synth-ai 0.1.0.dev49__py3-none-any.whl → 0.1.0.dev51__py3-none-any.whl

synth_ai/__init__.py

@@ -4,4 +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/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/zyk/lms/caching/constants.py

@@ -0,0 +1 @@
+DISKCACHE_SIZE_LIMIT = 10 * 1024 * 1024 * 1024 #10GB

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/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/zyk/lms/caching/initialize.py

@@ -0,0 +1,13 @@
+from synth_ai.zyk.lms.caching.handler import CacheHandler
+
+cache_handler = CacheHandler(use_ephemeral_store=True, use_persistent_store=True)
+ephemeral_cache_handler = CacheHandler(
+    use_ephemeral_store=True, use_persistent_store=False
+)
+
+
+def get_cache_handler(use_ephemeral_cache_only: bool = False):
+    if use_ephemeral_cache_only:
+        return ephemeral_cache_handler
+    else:
+        return cache_handler

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/zyk/lms/config.py

@@ -0,0 +1,10 @@
+import os
+from dotenv import load_dotenv
+
+
+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/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/zyk/lms/core/all.py

@@ -0,0 +1,47 @@
+from synth_ai.zyk.lms.vendors.core.anthropic_api import AnthropicAPI
+from synth_ai.zyk.lms.vendors.core.gemini_api import GeminiAPI
+from synth_ai.zyk.lms.vendors.core.openai_api import (
+    OpenAIPrivate,
+    OpenAIStructuredOutputClient,
+)
+from synth_ai.zyk.lms.vendors.supported.deepseek import DeepSeekAPI
+from synth_ai.zyk.lms.vendors.supported.together import TogetherAPI
+from synth_ai.zyk.lms.vendors.supported.groq import GroqAPI
+from synth_ai.zyk.lms.vendors.core.mistral_api import MistralAPI
+
+
+class OpenAIClient(OpenAIPrivate):
+    def __init__(self, synth_logging: bool = True):
+        super().__init__(
+            synth_logging=synth_logging,
+        )
+
+
+class AnthropicClient(AnthropicAPI):
+    def __init__(self):
+        super().__init__()
+
+
+class GeminiClient(GeminiAPI):
+    def __init__(self):
+        super().__init__()
+
+
+class DeepSeekClient(DeepSeekAPI):
+    def __init__(self):
+        super().__init__()
+
+
+class TogetherClient(TogetherAPI):
+    def __init__(self):
+        super().__init__()
+
+
+class GroqClient(GroqAPI):
+    def __init__(self):
+        super().__init__()
+
+
+class MistralClient(MistralAPI):
+    def __init__(self):
+        super().__init__()

synth_ai/zyk/lms/core/exceptions.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
+
+
+class StructuredOutputCoercionFailureException(Exception):
+    pass
+
+
+# ... rest of imports ...