synth-ai 0.1.0.dev14__tar.gz → 0.1.0.dev51__tar.gz

{synth_ai-0.1.0.dev14 → synth_ai-0.1.0.dev51}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.1.0.dev14
+Version: 0.1.0.dev51
 Summary: Software for aiding the best and multiplying the will.
 Home-page: https://github.com/synth-laboratories/synth-ai
 Author: Josh Purtell
@@ -35,24 +35,23 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: openai
-Requires-Dist: pydantic
-Requires-Dist: diskcache
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: diskcache>=5.0.0
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: anthropic>=0.34.2
 Requires-Dist: google>=3.0.0
-Requires-Dist: google-generativeai>=0.8.1
+Requires-Dist: google-api-core
+Requires-Dist: google-generativeai
 Requires-Dist: together>=1.2.12
 Requires-Dist: langfuse>=2.56.1
-Requires-Dist: synth-sdk>=0.3.1.dev4
 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
+Requires-Dist: mistralai
 Dynamic: author
 Dynamic: home-page
+Dynamic: license-file
 
 AI Infra used by the Synth AI Team
 ```

{synth_ai-0.1.0.dev14 → synth_ai-0.1.0.dev51}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.1.0.dev14"
+version = "0.1.0.dev51"
 description = "Software for aiding the best and multiplying the will."
 readme = "README.md"
 authors = [{ name = "Josh Purtell", email = "josh@usesynth.ai" }]
@@ -12,22 +12,20 @@ classifiers = [
 ]
 keywords = ["synth-ai"]
 dependencies = [
-    "openai",
-    "pydantic",
-    "diskcache",
+    "openai>=1.0.0",
+    "pydantic>=2.0.0",
+    "diskcache>=5.0.0",
     "backoff>=2.2.1",
     "anthropic>=0.34.2",
     "google>=3.0.0",
-    "google-generativeai>=0.8.1",
+    "google-api-core",
+    "google-generativeai",
     "together>=1.2.12",
     "langfuse>=2.56.1",
-    "synth-sdk>=0.3.1.dev4",
     "datasets>=3.2.0",
     "groq>=0.18.0",
     "pytest-timeout>=2.3.1",
-    "lock>=2018.3.25.2110",
-    "ollama>=0.4.7",
-    "mistralai>=1.5.0",
+    "mistralai",
 ]
 requires-python = ">=3.10"
 
@@ -38,9 +36,9 @@ Homepage = "https://github.com/synth-laboratories/synth-ai"
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
-[tool.setuptools]
-packages.find = {namespaces = true}
-package-dir = {"synth_ai" = "synth_ai"}
+[tool.setuptools.packages.find]
+where = ["."]  # Assumes 'synth_ai' package is in a dir named 'synth_ai' at this level
+include = ["synth_ai*"]
 
 # Explicitly exclude test directories and files
 [tool.setuptools.exclude-package-data]

{synth_ai-0.1.0.dev14 → synth_ai-0.1.0.dev51}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="synth-ai",
-    version="0.1.0.dev14",
+    version="0.0.0.dev1",
     packages=find_packages(),
     install_requires=[
         "openai",

{synth_ai-0.1.0.dev14 → synth_ai-0.1.0.dev51}/synth_ai/__init__.py

@@ -4,5 +4,7 @@ Synth AI - Software for aiding the best and multiplying the will.
 
 from importlib.metadata import version
 
+from synth_ai.zyk import LM  # Assuming LM is in zyk.py in the same directory
 
 __version__ = version("synth-ai")  # Gets version from installed package metadata
+__all__ = ["LM"]  # Explicitly define public API

synth_ai-0.1.0.dev51/synth_ai/zyk/__init__.py

@@ -0,0 +1,3 @@
+from synth_ai.zyk.lms.core.main import LM
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+__all__ = ["LM", "BaseLMResponse"]

synth_ai-0.1.0.dev51/synth_ai/zyk/lms/caching/ephemeral.py

@@ -0,0 +1,72 @@
+import os
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from diskcache import Cache
+from pydantic import BaseModel
+
+from synth_ai.zyk.lms.caching.constants import DISKCACHE_SIZE_LIMIT
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+
+
+@dataclass
+class EphemeralCache:
+    def __init__(self, fast_cache_dir: str = ".cache/ephemeral_cache"):
+        os.makedirs(fast_cache_dir, exist_ok=True)
+        self.fast_cache = Cache(fast_cache_dir, size_limit=DISKCACHE_SIZE_LIMIT)
+
+    def hit_cache(
+        self, key: str, response_model: Optional[BaseModel] = None
+    ) -> Optional[BaseLMResponse]:
+        if key not in self.fast_cache:
+            return None
+
+        try:
+            cache_data = self.fast_cache[key]
+        except AttributeError:
+            return None
+
+        if not isinstance(cache_data, dict):
+            return BaseLMResponse(
+                raw_response=cache_data, structured_output=None, tool_calls=None
+            )
+
+        raw_response = cache_data.get("raw_response")
+        tool_calls = cache_data.get("tool_calls")
+        structured_output = cache_data.get("structured_output")
+
+        if response_model and structured_output:
+            structured_output = response_model(**structured_output)
+
+        return BaseLMResponse(
+            raw_response=raw_response,
+            structured_output=structured_output,
+            tool_calls=tool_calls,
+        )
+
+    def add_to_cache(self, key: str, response: Union[BaseLMResponse, str]) -> None:
+        if isinstance(response, str):
+            self.fast_cache[key] = response
+            return
+
+        if isinstance(response, BaseLMResponse):
+            cache_data = {
+                "raw_response": response.raw_response
+                if response.raw_response is not None
+                else None,
+                "tool_calls": response.tool_calls
+                if response.tool_calls is not None
+                else None,
+                "structured_output": (
+                    response.structured_output.model_dump()
+                    if response.structured_output is not None
+                    else None
+                ),
+            }
+            self.fast_cache[key] = cache_data
+            return
+
+        raise ValueError(f"Invalid response type: {type(response)}")
+
+    def close(self):
+        self.fast_cache.close()

synth_ai-0.1.0.dev51/synth_ai/zyk/lms/caching/handler.py

@@ -0,0 +1,137 @@
+import hashlib
+from typing import Any, Dict, List, Optional, Type
+
+from pydantic import BaseModel
+
+from synth_ai.zyk.lms.caching.ephemeral import EphemeralCache
+from synth_ai.zyk.lms.caching.persistent import PersistentCache
+from synth_ai.zyk.lms.tools.base import BaseTool
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+
+persistent_cache = PersistentCache()
+ephemeral_cache = EphemeralCache()
+
+import logging
+logger = logging.getLogger(__name__)
+
+def map_params_to_key(
+    messages: List[Dict],
+    model: str,
+    temperature: float,
+    response_model: Optional[Type[BaseModel]],
+    tools: Optional[List[BaseTool]] = None,
+    reasoning_effort: str = "low",
+) -> str:
+    if any(m is None for m in messages):
+        raise ValueError("Messages cannot contain None values - messages: ", messages)
+    if not all([isinstance(msg["content"], str) for msg in messages]):
+        normalized_messages = "".join([str(msg["content"]) for msg in messages])
+    else:
+        normalized_messages = "".join([msg["content"] for msg in messages])
+    normalized_model = model
+    normalized_temperature = f"{temperature:.2f}"[:4]
+    normalized_response_model = str(response_model.schema()) if response_model else ""
+    normalized_reasoning_effort = reasoning_effort if reasoning_effort else ""
+
+    # Normalize tools if present
+    normalized_tools = ""
+    if tools and all(isinstance(tool, BaseTool) for tool in 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(),
+            }
+            tool_schemas.append(str(tool_schema))
+        #logger.error(f"Tool schemas: {tool_schemas}")
+        normalized_tools = "".join(tool_schemas)
+    elif tools:
+        logger.error(f"Tools: {tools}")
+        normalized_tools = "".join([str(tool) for tool in tools])
+
+    key_str = ""
+    components = [
+        normalized_messages,
+        normalized_model,
+        normalized_temperature,
+        normalized_response_model,
+        normalized_tools,
+        normalized_reasoning_effort
+    ]
+    for component in components:
+        if component:
+            key_str += str(component)
+
+    return hashlib.sha256(key_str.encode()).hexdigest() 
+
+
+class CacheHandler:
+    use_persistent_store: bool = False
+    use_ephemeral_store: bool = True
+
+    def __init__(
+        self, use_persistent_store: bool = False, use_ephemeral_store: bool = True
+    ):
+        self.use_persistent_store = use_persistent_store
+        self.use_ephemeral_store = use_ephemeral_store
+
+    def _validate_messages(self, messages: List[Dict[str, Any]]) -> None:
+        """Validate that messages are in the correct format."""
+        assert all(
+            [type(msg["content"]) == str for msg in messages]
+        ), "All message contents must be strings"
+
+    def hit_managed_cache(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        lm_config: Dict[str, Any],
+        tools: Optional[List[BaseTool]] = None,
+    ) -> Optional[BaseLMResponse]:
+        """Hit the cache with the given key."""
+        self._validate_messages(messages)
+        assert type(lm_config) == dict, "lm_config must be a dictionary"
+        key = map_params_to_key(
+            messages,
+            model,
+            lm_config.get("temperature", 0.0),
+            lm_config.get("response_model", None),
+            tools,
+            lm_config.get("reasoning_effort", "low"),
+        )
+        if self.use_persistent_store:
+            return persistent_cache.hit_cache(
+                key=key, response_model=lm_config.get("response_model", None)
+            )
+        elif self.use_ephemeral_store:
+            return ephemeral_cache.hit_cache(
+                key=key, response_model=lm_config.get("response_model", None)
+            )
+        else:
+            return None
+
+    def add_to_managed_cache(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        lm_config: Dict[str, Any],
+        output: BaseLMResponse,
+        tools: Optional[List[BaseTool]] = None,
+    ) -> None:
+        """Add the given output to the cache."""
+        self._validate_messages(messages)
+        assert type(output) == BaseLMResponse, "output must be a BaseLMResponse"
+        assert type(lm_config) == dict, "lm_config must be a dictionary"
+        key = map_params_to_key(
+            messages,
+            model,
+            lm_config.get("temperature", 0.0),
+            lm_config.get("response_model", None),
+            tools,
+            lm_config.get("reasoning_effort", "low"),
+        )
+        if self.use_persistent_store:
+            persistent_cache.add_to_cache(key, output)
+        if self.use_ephemeral_store:
+            ephemeral_cache.add_to_cache(key, output)

synth_ai-0.1.0.dev51/synth_ai/zyk/lms/caching/persistent.py

@@ -0,0 +1,83 @@
+import json
+import os
+import sqlite3
+from dataclasses import dataclass
+from typing import Optional, Type, Union
+
+from pydantic import BaseModel
+
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse
+
+
+@dataclass
+class PersistentCache:
+    def __init__(self, db_path: str = ".cache/persistent_cache.db"):
+        os.makedirs(os.path.dirname(db_path), exist_ok=True)
+        self.conn = sqlite3.connect(db_path)
+        self.cursor = self.conn.cursor()
+        self.cursor.execute("""CREATE TABLE IF NOT EXISTS cache
+                              (key TEXT PRIMARY KEY, response TEXT)""")
+        self.conn.commit()
+
+    def hit_cache(
+        self, key: str, response_model: Optional[Type[BaseModel]] = None
+    ) -> Optional[BaseLMResponse]:
+        self.cursor.execute("SELECT response FROM cache WHERE key = ?", (key,))
+        result = self.cursor.fetchone()
+        if not result:
+            return None
+
+        try:
+            cache_data = json.loads(result[0])
+        except json.JSONDecodeError:
+            # Handle legacy string responses
+            return BaseLMResponse(
+                raw_response=result[0], structured_output=None, tool_calls=None
+            )
+
+        if not isinstance(cache_data, dict):
+            return BaseLMResponse(
+                raw_response=cache_data, structured_output=None, tool_calls=None
+            )
+
+        raw_response = cache_data.get("raw_response")
+        tool_calls = cache_data.get("tool_calls")
+        structured_output = cache_data.get("structured_output")
+
+        if response_model and structured_output:
+            structured_output = response_model(**structured_output)
+
+        return BaseLMResponse(
+            raw_response=raw_response,
+            structured_output=structured_output,
+            tool_calls=tool_calls,
+        )
+
+    def add_to_cache(self, key: str, response: Union[BaseLMResponse, str]) -> None:
+        if isinstance(response, str):
+            cache_data = response
+        elif isinstance(response, BaseLMResponse):
+            cache_data = {
+                "raw_response": response.raw_response
+                if response.raw_response is not None
+                else None,
+                "tool_calls": response.tool_calls
+                if response.tool_calls is not None
+                else None,
+                "structured_output": (
+                    response.structured_output.model_dump()
+                    if response.structured_output is not None
+                    else None
+                ),
+            }
+        else:
+            raise ValueError(f"Invalid response type: {type(response)}")
+
+        self.cursor.execute(
+            "INSERT OR REPLACE INTO cache (key, response) VALUES (?, ?)",
+            (key, json.dumps(cache_data)),
+        )
+        self.conn.commit()
+
+    def close(self) -> None:
+        self.conn.close()

{synth_ai-0.1.0.dev14 → synth_ai-0.1.0.dev51}/synth_ai/zyk/lms/config.py

@@ -6,3 +6,5 @@ def should_use_cache() -> bool:
     load_dotenv()
     cache_env = os.getenv("USE_ZYK_CACHE", "true").lower()
     return cache_env not in ("false", "0", "no")
+
+reasoning_models = ["o1","o3-mini", "o3", "o4-mini", "claude-3-7-sonnet-latest"]

synth_ai-0.1.0.dev51/synth_ai/zyk/lms/constants.py

@@ -0,0 +1,22 @@
+OPENAI_REASONING_MODELS = ["o4", "o4-mini", "o3","o3-mini", "o1-mini", "o1"]
+CLAUDE_REASONING_MODELS = ["claude-3-7-sonnet-latest"]
+GEMINI_REASONING_MODELS = ["gemini-2.5-flash", "gemini-2.5-pro"]
+
+# Gemini models that support thinking
+GEMINI_REASONING_MODELS = ["gemini-2.5-flash", "gemini-2.5-pro"]
+GEMINI_THINKING_BUDGETS = {
+    "high": 10000,
+    "medium": 5000,
+    "low": 2500,
+}
+
+# Anthropic Sonnet 3.7 budgets
+SONNET_37_BUDGETS = {
+    "high": 8192,
+    "medium": 4096,
+    "low": 2048,
+}
+
+REASONING_MODELS = OPENAI_REASONING_MODELS + CLAUDE_REASONING_MODELS + GEMINI_REASONING_MODELS
+
+SPECIAL_BASE_TEMPS = {model: 1 for model in REASONING_MODELS}

{synth_ai-0.1.0.dev14 → synth_ai-0.1.0.dev51}/synth_ai/zyk/lms/core/main.py

@@ -10,9 +10,8 @@ from synth_ai.zyk.lms.core.vendor_clients import (
 )
 from synth_ai.zyk.lms.structured_outputs.handler import StructuredOutputHandler
 from synth_ai.zyk.lms.vendors.base import VendorBase
-
-REASONING_MODELS = ["deepseek-reasoner", "o1-mini", "o1-preview", "o1", "o3"]
-
+from synth_ai.zyk.lms.tools.base import BaseTool
+from synth_ai.zyk.lms.config import reasoning_models
 
 def build_messages(
     sys_msg: str,
@@ -108,7 +107,7 @@ class LM:
             {"max_retries": max_retries_dict.get(max_retries, 2)},
         )
         # Override temperature to 1 for reasoning models
-        effective_temperature = 1.0 if model_name in REASONING_MODELS else temperature
+        effective_temperature = 1.0 if model_name in reasoning_models else temperature
         self.lm_config = {"temperature": effective_temperature}
         self.model_name = model_name
 
@@ -120,6 +119,8 @@ class LM:
         images_as_bytes: List[Any] = [],
         response_model: Optional[BaseModel] = None,
         use_ephemeral_cache_only: bool = False,
+        tools: Optional[List[BaseTool]] = None,
+        reasoning_effort: str = "low",
     ):
         assert (system_message is None) == (
             user_message is None
@@ -127,37 +128,45 @@ 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"
         if messages is None:
             messages = build_messages(
                 system_message, user_message, images_as_bytes, self.model_name
             )
-
+        result = None
         if response_model:
             try:
-                return self.structured_output_handler.call_sync(
+                result = self.structured_output_handler.call_sync(
                     messages,
                     model=self.model_name,
                     lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    reasoning_effort=reasoning_effort,
                 )
             except StructuredOutputCoercionFailureException:
                 # print("Falling back to backup handler")
-                return self.backup_structured_output_handler.call_sync(
+                result = self.backup_structured_output_handler.call_sync(
                     messages,
                     model=self.model_name,
                     lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    reasoning_effort=reasoning_effort,
                 )
         else:
-            return self.client._hit_api_sync(
+            result = self.client._hit_api_sync(
                 messages=messages,
                 model=self.model_name,
                 lm_config=self.lm_config,
                 use_ephemeral_cache_only=use_ephemeral_cache_only,
+                tools=tools,
+                reasoning_effort=reasoning_effort,
             )
+        assert isinstance(result.raw_response, str), "Raw response must be a string"
+        assert (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(
         self,
@@ -167,6 +176,8 @@ class LM:
         images_as_bytes: List[Any] = [],
         response_model: Optional[BaseModel] = None,
         use_ephemeral_cache_only: bool = False,
+        tools: Optional[List[BaseTool]] = None,
+        reasoning_effort: str = "low",
     ):
         # "In respond_async")
         assert (system_message is None) == (
@@ -176,39 +187,47 @@ 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"
         if messages is None:
             messages = build_messages(
                 system_message, user_message, images_as_bytes, self.model_name
             )
-
+        result = None
         if response_model:
             try:
-                # "Trying structured output handler")
-                return await self.structured_output_handler.call_async(
+                print("Trying structured output handler")
+                result = await self.structured_output_handler.call_async(
                     messages,
                     model=self.model_name,
                     lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    reasoning_effort=reasoning_effort,
                 )
             except StructuredOutputCoercionFailureException:
-                # print("Falling back to backup handler")
-                return await self.backup_structured_output_handler.call_async(
+                print("Falling back to backup handler")
+                result = await self.backup_structured_output_handler.call_async(
                     messages,
                     model=self.model_name,
                     lm_config=self.lm_config,
                     response_model=response_model,
                     use_ephemeral_cache_only=use_ephemeral_cache_only,
+                    reasoning_effort=reasoning_effort,
                 )
         else:
-            # print("Calling API no response model")
-            return await self.client._hit_api_async(
+            #print("Calling API no response model")
+            result = await self.client._hit_api_async(
                 messages=messages,
                 model=self.model_name,
                 lm_config=self.lm_config,
                 use_ephemeral_cache_only=use_ephemeral_cache_only,
+                tools=tools,
+                reasoning_effort=reasoning_effort,
             )
-
+        assert isinstance(result.raw_response, str), "Raw response must be a string"
+        assert (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-0.1.0.dev14 → synth_ai-0.1.0.dev51}/synth_ai/zyk/lms/core/vendor_clients.py

@@ -5,15 +5,15 @@ from synth_ai.zyk.lms.core.all import (
     AnthropicClient,
     DeepSeekClient,
     GeminiClient,
+    GroqAPI,
+    MistralAPI,
     # OpenAIClient,
     OpenAIStructuredOutputClient,
     TogetherClient,
-    GroqAPI,
-    MistralAPI,
 )
 
 openai_naming_regexes: List[Pattern] = [
-    re.compile(r"^(ft:)?(o[1,3](-.*)?|gpt-.*)$"),
+    re.compile(r"^(ft:)?(o[1,3,4](-.*)?|gpt-.*)$"),
 ]
 openai_formatting_model_regexes: List[Pattern] = [
     re.compile(r"^(ft:)?gpt-4o(-.*)?$"),
@@ -23,6 +23,7 @@ anthropic_naming_regexes: List[Pattern] = [
 ]
 gemini_naming_regexes: List[Pattern] = [
     re.compile(r"^gemini-.*$"),
+    re.compile(r"^gemma[2-9].*$"),
 ]
 deepseek_naming_regexes: List[Pattern] = [
     re.compile(r"^deepseek-.*$"),