synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/tracing_v3/utils.py

@@ -1,108 +0,0 @@
-"""Utility functions for tracing v3."""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import uuid
-from datetime import UTC, datetime
-from typing import Any
-
-
-def iso_now() -> str:
-    """Get current UTC time as ISO format string."""
-    return datetime.now(UTC).isoformat()
-
-
-def json_dumps(obj: Any) -> str:
-    """JSON dump with consistent formatting and datetime handling."""
-    return json.dumps(obj, default=str, separators=(",", ":"))
-
-
-def json_loads(s: str) -> Any:
-    """Safe JSON load with error handling."""
-    try:
-        return json.loads(s)
-    except (json.JSONDecodeError, TypeError):
-        return {}
-
-
-def generate_session_id(prefix: str = "session") -> str:
-    """Generate a unique session ID."""
-    return f"{prefix}_{uuid.uuid4().hex[:12]}"
-
-
-def generate_experiment_id(name: str) -> str:
-    """Generate experiment ID from name."""
-    hash_obj = hashlib.sha256(name.encode())
-    return f"exp_{hash_obj.hexdigest()[:12]}"
-
-
-def detect_provider(model_name: str | None) -> str:
-    """Detect LLM provider from model name."""
-    if not model_name:
-        return "unknown"
-
-    model_lower = model_name.lower()
-
-    if any(
-        x in model_lower for x in ["gpt-", "text-davinci", "text-curie", "text-babbage", "text-ada"]
-    ):
-        return "openai"
-    elif any(x in model_lower for x in ["claude", "anthropic"]):
-        return "anthropic"
-    elif any(x in model_lower for x in ["palm", "gemini", "bard"]):
-        return "google"
-    elif "azure" in model_lower:
-        return "azure"
-    elif any(x in model_lower for x in ["llama", "mistral", "mixtral", "local"]):
-        return "local"
-    else:
-        return "unknown"
-
-
-def calculate_cost(model_name: str, input_tokens: int, output_tokens: int) -> float | None:
-    """Calculate cost in USD based on model and token counts."""
-    # This is a simplified version - in production you'd want a proper pricing table
-    pricing = {
-        "gpt-4": {"input": 0.03, "output": 0.06},  # per 1K tokens
-        "gpt-4-turbo": {"input": 0.01, "output": 0.03},
-        "gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015},
-        "claude-3-opus": {"input": 0.015, "output": 0.075},
-        "claude-3-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-haiku": {"input": 0.00025, "output": 0.00125},
-    }
-
-    for model_prefix, prices in pricing.items():
-        if model_prefix in model_name.lower():
-            input_cost = (input_tokens / 1000) * prices["input"]
-            output_cost = (output_tokens / 1000) * prices["output"]
-            return input_cost + output_cost
-
-    return None
-
-
-def truncate_content(content: str, max_length: int = 10000) -> str:
-    """Truncate content to maximum length."""
-    if len(content) <= max_length:
-        return content
-    return content[: max_length - 3] + "..."
-
-
-def format_duration(start: datetime, end: datetime) -> str:
-    """Format duration between two timestamps."""
-    delta = end - start
-    total_seconds = delta.total_seconds()
-
-    if total_seconds < 1:
-        return f"{int(total_seconds * 1000)}ms"
-    elif total_seconds < 60:
-        return f"{total_seconds:.1f}s"
-    elif total_seconds < 3600:
-        minutes = int(total_seconds // 60)
-        seconds = int(total_seconds % 60)
-        return f"{minutes}m {seconds}s"
-    else:
-        hours = int(total_seconds // 3600)
-        minutes = int((total_seconds % 3600) // 60)
-        return f"{hours}h {minutes}m"

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()