synth-ai 0.1.0.dev30__py3-none-any.whl → 0.1.0.dev32__py3-none-any.whl

public_tests/test_gemini_output.py

@@ -0,0 +1,188 @@
+import json
+import logging
+from typing import List
+
+import pytest
+from pydantic import BaseModel, Field
+
+from synth_ai.zyk import LM
+from synth_ai.zyk.lms.tools.base import BaseTool
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+# 1. Define the Tool Input Schema using BaseModel and Field
+class CraftaxToolArgs(BaseModel):
+    instance_id: str = Field(
+        description="The ID of the Craftax instance to interact with"
+    )
+    actions_list: List[str] = Field(
+        description="A sequence of actions to execute in the environment (e.g., ['up', 'left', 'do'])"
+    )
+    service_url: str = Field(description="The URL of the Craftax environment service")
+
+
+# 2. Define the Tool class by extending BaseTool
+class CraftaxTool(BaseTool):
+    name: str = "interact_with_craftax"
+    description: str = "Interacts with the Craftax environment by sending a sequence of actions to the service."
+    arguments = CraftaxToolArgs
+
+    async def execute(self, args: dict):
+        """Mock execution function for testing"""
+        logger.info(
+            f"Would execute actions: {args['actions_list']} for instance {args['instance_id']}"
+        )
+        return {
+            "observation": f"Executed actions: {args['actions_list']}",
+            "reward": 1.0,
+            "done": False,
+            "info": {"achievements": {"collect_wood": True}},
+        }
+
+
+# Helper function to create a simple tool dict (without RepeatedComposite)
+def create_simplified_tool():
+    return {
+        "name": "interact_with_craftax",
+        "description": "Interacts with the Craftax environment by sending a sequence of actions to the service.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "instance_id": {
+                    "type": "string",
+                    "description": "The ID of the Craftax instance to interact with",
+                },
+                "actions_list": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "A sequence of actions to execute in the environment",
+                },
+                "service_url": {
+                    "type": "string",
+                    "description": "The URL of the Craftax environment service",
+                },
+            },
+            "required": ["instance_id", "actions_list", "service_url"],
+        },
+    }
+
+
+# Define test constants
+SYSTEM_MESSAGE = """You are an agent playing Craftax. Your goal is to collect resources.
+You have access to a tool called `interact_with_craftax` to control the agent."""
+
+USER_MESSAGE = """# Map
+## Terrain_underneath_you
+grass
+## Surroundings
+- Tree is 1 steps up
+
+# Inventory
+## Resources
+- wood: 0
+
+Instructions: Collect 1 wood.
+Instance ID: test-instance-123
+Service URL: http://localhost:8002
+
+Make a tool call to execute actions. Do not explain what you're doing."""
+
+
+@pytest.mark.asyncio
+async def test_base_tool_to_json():
+    """Test that a BaseTool can be serialized to JSON in OpenAI and Gemini formats"""
+    tool = CraftaxTool()
+
+    # Test that the tool can be converted to OpenAI format
+    openai_format = tool.to_openai_tool()
+    openai_json = json.dumps(openai_format, indent=2)
+    assert "function" in openai_json
+    assert "interact_with_craftax" in openai_json
+
+    # Test that the tool can be converted to Gemini format
+    gemini_format = tool.to_gemini_tool()
+    gemini_json = json.dumps(gemini_format, indent=2)
+    assert "parameters" in gemini_json
+    assert "interact_with_craftax" in gemini_json
+
+
+@pytest.mark.asyncio
+async def test_simplified_gemini_tool():
+    """Test that a simplified Gemini tool can be serialized to JSON"""
+    simplified_tool = create_simplified_tool()
+    tool_json = json.dumps(simplified_tool, indent=2)
+    assert "parameters" in tool_json
+    assert "interact_with_craftax" in tool_json
+
+
+@pytest.mark.asyncio
+async def test_direct_gemini_tool_call():
+    """Test that calling Gemini with a directly formatted tool works"""
+    lm = LM(
+        model_name="gemini-2-flash",
+        formatting_model_name="gpt-4o-mini",
+        temperature=0,
+        max_retries="Few",
+        synth_logging=True,
+    )
+
+    # Create a direct function-only tool format
+    direct_tool = [create_simplified_tool()]
+
+    # We're expecting this to complete without errors
+    response = await lm.respond_async(
+        system_message=SYSTEM_MESSAGE,
+        user_message=USER_MESSAGE,
+        tools=direct_tool,
+    )
+
+    # Just check we got a response
+    assert response is not None
+    logger.info(f"Response with direct tool format: {response.raw_response}")
+
+    # If there are tool calls, validate basic structure
+    if response.tool_calls:
+        logger.info(f"Tool calls: {response.tool_calls}")
+        # Verify at least one tool call has the right structure
+        assert any("function" in tc for tc in response.tool_calls)
+
+
+@pytest.mark.asyncio
+async def test_base_tool_gemini_call():
+    """Test that calling Gemini with a BaseTool works"""
+    lm = LM(
+        model_name="gemini-2-flash",
+        formatting_model_name="gpt-4o-mini",
+        temperature=0,
+        max_retries="Few",
+        synth_logging=True,
+    )
+
+    # Use our properly defined BaseTool
+    tool = CraftaxTool()
+
+    # We're expecting this to complete without errors
+    response = await lm.respond_async(
+        system_message=SYSTEM_MESSAGE,
+        user_message=USER_MESSAGE,
+        tools=[tool],
+    )
+
+    # Just check we got a response
+    assert response is not None
+    logger.info(f"Response with BaseTool: {response.raw_response}")
+
+    # If there are tool calls, validate basic structure
+    if response.tool_calls:
+        logger.info(f"Tool calls: {response.tool_calls}")
+        # Verify at least one tool call has the right structure
+        assert any("function" in tc for tc in response.tool_calls)
+
+
+if __name__ == "__main__":
+    pytest.main(["-xvs", __file__])

synth_ai/zyk/lms/caching/handler.py

@@ -17,7 +17,7 @@ def map_params_to_key(
     model: str,
     temperature: float,
     response_model: Optional[Type[BaseModel]],
-    tools: Optional[List[BaseTool]] = None,
+    tools: Optional[List] = None,
 ) -> str:
     if not all([isinstance(msg["content"], str) for msg in messages]):
         normalized_messages = "".join([str(msg["content"]) for msg in messages])
@@ -31,12 +31,22 @@ def map_params_to_key(
     normalized_tools = ""
     if tools:
         tool_schemas = []
-        for tool in sorted(tools, key=lambda x: x.name):  # Sort by name for consistency
-            tool_schema = {
-                "name": tool.name,
-                "description": tool.description,
-                "arguments": tool.arguments.schema(),
-            }
+        for tool in tools:
+            tool_schema = {}
+            try:
+                tool_schema = {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "arguments": tool.arguments.model_json_schema(),
+                }
+            except AttributeError:
+                if isinstance(tool, dict) and "name" in tool:
+                    tool_schema = {
+                        "name": tool.get("name", ""),
+                        "description": tool.get("description", ""),
+                        "parameters": tool.get("parameters", {}),
+                    }
+
             tool_schemas.append(str(tool_schema))
         normalized_tools = "".join(tool_schemas)
 
@@ -72,7 +82,7 @@ class CacheHandler:
         model: str,
         messages: List[Dict[str, Any]],
         lm_config: Dict[str, Any],
-        tools: Optional[List[BaseTool]] = None,
+        tools: Optional[List] = None,
     ) -> Optional[BaseLMResponse]:
         """Hit the cache with the given key."""
         self._validate_messages(messages)
@@ -101,7 +111,7 @@ class CacheHandler:
         messages: List[Dict[str, Any]],
         lm_config: Dict[str, Any],
         output: BaseLMResponse,
-        tools: Optional[List[BaseTool]] = None,
+        tools: Optional[List] = None,
     ) -> None:
         """Add the given output to the cache."""
         self._validate_messages(messages)

synth_ai/zyk/lms/core/main.py

@@ -9,8 +9,7 @@ from synth_ai.zyk.lms.core.vendor_clients import (
     openai_naming_regexes,
 )
 from synth_ai.zyk.lms.structured_outputs.handler import StructuredOutputHandler
-from synth_ai.zyk.lms.vendors.base import VendorBase, BaseLMResponse
-from synth_ai.zyk.lms.tools.base import BaseTool
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
 
 REASONING_MODELS = ["deepseek-reasoner", "o1-mini", "o1-preview", "o1", "o3"]
 
@@ -121,7 +120,7 @@ class LM:
         images_as_bytes: List[Any] = [],
         response_model: Optional[BaseModel] = None,
         use_ephemeral_cache_only: bool = False,
-        tools: Optional[List[BaseTool]] = None,
+        tools: Optional[List] = None,
     ) -> BaseLMResponse:
         assert (system_message is None) == (
             user_message is None
@@ -129,7 +128,9 @@ class LM:
         assert (
             (messages is None) != (system_message is None)
         ), "Must provide either messages or system_message/user_message pair, but not both"
-        assert not (response_model and tools), "Cannot provide both response_model and tools"
+        assert not (
+            response_model and tools
+        ), "Cannot provide both response_model and tools"
         if messages is None:
             messages = build_messages(
                 system_message, user_message, images_as_bytes, self.model_name
@@ -162,8 +163,13 @@ class LM:
                 tools=tools,
             )
         assert isinstance(result.raw_response, str), "Raw response must be a string"
-        assert (isinstance(result.structured_output, BaseModel) or result.structured_output is None), "Structured output must be a Pydantic model or None"
-        assert (isinstance(result.tool_calls, list) or result.tool_calls is None), "Tool calls must be a list or None"
+        assert (
+            isinstance(result.structured_output, BaseModel)
+            or result.structured_output is None
+        ), "Structured output must be a Pydantic model or None"
+        assert (
+            isinstance(result.tool_calls, list) or result.tool_calls is None
+        ), "Tool calls must be a list or None"
         return result
 
     async def respond_async(
@@ -174,7 +180,7 @@ class LM:
         images_as_bytes: List[Any] = [],
         response_model: Optional[BaseModel] = None,
         use_ephemeral_cache_only: bool = False,
-        tools: Optional[List[BaseTool]] = None,
+        tools: Optional[List] = None,
     ) -> BaseLMResponse:
         # "In respond_async")
         assert (system_message is None) == (
@@ -184,7 +190,9 @@ class LM:
             (messages is None) != (system_message is None)
         ), "Must provide either messages or system_message/user_message pair, but not both"
 
-        assert not (response_model and tools), "Cannot provide both response_model and tools"
+        assert not (
+            response_model and tools
+        ), "Cannot provide both response_model and tools"
         if messages is None:
             messages = build_messages(
                 system_message, user_message, images_as_bytes, self.model_name
@@ -192,7 +200,7 @@ class LM:
         result = None
         if response_model:
             try:
-                #print("Trying structured output handler")
+                # print("Trying structured output handler")
                 result = await self.structured_output_handler.call_async(
                     messages,
                     model=self.model_name,
@@ -201,7 +209,7 @@ class LM:
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
                 )
             except StructuredOutputCoercionFailureException:
-                #print("Falling back to backup handler")
+                # print("Falling back to backup handler")
                 result = await self.backup_structured_output_handler.call_async(
                     messages,
                     model=self.model_name,
@@ -210,7 +218,7 @@ class LM:
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
                 )
         else:
-            #print("Calling API no response model")
+            # print("Calling API no response model")
             result = await self.client._hit_api_async(
                 messages=messages,
                 model=self.model_name,
@@ -219,10 +227,16 @@ class LM:
                 tools=tools,
             )
         assert isinstance(result.raw_response, str), "Raw response must be a string"
-        assert (isinstance(result.structured_output, BaseModel) or result.structured_output is None), "Structured output must be a Pydantic model or None"
-        assert (isinstance(result.tool_calls, list) or result.tool_calls is None), "Tool calls must be a list or None"
+        assert (
+            isinstance(result.structured_output, BaseModel)
+            or result.structured_output is None
+        ), "Structured output must be a Pydantic model or None"
+        assert (
+            isinstance(result.tool_calls, list) or result.tool_calls is None
+        ), "Tool calls must be a list or None"
         return result
 
+
 if __name__ == "__main__":
     import asyncio
 

synth_ai/zyk/lms/structured_outputs/handler.py

@@ -174,24 +174,24 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                 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:
-                print("Got cached hit, returning directly")
+                #print("Got cached hit, returning directly")
                 raw_text_response = raw_text_response_or_cached_hit.raw_response
             else:
                 raw_text_response = raw_text_response_or_cached_hit
             logger.debug(f"Raw response from model:\n{raw_text_response}")
 
-            print("Trying to parse structured output")
+            #print("Trying to parse structured output")
             try:
                 structured_output = pull_out_structured_output(
                     raw_text_response, response_model
                 )
 
-                print("Successfully parsed structured output on first attempt")
+                #print("Successfully parsed structured output on first attempt")
                 break
             except Exception as e:
                 logger.warning(f"Failed to parse structured output: {str(e)}")
                 try:
-                    print("Attempting to fix with forced JSON parser")
+                    #print("Attempting to fix with forced JSON parser")
                     structured_output = await fix_errant_forced_async(
                         messages_with_json_formatting_instructions,
                         raw_text_response,
@@ -200,7 +200,7 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                     )
                     assert isinstance(structured_output, BaseModel), "Structured output must be a Pydantic model"
                     assert not isinstance(structured_output, BaseLMResponse), "Got BaseLMResponse instead of Pydantic model"
-                    print("Successfully fixed and parsed structured output")
+                    #print("Successfully fixed and parsed structured output")
                     break
                 except Exception as e:
                     logger.error(f"Failed to fix structured output: {str(e)}")
@@ -215,8 +215,8 @@ class StringifiedJSONHandler(StructuredHandlerBase):
             raise StructuredOutputCoercionFailureException(
                 "Failed to get structured output"
             )
-        print("Successfully parsed structured output")
-        print(structured_output)
+        #print("Successfully parsed structured output")
+        #print(structured_output)
         assert isinstance(structured_output, BaseModel), "Structured output must be a Pydantic model"
         assert not isinstance(structured_output, BaseLMResponse),"Got BaseLMResponse instead of Pydantic model" 
         return BaseLMResponse(
@@ -277,16 +277,16 @@ class StringifiedJSONHandler(StructuredHandlerBase):
                 structured_output = pull_out_structured_output(
                     raw_text_response, response_model
                 )
-                print("Successfully parsed structured output on first attempt")
+                #print("Successfully parsed structured output on first attempt")
                 break
             except Exception as e:
                 logger.warning(f"Failed to parse structured output: {str(e)}")
                 try:
-                    print("Attempting to fix with forced JSON parser")
+                    #print("Attempting to fix with forced JSON parser")
                     structured_output = fix_errant_forced_sync(
                         raw_text_response, response_model, "gpt-4o-mini"
                     )
-                    print("Successfully fixed and parsed structured output")
+                    #print("Successfully fixed and parsed structured output")
                     break
                 except Exception as e:
                     logger.error(f"Failed to fix structured output: {str(e)}")

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

@@ -66,12 +66,39 @@ class GeminiAPI(VendorBase):
             )
         return contents
 
-    def _convert_tools_to_gemini_format(self, tools: List[BaseTool]) -> Tool:
+    def _convert_tools_to_gemini_format(self, tools: List[Any]) -> Tool:
         function_declarations = []
         for tool in tools:
-            function_declarations.append(tool.to_gemini_tool())
+            # Try to use to_gemini_tool method if available, otherwise assume it's a dict
+            try:
+                function_declarations.append(tool.to_gemini_tool())
+            except AttributeError:
+                # If tool is a properly formatted dict, use it directly
+                if "name" in tool and "parameters" in tool:
+                    function_declarations.append(tool)
+                else:
+                    raise ValueError(
+                        f"Unsupported tool format. Tools must be BaseTool instances or properly formatted dictionaries."
+                    )
         return Tool(function_declarations=function_declarations)
 
+    def _convert_args_to_dict(self, args):
+        """
+        Recursively convert Gemini's args objects to Python dictionaries.
+        """
+        # Try to convert dict-like objects
+        try:
+            return {k: self._convert_args_to_dict(v) for k, v in args.items()}
+        except (AttributeError, TypeError):
+            # Try to convert list-like objects
+            try:
+                if isinstance(args, (str, bytes)):
+                    return args
+                return [self._convert_args_to_dict(item) for item in args]
+            except (TypeError, AttributeError):
+                # Base case: primitive value
+                return args
+
     async def _private_request_async(
         self,
         messages: List[Dict],
@@ -90,11 +117,11 @@ class GeminiAPI(VendorBase):
             tools_config = self._convert_tools_to_gemini_format(tools)
 
         # Extract tool_config from lm_config if provided
-        tool_config = lm_config.get("tool_config") if lm_config else {
-            "function_calling_config": {
-                "mode": "any"
-            }
-        }
+        tool_config = (
+            lm_config.get("tool_config")
+            if lm_config
+            else {"function_calling_config": {"mode": "any"}}
+        )
 
         code_generation_model = genai.GenerativeModel(
             model_name=model_name,
@@ -113,8 +140,9 @@ class GeminiAPI(VendorBase):
         tool_calls = []
         for part in result.candidates[0].content.parts:
             if part.function_call:
-                # Convert MapComposite args to dict
-                args_dict = dict(part.function_call.args)
+                # Convert complex objects to Python dictionaries recursively
+                args_dict = self._convert_args_to_dict(part.function_call.args)
+                # Ensure serializable arguments
                 tool_calls.append(
                     {
                         "id": f"call_{len(tool_calls) + 1}",  # Generate unique IDs
@@ -145,11 +173,11 @@ class GeminiAPI(VendorBase):
             tools_config = self._convert_tools_to_gemini_format(tools)
 
         # Extract tool_config from lm_config if provided
-        tool_config = lm_config.get("tool_config") if lm_config else {
-            "function_calling_config": {
-                "mode": "any"
-            }
-        }
+        tool_config = (
+            lm_config.get("tool_config")
+            if lm_config
+            else {"function_calling_config": {"mode": "any"}}
+        )
 
         code_generation_model = genai.GenerativeModel(
             model_name=model_name,
@@ -168,8 +196,9 @@ class GeminiAPI(VendorBase):
         tool_calls = []
         for part in result.candidates[0].content.parts:
             if part.function_call:
-                # Convert MapComposite args to dict
-                args_dict = dict(part.function_call.args)
+                # Convert complex objects to Python dictionaries recursively
+                args_dict = self._convert_args_to_dict(part.function_call.args)
+                # Ensure serializable arguments
                 tool_calls.append(
                     {
                         "id": f"call_{len(tool_calls) + 1}",  # Generate unique IDs

{synth_ai-0.1.0.dev30.dist-info → synth_ai-0.1.0.dev32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: synth-ai
-Version: 0.1.0.dev30
+Version: 0.1.0.dev32
 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.dev30.dist-info → synth_ai-0.1.0.dev32.dist-info}/RECORD

@@ -4,6 +4,7 @@ public_tests/test_all_structured_outputs.py,sha256=bIcchimaVkq8q8D-GKO25d1_SauTF
 public_tests/test_anthropic_structured_outputs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 public_tests/test_deepseek_structured_outputs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 public_tests/test_deepseek_tools.py,sha256=MxEaiT_zinuMPeylqfNMsD11zRaMEwY0Fi28bg5op0A,1895
+public_tests/test_gemini_output.py,sha256=704NCnxNepYjUxJj3eEms6zHRCps2PSaR8A-lcsQxb4,6062
 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
@@ -22,19 +23,19 @@ 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=6DhILKDiF7SRhzHyKgpdq_JS_VN1qS_ZQZRJW-0VF_o,4149
+synth_ai/zyk/lms/caching/handler.py,sha256=a-4FBxXLWeHCXiGDWP8QU-LPxMAvGbJ_5lUrXnZytn0,4478
 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=L6zKjF3UxSvW-UUykaX1gYEQ9wl9QOHQf8UJN5cfmwA,10279
+synth_ai/zyk/lms/core/main.py,sha256=kKxk-1TZQMNXDrLv7qA42fNOsXes-G9kLtNg-LtrpYY,10370
 synth_ai/zyk/lms/core/vendor_clients.py,sha256=go6VGF3-JkZyUD81LwRkcBaxdWSVaV9vRxVTNqKSxvM,2781
 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=gh3KtmZCyUima5BunpjaeKcanmRWJvCy8Ly8gUgDf_M,16915
+synth_ai/zyk/lms/structured_outputs/handler.py,sha256=BQ0T4HBFXC9qesF8v0lG8MuiOecWm2YEF75nUt1mB_s,16925
 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
@@ -45,7 +46,7 @@ synth_ai/zyk/lms/vendors/openai_standard.py,sha256=Th_0QjmrJ7gemxsKnWmij46lIz4QW
 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=QM4xuaigdVOjBuzkPyT-RSOtvT2wiKxAiHRfI77GYn8,13461
-synth_ai/zyk/lms/vendors/core/gemini_api.py,sha256=j8pGGGkJNOVmadpkZsGYhwoSkwsdpX_jAXhrfydoNk8,9631
+synth_ai/zyk/lms/vendors/core/gemini_api.py,sha256=I1goLy5R8eBLrun2jpnD4o87NlmzWgPrfYaeu9RZN8M,11008
 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/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,11 +56,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.dev30.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
+synth_ai-0.1.0.dev32.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.dev30.dist-info/METADATA,sha256=ryafJbsOXPxAxLfXRtJUw6EkJjcP2k1ND0TNgQTE59M,2702
-synth_ai-0.1.0.dev30.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-synth_ai-0.1.0.dev30.dist-info/top_level.txt,sha256=5GzJO9j-KbJ_4ppxhmCUa_qdhHM4-9cHHNU76yAI8do,42
-synth_ai-0.1.0.dev30.dist-info/RECORD,,
+synth_ai-0.1.0.dev32.dist-info/METADATA,sha256=zgAF8JSt2QckCC9M4iLt2vVn2i1c7N6MEUj4YEKTV9k,2702
+synth_ai-0.1.0.dev32.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+synth_ai-0.1.0.dev32.dist-info/top_level.txt,sha256=5GzJO9j-KbJ_4ppxhmCUa_qdhHM4-9cHHNU76yAI8do,42
+synth_ai-0.1.0.dev32.dist-info/RECORD,,