RouteKitAI 0.1.0__py3-none-any.whl

routekitai/providers/anthropic.py

@@ -0,0 +1,227 @@
+"""Anthropic Claude model provider."""
+
+import os
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+
+from routekitai.core.errors import ModelError
+from routekitai.core.message import Message, MessageRole
+from routekitai.core.model import Model, ModelResponse, StreamEvent, ToolCall, Usage
+from routekitai.core.tool import Tool
+
+
+class AnthropicModel(Model):
+    """Anthropic Claude model provider.
+
+    Supports Claude models via Anthropic API with tool use.
+    """
+
+    def __init__(
+        self,
+        name: str = "claude-3-opus-20240229",
+        provider: str = "anthropic",
+        api_key: str | None = None,
+        base_url: str = "https://api.anthropic.com/v1",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize Anthropic model.
+
+        Args:
+            name: Model name (e.g., claude-3-opus-20240229, claude-3-sonnet-20240229)
+            provider: Provider name
+            api_key: Anthropic API key (defaults to ANTHROPIC_API_KEY env var)
+            base_url: API base URL
+            **kwargs: Additional configuration
+        """
+        super().__init__()
+        self._name = name
+        self._provider = provider
+        self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+        self.base_url = base_url.rstrip("/")
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def name(self) -> str:
+        """Return the model name."""
+        return self._name
+
+    @property
+    def provider(self) -> str:
+        """Return the provider name."""
+        return self._provider
+
+    def _get_client(self) -> "httpx.AsyncClient":
+        """Get or create HTTP client."""
+        try:
+            import httpx
+        except ImportError as e:
+            raise ModelError(
+                "httpx is required for Anthropic provider. Install with: pip install httpx"
+            ) from e
+
+        if self._client is None:
+            headers = {
+                "Content-Type": "application/json",
+                "x-api-key": self.api_key or "",
+                "anthropic-version": "2023-06-01",
+            }
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=60.0,
+            )
+        return self._client
+
+    def _message_to_anthropic(self, message: Message) -> dict[str, Any]:
+        """Convert routkitai Message to Anthropic format."""
+        role_map = {
+            MessageRole.SYSTEM: "system",
+            MessageRole.USER: "user",
+            MessageRole.ASSISTANT: "assistant",
+        }
+        # Anthropic doesn't support tool role messages directly
+        if message.role == MessageRole.TOOL:
+            # Convert tool messages to user messages with tool result
+            return {
+                "role": "user",
+                "content": f"Tool result: {message.content}",
+            }
+        return {
+            "role": role_map.get(message.role, "user"),
+            "content": message.content,
+        }
+
+    def _tools_to_anthropic(self, tools: list[Tool]) -> list[dict[str, Any]]:
+        """Convert routkitai Tools to Anthropic tool format."""
+        return [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.parameters,
+            }
+            for tool in tools
+        ]
+
+    def _anthropic_to_tool_calls(self, tool_use_blocks: list[dict[str, Any]]) -> list[ToolCall]:
+        """Convert Anthropic tool use blocks to routkitai format."""
+        result = []
+        for block in tool_use_blocks:
+            if block.get("type") == "tool_use":
+                result.append(
+                    ToolCall(
+                        id=block.get("id", ""),
+                        name=block.get("name", ""),
+                        arguments=block.get("input", {}),
+                    )
+                )
+        return result
+
+    async def chat(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> ModelResponse | AsyncIterator[StreamEvent]:
+        """Chat with Anthropic Claude model.
+
+        Args:
+            messages: Conversation messages
+            tools: Optional tools
+            stream: Whether to stream (not yet implemented)
+            **kwargs: Additional parameters (max_tokens, temperature, etc.)
+
+        Returns:
+            ModelResponse or stream of events
+
+        Raises:
+            ModelError: If API call fails
+        """
+        if stream:
+            raise NotImplementedError("Streaming not yet implemented for Anthropic")
+
+        if not self.api_key:
+            raise ModelError(
+                "Anthropic API key is required. Set ANTHROPIC_API_KEY env var or pass api_key parameter"
+            )
+
+        client = self._get_client()
+
+        # Separate system messages from conversation
+        system_messages = [msg.content for msg in messages if msg.role == MessageRole.SYSTEM]
+        conversation_messages = [
+            self._message_to_anthropic(msg) for msg in messages if msg.role != MessageRole.SYSTEM
+        ]
+
+        # Prepare request
+        request_data: dict[str, Any] = {
+            "model": self.name,
+            "messages": conversation_messages,
+            "max_tokens": kwargs.get("max_tokens", 1024),
+            **{k: v for k, v in kwargs.items() if k not in ("max_tokens", "stream")},
+        }
+
+        if system_messages:
+            request_data["system"] = (
+                system_messages[0] if len(system_messages) == 1 else "\n".join(system_messages)
+            )
+
+        if tools:
+            request_data["tools"] = self._tools_to_anthropic(tools)
+
+        try:
+            response = await client.post("/messages", json=request_data)
+            response.raise_for_status()
+            data = response.json()
+
+            # Parse response
+            content_blocks = data.get("content", [])
+            text_content = ""
+            tool_use_blocks = []
+
+            for block in content_blocks:
+                if block.get("type") == "text":
+                    text_content += block.get("text", "")
+                elif block.get("type") == "tool_use":
+                    tool_use_blocks.append(block)
+
+            # Convert tool calls
+            tool_calls = None
+            if tool_use_blocks:
+                tool_calls = self._anthropic_to_tool_calls(tool_use_blocks)
+
+            # Parse usage
+            usage_data = data.get("usage", {})
+            usage = Usage(
+                prompt_tokens=usage_data.get("input_tokens", 0),
+                completion_tokens=usage_data.get("output_tokens", 0),
+                total_tokens=usage_data.get("input_tokens", 0) + usage_data.get("output_tokens", 0),
+            )
+
+            return ModelResponse(
+                content=text_content,
+                tool_calls=tool_calls,
+                usage=usage,
+                metadata={"raw_response": data},
+            )
+
+        except httpx.HTTPStatusError as e:
+            raise ModelError(
+                f"Anthropic API error: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise ModelError(f"Failed to call Anthropic API: {e}") from e
+
+    async def __aenter__(self) -> "AnthropicModel":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any
+    ) -> None:
+        """Async context manager exit."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None

routekitai/providers/azure_openai.py

@@ -0,0 +1,243 @@
+"""Azure OpenAI model provider."""
+
+import json
+import os
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+
+from routekitai.core.errors import ModelError
+from routekitai.core.message import Message, MessageRole
+from routekitai.core.model import Model, ModelResponse, StreamEvent, ToolCall, Usage
+from routekitai.core.tool import Tool
+
+
+class AzureOpenAIModel(Model):
+    """Azure OpenAI model provider.
+
+    Supports Azure OpenAI deployments with custom endpoints and API versions.
+    """
+
+    def __init__(
+        self,
+        name: str = "gpt-4",
+        provider: str = "azure-openai",
+        api_key: str | None = None,
+        endpoint: str | None = None,
+        deployment_name: str | None = None,
+        api_version: str = "2024-02-15-preview",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize Azure OpenAI model.
+
+        Args:
+            name: Model name
+            provider: Provider name
+            api_key: Azure OpenAI API key (defaults to AZURE_OPENAI_API_KEY env var)
+            endpoint: Azure OpenAI endpoint URL (defaults to AZURE_OPENAI_ENDPOINT env var)
+            deployment_name: Deployment name (defaults to model name)
+            api_version: API version
+            **kwargs: Additional configuration
+        """
+        super().__init__()
+        self._name = name
+        self._provider = provider
+        self.api_key = api_key or os.getenv("AZURE_OPENAI_API_KEY")
+        self.endpoint = (endpoint or os.getenv("AZURE_OPENAI_ENDPOINT") or "").rstrip("/")
+        self.deployment_name = deployment_name or name
+        self.api_version = api_version
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def name(self) -> str:
+        """Return the model name."""
+        return self._name
+
+    @property
+    def provider(self) -> str:
+        """Return the provider name."""
+        return self._provider
+
+    def _get_client(self) -> "httpx.AsyncClient":
+        """Get or create HTTP client."""
+        try:
+            import httpx
+        except ImportError as e:
+            raise ModelError(
+                "httpx is required for Azure OpenAI provider. Install with: pip install httpx"
+            ) from e
+
+        if not self.endpoint:
+            raise ModelError(
+                "Azure OpenAI endpoint is required. Set AZURE_OPENAI_ENDPOINT env var or pass endpoint parameter"
+            )
+        if self._client is None:
+            headers = {
+                "Content-Type": "application/json",
+                "api-key": self.api_key or "",
+            }
+            self._client = httpx.AsyncClient(
+                base_url=self.endpoint,
+                headers=headers,
+                timeout=60.0,
+            )
+        return self._client
+
+    def _message_to_openai(self, message: Message) -> dict[str, Any]:
+        """Convert routkitai Message to OpenAI format."""
+        role_map = {
+            MessageRole.SYSTEM: "system",
+            MessageRole.USER: "user",
+            MessageRole.ASSISTANT: "assistant",
+            MessageRole.TOOL: "tool",
+        }
+        msg_dict: dict[str, Any] = {
+            "role": role_map.get(message.role, "user"),
+            "content": message.content,
+        }
+        if message.tool_calls:
+            msg_dict["tool_calls"] = [
+                {
+                    "id": tc.get("id", ""),
+                    "type": "function",
+                    "function": {
+                        "name": tc.get("name", ""),
+                        "arguments": json.dumps(tc.get("arguments", {})),
+                    },
+                }
+                for tc in message.tool_calls
+            ]
+        if message.tool_result:
+            msg_dict["tool_call_id"] = message.tool_result.get("tool_call_id", "")
+        return msg_dict
+
+    def _tools_to_openai(self, tools: list[Tool]) -> list[dict[str, Any]]:
+        """Convert routkitai Tools to OpenAI function format."""
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.parameters,
+                },
+            }
+            for tool in tools
+        ]
+
+    def _openai_to_tool_calls(self, tool_calls: list[dict[str, Any]]) -> list[ToolCall]:
+        """Convert OpenAI tool calls to routkitai format."""
+        result = []
+        for tc in tool_calls:
+            if tc.get("type") == "function":
+                func = tc.get("function", {})
+                try:
+                    arguments = json.loads(func.get("arguments", "{}"))
+                except (json.JSONDecodeError, TypeError):
+                    arguments = func.get("arguments", {})
+                result.append(
+                    ToolCall(
+                        id=tc.get("id", ""),
+                        name=func.get("name", ""),
+                        arguments=arguments,
+                    )
+                )
+        return result
+
+    async def chat(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> ModelResponse | AsyncIterator[StreamEvent]:
+        """Chat with Azure OpenAI model.
+
+        Args:
+            messages: Conversation messages
+            tools: Optional tools
+            stream: Whether to stream (not yet implemented)
+            **kwargs: Additional parameters (temperature, max_tokens, etc.)
+
+        Returns:
+            ModelResponse or stream of events
+
+        Raises:
+            ModelError: If API call fails
+        """
+        if stream:
+            raise NotImplementedError("Streaming not yet implemented for Azure OpenAI")
+
+        if not self.api_key:
+            raise ModelError(
+                "Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY env var or pass api_key parameter"
+            )
+
+        client = self._get_client()
+
+        # Convert messages
+        openai_messages = [self._message_to_openai(msg) for msg in messages]
+
+        # Prepare request URL with deployment and API version
+        url = f"/openai/deployments/{self.deployment_name}/chat/completions?api-version={self.api_version}"
+
+        # Prepare request data
+        request_data: dict[str, Any] = {
+            "messages": openai_messages,
+            **kwargs,  # Allow temperature, max_tokens, etc.
+        }
+
+        # Add tools if provided
+        if tools:
+            request_data["tools"] = self._tools_to_openai(tools)
+
+        try:
+            response = await client.post(url, json=request_data)
+            response.raise_for_status()
+            data = response.json()
+
+            # Parse response
+            choice = data.get("choices", [{}])[0]
+            message = choice.get("message", {})
+            content = message.get("content", "")
+            tool_calls_data = message.get("tool_calls", [])
+
+            # Convert tool calls
+            tool_calls = None
+            if tool_calls_data:
+                tool_calls = self._openai_to_tool_calls(tool_calls_data)
+
+            # Parse usage
+            usage_data = data.get("usage", {})
+            usage = Usage(
+                prompt_tokens=usage_data.get("prompt_tokens", 0),
+                completion_tokens=usage_data.get("completion_tokens", 0),
+                total_tokens=usage_data.get("total_tokens", 0),
+            )
+
+            return ModelResponse(
+                content=content,
+                tool_calls=tool_calls,
+                usage=usage,
+                metadata={"raw_response": data},
+            )
+
+        except httpx.HTTPStatusError as e:
+            raise ModelError(
+                f"Azure OpenAI API error: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise ModelError(f"Failed to call Azure OpenAI API: {e}") from e
+
+    async def __aenter__(self) -> "AzureOpenAIModel":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any
+    ) -> None:
+        """Async context manager exit."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None

routekitai/providers/local.py

@@ -0,0 +1,196 @@
+"""Local/Fake model provider for testing."""
+
+from collections import deque
+from collections.abc import AsyncIterator, Callable
+from typing import Any
+
+from pydantic import Field
+
+from routekitai.core.errors import ModelError
+from routekitai.core.message import Message
+from routekitai.core.model import Model, ModelResponse, StreamEvent, ToolCall, Usage
+from routekitai.core.tool import Tool
+
+
+class FakeModel(Model):
+    """Deterministic fake model for testing.
+
+    Uses scripted responses based on message content or a response function.
+    Can also use a queue of responses for sequential calls.
+    """
+
+    name: str = Field(default="fake", description="Model name")
+    provider: str = Field(default="local", description="Provider name")
+    responses: dict[str, str | dict[str, Any]] | None = Field(
+        default=None, description="Dict mapping message content to response"
+    )
+    response_fn: Callable[[list[Message], list[Tool] | None], str | dict[str, Any]] | None = Field(
+        default=None, description="Function(message, tools) -> response"
+    )
+    response_queue: deque[str | dict[str, Any] | Callable] = Field(
+        default_factory=deque, description="Queue of responses for sequential calls"
+    )
+    call_count: int = Field(default=0, exclude=True)
+
+    def __init__(
+        self,
+        name: str = "fake",
+        provider: str = "local",
+        responses: dict[str, str | dict[str, Any]] | None = None,
+        response_fn: Callable[[list[Message], list[Tool] | None], str | dict[str, Any]]
+        | None = None,
+        response_queue: deque[str | dict[str, Any] | Callable] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize fake model.
+
+        Args:
+            name: Model name
+            provider: Provider name
+            responses: Dict mapping message content to response
+            response_fn: Function(message, tools) -> response dict
+            response_queue: Queue of responses for sequential calls
+            **kwargs: Additional configuration
+        """
+        super().__init__()
+        object.__setattr__(self, "name", name)
+        object.__setattr__(self, "provider", provider)
+        object.__setattr__(self, "responses", responses or {})
+        object.__setattr__(self, "response_fn", response_fn)
+        object.__setattr__(self, "response_queue", response_queue or deque())
+        object.__setattr__(self, "call_count", 0)
+
+    def add_response(
+        self,
+        response: str
+        | dict[str, Any]
+        | Callable[[list[Message], list[Tool] | None], str | dict[str, Any]],
+    ) -> None:
+        """Add a response to the queue.
+
+        Args:
+            response: Response string, dict, or callable
+        """
+        self.response_queue.append(response)
+
+    async def chat(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> ModelResponse | AsyncIterator[StreamEvent]:
+        """Chat with fake model.
+
+        Args:
+            messages: Conversation messages
+            tools: Optional tools
+            stream: Whether to stream (not supported)
+            **kwargs: Additional parameters
+
+        Returns:
+            ModelResponse
+
+        Raises:
+            ModelError: If model call fails
+        """
+        if stream:
+            raise NotImplementedError("Streaming not supported for FakeModel")
+
+        object.__setattr__(self, "call_count", self.call_count + 1)
+
+        # Get last user message
+        last_message = None
+        for msg in reversed(messages):
+            if msg.role.value == "user":
+                last_message = msg
+                break
+
+        # Use response queue if available (for sequential calls)
+        if self.response_queue:
+            response_data = self.response_queue.popleft()
+            if callable(response_data):
+                result = response_data(messages, tools)
+            else:
+                result = response_data
+
+            if isinstance(result, dict):
+                tool_calls = None
+                if "tool_calls" in result:
+                    tool_calls = [
+                        ToolCall(
+                            id=tc.get("id", f"call_{i}"),
+                            name=tc.get("name", ""),
+                            arguments=tc.get("arguments", {}),
+                        )
+                        for i, tc in enumerate(result.get("tool_calls", []))
+                    ]
+                return ModelResponse(
+                    content=result.get("content", ""),
+                    tool_calls=tool_calls,
+                    usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30),
+                )
+            elif isinstance(result, str):
+                return ModelResponse(
+                    content=result,
+                    usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30),
+                )
+
+        # Use response function if provided
+        if self.response_fn:
+            try:
+                result = self.response_fn(messages, tools)
+                if isinstance(result, dict):
+                    return ModelResponse(
+                        content=result.get("content", ""),
+                        tool_calls=result.get("tool_calls"),
+                        usage=result.get(
+                            "usage", Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30)
+                        ),
+                    )
+                elif isinstance(result, str):
+                    return ModelResponse(
+                        content=result,
+                        usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30),
+                    )
+            except Exception as e:
+                raise ModelError(f"Response function failed: {e}") from e
+
+        # Use responses dict
+        if last_message and self.responses:
+            content = last_message.content.lower()
+            for key, response in self.responses.items():
+                if key.lower() in content:
+                    # Check if response includes tool calls
+                    if isinstance(response, dict):
+                        tool_calls = None
+                        if "tool_calls" in response:
+                            tool_calls = [
+                                ToolCall(
+                                    id=tc.get("id", f"call_{i}"),
+                                    name=tc.get("name", ""),
+                                    arguments=tc.get("arguments", {}),
+                                )
+                                for i, tc in enumerate(response.get("tool_calls", []))
+                            ]
+                        return ModelResponse(
+                            content=response.get("content", ""),
+                            tool_calls=tool_calls,
+                            usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30),
+                        )
+                    return ModelResponse(
+                        content=response,
+                        usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30),
+                    )
+
+        # Default response
+        default = "I understand. How can I help you?"
+        if tools and last_message:
+            # If tools available and user asks something, suggest using a tool
+            tool_names = [t.name for t in tools]
+            default = f"I can help with that. Available tools: {', '.join(tool_names)}."
+
+        return ModelResponse(
+            content=default,
+            usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30),
+        )