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

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
@@ -28,6 +27,14 @@ 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 (
+    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.provider_support.suppress_logging import *
 from synth_ai.tracing_v1.trackers import (
     synth_tracker_async,
@@ -349,7 +356,17 @@ def _wrap(anthropic_resource: AnthropicDefinition, initialize, wrapped, args, kw
     generation = new_langfuse.generation(**generation_data)
 
     try:
-        anthropic_response = wrapped(*args, **arg_extractor.get_anthropic_args())
+        call_kwargs = arg_extractor.get_anthropic_args()
+        # Apply context-scoped injection to chat messages if present
+        if isinstance(call_kwargs, dict) and "messages" in call_kwargs:
+            try:
+                with use_overrides_for_messages(call_kwargs["messages"]):  # type: ignore[arg-type]
+                    call_kwargs["messages"] = apply_injection_overrides(call_kwargs["messages"])  # type: ignore[arg-type]
+                    call_kwargs = apply_tool_overrides(call_kwargs)
+                    call_kwargs = apply_param_overrides(call_kwargs)
+            except Exception:
+                pass
+        anthropic_response = wrapped(*args, **call_kwargs)
 
         # If it's a streaming call, returns a generator
         if isinstance(anthropic_response, types.GeneratorType):
@@ -363,10 +380,10 @@ def _wrap(anthropic_resource: AnthropicDefinition, initialize, wrapped, args, kw
         else:
             model, completion, usage = _extract_anthropic_completion(anthropic_response)
             # Synth tracking
-            if "messages" in arg_extractor.get_anthropic_args():
+            if "messages" in call_kwargs:
                 # print("\nWRAP: Messages API path")
-                system_content = arg_extractor.get_anthropic_args().get("system")
-                original_messages = arg_extractor.get_anthropic_args()["messages"]
+                system_content = call_kwargs.get("system")
+                original_messages = call_kwargs["messages"]
                 # print(f"WRAP: Original messages: {original_messages}")
                 # print(f"WRAP: System content: {system_content}")
 
@@ -397,9 +414,9 @@ def _wrap(anthropic_resource: AnthropicDefinition, initialize, wrapped, args, kw
                 )
                 # print("Finished tracking LM output")
 
-            elif "prompt" in arg_extractor.get_anthropic_args():
+            elif "prompt" in call_kwargs:
                 # print("\nWRAP: Completions API path")
-                user_prompt = arg_extractor.get_anthropic_args().get("prompt", "")
+                user_prompt = call_kwargs.get("prompt", "")
                 # print(f"WRAP: User prompt: {user_prompt}")
                 messages = [{"role": "user", "content": user_prompt}]
                 # print(f"WRAP: Messages created: {messages}")
@@ -476,17 +493,27 @@ async def _wrap_async(anthropic_resource: AnthropicDefinition, initialize, wrapp
 
     try:
         logger.debug("About to call wrapped function")
-        response = await wrapped(*args, **kwargs)
+        call_kwargs = kwargs
+        # Apply context-scoped injection to chat messages if present
+        if isinstance(call_kwargs, dict) and "messages" in call_kwargs:
+            try:
+                with use_overrides_for_messages(call_kwargs["messages"]):  # type: ignore[arg-type]
+                    call_kwargs["messages"] = apply_injection_overrides(call_kwargs["messages"])  # type: ignore[arg-type]
+                    call_kwargs = apply_tool_overrides(call_kwargs)
+                    call_kwargs = apply_param_overrides(call_kwargs)
+            except Exception:
+                pass
+        response = await wrapped(*args, **call_kwargs)
         logger.debug(f"Got response: {response}")
 
         model, completion, usage = _extract_anthropic_completion(response)
         logger.debug(f"Extracted completion - Model: {model}, Usage: {usage}")
 
         # Synth tracking
-        if "messages" in arg_extractor.get_anthropic_args():
+        if "messages" in call_kwargs:
             # logger.debug("WRAP_ASYNC: Messages API path detected")
-            system_content = arg_extractor.get_anthropic_args().get("system")
-            original_messages = arg_extractor.get_anthropic_args()["messages"]
+            system_content = call_kwargs.get("system")
+            original_messages = call_kwargs["messages"]
             # logger.debug("WRAP_ASYNC: Original messages: %s", original_messages)
             # logger.debug("WRAP_ASYNC: System content: %s", system_content)
 
@@ -511,9 +538,9 @@ async def _wrap_async(anthropic_resource: AnthropicDefinition, initialize, wrapp
                 model_name=model,
                 finetune=False,
             )
-        elif "prompt" in arg_extractor.get_anthropic_args():
+        elif "prompt" in call_kwargs:
             # Handle Completions API format
-            user_prompt = arg_extractor.get_anthropic_args().get("prompt", "")
+            user_prompt = call_kwargs.get("prompt", "")
             messages = [{"role": "user", "content": user_prompt}]
             assistant_msg = [{"role": "assistant", "content": completion}]
 
@@ -772,7 +799,7 @@ class LangfuseAnthropicResponseGeneratorAsync:
 
 
 class AnthropicLangfuse:
-    _langfuse: Optional[Langfuse] = None
+    _langfuse: Langfuse | None = None
 
     def initialize(self):
         self._langfuse = LangfuseSingleton().get(
@@ -919,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
@@ -16,14 +15,24 @@ from packaging.version import Version
 from pydantic import BaseModel
 from wrapt import wrap_function_wrapper
 
+from synth_ai.lm.overrides import (
+    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.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
@@ -52,7 +61,7 @@ class OpenAiDefinition:
     method: str
     type: str
     sync: bool
-    min_version: Optional[str] = None
+    min_version: str | None = None
 
 
 OPENAI_METHODS_V0 = [
@@ -205,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:
@@ -214,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
 
 
@@ -411,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}")
@@ -475,7 +484,17 @@ def _wrap(open_ai_resource: OpenAiDefinition, initialize, wrapped, args, kwargs)
     )
     generation = new_langfuse.generation(**generation)
     try:
-        openai_response = wrapped(**arg_extractor.get_openai_args())
+        openai_args = arg_extractor.get_openai_args()
+        # Apply context-scoped injection to chat messages if present
+        if isinstance(openai_args, dict) and "messages" in openai_args:
+            try:
+                with use_overrides_for_messages(openai_args["messages"]):  # type: ignore[arg-type]
+                    openai_args["messages"] = apply_injection_overrides(openai_args["messages"])  # type: ignore[arg-type]
+                    openai_args = apply_tool_overrides(openai_args)
+                    openai_args = apply_param_overrides(openai_args)
+            except Exception:
+                pass
+        openai_response = wrapped(**openai_args)
 
         if _is_streaming_response(openai_response):
             return LangfuseResponseGeneratorSync(
@@ -527,7 +546,7 @@ def _wrap(open_ai_resource: OpenAiDefinition, initialize, wrapped, args, kwargs)
                 )
 
             elif open_ai_resource.type == "chat":
-                messages = arg_extractor.get_openai_args().get("messages", [])
+                messages = openai_args.get("messages", [])
                 message_input = MessageInputs(messages=messages)
 
                 # Track user input
@@ -605,7 +624,17 @@ async def _wrap_async(open_ai_resource: OpenAiDefinition, initialize, wrapped, a
     generation = new_langfuse.generation(**generation)
 
     try:
-        openai_response = await wrapped(**arg_extractor.get_openai_args())
+        openai_args = arg_extractor.get_openai_args()
+        # Apply context-scoped injection to chat messages if present
+        if isinstance(openai_args, dict) and "messages" in openai_args:
+            try:
+                with use_overrides_for_messages(openai_args["messages"]):  # type: ignore[arg-type]
+                    openai_args["messages"] = apply_injection_overrides(openai_args["messages"])  # type: ignore[arg-type]
+                    openai_args = apply_tool_overrides(openai_args)
+                    openai_args = apply_param_overrides(openai_args)
+            except Exception:
+                pass
+        openai_response = await wrapped(**openai_args)
 
         if _is_streaming_response(openai_response):
             return LangfuseResponseGeneratorAsync(
@@ -654,7 +683,7 @@ async def _wrap_async(open_ai_resource: OpenAiDefinition, initialize, wrapped, a
                 )
 
             elif open_ai_resource.type == "chat":
-                messages = arg_extractor.get_openai_args().get("messages", [])
+                messages = openai_args.get("messages", [])
                 message_input = MessageInputs(messages=messages)
 
                 # Track user input
@@ -735,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(
@@ -793,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()
@@ -816,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.

synth_ai/lm/structured_outputs/handler.py

@@ -8,10 +8,12 @@ in the requested structured format (Pydantic models).
 import logging
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from collections.abc import Callable
+from typing import Any, Literal
 
 from pydantic import BaseModel
 
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 from synth_ai.lm.core.exceptions import StructuredOutputCoercionFailureException
 from synth_ai.lm.structured_outputs.inject import (
     inject_structured_output_instructions,
@@ -22,7 +24,6 @@ from synth_ai.lm.structured_outputs.rehabilitate import (
     pull_out_structured_output,
 )
 from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 
 logger = logging.getLogger(__name__)
 
@@ -30,26 +31,27 @@ logger = logging.getLogger(__name__)
 class StructuredHandlerBase(ABC):
     """
     Abstract base class for structured output handlers.
-    
+
     Handles the logic for ensuring language models return properly formatted
     structured outputs, with retry logic and error handling.
-    
+
     Attributes:
         core_client: Primary vendor client for API calls
         retry_client: Client used for retry attempts (may use different model)
         handler_params: Configuration parameters including retry count
         structured_output_mode: Either "stringified_json" or "forced_json"
     """
+
     core_client: VendorBase
     retry_client: VendorBase
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
     structured_output_mode: Literal["stringified_json", "forced_json"]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
-        handler_params: Optional[Dict[str, Any]] = None,
+        handler_params: dict[str, Any] | None = None,
         structured_output_mode: Literal["stringified_json", "forced_json"] = "stringified_json",
     ):
         self.core_client = core_client
@@ -59,7 +61,7 @@ class StructuredHandlerBase(ABC):
 
     async def call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         temperature: float = 0.0,
@@ -74,7 +76,7 @@ class StructuredHandlerBase(ABC):
             model=model,
             response_model=response_model,
             api_call_method=self.core_client._hit_api_async_structured_output
-            if (not not response_model and self.structured_output_mode == "forced_json")
+            if (response_model and self.structured_output_mode == "forced_json")
             else self.core_client._hit_api_async,
             temperature=temperature,
             use_ephemeral_cache_only=use_ephemeral_cache_only,
@@ -83,7 +85,7 @@ class StructuredHandlerBase(ABC):
 
     def call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         model: str,
         temperature: float = 0.0,
@@ -97,7 +99,7 @@ class StructuredHandlerBase(ABC):
             model=model,
             response_model=response_model,
             api_call_method=self.core_client._hit_api_sync_structured_output
-            if (not not response_model and self.structured_output_mode == "forced_json")
+            if (response_model and self.structured_output_mode == "forced_json")
             else self.core_client._hit_api_sync,
             temperature=temperature,
             use_ephemeral_cache_only=use_ephemeral_cache_only,
@@ -107,7 +109,7 @@ class StructuredHandlerBase(ABC):
     @abstractmethod
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method,
@@ -119,7 +121,7 @@ class StructuredHandlerBase(ABC):
     @abstractmethod
     def _process_call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method,
@@ -132,24 +134,24 @@ class StructuredHandlerBase(ABC):
 class StringifiedJSONHandler(StructuredHandlerBase):
     core_client: VendorBase
     retry_client: VendorBase
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
-        handler_params: Dict[str, Any] = {"retries": 3},
+        handler_params: dict[str, Any] | None = None,
     ):
         super().__init__(
             core_client,
             retry_client,
-            handler_params,
+            handler_params or {"retries": 3},
             structured_output_mode="stringified_json",
         )
 
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         temperature: float,
@@ -170,7 +172,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                 response_model=response_model,
                 previously_failed_error_messages=previously_failed_error_messages,
             )
-            t0 = time.time()
+            # t0 = time.time()  # unused
             raw_text_response_or_cached_hit = await api_call_method(
                 messages=messages_with_json_formatting_instructions,
                 model=model,
@@ -184,7 +186,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
             assert type(raw_text_response_or_cached_hit) in [str, BaseLMResponse], (
                 f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
             )
-            if type(raw_text_response_or_cached_hit) == BaseLMResponse:
+            if isinstance(raw_text_response_or_cached_hit, BaseLMResponse):
                 # print("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
             else:
@@ -242,7 +244,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
 
     def _process_call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         temperature: float,
@@ -277,7 +279,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
             assert type(raw_text_response_or_cached_hit) in [str, BaseLMResponse], (
                 f"Expected str or BaseLMResponse, got {type(raw_text_response_or_cached_hit)}"
             )
-            if type(raw_text_response_or_cached_hit) == BaseLMResponse:
+            if isinstance(raw_text_response_or_cached_hit, BaseLMResponse):
                 logger.info("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
             else:
@@ -320,26 +322,26 @@ class StringifiedJSONHandler(StructuredHandlerBase):
 class ForcedJSONHandler(StructuredHandlerBase):
     core_client: VendorBase
     retry_client: VendorBase
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
-        handler_params: Dict[str, Any] = {},
+        handler_params: dict[str, Any] | None = None,
         reasoning_effort: str = "high",
     ):
         super().__init__(
             core_client,
             retry_client,
-            handler_params,
+            handler_params or {"retries": 3},
             structured_output_mode="forced_json",
         )
         self.reasoning_effort = reasoning_effort
 
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method: Callable,
@@ -360,7 +362,7 @@ class ForcedJSONHandler(StructuredHandlerBase):
 
     def _process_call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method: Callable,
@@ -380,16 +382,16 @@ class ForcedJSONHandler(StructuredHandlerBase):
 
 
 class StructuredOutputHandler:
-    handler: Union[StringifiedJSONHandler, ForcedJSONHandler]
+    handler: StringifiedJSONHandler | ForcedJSONHandler
     mode: Literal["stringified_json", "forced_json"]
-    handler_params: Dict[str, Any]
+    handler_params: dict[str, Any]
 
     def __init__(
         self,
         core_client: VendorBase,
         retry_client: VendorBase,
         mode: Literal["stringified_json", "forced_json"],
-        handler_params: Dict[str, Any] = {},
+        handler_params: dict[str, Any] = {},
     ):
         self.mode = mode
         if self.mode == "stringified_json":
@@ -402,11 +404,11 @@ class StructuredOutputHandler:
 
     async def call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         use_ephemeral_cache_only: bool = False,
-        lm_config: Dict[str, Any] = {},
+        lm_config: dict[str, Any] = {},
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
         # print("Output handler call async")
@@ -421,11 +423,11 @@ class StructuredOutputHandler:
 
     def call_sync(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         use_ephemeral_cache_only: bool = False,
-        lm_config: Dict[str, Any] = {},
+        lm_config: dict[str, Any] = {},
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
         return self.handler.call_sync(