synth-ai 0.2.0__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/{zyk/lms → lm}/vendors/core/gemini_api.py

@@ -4,18 +4,18 @@ import os
 import warnings
 from typing import Any, Dict, List, Optional, Tuple, Type
 
-from google import genai
+import google.genai as genai
 from google.api_core.exceptions import ResourceExhausted
 from google.genai import types
-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, VendorBase
-from synth_ai.zyk.lms.constants import (
+from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
+from synth_ai.lm.constants import (
     SPECIAL_BASE_TEMPS,
     GEMINI_REASONING_MODELS,
     GEMINI_THINKING_BUDGETS,
 )
-from synth_ai.zyk.lms.vendors.retries import BACKOFF_TOLERANCE, MAX_BACKOFF, backoff
+from synth_ai.lm.vendors.retries import BACKOFF_TOLERANCE, MAX_BACKOFF, backoff
 import logging
 
 
@@ -59,7 +59,6 @@ class GeminiAPI(VendorBase):
         self.used_for_structured_outputs = used_for_structured_outputs
         self.exceptions_to_retry = exceptions_to_retry
 
-
     def get_aliased_model_name(self, model_name: str) -> str:
         if model_name in ALIASES:
             return ALIASES[model_name]
@@ -77,7 +76,9 @@ class GeminiAPI(VendorBase):
             if m["role"].lower() not in ["user", "assistant"]:
                 continue
             role = "user" if m["role"] == "user" else "assistant"
-            contents.append(types.Content(role=role, parts=[types.Part.from_text(text=m["content"])]))
+            contents.append(
+                types.Content(role=role, parts=[types.Part.from_text(text=m["content"])])
+            )
         return contents
 
     @staticmethod
@@ -86,19 +87,19 @@ class GeminiAPI(VendorBase):
         out: List[types.Tool] = []
         for t in tools:
             # Assume t.to_gemini_tool() now correctly returns a FunctionDeclaration
-            #func_decl = t.to_gemini_tool()
+            # func_decl = t.to_gemini_tool()
             if isinstance(t, dict):
                 func_decl = t
             else:
                 func_decl = t.to_gemini_tool()
             if not isinstance(func_decl, types.FunctionDeclaration):
-                 # Or fetch schema parts if to_gemini_tool still returns dict
-                 # This depends on BaseTool.to_gemini_tool implementation
-                tool_dict = func_decl # Assuming it's a dict for now
+                # Or fetch schema parts if to_gemini_tool still returns dict
+                # This depends on BaseTool.to_gemini_tool implementation
+                tool_dict = func_decl  # Assuming it's a dict for now
                 func_decl = types.FunctionDeclaration(
-                    name=tool_dict['name'],
-                    description=tool_dict['description'],
-                    parameters=tool_dict['parameters'], # Expects OpenAPI-style dict
+                    name=tool_dict["name"],
+                    description=tool_dict["description"],
+                    parameters=tool_dict["parameters"],  # Expects OpenAPI-style dict
                 )
             out.append(types.Tool(function_declarations=[func_decl]))
         return out
@@ -118,21 +119,23 @@ class GeminiAPI(VendorBase):
             cfg_kwargs["thinking_config"] = types.ThinkingConfig(
                 thinking_budget=GEMINI_THINKING_BUDGETS[reasoning_effort]
             )
-        
+
         if any(m["role"] == "system" for m in messages):
-            cfg_kwargs["system_instruction"] = next(m["content"] for m in messages if m["role"] == "system")
-        
+            cfg_kwargs["system_instruction"] = next(
+                m["content"] for m in messages if m["role"] == "system"
+            )
+
         generation_config = types.GenerateContentConfig(
             **cfg_kwargs,
             tool_config=lm_config.get("tool_config") if lm_config else None,
-            tools=self._tools_to_genai(tools) if tools else None
+            tools=self._tools_to_genai(tools) if tools else None,
         )
         client = _get_client()
         resp = await client.aio.models.generate_content(
             model=model_name,
             contents=self._msg_to_contents(messages),
             config=generation_config,
-            #safety_settings=SAFETY_SETTINGS,
+            # safety_settings=SAFETY_SETTINGS,
         )
         return self._extract(resp)
 
@@ -152,11 +155,13 @@ class GeminiAPI(VendorBase):
                 thinking_budget=GEMINI_THINKING_BUDGETS[reasoning_effort]
             )
         if any(m["role"] == "system" for m in messages):
-            cfg_kwargs["system_instruction"] = next(m["content"] for m in messages if m["role"] == "system")
+            cfg_kwargs["system_instruction"] = next(
+                m["content"] for m in messages if m["role"] == "system"
+            )
         generation_config = types.GenerateContentConfig(
             **cfg_kwargs,
             tool_config=lm_config.get("tool_config") if lm_config else None,
-            tools=self._tools_to_genai(tools) if tools else None
+            tools=self._tools_to_genai(tools) if tools else None,
         )
 
         client = _get_client()
@@ -173,8 +178,8 @@ class GeminiAPI(VendorBase):
         # Extract text, handling cases where it might be missing
         try:
             text = response.text
-        except ValueError: # Handle cases where only non-text parts exist
-            text = "" 
+        except ValueError:  # Handle cases where only non-text parts exist
+            text = ""
 
         calls = []
         # Access parts through candidates[0].content
@@ -209,9 +214,9 @@ class GeminiAPI(VendorBase):
         reasoning_effort: str = "high",
         tools: Optional[List[BaseTool]] = None,
     ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
+        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)
         lm_config["reasoning_effort"] = reasoning_effort
         cache_result = used_cache_handler.hit_managed_cache(
@@ -258,12 +263,10 @@ class GeminiAPI(VendorBase):
         reasoning_effort: str = "high",
         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=use_ephemeral_cache_only
+        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=use_ephemeral_cache_only)
         lm_config["reasoning_effort"] = reasoning_effort
         cache_result = used_cache_handler.hit_managed_cache(
             model, messages, lm_config=lm_config, tools=tools

synth_ai/{zyk/lms → lm}/vendors/core/mistral_api.py

@@ -6,11 +6,11 @@ import pydantic
 from mistralai import Mistral  # use Mistral as both sync and async client
 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, VendorBase
-from synth_ai.zyk.lms.constants import SPECIAL_BASE_TEMPS
-from synth_ai.zyk.lms.vendors.core.openai_api import OpenAIStructuredOutputClient
+from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
+from synth_ai.lm.vendors.core.openai_api import OpenAIStructuredOutputClient
 
 # Since the mistralai package doesn't expose an exceptions module,
 # we fallback to catching all Exceptions for retry.
@@ -47,9 +47,9 @@ class MistralAPI(VendorBase):
         reasoning_effort: str = "high",
         tools: Optional[List[BaseTool]] = None,
     ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
+        assert lm_config.get("response_model", None) is None, (
+            "response_model is not supported for standard calls"
+        )
         assert not (response_model and tools), "Cannot provide both response_model and tools"
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         lm_config["reasoning_effort"] = reasoning_effort
@@ -69,20 +69,15 @@ class MistralAPI(VendorBase):
                 )
             )
 
-        mistral_messages = [
-            {"role": msg["role"], "content": msg["content"]} for msg in messages
-        ]
+        mistral_messages = [{"role": msg["role"], "content": msg["content"]} for msg in messages]
         functions = [tool.to_mistral_tool() for tool in tools] if tools else None
         params = {
             "model": model,
             "messages": mistral_messages,
             "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            ),
+            "temperature": lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
             "stream": False,
             "tool_choice": "auto" if functions else None,
-            
         }
         if response_model:
             params["response_format"] = response_model
@@ -142,11 +137,11 @@ class MistralAPI(VendorBase):
         reasoning_effort: str = "high",
         tools: Optional[List[BaseTool]] = None,
     ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
+        assert lm_config.get("response_model", None) is None, (
+            "response_model is not supported for standard calls"
+        )
         assert not (response_model and tools), "Cannot provide both response_model and tools"
-       
+
         used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
         lm_config["reasoning_effort"] = reasoning_effort
         cache_result = used_cache_handler.hit_managed_cache(
@@ -165,21 +160,17 @@ class MistralAPI(VendorBase):
                 )
             )
 
-        mistral_messages = [
-            {"role": msg["role"], "content": msg["content"]} for msg in messages
-        ]
+        mistral_messages = [{"role": msg["role"], "content": msg["content"]} for msg in messages]
         functions = [tool.to_mistral_tool() for tool in tools] if tools else None
-        
+
         params = {
             "model": model,
             "messages": mistral_messages,
             "max_tokens": lm_config.get("max_tokens", 4096),
-            "temperature": lm_config.get(
-                "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-            ),
+            "temperature": lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
             "stream": False,
             "tool_choice": "auto" if functions else None,
-            #"tools": functions,
+            # "tools": functions,
         }
         if response_model:
             params["response_format"] = response_model
@@ -328,4 +319,4 @@ if __name__ == "__main__":
 
     response = asyncio.run(run_async())
     t2 = time.time()
-    print(f"Got {len(response.name)} chars in {t2-t} seconds")
+    print(f"Got {len(response.name)} chars in {t2 - t} seconds")

synth_ai/{zyk/lms → lm}/vendors/core/openai_api.py

@@ -7,11 +7,11 @@ import pydantic_core
 # from openai import AsyncOpenAI, OpenAI
 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.constants import SPECIAL_BASE_TEMPS, OPENAI_REASONING_MODELS
-from synth_ai.zyk.lms.vendors.openai_standard import OpenAIStandard
+from synth_ai.lm.caching.initialize import get_cache_handler
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS, OPENAI_REASONING_MODELS
+from synth_ai.lm.vendors.openai_standard import OpenAIStandard
 
 OPENAI_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
     pydantic_core._pydantic_core.ValidationError,
@@ -29,7 +29,7 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
     def __init__(self, synth_logging: bool = True):
         if synth_logging:
             # print("Using synth logging - OpenAIStructuredOutputClient")
-            from synth_sdk import AsyncOpenAI, OpenAI
+            from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
         else:
             # print("Not using synth logging - OpenAIStructuredOutputClient")
             from openai import AsyncOpenAI, OpenAI
@@ -54,29 +54,25 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
         if tools:
             raise ValueError("Tools are not supported for async structured output")
         # "Hit client")
-        lm_config = {"temperature": temperature, "response_model": response_model, "reasoning_effort": reasoning_effort}
-        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
-        )
+        lm_config = {
+            "temperature": temperature,
+            "response_model": response_model,
+            "reasoning_effort": reasoning_effort,
+        }
+        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)
         if cache_result:
             # print("Hit cache")
             assert type(cache_result) in [
                 dict,
                 BaseLMResponse,
             ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return (
-                cache_result["response"] if type(cache_result) == dict else cache_result
-            )
+            return cache_result["response"] if type(cache_result) == dict else cache_result
         if model in OPENAI_REASONING_MODELS:
             output = await self.async_client.beta.chat.completions.parse(
                 model=model,
                 messages=messages,
-                temperature=lm_config.get(
-                    "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-                ),
+                temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
                 response_format=response_model,
                 reasoning_effort=reasoning_effort,
             )
@@ -93,9 +89,7 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
             structured_output=api_result,
             tool_calls=None,
         )
-        used_cache_handler.add_to_managed_cache(
-            model, messages, lm_config, output=lm_response
-        )
+        used_cache_handler.add_to_managed_cache(model, messages, lm_config, output=lm_response)
         return lm_response
 
     def _hit_api_sync_structured_output(
@@ -110,28 +104,24 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
     ) -> str:
         if tools:
             raise ValueError("Tools are not supported for sync structured output")
-        lm_config = {"temperature": temperature, "response_model": response_model, "reasoning_effort": reasoning_effort}
-        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
-        )
+        lm_config = {
+            "temperature": temperature,
+            "response_model": response_model,
+            "reasoning_effort": reasoning_effort,
+        }
+        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)
         if cache_result:
             assert type(cache_result) in [
                 dict,
                 BaseLMResponse,
             ], f"Expected dict or BaseLMResponse, got {type(cache_result)}"
-            return (
-                cache_result["response"] if type(cache_result) == dict else cache_result
-            )
+            return cache_result["response"] if type(cache_result) == dict else cache_result
         if model in OPENAI_REASONING_MODELS:
             output = self.sync_client.beta.chat.completions.parse(
                 model=model,
                 messages=messages,
-                temperature=lm_config.get(
-                    "temperature", SPECIAL_BASE_TEMPS.get(model, 0)
-                ),
+                temperature=lm_config.get("temperature", SPECIAL_BASE_TEMPS.get(model, 0)),
                 response_format=response_model,
                 reasoning_effort=reasoning_effort,
             )
@@ -158,7 +148,7 @@ class OpenAIPrivate(OpenAIStandard):
     def __init__(self, synth_logging: bool = True):
         if synth_logging:
             # print("Using synth logging - OpenAIPrivate")
-            from synth_sdk import AsyncOpenAI, OpenAI
+            from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
         else:
             # print("Not using synth logging - OpenAIPrivate")
             from openai import AsyncOpenAI, OpenAI

synth_ai/{zyk/lms → lm}/vendors/openai_standard.py

@@ -5,13 +5,13 @@ import openai
 import pydantic_core
 from pydantic import BaseModel
 
-from synth_ai.zyk.lms.caching.initialize import (
+from synth_ai.lm.caching.initialize import (
     get_cache_handler,
 )
-from synth_ai.zyk.lms.tools.base import BaseTool
-from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.zyk.lms.constants import SPECIAL_BASE_TEMPS
-from synth_ai.zyk.lms.vendors.retries import MAX_BACKOFF
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
+from synth_ai.lm.constants import SPECIAL_BASE_TEMPS
+from synth_ai.lm.vendors.retries import MAX_BACKOFF
 import backoff
 
 DEFAULT_EXCEPTIONS_TO_RETRY = (
@@ -24,9 +24,7 @@ DEFAULT_EXCEPTIONS_TO_RETRY = (
 )
 
 
-def special_orion_transform(
-    model: str, messages: List[Dict[str, Any]]
-) -> List[Dict[str, Any]]:
+def special_orion_transform(model: str, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     if "o1-" in model:
         messages = [
             {
@@ -76,9 +74,9 @@ class OpenAIStandard(VendorBase):
         reasoning_effort: str = "high",
         tools: Optional[List[BaseTool]] = None,
     ) -> BaseLMResponse:
-        assert (
-            lm_config.get("response_model", None) is None
-        ), "response_model is not supported for standard calls"
+        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)
         lm_config["reasoning_effort"] = reasoning_effort
@@ -156,13 +154,11 @@ class OpenAIStandard(VendorBase):
         reasoning_effort: str = "high",
         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=use_ephemeral_cache_only
+        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=use_ephemeral_cache_only)
         lm_config["reasoning_effort"] = reasoning_effort
         cache_result = used_cache_handler.hit_managed_cache(
             model, messages, lm_config=lm_config, tools=tools
@@ -231,12 +227,14 @@ class OpenAIStandard(VendorBase):
         reasoning_effort: str = "high",
         tools: Optional[List[BaseTool]] = None,
     ) -> BaseLMResponse:
-        lm_config = {"temperature": temperature, "response_model": response_model, "reasoning_effort": reasoning_effort}
+        lm_config = {
+            "temperature": temperature,
+            "response_model": response_model,
+            "reasoning_effort": reasoning_effort,
+        }
         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
-            )
+        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
@@ -265,9 +263,7 @@ class OpenAIStandard(VendorBase):
 
         output = await self.async_client.chat.completions.create(**api_params)
 
-        structured_output_api_result = response_model(
-            **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,
@@ -290,12 +286,14 @@ class OpenAIStandard(VendorBase):
         reasoning_effort: str = "high",
         tools: Optional[List[BaseTool]] = None,
     ) -> BaseLMResponse:
-        lm_config = {"temperature": temperature, "response_model": response_model, "reasoning_effort": reasoning_effort}
+        lm_config = {
+            "temperature": temperature,
+            "response_model": response_model,
+            "reasoning_effort": reasoning_effort,
+        }
         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
-            )
+        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
@@ -324,9 +322,7 @@ class OpenAIStandard(VendorBase):
 
         output = self.sync_client.chat.completions.create(**api_params)
 
-        structured_output_api_result = response_model(
-            **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,

synth_ai/{zyk/lms → lm}/vendors/retries.py

@@ -11,4 +11,4 @@ BACKOFF_TOLERANCE: int = 20
 try:
     MAX_BACKOFF: int = max(1, int(os.getenv("SYNTH_AI_MAX_BACKOFF", "120")))
 except ValueError:
-    MAX_BACKOFF = 120
+    MAX_BACKOFF = 120