synth-ai 0.2.14__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/v0/api/__init__.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-# Legacy shim package to preserve old import paths like `synth_ai.v0.api.*`.
-# New code should import from `synth_ai.api.*` directly.
-
-__all__: list[str] = []
-
-

synth_ai/v0/api/models/__init__.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-try:
-    from synth_ai.api.models.supported import *  # type: ignore  # re-export
-except Exception:  # pragma: no cover
-    pass
-
-

synth_ai/v0/api/models/supported.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-# Backward-compat shim: old path `synth_ai.v0.api.models.supported`
-# now maps to the canonical module `synth_ai.api.models.supported`.
-
-from synth_ai.api.models.supported import *  # type: ignore[F401,F403]
-
-

synth_ai/v0/config/__init__.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-# Compatibility package to mirror historical import paths.
-# Re-export constants from the modern location under synth_ai.config.
-
-try:
-    from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT as _PROD
-except Exception:  # pragma: no cover
-    _PROD = None
-
-__all__ = [
-    "_PROD",
-]
-
-

synth_ai/v0/config/base_url.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-try:
-    # Prefer the modern constant
-    from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT as PROD_BASE_URL_DEFAULT  # type: ignore
-except Exception:  # pragma: no cover
-    # Fallback if the modern module moves; provide a safe default
-    PROD_BASE_URL_DEFAULT = "https://agent-learning.onrender.com"
-
-__all__ = ["PROD_BASE_URL_DEFAULT"]
-
-

synth_ai/v0/lm/__init__.py

@@ -1,51 +0,0 @@
-"""Synth AI Language Model Interface (legacy)."""
-
-import sys as _sys
-
-_sys.modules.setdefault("synth_ai.v0.lm", _sys.modules.get(__name__))
-
-from .config import OpenAIConfig, SynthConfig
-from .core.main_v3 import LM
-from .unified_interface import (
-    OpenAIProvider,
-    SynthProvider,
-    UnifiedLMClient,
-    UnifiedLMProvider,
-    create_provider,
-)
-from .vendors.synth_client import (
-    AsyncSynthClient,
-    SyncSynthClient,
-    create_async_client,
-    create_chat_completion_async,
-    create_chat_completion_sync,
-    create_sync_client,
-)
-from .warmup import get_warmup_status, warmup_synth_model
-
-__all__ = [
-    # Configuration
-    "SynthConfig",
-    "OpenAIConfig",
-    # Warmup utilities
-    "warmup_synth_model",
-    "get_warmup_status",
-    # Unified interface
-    "UnifiedLMProvider",
-    "OpenAIProvider",
-    "SynthProvider",
-    "UnifiedLMClient",
-    "create_provider",
-    # Synth client
-    "AsyncSynthClient",
-    "SyncSynthClient",
-    "create_async_client",
-    "create_sync_client",
-    "create_chat_completion_async",
-    "create_chat_completion_sync",
-    # Core LM class
-    "LM",
-]
-
-# Version info
-__version__ = "0.1.0"

synth_ai/v0/lm/caching/constants.py

@@ -1,6 +0,0 @@
-"""
-Constants for the caching module.
-"""
-
-# Maximum size limit for disk cache storage (10GB)
-DISKCACHE_SIZE_LIMIT = 10 * 1024 * 1024 * 1024  # 10GB

synth_ai/v0/lm/caching/ephemeral.py

@@ -1,100 +0,0 @@
-"""
-Ephemeral (temporary) caching for LM responses.
-
-This module provides a disk-based cache that persists only for the duration
-of the application run, useful for avoiding redundant API calls within a session.
-"""
-
-import os
-from dataclasses import dataclass
-
-from diskcache import Cache
-from pydantic import BaseModel
-
-from synth_ai.v0.lm.caching.constants import DISKCACHE_SIZE_LIMIT
-from synth_ai.v0.lm.vendors.base import BaseLMResponse
-
-
-@dataclass
-class EphemeralCache:
-    """
-    Ephemeral cache implementation using diskcache.
-
-    This cache stores LM responses temporarily on disk with a size limit.
-    The cache is cleared when the application restarts.
-    """
-
-    def __init__(self, fast_cache_dir: str = ".cache/ephemeral_cache"):
-        os.makedirs(fast_cache_dir, exist_ok=True)
-        self.fast_cache = Cache(fast_cache_dir, size_limit=DISKCACHE_SIZE_LIMIT)
-
-    def hit_cache(self, key: str, response_model: 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 to reconstruct structured output
-
-        Returns:
-            BaseLMResponse if found in cache, None otherwise
-        """
-        if key not in self.fast_cache:
-            return None
-
-        try:
-            cache_data = self.fast_cache[key]
-        except AttributeError:
-            return 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
-        """
-        if isinstance(response, str):
-            self.fast_cache[key] = response
-            return
-
-        if 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
-                ),
-            }
-            self.fast_cache[key] = cache_data
-            return
-
-        raise ValueError(f"Invalid response type: {type(response)}")
-
-    def close(self):
-        """Close the cache and free resources."""
-        self.fast_cache.close()

synth_ai/v0/lm/caching/handler.py

@@ -1,137 +0,0 @@
-import hashlib
-from typing import Any
-
-from pydantic import BaseModel
-
-from synth_ai.v0.lm.caching.ephemeral import EphemeralCache
-from synth_ai.v0.lm.caching.persistent import PersistentCache
-from synth_ai.v0.lm.tools.base import BaseTool
-from synth_ai.v0.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/v0/lm/caching/initialize.py

@@ -1,11 +0,0 @@
-from synth_ai.v0.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/v0/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.v0.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/v0/lm/config.py

@@ -1,115 +0,0 @@
-"""
-Configuration management for LM providers.
-Loads sensitive configuration from environment variables.
-"""
-
-import os
-from dataclasses import dataclass
-
-try:
-    # Optional dependency during tests; fallback to no-op if missing
-    from dotenv import load_dotenv  # type: ignore
-except Exception:  # pragma: no cover - best-effort fallback
-    def load_dotenv(*args, **kwargs):  # type: ignore
-        return False
-
-# 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/v0/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/v0/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"]