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

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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,206 @@
+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

@@ -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"]