merge

Author: NicolasGirardot

.github/workflows/release.yml

@@ -6,10 +6,25 @@ on:
       - "v*"
 
 jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+      - run: uv python install 3.12
+      - run: uv sync --all-extras
+      - run: uv run ruff format --check .
+      - run: uv run ruff check .
+      - run: uv run pytest
+
   release:
+    needs: test
     runs-on: ubuntu-latest
     permissions:
-      id-token: write  # Required for trusted publishing
+      id-token: write
 
     steps:
       - uses: actions/checkout@v4
@@ -27,4 +42,3 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
-

README.md

@@ -1,283 +1,84 @@
-# Edgee Gateway SDK
+# Edgee Python SDK
 
-Lightweight Python SDK for Edgee AI Gateway with built-in tool execution support.
+Lightweight, type-safe Python SDK for the [Edgee AI Gateway](https://www.edgee.cloud).
+
+[![PyPI version](https://img.shields.io/pypi/v/edgee.svg)]( )
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 
 ## Installation
 
 ```bash
 pip install edgee
 ```
 
-## Usage
+## Quick Start
 
 ```python
 import os
 from edgee import Edgee
 
-edgee = Edgee(os.environ.get("EDGEE_API_KEY"))
-```
-
-### Simple Input
+edgee = Edgee("your-api-key")
 
-```python
+# Send a simple request
 response = edgee.send(
     model="gpt-4o",
-    input="What is the capital of France?",
+    input="What is the capital of France?"
 )
 
 print(response.text)
+# "The capital of France is Paris."
 ```
 
-### Full Input with Messages
-
-```python
-response = edgee.send(
-    model="gpt-4o",
-    input={
-        "messages": [
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "Hello!"},
-        ],
-    },
-)
-```
+## Send Method
 
-## Tools
-
-The SDK supports two modes for working with tools:
-
-### Simple Mode: Automatic Tool Execution
-
-Use the `Tool` class with Pydantic models for automatic tool execution. The SDK will handle the entire agentic loop for you:
+The `send()` method makes non-streaming chat completion requests:
 
 ```python
-from pydantic import BaseModel
-from edgee import Edgee, Tool
-
-edgee = Edgee(os.environ.get("EDGEE_API_KEY"))
-
-# Define tool parameters with Pydantic
-class WeatherParams(BaseModel):
-    location: str
-
-# Define the tool handler
-def get_weather(params: WeatherParams) -> dict:
-    # Your implementation here
-    return {"temperature": 22, "condition": "sunny", "location": params.location}
-
-# Create the tool
-weather_tool = Tool(
-    name="get_weather",
-    description="Get the current weather for a location",
-    schema=WeatherParams,
-    handler=get_weather,
-)
-
-# The SDK automatically:
-# 1. Sends the request with tools
-# 2. Executes tools when the model requests them
-# 3. Sends results back to the model
-# 4. Returns the final response
 response = edgee.send(
     model="gpt-4o",
-    input="What's the weather in Paris?",
-    tools=[weather_tool],
+    input="Hello, world!"
 )
 
-print(response.text)
-# "The weather in Paris is sunny with a temperature of 22°C."
+# Access response
+print(response.text)           # Text content
+print(response.finish_reason)  # Finish reason
+print(response.tool_calls)     # Tool calls (if any)
 ```
 
-#### Multiple Tools
-
-```python
-from typing import Literal
-from pydantic import BaseModel
-
-class CalculatorParams(BaseModel):
-    operation: Literal["add", "subtract", "multiply", "divide"]
-    a: float
-    b: float
-
-def calculate(params: CalculatorParams) -> dict:
-    ops = {
-        "add": params.a + params.b,
-        "subtract": params.a - params.b,
-        "multiply": params.a * params.b,
-        "divide": params.a / params.b if params.b != 0 else "Error: division by zero",
-    }
-    return {"result": ops[params.operation]}
+## Stream Method
 
-calculator_tool = Tool(
-    name="calculate",
-    description="Perform arithmetic operations",
-    schema=CalculatorParams,
-    handler=calculate,
-)
-
-response = edgee.send(
-    model="gpt-4o",
-    input="What's 25 * 4, and what's the weather in London?",
-    tools=[weather_tool, calculator_tool],
-)
-```
-
-#### Configuration Options
+The `stream()` method enables real-time streaming responses:
 
 ```python
-response = edgee.send(
-    model="gpt-4o",
-    input="Complex query requiring multiple tool calls",
-    tools=[tool1, tool2],
-    max_tool_iterations=15,  # Default: 10
-)
-```
-
-### Advanced Mode: Manual Tool Handling
-
-For full control over tool execution, use the advanced mode with raw tool definitions:
-
-```python
-response = edgee.send(
-    model="gpt-4o",
-    input={
-        "messages": [{"role": "user", "content": "What's the weather in Paris?"}],
-        "tools": [
-            {
-                "type": "function",
-                "function": {
-                    "name": "get_weather",
-                    "description": "Get weather for a location",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "location": {"type": "string"},
-                        },
-                    },
-                },
-            },
-        ],
-        "tool_choice": "auto",
-    },
-)
-
-# Handle tool calls manually
-if response.tool_calls:
-    print(response.tool_calls)
-    # Execute tools and send results back...
-```
-
-## Streaming
-
-```python
-for chunk in edgee.stream(model="gpt-4o", input="Tell me a story"):
+for chunk in edgee.stream("gpt-4o", "Tell me a story"):
     if chunk.text:
         print(chunk.text, end="", flush=True)
-```
 
-#### Alternative: Using send(stream=True)
-
-```python
-for chunk in edgee.send(model="gpt-4o", input="Tell me a story", stream=True):
-    if chunk.text:
-        print(chunk.text, end="", flush=True)
+    if chunk.finish_reason:
+        print(f"\nFinished: {chunk.finish_reason}")
 ```
 
-## Response
+## Features
 
-```python
-@dataclass
-class SendResponse:
-    choices: list[Choice]
-    usage: Usage | None
+- ✅ **Type-safe** - Full type hints with dataclasses
+- ✅ **OpenAI-compatible** - Works with any model supported by Edgee
+- ✅ **Streaming** - Real-time response streaming with generators
+- ✅ **Tool calling** - Full support for function calling
+- ✅ **Flexible input** - Accept strings, dicts, or InputObject
+- ✅ **Zero dependencies** - Uses only Python standard library
 
-    # Convenience properties
-    text: str | None         # choices[0].message["content"]
-    message: dict | None     # choices[0].message
-    finish_reason: str | None  # choices[0].finish_reason
-    tool_calls: list | None  # choices[0].message["tool_calls"]
+## Documentation
 
-@dataclass
-class Choice:
-    index: int
-    message: dict  # {"role": str, "content": str | None, "tool_calls": list | None}
-    finish_reason: str | None
+For complete documentation, examples, and API reference, visit:
 
-@dataclass
-class InputTokenDetails:
-    cached_tokens: int
+**👉 [Official Python SDK Documentation](https://www.edgee.cloud/docs/sdk/python)**
 
-@dataclass
-class OutputTokenDetails:
-    reasoning_tokens: int
+The documentation includes:
+- [Configuration guide](https://www.edgee.cloud/docs/sdk/python/configuration) - Multiple ways to configure the SDK
+- [Send method](https://www.edgee.cloud/docs/sdk/python/send) - Complete guide to non-streaming requests
+- [Stream method](https://www.edgee.cloud/docs/sdk/python/stream) - Streaming responses guide
+- [Tools](https://www.edgee.cloud/docs/sdk/python/tools) - Function calling guide
 
-@dataclass
-class Usage:
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
-    input_tokens_details: InputTokenDetails
-    output_tokens_details: OutputTokenDetails
-```
-
-### Streaming Response
-
-```python
-@dataclass
-class StreamChunk:
-    choices: list[StreamChoice]
+## License
 
-    # Convenience properties
-    text: str | None         # choices[0].delta.content
-    role: str | None         # choices[0].delta.role
-    finish_reason: str | None  # choices[0].finish_reason
-
-@dataclass
-class StreamChoice:
-    index: int
-    delta: StreamDelta
-    finish_reason: str | None
-
-@dataclass
-class StreamDelta:
-    role: str | None
-    content: str | None
-    tool_calls: list[dict] | None
-```
-
-## API Reference
-
-### `Tool` Class
-
-```python
-from pydantic import BaseModel
-from edgee import Tool
-
-class MyParams(BaseModel):
-    param1: str
-    param2: int
-
-tool = Tool(
-    name="my_tool",           # Unique tool name
-    description="...",        # Tool description for the model
-    schema=MyParams,          # Pydantic model for parameters
-    handler=my_function,      # Function to execute
-)
-
-# Methods
-tool.to_dict()               # Convert to OpenAI tool format
-tool.execute(args)           # Validate and execute handler
-```
-
-### `create_tool` Helper
-
-```python
-from edgee import create_tool
-
-tool = create_tool(
-    name="my_tool",
-    schema=MyParams,
-    handler=my_function,
-    description="...",
-)
-```
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "edgee"
-version = "0.1.1"
+version = "1.0.0"
 description = "Lightweight Python SDK for Edgee AI Gateway"
 readme = "README.md"
 license = "Apache-2.0"