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

synth_ai/lm/caching/ephemeral.py

@@ -7,7 +7,6 @@ of the application run, useful for avoiding redundant API calls within a session
 
 import os
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from diskcache import Cache
 from pydantic import BaseModel
@@ -20,24 +19,25 @@ from synth_ai.lm.vendors.base import BaseLMResponse
 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: Optional[BaseModel] = None
-    ) -> Optional[BaseLMResponse]:
+        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
         """
@@ -65,14 +65,14 @@ class EphemeralCache:
             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
         """

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},
             {
@@ -115,7 +117,11 @@ class LM:
         if enable_v2_tracing is not None:
             enable_v3_tracing = enable_v2_tracing
 
+        # Debug logging
+        print(f"🔍 LM __init__: provider={provider}, vendor={vendor}, model={model}")
+
         # If vendor not provided, infer from model name
+        # But only if no explicit provider was given
         if vendor is None and model is not None:
             # Import vendor detection logic
             from synth_ai.lm.core.vendor_clients import (
@@ -154,6 +160,7 @@ class LM:
 
         self.vendor = vendor
         self.model = model
+        print(f"🔍 LM final: vendor={self.vendor}, model={self.model}")
         self.is_structured = is_structured
         self.structured_outputs_vendor = structured_outputs_vendor
         self.response_format = response_format
@@ -163,7 +170,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 +228,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)
 
@@ -332,6 +342,14 @@ class LM:
             if hasattr(vendor_wrapper, "_hit_api_async"):
                 # OpenAIStandard expects lm_config
                 lm_config = {"temperature": self.temperature, **self.additional_params, **kwargs}
+                # Map convenience enable_thinking => thinking_mode unless explicitly set
+                if "enable_thinking" in lm_config and "thinking_mode" not in lm_config:
+                    try:
+                        et = lm_config.get("enable_thinking")
+                        if isinstance(et, bool):
+                            lm_config["thinking_mode"] = "think" if et else "no_think"
+                    except Exception:
+                        pass
                 if self.json_mode:
                     lm_config["response_format"] = {"type": "json_object"}
 
@@ -377,11 +395,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 +419,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 +438,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/synth_models.py

@@ -0,0 +1,48 @@
+"""
+Synth-supported models registry.
+
+This module defines the specific models that are supported by Synth's infrastructure.
+Models are organized by family and size for easy maintenance and extension.
+
+MAINTENANCE GUIDE:
+1. Add new model families to the appropriate lists (QWEN_MODELS, OTHER_SYNTH_MODELS)
+2. Fine-tuned models (ft:) are automatically detected by regex
+3. Update SYNTH_SUPPORTED_MODELS set when adding new models
+4. Test changes with: pytest tests/lms/test_qwen_chat_completions.py
+
+WHY THIS EXISTS:
+- The previous regex (^.*\/.*$) was too broad and caught unintended models
+- This provides explicit control over which models use Synth infrastructure
+- Easier to maintain and debug model routing issues
+"""
+
+from typing import List, Set
+
+# Qwen3 model families supported by Synth
+QWEN3_MODELS: List[str] = [
+    # Qwen3 base models
+    "Qwen/Qwen3-0.6B",
+    "Qwen/Qwen3-1.7B",
+    "Qwen/Qwen3-4B",
+    "Qwen/Qwen3-8B",
+    "Qwen/Qwen3-14B",
+    "Qwen/Qwen3-32B",
+
+    # Qwen3 specialized variants
+    "Qwen/Qwen3-4B-Instruct-2507",
+    "Qwen/Qwen3-4B-Thinking-2507",
+]
+
+# Fine-tuned models pattern - any model starting with "ft:" is considered Synth-compatible
+# These are dynamically detected, but we can add specific known ones here
+FINE_TUNED_MODELS: List[str] = [
+    # Add specific fine-tuned models that are known to work with Synth
+    # Examples:
+    # "ft:Qwen/Qwen3-4B-Instruct-2507:ftjob-22",
+]
+
+# Combine all Synth-supported models
+SYNTH_SUPPORTED_MODELS: Set[str] = set(QWEN3_MODELS + FINE_TUNED_MODELS)
+
+# Export the main set for easy import
+__all__ = ["SYNTH_SUPPORTED_MODELS", "QWEN3_MODELS", "FINE_TUNED_MODELS"]