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

synth_ai/lm/caching/handler.py

@@ -1,137 +0,0 @@
-import hashlib
-from typing import Any
-
-from pydantic import BaseModel
-
-from synth_ai.lm.caching.ephemeral import EphemeralCache
-from synth_ai.lm.caching.persistent import PersistentCache
-from synth_ai.lm.tools.base import BaseTool
-from synth_ai.lm.vendors.base import BaseLMResponse
-
-persistent_cache = PersistentCache()
-ephemeral_cache = EphemeralCache()
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-def map_params_to_key(
-    messages: list[dict],
-    model: str,
-    temperature: float,
-    response_model: type[BaseModel] | None,
-    tools: list[BaseTool] | None = None,
-    reasoning_effort: str = "low",
-) -> str:
-    if any(m is None for m in messages):
-        raise ValueError("Messages cannot contain None values - messages: ", messages)
-    if not all([isinstance(msg["content"], str) for msg in messages]):
-        normalized_messages = "".join([str(msg["content"]) for msg in messages])
-    else:
-        normalized_messages = "".join([msg["content"] for msg in messages])
-    normalized_model = model
-    normalized_temperature = f"{temperature:.2f}"[:4]
-    normalized_response_model = str(response_model.model_json_schema()) if response_model else ""
-    normalized_reasoning_effort = reasoning_effort if reasoning_effort else ""
-
-    # Normalize tools if present
-    normalized_tools = ""
-    if tools and all(isinstance(tool, BaseTool) for tool in tools):
-        tool_schemas = []
-        for tool in sorted(tools, key=lambda x: x.name):  # Sort by name for consistency
-            tool_schema = {
-                "name": tool.name,
-                "description": tool.description,
-                "arguments": tool.arguments.model_json_schema(),
-            }
-            tool_schemas.append(str(tool_schema))
-        # logger.error(f"Tool schemas: {tool_schemas}")
-        normalized_tools = "".join(tool_schemas)
-    elif tools:
-        # logger.error(f"Tools: {tools}")
-        normalized_tools = "".join([str(tool) for tool in tools])
-
-    key_str = ""
-    components = [
-        normalized_messages,
-        normalized_model,
-        normalized_temperature,
-        normalized_response_model,
-        normalized_tools,
-        normalized_reasoning_effort,
-    ]
-    for component in components:
-        if component:
-            key_str += str(component)
-
-    return hashlib.sha256(key_str.encode()).hexdigest()
-
-
-class CacheHandler:
-    use_persistent_store: bool = False
-    use_ephemeral_store: bool = True
-
-    def __init__(self, use_persistent_store: bool = False, use_ephemeral_store: bool = True):
-        self.use_persistent_store = use_persistent_store
-        self.use_ephemeral_store = use_ephemeral_store
-
-    def _validate_messages(self, messages: list[dict[str, Any]]) -> None:
-        """Validate that messages are in the correct format."""
-        assert all(isinstance(msg["content"], str) for msg in messages), (
-            "All message contents must be strings"
-        )
-
-    def hit_managed_cache(
-        self,
-        model: str,
-        messages: list[dict[str, Any]],
-        lm_config: dict[str, Any],
-        tools: list[BaseTool] | None = None,
-    ) -> BaseLMResponse | None:
-        """Hit the cache with the given key."""
-        self._validate_messages(messages)
-        assert isinstance(lm_config, dict), "lm_config must be a dictionary"
-        key = map_params_to_key(
-            messages,
-            model,
-            lm_config.get("temperature", 0.0),
-            lm_config.get("response_model"),
-            tools,
-            lm_config.get("reasoning_effort", "low"),
-        )
-        if self.use_persistent_store:
-            return persistent_cache.hit_cache(
-                key=key, response_model=lm_config.get("response_model")
-            )
-        elif self.use_ephemeral_store:
-            return ephemeral_cache.hit_cache(
-                key=key, response_model=lm_config.get("response_model")
-            )
-        else:
-            return None
-
-    def add_to_managed_cache(
-        self,
-        model: str,
-        messages: list[dict[str, Any]],
-        lm_config: dict[str, Any],
-        output: BaseLMResponse,
-        tools: list[BaseTool] | None = None,
-    ) -> None:
-        """Add the given output to the cache."""
-        self._validate_messages(messages)
-        assert isinstance(output, BaseLMResponse), "output must be a BaseLMResponse"
-        assert isinstance(lm_config, dict), "lm_config must be a dictionary"
-        key = map_params_to_key(
-            messages,
-            model,
-            lm_config.get("temperature", 0.0),
-            lm_config.get("response_model"),
-            tools,
-            lm_config.get("reasoning_effort", "low"),
-        )
-        if self.use_persistent_store:
-            persistent_cache.add_to_cache(key, output)
-        if self.use_ephemeral_store:
-            ephemeral_cache.add_to_cache(key, output)

synth_ai/lm/caching/initialize.py

@@ -1,11 +0,0 @@
-from synth_ai.lm.caching.handler import CacheHandler
-
-cache_handler = CacheHandler(use_ephemeral_store=True, use_persistent_store=True)
-ephemeral_cache_handler = CacheHandler(use_ephemeral_store=True, use_persistent_store=False)
-
-
-def get_cache_handler(use_ephemeral_cache_only: bool = False):
-    if use_ephemeral_cache_only:
-        return ephemeral_cache_handler
-    else:
-        return cache_handler

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 ...