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

synth_ai/lm/structured_outputs/inject.py

@@ -1,22 +1,19 @@
 import json
+import warnings
 from typing import (
     Any,
-    Dict,
-    List,
+    Literal,
     Optional,
-    Tuple,
-    Type,
-    get_type_hints,
+    Union,
     get_args,
     get_origin,
-    Union,
-    Literal,
+    get_type_hints,
 )
+
 from pydantic import BaseModel
-import warnings
 
 
-def generate_type_map() -> Dict[Any, str]:
+def generate_type_map() -> dict[Any, str]:
     base_types = {
         int: "int",
         float: "float",
@@ -26,8 +23,8 @@ def generate_type_map() -> Dict[Any, str]:
     }
 
     collection_types = {
-        List: "List",
-        Dict: "Dict",
+        list: "List",
+        dict: "Dict",
         Optional: "Optional",
     }
 
@@ -37,19 +34,19 @@ def generate_type_map() -> Dict[Any, str]:
         for collection, collection_name in collection_types.items():
             if collection is Optional:
                 type_map[Optional[base_type]] = name
-            elif collection is Dict:
+            elif collection is dict:
                 # Handle generic Dict type
-                type_map[Dict] = "Dict[Any,Any]"
+                type_map[dict] = "Dict[Any,Any]"
                 # Provide both key and value types for Dict
-                type_map[Dict[base_type, base_type]] = f"{collection_name}[{name},{name}]"
+                type_map[dict[base_type, base_type]] = f"{collection_name}[{name},{name}]"
                 # Handle Dict[Any, Any] explicitly
-                type_map[Dict[Any, Any]] = "Dict[Any,Any]"
+                type_map[dict[Any, Any]] = "Dict[Any,Any]"
             else:
                 type_map[collection[base_type]] = f"{collection_name}[{name}]"
     return type_map
 
 
-def generate_example_dict() -> Dict[str, Any]:
+def generate_example_dict() -> dict[str, Any]:
     example_values = {
         "str": "<Your type-str response here>",
         "int": "<Your type-int response here>",
@@ -101,10 +98,10 @@ def get_type_string(type_hint):
             return f"{type_hint.__name__}({', '.join(f'{k}: {v}' for k, v in field_types.items())})"
         else:
             return base_type_examples.get(type_hint, ("Unknown", "unknown"))[0]
-    elif origin in (list, List):
+    elif origin in (list, list):
         elem_type = get_type_string(args[0])
         return f"List[{elem_type}]"
-    elif origin in (dict, Dict):
+    elif origin in (dict, dict):
         key_type = get_type_string(args[0])
         value_type = get_type_string(args[1])
         return f"Dict[{key_type}, {value_type}]"
@@ -167,10 +164,10 @@ def get_example_value(type_hint):
             return example, union_docs
         else:
             return base_type_examples.get(type_hint, ("Unknown", "unknown"))[1], []
-    elif origin in (list, List):
+    elif origin in (list, list):
         value, docs = get_example_value(args[0])
         return [value], docs
-    elif origin in (dict, Dict):
+    elif origin in (dict, dict):
         if not args or len(args) < 2:
             warnings.warn(
                 f"Dictionary type hint {type_hint} missing type arguments. "
@@ -224,9 +221,9 @@ def get_example_value(type_hint):
 def add_json_instructions_to_messages(
     system_message,
     user_message,
-    response_model: Optional[Type[BaseModel]] = None,
-    previously_failed_error_messages: List[str] = [],
-) -> Tuple[str, str]:
+    response_model: type[BaseModel] | None = None,
+    previously_failed_error_messages: list[str] = [],
+) -> tuple[str, str]:
     if response_model:
         type_hints = get_type_hints(response_model)
         # print("Type hints", type_hints)
@@ -283,10 +280,10 @@ Here are some error traces from previous attempts:
 
 
 def inject_structured_output_instructions(
-    messages: List[Dict[str, str]],
-    response_model: Optional[Type[BaseModel]] = None,
-    previously_failed_error_messages: List[str] = [],
-) -> List[Dict[str, str]]:
+    messages: list[dict[str, str]],
+    response_model: type[BaseModel] | None = None,
+    previously_failed_error_messages: list[str] = [],
+) -> list[dict[str, str]]:
     prev_system_message_content = messages[0]["content"]
     prev_user_message_content = messages[1]["content"]
     system_message, user_message = add_json_instructions_to_messages(

synth_ai/lm/structured_outputs/rehabilitate.py

@@ -2,15 +2,13 @@ import ast
 import json
 import logging
 import re
-from typing import Dict, List, Type, Union
 
 from pydantic import BaseModel
 
-from synth_ai.lm.vendors.base import VendorBase
 from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
 
 
-def pull_out_structured_output(response_raw: str, response_model: Type[BaseModel]) -> BaseModel:
+def pull_out_structured_output(response_raw: str, response_model: type[BaseModel]) -> BaseModel:
     logger = logging.getLogger(__name__)
     # logger.debug(f"Raw response received: {response_raw}")
 
@@ -36,7 +34,7 @@ def pull_out_structured_output(response_raw: str, response_model: Type[BaseModel
     try:
         response = json.loads(response_prepared)
         final = response_model(**response)
-    except json.JSONDecodeError as e:
+    except json.JSONDecodeError:
         # Attempt to parse using ast.literal_eval as a fallback
         response_prepared = response_prepared.replace("\n", "").replace("\\n", "")
         response_prepared = response_prepared.replace('\\"', '"')
@@ -46,18 +44,22 @@ def pull_out_structured_output(response_raw: str, response_model: Type[BaseModel
         except Exception as inner_e:
             raise ValueError(
                 f"Failed to parse response as {response_model}: {inner_e} - {response_prepared}"
-            )
+            ) from inner_e
     except Exception as e:
-        raise ValueError(f"Failed to parse response as {response_model}: {e} - {response_prepared}")
+        raise ValueError(
+            f"Failed to parse response as {response_model}: {e} - {response_prepared}"
+        ) from e
     assert isinstance(final, BaseModel), "Structured output must be a Pydantic model"
     return final
 
 
 def fix_errant_stringified_json_sync(
     response_raw: str,
-    response_model: Type[BaseModel],
-    models: List[str] = ["gpt-4o-mini", "gpt-4o"],
+    response_model: type[BaseModel],
+    models: list[str] | None = None,
 ) -> BaseModel:
+    if models is None:
+        models = ["gpt-4o-mini", "gpt-4o"]
     try:
         return pull_out_structured_output(response_raw, response_model)
     except ValueError as e:
@@ -85,14 +87,16 @@ def fix_errant_stringified_json_sync(
                 return pull_out_structured_output(fixed_response, response_model)
             except Exception as e:
                 pass
-        raise ValueError("Failed to fix response using any model")
+        raise ValueError("Failed to fix response using any model") from None
 
 
 async def fix_errant_stringified_json_async(
     response_raw: str,
-    response_model: Type[BaseModel],
-    models: List[str] = ["gpt-4o-mini", "gpt-4o"],
+    response_model: type[BaseModel],
+    models: list[str] | None = None,
 ) -> BaseModel:
+    if models is None:
+        models = ["gpt-4o-mini", "gpt-4o"]
     try:
         return pull_out_structured_output(response_raw, response_model)
     except ValueError as e:
@@ -119,13 +123,13 @@ async def fix_errant_stringified_json_async(
                 return pull_out_structured_output(fixed_response, response_model)
             except Exception as e:
                 pass
-        raise ValueError("Failed to fix response using any model")
+        raise ValueError("Failed to fix response using any model") from None
 
 
 async def fix_errant_forced_async(
-    messages: List[Dict],
+    messages: list[dict],
     response_raw: str,
-    response_model: Type[BaseModel],
+    response_model: type[BaseModel],
     model: str,
 ) -> BaseModel:
     try:
@@ -157,7 +161,7 @@ async def fix_errant_forced_async(
 
 def fix_errant_forced_sync(
     response_raw: str,
-    response_model: Type[BaseModel],
+    response_model: type[BaseModel],
     model: str,
 ) -> BaseModel:
     client = OpenAIStructuredOutputClient()

synth_ai/lm/tools/base.py

@@ -4,7 +4,7 @@ Base class for LM tools.
 This module provides the base class for defining tools that can be used with language models.
 """
 
-from typing import Type, Dict, Any
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -12,25 +12,26 @@ from pydantic import BaseModel
 class BaseTool(BaseModel):
     """
     Base class for defining tools that can be used with language models.
-    
+
     Attributes:
         name: The name of the tool
         arguments: Pydantic model defining the tool's arguments
         description: Human-readable description of what the tool does
         strict: Whether to enforce strict schema validation (default True)
     """
+
     name: str
-    arguments: Type[BaseModel]
+    arguments: type[BaseModel]
     description: str = ""
     strict: bool = True
 
-    def to_openai_tool(self) -> Dict[str, Any]:
+    def to_openai_tool(self) -> dict[str, Any]:
         """
         Convert the tool to OpenAI's tool format.
-        
+
         Returns:
             dict: Tool definition in OpenAI's expected format
-            
+
         Note:
             - Ensures additionalProperties is False for strict validation
             - Fixes array items that lack explicit types
@@ -40,7 +41,7 @@ class BaseTool(BaseModel):
         schema["additionalProperties"] = False
 
         if "properties" in schema:
-            for prop_name, prop_schema in schema["properties"].items():
+            for _prop_name, prop_schema in schema["properties"].items():
                 if prop_schema.get("type") == "array":
                     items_schema = prop_schema.get("items", {})
                     if not isinstance(items_schema, dict) or not items_schema.get("type"):
@@ -63,13 +64,13 @@ class BaseTool(BaseModel):
             },
         }
 
-    def to_anthropic_tool(self) -> Dict[str, Any]:
+    def to_anthropic_tool(self) -> dict[str, Any]:
         """
         Convert the tool to Anthropic's tool format.
-        
+
         Returns:
             dict: Tool definition in Anthropic's expected format
-            
+
         Note:
             Anthropic uses a different format with input_schema instead of parameters.
         """
@@ -86,13 +87,13 @@ class BaseTool(BaseModel):
             },
         }
 
-    def to_mistral_tool(self) -> Dict[str, Any]:
+    def to_mistral_tool(self) -> dict[str, Any]:
         """
         Convert the tool to Mistral's tool format.
-        
+
         Returns:
             dict: Tool definition in Mistral's expected format
-            
+
         Note:
             Mistral requires explicit handling of array types and enum values.
         """
@@ -130,13 +131,13 @@ class BaseTool(BaseModel):
             },
         }
 
-    def to_gemini_tool(self) -> Dict[str, Any]:
+    def to_gemini_tool(self) -> dict[str, Any]:
         """
         Convert the tool to Gemini's tool format.
-        
+
         Returns:
             dict: Tool definition in Gemini's expected format
-            
+
         Note:
             Gemini uses a simpler format without the nested "function" key.
         """

synth_ai/lm/unified_interface.py

@@ -3,12 +3,11 @@ Unified interface for LM providers.
 Provides a consistent API for OpenAI and Synth backends.
 """
 
-import os
 import logging
 from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Optional, Union
+from typing import Any
 
-from .config import SynthConfig, OpenAIConfig
+from .config import OpenAIConfig, SynthConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,8 +17,8 @@ class UnifiedLMProvider(ABC):
 
     @abstractmethod
     async def create_chat_completion(
-        self, model: str, messages: List[Dict[str, Any]], **kwargs
-    ) -> Dict[str, Any]:
+        self, model: str, messages: list[dict[str, Any]], **kwargs
+    ) -> dict[str, Any]:
         """Create a chat completion."""
         pass
 
@@ -37,7 +36,7 @@ class UnifiedLMProvider(ABC):
 class OpenAIProvider(UnifiedLMProvider):
     """OpenAI provider implementation."""
 
-    def __init__(self, api_key: Optional[str] = None, **kwargs):
+    def __init__(self, api_key: str | None = None, **kwargs):
         """
         Initialize OpenAI provider.
 
@@ -47,8 +46,8 @@ class OpenAIProvider(UnifiedLMProvider):
         """
         try:
             from openai import AsyncOpenAI
-        except ImportError:
-            raise ImportError("OpenAI package not installed. Run: pip install openai")
+        except ImportError as err:
+            raise ImportError("OpenAI package not installed. Run: pip install openai") from err
 
         # Use provided key or load from environment
         if api_key is None:
@@ -59,8 +58,8 @@ class OpenAIProvider(UnifiedLMProvider):
         logger.info("Initialized OpenAI provider")
 
     async def create_chat_completion(
-        self, model: str, messages: List[Dict[str, Any]], **kwargs
-    ) -> Dict[str, Any]:
+        self, model: str, messages: list[dict[str, Any]], **kwargs
+    ) -> dict[str, Any]:
         """Create a chat completion using OpenAI."""
         response = await self.client.chat.completions.create(
             model=model, messages=messages, **kwargs
@@ -82,7 +81,7 @@ class OpenAIProvider(UnifiedLMProvider):
 class SynthProvider(UnifiedLMProvider):
     """Synth provider implementation."""
 
-    def __init__(self, config: Optional[SynthConfig] = None, **kwargs):
+    def __init__(self, config: SynthConfig | None = None, **kwargs):
         """
         Initialize Synth provider.
 
@@ -96,8 +95,8 @@ class SynthProvider(UnifiedLMProvider):
         self.client = AsyncSynthClient(self.config)
 
     async def create_chat_completion(
-        self, model: str, messages: List[Dict[str, Any]], **kwargs
-    ) -> Dict[str, Any]:
+        self, model: str, messages: list[dict[str, Any]], **kwargs
+    ) -> dict[str, Any]:
         """Create a chat completion using Synth."""
         return await self.client.chat_completions_create(model=model, messages=messages, **kwargs)
 
@@ -156,9 +155,9 @@ class UnifiedLMClient:
             default_provider: Default provider to use ("openai" or "synth")
         """
         self.default_provider = default_provider
-        self._providers: Dict[str, UnifiedLMProvider] = {}
+        self._providers: dict[str, UnifiedLMProvider] = {}
 
-    async def _get_provider(self, provider: Optional[str] = None) -> UnifiedLMProvider:
+    async def _get_provider(self, provider: str | None = None) -> UnifiedLMProvider:
         """Get or create a provider instance."""
         provider_name = provider or self.default_provider
 
@@ -168,8 +167,8 @@ class UnifiedLMClient:
         return self._providers[provider_name]
 
     async def create_chat_completion(
-        self, model: str, messages: List[Dict[str, Any]], provider: Optional[str] = None, **kwargs
-    ) -> Dict[str, Any]:
+        self, model: str, messages: list[dict[str, Any]], provider: str | None = None, **kwargs
+    ) -> dict[str, Any]:
         """
         Create a chat completion using specified or default provider.
 
@@ -185,7 +184,7 @@ class UnifiedLMClient:
         provider_instance = await self._get_provider(provider)
         return await provider_instance.create_chat_completion(model, messages, **kwargs)
 
-    async def warmup(self, model: str, provider: Optional[str] = None, **kwargs) -> bool:
+    async def warmup(self, model: str, provider: str | None = None, **kwargs) -> bool:
         """Warm up a model on specified provider."""
         provider_instance = await self._get_provider(provider)
         return await provider_instance.warmup(model, **kwargs)

synth_ai/lm/vendors/base.py

@@ -5,7 +5,7 @@ This module provides abstract base classes for implementing language model vendo
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -13,7 +13,7 @@ from pydantic import BaseModel
 class BaseLMResponse(BaseModel):
     """
     Standard response format from language model API calls.
-    
+
     Attributes:
         raw_response: The raw text response from the model
         structured_output: Optional parsed Pydantic model if structured output was requested
@@ -22,39 +22,41 @@ class BaseLMResponse(BaseModel):
         reasoning: Optional reasoning trace from the model (o1 models)
         api_type: Optional API type used ("chat", "responses", or "harmony")
     """
+
     raw_response: str
-    structured_output: Optional[BaseModel] = None
-    tool_calls: Optional[List[Dict]] = None
-    response_id: Optional[str] = None
-    reasoning: Optional[str] = None
-    api_type: Optional[str] = None
-    usage: Optional[Dict[str, Any]] = None
+    structured_output: BaseModel | None = None
+    tool_calls: list[dict] | None = None
+    response_id: str | None = None
+    reasoning: str | None = None
+    api_type: str | None = None
+    usage: dict[str, Any] | None = None
 
 
 class VendorBase(ABC):
     """
     Abstract base class for language model vendor implementations.
-    
+
     Attributes:
         used_for_structured_outputs: Whether this vendor supports structured outputs
         exceptions_to_retry: List of exceptions that should trigger retries
     """
+
     used_for_structured_outputs: bool = False
-    exceptions_to_retry: List[Exception] = []
+    exceptions_to_retry: list[Exception] = []
 
     @abstractmethod
     async def _hit_api_async(
         self,
-        messages: List[Dict[str, Any]],
-        response_model_override: Optional[BaseModel] = None,
+        messages: list[dict[str, Any]],
+        response_model_override: BaseModel | None = None,
     ) -> str:
         """
         Make an asynchronous API call to the language model.
-        
+
         Args:
             messages: List of message dictionaries with role and content
             response_model_override: Optional Pydantic model for structured output
-            
+
         Returns:
             str: The model's response
         """
@@ -63,16 +65,16 @@ class VendorBase(ABC):
     @abstractmethod
     def _hit_api_sync(
         self,
-        messages: List[Dict[str, Any]],
-        response_model_override: Optional[BaseModel] = None,
+        messages: list[dict[str, Any]],
+        response_model_override: BaseModel | None = None,
     ) -> str:
         """
         Make a synchronous API call to the language model.
-        
+
         Args:
             messages: List of message dictionaries with role and content
             response_model_override: Optional Pydantic model for structured output
-            
+
         Returns:
             str: The model's response
         """

synth_ai/lm/vendors/core/anthropic_api.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
 import anthropic
 import pydantic
@@ -8,27 +8,32 @@ from pydantic import BaseModel
 from synth_ai.lm.caching.initialize import (
     get_cache_handler,
 )
+from synth_ai.lm.constants import CLAUDE_REASONING_MODELS, SONNET_37_BUDGETS, SPECIAL_BASE_TEMPS
+from synth_ai.lm.overrides import (
+    apply_injection as apply_injection_overrides,
+)
+from synth_ai.lm.overrides import (
+    apply_param_overrides,
+    use_overrides_for_messages,
+)
 from synth_ai.lm.tools.base import BaseTool
 from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.lm.constants import SPECIAL_BASE_TEMPS, CLAUDE_REASONING_MODELS, SONNET_37_BUDGETS
 from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
-from synth_ai.lm.overrides import use_overrides_for_messages, apply_injection as apply_injection_overrides, apply_param_overrides
-from synth_ai.lm.injection import apply_injection
 
-ANTHROPIC_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (anthropic.APIError,)
+ANTHROPIC_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (anthropic.APIError,)
 
 
 class AnthropicAPI(VendorBase):
     used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple = ANTHROPIC_EXCEPTIONS_TO_RETRY
+    exceptions_to_retry: tuple = ANTHROPIC_EXCEPTIONS_TO_RETRY
     sync_client: Any
     async_client: Any
 
     def __init__(
         self,
-        exceptions_to_retry: Tuple[Type[Exception], ...] = ANTHROPIC_EXCEPTIONS_TO_RETRY,
+        exceptions_to_retry: tuple[type[Exception], ...] = ANTHROPIC_EXCEPTIONS_TO_RETRY,
         used_for_structured_outputs: bool = False,
-        reasoning_effort: Optional[str] = "high",
+        reasoning_effort: str | None = "high",
     ):
         self.sync_client = anthropic.Anthropic()
         self.async_client = anthropic.AsyncAnthropic()
@@ -46,14 +51,14 @@ class AnthropicAPI(VendorBase):
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        **vendor_params: Dict[str, Any],
+        tools: list[BaseTool] | None = None,
+        **vendor_params: dict[str, Any],
     ) -> BaseLMResponse:
-        assert lm_config.get("response_model", None) is None, (
+        assert lm_config.get("response_model") is None, (
             "response_model is not supported for standard calls"
         )
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
@@ -77,6 +82,7 @@ class AnthropicAPI(VendorBase):
         }
         with use_overrides_for_messages(messages):
             from synth_ai.lm.overrides import apply_tool_overrides
+
             api_params = apply_tool_overrides(api_params)
             api_params = apply_param_overrides(api_params)
 
@@ -89,8 +95,11 @@ class AnthropicAPI(VendorBase):
             import inspect
 
             create_sig = inspect.signature(self.async_client.messages.create)
-            if "thinking" in create_sig.parameters and model in CLAUDE_REASONING_MODELS:
-                if reasoning_effort in ["high", "medium"]:
+            if (
+                "thinking" in create_sig.parameters
+                and model in CLAUDE_REASONING_MODELS
+                and reasoning_effort in ["high", "medium"]
+            ):
                     budget = SONNET_37_BUDGETS[reasoning_effort]
                     api_params["thinking"] = {
                         "type": "enabled",
@@ -144,14 +153,14 @@ class AnthropicAPI(VendorBase):
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        **vendor_params: Dict[str, Any],
+        tools: list[BaseTool] | None = None,
+        **vendor_params: dict[str, Any],
     ) -> BaseLMResponse:
-        assert lm_config.get("response_model", None) is None, (
+        assert lm_config.get("response_model") is None, (
             "response_model is not supported for standard calls"
         )
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only=use_ephemeral_cache_only)
@@ -175,6 +184,7 @@ class AnthropicAPI(VendorBase):
         }
         with use_overrides_for_messages(messages):
             from synth_ai.lm.overrides import apply_tool_overrides
+
             api_params = apply_tool_overrides(api_params)
             api_params = apply_param_overrides(api_params)
 
@@ -238,12 +248,12 @@ class AnthropicAPI(VendorBase):
     async def _hit_api_async_structured_output(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         temperature: float,
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        **vendor_params: Dict[str, Any],
+        **vendor_params: dict[str, Any],
     ) -> BaseLMResponse:
         try:
             # First try with Anthropic
@@ -297,17 +307,16 @@ class AnthropicAPI(VendorBase):
     def _hit_api_sync_structured_output(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         response_model: BaseModel,
         temperature: float,
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        **vendor_params: Dict[str, Any],
+        **vendor_params: dict[str, Any],
     ) -> BaseLMResponse:
         try:
             # First try with Anthropic
             reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
-            import time
 
             if model in CLAUDE_REASONING_MODELS:
                 if reasoning_effort in ["high", "medium"]:
@@ -359,13 +368,13 @@ class AnthropicAPI(VendorBase):
 
     async def _process_call_async(
         self,
-        messages: List[Dict[str, Any]],
+        messages: list[dict[str, Any]],
         model: str,
         response_model: BaseModel,
         api_call_method,
         temperature: float = 0.0,
         use_ephemeral_cache_only: bool = False,
-        vendor_params: Dict[str, Any] = None,
+        vendor_params: dict[str, Any] = None,
     ) -> BaseModel:
         vendor_params = vendor_params or {}
         # Each vendor can filter parameters they support