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

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(

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)