synth-ai 0.1.0.dev27__py3-none-any.whl → 0.1.0.dev29__py3-none-any.whl

synth_ai/zyk/lms/vendors/openai_standard.py

@@ -1,15 +1,17 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional, Union
 
+import groq
 import openai
 import pydantic_core
+from pydantic import BaseModel
 
 from synth_ai.zyk.lms.caching.initialize import (
     get_cache_handler,
 )
-from synth_ai.zyk.lms.vendors.base import VendorBase
+from synth_ai.zyk.lms.tools.base import BaseTool
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
 from synth_ai.zyk.lms.vendors.constants import SPECIAL_BASE_TEMPS
-from synth_ai.zyk.lms.vendors.retries import BACKOFF_TOLERANCE, backoff
-import groq
+
 DEFAULT_EXCEPTIONS_TO_RETRY = (
     pydantic_core._pydantic_core.ValidationError,
     openai.APIConnectionError,
@@ -23,7 +25,7 @@ DEFAULT_EXCEPTIONS_TO_RETRY = (
 def special_orion_transform(
     model: str, messages: List[Dict[str, Any]]
 ) -> List[Dict[str, Any]]:
-    if "o1-" in model or "o3-" in model:
+    if "o1-" in model:
         messages = [
             {
                 "role": "user",
@@ -63,13 +65,13 @@ class OpenAIStandard(VendorBase):
         self.used_for_structured_outputs = used_for_structured_outputs
         self.exceptions_to_retry = exceptions_to_retry
 
-    @backoff.on_exception(
-        backoff.expo,
-        exceptions_to_retry,
-        max_tries=BACKOFF_TOLERANCE,
-        on_backoff=on_backoff_handler_async,
-        on_giveup=lambda e: print(e),
-    )
+    # @backoff.on_exception(
+    #     backoff.expo,
+    #     exceptions_to_retry,
+    #     max_tries=BACKOFF_TOLERANCE,
+    #     on_backoff=on_backoff_handler_async,
+    #     on_giveup=lambda e: print(e),
+    # )
     async def _hit_api_async(
         self,
         model: str,
@@ -77,21 +79,18 @@ class OpenAIStandard(VendorBase):
         lm_config: Dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-    ) -> str:
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
         assert (
             lm_config.get("response_model", None) is None
         ), "response_model is not supported for standard calls"
         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
+            model, messages, lm_config=lm_config, tools=tools
         )
         if cache_result:
-            return (
-                cache_result["response"]
-                if isinstance(cache_result, dict)
-                else cache_result
-            )
+            return cache_result
 
         # Common API call params
         api_params = {
@@ -99,6 +98,10 @@ class OpenAIStandard(VendorBase):
             "messages": messages,
         }
 
+        # Add tools if provided
+        if tools:
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+
         # Only add temperature for non o1/o3 models
         if not any(prefix in model for prefix in ["o1-", "o3-"]):
             api_params["temperature"] = lm_config.get(
@@ -106,25 +109,45 @@ class OpenAIStandard(VendorBase):
             )
 
         # Add reasoning_effort only for o3-mini
-        if "o3-mini" in model:
-            #print("Reasoning effort:", reasoning_effort)
+        if model in ["o3-mini"]:
+            print("Reasoning effort:", reasoning_effort)
             api_params["reasoning_effort"] = reasoning_effort
 
         output = await self.async_client.chat.completions.create(**api_params)
+        message = output.choices[0].message
+
+        # Convert tool calls to dict format
+        tool_calls = None
+        if message.tool_calls:
+            tool_calls = [
+                {
+                    "id": tc.id,
+                    "type": tc.type,
+                    "function": {
+                        "name": tc.function.name,
+                        "arguments": tc.function.arguments,
+                    },
+                }
+                for tc in message.tool_calls
+            ]
 
-        api_result = output.choices[0].message.content
+        lm_response = BaseLMResponse(
+            raw_response=message.content or "",  # Use empty string if no content
+            structured_output=None,
+            tool_calls=tool_calls,
+        )
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=api_result
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools
         )
-        return api_result
-
-    @backoff.on_exception(
-        backoff.expo,
-        exceptions_to_retry,
-        max_tries=BACKOFF_TOLERANCE,
-        on_backoff=on_backoff_handler_sync,
-        on_giveup=lambda e: print(e),
-    )
+        return lm_response
+
+    # @backoff.on_exception(
+    #     backoff.expo,
+    #     exceptions_to_retry,
+    #     max_tries=BACKOFF_TOLERANCE,
+    #     on_backoff=on_backoff_handler_sync,
+    #     on_giveup=lambda e: print(e),
+    # )
     def _hit_api_sync(
         self,
         model: str,
@@ -132,7 +155,8 @@ class OpenAIStandard(VendorBase):
         lm_config: Dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-    ) -> str:
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
         assert (
             lm_config.get("response_model", None) is None
         ), "response_model is not supported for standard calls"
@@ -141,21 +165,145 @@ 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
+            model, messages, lm_config=lm_config, tools=tools
         )
         if cache_result:
-            return (
-                cache_result["response"]
-                if isinstance(cache_result, dict)
-                else cache_result
+            return cache_result
+
+        # Common API call params
+        api_params = {
+            "model": model,
+            "messages": messages,
+        }
+
+        # Add tools if provided
+        if tools:
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+
+        # Only add temperature for non o1/o3 models
+        if not any(prefix in model for prefix in ["o1-", "o3-"]):
+            api_params["temperature"] = lm_config.get(
+                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
             )
 
+        # Add reasoning_effort only for o3-mini
+        if model in ["o3-mini"]:
+            api_params["reasoning_effort"] = reasoning_effort
+
+        output = self.sync_client.chat.completions.create(**api_params)
+        message = output.choices[0].message
+
+        # Convert tool calls to dict format
+        tool_calls = None
+        if message.tool_calls:
+            tool_calls = [
+                {
+                    "id": tc.id,
+                    "type": tc.type,
+                    "function": {
+                        "name": tc.function.name,
+                        "arguments": tc.function.arguments,
+                    },
+                }
+                for tc in message.tool_calls
+            ]
+
+        lm_response = BaseLMResponse(
+            raw_response=message.content or "",  # Use empty string if no content
+            structured_output=None,
+            tool_calls=tool_calls,
+        )
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+        )
+        return lm_response
+
+    async def _hit_api_async_structured_output(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        response_model: BaseModel,
+        temperature: float,
+        use_ephemeral_cache_only: bool = False,
+        reasoning_effort: str = "high",
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        lm_config = {"temperature": temperature, "response_model": response_model}
+        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
+            )
+        )
+        if cache_result is not None:
+            return cache_result
+
+        # Common API call params
+        api_params = {
+            "model": model,
+            "messages": messages,
+        }
+
+        # Add tools if provided
+        if tools:
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+
+        # Only add temperature for non o1/o3 models
+        if not any(prefix in model for prefix in ["o1-", "o3-"]):
+            api_params["temperature"] = lm_config.get(
+                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
+            )
+
+        # Add reasoning_effort only for o3-mini
+        if model in ["o3-mini"]:
+            api_params["reasoning_effort"] = reasoning_effort
+
+        output = await self.async_client.chat.completions.create(**api_params)
+
+        structured_output_api_result = response_model(
+            **output.choices[0].message.content
+        )
+        tool_calls = output.choices[0].message.tool_calls
+        lm_response = BaseLMResponse(
+            raw_response=output.choices[0].message.content,
+            structured_output=structured_output_api_result,
+            tool_calls=tool_calls,
+        )
+        used_cache_handler.add_to_managed_cache(
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools
+        )
+        return lm_response
+
+    def _hit_api_sync_structured_output(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        response_model: BaseModel,
+        temperature: float,
+        use_ephemeral_cache_only: bool = False,
+        reasoning_effort: str = "high",
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        lm_config = {"temperature": temperature, "response_model": response_model}
+        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
+            )
+        )
+        if cache_result is not None:
+            return cache_result
+
         # Common API call params
         api_params = {
             "model": model,
             "messages": messages,
         }
 
+        # Add tools if provided
+        if tools:
+            api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+
         # Only add temperature for non o1/o3 models
         if not any(prefix in model for prefix in ["o1-", "o3-"]):
             api_params["temperature"] = lm_config.get(
@@ -168,8 +316,16 @@ class OpenAIStandard(VendorBase):
 
         output = self.sync_client.chat.completions.create(**api_params)
 
-        api_result = output.choices[0].message.content
+        structured_output_api_result = response_model(
+            **output.choices[0].message.content
+        )
+        tool_calls = output.choices[0].message.tool_calls
+        lm_response = BaseLMResponse(
+            raw_response=output.choices[0].message.content,
+            structured_output=structured_output_api_result,
+            tool_calls=tool_calls,
+        )
         used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config=lm_config, output=api_result
+            model, messages, lm_config=lm_config, output=lm_response, tools=tools
         )
-        return api_result
+        return lm_response

synth_ai/zyk/lms/vendors/supported/deepseek.py

@@ -1,7 +1,9 @@
 import os
+from typing import Any, Dict, List, Optional, Tuple
 
 from openai import AsyncOpenAI, OpenAI
 
+from synth_ai.zyk.lms.tools.base import BaseTool
 from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
 
 
@@ -16,3 +18,56 @@ class DeepSeekAPI(OpenAIStandard):
             api_key=os.environ.get("DEEPSEEK_API_KEY"),
             base_url="https://api.deepseek.com",
         )
+
+    def _convert_tools_to_openai_format(self, tools: List[BaseTool]) -> List[Dict]:
+        return [tool.to_openai_tool() for tool in tools]
+
+    async def _private_request_async(
+        self,
+        messages: List[Dict],
+        temperature: float = 0,
+        model_name: str = "deepseek-chat",
+        reasoning_effort: str = "high",
+        tools: Optional[List[BaseTool]] = None,
+        lm_config: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[str, Optional[List[Dict]]]:
+        request_params = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": temperature,
+        }
+
+        if tools:
+            request_params["tools"] = self._convert_tools_to_openai_format(tools)
+
+        response = await self.async_client.chat.completions.create(**request_params)
+        message = response.choices[0].message
+
+        return message.content, message.tool_calls if hasattr(
+            message, "tool_calls"
+        ) else None
+
+    def _private_request_sync(
+        self,
+        messages: List[Dict],
+        temperature: float = 0,
+        model_name: str = "deepseek-chat",
+        reasoning_effort: str = "high",
+        tools: Optional[List[BaseTool]] = None,
+        lm_config: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[str, Optional[List[Dict]]]:
+        request_params = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": temperature,
+        }
+
+        if tools:
+            request_params["tools"] = self._convert_tools_to_openai_format(tools)
+
+        response = self.sync_client.chat.completions.create(**request_params)
+        message = response.choices[0].message
+
+        return message.content, message.tool_calls if hasattr(
+            message, "tool_calls"
+        ) else None

{synth_ai-0.1.0.dev27.dist-info → synth_ai-0.1.0.dev29.dist-info}/METADATA

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: synth-ai
-Version: 0.1.0.dev27
+Version: 0.1.0.dev29
 Summary: Software for aiding the best and multiplying the will.
-Home-page: https://github.com/synth-laboratories/synth-ai
 Author: Josh Purtell
 Author-email: Josh Purtell <josh@usesynth.ai>
 License: MIT License
@@ -44,15 +43,13 @@ Requires-Dist: google>=3.0.0
 Requires-Dist: google-generativeai>=0.8.1
 Requires-Dist: together>=1.2.12
 Requires-Dist: langfuse>=2.56.1
-Requires-Dist: synth-sdk>=0.3.1.dev4
+Requires-Dist: synth-sdk==0.3.1.dev5
 Requires-Dist: datasets>=3.2.0
 Requires-Dist: groq>=0.18.0
 Requires-Dist: pytest-timeout>=2.3.1
 Requires-Dist: lock>=2018.3.25.2110
 Requires-Dist: ollama>=0.4.7
 Requires-Dist: mistralai>=1.5.0
-Dynamic: author
-Dynamic: home-page
 Dynamic: license-file
 
 AI Infra used by the Synth AI Team

synth_ai-0.1.0.dev29.dist-info/RECORD

@@ -0,0 +1,65 @@
+private_tests/try_synth_sdk.py,sha256=vk4lUEfpQfLACFl6Qw468t_lsuYxuoIIr05WRgWKGKY,24
+public_tests/test_agent.py,sha256=OGmUsd-f0ZRL0xIwJ0MO_dPYQOshNdnmmESxfTSytDM,22552
+public_tests/test_all_structured_outputs.py,sha256=bIcchimaVkq8q8D-GKO25d1_SauTFh4a0c3OEKh3_8o,6524
+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_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_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
+public_tests/test_structured_outputs.py,sha256=9SFpH4RQ6nRcphBVmELRNSvhRjYaJBu_z-r6xqKAYpg,4213
+public_tests/test_synth_sdk.py,sha256=jqJHKpvBn9qj21P76z9onXfPg88jyUmBTKmdvCsQMk8,14885
+public_tests/test_text.py,sha256=UyPZ0ci-XBjK35tAeV0kN1X8Njf-0pHfEPZhsWDZ0-c,4072
+public_tests/test_tools.py,sha256=LXR78QWYssjtIQwUIJAn5O747tUDWbbPTGpf0VyojS8,10111
+synth_ai/__init__.py,sha256=tX_fcK8u64BoPEboRa3dIKK_WpLy5KAxL2Ucl-l0xVg,147
+synth_ai/zyk/__init__.py,sha256=kGMD-drlBVdsyT-QFODMwaZUtxPCJ9mg58GKQUvFqo0,134
+synth_ai/zyk/lms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synth_ai/zyk/lms/config.py,sha256=CcN5NL99j0UZubyGo-MUfbPD3pWosAMju_sqgfvqLVY,201
+synth_ai/zyk/lms/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/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=xuoCBAzWnyY52DVdBUJPjIoEIUaCtheAcHG1ZyP8ndQ,10223
+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/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=zqCOyXZqo297wboR9EKVSkvpq6JCMSJyeso8HdZPKa4,102
+synth_ai/zyk/lms/vendors/openai_standard.py,sha256=Th_0QjmrJ7gemxsKnWmij46lIz4QWZOi7Du5OOiLUcc,11413
+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/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
+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
+synth_ai/zyk/lms/vendors/supported/deepseek.py,sha256=BElW0NGpkSA62wOqzzMtDw8XR36rSNXK5LldeHJkQrc,2430
+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.dev29.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.dev29.dist-info/METADATA,sha256=roTXgOH0Ms_JHCBW8uyG1nUnwV3QDamb-PlvmGqZ-Hw,2702
+synth_ai-0.1.0.dev29.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+synth_ai-0.1.0.dev29.dist-info/top_level.txt,sha256=5GzJO9j-KbJ_4ppxhmCUa_qdhHM4-9cHHNU76yAI8do,42
+synth_ai-0.1.0.dev29.dist-info/RECORD,,

public_tests/test_sonnet_thinking.py

@@ -1,178 +0,0 @@
-import asyncio
-import unittest
-
-from synth_ai.zyk import LM
-
-
-class TestSonnetThinking(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.lm = LM(
-            model_name="claude-3-7-sonnet-latest",
-            formatting_model_name="gpt-4o-mini",
-            temperature=0,
-        )
-        # Set reasoning_effort in lm_config
-        cls.lm.lm_config["reasoning_effort"] = "high"
-
-    async def test_thinking_response(self):
-        messages = [
-            {"role": "system", "content": "You are a helpful AI assistant."},
-            {
-                "role": "user",
-                "content": "Please solve this math problem step by step: If a train travels at 60 mph for 2.5 hours, how far does it travel?",
-            },
-        ]
-
-        response = await self.lm.respond_async(messages=messages)
-        print("\n=== Math Problem Test ===")
-        print(f"Response:\n{response}\n")
-        self.assertIsInstance(response, str)
-        self.assertGreater(len(response), 0)
-
-        # Test that the response includes numerical calculation
-        self.assertTrue(any(char.isdigit() for char in response))
-
-    async def test_thinking_structured_output(self):
-        from pydantic import BaseModel
-
-        class MathSolution(BaseModel):
-            steps: list[str]
-            final_answer: float
-            units: str
-
-        messages = [
-            {"role": "system", "content": "You are a math problem solver."},
-            {
-                "role": "user",
-                "content": "If a car travels at 30 mph for 45 minutes, how far does it travel? Provide steps.",
-            },
-        ]
-
-        response = await self.lm.respond_async(
-            messages=messages, response_model=MathSolution
-        )
-
-        print("\n=== Structured Math Problem Test ===")
-        print(f"Steps:")
-        for i, step in enumerate(response.steps, 1):
-            print(f"{i}. {step}")
-        print(f"Final Answer: {response.final_answer} {response.units}\n")
-
-        self.assertIsInstance(response, MathSolution)
-        self.assertGreater(len(response.steps), 0)
-        self.assertIsInstance(response.final_answer, float)
-        self.assertIsInstance(response.units, str)
-
-    async def test_thinking_with_high_effort(self):
-        messages = [
-            {
-                "role": "system",
-                "content": "You are a problem-solving AI. Break down complex problems into detailed steps.",
-            },
-            {
-                "role": "user",
-                "content": "Design a system to automate a coffee shop's inventory management. Consider all aspects.",
-            },
-        ]
-
-        print("\n=== High Effort Thinking Test ===")
-        response = await self.lm.respond_async(messages=messages)
-        print(f"High Effort Response:\n{response}\n")
-        self.assertIsInstance(response, str)
-        self.assertGreater(len(response), 100)  # Expecting detailed response
-
-        # Test with medium effort
-        lm_medium = LM(
-            model_name="claude-3-7-sonnet-latest",
-            formatting_model_name="gpt-4o-mini",
-            temperature=0,
-        )
-        lm_medium.lm_config["reasoning_effort"] = "medium"
-        print("\n=== Medium Effort Thinking Test ===")
-        response_medium = await lm_medium.respond_async(messages=messages)
-        print(f"Medium Effort Response:\n{response_medium}\n")
-        self.assertIsInstance(response_medium, str)
-
-    async def test_thinking_blocks_attributes(self):
-        """Test to verify thinking blocks have the correct attributes and structure"""
-        messages = [
-            {"role": "system", "content": "You are a helpful AI assistant."},
-            {
-                "role": "user",
-                "content": "Please solve this math problem step by step: If a train travels at 60 mph for 2.5 hours, how far does it travel?",
-            },
-        ]
-
-        print("\n=== Testing Thinking Blocks Structure ===")
-        try:
-            response = await self.lm.respond_async(messages=messages)
-            print(f"Response received successfully: {response[:100]}...")
-            self.assertIsInstance(response, str)
-            self.assertGreater(len(response), 0)
-        except AttributeError as e:
-            if "'TextBlock' object has no attribute 'value'" in str(e):
-                self.fail(
-                    "TextBlock missing 'value' attribute - API response structure may have changed"
-                )
-            raise
-
-    async def test_thinking_blocks_with_structured_output(self):
-        """Test thinking blocks with structured output to verify attribute handling"""
-        from pydantic import BaseModel
-
-        class SimpleResponse(BaseModel):
-            answer: str
-            explanation: str
-
-        messages = [
-            {"role": "system", "content": "You are a helpful AI assistant."},
-            {"role": "user", "content": "What is 2+2? Provide answer and explanation."},
-        ]
-
-        print("\n=== Testing Thinking Blocks with Structured Output ===")
-        try:
-            response = await self.lm.respond_async(
-                messages=messages, response_model=SimpleResponse
-            )
-            print(f"Structured response received: {response}")
-            self.assertIsInstance(response, SimpleResponse)
-            self.assertTrue(hasattr(response, "answer"))
-            self.assertTrue(hasattr(response, "explanation"))
-        except AttributeError as e:
-            if "'TextBlock' object has no attribute 'value'" in str(e):
-                self.fail("TextBlock missing 'value' attribute in structured output")
-            raise
-
-    async def test_thinking_blocks_raw_response(self):
-        """Test to examine the raw response structure from the API"""
-        messages = [
-            {"role": "system", "content": "You are a helpful AI assistant."},
-            {"role": "user", "content": "Count from 1 to 3."},
-        ]
-
-        print("\n=== Testing Raw Response Structure ===")
-        try:
-            # Access the raw response if possible
-            response = await self.lm.respond_async(messages=messages)
-            print(f"Raw response type: {type(response)}")
-            print(f"Raw response content: {response}")
-            self.assertIsInstance(response, str)
-        except Exception as e:
-            print(f"Exception type: {type(e)}")
-            print(f"Exception message: {str(e)}")
-            raise
-
-    def test_all(self):
-        print("\nStarting Claude 3.7 Sonnet Thinking Tests...")
-        asyncio.run(self.test_thinking_response())
-        asyncio.run(self.test_thinking_structured_output())
-        asyncio.run(self.test_thinking_with_high_effort())
-        asyncio.run(self.test_thinking_blocks_attributes())
-        asyncio.run(self.test_thinking_blocks_with_structured_output())
-        asyncio.run(self.test_thinking_blocks_raw_response())
-        print("\nAll tests completed successfully!")
-
-
-if __name__ == "__main__":
-    unittest.main()