synth-ai 0.2.4.dev6__py3-none-any.whl → 0.2.4.dev7__py3-none-any.whl

synth_ai/lm/caching/handler.py

@@ -1,5 +1,5 @@
 import hashlib
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -17,11 +17,11 @@ logger = logging.getLogger(__name__)
 
 
 def map_params_to_key(
-    messages: List[Dict],
+    messages: list[dict],
     model: str,
     temperature: float,
-    response_model: Optional[Type[BaseModel]],
-    tools: Optional[List[BaseTool]] = None,
+    response_model: type[BaseModel] | None,
+    tools: list[BaseTool] | None = None,
     reasoning_effort: str = "low",
 ) -> str:
     if any(m is None for m in messages):
@@ -76,37 +76,37 @@ class CacheHandler:
         self.use_persistent_store = use_persistent_store
         self.use_ephemeral_store = use_ephemeral_store
 
-    def _validate_messages(self, messages: List[Dict[str, Any]]) -> None:
+    def _validate_messages(self, messages: list[dict[str, Any]]) -> None:
         """Validate that messages are in the correct format."""
-        assert all([type(msg["content"]) == str for msg in messages]), (
+        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: Optional[List[BaseTool]] = None,
-    ) -> Optional[BaseLMResponse]:
+        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 type(lm_config) == dict, "lm_config must be a dictionary"
+        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", None),
+            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", None)
+                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", None)
+                key=key, response_model=lm_config.get("response_model")
             )
         else:
             return None
@@ -114,20 +114,20 @@ class CacheHandler:
     def add_to_managed_cache(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         output: BaseLMResponse,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> None:
         """Add the given output to the cache."""
         self._validate_messages(messages)
-        assert type(output) == BaseLMResponse, "output must be a BaseLMResponse"
-        assert type(lm_config) == dict, "lm_config must be a dictionary"
+        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", None),
+            lm_config.get("response_model"),
             tools,
             lm_config.get("reasoning_effort", "low"),
         )

synth_ai/lm/caching/persistent.py

@@ -9,7 +9,6 @@ import json
 import os
 import sqlite3
 from dataclasses import dataclass
-from typing import Optional, Type, Union
 
 from pydantic import BaseModel
 
@@ -20,10 +19,11 @@ from synth_ai.lm.vendors.base import BaseLMResponse
 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)
@@ -33,15 +33,15 @@ class PersistentCache:
         self.conn.commit()
 
     def hit_cache(
-        self, key: str, response_model: Optional[Type[BaseModel]] = None
-    ) -> Optional[BaseLMResponse]:
+        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
         """
@@ -72,17 +72,17 @@ class PersistentCache:
             tool_calls=tool_calls,
         )
 
-    def add_to_cache(self, key: str, response: Union[BaseLMResponse, str]) -> None:
+    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.
         """

synth_ai/lm/config.py

@@ -4,8 +4,8 @@ Loads sensitive configuration from environment variables.
 """
 
 import os
-from typing import Optional
 from dataclasses import dataclass
+
 from dotenv import load_dotenv
 
 # Load environment variables from .env file
@@ -15,10 +15,10 @@ 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.

synth_ai/lm/constants.py

@@ -13,20 +13,20 @@ 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
+    "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
+    "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 = {model: 1 for model in REASONING_MODELS}
+SPECIAL_BASE_TEMPS = dict.fromkeys(REASONING_MODELS, 1)

synth_ai/lm/core/all.py

@@ -4,12 +4,12 @@ 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.together import TogetherAPI
-from synth_ai.lm.vendors.supported.groq import GroqAPI
 from synth_ai.lm.vendors.supported.grok import GrokAPI
-from synth_ai.lm.vendors.supported.custom_endpoint import CustomEndpointAPI
+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):
@@ -57,3 +57,17 @@ class CustomEndpointClient(CustomEndpointAPI):
 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,5 +1,3 @@
-from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 
 class StructuredOutputCoercionFailureException(Exception):

synth_ai/lm/core/main.py

@@ -1,8 +1,9 @@
-from typing import Any, Dict, List, Literal, Optional, Union
 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,
@@ -10,29 +11,28 @@ from synth_ai.lm.core.vendor_clients import (
     openai_naming_regexes,
 )
 from synth_ai.lm.structured_outputs.handler import StructuredOutputHandler
-from synth_ai.lm.vendors.base import VendorBase
 from synth_ai.lm.tools.base import BaseTool
-from synth_ai.lm.config import reasoning_models
+from synth_ai.lm.vendors.base import VendorBase
 
 
 def build_messages(
     sys_msg: str,
     user_msg: str,
-    images_bytes: List[bytes] = [],
-    model_name: Optional[str] = None,
-) -> List[Dict]:
+    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
@@ -102,7 +102,7 @@ class LM:
     # if str
     model_name: str
     client: VendorBase
-    lm_config: Dict[str, Any]
+    lm_config: dict[str, Any]
     structured_output_handler: StructuredOutputHandler
 
     def __init__(
@@ -113,23 +113,8 @@ class LM:
         max_retries: Literal["None", "Few", "Many"] = "Few",
         structured_output_mode: Literal["stringified_json", "forced_json"] = "stringified_json",
         synth_logging: bool = True,
-        provider: Optional[
-            Union[
-                Literal[
-                    "openai",
-                    "anthropic",
-                    "groq",
-                    "gemini",
-                    "deepseek",
-                    "grok",
-                    "mistral",
-                    "openrouter",
-                    "together",
-                ],
-                str,
-            ]
-        ] = None,
-        enable_thinking: Optional[bool] = None,
+        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
@@ -170,13 +155,13 @@ class LM:
 
     def respond_sync(
         self,
-        system_message: Optional[str] = None,
-        user_message: Optional[str] = None,
-        messages: Optional[List[Dict]] = None,
-        images_as_bytes: List[bytes] = [],
-        response_model: Optional[BaseModel] = None,
+        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: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
         reasoning_effort: str = "low",
     ):
         assert (system_message is None) == (user_message is None), (
@@ -231,13 +216,13 @@ class LM:
 
     async def respond_async(
         self,
-        system_message: Optional[str] = None,
-        user_message: Optional[str] = None,
-        messages: Optional[List[Dict]] = None,
-        images_as_bytes: List[bytes] = [],
-        response_model: Optional[BaseModel] = None,
+        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: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
         reasoning_effort: str = "low",
     ):
         # "In respond_async")
@@ -300,8 +285,8 @@ if __name__ == "__main__":
 
     # 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(
+        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"
         )
 

synth_ai/lm/core/main_v3.py

@@ -53,7 +53,9 @@ def build_messages(
                 ],
             },
         ]
-    elif len(images_bytes) > 0 and any(regex.match(model_name) for regex in anthropic_naming_regexes):
+    elif len(images_bytes) > 0 and any(
+        regex.match(model_name) for regex in anthropic_naming_regexes
+    ):
         return [
             {"role": "system", "content": sys_msg},
             {
@@ -163,7 +165,7 @@ class LM:
         self.system_id = system_id or f"lm_{self.vendor or 'unknown'}_{self.model or 'unknown'}"
         self.enable_v3_tracing = enable_v3_tracing
         self.additional_params = additional_params
-        
+
         # Initialize vendor wrapper early, before any potential usage
         # (e.g., within StructuredOutputHandler initialization below)
         self._vendor_wrapper = None
@@ -221,11 +223,14 @@ class LM:
         """Determine if Responses API should be used."""
         if self.use_responses_api is not None:
             return self.use_responses_api
-        
+
         # Auto-detect based on model
         responses_models = {
-            "o4-mini", "o3", "o3-mini",  # Supported Synth-hosted models
-            "gpt-oss-120b", "gpt-oss-20b"  # OSS models via Synth
+            "o4-mini",
+            "o3",
+            "o3-mini",  # Supported Synth-hosted models
+            "gpt-oss-120b",
+            "gpt-oss-20b",  # OSS models via Synth
         }
         return self.model in responses_models or (self.model and self.model in reasoning_models)
 
@@ -377,11 +382,15 @@ class LM:
                         raise AttributeError(
                             f"Vendor wrapper {type(vendor_wrapper).__name__} has no suitable response method"
                         )
-                    if not hasattr(response, 'api_type'):
+                    if not hasattr(response, "api_type"):
                         response.api_type = "chat"
 
                 # Update stored response ID if auto-storing
-                if self.auto_store_responses and hasattr(response, 'response_id') and response.response_id:
+                if (
+                    self.auto_store_responses
+                    and hasattr(response, "response_id")
+                    and response.response_id
+                ):
                     self._last_response_id = response.response_id
 
             except Exception as e:
@@ -397,12 +406,13 @@ class LM:
             and hasattr(self.session_tracer, "current_session")
         ):
             latency_ms = int((time.time() - start_time) * 1000)
-            
+
             # Create LLMCallRecord from the response
             from datetime import datetime
+
             started_at = datetime.utcnow()
             completed_at = datetime.utcnow()
-            
+
             call_record = create_llm_call_record_from_response(
                 response=response,
                 model_name=self.model or self.vendor,
@@ -415,7 +425,7 @@ class LM:
                 completed_at=completed_at,
                 latency_ms=latency_ms,
             )
-            
+
             # Compute aggregates from the call record
             aggregates = compute_aggregates_from_call_records([call_record])
 

synth_ai/lm/core/vendor_clients.py

@@ -6,43 +6,44 @@ based on model names or explicit provider specifications.
 """
 
 import re
-from typing import Any, List, Pattern, Optional, Dict
+from re import Pattern
+from typing import Any
 
 from synth_ai.lm.core.all import (
     AnthropicClient,
+    CustomEndpointClient,
     DeepSeekClient,
     GeminiClient,
-    GroqClient,
     GrokClient,
+    GroqClient,
     # OpenAIClient,
     OpenAIStructuredOutputClient,
-    TogetherClient,
-    CustomEndpointClient,
     OpenRouterClient,
+    TogetherClient,
 )
 
 # Regular expressions to match model names to their respective providers
-openai_naming_regexes: List[Pattern] = [
+openai_naming_regexes: list[Pattern] = [
     re.compile(r"^(ft:)?(o[1,3,4](-.*)?|gpt-.*)$"),
 ]
-openai_formatting_model_regexes: List[Pattern] = [
+openai_formatting_model_regexes: list[Pattern] = [
     re.compile(r"^(ft:)?gpt-4o(-.*)?$"),
 ]
-anthropic_naming_regexes: List[Pattern] = [
+anthropic_naming_regexes: list[Pattern] = [
     re.compile(r"^claude-.*$"),
 ]
-gemini_naming_regexes: List[Pattern] = [
+gemini_naming_regexes: list[Pattern] = [
     re.compile(r"^gemini-.*$"),
     re.compile(r"^gemma[2-9].*$"),
 ]
-deepseek_naming_regexes: List[Pattern] = [
+deepseek_naming_regexes: list[Pattern] = [
     re.compile(r"^deepseek-.*$"),
 ]
-together_naming_regexes: List[Pattern] = [
+together_naming_regexes: list[Pattern] = [
     re.compile(r"^.*\/.*$"),
 ]
 
-groq_naming_regexes: List[Pattern] = [
+groq_naming_regexes: list[Pattern] = [
     re.compile(r"^llama-3.3-70b-versatile$"),
     re.compile(r"^llama-3.1-8b-instant$"),
     re.compile(r"^qwen-2.5-32b$"),
@@ -60,7 +61,7 @@ groq_naming_regexes: List[Pattern] = [
     re.compile(r"^moonshotai/kimi-k2-instruct$"),
 ]
 
-grok_naming_regexes: List[Pattern] = [
+grok_naming_regexes: list[Pattern] = [
     re.compile(r"^grok-3-beta$"),
     re.compile(r"^grok-3-mini-beta$"),
     re.compile(r"^grok-beta$"),
@@ -68,16 +69,16 @@ grok_naming_regexes: List[Pattern] = [
 ]
 
 
-openrouter_naming_regexes: List[Pattern] = [
+openrouter_naming_regexes: list[Pattern] = [
     re.compile(r"^openrouter/.*$"),  # openrouter/model-name pattern
 ]
 
-openrouter_naming_regexes: List[Pattern] = [
+openrouter_naming_regexes: list[Pattern] = [
     re.compile(r"^openrouter/.*$"),  # openrouter/model-name pattern
 ]
 
 # Custom endpoint patterns - check these before generic patterns
-custom_endpoint_naming_regexes: List[Pattern] = [
+custom_endpoint_naming_regexes: list[Pattern] = [
     # Modal endpoints: org--app.modal.run
     re.compile(r"^[a-zA-Z0-9\-]+--[a-zA-Z0-9\-]+\.modal\.run$"),
     # Generic domain patterns for custom endpoints
@@ -86,7 +87,7 @@ custom_endpoint_naming_regexes: List[Pattern] = [
 ]
 
 # Provider mapping for explicit provider overrides
-PROVIDER_MAP: Dict[str, Any] = {
+PROVIDER_MAP: dict[str, Any] = {
     "openai": OpenAIStructuredOutputClient,
     "anthropic": AnthropicClient,
     "groq": GroqClient,
@@ -104,7 +105,7 @@ def get_client(
     model_name: str,
     with_formatting: bool = False,
     synth_logging: bool = True,
-    provider: Optional[str] = None,
+    provider: str | None = None,
 ) -> Any:
     """
     Get a vendor client for the specified model.

synth_ai/lm/injection.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 import contextvars
 from contextlib import contextmanager
-from typing import Any, Dict, List, Optional
+from typing import Any
 
-Rule = Dict[str, Any]
+Rule = dict[str, Any]
 
-_rules_ctx: contextvars.ContextVar[Optional[List[Rule]]] = contextvars.ContextVar(
+_rules_ctx: contextvars.ContextVar[list[Rule] | None] = contextvars.ContextVar(
     "injection_rules", default=None
 )
 
 
-def set_injection_rules(rules: List[Rule]):
+def set_injection_rules(rules: list[Rule]):
     """Set prompt-injection rules for the current context and return a reset token.
 
     Each rule must be a dict with at least keys: "find" and "replace" (strings).
@@ -24,7 +24,7 @@ def set_injection_rules(rules: List[Rule]):
     return _rules_ctx.set(rules)
 
 
-def get_injection_rules() -> Optional[List[Rule]]:
+def get_injection_rules() -> list[Rule] | None:
     """Get the current context's injection rules, if any."""
     return _rules_ctx.get()
 
@@ -34,7 +34,7 @@ def clear_injection_rules(token) -> None:
     _rules_ctx.reset(token)
 
 
-def apply_injection(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def apply_injection(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
     """Apply ordered substring replacements to text parts of messages in place.
 
     - Only modifies `str` content or list parts where `part["type"] == "text"`.
@@ -71,11 +71,10 @@ def apply_injection(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
 
 
 @contextmanager
-def injection_rules_ctx(rules: List[Rule]):
+def injection_rules_ctx(rules: list[Rule]):
     """Context manager to temporarily apply injection rules within the block."""
     tok = set_injection_rules(rules)
     try:
         yield
     finally:
         clear_injection_rules(tok)
-