synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/lm/unified_interface.py

@@ -1,202 +0,0 @@
-"""
-Unified interface for LM providers.
-Provides a consistent API for OpenAI and Synth backends.
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from typing import Any
-
-from .config import OpenAIConfig, SynthConfig
-
-logger = logging.getLogger(__name__)
-
-
-class UnifiedLMProvider(ABC):
-    """Abstract base class for LM providers."""
-
-    @abstractmethod
-    async def create_chat_completion(
-        self, model: str, messages: list[dict[str, Any]], **kwargs
-    ) -> dict[str, Any]:
-        """Create a chat completion."""
-        pass
-
-    @abstractmethod
-    async def warmup(self, model: str, **kwargs) -> bool:
-        """Warm up the model (optional for providers)."""
-        pass
-
-    @abstractmethod
-    async def close(self):
-        """Clean up resources."""
-        pass
-
-
-class OpenAIProvider(UnifiedLMProvider):
-    """OpenAI provider implementation."""
-
-    def __init__(self, api_key: str | None = None, **kwargs):
-        """
-        Initialize OpenAI provider.
-
-        Args:
-            api_key: Optional API key. If not provided, uses OPENAI_API_KEY env var.
-            **kwargs: Additional OpenAI client configuration
-        """
-        try:
-            from openai import AsyncOpenAI
-        except ImportError as err:
-            raise ImportError("OpenAI package not installed. Run: pip install openai") from err
-
-        # Use provided key or load from environment
-        if api_key is None:
-            config = OpenAIConfig.from_env()
-            api_key = config.api_key
-
-        self.client = AsyncOpenAI(api_key=api_key, **kwargs)
-        logger.info("Initialized OpenAI provider")
-
-    async def create_chat_completion(
-        self, model: str, messages: list[dict[str, Any]], **kwargs
-    ) -> dict[str, Any]:
-        """Create a chat completion using OpenAI."""
-        response = await self.client.chat.completions.create(
-            model=model, messages=messages, **kwargs
-        )
-        # Convert to dict for consistency
-        return response.model_dump()
-
-    async def warmup(self, model: str, **kwargs) -> bool:
-        """OpenAI doesn't need warmup."""
-        logger.debug(f"OpenAI model {model} doesn't require warmup")
-        return True
-
-    async def close(self):
-        """Close the OpenAI client."""
-        if hasattr(self.client, "close"):
-            await self.client.close()
-
-
-class SynthProvider(UnifiedLMProvider):
-    """Synth provider implementation."""
-
-    def __init__(self, config: SynthConfig | None = None, **kwargs):
-        """
-        Initialize Synth provider.
-
-        Args:
-            config: Optional SynthConfig. If not provided, loads from environment.
-            **kwargs: Additional configuration
-        """
-        from .vendors.synth_client import AsyncSynthClient
-
-        self.config = config or SynthConfig.from_env()
-        self.client = AsyncSynthClient(self.config)
-
-    async def create_chat_completion(
-        self, model: str, messages: list[dict[str, Any]], **kwargs
-    ) -> dict[str, Any]:
-        """Create a chat completion using Synth."""
-        return await self.client.chat_completions_create(model=model, messages=messages, **kwargs)
-
-    async def warmup(self, model: str, **kwargs) -> bool:
-        """Warm up the Synth model."""
-        from .warmup import warmup_synth_model
-
-        return await warmup_synth_model(model, config=self.config, **kwargs)
-
-    async def close(self):
-        """Close the Synth client."""
-        await self.client.close()
-
-
-# Factory function
-def create_provider(provider_type: str, **config) -> UnifiedLMProvider:
-    """
-    Create a provider instance.
-
-    Args:
-        provider_type: "openai" or "synth"
-        **config: Provider-specific configuration
-
-    Returns:
-        UnifiedLMProvider instance
-
-    Examples:
-        # Create OpenAI provider
-        provider = create_provider("openai")
-
-        # Create Synth provider with custom config
-        provider = create_provider("synth", timeout=60.0)
-
-        # Create provider based on environment variable
-        provider_type = os.getenv("LM_PROVIDER", "synth")
-        provider = create_provider(provider_type)
-    """
-    if provider_type.lower() == "openai":
-        return OpenAIProvider(**config)
-    elif provider_type.lower() == "synth":
-        return SynthProvider(**config)
-    else:
-        raise ValueError(f"Unknown provider: {provider_type}. Supported providers: openai, synth")
-
-
-class UnifiedLMClient:
-    """
-    High-level client that can switch between providers dynamically.
-    """
-
-    def __init__(self, default_provider: str = "synth"):
-        """
-        Initialize unified client.
-
-        Args:
-            default_provider: Default provider to use ("openai" or "synth")
-        """
-        self.default_provider = default_provider
-        self._providers: dict[str, UnifiedLMProvider] = {}
-
-    async def _get_provider(self, provider: str | None = None) -> UnifiedLMProvider:
-        """Get or create a provider instance."""
-        provider_name = provider or self.default_provider
-
-        if provider_name not in self._providers:
-            self._providers[provider_name] = create_provider(provider_name)
-
-        return self._providers[provider_name]
-
-    async def create_chat_completion(
-        self, model: str, messages: list[dict[str, Any]], provider: str | None = None, **kwargs
-    ) -> dict[str, Any]:
-        """
-        Create a chat completion using specified or default provider.
-
-        Args:
-            model: Model identifier
-            messages: List of message dicts
-            provider: Optional provider override
-            **kwargs: Additional parameters
-
-        Returns:
-            OpenAI-compatible response dict
-        """
-        provider_instance = await self._get_provider(provider)
-        return await provider_instance.create_chat_completion(model, messages, **kwargs)
-
-    async def warmup(self, model: str, provider: str | None = None, **kwargs) -> bool:
-        """Warm up a model on specified provider."""
-        provider_instance = await self._get_provider(provider)
-        return await provider_instance.warmup(model, **kwargs)
-
-    async def close(self):
-        """Close all provider connections."""
-        for provider in self._providers.values():
-            await provider.close()
-        self._providers.clear()
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, *args):
-        await self.close()

synth_ai/lm/vendors/base.py

@@ -1,81 +0,0 @@
-"""
-Base classes for LM vendors.
-
-This module provides abstract base classes for implementing language model vendor integrations.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-from pydantic import BaseModel
-
-
-class BaseLMResponse(BaseModel):
-    """
-    Standard response format from language model API calls.
-
-    Attributes:
-        raw_response: The raw text response from the model
-        structured_output: Optional parsed Pydantic model if structured output was requested
-        tool_calls: Optional list of tool calls if tools were provided
-        response_id: Optional response ID for thread management (Responses API)
-        reasoning: Optional reasoning trace from the model (o1 models)
-        api_type: Optional API type used ("chat", "responses", or "harmony")
-    """
-
-    raw_response: str
-    structured_output: BaseModel | None = None
-    tool_calls: list[dict] | None = None
-    response_id: str | None = None
-    reasoning: str | None = None
-    api_type: str | None = None
-    usage: dict[str, Any] | None = None
-
-
-class VendorBase(ABC):
-    """
-    Abstract base class for language model vendor implementations.
-
-    Attributes:
-        used_for_structured_outputs: Whether this vendor supports structured outputs
-        exceptions_to_retry: List of exceptions that should trigger retries
-    """
-
-    used_for_structured_outputs: bool = False
-    exceptions_to_retry: list[Exception] = []
-
-    @abstractmethod
-    async def _hit_api_async(
-        self,
-        messages: list[dict[str, Any]],
-        response_model_override: BaseModel | None = None,
-    ) -> str:
-        """
-        Make an asynchronous API call to the language model.
-
-        Args:
-            messages: List of message dictionaries with role and content
-            response_model_override: Optional Pydantic model for structured output
-
-        Returns:
-            str: The model's response
-        """
-        pass
-
-    @abstractmethod
-    def _hit_api_sync(
-        self,
-        messages: list[dict[str, Any]],
-        response_model_override: BaseModel | None = None,
-    ) -> str:
-        """
-        Make a synchronous API call to the language model.
-
-        Args:
-            messages: List of message dictionaries with role and content
-            response_model_override: Optional Pydantic model for structured output
-
-        Returns:
-            str: The model's response
-        """
-        pass

synth_ai/lm/vendors/core/anthropic_api.py

@@ -1,387 +0,0 @@
-import json
-from typing import Any
-
-import anthropic
-import pydantic
-from pydantic import BaseModel
-
-from synth_ai.lm.caching.initialize import (
-    get_cache_handler,
-)
-from synth_ai.lm.constants import CLAUDE_REASONING_MODELS, SONNET_37_BUDGETS, SPECIAL_BASE_TEMPS
-from synth_ai.lm.overrides import (
-    apply_injection as apply_injection_overrides,
-)
-from synth_ai.lm.overrides import (
-    apply_param_overrides,
-    use_overrides_for_messages,
-)
-from synth_ai.lm.tools.base import BaseTool
-from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
-
-ANTHROPIC_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (anthropic.APIError,)
-
-
-class AnthropicAPI(VendorBase):
-    used_for_structured_outputs: bool = True
-    exceptions_to_retry: tuple = ANTHROPIC_EXCEPTIONS_TO_RETRY
-    sync_client: Any
-    async_client: Any
-
-    def __init__(
-        self,
-        exceptions_to_retry: tuple[type[Exception], ...] = ANTHROPIC_EXCEPTIONS_TO_RETRY,
-        used_for_structured_outputs: bool = False,
-        reasoning_effort: str | None = "high",
-    ):
-        self.sync_client = anthropic.Anthropic()
-        self.async_client = anthropic.AsyncAnthropic()
-        self.used_for_structured_outputs = used_for_structured_outputs
-        self.exceptions_to_retry = exceptions_to_retry
-        self._openai_fallback = None
-        self.reasoning_effort = reasoning_effort
-
-    # @backoff.on_exception(
-    #     backoff.expo,
-    #     exceptions_to_retry,
-    #     max_tries=BACKOFF_TOLERANCE,
-    #     on_giveup=lambda e: print(e),
-    # )
-    async def _hit_api_async(
-        self,
-        model: str,
-        messages: list[dict[str, Any]],
-        lm_config: dict[str, Any],
-        use_ephemeral_cache_only: bool = False,
-        reasoning_effort: str = "high",
-        tools: list[BaseTool] | None = None,
-        **vendor_params: dict[str, Any],
-    ) -> BaseLMResponse:
-        assert lm_config.get("response_model") is None, (
-            "response_model is not supported for standard calls"
-        )
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
-        lm_config["reasoning_effort"] = reasoning_effort
-        # Apply context-scoped overrides and injection before splitting
-        with use_overrides_for_messages(messages):
-            messages = apply_injection_overrides(messages)
-        cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
-        )
-        if cache_result:
-            return cache_result
-
-        # Common API parameters
-        api_params = {
-            "system": messages[0]["content"],
-            "messages": messages[1:],
-            "model": model,
-            "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
-        }
-        with use_overrides_for_messages(messages):
-            from synth_ai.lm.overrides import apply_tool_overrides
-
-            api_params = apply_tool_overrides(api_params)
-            api_params = apply_param_overrides(api_params)
-
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = [tool.to_anthropic_tool() for tool in tools]
-
-        # Only try to add thinking if supported by the SDK
-        try:
-            import inspect
-
-            create_sig = inspect.signature(self.async_client.messages.create)
-            if (
-                "thinking" in create_sig.parameters
-                and model in CLAUDE_REASONING_MODELS
-                and reasoning_effort in ["high", "medium"]
-            ):
-                    budget = SONNET_37_BUDGETS[reasoning_effort]
-                    api_params["thinking"] = {
-                        "type": "enabled",
-                        "budget_tokens": budget,
-                    }
-                    api_params["max_tokens"] = budget + 4096
-                    api_params["temperature"] = 1
-        except (ImportError, AttributeError, TypeError):
-            pass
-
-        # Make the API call
-        response = await self.async_client.messages.create(**api_params)
-
-        # Extract text content and tool calls
-        raw_response = ""
-        tool_calls = []
-
-        for content in response.content:
-            if content.type == "text":
-                raw_response += content.text
-            elif content.type == "tool_use":
-                tool_calls.append(
-                    {
-                        "id": content.id,
-                        "type": "function",
-                        "function": {
-                            "name": content.name,
-                            "arguments": json.dumps(content.input),
-                        },
-                    }
-                )
-
-        lm_response = BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=None,
-            tool_calls=tool_calls if tool_calls else None,
-        )
-
-        lm_config["reasoning_effort"] = reasoning_effort
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
-        )
-        return lm_response
-
-    # @backoff.on_exception(
-    #     backoff.expo,
-    #     exceptions_to_retry,
-    #     max_tries=BACKOFF_TOLERANCE,
-    #     on_giveup=lambda e: print(e),
-    # )
-    def _hit_api_sync(
-        self,
-        model: str,
-        messages: list[dict[str, Any]],
-        lm_config: dict[str, Any],
-        use_ephemeral_cache_only: bool = False,
-        reasoning_effort: str = "high",
-        tools: list[BaseTool] | None = None,
-        **vendor_params: dict[str, Any],
-    ) -> BaseLMResponse:
-        assert lm_config.get("response_model") is None, (
-            "response_model is not supported for standard calls"
-        )
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only=use_ephemeral_cache_only)
-        lm_config["reasoning_effort"] = reasoning_effort
-        with use_overrides_for_messages(messages):
-            # Apply context-scoped injection before splitting into system/messages
-            messages = apply_injection_overrides(messages)
-        cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
-        )
-        if cache_result:
-            return cache_result
-
-        # Common API parameters
-        api_params = {
-            "system": messages[0]["content"],
-            "messages": messages[1:],
-            "model": model,
-            "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
-        }
-        with use_overrides_for_messages(messages):
-            from synth_ai.lm.overrides import apply_tool_overrides
-
-            api_params = apply_tool_overrides(api_params)
-            api_params = apply_param_overrides(api_params)
-
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = [tool.to_anthropic_tool() for tool in tools]
-
-        # Only try to add thinking if supported by the SDK
-        try:
-            import inspect
-
-            create_sig = inspect.signature(self.sync_client.messages.create)
-            if "thinking" in create_sig.parameters and model in CLAUDE_REASONING_MODELS:
-                api_params["temperature"] = 1
-                if reasoning_effort in ["high", "medium"]:
-                    budgets = SONNET_37_BUDGETS
-                    budget = budgets[reasoning_effort]
-                    api_params["thinking"] = {
-                        "type": "enabled",
-                        "budget_tokens": budget,
-                    }
-                    api_params["max_tokens"] = budget + 4096
-                    api_params["temperature"] = 1
-        except (ImportError, AttributeError, TypeError):
-            pass
-
-        # Make the API call
-        response = self.sync_client.messages.create(**api_params)
-
-        # Extract text content and tool calls
-        raw_response = ""
-        tool_calls = []
-
-        for content in response.content:
-            if content.type == "text":
-                raw_response += content.text
-            elif content.type == "tool_use":
-                tool_calls.append(
-                    {
-                        "id": content.id,
-                        "type": "function",
-                        "function": {
-                            "name": content.name,
-                            "arguments": json.dumps(content.input),
-                        },
-                    }
-                )
-
-        lm_response = BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=None,
-            tool_calls=tool_calls if tool_calls else None,
-        )
-
-        lm_config["reasoning_effort"] = reasoning_effort
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
-        )
-        return lm_response
-
-    async def _hit_api_async_structured_output(
-        self,
-        model: str,
-        messages: list[dict[str, Any]],
-        response_model: BaseModel,
-        temperature: float,
-        use_ephemeral_cache_only: bool = False,
-        reasoning_effort: str = "high",
-        **vendor_params: dict[str, Any],
-    ) -> BaseLMResponse:
-        try:
-            # First try with Anthropic
-            reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
-            if model in CLAUDE_REASONING_MODELS:
-                # if reasoning_effort in ["high", "medium"]:
-                budgets = SONNET_37_BUDGETS
-                budget = budgets[reasoning_effort]
-                max_tokens = budget + 4096
-                temperature = 1
-
-                response = await self.async_client.messages.create(
-                    system=messages[0]["content"],
-                    messages=messages[1:],
-                    model=model,
-                    max_tokens=max_tokens,
-                    thinking={"type": "enabled", "budget_tokens": budget},
-                    temperature=temperature,
-                )
-            else:
-                # For non-reasoning models, use default max_tokens and temperature
-                max_tokens = 4096
-                temperature = vendor_params.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0))
-                response = await self.async_client.messages.create(
-                    system=messages[0]["content"],
-                    messages=messages[1:],
-                    model=model,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                )
-            result = response.content[0].text
-            parsed = json.loads(result)
-            lm_response = BaseLMResponse(
-                raw_response="",
-                structured_output=response_model(**parsed),
-                tool_calls=None,
-            )
-            return lm_response
-        except (json.JSONDecodeError, pydantic.ValidationError):
-            # If Anthropic fails, fallback to OpenAI
-            if self._openai_fallback is None:
-                self._openai_fallback = OpenAIStructuredOutputClient()
-            return await self._openai_fallback._hit_api_async_structured_output(
-                model="gpt-4o",  # Fallback to GPT-4
-                messages=messages,
-                response_model=response_model,
-                temperature=temperature,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-            )
-
-    def _hit_api_sync_structured_output(
-        self,
-        model: str,
-        messages: list[dict[str, Any]],
-        response_model: BaseModel,
-        temperature: float,
-        use_ephemeral_cache_only: bool = False,
-        reasoning_effort: str = "high",
-        **vendor_params: dict[str, Any],
-    ) -> BaseLMResponse:
-        try:
-            # First try with Anthropic
-            reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
-
-            if model in CLAUDE_REASONING_MODELS:
-                if reasoning_effort in ["high", "medium"]:
-                    budgets = SONNET_37_BUDGETS
-                    budget = budgets[reasoning_effort]
-                    max_tokens = budget + 4096
-                    temperature = 1
-                response = self.sync_client.messages.create(
-                    system=messages[0]["content"],
-                    messages=messages[1:],
-                    model=model,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    thinking={"type": "enabled", "budget_tokens": budget},
-                )
-            else:
-                # For non-reasoning models, use default max_tokens and temperature
-                max_tokens = 4096
-                temperature = vendor_params.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0))
-                response = self.sync_client.messages.create(
-                    system=messages[0]["content"],
-                    messages=messages[1:],
-                    model=model,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                )
-            # print("Time taken for API call", time.time() - t)
-            result = response.content[0].text
-            # Try to parse the result as JSON
-            parsed = json.loads(result)
-            lm_response = BaseLMResponse(
-                raw_response="",
-                structured_output=response_model(**parsed),
-                tool_calls=None,
-            )
-            return lm_response
-        except (json.JSONDecodeError, pydantic.ValidationError):
-            # If Anthropic fails, fallback to OpenAI
-            print("WARNING - Falling back to OpenAI - THIS IS SLOW")
-            if self._openai_fallback is None:
-                self._openai_fallback = OpenAIStructuredOutputClient()
-            return self._openai_fallback._hit_api_sync_structured_output(
-                model="gpt-4o",  # Fallback to GPT-4
-                messages=messages,
-                response_model=response_model,
-                temperature=temperature,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-            )
-
-    async def _process_call_async(
-        self,
-        messages: list[dict[str, Any]],
-        model: str,
-        response_model: BaseModel,
-        api_call_method,
-        temperature: float = 0.0,
-        use_ephemeral_cache_only: bool = False,
-        vendor_params: dict[str, Any] = None,
-    ) -> BaseModel:
-        vendor_params = vendor_params or {}
-        # Each vendor can filter parameters they support
-        return await api_call_method(
-            messages=messages,
-            model=model,
-            temperature=temperature,
-            use_ephemeral_cache_only=use_ephemeral_cache_only,
-            **vendor_params,  # Pass all vendor-specific params
-        )