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

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

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, List, Tuple, Type
+from typing import Any, Dict, List, Optional, Tuple, Type
 
 import anthropic
 import pydantic
@@ -8,14 +8,20 @@ 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.core.openai_api import OpenAIStructuredOutputClient
-from synth_ai.zyk.lms.vendors.retries import BACKOFF_TOLERANCE, backoff
 
 ANTHROPIC_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (anthropic.APIError,)
 
 
+sonnet_37_budgets = {
+    "high": 4000,
+    "medium": 2000,
+    "low": 1000,
+}
+
 class AnthropicAPI(VendorBase):
     used_for_structured_outputs: bool = True
     exceptions_to_retry: Tuple = ANTHROPIC_EXCEPTIONS_TO_RETRY
@@ -37,12 +43,12 @@ class AnthropicAPI(VendorBase):
         self._openai_fallback = None
         self.reasoning_effort = reasoning_effort
 
-    @backoff.on_exception(
-        backoff.expo,
-        exceptions_to_retry,
-        max_tries=BACKOFF_TOLERANCE,
-        on_giveup=lambda e: print(e),
-    )
+    # @backoff.on_exception(
+    #     backoff.expo,
+    #     exceptions_to_retry,
+    #     max_tries=BACKOFF_TOLERANCE,
+    #     on_giveup=lambda e: print(e),
+    # )
     async def _hit_api_async(
         self,
         model: str,
@@ -50,83 +56,90 @@ class AnthropicAPI(VendorBase):
         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],
-    ) -> str:
+    ) -> BaseLMResponse:
         assert (
             lm_config.get("response_model", None) is None
         ), "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
+            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 parameters
         api_params = {
             "system": messages[0]["content"],
             "messages": messages[1:],
             "model": model,
-            "max_tokens": lm_config.get("max_tokens", 4096 * 2),
+            "max_tokens": lm_config.get("max_tokens", 4096),
             "temperature": lm_config.get(
                 "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
             ),
         }
 
-        # Handle thinking budget for Claude 3.7
+        # Add tools if provided
+        if tools:
+            api_params["tools"] = [tool.to_anthropic_tool() for tool in tools]
+
+        # Only try to add thinking if supported by the SDK
         try:
             import inspect
 
             create_sig = inspect.signature(self.async_client.messages.create)
             if "thinking" in create_sig.parameters and "claude-3-7" in model:
                 if reasoning_effort in ["high", "medium"]:
-                    budgets = {
-                        "high": 4000,
-                        "medium": 2000,
-                        "low": 1000,
-                    }
-                    budget = budgets[reasoning_effort]
+                    budget = sonnet_37_budgets[reasoning_effort]    
                     api_params["thinking"] = {
                         "type": "enabled",
                         "budget_tokens": budget,
                     }
-                    # Ensure max_tokens is greater than thinking budget
-                    api_params["max_tokens"] = max(
-                        api_params["max_tokens"], budget + 4096
-                    )
-                    # Set temperature to 1 for thinking, but only in API call
-                    api_params["temperature"] = 1.0
+                    api_params["max_tokens"] = budget+4096
+                    api_params["temperature"] = 1
         except (ImportError, AttributeError, TypeError):
             pass
 
         # Make the API call
         response = await self.async_client.messages.create(**api_params)
 
-        # Handle both regular and thinking responses
-        if hasattr(response.content[0], "text"):
-            api_result = response.content[0].text
-        else:
-            # For thinking responses, get the final output
-            thinking_blocks = [
-                block for block in response.content if block.type == "text"
-            ]
-            api_result = thinking_blocks[-1].text if thinking_blocks else ""
+        # Extract text content and tool calls
+        raw_response = ""
+        tool_calls = []
+
+        for content in response.content:
+            if content.type == "text":
+                raw_response += content.text
+            elif content.type == "tool_use":
+                tool_calls.append(
+                    {
+                        "id": content.id,
+                        "type": "function",
+                        "function": {
+                            "name": content.name,
+                            "arguments": json.dumps(content.input),
+                        },
+                    }
+                )
+
+        lm_response = BaseLMResponse(
+            raw_response=raw_response,
+            structured_output=None,
+            tool_calls=tool_calls if tool_calls else None,
+        )
 
         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_giveup=lambda e: print(e),
-    )
+        return lm_response
+
+    # @backoff.on_exception(
+    #     backoff.expo,
+    #     exceptions_to_retry,
+    #     max_tries=BACKOFF_TOLERANCE,
+    #     on_giveup=lambda e: print(e),
+    # )
     def _hit_api_sync(
         self,
         model: str,
@@ -134,8 +147,9 @@ class AnthropicAPI(VendorBase):
         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],
-    ) -> str:
+    ) -> BaseLMResponse:
         assert (
             lm_config.get("response_model", None) is None
         ), "response_model is not supported for standard calls"
@@ -143,14 +157,10 @@ 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
+            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 parameters
         api_params = {
@@ -163,45 +173,61 @@ class AnthropicAPI(VendorBase):
             ),
         }
 
-        # Only try to add thinking if supported by the SDK (check if Claude 3.7 and if reasoning_effort is set)
-        # Try to detect capabilities without causing an error
+        # Add tools if provided
+        if tools:
+            api_params["tools"] = [tool.to_anthropic_tool() for tool in tools]
+
+        # Only try to add thinking if supported by the SDK
         try:
             import inspect
 
             create_sig = inspect.signature(self.sync_client.messages.create)
             if "thinking" in create_sig.parameters and "claude-3-7" in model:
+                api_params["temperature"] = 1
                 if reasoning_effort in ["high", "medium"]:
-                    budgets = {
-                        "high": 4000,
-                        "medium": 2000,
-                        "low": 1000,
-                    }
+                    budgets = sonnet_37_budgets
                     budget = budgets[reasoning_effort]
                     api_params["thinking"] = {
                         "type": "enabled",
                         "budget_tokens": budget,
                     }
+                    api_params["max_tokens"] = budget+4096
+                    api_params["temperature"] = 1
         except (ImportError, AttributeError, TypeError):
-            # If we can't inspect or the parameter doesn't exist, just continue without it
             pass
 
         # Make the API call
         response = self.sync_client.messages.create(**api_params)
 
-        # Handle both regular and thinking responses
-        if hasattr(response.content[0], "text"):
-            api_result = response.content[0].text
-        else:
-            # For thinking responses, get the final output
-            thinking_blocks = [
-                block for block in response.content if block.type == "text"
-            ]
-            api_result = thinking_blocks[-1].text if thinking_blocks else ""
+        # Extract text content and tool calls
+        raw_response = ""
+        tool_calls = []
+
+        for content in response.content:
+            if content.type == "text":
+                raw_response += content.text
+            elif content.type == "tool_use":
+                tool_calls.append(
+                    {
+                        "id": content.id,
+                        "type": "function",
+                        "function": {
+                            "name": content.name,
+                            "arguments": json.dumps(content.input),
+                        },
+                    }
+                )
+
+        lm_response = BaseLMResponse(
+            raw_response=raw_response,
+            structured_output=None,
+            tool_calls=tool_calls if tool_calls else None,
+        )
 
         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
 
     async def _hit_api_async_structured_output(
         self,
@@ -212,36 +238,42 @@ class AnthropicAPI(VendorBase):
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
         **vendor_params: Dict[str, Any],
-    ) -> str:
+    ) -> BaseLMResponse:
         try:
             # First try with Anthropic
             reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
             if "claude-3-7" in model:
-                if reasoning_effort in ["high", "medium"]:
-                    budgets = {
-                        "high": 4000,
-                        "medium": 2000,
-                        "low": 1000,
-                    }
-                    budget = budgets[reasoning_effort]
+
+                #if reasoning_effort in ["high", "medium"]:
+                budgets = sonnet_37_budgets
+                budget = budgets[reasoning_effort]
+                max_tokens = budget+4096
+                temperature = 1
+                
                 response = await self.async_client.messages.create(
                     system=messages[0]["content"],
                     messages=messages[1:],
                     model=model,
-                    max_tokens=4096,
+                    max_tokens=max_tokens,
                     thinking={"type": "enabled", "budget_tokens": budget},
+                    temperature=temperature,
                 )
             else:
                 response = await self.async_client.messages.create(
                     system=messages[0]["content"],
                     messages=messages[1:],
                     model=model,
-                    max_tokens=4096,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
                 )
             result = response.content[0].text
-            # Try to parse the result as JSON
             parsed = json.loads(result)
-            return response_model(**parsed)
+            lm_response = BaseLMResponse(
+                raw_response="",
+                structured_output=response_model(**parsed),
+                tool_calls=None,
+            )
+            return lm_response
         except (json.JSONDecodeError, pydantic.ValidationError):
             # If Anthropic fails, fallback to OpenAI
             if self._openai_fallback is None:
@@ -263,7 +295,7 @@ class AnthropicAPI(VendorBase):
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
         **vendor_params: Dict[str, Any],
-    ) -> str:
+    ) -> BaseLMResponse:
         try:
             # First try with Anthropic
             reasoning_effort = vendor_params.get("reasoning_effort", reasoning_effort)
@@ -271,17 +303,15 @@ class AnthropicAPI(VendorBase):
 
             if "claude-3-7" in model:
                 if reasoning_effort in ["high", "medium"]:
-                    budgets = {
-                        "high": 4000,
-                        "medium": 2000,
-                        "low": 1000,
-                    }
+                    budgets = sonnet_37_budgets
                     budget = budgets[reasoning_effort]
+                    max_tokens = budget+4096
+                    temperature = 1
                 response = self.sync_client.messages.create(
                     system=messages[0]["content"],
                     messages=messages[1:],
                     model=model,
-                    max_tokens=4096,
+                    max_tokens=max_tokens,
                     temperature=temperature,
                     thinking={"type": "enabled", "budget_tokens": budget},
                 )
@@ -290,14 +320,19 @@ class AnthropicAPI(VendorBase):
                     system=messages[0]["content"],
                     messages=messages[1:],
                     model=model,
-                    max_tokens=4096,
+                    max_tokens=max_tokens,
                     temperature=temperature,
                 )
             # print("Time taken for API call", time.time() - t)
             result = response.content[0].text
             # Try to parse the result as JSON
             parsed = json.loads(result)
-            return response_model(**parsed)
+            lm_response = BaseLMResponse(
+                raw_response="",
+                structured_output=response_model(**parsed),
+                tool_calls=None,
+            )
+            return lm_response
         except (json.JSONDecodeError, pydantic.ValidationError):
             # If Anthropic fails, fallback to OpenAI
             print("WARNING - Falling back to OpenAI - THIS IS SLOW")

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

@@ -1,16 +1,18 @@
+import json
 import logging
 import os
 import warnings
-from typing import Any, Dict, List, Tuple, Type
+from typing import Any, Dict, List, Optional, Tuple, Type
 
 import google.generativeai as genai
 from google.api_core.exceptions import ResourceExhausted
-from google.generativeai.types import HarmBlockThreshold, HarmCategory
+from google.generativeai.types import HarmBlockThreshold, HarmCategory, Tool
 
 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
 
@@ -41,23 +43,89 @@ class GeminiAPI(VendorBase):
         self.used_for_structured_outputs = used_for_structured_outputs
         self.exceptions_to_retry = exceptions_to_retry
 
+    def _convert_messages_to_contents(
+        self, messages: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        contents = []
+        system_instruction = None
+        for message in messages:
+            if message["role"] == "system":
+                system_instruction = (
+                    f"<instructions>\n{message['content']}\n</instructions>"
+                )
+                continue
+            elif system_instruction:
+                text = system_instruction + "\n" + message["content"]
+            else:
+                text = message["content"]
+            contents.append(
+                {
+                    "role": message["role"],
+                    "parts": [{"text": text}],
+                }
+            )
+        return contents
+
+    def _convert_tools_to_gemini_format(self, tools: List[BaseTool]) -> Tool:
+        function_declarations = []
+        for tool in tools:
+            function_declarations.append(tool.to_gemini_tool())
+        return Tool(function_declarations=function_declarations)
+
     async def _private_request_async(
         self,
         messages: List[Dict],
         temperature: float = 0,
         model_name: str = "gemini-1.5-flash",
         reasoning_effort: str = "high",
-    ) -> str:
+        tools: Optional[List[BaseTool]] = None,
+        lm_config: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[str, Optional[List[Dict]]]:
+        generation_config = {
+            "temperature": temperature,
+        }
+
+        tools_config = None
+        if tools:
+            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"
+            }
+        }
+
         code_generation_model = genai.GenerativeModel(
             model_name=model_name,
-            generation_config={"temperature": temperature},
-            system_instruction=messages[0]["content"],
+            generation_config=generation_config,
+            tools=tools_config if tools_config else None,
+            tool_config=tool_config,
         )
+
+        contents = self._convert_messages_to_contents(messages)
         result = await code_generation_model.generate_content_async(
-            messages[1]["content"],
+            contents=contents,
             safety_settings=SAFETY_SETTINGS,
         )
-        return result.text
+
+        text = result.candidates[0].content.parts[0].text
+        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)
+                tool_calls.append(
+                    {
+                        "id": f"call_{len(tool_calls) + 1}",  # Generate unique IDs
+                        "type": "function",
+                        "function": {
+                            "name": part.function_call.name,
+                            "arguments": json.dumps(args_dict),
+                        },
+                    }
+                )
+        return text, tool_calls if tool_calls else None
 
     def _private_request_sync(
         self,
@@ -65,17 +133,54 @@ class GeminiAPI(VendorBase):
         temperature: float = 0,
         model_name: str = "gemini-1.5-flash",
         reasoning_effort: str = "high",
-    ) -> str:
+        tools: Optional[List[BaseTool]] = None,
+        lm_config: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[str, Optional[List[Dict]]]:
+        generation_config = {
+            "temperature": temperature,
+        }
+
+        tools_config = None
+        if tools:
+            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"
+            }
+        }
+
         code_generation_model = genai.GenerativeModel(
             model_name=model_name,
-            generation_config={"temperature": temperature},
-            system_instruction=messages[0]["content"],
+            generation_config=generation_config,
+            tools=tools_config if tools_config else None,
+            tool_config=tool_config,
         )
+
+        contents = self._convert_messages_to_contents(messages)
         result = code_generation_model.generate_content(
-            messages[1]["content"],
+            contents=contents,
             safety_settings=SAFETY_SETTINGS,
         )
-        return result.text
+
+        text = result.candidates[0].content.parts[0].text
+        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)
+                tool_calls.append(
+                    {
+                        "id": f"call_{len(tool_calls) + 1}",  # Generate unique IDs
+                        "type": "function",
+                        "function": {
+                            "name": part.function_call.name,
+                            "arguments": json.dumps(args_dict),
+                        },
+                    }
+                )
+        return text, tool_calls if tool_calls else None
 
     @backoff.on_exception(
         backoff.expo,
@@ -90,29 +195,35 @@ class GeminiAPI(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"
         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
-            )
-        api_result = await self._private_request_async(
+            return cache_result
+
+        raw_response, tool_calls = await self._private_request_async(
             messages,
             temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
             reasoning_effort=reasoning_effort,
+            tools=tools,
+        )
+
+        lm_response = BaseLMResponse(
+            raw_response=raw_response,
+            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
+        return lm_response
 
     @backoff.on_exception(
         backoff.expo,
@@ -127,26 +238,34 @@ class GeminiAPI(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"
-        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
+        used_cache_handler = get_cache_handler(
+            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
-            )
-        api_result = self._private_request_sync(
+            return cache_result
+
+        raw_response, tool_calls = self._private_request_sync(
             messages,
             temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
             reasoning_effort=reasoning_effort,
+            tools=tools,
         )
+
+        lm_response = BaseLMResponse(
+            raw_response=raw_response,
+            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
+        return lm_response