synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/lm/core/vendor_clients.py

@@ -1,188 +0,0 @@
-"""
-Vendor client selection and routing.
-
-This module handles the logic for selecting the appropriate vendor client
-based on model names or explicit provider specifications.
-"""
-
-import re
-from re import Pattern
-from typing import Any
-
-from synth_ai.lm.core.all import (
-    AnthropicClient,
-    CustomEndpointClient,
-    DeepSeekClient,
-    GeminiClient,
-    GrokClient,
-    GroqClient,
-    # OpenAIClient,
-    OpenAIStructuredOutputClient,
-    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] = [
-    re.compile(r"^(ft:)?(o[1,3,4](-.*)?|gpt-.*)$"),
-]
-openai_formatting_model_regexes: list[Pattern] = [
-    re.compile(r"^(ft:)?gpt-4o(-.*)?$"),
-]
-anthropic_naming_regexes: list[Pattern] = [
-    re.compile(r"^claude-.*$"),
-]
-gemini_naming_regexes: list[Pattern] = [
-    re.compile(r"^gemini-.*$"),
-    re.compile(r"^gemma[2-9].*$"),
-]
-deepseek_naming_regexes: list[Pattern] = [
-    re.compile(r"^deepseek-.*$"),
-]
-# 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] = [
-    re.compile(r"^llama-3.3-70b-versatile$"),
-    re.compile(r"^llama-3.1-8b-instant$"),
-    re.compile(r"^qwen-2.5-32b$"),
-    re.compile(r"^deepseek-r1-distill-qwen-32b$"),
-    re.compile(r"^deepseek-r1-distill-llama-70b-specdec$"),
-    re.compile(r"^deepseek-r1-distill-llama-70b$"),
-    re.compile(r"^llama-3.3-70b-specdec$"),
-    re.compile(r"^llama-3.2-1b-preview$"),
-    re.compile(r"^llama-3.2-3b-preview$"),
-    re.compile(r"^llama-3.2-11b-vision-preview$"),
-    re.compile(r"^llama-3.2-90b-vision-preview$"),
-    re.compile(r"^meta-llama/llama-4-scout-17b-16e-instruct$"),
-    re.compile(r"^meta-llama/llama-4-maverick-17b-128e-instruct$"),
-    re.compile(r"^qwen/qwen3-32b$"),
-    re.compile(r"^moonshotai/kimi-k2-instruct$"),
-]
-
-grok_naming_regexes: list[Pattern] = [
-    re.compile(r"^grok-3-beta$"),
-    re.compile(r"^grok-3-mini-beta$"),
-    re.compile(r"^grok-beta$"),
-    re.compile(r"^grok-.*$"),  # Catch-all for future Grok models
-]
-
-
-openrouter_naming_regexes: list[Pattern] = [
-    re.compile(r"^openrouter/.*$"),  # openrouter/model-name 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] = [
-    # 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] = {
-    "openai": OpenAIStructuredOutputClient,
-    "anthropic": AnthropicClient,
-    "groq": GroqClient,
-    "gemini": GeminiClient,
-    "deepseek": DeepSeekClient,
-    "grok": GrokClient,
-    "openrouter": OpenRouterClient,
-    "together": TogetherClient,
-    "synth": OpenAIStructuredOutputClient,  # Synth uses OpenAI-compatible API
-    "custom_endpoint": CustomEndpointClient,
-}
-
-
-def get_client(
-    model_name: str,
-    with_formatting: bool = False,
-    synth_logging: bool = True,
-    provider: str | None = None,
-) -> Any:
-    """
-    Get a vendor client for the specified model.
-
-    Args:
-        model_name: The name of the model to use.
-        with_formatting: Whether to use formatting capabilities.
-        synth_logging: Whether to enable Synth logging.
-        provider: Optional provider override. If specified, forces the use of a specific vendor
-                 implementation regardless of model name.
-
-    Returns:
-        A vendor client instance.
-
-    Raises:
-        ValueError: If the provider is unsupported or model name is invalid.
-    """
-    # print("With formatting", with_formatting)
-
-    # If provider is explicitly specified, use it
-    if provider:
-        if provider not in PROVIDER_MAP:
-            raise ValueError(
-                f"Unsupported provider: '{provider}'. Supported providers are: {', '.join(PROVIDER_MAP.keys())}"
-            )
-
-        # Log the provider override
-        client_class = PROVIDER_MAP[provider]
-
-        # Special handling for OpenAI and Synth with formatting
-        if provider in ["openai", "synth"]:
-            return client_class(synth_logging=synth_logging)
-        # Special handling for Anthropic with formatting
-        elif provider == "anthropic" and with_formatting:
-            client = client_class()
-            client._hit_api_async_structured_output = OpenAIStructuredOutputClient(
-                synth_logging=synth_logging
-            )._hit_api_async
-            return client
-        # Custom endpoint needs the model_name as endpoint_url
-        elif provider == "custom_endpoint":
-            return CustomEndpointClient(endpoint_url=model_name)
-        else:
-            return client_class()
-
-    # Original regex-based detection
-    if any(regex.match(model_name) for regex in openai_naming_regexes):
-        # print("Returning OpenAIStructuredOutputClient")
-        return OpenAIStructuredOutputClient(
-            synth_logging=synth_logging,
-        )
-    elif any(regex.match(model_name) for regex in anthropic_naming_regexes):
-        if with_formatting:
-            client = AnthropicClient()
-            client._hit_api_async_structured_output = OpenAIStructuredOutputClient(
-                synth_logging=synth_logging
-            )._hit_api_async
-            return client
-        else:
-            return AnthropicClient()
-    elif any(regex.match(model_name) for regex in gemini_naming_regexes):
-        return GeminiClient()
-    elif any(regex.match(model_name) for regex in deepseek_naming_regexes):
-        return DeepSeekClient()
-    elif any(regex.match(model_name) for regex in groq_naming_regexes):
-        return GroqClient()
-    elif any(regex.match(model_name) for regex in grok_naming_regexes):
-        return GrokClient()
-    elif any(regex.match(model_name) for regex in openrouter_naming_regexes):
-        return OpenRouterClient()
-    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 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/cost/monitor.py

@@ -1 +0,0 @@
-# TODO

synth_ai/lm/cost/statefulness.py

@@ -1 +0,0 @@
-# Maybe some kind of ephemeral cache

synth_ai/lm/injection.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-import contextvars
-from contextlib import contextmanager
-from typing import Any
-
-Rule = dict[str, Any]
-
-_rules_ctx: contextvars.ContextVar[list[Rule] | None] = contextvars.ContextVar(
-    "injection_rules", default=None
-)
-
-
-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).
-    Optional: "roles" as a list of role names to scope the replacement.
-    """
-    if not isinstance(rules, list) or not all(
-        isinstance(r, dict) and "find" in r and "replace" in r for r in rules
-    ):
-        raise ValueError("Injection rules must be a list of dicts with 'find' and 'replace'")
-    return _rules_ctx.set(rules)
-
-
-def get_injection_rules() -> list[Rule] | None:
-    """Get the current context's injection rules, if any."""
-    return _rules_ctx.get()
-
-
-def clear_injection_rules(token) -> None:
-    """Reset the injection rules to the previous value using the provided token."""
-    _rules_ctx.reset(token)
-
-
-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"`.
-    - Honors optional `roles` scoping in each rule.
-    - Returns the input list for convenience.
-    """
-    rules = get_injection_rules()
-    if not rules:
-        return messages
-
-    for m in messages:
-        role = m.get("role")
-        content = m.get("content")
-        if isinstance(content, str):
-            new_content = content
-            for r in rules:
-                allowed_roles = r.get("roles")
-                if allowed_roles is not None and role not in allowed_roles:
-                    continue
-                new_content = new_content.replace(str(r["find"]), str(r["replace"]))
-            m["content"] = new_content
-        elif isinstance(content, list):
-            for part in content:
-                if part.get("type") == "text":
-                    text = part.get("text", "")
-                    new_text = text
-                    for r in rules:
-                        allowed_roles = r.get("roles")
-                        if allowed_roles is not None and role not in allowed_roles:
-                            continue
-                        new_text = new_text.replace(str(r["find"]), str(r["replace"]))
-                    part["text"] = new_text
-    return messages
-
-
-@contextmanager
-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,206 +0,0 @@
-from __future__ import annotations
-
-import contextvars
-from contextlib import contextmanager
-from typing import Any
-
-from synth_ai.lm.injection import (
-    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):
-# {
-#   "match": {"contains": "atm", "role": "user" | "system" | None},
-#   "injection_rules": [{"find": str, "replace": str, "roles": Optional[List[str]]}],
-#   "params": { ... api params to override ... },
-#   "tools": { ... optional tools overrides ... },
-# }
-_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[dict[str, Any] | None] = contextvars.ContextVar(
-    "param_overrides", default=None
-)
-_tool_overrides_ctx: contextvars.ContextVar[dict[str, Any] | None] = contextvars.ContextVar(
-    "tool_overrides", default=None
-)
-_current_override_label_ctx: contextvars.ContextVar[str | None] = contextvars.ContextVar(
-    "override_label", default=None
-)
-
-
-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() -> list[dict[str, Any]] | None:
-    return _override_specs_ctx.get()
-
-
-def clear_override_specs(token) -> None:
-    _override_specs_ctx.reset(token)
-
-
-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
-    if not contains:
-        # no match criteria means always apply
-        return True
-    contains_l = str(contains).lower()
-    for m in messages:
-        if role and m.get("role") != role:
-            continue
-        c = m.get("content")
-        if isinstance(c, str) and contains_l in c.lower():
-            return True
-        if isinstance(c, list):
-            for part in c:
-                if part.get("type") == "text" and contains_l in str(part.get("text", "")).lower():
-                    return True
-    return False
-
-
-def resolve_override_for_messages(messages: list[dict[str, Any]]) -> dict[str, Any] | None:
-    specs = get_override_specs() or []
-    for spec in specs:
-        try:
-            if _matches(spec, messages):
-                return spec
-        except Exception:
-            # On matcher errors, skip spec
-            continue
-    return None
-
-
-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]:
-    ov = _param_overrides_ctx.get()
-    if not ov:
-        return api_params
-    # Shallow merge only known keys users provided
-    for k, v in ov.items():
-        api_params[k] = v
-    return api_params
-
-
-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"]:
-      - set_tools: replace tools entirely
-      - add_tools: append tools
-      - remove_tools_by_name: remove by function name
-      - tool_choice: set tool_choice param
-    """
-    ov = _tool_overrides_ctx.get()
-    if not ov:
-        return api_params
-    tov = ov.get("tools") if isinstance(ov, dict) else None
-    if tov:
-        tools = api_params.get("tools")
-        if "set_tools" in tov:
-            tools = tov["set_tools"]
-        if "add_tools" in tov:
-            tools = (tools or []) + tov["add_tools"]
-        if "remove_tools_by_name" in tov and tools:
-            names = set(tov["remove_tools_by_name"])  # function names
-            new_tools = []
-            for t in tools:
-                try:
-                    # OpenAI dict style
-                    fn = t.get("function", {}).get("name") if isinstance(t, dict) else None
-                except Exception:
-                    fn = None
-                # If BaseTool objects slipped through
-                if fn is None:
-                    fn = getattr(t, "function_name", None)
-                if fn is None or fn not in names:
-                    new_tools.append(t)
-            tools = new_tools
-        if tools is not None:
-            api_params["tools"] = tools
-        if "tool_choice" in tov:
-            api_params["tool_choice"] = tov["tool_choice"]
-    return api_params
-
-
-@contextmanager
-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.
-    - Yields, then resets ContextVars to previous values.
-    """
-    spec = resolve_override_for_messages(messages) or {}
-    inj_rules = spec.get("injection_rules")
-    params = spec.get("params")
-    inj_tok = None
-    param_tok = None
-    tool_tok = None
-    label_tok = None
-    try:
-        if inj_rules:
-            inj_tok = set_injection_rules(inj_rules)
-        if params:
-            param_tok = _param_overrides_ctx.set(params)
-        tools = spec.get("tools")
-        if tools:
-            tool_tok = _tool_overrides_ctx.set({"tools": tools})
-        lbl = spec.get("label")
-        if lbl:
-            label_tok = _current_override_label_ctx.set(str(lbl))
-        yield
-    finally:
-        if inj_tok is not None:
-            clear_injection_rules(inj_tok)
-        if param_tok is not None:
-            _param_overrides_ctx.reset(param_tok)
-        if tool_tok is not None:
-            _tool_overrides_ctx.reset(tool_tok)
-        if label_tok is not None:
-            _current_override_label_ctx.reset(label_tok)
-
-
-def get_current_override_label() -> str | None:
-    return _current_override_label_ctx.get()
-
-
-class LMOverridesContext:
-    """Context manager to register per-call override specs.
-
-    Usage:
-        with LMOverridesContext([
-            {"match": {"contains": "atm", "role": "user"}, "injection_rules": [...], "params": {...}},
-            {"match": {"contains": "refund"}, "params": {"temperature": 0.0}},
-        ]):
-            run_pipeline()
-    """
-
-    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 []
-        self._tok = None
-
-    def __enter__(self):
-        self._tok = set_override_specs(self._specs)
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        if self._tok is not None:
-            clear_override_specs(self._tok)

synth_ai/lm/provider_support/__init__.py

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