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

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

synth_ai/lm/vendors/core/gemini_api.py

@@ -2,22 +2,21 @@ import json
 import logging
 import os
 import warnings
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
 import google.genai as genai
 from google.api_core.exceptions import ResourceExhausted
 from google.genai import types
+
 from synth_ai.lm.caching.initialize import get_cache_handler
-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,
     GEMINI_REASONING_MODELS,
     GEMINI_THINKING_BUDGETS,
+    SPECIAL_BASE_TEMPS,
 )
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
 from synth_ai.lm.vendors.retries import BACKOFF_TOLERANCE, MAX_BACKOFF, backoff
-import logging
-
 
 ALIASES = {
     "gemini-2.5-flash": "gemini-2.5-flash-preview-04-17",
@@ -25,7 +24,7 @@ ALIASES = {
 
 logger = logging.getLogger(__name__)
 _CLIENT = None  # Initialize lazily when needed
-GEMINI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (ResourceExhausted,)
+GEMINI_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (ResourceExhausted,)
 logging.getLogger("google.genai").setLevel(logging.ERROR)
 os.environ["GRPC_VERBOSITY"] = "ERROR"
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
@@ -49,11 +48,11 @@ def _get_client():
 
 class GeminiAPI(VendorBase):
     used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple[Type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY
+    exceptions_to_retry: tuple[type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY
 
     def __init__(
         self,
-        exceptions_to_retry: Tuple[Type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY,
+        exceptions_to_retry: tuple[type[Exception], ...] = GEMINI_EXCEPTIONS_TO_RETRY,
         used_for_structured_outputs: bool = False,
     ):
         self.used_for_structured_outputs = used_for_structured_outputs
@@ -65,7 +64,7 @@ class GeminiAPI(VendorBase):
         return model_name
 
     @staticmethod
-    def _msg_to_contents(messages: List[Dict[str, Any]]) -> List[types.Content]:
+    def _msg_to_contents(messages: list[dict[str, Any]]) -> list[types.Content]:
         # contents, sys_instr = [], None
         contents = []
         for m in messages:
@@ -82,16 +81,12 @@ class GeminiAPI(VendorBase):
         return contents
 
     @staticmethod
-    def _tools_to_genai(tools: List[BaseTool]) -> List[types.Tool]:
+    def _tools_to_genai(tools: list[BaseTool]) -> list[types.Tool]:
         """Convert internal BaseTool → genai Tool."""
-        out: List[types.Tool] = []
+        out: list[types.Tool] = []
         for t in tools:
             # Assume t.to_gemini_tool() now correctly returns a FunctionDeclaration
-            # func_decl = t.to_gemini_tool()
-            if isinstance(t, dict):
-                func_decl = t
-            else:
-                func_decl = t.to_gemini_tool()
+            func_decl = t if isinstance(t, dict) else t.to_gemini_tool()
             if not isinstance(func_decl, types.FunctionDeclaration):
                 # Or fetch schema parts if to_gemini_tool still returns dict
                 # This depends on BaseTool.to_gemini_tool implementation
@@ -106,15 +101,15 @@ class GeminiAPI(VendorBase):
 
     async def _gen_content_async(
         self,
-        messages: List[Dict],
+        messages: list[dict],
         temperature: float,
         model_name: str,
         reasoning_effort: str,
-        tools: Optional[List[BaseTool]],
-        lm_config: Optional[Dict[str, Any]],
-    ) -> Tuple[str, Optional[List[Dict]]]:
+        tools: list[BaseTool] | None,
+        lm_config: dict[str, Any] | None,
+    ) -> tuple[str, list[dict] | None]:
         model_name = self.get_aliased_model_name(model_name)
-        cfg_kwargs: Dict[str, Any] = {"temperature": temperature}
+        cfg_kwargs: dict[str, Any] = {"temperature": temperature}
         if model_name in GEMINI_REASONING_MODELS and reasoning_effort in GEMINI_THINKING_BUDGETS:
             cfg_kwargs["thinking_config"] = types.ThinkingConfig(
                 thinking_budget=GEMINI_THINKING_BUDGETS[reasoning_effort]
@@ -141,15 +136,15 @@ class GeminiAPI(VendorBase):
 
     def _gen_content_sync(
         self,
-        messages: List[Dict],
+        messages: list[dict],
         temperature: float,
         model_name: str,
         reasoning_effort: str,
-        tools: Optional[List[BaseTool]],
-        lm_config: Optional[Dict[str, Any]],
-    ) -> Tuple[str, Optional[List[Dict]]]:
+        tools: list[BaseTool] | None,
+        lm_config: dict[str, Any] | None,
+    ) -> tuple[str, list[dict] | None]:
         model_name = self.get_aliased_model_name(model_name)
-        cfg_kwargs: Dict[str, Any] = {"temperature": temperature}
+        cfg_kwargs: dict[str, Any] = {"temperature": temperature}
         if model_name in GEMINI_REASONING_MODELS and reasoning_effort in GEMINI_THINKING_BUDGETS:
             cfg_kwargs["thinking_config"] = types.ThinkingConfig(
                 thinking_budget=GEMINI_THINKING_BUDGETS[reasoning_effort]
@@ -174,7 +169,7 @@ class GeminiAPI(VendorBase):
         return self._extract(resp)
 
     @staticmethod
-    def _extract(response) -> Tuple[str, Optional[List[Dict]]]:
+    def _extract(response) -> tuple[str, list[dict] | None]:
         # Extract text, handling cases where it might be missing
         try:
             text = response.text
@@ -208,13 +203,13 @@ class GeminiAPI(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,
+        tools: list[BaseTool] | None = None,
     ) -> 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)
@@ -257,13 +252,13 @@ class GeminiAPI(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,
+        tools: list[BaseTool] | None = None,
     ) -> 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)

synth_ai/lm/vendors/core/mistral_api.py

@@ -1,30 +1,30 @@
 import json
 import os
-from typing import Any, Dict, List, Optional, Tuple, Type
+from typing import Any
 
 import pydantic
 from mistralai import Mistral  # use Mistral as both sync and async client
 from pydantic import BaseModel
 
 from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
 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
 from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
 
 # Since the mistralai package doesn't expose an exceptions module,
 # we fallback to catching all Exceptions for retry.
-MISTRAL_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (Exception,)
+MISTRAL_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (Exception,)
 
 
 class MistralAPI(VendorBase):
     used_for_structured_outputs: bool = True
-    exceptions_to_retry: Tuple = MISTRAL_EXCEPTIONS_TO_RETRY
+    exceptions_to_retry: tuple = MISTRAL_EXCEPTIONS_TO_RETRY
     _openai_fallback: Any
 
     def __init__(
         self,
-        exceptions_to_retry: Tuple[Type[Exception], ...] = MISTRAL_EXCEPTIONS_TO_RETRY,
+        exceptions_to_retry: tuple[type[Exception], ...] = MISTRAL_EXCEPTIONS_TO_RETRY,
         used_for_structured_outputs: bool = False,
     ):
         self.used_for_structured_outputs = used_for_structured_outputs
@@ -40,14 +40,14 @@ class MistralAPI(VendorBase):
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        response_model: Optional[BaseModel] = None,
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
+        response_model: BaseModel | None = None,
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> 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"
         )
         assert not (response_model and tools), "Cannot provide both response_model and tools"
@@ -63,7 +63,7 @@ class MistralAPI(VendorBase):
             ], f"Expected BaseLMResponse or str, got {type(cache_result)}"
             return (
                 cache_result
-                if type(cache_result) == BaseLMResponse
+                if isinstance(cache_result, BaseLMResponse)
                 else BaseLMResponse(
                     raw_response=cache_result, structured_output=None, tool_calls=None
                 )
@@ -130,14 +130,14 @@ class MistralAPI(VendorBase):
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        response_model: Optional[BaseModel] = None,
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
+        response_model: BaseModel | None = None,
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> 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"
         )
         assert not (response_model and tools), "Cannot provide both response_model and tools"
@@ -154,7 +154,7 @@ class MistralAPI(VendorBase):
             ], f"Expected BaseLMResponse or str, got {type(cache_result)}"
             return (
                 cache_result
-                if type(cache_result) == BaseLMResponse
+                if isinstance(cache_result, BaseLMResponse)
                 else BaseLMResponse(
                     raw_response=cache_result, structured_output=None, tool_calls=None
                 )
@@ -217,7 +217,7 @@ class MistralAPI(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,
@@ -256,7 +256,7 @@ class MistralAPI(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,

synth_ai/lm/vendors/core/openai_api.py

@@ -6,7 +6,8 @@ supporting both standard and structured output modes.
 """
 
 import json
-from typing import Any, Dict, List, Optional, Tuple, Type
+import os
+from typing import Any
 
 import openai
 import pydantic_core
@@ -15,13 +16,13 @@ import pydantic_core
 from pydantic import BaseModel
 
 from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.constants import OPENAI_REASONING_MODELS, SPECIAL_BASE_TEMPS
 from synth_ai.lm.tools.base import BaseTool
 from synth_ai.lm.vendors.base import BaseLMResponse
-from synth_ai.lm.constants import SPECIAL_BASE_TEMPS, OPENAI_REASONING_MODELS
 from synth_ai.lm.vendors.openai_standard import OpenAIStandard
 
 # Exceptions that should trigger retry logic for OpenAI API calls
-OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
+OPENAI_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (
     pydantic_core._pydantic_core.ValidationError,
     openai.OpenAIError,
     openai.APIConnectionError,
@@ -36,33 +37,61 @@ OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
 class OpenAIStructuredOutputClient(OpenAIStandard):
     """
     OpenAI client with support for structured outputs.
-    
+
     This client extends the standard OpenAI client to support structured outputs
     using OpenAI's native structured output feature or response format parameter.
     """
+
     def __init__(self, synth_logging: bool = True):
-        if synth_logging:
+        # Check if we should use Synth clients instead of OpenAI
+        openai_base = os.getenv("OPENAI_API_BASE", "")
+        use_synth = (openai_base.startswith("https://synth") or
+                    openai_base.startswith("https://agent-learning") or
+                    os.getenv("SYNTH_BASE_URL") or os.getenv("MODAL_BASE_URL"))
+
+        if use_synth:
+            # Use Synth clients for Synth endpoints
+            from synth_ai.lm.vendors.synth_client import AsyncSynthClient, SyncSynthClient
+            from synth_ai.lm.config import SynthConfig
+
+            # Create config from OPENAI_* environment variables if available
+            openai_base = os.getenv("OPENAI_API_BASE")
+            openai_key = os.getenv("OPENAI_API_KEY")
+
+            if openai_base and openai_key:
+                config = SynthConfig(base_url=openai_base, api_key=openai_key)
+                sync_client = SyncSynthClient(config)
+                async_client = AsyncSynthClient(config)
+            else:
+                # Fall back to default config loading
+                sync_client = SyncSynthClient()
+                async_client = AsyncSynthClient()
+        elif synth_logging:
             # print("Using synth logging - OpenAIStructuredOutputClient")
             from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
+            sync_client = OpenAI()
+            async_client = AsyncOpenAI()
         else:
             # print("Not using synth logging - OpenAIStructuredOutputClient")
             from openai import AsyncOpenAI, OpenAI
+            sync_client = OpenAI()
+            async_client = AsyncOpenAI()
 
         super().__init__(
             used_for_structured_outputs=True,
             exceptions_to_retry=OPENAI_EXCEPTIONS_TO_RETRY,
-            sync_client=OpenAI(),
-            async_client=AsyncOpenAI(),
+            sync_client=sync_client,
+            async_client=async_client,
         )
 
     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,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
         reasoning_effort: str = "high",
     ) -> str:
         if tools:
@@ -81,7 +110,7 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
                 dict,
                 BaseLMResponse,
             ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return cache_result["response"] if type(cache_result) == dict else cache_result
+            return cache_result["response"] if isinstance(cache_result, dict) else cache_result
         if model in OPENAI_REASONING_MODELS:
             output = await self.async_client.beta.chat.completions.parse(
                 model=model,
@@ -109,11 +138,11 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
     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,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
         reasoning_effort: str = "high",
     ) -> str:
         if tools:
@@ -130,7 +159,7 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
                 dict,
                 BaseLMResponse,
             ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return cache_result["response"] if type(cache_result) == dict else cache_result
+            return cache_result["response"] if isinstance(cache_result, dict) else cache_result
         if model in OPENAI_REASONING_MODELS:
             output = self.sync_client.beta.chat.completions.parse(
                 model=model,