toolproxy 0.2.0__tar.gz → 0.3.0__tar.gz

{toolproxy-0.2.0 → toolproxy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toolproxy
-Version: 0.2.0
+Version: 0.3.0
 Summary: Universal tool-calling wrapper for non-tool-native LLMs — emulates function calling via structured JSON planning
 Project-URL: Homepage, https://github.com/yourusername/toolproxy
 Project-URL: Repository, https://github.com/yourusername/toolproxy
@@ -24,12 +24,24 @@ Requires-Python: >=3.10
 Requires-Dist: httpx>=0.25
 Requires-Dist: openai>=1.0
 Requires-Dist: pydantic>=2.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.25; extra == 'anthropic'
+Provides-Extra: cohere
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
 Requires-Dist: pytest-mock>=3.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: full
+Requires-Dist: anthropic>=0.25; extra == 'full'
+Requires-Dist: opentelemetry-api>=1.20; extra == 'full'
+Requires-Dist: opentelemetry-sdk>=1.20; extra == 'full'
+Provides-Extra: gemini
+Provides-Extra: groq
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.20; extra == 'otel'
+Requires-Dist: opentelemetry-sdk>=1.20; extra == 'otel'
 Description-Content-Type: text/markdown
 
 # toolproxy

{toolproxy-0.2.0 → toolproxy-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "toolproxy"
-version = "0.2.0"
+version = "0.3.0"
 description = "Universal tool-calling wrapper for non-tool-native LLMs — emulates function calling via structured JSON planning"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,6 +46,27 @@ dev = [
     "build>=1.0",
     "twine>=5.0",
 ]
+anthropic = [
+    "anthropic>=0.25",
+]
+gemini = [
+    # No extra package needed — uses Google's OpenAI-compat endpoint
+]
+groq = [
+    # No extra package needed — uses Groq's OpenAI-compat endpoint
+]
+cohere = [
+    # No extra package needed — uses Cohere's OpenAI-compat endpoint
+]
+otel = [
+    "opentelemetry-sdk>=1.20",
+    "opentelemetry-api>=1.20",
+]
+full = [
+    "anthropic>=0.25",
+    "opentelemetry-sdk>=1.20",
+    "opentelemetry-api>=1.20",
+]
 
 [project.urls]
 Homepage = "https://github.com/yourusername/toolproxy"

{toolproxy-0.2.0 → toolproxy-0.3.0}/src/toolproxy/__init__.py

@@ -13,6 +13,18 @@ Public API:
     Action          — emulated-mode structured output
     StreamChunk     — (v0.2) streaming event from agent.stream()
 
+Memory (v0.3):
+    BaseMemory, ConversationBuffer, SlidingWindowMemory, TokenWindowMemory
+
+Observability (v0.3):
+    BaseTracer, FileTracer, PrintTracer, OpenTelemetryTracer
+
+Adapters (v0.3):
+    AnthropicClient, GeminiClient, AzureOpenAIClient, GroqClient, CohereClient
+
+MCP (v0.3):
+    MCPToolset, MCPClient, MCPToolInfo
+
 Utilities:
     probe_tool_support — (v0.2) async helper to detect native tool support
 
@@ -57,6 +69,24 @@ from .schemas import (
 )
 from .tools import ToolDefinition, ToolRegistry, tool
 
+# v0.3 — Memory
+from .memory import BaseMemory, ConversationBuffer, SlidingWindowMemory, TokenWindowMemory
+
+# v0.3 — Observability
+from .observability import BaseTracer, FileTracer, PrintTracer, OpenTelemetryTracer
+
+# v0.3 — Adapters (lazy imports — no hard deps until used)
+from .adapters import (
+    AnthropicClient,
+    GeminiClient,
+    AzureOpenAIClient,
+    GroqClient,
+    CohereClient,
+)
+
+# v0.3 — MCP
+from .mcp import MCPClient, MCPToolInfo, MCPToolset
+
 __all__ = [
     # Main API
     "UniversalAgent",
@@ -76,7 +106,7 @@ __all__ = [
     "ToolCall",
     "ToolResult",
     "TraceEntry",
-    # Clients
+    # Core clients
     "LLMClient",
     "ModelResponse",
     "OpenRouterClient",
@@ -84,6 +114,26 @@ __all__ = [
     "OllamaClient",
     "MockClient",
     "get_client",
+    # v0.3 Adapters
+    "AnthropicClient",
+    "GeminiClient",
+    "AzureOpenAIClient",
+    "GroqClient",
+    "CohereClient",
+    # v0.3 Memory
+    "BaseMemory",
+    "ConversationBuffer",
+    "SlidingWindowMemory",
+    "TokenWindowMemory",
+    # v0.3 Observability
+    "BaseTracer",
+    "FileTracer",
+    "PrintTracer",
+    "OpenTelemetryTracer",
+    # v0.3 MCP
+    "MCPClient",
+    "MCPToolInfo",
+    "MCPToolset",
     # Exceptions
     "UniversalAgentError",
     "ToolNotFoundError",
@@ -94,4 +144,4 @@ __all__ = [
     "ExecutionPolicyError",
 ]
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

toolproxy-0.3.0/src/toolproxy/adapters/__init__.py

@@ -0,0 +1,27 @@
+"""
+toolproxy.adapters — provider-specific LLM client implementations.
+
+New providers added in v0.3:
+    AnthropicClient    — Claude models via the Anthropic API.
+    GeminiClient       — Gemini models via Google's OpenAI-compat endpoint.
+    AzureOpenAIClient  — GPT models via Azure OpenAI Service.
+    GroqClient         — Fast inference via Groq's OpenAI-compat API.
+    CohereClient       — Command R+ via Cohere's OpenAI-compat v2 API.
+
+Each adapter uses optional imports: the underlying SDK or httpx is imported
+only when the client is instantiated, giving a clear error message if the
+required package is not installed.
+"""
+from .anthropic import AnthropicClient
+from .gemini import GeminiClient
+from .azure import AzureOpenAIClient
+from .groq import GroqClient
+from .cohere import CohereClient
+
+__all__ = [
+    "AnthropicClient",
+    "GeminiClient",
+    "AzureOpenAIClient",
+    "GroqClient",
+    "CohereClient",
+]

toolproxy-0.3.0/src/toolproxy/adapters/anthropic.py

@@ -0,0 +1,242 @@
+"""
+AnthropicClient — Claude models via the Anthropic Python SDK.
+
+Requires the ``anthropic`` package::
+
+    pip install "toolproxy[anthropic]"
+    # or
+    pip install anthropic
+
+Usage::
+
+    from toolproxy import UniversalAgent
+
+    agent = UniversalAgent(
+        model="anthropic/claude-3-5-sonnet-20241022",
+        api_key="sk-ant-...",
+        tools=[...],
+    )
+
+Supported model prefixes:
+    ``anthropic/claude-3-5-sonnet-20241022``
+    ``anthropic/claude-3-5-haiku-20241022``
+    ``anthropic/claude-3-opus-20240229``
+    ``anthropic/claude-3-haiku-20240307``
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from ..llm_client import LLMClient, ModelResponse
+from ..schemas import Message, StreamChunk, ToolCall
+from ..exceptions import ModelError
+from ..config import model_supports_native_tools
+
+# Anthropic models all support native tool calling
+_ANTHROPIC_NATIVE_TOOLS = True
+_DEFAULT_MAX_TOKENS = 4096
+
+
+def _convert_messages_to_anthropic(
+    messages: List[Message],
+) -> tuple[Optional[str], List[Dict[str, Any]]]:
+    """
+    Convert toolproxy Messages to Anthropic API format.
+
+    Returns (system_prompt, messages_list).
+    Anthropic separates system prompts from the messages list.
+    """
+    system_prompt: Optional[str] = None
+    anthropic_messages: List[Dict[str, Any]] = []
+
+    for msg in messages:
+        if msg.role == "system":
+            # Anthropic takes system as a top-level param, not in messages
+            system_prompt = msg.content
+            continue
+
+        if msg.role == "tool":
+            # Tool results go as user messages with tool_result content blocks
+            anthropic_messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": msg.tool_call_id or "unknown",
+                            "content": msg.content,
+                        }
+                    ],
+                }
+            )
+        elif msg.role == "assistant":
+            anthropic_messages.append({"role": "assistant", "content": msg.content})
+        else:
+            anthropic_messages.append({"role": "user", "content": msg.content})
+
+    return system_prompt, anthropic_messages
+
+
+def _convert_tools_to_anthropic(
+    tools: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    """Convert OpenAI-style tool schemas to Anthropic format."""
+    anthropic_tools = []
+    for t in tools:
+        fn = t.get("function", t)
+        anthropic_tools.append(
+            {
+                "name": fn["name"],
+                "description": fn.get("description", ""),
+                "input_schema": fn.get("parameters", {"type": "object", "properties": {}}),
+            }
+        )
+    return anthropic_tools
+
+
+def _parse_anthropic_response(response: Any) -> ModelResponse:
+    """Parse an Anthropic Message object into a provider-agnostic ModelResponse."""
+    raw_text = ""
+    tool_calls: List[ToolCall] = []
+
+    for block in response.content:
+        if block.type == "text":
+            raw_text += block.text
+        elif block.type == "tool_use":
+            tool_calls.append(
+                ToolCall(
+                    tool_name=block.name,
+                    arguments=block.input if isinstance(block.input, dict) else {},
+                    call_id=block.id,
+                )
+            )
+
+    return ModelResponse(raw_text=raw_text, tool_calls=tool_calls)
+
+
+class AnthropicClient(LLMClient):
+    """
+    LLM client for Anthropic's Claude models.
+
+    Wraps the official ``anthropic`` Python SDK. All Claude models support
+    native tool calling, so this client always returns ``supports_native_tools()
+    == True``.
+
+    Parameters
+    ----------
+    model:
+        Model name (e.g. ``"claude-3-5-sonnet-20241022"``).
+    api_key:
+        Anthropic API key. Falls back to ``ANTHROPIC_API_KEY`` env var.
+    max_tokens:
+        Maximum tokens in the response (default 4096).
+    timeout:
+        Request timeout in seconds (default 60).
+    """
+
+    def __init__(
+        self,
+        model: str,
+        api_key: Optional[str] = None,
+        max_tokens: int = _DEFAULT_MAX_TOKENS,
+        timeout: float = 60.0,
+    ) -> None:
+        try:
+            import anthropic as _anthropic  # noqa: F401
+        except ImportError:
+            raise ImportError(
+                "The 'anthropic' package is required for AnthropicClient.\n"
+                "Install it with: pip install 'toolproxy[anthropic]'\n"
+                "or: pip install anthropic"
+            )
+
+        import anthropic
+
+        self.model = model
+        self._max_tokens = max_tokens
+        self._timeout = timeout
+
+        resolved_key = api_key or os.environ.get("ANTHROPIC_API_KEY", "")
+        self._client = anthropic.Anthropic(api_key=resolved_key)
+        self._async_client = anthropic.AsyncAnthropic(api_key=resolved_key)
+
+    def supports_native_tools(self) -> bool:
+        return True
+
+    def generate(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ModelResponse:
+        system_prompt, anthropic_messages = _convert_messages_to_anthropic(messages)
+
+        kwargs: Dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": self._max_tokens,
+            "messages": anthropic_messages,
+        }
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        if tools:
+            kwargs["tools"] = _convert_tools_to_anthropic(tools)
+
+        try:
+            response = self._client.messages.create(**kwargs)
+        except Exception as exc:
+            raise ModelError(f"Anthropic API error: {exc}") from exc
+
+        return _parse_anthropic_response(response)
+
+    async def agenerate(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ModelResponse:
+        system_prompt, anthropic_messages = _convert_messages_to_anthropic(messages)
+
+        kwargs: Dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": self._max_tokens,
+            "messages": anthropic_messages,
+        }
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        if tools:
+            kwargs["tools"] = _convert_tools_to_anthropic(tools)
+
+        try:
+            response = await self._async_client.messages.create(**kwargs)
+        except Exception as exc:
+            raise ModelError(f"Anthropic API error: {exc}") from exc
+
+        return _parse_anthropic_response(response)
+
+    async def astream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncIterator[StreamChunk]:
+        system_prompt, anthropic_messages = _convert_messages_to_anthropic(messages)
+
+        kwargs: Dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": self._max_tokens,
+            "messages": anthropic_messages,
+        }
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        if tools:
+            kwargs["tools"] = _convert_tools_to_anthropic(tools)
+
+        accumulated = ""
+        try:
+            async with self._async_client.messages.stream(**kwargs) as stream:
+                async for text in stream.text_stream:
+                    accumulated += text
+                    yield StreamChunk(delta=text)
+        except Exception as exc:
+            raise ModelError(f"Anthropic streaming error: {exc}") from exc
+
+        yield StreamChunk(done=True, content=accumulated)

toolproxy-0.3.0/src/toolproxy/adapters/azure.py

@@ -0,0 +1,213 @@
+"""
+AzureOpenAIClient — GPT models via Azure OpenAI Service.
+
+Wraps the Azure variant of the OpenAI-compatible API. The key differences
+from the standard OpenAI client are:
+
+- Endpoint is per-deployment (not per-model).
+- Authentication uses an ``api-key`` header (or AAD Bearer token).
+- Requires an ``api-version`` query parameter.
+
+No extra packages required beyond ``httpx``.
+
+Usage::
+
+    from toolproxy import UniversalAgent
+
+    agent = UniversalAgent(
+        model="azure/gpt-4o",
+        base_url="https://<your-resource>.openai.azure.com/openai/deployments/<deployment>",
+        api_key="<azure-api-key>",
+        tools=[...],
+    )
+
+    # Or via environment variables:
+    # AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_DEPLOYMENT
+
+Environment variables:
+    AZURE_OPENAI_API_KEY      — API key
+    AZURE_OPENAI_ENDPOINT     — e.g. https://<resource>.openai.azure.com
+    AZURE_OPENAI_DEPLOYMENT   — deployment name (model alias in Azure)
+    AZURE_OPENAI_API_VERSION  — API version (default: 2024-10-21)
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+import httpx
+
+from ..llm_client import (
+    LLMClient,
+    ModelResponse,
+    _messages_to_openai,
+    _parse_native_tool_calls,
+    _parse_openai_response,
+)
+from ..schemas import Message, StreamChunk, ToolCall
+from ..exceptions import ModelError
+from ..config import model_supports_native_tools
+
+_DEFAULT_API_VERSION = "2024-10-21"
+
+
+class AzureOpenAIClient(LLMClient):
+    """
+    LLM client for Azure OpenAI Service.
+
+    Parameters
+    ----------
+    model:
+        Model / deployment name (e.g. ``"gpt-4o"``).
+    api_key:
+        Azure OpenAI API key. Falls back to ``AZURE_OPENAI_API_KEY``.
+    endpoint:
+        Azure resource endpoint (e.g. ``https://<resource>.openai.azure.com``).
+        Falls back to ``AZURE_OPENAI_ENDPOINT``.
+    deployment:
+        Deployment name. Defaults to *model* if not specified.
+        Falls back to ``AZURE_OPENAI_DEPLOYMENT``.
+    api_version:
+        Azure API version string. Defaults to ``"2024-10-21"``.
+    native_tools:
+        Override native tool-calling detection.
+    timeout:
+        Request timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        api_key: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        deployment: Optional[str] = None,
+        api_version: str = _DEFAULT_API_VERSION,
+        native_tools: Optional[bool] = None,
+        timeout: float = 60.0,
+    ) -> None:
+        self.model = model
+        self._api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY", "")
+        self._endpoint = (
+            endpoint
+            or os.environ.get("AZURE_OPENAI_ENDPOINT", "")
+        ).rstrip("/")
+        self._deployment = (
+            deployment
+            or os.environ.get("AZURE_OPENAI_DEPLOYMENT")
+            or model
+        )
+        self._api_version = api_version
+        self._native_tools = (
+            native_tools if native_tools is not None else model_supports_native_tools(model)
+        )
+        self._timeout = timeout
+
+    def _chat_url(self) -> str:
+        return (
+            f"{self._endpoint}/openai/deployments/{self._deployment}"
+            f"/chat/completions?api-version={self._api_version}"
+        )
+
+    def _headers(self) -> Dict[str, str]:
+        return {
+            "api-key": self._api_key,
+            "Content-Type": "application/json",
+        }
+
+    def _body(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"messages": _messages_to_openai(messages)}
+        if tools and self._native_tools:
+            body["tools"] = tools
+            body["tool_choice"] = "auto"
+        if stream:
+            body["stream"] = True
+        return body
+
+    def supports_native_tools(self) -> bool:
+        return self._native_tools
+
+    def generate(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ModelResponse:
+        try:
+            resp = httpx.post(
+                self._chat_url(),
+                headers=self._headers(),
+                json=self._body(messages, tools),
+                timeout=self._timeout,
+            )
+            resp.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            raise ModelError(f"Azure HTTP {exc.response.status_code}: {exc.response.text}") from exc
+        except httpx.RequestError as exc:
+            raise ModelError(f"Azure request failed: {exc}") from exc
+
+        return _parse_openai_response(resp.json())
+
+    async def agenerate(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ModelResponse:
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            try:
+                resp = await client.post(
+                    self._chat_url(),
+                    headers=self._headers(),
+                    json=self._body(messages, tools),
+                )
+                resp.raise_for_status()
+            except httpx.HTTPStatusError as exc:
+                raise ModelError(f"Azure HTTP {exc.response.status_code}: {exc.response.text}") from exc
+            except httpx.RequestError as exc:
+                raise ModelError(f"Azure request failed: {exc}") from exc
+
+        return _parse_openai_response(resp.json())
+
+    async def astream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncIterator[StreamChunk]:
+        accumulated = ""
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            async with client.stream(
+                "POST",
+                self._chat_url(),
+                headers=self._headers(),
+                json=self._body(messages, tools, stream=True),
+            ) as resp:
+                try:
+                    resp.raise_for_status()
+                except httpx.HTTPStatusError as exc:
+                    raise ModelError(
+                        f"Azure HTTP {exc.response.status_code}: {exc.response.text}"
+                    ) from exc
+
+                async for line in resp.aiter_lines():
+                    if not line.startswith("data:"):
+                        continue
+                    data_str = line[5:].strip()
+                    if data_str == "[DONE]":
+                        break
+                    try:
+                        chunk_data = json.loads(data_str)
+                    except json.JSONDecodeError:
+                        continue
+                    choices = chunk_data.get("choices", [])
+                    if not choices:
+                        continue
+                    token = choices[0].get("delta", {}).get("content") or ""
+                    if token:
+                        accumulated += token
+                        yield StreamChunk(delta=token)
+
+        yield StreamChunk(done=True, content=accumulated)