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

synth_ai/lm/core/vendor_clients.py

@@ -6,43 +6,47 @@ 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,
 )
+from synth_ai.lm.core.synth_models import SYNTH_SUPPORTED_MODELS
 
 # 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] = [
-    re.compile(r"^.*\/.*$"),
+# Synth-specific model patterns (Qwen3 and fine-tuned models)
+synth_naming_regexes: list[Pattern] = [
+    re.compile(r"^ft:.*$"),  # Fine-tuned models (ft:model-name)
+    re.compile(r"^Qwen/Qwen3.*$"),  # Qwen3 models specifically (Qwen/Qwen3-*)
 ]
 
-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 +64,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,25 +72,23 @@ 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] = [
-    # Modal endpoints: org--app.modal.run
-    re.compile(r"^[a-zA-Z0-9\-]+--[a-zA-Z0-9\-]+\.modal\.run$"),
+custom_endpoint_naming_regexes: list[Pattern] = [
     # Generic domain patterns for custom endpoints
     re.compile(r"^[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+\.[a-zA-Z]+$"),  # domain.tld
     re.compile(r"^[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+\.[a-zA-Z]+\/[a-zA-Z0-9\-\/]+$"),  # domain.tld/path
 ]
 
 # Provider mapping for explicit provider overrides
-PROVIDER_MAP: Dict[str, Any] = {
+PROVIDER_MAP: dict[str, Any] = {
     "openai": OpenAIStructuredOutputClient,
     "anthropic": AnthropicClient,
     "groq": GroqClient,
@@ -104,7 +106,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.
@@ -178,7 +180,9 @@ def get_client(
     elif any(regex.match(model_name) for regex in custom_endpoint_naming_regexes):
         # Custom endpoints are passed as the endpoint URL
         return CustomEndpointClient(endpoint_url=model_name)
-    elif any(regex.match(model_name) for regex in together_naming_regexes):
-        return TogetherClient()
+    elif (any(regex.match(model_name) for regex in synth_naming_regexes) or
+          model_name in SYNTH_SUPPORTED_MODELS):
+        # Synth models use OpenAI-compatible client with custom endpoint
+        return OpenAIStructuredOutputClient(synth_logging=synth_logging)
     else:
         raise ValueError(f"Invalid model name: {model_name}")

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

synth_ai/lm/overrides.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-from contextlib import contextmanager
-from typing import Any, Dict, List, Optional, Tuple
 import contextvars
+from contextlib import contextmanager
+from typing import Any
 
 from synth_ai.lm.injection import (
-    set_injection_rules,
-    clear_injection_rules,
     apply_injection as _apply_injection,
 )
+from synth_ai.lm.injection import (
+    clear_injection_rules,
+    set_injection_rules,
+)
 
 # Context to hold a list of override specs to evaluate per-call
 # Each spec shape (minimal v1):
@@ -18,29 +20,29 @@ from synth_ai.lm.injection import (
 #   "params": { ... api params to override ... },
 #   "tools": { ... optional tools overrides ... },
 # }
-_override_specs_ctx: contextvars.ContextVar[Optional[List[Dict[str, Any]]]] = contextvars.ContextVar(
-    "override_specs", default=None
+_override_specs_ctx: contextvars.ContextVar[list[dict[str, Any]] | None] = (
+    contextvars.ContextVar("override_specs", default=None)
 )
 
 # ContextVars actually applied for the specific call once matched
-_param_overrides_ctx: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+_param_overrides_ctx: contextvars.ContextVar[dict[str, Any] | None] = contextvars.ContextVar(
     "param_overrides", default=None
 )
-_tool_overrides_ctx: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+_tool_overrides_ctx: contextvars.ContextVar[dict[str, Any] | None] = contextvars.ContextVar(
     "tool_overrides", default=None
 )
-_current_override_label_ctx: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+_current_override_label_ctx: contextvars.ContextVar[str | None] = contextvars.ContextVar(
     "override_label", default=None
 )
 
 
-def set_override_specs(specs: List[Dict[str, Any]]):
+def set_override_specs(specs: list[dict[str, Any]]):
     if not isinstance(specs, list):
         raise ValueError("override specs must be a list of dicts")
     return _override_specs_ctx.set(specs)
 
 
-def get_override_specs() -> Optional[List[Dict[str, Any]]]:
+def get_override_specs() -> list[dict[str, Any]] | None:
     return _override_specs_ctx.get()
 
 
@@ -48,7 +50,7 @@ def clear_override_specs(token) -> None:
     _override_specs_ctx.reset(token)
 
 
-def _matches(spec: Dict[str, Any], messages: List[Dict[str, Any]]) -> bool:
+def _matches(spec: dict[str, Any], messages: list[dict[str, Any]]) -> bool:
     match = spec.get("match") or {}
     contains = match.get("contains")
     role = match.get("role")  # optional
@@ -69,7 +71,7 @@ def _matches(spec: Dict[str, Any], messages: List[Dict[str, Any]]) -> bool:
     return False
 
 
-def resolve_override_for_messages(messages: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+def resolve_override_for_messages(messages: list[dict[str, Any]]) -> dict[str, Any] | None:
     specs = get_override_specs() or []
     for spec in specs:
         try:
@@ -81,12 +83,12 @@ def resolve_override_for_messages(messages: List[Dict[str, Any]]) -> Optional[Di
     return None
 
 
-def apply_injection(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def apply_injection(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
     # Delegate to injection.apply_injection
     return _apply_injection(messages)
 
 
-def apply_param_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
+def apply_param_overrides(api_params: dict[str, Any]) -> dict[str, Any]:
     ov = _param_overrides_ctx.get()
     if not ov:
         return api_params
@@ -96,7 +98,7 @@ def apply_param_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
     return api_params
 
 
-def apply_tool_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
+def apply_tool_overrides(api_params: dict[str, Any]) -> dict[str, Any]:
     """Apply tool overrides to OpenAI/Anthropic-like api_params in place.
 
     Supports keys under spec["tools"]:
@@ -138,7 +140,7 @@ def apply_tool_overrides(api_params: Dict[str, Any]) -> Dict[str, Any]:
 
 
 @contextmanager
-def use_overrides_for_messages(messages: List[Dict[str, Any]]):
+def use_overrides_for_messages(messages: list[dict[str, Any]]):
     """Resolve an override spec against messages and apply its contexts within the scope.
 
     - Sets injection rules and param overrides if present on the matched spec.
@@ -174,7 +176,7 @@ def use_overrides_for_messages(messages: List[Dict[str, Any]]):
             _current_override_label_ctx.reset(label_tok)
 
 
-def get_current_override_label() -> Optional[str]:
+def get_current_override_label() -> str | None:
     return _current_override_label_ctx.get()
 
 
@@ -189,7 +191,7 @@ class LMOverridesContext:
             run_pipeline()
     """
 
-    def __init__(self, override_specs: Optional[List[Dict[str, Any]]] | Dict[str, Any] = None):
+    def __init__(self, override_specs: list[dict[str, Any]] | None | dict[str, Any] = None):
         if isinstance(override_specs, dict):
             override_specs = [override_specs]
         self._specs = override_specs or []

synth_ai/lm/provider_support/__init__.py

@@ -2,7 +2,7 @@
 Provider support for LLM services with integrated tracing.
 """
 
-from .openai import OpenAI, AsyncOpenAI
 from .anthropic import Anthropic, AsyncAnthropic
+from .openai import AsyncOpenAI, OpenAI
 
 __all__ = ["OpenAI", "AsyncOpenAI", "Anthropic", "AsyncAnthropic"]

synth_ai/lm/provider_support/anthropic.py

@@ -6,14 +6,13 @@ Analogous to the modified OpenAI version.
 import logging
 import types
 from dataclasses import dataclass
-from typing import Optional
 
 try:
     import anthropic
-except ImportError:
+except ImportError as err:
     raise ModuleNotFoundError(
         "Please install anthropic to use this feature: 'pip install anthropic'"
-    )
+    ) from err
 
 try:
     from anthropic import AsyncClient, Client
@@ -27,14 +26,15 @@ from langfuse.decorators import langfuse_context
 from langfuse.utils import _get_timestamp
 from langfuse.utils.langfuse_singleton import LangfuseSingleton
 from wrapt import wrap_function_wrapper
+
 from synth_ai.lm.overrides import (
-    use_overrides_for_messages,
     apply_injection as apply_injection_overrides,
+)
+from synth_ai.lm.overrides import (
     apply_param_overrides,
     apply_tool_overrides,
+    use_overrides_for_messages,
 )
-from synth_ai.lm.injection import apply_injection
-
 from synth_ai.lm.provider_support.suppress_logging import *
 from synth_ai.tracing_v1.trackers import (
     synth_tracker_async,
@@ -799,7 +799,7 @@ class LangfuseAnthropicResponseGeneratorAsync:
 
 
 class AnthropicLangfuse:
-    _langfuse: Optional[Langfuse] = None
+    _langfuse: Langfuse | None = None
 
     def initialize(self):
         self._langfuse = LangfuseSingleton().get(
@@ -946,14 +946,14 @@ class AnthropicLangfuse:
 
         anthropic.AsyncClient.__init__ = new_async_init
 
-        setattr(anthropic, "langfuse_public_key", None)
-        setattr(anthropic, "langfuse_secret_key", None)
-        setattr(anthropic, "langfuse_host", None)
-        setattr(anthropic, "langfuse_debug", None)
-        setattr(anthropic, "langfuse_enabled", True)
-        setattr(anthropic, "langfuse_sample_rate", None)
-        setattr(anthropic, "langfuse_auth_check", self.langfuse_auth_check)
-        setattr(anthropic, "flush_langfuse", self.flush)
+        anthropic.langfuse_public_key = None
+        anthropic.langfuse_secret_key = None
+        anthropic.langfuse_host = None
+        anthropic.langfuse_debug = None
+        anthropic.langfuse_enabled = True
+        anthropic.langfuse_sample_rate = None
+        anthropic.langfuse_auth_check = self.langfuse_auth_check
+        anthropic.flush_langfuse = self.flush
 
 
 modifier = AnthropicLangfuse()

synth_ai/lm/provider_support/openai.py

@@ -4,7 +4,6 @@ import types
 from collections import defaultdict
 from dataclasses import dataclass
 from inspect import isclass
-from typing import List, Optional
 
 import openai.resources
 from langfuse import Langfuse
@@ -15,22 +14,25 @@ from langfuse.utils.langfuse_singleton import LangfuseSingleton
 from packaging.version import Version
 from pydantic import BaseModel
 from wrapt import wrap_function_wrapper
+
 from synth_ai.lm.overrides import (
-    use_overrides_for_messages,
     apply_injection as apply_injection_overrides,
+)
+from synth_ai.lm.overrides import (
     apply_param_overrides,
     apply_tool_overrides,
+    use_overrides_for_messages,
 )
-from synth_ai.lm.injection import apply_injection
-
 from synth_ai.lm.provider_support.suppress_logging import *
 from synth_ai.tracing_v1.abstractions import MessageInputs
 from synth_ai.tracing_v1.trackers import synth_tracker_async, synth_tracker_sync
 
 try:
     import openai
-except ImportError:
-    raise ModuleNotFoundError("Please install OpenAI to use this feature: 'pip install openai'")
+except ImportError as err:
+    raise ModuleNotFoundError(
+        "Please install OpenAI to use this feature: 'pip install openai'"
+    ) from err
 
 # CREDIT TO LANGFUSE FOR OPEN-SOURCING THE CODE THAT THIS IS BASED ON
 # USING WITH MIT LICENSE PERMISSION
@@ -59,7 +61,7 @@ class OpenAiDefinition:
     method: str
     type: str
     sync: bool
-    min_version: Optional[str] = None
+    min_version: str | None = None
 
 
 OPENAI_METHODS_V0 = [
@@ -212,7 +214,7 @@ def _extract_chat_response(kwargs: dict):
     Extracts the LLM output from the response.
     """
     response = {
-        "role": kwargs.get("role", None),
+        "role": kwargs.get("role"),
     }
 
     if kwargs.get("function_call") is not None:
@@ -221,7 +223,7 @@ def _extract_chat_response(kwargs: dict):
     if kwargs.get("tool_calls") is not None:
         response.update({"tool_calls": kwargs["tool_calls"]})
 
-    response["content"] = kwargs.get("content", None)
+    response["content"] = kwargs.get("content")
     return response
 
 
@@ -418,7 +420,7 @@ def _extract_streamed_openai_response(resource, chunks):
             usage = chunk_usage
 
         # Process choices
-        choices = chunk.get("choices", [])
+        choices = chunk.get("choices", [])  # noqa: F841
         # logger.debug(f"Extracted - model: {model}, choices: {choices}")
 
     # logger.debug(f"Final completion: {completion}")
@@ -762,7 +764,7 @@ async def _wrap_async(open_ai_resource: OpenAiDefinition, initialize, wrapped, a
 
 
 class OpenAILangfuse:
-    _langfuse: Optional[Langfuse] = None
+    _langfuse: Langfuse | None = None
 
     def initialize(self):
         self._langfuse = LangfuseSingleton().get(
@@ -820,15 +822,15 @@ class OpenAILangfuse:
                 else _wrap_async(resource, self.initialize),
             )
 
-        setattr(openai, "langfuse_public_key", None)
-        setattr(openai, "langfuse_secret_key", None)
-        setattr(openai, "langfuse_host", None)
-        setattr(openai, "langfuse_debug", None)
-        setattr(openai, "langfuse_enabled", True)
-        setattr(openai, "langfuse_sample_rate", None)
-        setattr(openai, "langfuse_mask", None)
-        setattr(openai, "langfuse_auth_check", self.langfuse_auth_check)
-        setattr(openai, "flush_langfuse", self.flush)
+        openai.langfuse_public_key = None
+        openai.langfuse_secret_key = None
+        openai.langfuse_host = None
+        openai.langfuse_debug = None
+        openai.langfuse_enabled = True
+        openai.langfuse_sample_rate = None
+        openai.langfuse_mask = None
+        openai.langfuse_auth_check = self.langfuse_auth_check
+        openai.flush_langfuse = self.flush
 
 
 modifier = OpenAILangfuse()
@@ -843,7 +845,7 @@ def auth_check():
     return modifier._langfuse.auth_check()
 
 
-def _filter_image_data(messages: List[dict]):
+def _filter_image_data(messages: list[dict]):
     """https://platform.openai.com/docs/guides/vision?lang=python
 
     The messages array remains the same, but the 'image_url' is removed from the 'content' array.