synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/lm/caching/persistent.py

@@ -1,114 +0,0 @@
-"""
-Persistent caching for LM responses.
-
-This module provides a SQLite-based cache that persists LM responses
-across application restarts, useful for long-term caching of expensive API calls.
-"""
-
-import json
-import os
-import sqlite3
-from dataclasses import dataclass
-
-from pydantic import BaseModel
-
-from synth_ai.lm.vendors.base import BaseLMResponse
-
-
-@dataclass
-class PersistentCache:
-    """
-    Persistent cache implementation using SQLite.
-
-    This cache stores LM responses in a SQLite database that persists
-    across application restarts.
-    """
-
-    def __init__(self, db_path: str = ".cache/persistent_cache.db"):
-        os.makedirs(os.path.dirname(db_path), exist_ok=True)
-        self.conn = sqlite3.connect(db_path)
-        self.cursor = self.conn.cursor()
-        self.cursor.execute("""CREATE TABLE IF NOT EXISTS cache
-                              (key TEXT PRIMARY KEY, response TEXT)""")
-        self.conn.commit()
-
-    def hit_cache(
-        self, key: str, response_model: type[BaseModel] | None = None
-    ) -> BaseLMResponse | None:
-        """
-        Check if a response exists in cache for the given key.
-
-        Args:
-            key: Cache key to look up
-            response_model: Optional Pydantic model class to reconstruct structured output
-
-        Returns:
-            BaseLMResponse if found in cache, None otherwise
-        """
-        self.cursor.execute("SELECT response FROM cache WHERE key = ?", (key,))
-        result = self.cursor.fetchone()
-        if not result:
-            return None
-
-        try:
-            cache_data = json.loads(result[0])
-        except json.JSONDecodeError:
-            # Handle legacy string responses
-            return BaseLMResponse(raw_response=result[0], structured_output=None, tool_calls=None)
-
-        if not isinstance(cache_data, dict):
-            return BaseLMResponse(raw_response=cache_data, structured_output=None, tool_calls=None)
-
-        raw_response = cache_data.get("raw_response")
-        tool_calls = cache_data.get("tool_calls")
-        structured_output = cache_data.get("structured_output")
-
-        if response_model and structured_output:
-            structured_output = response_model(**structured_output)
-
-        return BaseLMResponse(
-            raw_response=raw_response,
-            structured_output=structured_output,
-            tool_calls=tool_calls,
-        )
-
-    def add_to_cache(self, key: str, response: BaseLMResponse | str) -> None:
-        """
-        Add a response to the cache.
-
-        Args:
-            key: Cache key to store under
-            response: Either a BaseLMResponse object or raw string response
-
-        Raises:
-            ValueError: If response type is not supported
-
-        Note:
-            Uses INSERT OR REPLACE to update existing cache entries.
-        """
-        if isinstance(response, str):
-            cache_data = response
-        elif isinstance(response, BaseLMResponse):
-            cache_data = {
-                "raw_response": response.raw_response
-                if response.raw_response is not None
-                else None,
-                "tool_calls": response.tool_calls if response.tool_calls is not None else None,
-                "structured_output": (
-                    response.structured_output.model_dump()
-                    if response.structured_output is not None
-                    else None
-                ),
-            }
-        else:
-            raise ValueError(f"Invalid response type: {type(response)}")
-
-        self.cursor.execute(
-            "INSERT OR REPLACE INTO cache (key, response) VALUES (?, ?)",
-            (key, json.dumps(cache_data)),
-        )
-        self.conn.commit()
-
-    def close(self) -> None:
-        """Close the database connection and free resources."""
-        self.conn.close()

synth_ai/lm/config.py

@@ -1,110 +0,0 @@
-"""
-Configuration management for LM providers.
-Loads sensitive configuration from environment variables.
-"""
-
-import os
-from dataclasses import dataclass
-
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-
-def should_use_cache() -> bool:
-    """
-    Check if caching should be enabled based on environment variable.
-
-    Returns:
-        bool: True if caching is enabled (default), False if explicitly disabled.
-
-    Note:
-        Caching is controlled by the USE_ZYK_CACHE environment variable.
-        Set to "false", "0", or "no" to disable caching.
-    """
-    cache_env = os.getenv("USE_ZYK_CACHE", "true").lower()
-    return cache_env not in ("false", "0", "no")
-
-
-# List of models that are considered reasoning models
-# These models typically have special handling for temperature and other parameters
-reasoning_models = ["o1", "o3-mini", "o3", "o4-mini", "claude-3-7-sonnet-latest"]
-
-
-@dataclass
-class SynthConfig:
-    """Synth API configuration loaded from environment."""
-
-    base_url: str
-    api_key: str
-    timeout: float = 120.0
-    max_retries: int = 3
-
-    @classmethod
-    def from_env(cls) -> "SynthConfig":
-        """Load configuration from environment variables."""
-        # Support both SYNTH_ and MODAL_ prefixes for compatibility
-        base_url = os.getenv("SYNTH_BASE_URL") or os.getenv("MODAL_BASE_URL")
-        api_key = os.getenv("SYNTH_API_KEY") or os.getenv("MODAL_API_KEY")
-
-        if not base_url:
-            raise ValueError(
-                "SYNTH_BASE_URL or MODAL_BASE_URL not found in environment. "
-                "Please set it in your .env file:\n"
-                "SYNTH_BASE_URL=<your-synth-url>"
-            )
-
-        if not api_key:
-            raise ValueError(
-                "SYNTH_API_KEY or MODAL_API_KEY not found in environment. "
-                "Please set it in your .env file:\n"
-                "SYNTH_API_KEY=<your-api-key>"
-            )
-
-        # Ensure base URL includes /v1 for OpenAI client compatibility
-        # OpenAI client doesn't automatically add /v1, so we need to include it
-        if not base_url.endswith("/v1"):
-            base_url = base_url.rstrip("/") + "/v1"
-
-        return cls(
-            base_url=base_url.rstrip("/"),  # Remove trailing slash if present
-            api_key=api_key,
-            timeout=float(os.getenv("SYNTH_TIMEOUT", "120")),
-            max_retries=int(os.getenv("SYNTH_MAX_RETRIES", "3")),
-        )
-
-    def get_base_url_without_v1(self) -> str:
-        """Get base URL without /v1 for direct API calls."""
-        if self.base_url.endswith("/v1"):
-            return self.base_url[:-3]
-        return self.base_url
-
-    def __repr__(self) -> str:
-        """Safe representation without exposing sensitive data."""
-        return f"SynthConfig(base_url={self.base_url}, api_key=*****, timeout={self.timeout})"
-
-
-@dataclass
-class OpenAIConfig:
-    """OpenAI API configuration loaded from environment."""
-
-    api_key: str
-
-    @classmethod
-    def from_env(cls) -> "OpenAIConfig":
-        """Load configuration from environment variables."""
-        api_key = os.getenv("OPENAI_API_KEY")
-
-        if not api_key:
-            raise ValueError(
-                "OPENAI_API_KEY not found in environment. "
-                "Please set it in your .env file:\n"
-                "OPENAI_API_KEY=<your-openai-api-key>"
-            )
-
-        return cls(api_key=api_key)
-
-    def __repr__(self) -> str:
-        """Safe representation without exposing sensitive data."""
-        return "OpenAIConfig(api_key=*****)"

synth_ai/lm/constants.py

@@ -1,32 +0,0 @@
-"""
-Constants for LM module.
-
-This module defines constants used across the LM (Language Model) module,
-including model names, reasoning models, thinking budgets, and temperature settings.
-"""
-
-# Reasoning model names by provider
-OPENAI_REASONING_MODELS = ["o4", "o4-mini", "o3", "o3-mini", "o1-mini", "o1"]
-CLAUDE_REASONING_MODELS = ["claude-3-7-sonnet-latest"]
-GEMINI_REASONING_MODELS = ["gemini-2.5-flash", "gemini-2.5-pro"]
-
-# Gemini models that support thinking
-GEMINI_REASONING_MODELS = ["gemini-2.5-flash", "gemini-2.5-pro"]
-GEMINI_THINKING_BUDGETS = {
-    "high": 10000,  # High thinking budget for complex reasoning
-    "medium": 5000,  # Medium thinking budget for standard reasoning
-    "low": 2500,  # Low thinking budget for simple reasoning
-}
-
-# Anthropic Sonnet 3.7 budgets
-SONNET_37_BUDGETS = {
-    "high": 8192,  # High budget for complex tasks
-    "medium": 4096,  # Medium budget for standard tasks
-    "low": 2048,  # Low budget for simple tasks
-}
-
-# Combined list of all reasoning models
-REASONING_MODELS = OPENAI_REASONING_MODELS + CLAUDE_REASONING_MODELS + GEMINI_REASONING_MODELS
-
-# Special base temperatures for reasoning models (all set to 1.0)
-SPECIAL_BASE_TEMPS = dict.fromkeys(REASONING_MODELS, 1)

synth_ai/lm/core/__init__.py

@@ -1,8 +0,0 @@
-"""
-Core LM module with v3 tracing support.
-"""
-
-# Import v3 as the default LM implementation
-from .main_v3 import LM
-
-__all__ = ["LM"]

synth_ai/lm/core/all.py

@@ -1,73 +0,0 @@
-from synth_ai.lm.vendors.core.anthropic_api import AnthropicAPI
-from synth_ai.lm.vendors.core.gemini_api import GeminiAPI
-from synth_ai.lm.vendors.core.openai_api import (
-    OpenAIPrivate,
-    OpenAIStructuredOutputClient,
-)
-from synth_ai.lm.vendors.supported.custom_endpoint import CustomEndpointAPI
-from synth_ai.lm.vendors.supported.deepseek import DeepSeekAPI
-from synth_ai.lm.vendors.supported.grok import GrokAPI
-from synth_ai.lm.vendors.supported.groq import GroqAPI
-from synth_ai.lm.vendors.supported.openrouter import OpenRouterAPI
-from synth_ai.lm.vendors.supported.together import TogetherAPI
-
-
-class OpenAIClient(OpenAIPrivate):
-    def __init__(self, synth_logging: bool = True):
-        super().__init__(
-            synth_logging=synth_logging,
-        )
-
-
-class AnthropicClient(AnthropicAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class GeminiClient(GeminiAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class DeepSeekClient(DeepSeekAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class TogetherClient(TogetherAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class GroqClient(GroqAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class GrokClient(GrokAPI):
-    def __init__(self):
-        super().__init__()
-
-
-class CustomEndpointClient(CustomEndpointAPI):
-    def __init__(self, endpoint_url: str):
-        super().__init__(endpoint_url=endpoint_url)
-
-
-class OpenRouterClient(OpenRouterAPI):
-    def __init__(self):
-        super().__init__()
-
-
-__all__ = [
-    "OpenAIClient",
-    "AnthropicClient",
-    "GeminiClient",
-    "DeepSeekClient",
-    "TogetherClient",
-    "GroqClient",
-    "GrokClient",
-    "CustomEndpointClient",
-    "OpenRouterClient",
-    "OpenAIStructuredOutputClient",
-]

synth_ai/lm/core/exceptions.py

@@ -1,7 +0,0 @@
-
-
-class StructuredOutputCoercionFailureException(Exception):
-    pass
-
-
-# ... rest of imports ...

synth_ai/lm/core/main.py

@@ -1,319 +0,0 @@
-import os
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-from synth_ai.lm.config import reasoning_models
-from synth_ai.lm.core.exceptions import StructuredOutputCoercionFailureException
-from synth_ai.lm.core.vendor_clients import (
-    anthropic_naming_regexes,
-    get_client,
-    openai_naming_regexes,
-)
-from synth_ai.lm.structured_outputs.handler import StructuredOutputHandler
-from synth_ai.lm.tools.base import BaseTool
-from synth_ai.lm.vendors.base import VendorBase
-
-
-def build_messages(
-    sys_msg: str,
-    user_msg: str,
-    images_bytes: list[bytes] = [],
-    model_name: str | None = None,
-) -> list[dict]:
-    """
-    Build a messages list for API calls, handling image formatting based on the model provider.
-
-    Args:
-        sys_msg: System message content
-        user_msg: User message content
-        images_bytes: List of base64-encoded image bytes
-        model_name: Model name to determine proper image format (OpenAI vs Anthropic)
-
-    Returns:
-        List[Dict]: Formatted messages list ready for API calls
-
-    Note:
-        Different providers require different image formats:
-        - OpenAI: Uses "image_url" with data URL format
-        - Anthropic: Uses "image" with source object containing base64 data
-    """
-    if len(images_bytes) > 0 and any(regex.match(model_name) for regex in openai_naming_regexes):
-        return [
-            {"role": "system", "content": sys_msg},
-            {
-                "role": "user",
-                "content": [{"type": "text", "text": user_msg}]
-                + [
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{image_bytes}"},
-                    }
-                    for image_bytes in images_bytes
-                ],
-            },
-        ]
-    elif len(images_bytes) > 0 and any(
-        regex.match(model_name) for regex in anthropic_naming_regexes
-    ):
-        system_info = {"role": "system", "content": sys_msg}
-        user_info = {
-            "role": "user",
-            "content": [{"type": "text", "text": user_msg}]
-            + [
-                {
-                    "type": "image",
-                    "source": {
-                        "type": "base64",
-                        "media_type": "image/png",
-                        "data": image_bytes,
-                    },
-                }
-                for image_bytes in images_bytes
-            ],
-        }
-        return [system_info, user_info]
-    elif len(images_bytes) > 0:
-        raise ValueError("Images are not yet supported for this model")
-    else:
-        return [
-            {"role": "system", "content": sys_msg},
-            {"role": "user", "content": user_msg},
-        ]
-
-
-class LM:
-    """
-    Language Model interface for interacting with various AI providers.
-
-    Args:
-        model_name: The name of the model to use.
-        formatting_model_name: The model to use for formatting structured outputs.
-        temperature: The temperature setting for the model (0.0 to 1.0).
-        max_retries: Number of retries for API calls ("None", "Few", or "Many").
-        structured_output_mode: Mode for structured outputs ("stringified_json" or "forced_json").
-        synth_logging: Whether to enable Synth logging.
-        provider: Optional provider override. If specified, forces the use of a specific vendor
-                 implementation regardless of model name. Can also be set via SYNTH_AI_DEFAULT_PROVIDER
-                 environment variable. Supported values: "openai", "anthropic", "groq", "gemini",
-                 "deepseek", "grok", "mistral", "openrouter", "together", or a custom string.
-    """
-
-    # if str
-    model_name: str
-    client: VendorBase
-    lm_config: dict[str, Any]
-    structured_output_handler: StructuredOutputHandler
-
-    def __init__(
-        self,
-        model_name: str,
-        formatting_model_name: str,
-        temperature: float,
-        max_retries: Literal["None", "Few", "Many"] = "Few",
-        structured_output_mode: Literal["stringified_json", "forced_json"] = "stringified_json",
-        synth_logging: bool = True,
-        provider: Literal["openai", "anthropic", "groq", "gemini", "deepseek", "grok", "mistral", "openrouter", "together"] | str | None = None,
-        enable_thinking: bool | None = None,
-    ):
-        # print("Structured output mode", structured_output_mode)
-        # Check for environment variable if provider is not specified
-        effective_provider = provider or os.environ.get("SYNTH_AI_DEFAULT_PROVIDER")
-
-        self.client = get_client(
-            model_name,
-            with_formatting=structured_output_mode == "forced_json",
-            synth_logging=synth_logging,
-            provider=effective_provider,
-        )
-        # print(self.client.__class__)
-
-        formatting_client = get_client(
-            formatting_model_name, with_formatting=True, synth_logging=synth_logging, provider=None
-        )
-
-        max_retries_dict = {"None": 0, "Few": 2, "Many": 5}
-        self.structured_output_handler = StructuredOutputHandler(
-            self.client,
-            formatting_client,
-            structured_output_mode,
-            {"max_retries": max_retries_dict.get(max_retries, 2)},
-        )
-        self.backup_structured_output_handler = StructuredOutputHandler(
-            self.client,
-            formatting_client,
-            "forced_json",
-            {"max_retries": max_retries_dict.get(max_retries, 2)},
-        )
-        # Override temperature to 1 for reasoning models
-        effective_temperature = 1.0 if model_name in reasoning_models else temperature
-        self.lm_config = {"temperature": effective_temperature}
-        if enable_thinking is not None:
-            # For providers that support it (e.g., Synth + Qwen3), this will be forwarded
-            self.lm_config["enable_thinking"] = enable_thinking
-        self.model_name = model_name
-
-    def respond_sync(
-        self,
-        system_message: str | None = None,
-        user_message: str | None = None,
-        messages: list[dict] | None = None,
-        images_as_bytes: list[bytes] = [],
-        response_model: BaseModel | None = None,
-        use_ephemeral_cache_only: bool = False,
-        tools: list[BaseTool] | None = None,
-        reasoning_effort: str = "low",
-    ):
-        assert (system_message is None) == (user_message is None), (
-            "Must provide both system_message and user_message or neither"
-        )
-        assert (messages is None) != (system_message is None), (
-            "Must provide either messages or system_message/user_message pair, but not both"
-        )
-        assert not (response_model and tools), "Cannot provide both response_model and tools"
-        if messages is None:
-            messages = build_messages(
-                system_message, user_message, images_as_bytes, self.model_name
-            )
-        result = None
-        if response_model:
-            try:
-                result = self.structured_output_handler.call_sync(
-                    messages,
-                    model=self.model_name,
-                    lm_config=self.lm_config,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    reasoning_effort=reasoning_effort,
-                )
-            except StructuredOutputCoercionFailureException:
-                # print("Falling back to backup handler")
-                result = self.backup_structured_output_handler.call_sync(
-                    messages,
-                    model=self.model_name,
-                    lm_config=self.lm_config,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    reasoning_effort=reasoning_effort,
-                )
-        else:
-            result = self.client._hit_api_sync(
-                messages=messages,
-                model=self.model_name,
-                lm_config=self.lm_config,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-                tools=tools,
-                reasoning_effort=reasoning_effort,
-            )
-        assert isinstance(result.raw_response, str), "Raw response must be a string"
-        assert (
-            isinstance(result.structured_output, BaseModel) or result.structured_output is None
-        ), "Structured output must be a Pydantic model or None"
-        assert isinstance(result.tool_calls, list) or result.tool_calls is None, (
-            "Tool calls must be a list or None"
-        )
-        return result
-
-    async def respond_async(
-        self,
-        system_message: str | None = None,
-        user_message: str | None = None,
-        messages: list[dict] | None = None,
-        images_as_bytes: list[bytes] = [],
-        response_model: BaseModel | None = None,
-        use_ephemeral_cache_only: bool = False,
-        tools: list[BaseTool] | None = None,
-        reasoning_effort: str = "low",
-    ):
-        # "In respond_async")
-        assert (system_message is None) == (user_message is None), (
-            "Must provide both system_message and user_message or neither"
-        )
-        assert (messages is None) != (system_message is None), (
-            "Must provide either messages or system_message/user_message pair, but not both"
-        )
-
-        assert not (response_model and tools), "Cannot provide both response_model and tools"
-        if messages is None:
-            messages = build_messages(
-                system_message, user_message, images_as_bytes, self.model_name
-            )
-        result = None
-        if response_model:
-            try:
-                print("Trying structured output handler")
-                result = await self.structured_output_handler.call_async(
-                    messages,
-                    model=self.model_name,
-                    lm_config=self.lm_config,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    reasoning_effort=reasoning_effort,
-                )
-            except StructuredOutputCoercionFailureException:
-                print("Falling back to backup handler")
-                result = await self.backup_structured_output_handler.call_async(
-                    messages,
-                    model=self.model_name,
-                    lm_config=self.lm_config,
-                    response_model=response_model,
-                    use_ephemeral_cache_only=use_ephemeral_cache_only,
-                    reasoning_effort=reasoning_effort,
-                )
-        else:
-            # print("Calling API no response model")
-            result = await self.client._hit_api_async(
-                messages=messages,
-                model=self.model_name,
-                lm_config=self.lm_config,
-                use_ephemeral_cache_only=use_ephemeral_cache_only,
-                tools=tools,
-                reasoning_effort=reasoning_effort,
-            )
-        assert isinstance(result.raw_response, str), "Raw response must be a string"
-        assert (
-            isinstance(result.structured_output, BaseModel) or result.structured_output is None
-        ), "Structured output must be a Pydantic model or None"
-        assert isinstance(result.tool_calls, list) or result.tool_calls is None, (
-            "Tool calls must be a list or None"
-        )
-        return result
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    # Update json instructions to handle nested pydantic?
-    class Thought(BaseModel):
-        argument_keys: list[str] = Field(description="The keys of the arguments")
-        argument_values: list[str] = Field(
-            description="Stringified JSON for the values of the arguments"
-        )
-
-    class TestModel(BaseModel):
-        emotion: str = Field(description="The emotion expressed")
-        concern: str = Field(description="The concern expressed")
-        action: str = Field(description="The action to be taken")
-        thought: Thought = Field(description="The thought process")
-
-        class Config:
-            schema_extra = {"required": ["thought", "emotion", "concern", "action"]}
-
-    lm = LM(
-        model_name="gpt-4o-mini",
-        formatting_model_name="gpt-4o-mini",
-        temperature=1,
-        max_retries="Few",
-        structured_output_mode="forced_json",
-    )
-    print(
-        asyncio.run(
-            lm.respond_async(
-                system_message="You are a helpful assistant ",
-                user_message="Hello, how are you?",
-                images_as_bytes=[],
-                response_model=TestModel,
-                use_ephemeral_cache_only=False,
-            )
-        )
-    )