synth-ai 0.1.0.dev36__py3-none-any.whl → 0.1.0.dev38__py3-none-any.whl

public_tests/test_reasoning_effort.py

@@ -0,0 +1,75 @@
+import asyncio
+import pytest
+from synth_ai.zyk.lms.core.main import LM
+FORMATTING_MODEL_NAME = "gpt-4o-mini"
+
+# List of reasoning models to test
+# Note: Ensure these models are correctly configured and accessible in your environment
+# And that they are included in REASONING_MODELS in main.py
+REASONING_MODELS_TO_TEST = [
+    "o4-mini",
+    "claude-3-7-sonnet-latest",
+    "gemini-2.5-pro"
+]
+
+# Define effort levels (adjust if specific models use different terms)
+EFFORT_LEVELS = ["low", "medium", "high"]
+
+@pytest.mark.parametrize("model_name", REASONING_MODELS_TO_TEST)
+@pytest.mark.parametrize("effort", EFFORT_LEVELS)
+@pytest.mark.asyncio
+async def test_reasoning_effort_levels(model_name, effort):
+    """
+    Tests that the reasoning_effort parameter is accepted and calls succeed for various models and levels.
+    Note: This test primarily checks for successful API calls across effort levels.
+    Comparing output length or quality based on 'effort' is complex and model-specific.
+    Anthropic's 'thinking' budget might correlate, but OpenAI/others might handle 'effort' differently or ignore it.
+    """
+    print(f"\nTesting model: {model_name} with effort: {effort}")
+    lm = LM(
+        model_name=model_name,
+        formatting_model_name=FORMATTING_MODEL_NAME,
+        temperature=0,
+    )
+
+    system_prompt = "You are a helpful assistant designed to explain complex topics simply."
+    user_prompt = f"Explain the concept of quantum entanglement step by step using a simple analogy. Be concise if effort is low, detailed if high. Current effort: {effort}."
+
+    try:
+        result = await lm.respond_async(
+            system_message=system_prompt,
+            user_message=user_prompt,
+            reasoning_effort=effort, # Pass the effort level
+        )
+
+        response = result.raw_response
+
+        # Assert call succeeded and response is non-empty
+        assert isinstance(response, str), f"Model {model_name} (effort={effort}) failed. Response type: {type(response)}"
+        assert len(response) > 0, f"Model {model_name} (effort={effort}): Response is empty."
+
+        print(f"  Response length (effort={effort}): {len(response)}")
+        # print(f"  Response snippet: {response[:100]}...") # Optional: print snippet
+
+    except Exception as e:
+        pytest.fail(f"Model {model_name} (effort={effort}) raised an exception: {e}")
+
+# Optional: Add a separate test to compare lengths between low and high effort for specific models if needed.
+
+if __name__ == "__main__":
+    async def main():
+        print("Running effort tests directly...")
+        test_models = REASONING_MODELS_TO_TEST
+        effort_levels_to_run = EFFORT_LEVELS
+
+        all_tasks = []
+        for model in test_models:
+            for effort_level in effort_levels_to_run:
+                 # Create a task for each combination
+                 all_tasks.append(test_reasoning_effort_levels(model, effort_level))
+
+        # Run all tests concurrently (be mindful of rate limits)
+        await asyncio.gather(*all_tasks)
+        print("\nTest run finished.")
+
+    asyncio.run(main()) 

synth_ai/zyk/lms/caching/handler.py

@@ -18,6 +18,8 @@ def map_params_to_key(
     temperature: float,
     response_model: Optional[Type[BaseModel]],
     tools: Optional[List] = None,
+    reasoning_effort: Optional[str] = None,
+    max_tokens: Optional[int] = None,
 ) -> str:
     if not all([isinstance(msg["content"], str) for msg in messages]):
         normalized_messages = "".join([str(msg["content"]) for msg in messages])
@@ -26,6 +28,8 @@ def map_params_to_key(
     normalized_model = model
     normalized_temperature = f"{temperature:.2f}"[:4]
     normalized_response_model = str(response_model.schema()) if response_model else ""
+    normalized_reasoning_effort = str(reasoning_effort) if reasoning_effort is not None else ""
+    normalized_max_tokens = str(max_tokens) if max_tokens is not None else ""
 
     # Normalize tools if present
     normalized_tools = ""
@@ -57,6 +61,8 @@ def map_params_to_key(
             + normalized_temperature
             + normalized_response_model
             + normalized_tools
+            + normalized_reasoning_effort
+            + normalized_max_tokens
         ).encode()
     ).hexdigest()
 
@@ -83,6 +89,7 @@ class CacheHandler:
         messages: List[Dict[str, Any]],
         lm_config: Dict[str, Any],
         tools: Optional[List] = None,
+        reasoning_effort: Optional[str] = None,
     ) -> Optional[BaseLMResponse]:
         """Hit the cache with the given key."""
         self._validate_messages(messages)
@@ -93,6 +100,8 @@ class CacheHandler:
             lm_config.get("temperature", 0.0),
             lm_config.get("response_model", None),
             tools,
+            reasoning_effort,
+            lm_config.get("max_tokens"),
         )
         if self.use_persistent_store:
             return persistent_cache.hit_cache(
@@ -112,6 +121,7 @@ class CacheHandler:
         lm_config: Dict[str, Any],
         output: BaseLMResponse,
         tools: Optional[List] = None,
+        reasoning_effort: Optional[str] = None,
     ) -> None:
         """Add the given output to the cache."""
         self._validate_messages(messages)
@@ -123,6 +133,8 @@ class CacheHandler:
             lm_config.get("temperature", 0.0),
             lm_config.get("response_model", None),
             tools,
+            reasoning_effort,
+            lm_config.get("max_tokens"),
         )
         if self.use_persistent_store:
             persistent_cache.add_to_cache(key, output)

synth_ai/zyk/lms/core/main.py

@@ -11,7 +11,7 @@ from synth_ai.zyk.lms.core.vendor_clients import (
 from synth_ai.zyk.lms.structured_outputs.handler import StructuredOutputHandler
 from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
 
-REASONING_MODELS = ["deepseek-reasoner", "o1-mini", "o1-preview", "o1", "o3"]
+REASONING_MODELS = ["deepseek-reasoner", "o1-mini", "o1-preview", "o1", "o3", "o4-mini", "claude-3-7-latest-thinking", "gemini-1.5-pro-latest"]
 
 
 def build_messages(
@@ -92,18 +92,33 @@ class LM:
         )
         # print(self.client.__class__)
 
+        # Determine if the primary model supports forced JSON or specific formatting modes
+       # primary_model_supports_forced_json = self.client.supports_forced_json()
+
+        # Choose the structured output mode based on primary model capability
+        # effective_structured_output_mode = structured_output_mode
+        # if not primary_model_supports_forced_json and structured_output_mode == "forced_json":
+        #     # Fallback or adjust if the primary model doesn't support the desired mode
+        #     # For simplicity, let's assume we might want to fallback to stringified_json or handle differently
+        #     # print(f"Warning: Model {model_name} does not support forced_json. Adjusting strategy.")
+        #     effective_structured_output_mode = "stringified_json" # Example fallback
+
+
         formatting_client = get_client(formatting_model_name, with_formatting=True)
 
+
         max_retries_dict = {"None": 0, "Few": 2, "Many": 5}
+        # Use the effective mode for the primary handler
         self.structured_output_handler = StructuredOutputHandler(
             self.client,
             formatting_client,
-            structured_output_mode,
+            structured_output_mode, # Use original mode
             {"max_retries": max_retries_dict.get(max_retries, 2)},
         )
+         # Always have a forced_json backup handler ready
         self.backup_structured_output_handler = StructuredOutputHandler(
-            self.client,
-            formatting_client,
+            self.client, # This should ideally use a client capable of forced_json if primary isn't
+            formatting_client, # Formatting client must support forced_json
             "forced_json",
             {"max_retries": max_retries_dict.get(max_retries, 2)},
         )
@@ -121,6 +136,7 @@ class LM:
         response_model: Optional[BaseModel] = None,
         use_ephemeral_cache_only: bool = False,
         tools: Optional[List] = None,
+        reasoning_effort: Optional[str] = None,
     ) -> BaseLMResponse:
         assert (system_message is None) == (
             user_message is None
@@ -131,6 +147,14 @@ class LM:
         assert not (
             response_model and tools
         ), "Cannot provide both response_model and tools"
+
+        current_lm_config = self.lm_config.copy()
+        if self.model_name in REASONING_MODELS:
+            # Removed logic that set max_tokens based on reasoning_tokens
+            # Vendor clients will now receive reasoning_effort directly
+            pass
+
+
         if messages is None:
             messages = build_messages(
                 system_message, user_message, images_as_bytes, self.model_name
@@ -139,28 +163,31 @@ class LM:
         if response_model:
             try:
                 result = self.structured_output_handler.call_sync(
-                    messages,
+                    messages=messages,
                     model=self.model_name,
-                    lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    lm_config=current_lm_config,
+                    reasoning_effort=reasoning_effort,
                 )
             except StructuredOutputCoercionFailureException:
                 # print("Falling back to backup handler")
                 result = self.backup_structured_output_handler.call_sync(
-                    messages,
+                    messages=messages,
                     model=self.model_name,
-                    lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    lm_config=current_lm_config,
+                    reasoning_effort=reasoning_effort,
                 )
         else:
             result = self.client._hit_api_sync(
                 messages=messages,
                 model=self.model_name,
-                lm_config=self.lm_config,
+                lm_config=current_lm_config,
                 use_ephemeral_cache_only=use_ephemeral_cache_only,
                 tools=tools,
+                reasoning_effort=reasoning_effort,
             )
         assert isinstance(result.raw_response, str), "Raw response must be a string"
         assert (
@@ -181,6 +208,7 @@ class LM:
         response_model: Optional[BaseModel] = None,
         use_ephemeral_cache_only: bool = False,
         tools: Optional[List] = None,
+        reasoning_effort: Optional[str] = None,
     ) -> BaseLMResponse:
         # "In respond_async")
         assert (system_message is None) == (
@@ -193,6 +221,13 @@ class LM:
         assert not (
             response_model and tools
         ), "Cannot provide both response_model and tools"
+
+        current_lm_config = self.lm_config.copy()
+        if self.model_name in REASONING_MODELS:
+            # Removed logic that set max_tokens based on reasoning_tokens
+            # Vendor clients will now receive reasoning_effort directly
+            pass
+
         if messages is None:
             messages = build_messages(
                 system_message, user_message, images_as_bytes, self.model_name
@@ -202,29 +237,32 @@ class LM:
             try:
                 # print("Trying structured output handler")
                 result = await self.structured_output_handler.call_async(
-                    messages,
+                    messages=messages,
                     model=self.model_name,
-                    lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    lm_config=current_lm_config,
+                    reasoning_effort=reasoning_effort,
                 )
             except StructuredOutputCoercionFailureException:
                 # print("Falling back to backup handler")
                 result = await self.backup_structured_output_handler.call_async(
-                    messages,
+                    messages=messages,
                     model=self.model_name,
-                    lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    lm_config=current_lm_config,
+                    reasoning_effort=reasoning_effort,
                 )
         else:
             # print("Calling API no response model")
             result = await self.client._hit_api_async(
                 messages=messages,
                 model=self.model_name,
-                lm_config=self.lm_config,
+                lm_config=current_lm_config,
                 use_ephemeral_cache_only=use_ephemeral_cache_only,
                 tools=tools,
+                reasoning_effort=reasoning_effort,
             )
         assert isinstance(result.raw_response, str), "Raw response must be a string"
         assert (

synth_ai/zyk/lms/structured_outputs/handler.py

@@ -429,6 +429,7 @@ class StructuredOutputHandler:
         lm_config: Dict[str, Any] = {},
         reasoning_effort: str = "high",
     ) -> BaseLMResponse:
+        # print("Output handler call sync")
         return self.handler.call_sync(
             messages=messages,
             model=model,

synth_ai/zyk/lms/vendors/core/anthropic_api.py

@@ -17,8 +17,8 @@ ANTHROPIC_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (anthropic.APIError
 
 
 sonnet_37_budgets = {
-    "high": 4000,
-    "medium": 2000,
+    "high": 8000,
+    "medium": 4000,
     "low": 1000,
 }
 
@@ -64,7 +64,7 @@ class AnthropicAPI(VendorBase):
         ), "response_model is not supported for standard calls"
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
+            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
         )
         if cache_result:
             return cache_result
@@ -135,7 +135,7 @@ class AnthropicAPI(VendorBase):
         )
 
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
         )
         return lm_response
 
@@ -162,7 +162,7 @@ class AnthropicAPI(VendorBase):
             use_ephemeral_cache_only=use_ephemeral_cache_only
         )
         cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
+            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
         )
         if cache_result:
             return cache_result
@@ -235,7 +235,7 @@ class AnthropicAPI(VendorBase):
         )
 
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
         )
         return lm_response
 
@@ -249,6 +249,17 @@ class AnthropicAPI(VendorBase):
         reasoning_effort: str = "high",
         **vendor_params: Dict[str, Any],
     ) -> BaseLMResponse:
+        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
+        lm_config = {"temperature": temperature, "response_model": response_model}
+        cache_result = used_cache_handler.hit_managed_cache(
+            model=model,
+            messages=messages,
+            lm_config=lm_config,
+            reasoning_effort=reasoning_effort,
+        )
+        if cache_result:
+            return cache_result
+        
         try:
             # First try with Anthropic
             reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
@@ -283,6 +294,13 @@ class AnthropicAPI(VendorBase):
                 structured_output=response_model(**parsed),
                 tool_calls=None,
             )
+            used_cache_handler.add_to_managed_cache(
+                model=model,
+                messages=messages,
+                lm_config=lm_config,
+                output=lm_response,
+                reasoning_effort=reasoning_effort,
+            )
             return lm_response
         except (json.JSONDecodeError, pydantic.ValidationError):
             # If Anthropic fails, fallback to OpenAI
@@ -306,6 +324,17 @@ class AnthropicAPI(VendorBase):
         reasoning_effort: str = "high",
         **vendor_params: Dict[str, Any],
     ) -> BaseLMResponse:
+        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
+        lm_config = {"temperature": temperature, "response_model": response_model}
+        cache_result = used_cache_handler.hit_managed_cache(
+            model=model,
+            messages=messages,
+            lm_config=lm_config,
+            reasoning_effort=reasoning_effort,
+        )
+        if cache_result:
+            return cache_result
+
         try:
             # First try with Anthropic
             reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
@@ -342,6 +371,13 @@ class AnthropicAPI(VendorBase):
                 structured_output=response_model(**parsed),
                 tool_calls=None,
             )
+            used_cache_handler.add_to_managed_cache(
+                model=model,
+                messages=messages,
+                lm_config=lm_config,
+                output=lm_response,
+                reasoning_effort=reasoning_effort,
+            )
             return lm_response
         except (json.JSONDecodeError, pydantic.ValidationError):
             # If Anthropic fails, fallback to OpenAI

synth_ai/zyk/lms/vendors/core/gemini_api.py

@@ -111,6 +111,9 @@ class GeminiAPI(VendorBase):
         generation_config = {
             "temperature": temperature,
         }
+        # Add max_output_tokens if max_tokens is in lm_config
+        if lm_config and "max_tokens" in lm_config:
+            generation_config["max_output_tokens"] = lm_config["max_tokens"]
 
         tools_config = None
         if tools:
@@ -167,6 +170,9 @@ class GeminiAPI(VendorBase):
         generation_config = {
             "temperature": temperature,
         }
+        # Add max_output_tokens if max_tokens is in lm_config
+        if lm_config and "max_tokens" in lm_config:
+            generation_config["max_output_tokens"] = lm_config["max_tokens"]
 
         tools_config = None
         if tools:
@@ -231,7 +237,7 @@ class GeminiAPI(VendorBase):
         ), "response_model is not supported for standard calls"
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
+            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
         )
         if cache_result:
             return cache_result
@@ -250,7 +256,7 @@ class GeminiAPI(VendorBase):
         )
 
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
         )
         return lm_response
 
@@ -276,7 +282,7 @@ class GeminiAPI(VendorBase):
             use_ephemeral_cache_only=use_ephemeral_cache_only
         )
         cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
+            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
         )
         if cache_result:
             return cache_result
@@ -295,6 +301,6 @@ class GeminiAPI(VendorBase):
         )
 
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
         )
         return lm_response

synth_ai/zyk/lms/vendors/core/openai_api.py

@@ -10,7 +10,7 @@ from pydantic import BaseModel
 from synth_ai.zyk.lms.caching.initialize import get_cache_handler
 from synth_ai.zyk.lms.tools.base import BaseTool
 from synth_ai.zyk.lms.vendors.base import BaseLMResponse
-from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS
+from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS, openai_reasoners
 from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
 
 OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
@@ -70,21 +70,20 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
             return (
                 cache_result["response"] if type(cache_result) == dict else cache_result
             )
-        if model in ["o3-mini", "o3", "o1-mini", "o1"]:
-            output = await self.async_client.beta.chat.completions.parse(
+        if model in openai_reasoners:
+            output = await self.async_client.chat.completions.create(
                 model=model,
                 messages=messages,
-                temperature=lm_config.get(
-                    "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-                ),
-                response_format=response_model,
-                reasoning_effort=reasoning_effort,
+                temperature=temperature,
+                tools=tools,
+                max_completion_tokens=lm_config.get("max_tokens"),
             )
         else:
-            output = await self.async_client.beta.chat.completions.parse(
+            output = await self.async_client.chat.completions.create(
                 model=model,
                 messages=messages,
-                response_format=response_model,
+                temperature=temperature,
+                max_tokens=lm_config.get("max_tokens"),
             )
         # "Output", output)
         api_result = response_model(**json.loads(output.choices[0].message.content))
@@ -126,20 +125,19 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
                 cache_result["response"] if type(cache_result) == dict else cache_result
             )
         if model in ["o3-mini", "o3", "o1-mini", "o1"]:
-            output = self.sync_client.beta.chat.completions.parse(
+            output = self.sync_client.chat.completions.create(
                 model=model,
                 messages=messages,
-                temperature=lm_config.get(
-                    "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-                ),
-                response_format=response_model,
-                reasoning_effort=reasoning_effort,
+                temperature=temperature,
+                tools=tools,
+                max_tokens=lm_config.get("max_tokens"),
             )
         else:
-            output = self.sync_client.beta.chat.completions.parse(
+            output = self.sync_client.chat.completions.create(
                 model=model,
                 messages=messages,
-                response_format=response_model,
+                temperature=temperature,
+                max_tokens=lm_config.get("max_tokens"),
             )
         api_result = response_model(**json.loads(output.choices[0].message.content))
 

synth_ai/zyk/lms/vendors/openai_standard.py

@@ -87,7 +87,7 @@ class OpenAIStandard(VendorBase):
         messages = special_orion_transform(model, messages)
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
+            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
         )
         if cache_result:
             return cache_result
@@ -97,6 +97,9 @@ class OpenAIStandard(VendorBase):
             "model": model,
             "messages": messages,
         }
+        # Add max_tokens if present in lm_config
+        if "max_tokens" in lm_config:
+            api_params["max_completion_tokens"] = lm_config["max_tokens"]
 
         # Add tools if provided
         if tools:
@@ -142,7 +145,7 @@ class OpenAIStandard(VendorBase):
             tool_calls=tool_calls,
         )
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
         )
         return lm_response
 
@@ -170,7 +173,7 @@ class OpenAIStandard(VendorBase):
             use_ephemeral_cache_only=use_ephemeral_cache_only
         )
         cache_result = used_cache_handler.hit_managed_cache(
-            model, messages, lm_config=lm_config, tools=tools
+            model, messages, lm_config=lm_config, tools=tools, reasoning_effort=reasoning_effort
         )
         if cache_result:
             return cache_result
@@ -180,6 +183,9 @@ class OpenAIStandard(VendorBase):
             "model": model,
             "messages": messages,
         }
+        # Add max_tokens if present in lm_config
+        if "max_tokens" in lm_config:
+            api_params["max_tokens"] = lm_config["max_tokens"]
 
         # Add tools if provided
         if tools:
@@ -224,7 +230,7 @@ class OpenAIStandard(VendorBase):
             tool_calls=tool_calls,
         )
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools, reasoning_effort=reasoning_effort
         )
         return lm_response
 
@@ -242,7 +248,11 @@ class OpenAIStandard(VendorBase):
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         cache_result: Union[BaseLMResponse, None] = (
             used_cache_handler.hit_managed_cache(
-                model, messages, lm_config=lm_config, tools=tools
+                model,
+                messages,
+                lm_config=lm_config,
+                tools=tools,
+                reasoning_effort=reasoning_effort,
             )
         )
         if cache_result is not None:
@@ -285,7 +295,12 @@ class OpenAIStandard(VendorBase):
             tool_calls=tool_calls,
         )
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model,
+            messages,
+            lm_config=lm_config,
+            output=lm_response,
+            tools=tools,
+            reasoning_effort=reasoning_effort,
         )
         return lm_response
 
@@ -303,7 +318,11 @@ class OpenAIStandard(VendorBase):
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         cache_result: Union[BaseLMResponse, None] = (
             used_cache_handler.hit_managed_cache(
-                model, messages, lm_config=lm_config, tools=tools
+                model,
+                messages,
+                lm_config=lm_config,
+                tools=tools,
+                reasoning_effort=reasoning_effort,
             )
         )
         if cache_result is not None:
@@ -346,6 +365,11 @@ class OpenAIStandard(VendorBase):
             tool_calls=tool_calls,
         )
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+            model,
+            messages,
+            lm_config=lm_config,
+            output=lm_response,
+            tools=tools,
+            reasoning_effort=reasoning_effort,
         )
         return lm_response

{synth_ai-0.1.0.dev36.dist-info → synth_ai-0.1.0.dev38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: synth-ai
-Version: 0.1.0.dev36
+Version: 0.1.0.dev38
 Summary: Software for aiding the best and multiplying the will.
 Author: Josh Purtell
 Author-email: Josh Purtell <josh@usesynth.ai>

{synth_ai-0.1.0.dev36.dist-info → synth_ai-0.1.0.dev38.dist-info}/RECORD

@@ -8,6 +8,7 @@ public_tests/test_gemini_output.py,sha256=704NCnxNepYjUxJj3eEms6zHRCps2PSaR8A-lc
 public_tests/test_gemini_structured_outputs.py,sha256=yKa3CDVJxE_Vb2BbVROje83Pb35MBusF0Nb-ttWbqS8,4001
 public_tests/test_models.py,sha256=QGevBfBuQzwyKw1ez34igDyJpMTBVOc3meW6yqFE-bM,5853
 public_tests/test_openai_structured_outputs.py,sha256=oIhdZ2QVLmn0LaqBpCP3Qhbn2KHJv633DGn6u9Ousak,3999
+public_tests/test_reasoning_effort.py,sha256=w4dIiEaEU8gnfAmjrpCC5y-c9w-eH9NzFjwUHe2deyg,3089
 public_tests/test_reasoning_models.py,sha256=Vr4sFRYcrYOBAZMFz2a0fZQqa-WjRwbtwc6lXy6bF4I,2897
 public_tests/test_recursive_structured_outputs.py,sha256=rrqzsU5ExNt-m_wu9j_fkbHiEsAtbKEK66uK5Ub2ojs,6296
 public_tests/test_structured.py,sha256=rftVwvYgMSHkRZM1WUJzga5Uvl9hmc5OpXzBshEXNF0,3740
@@ -23,32 +24,32 @@ synth_ai/zyk/lms/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 synth_ai/zyk/lms/caching/constants.py,sha256=fPi3x9p-yRdvixMSIyclvmwmwCRliXLXQjEm6dRnG8s,52
 synth_ai/zyk/lms/caching/dbs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synth_ai/zyk/lms/caching/ephemeral.py,sha256=pNMG5Rzzp2m0Ln1UYmWxz1qbXwq3iNIrhjYAS0yO3ZE,2370
-synth_ai/zyk/lms/caching/handler.py,sha256=a-4FBxXLWeHCXiGDWP8QU-LPxMAvGbJ_5lUrXnZytn0,4478
+synth_ai/zyk/lms/caching/handler.py,sha256=4h4Kywf0_-WohE1RxBt4cqPo-kHRjZv-2K50WWO91V4,5050
 synth_ai/zyk/lms/caching/initialize.py,sha256=zZls6RKAax6Z-8oJInGaSg_RPN_fEZ6e_RCX64lMLJw,416
 synth_ai/zyk/lms/caching/persistent.py,sha256=ZaY1A9qhvfNKzcAI9FnwbIrgMKvVeIfb_yCyl3M8dxE,2860
 synth_ai/zyk/lms/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synth_ai/zyk/lms/core/all.py,sha256=wakK0HhvYRuaQZmxClURyNf3vUkTbm3OABw3TgpMjOQ,1185
 synth_ai/zyk/lms/core/exceptions.py,sha256=K0BVdAzxVIchsvYZAaHEH1GAWBZvpxhFi-SPcJOjyPQ,205
-synth_ai/zyk/lms/core/main.py,sha256=kKxk-1TZQMNXDrLv7qA42fNOsXes-G9kLtNg-LtrpYY,10370
+synth_ai/zyk/lms/core/main.py,sha256=NNPd4wwpgscFtCCrVPgz6gcrg7kOTSKsBFhldV0kwv0,12502
 synth_ai/zyk/lms/core/vendor_clients.py,sha256=C4ICuczCG2yRpDbrraT0LUoaPFYytuetfJLqhgvGn8A,2785
 synth_ai/zyk/lms/cost/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synth_ai/zyk/lms/cost/monitor.py,sha256=cSKIvw6WdPZIRubADWxQoh1MdB40T8-jjgfNUeUHIn0,5
 synth_ai/zyk/lms/cost/statefulness.py,sha256=TOsuXL8IjtKOYJ2aJQF8TwJVqn_wQ7AIwJJmdhMye7U,36
 synth_ai/zyk/lms/structured_outputs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synth_ai/zyk/lms/structured_outputs/handler.py,sha256=BQ0T4HBFXC9qesF8v0lG8MuiOecWm2YEF75nUt1mB_s,16925
+synth_ai/zyk/lms/structured_outputs/handler.py,sha256=Y7qQ8VReofLKDX6M7L5OXBUmTyHw6bWEfYz0jqvQIZ0,16969
 synth_ai/zyk/lms/structured_outputs/inject.py,sha256=Fy-zDeleRxOZ8ZRM6IuZ6CP2XZnMe4K2PEn4Q9c_KPY,11777
 synth_ai/zyk/lms/structured_outputs/rehabilitate.py,sha256=GuIhzsb7rTvwgn7f9I9omNnXBz5Me_qrtNYcTWzw5_U,7909
 synth_ai/zyk/lms/tools/base.py,sha256=j7wYb1xAvaAm3qVrINphgUhGS-UjZmRpbouseQYgh7A,3228
 synth_ai/zyk/lms/vendors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synth_ai/zyk/lms/vendors/base.py,sha256=aK4PEtkMLt_o3qD22kW-x3HJUEKdIk06zlH4kX0VkAE,760
 synth_ai/zyk/lms/vendors/constants.py,sha256=3CCq45otD80yaLts5sFHvPgLCQNkcjHkc9cqOQ0zH4Y,320
-synth_ai/zyk/lms/vendors/openai_standard.py,sha256=oii23QtG_sh_V2yFV1ZMF7F0t9Q_mGL8yM_QxZnZ9QA,12091
+synth_ai/zyk/lms/vendors/openai_standard.py,sha256=A8fRaazdaccFW24De2dDyiH2kdjhf9SAlQhLmAQuZjA,12934
 synth_ai/zyk/lms/vendors/retries.py,sha256=m-WvAiPix9ovnO2S-m53Td5VZDWBVBFuHuSK9--OVxw,38
 synth_ai/zyk/lms/vendors/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synth_ai/zyk/lms/vendors/core/anthropic_api.py,sha256=vxANYEcU46n6flRJ4y5j4VrSA1ky4EXo8nWgYPLi3HU,13829
-synth_ai/zyk/lms/vendors/core/gemini_api.py,sha256=I1goLy5R8eBLrun2jpnD4o87NlmzWgPrfYaeu9RZN8M,11008
+synth_ai/zyk/lms/vendors/core/anthropic_api.py,sha256=cgSPFgR9YM8eO1if92fch6pVv0Dxk3xigSXExGSdu-4,15329
+synth_ai/zyk/lms/vendors/core/gemini_api.py,sha256=gsWudX1RP2a4mjuyWZXT3LUek-UMUYhCfE5TMYxp0nA,11530
 synth_ai/zyk/lms/vendors/core/mistral_api.py,sha256=-EMPBEIoYxxDMxukmcmKL8AGAHPNYe4w-76gsPtmrhk,11860
-synth_ai/zyk/lms/vendors/core/openai_api.py,sha256=QkQqba851EEGf9n5H31-pJ6WexhTZkdPWQap0oGy2Ho,6713
+synth_ai/zyk/lms/vendors/core/openai_api.py,sha256=GDCHIc0kpCnNPj2oW8RE3Cj2U_HcbXzzA5JV1ArAQlE,6600
 synth_ai/zyk/lms/vendors/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synth_ai/zyk/lms/vendors/local/ollama.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synth_ai/zyk/lms/vendors/supported/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,11 +57,11 @@ synth_ai/zyk/lms/vendors/supported/deepseek.py,sha256=BElW0NGpkSA62wOqzzMtDw8XR3
 synth_ai/zyk/lms/vendors/supported/groq.py,sha256=Fbi7QvhdLx0F-VHO5PY-uIQlPR0bo3C9h1MvIOx8nz0,388
 synth_ai/zyk/lms/vendors/supported/ollama.py,sha256=K30VBFRTd7NYyPmyBVRZS2sm0UB651AHp9i3wd55W64,469
 synth_ai/zyk/lms/vendors/supported/together.py,sha256=Ni_jBqqGPN0PkkY-Ew64s3gNKk51k3FCpLSwlNhKbf0,342
-synth_ai-0.1.0.dev36.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
+synth_ai-0.1.0.dev38.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
 tests/test_agent.py,sha256=CjPPWuMWC_TzX1DkDald-bbAxgjXE-HPQvFhq2B--5k,22363
 tests/test_recursive_structured_outputs.py,sha256=Ne-9XwnOxN7eSpGbNHOpegR-sRj589I84T6y8Z_4QnA,5781
 tests/test_structured_outputs.py,sha256=J7sfbGZ7OeB5ONIKpcCTymyayNyAdFfGokC1bcUrSx0,3651
-synth_ai-0.1.0.dev36.dist-info/METADATA,sha256=xID7XqBdy-n664hgNBaNRhVTaot5fLUlTBVJiVVqvjw,2702
-synth_ai-0.1.0.dev36.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-synth_ai-0.1.0.dev36.dist-info/top_level.txt,sha256=5GzJO9j-KbJ_4ppxhmCUa_qdhHM4-9cHHNU76yAI8do,42
-synth_ai-0.1.0.dev36.dist-info/RECORD,,
+synth_ai-0.1.0.dev38.dist-info/METADATA,sha256=JHm6Ol6dT8wqnCf-Iq3dQJFxII1oFAMFHDkJY9tDm4o,2702
+synth_ai-0.1.0.dev38.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+synth_ai-0.1.0.dev38.dist-info/top_level.txt,sha256=5GzJO9j-KbJ_4ppxhmCUa_qdhHM4-9cHHNU76yAI8do,42
+synth_ai-0.1.0.dev38.dist-info/RECORD,,