synth-ai 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

synth_ai/__init__.py

@@ -2,9 +2,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
+__version__ = "0.1.4"
 __all__ = ["LM"]  # Explicitly define public API

synth_ai/zyk/lms/core/all.py

@@ -8,6 +8,7 @@ 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
+from synth_ai.zyk.lms.vendors.supported.custom_endpoint import CustomEndpointAPI
 
 
 class OpenAIClient(OpenAIPrivate):
@@ -45,3 +46,8 @@ class GroqClient(GroqAPI):
 class MistralClient(MistralAPI):
     def __init__(self):
         super().__init__()
+
+
+class CustomEndpointClient(CustomEndpointAPI):
+    def __init__(self, endpoint_url: str):
+        super().__init__(endpoint_url=endpoint_url)

synth_ai/zyk/lms/core/vendor_clients.py

@@ -5,11 +5,12 @@ from synth_ai.zyk.lms.core.all import (
     AnthropicClient,
     DeepSeekClient,
     GeminiClient,
-    GroqAPI,
-    MistralAPI,
+    GroqClient,
+    MistralClient,
     # OpenAIClient,
     OpenAIStructuredOutputClient,
     TogetherClient,
+    CustomEndpointClient,
 )
 
 openai_naming_regexes: List[Pattern] = [
@@ -53,6 +54,15 @@ mistral_naming_regexes: List[Pattern] = [
     re.compile(r"^mistral-.*$"),
 ]
 
+# Custom endpoint patterns - check these before generic patterns
+custom_endpoint_naming_regexes: List[Pattern] = [
+    # Modal endpoints: org--app.modal.run
+    re.compile(r"^[a-zA-Z0-9\-]+--[a-zA-Z0-9\-]+\.modal\.run$"),
+    # Generic domain patterns for custom endpoints
+    re.compile(r"^[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+\.[a-zA-Z]+$"),  # domain.tld
+    re.compile(r"^[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+\.[a-zA-Z]+\/[a-zA-Z0-9\-\/]+$"),  # domain.tld/path
+]
+
 
 def get_client(
     model_name: str,
@@ -79,9 +89,12 @@ def get_client(
     elif any(regex.match(model_name) for regex in deepseek_naming_regexes):
         return DeepSeekClient()
     elif any(regex.match(model_name) for regex in groq_naming_regexes):
-        return GroqAPI()
+        return GroqClient()
     elif any(regex.match(model_name) for regex in mistral_naming_regexes):
-        return MistralAPI()
+        return MistralClient()
+    elif any(regex.match(model_name) for regex in custom_endpoint_naming_regexes):
+        # Custom endpoints are passed as the endpoint URL
+        return CustomEndpointClient(endpoint_url=model_name)
     elif any(regex.match(model_name) for regex in together_naming_regexes):
         return TogetherClient()
     else:

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

@@ -0,0 +1,394 @@
+import re
+import os
+import json
+import asyncio
+import time
+from typing import Any, Dict, List, Optional, Tuple, Type
+import requests
+import httpx
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import random
+from urllib.parse import urlparse
+
+from synth_ai.zyk.lms.vendors.base import BaseLMResponse, VendorBase
+from synth_ai.zyk.lms.tools.base import BaseTool
+from synth_ai.zyk.lms.caching.initialize import get_cache_handler
+
+# Exception types for retry
+CUSTOM_ENDPOINT_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
+    requests.RequestException, 
+    requests.Timeout,
+    httpx.RequestError,
+    httpx.TimeoutException
+)
+
+class CustomEndpointAPI(VendorBase):
+    """Generic vendor client for custom OpenAI-compatible endpoints."""
+    
+    used_for_structured_outputs: bool = False
+    exceptions_to_retry: List = list(CUSTOM_ENDPOINT_EXCEPTIONS_TO_RETRY)
+    
+    def __init__(self, endpoint_url: str):
+        # Validate and sanitize URL
+        self._validate_endpoint_url(endpoint_url)
+        self.endpoint_url = endpoint_url
+        
+        # Construct full chat completions URL
+        if endpoint_url.endswith('/'):
+            endpoint_url = endpoint_url[:-1]
+        self.chat_completions_url = f"https://{endpoint_url}/chat/completions"
+        self.health_url = f"https://{endpoint_url}/health"
+        
+        # Setup session with connection pooling and retries
+        self.session = self._create_session()
+        self.async_client = None  # Lazy init
+        
+        # Get auth token from environment (generic support for any auth)
+        self.auth_token = os.environ.get("CUSTOM_ENDPOINT_API_TOKEN")
+        
+    def _validate_endpoint_url(self, url: str) -> None:
+        """Validate endpoint URL format and prevent SSRF."""
+        # Block dangerous URL patterns
+        dangerous_patterns = [
+            "file://", "ftp://", "gopher://",
+            "localhost", "127.", "0.0.0.0",
+            "10.", "192.168.", "172.16.", "172.17.", "172.18.", "172.19.",
+            "172.20.", "172.21.", "172.22.", "172.23.", "172.24.", "172.25.",
+            "172.26.", "172.27.", "172.28.", "172.29.", "172.30.", "172.31.",
+            "169.254.",  # link-local
+            "::1", "fc00:", "fd00:", "fe80:",  # IPv6 private
+        ]
+        
+        for pattern in dangerous_patterns:
+            if pattern in url.lower():
+                raise ValueError(f"Blocked URL pattern for security: {pattern}")
+                
+        # Limit URL length
+        if len(url) > 256:
+            raise ValueError(f"Endpoint URL too long (max 256 chars)")
+            
+        # Basic URL format check
+        if not re.match(r'^[a-zA-Z0-9\-._~:/?#\[\]@!$&\'()*+,;=]+$', url):
+            raise ValueError(f"Invalid URL format: {url}")
+    
+    def _create_session(self) -> requests.Session:
+        """Create session with retry strategy and connection pooling."""
+        session = requests.Session()
+        
+        # Exponential backoff with jitter
+        retry_strategy = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["POST", "GET"]
+        )
+        
+        adapter = HTTPAdapter(
+            max_retries=retry_strategy,
+            pool_connections=10,
+            pool_maxsize=20
+        )
+        
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+        
+        return session
+    
+    async def _get_async_client(self) -> httpx.AsyncClient:
+        """Lazy init async client with shared retry logic."""
+        if self.async_client is None:
+            self.async_client = httpx.AsyncClient(
+                timeout=httpx.Timeout(30.0),
+                limits=httpx.Limits(max_connections=10, max_keepalive_connections=5)
+            )
+        return self.async_client
+    
+    def _get_timeout(self, lm_config: Dict[str, Any]) -> float:
+        """Get timeout with per-call override support."""
+        return lm_config.get("timeout", 
+                           float(os.environ.get("CUSTOM_ENDPOINT_REQUEST_TIMEOUT", "30")))
+    
+    def _get_temperature_override(self) -> Optional[float]:
+        """Get temperature override from environment for this specific endpoint."""
+        # Create a safe env var key from the endpoint URL
+        # e.g., "example.com/api" -> "CUSTOM_ENDPOINT_TEMP_EXAMPLE_COM_API"
+        safe_key = re.sub(r'[^A-Za-z0-9]', '_', self.endpoint_url).upper()
+        safe_key = safe_key[:64]  # Limit length
+        
+        env_key = f"CUSTOM_ENDPOINT_TEMP_{safe_key}"
+        temp_str = os.environ.get(env_key)
+        return float(temp_str) if temp_str else None
+    
+    def _compress_tool_schema(self, schema: Dict[str, Any]) -> Dict[str, Any]:
+        """Compress JSON schema to reduce token usage."""
+        if isinstance(schema, dict):
+            # Remove verbose keys
+            compressed = {
+                k: self._compress_tool_schema(v) 
+                for k, v in schema.items() 
+                if k not in ["title", "$ref", "$schema"]
+            }
+            # Shorten descriptions
+            if "description" in compressed and len(compressed["description"]) > 50:
+                compressed["description"] = compressed["description"][:47] + "..."
+            return compressed
+        elif isinstance(schema, list):
+            return [self._compress_tool_schema(item) for item in schema]
+        return schema
+    
+    def _inject_tools_into_prompt(self, system_message: str, tools: List[BaseTool]) -> str:
+        """Inject tool definitions with compressed schemas and clear output format."""
+        if not tools:
+            return system_message
+            
+        tool_descriptions = []
+        for tool in tools:
+            schema = tool.arguments.model_json_schema()
+            compressed_schema = self._compress_tool_schema(schema)
+            
+            tool_desc = f"Tool: {tool.name}\nDesc: {tool.description}\nParams: {json.dumps(compressed_schema, separators=(',', ':'))}"
+            tool_descriptions.append(tool_desc)
+        
+        tools_text = "\n".join(tool_descriptions)
+        
+        return f"""{system_message}
+
+Available tools:
+{tools_text}
+
+IMPORTANT: To use a tool, respond with JSON wrapped in ```json fences:
+```json
+{{"tool_call": {{"name": "tool_name", "arguments": {{...}}}}}}
+```
+
+For regular responses, just respond normally without JSON fences."""
+
+    def _extract_tool_calls(self, content: str, tools: List[BaseTool]) -> tuple[Optional[List], str]:
+        """Extract and validate tool calls from response."""
+        # Look for JSON fenced blocks
+        json_pattern = r'```json\s*(\{.*?\})\s*```'
+        matches = re.findall(json_pattern, content, re.DOTALL)
+        
+        if not matches:
+            return None, content
+            
+        tool_calls = []
+        cleaned_content = content
+        
+        for match in matches:
+            try:
+                tool_data = json.loads(match)
+                if "tool_call" in tool_data:
+                    call_data = tool_data["tool_call"]
+                    tool_name = call_data.get("name")
+                    
+                    # Validate against available tools
+                    matching_tool = next((t for t in tools if t.name == tool_name), None)
+                    if matching_tool:
+                        # Validate arguments with pydantic
+                        validated_args = matching_tool.arguments(**call_data.get("arguments", {}))
+                        tool_calls.append({
+                            "name": tool_name,
+                            "arguments": validated_args.model_dump()
+                        })
+                        
+                        # Remove tool call from content
+                        cleaned_content = cleaned_content.replace(f"```json\n{match}\n```", "").strip()
+                        
+            except (json.JSONDecodeError, Exception):
+                # Fall back to treating as normal text if validation fails
+                continue
+                
+        return tool_calls if tool_calls else None, cleaned_content
+    
+    def _exponential_backoff_with_jitter(self, attempt: int) -> float:
+        """Calculate backoff time with jitter to prevent thundering herd."""
+        base_delay = min(2 ** attempt, 32)  # Cap at 32 seconds
+        jitter = random.uniform(0, 1)
+        return base_delay + jitter
+    
+    def _handle_rate_limit(self, response: requests.Response) -> None:
+        """Extract and propagate rate limit information."""
+        if response.status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            if retry_after:
+                # Bubble up to synth-ai scheduler
+                raise requests.exceptions.RetryError(f"Rate limited. Retry after {retry_after}s")
+    
+    async def _hit_api_async(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        lm_config: Dict[str, Any],
+        use_ephemeral_cache_only: bool = False,
+        reasoning_effort: str = "low",
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        """Async API call with comprehensive error handling and streaming support."""
+        
+        # Cache integration - check first
+        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
+        cache_result = used_cache_handler.hit_managed_cache(
+            model, messages, lm_config=lm_config, tools=tools
+        )
+        if cache_result:
+            return cache_result
+        
+        # Apply tool injection
+        if tools and messages:
+            messages = messages.copy()
+            if messages and messages[0].get("role") == "system":
+                messages[0]["content"] = self._inject_tools_into_prompt(
+                    messages[0]["content"], tools
+                )
+        
+        # Prepare request
+        headers = {"Content-Type": "application/json"}
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+        
+        # Apply temperature override
+        temp_override = self._get_temperature_override()
+        request_temp = temp_override if temp_override else lm_config.get("temperature", 0.7)
+        
+        payload = {
+            "model": model,  # Pass through the model name
+            "messages": messages,
+            "temperature": request_temp,
+            "stream": lm_config.get("stream", False)
+        }
+        
+        timeout = self._get_timeout(lm_config)
+        client = await self._get_async_client()
+        
+        # Make request with retry logic
+        for attempt in range(3):
+            try:
+                response = await client.post(
+                    self.chat_completions_url,
+                    json=payload,
+                    headers=headers,
+                    timeout=timeout
+                )
+                
+                if response.status_code == 429:
+                    self._handle_rate_limit(response)
+                    
+                response.raise_for_status()
+                
+                response_data = response.json()
+                content = response_data["choices"][0]["message"]["content"]
+                
+                # Extract tool calls
+                tool_calls, clean_content = self._extract_tool_calls(content, tools or [])
+                
+                lm_response = BaseLMResponse(
+                    raw_response=clean_content,
+                    structured_output=None,
+                    tool_calls=tool_calls
+                )
+                
+                # Add to cache
+                used_cache_handler.add_to_managed_cache(
+                    model, messages, lm_config=lm_config, output=lm_response, tools=tools
+                )
+                
+                return lm_response
+                    
+            except (httpx.RequestError, httpx.TimeoutException) as e:
+                if attempt == 2:  # Last attempt
+                    raise
+                await asyncio.sleep(self._exponential_backoff_with_jitter(attempt))
+                
+    def _hit_api_sync(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        lm_config: Dict[str, Any],
+        use_ephemeral_cache_only: bool = False,
+        reasoning_effort: str = "low",
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        """Sync version with same logic as async."""
+        
+        # Cache integration - check first
+        used_cache_handler = get_cache_handler(use_ephemeral_cache_only)
+        cache_result = used_cache_handler.hit_managed_cache(
+            model, messages, lm_config=lm_config, tools=tools
+        )
+        if cache_result:
+            return cache_result
+        
+        # Apply tool injection
+        if tools and messages:
+            messages = messages.copy()
+            if messages and messages[0].get("role") == "system":
+                messages[0]["content"] = self._inject_tools_into_prompt(
+                    messages[0]["content"], tools
+                )
+        
+        # Prepare request
+        headers = {"Content-Type": "application/json"}
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+        
+        # Apply temperature override
+        temp_override = self._get_temperature_override()
+        request_temp = temp_override if temp_override else lm_config.get("temperature", 0.7)
+        
+        payload = {
+            "model": model,  # Pass through the model name
+            "messages": messages,
+            "temperature": request_temp,
+            "stream": lm_config.get("stream", False)
+        }
+        
+        timeout = self._get_timeout(lm_config)
+        
+        # Make request with retry logic
+        for attempt in range(3):
+            try:
+                response = self.session.post(
+                    self.chat_completions_url,
+                    json=payload,
+                    headers=headers,
+                    timeout=timeout
+                )
+                
+                if response.status_code == 429:
+                    self._handle_rate_limit(response)
+                    
+                response.raise_for_status()
+                
+                response_data = response.json()
+                content = response_data["choices"][0]["message"]["content"]
+                
+                # Extract tool calls
+                tool_calls, clean_content = self._extract_tool_calls(content, tools or [])
+                
+                lm_response = BaseLMResponse(
+                    raw_response=clean_content,
+                    structured_output=None,
+                    tool_calls=tool_calls
+                )
+                
+                # Add to cache
+                used_cache_handler.add_to_managed_cache(
+                    model, messages, lm_config=lm_config, output=lm_response, tools=tools
+                )
+                
+                return lm_response
+                    
+            except (requests.RequestException, requests.Timeout) as e:
+                if attempt == 2:  # Last attempt
+                    raise
+                time.sleep(self._exponential_backoff_with_jitter(attempt))
+    
+    def __del__(self):
+        """Cleanup resources."""
+        if hasattr(self, 'session'):
+            self.session.close()
+        if hasattr(self, 'async_client') and self.async_client:
+            # Schedule cleanup for async client
+            pass

synth_ai-0.1.4.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: synth-ai
+Version: 0.1.4
+Home-page: https://github.com/synth-laboratories/synth-ai
+Author: Josh Purtell
+Author-email: josh@usesynth.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai
+Requires-Dist: pydantic>=2.9.2
+Requires-Dist: diskcache
+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: together>=1.2.12
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+
+AI Infra used by the Synth AI Team
+```
+  _____             _   _                _____ 
+ / ____|           | | | |         /\   |_   _|
+| (___  _   _ _ __ | |_| |__      /  \    | |  
+ \___ \| | | | '_ \| __| '_ \    / /\ \   | |  
+ ____) | |_| | | | | |_| | | |  / ____ \ _| |_ 
+|_____/ \__, |_| |_|\__|_| |_| /_/    \_\_____|
+         __/ |                                 
+        |___/                                  
+```

{synth_ai-0.1.3.dist-info → synth_ai-0.1.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-synth_ai/__init__.py,sha256=dflUvGJ59nrEo81cf7GqUA4ExYbjePhQShSLsr1B0qE,325
+synth_ai/__init__.py,sha256=06VvZlwVtT7OXvu5iqFvWhLw46BmQsIAYQe8wHNUiB0,225
 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=UBMi0DIFQDBV_eGPK5vG8R7VwxXcV10BPGq1iV8vVjg,282
@@ -11,10 +11,10 @@ synth_ai/zyk/lms/caching/handler.py,sha256=HEo_e8q3kqDSVW0hN1AA6Rx5cBvlEeizi-kiO
 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/all.py,sha256=MAlhGk5LBK7En-oUzFBoemGl_GZbenmvqhlkSQ7cfGc,1410
 synth_ai/zyk/lms/core/exceptions.py,sha256=K0BVdAzxVIchsvYZAaHEH1GAWBZvpxhFi-SPcJOjyPQ,205
 synth_ai/zyk/lms/core/main.py,sha256=pLz7COTdvDWQivYaA1iYYF2onUOosD_sFaPJG48bdKM,10598
-synth_ai/zyk/lms/core/vendor_clients.py,sha256=ar5kUbzF91l0uWcBIDp5fKkrv6KWpvw-O3LN7dkP4Nk,2952
+synth_ai/zyk/lms/core/vendor_clients.py,sha256=7D30Ol-eVaJ8pZnbqeKADJ6q_Nz5buOd2qQJrrn8Rlk,3647
 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
@@ -22,7 +22,6 @@ synth_ai/zyk/lms/structured_outputs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQ
 synth_ai/zyk/lms/structured_outputs/handler.py,sha256=4DboLNZyXpqNB5YNCSgGHBsNbWqFk-8uwV944nOYNo8,16919
 synth_ai/zyk/lms/structured_outputs/inject.py,sha256=Fy-zDeleRxOZ8ZRM6IuZ6CP2XZnMe4K2PEn4Q9c_KPY,11777
 synth_ai/zyk/lms/structured_outputs/rehabilitate.py,sha256=ecKGWrgWYUSplqHzK40KdohwaN8gBV0xl4LUReLN_vg,7910
-synth_ai/zyk/lms/tools/base.py,sha256=i-AIVRlitiQ4JMJ_BBFRSpUcWgxWIUYoHxAqfxHN_7E,4056
 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/openai_standard.py,sha256=dgHC7RWrxwaWto6_frKdfEKazKvvAMYJM1YgJgbVpb8,12279
@@ -35,12 +34,13 @@ synth_ai/zyk/lms/vendors/core/openai_api.py,sha256=O5KbRpy0pDDofVjxgZdeU69ueUl6S
 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/custom_endpoint.py,sha256=awluDoUgcRROsZdH_o_Whe2D0MjQfOZOnmgWbESAbIQ,15523
 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.3.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
-synth_ai-0.1.3.dist-info/METADATA,sha256=BG1WVpscaA1qM4CBePMnBecdIu-p0X6CLXVvMOOWeFo,2760
-synth_ai-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-synth_ai-0.1.3.dist-info/top_level.txt,sha256=fBmtZyVHuKaGa29oHBaaUkrUIWTqSpoVMPiVdCDP3k8,9
-synth_ai-0.1.3.dist-info/RECORD,,
+synth_ai-0.1.4.dist-info/licenses/LICENSE,sha256=ynhjRQUfqA_RdGRATApfFA_fBAy9cno04sLtLUqxVFM,1069
+synth_ai-0.1.4.dist-info/METADATA,sha256=Bz_Gf7gZtnLIJdgjrD17XS_HQNj_oGlXdFufcrLP2Ko,1084
+synth_ai-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+synth_ai-0.1.4.dist-info/top_level.txt,sha256=fBmtZyVHuKaGa29oHBaaUkrUIWTqSpoVMPiVdCDP3k8,9
+synth_ai-0.1.4.dist-info/RECORD,,

synth_ai/zyk/lms/tools/base.py

@@ -1,118 +0,0 @@
-from typing import Type
-
-from pydantic import BaseModel
-
-
-class BaseTool(BaseModel):
-    name: str
-    arguments: Type[BaseModel]
-    description: str = ""
-    strict: bool = True
-
-    def to_openai_tool(self):
-        schema = self.arguments.model_json_schema()
-        schema["additionalProperties"] = False
-
-        if "properties" in schema:
-            for prop_name, prop_schema in schema["properties"].items():
-                if prop_schema.get("type") == "array":
-                    items_schema = prop_schema.get("items", {})
-                    if not isinstance(items_schema, dict) or not items_schema.get("type"):
-                        prop_schema["items"] = {"type": "string"}
-
-                elif "anyOf" in prop_schema:
-                    for sub_schema in prop_schema["anyOf"]:
-                        if isinstance(sub_schema, dict) and sub_schema.get("type") == "array":
-                            items_schema = sub_schema.get("items", {})
-                            if not isinstance(items_schema, dict) or not items_schema.get("type"):
-                                sub_schema["items"] = {"type": "string"}
-
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": schema,
-                "strict": self.strict,
-            },
-        }
-
-    def to_anthropic_tool(self):
-        schema = self.arguments.model_json_schema()
-        schema["additionalProperties"] = False
-
-        return {
-            "name": self.name,
-            "description": self.description,
-            "input_schema": {
-                "type": "object",
-                "properties": schema["properties"],
-                "required": schema.get("required", []),
-            },
-        }
-
-    def to_mistral_tool(self):
-        schema = self.arguments.model_json_schema()
-        properties = {}
-        for prop_name, prop in schema.get("properties", {}).items():
-            prop_type = prop["type"]
-            if prop_type == "array" and "items" in prop:
-                properties[prop_name] = {
-                    "type": "array",
-                    "items": prop["items"],
-                    "description": prop.get("description", ""),
-                }
-                continue
-
-            properties[prop_name] = {
-                "type": prop_type,
-                "description": prop.get("description", ""),
-            }
-            if "enum" in prop:
-                properties[prop_name]["enum"] = prop["enum"]
-
-        parameters = {
-            "type": "object",
-            "properties": properties,
-            "required": schema.get("required", []),
-            "additionalProperties": False,
-        }
-        return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": parameters,
-            },
-        }
-
-    def to_gemini_tool(self):
-        schema = self.arguments.model_json_schema()
-        # Convert Pydantic schema types to Gemini schema types
-        properties = {}
-        for name, prop in schema["properties"].items():
-            prop_type = prop.get("type", "string")
-            if prop_type == "array" and "items" in prop:
-                properties[name] = {
-                    "type": "array",
-                    "items": prop["items"],
-                    "description": prop.get("description", ""),
-                }
-                continue
-
-            properties[name] = {
-                "type": prop_type,
-                "description": prop.get("description", ""),
-            }
-            if "enum" in prop:
-                properties[name]["enum"] = prop["enum"]
-
-        return {
-            "name": self.name,
-            "description": self.description,
-            "parameters": {
-                "type": "object",
-                "properties": properties,
-                "required": schema.get("required", []),
-            },
-        }

synth_ai-0.1.3.dist-info/METADATA

@@ -1,67 +0,0 @@
-Metadata-Version: 2.4
-Name: synth-ai
-Version: 0.1.3
-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
-        
-        Copyright (c) 2024 Josh Purtell
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-Project-URL: Homepage, https://github.com/synth-laboratories/synth-ai
-Keywords: synth-ai
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-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-api-core
-Requires-Dist: google-generativeai
-Requires-Dist: google-genai
-Requires-Dist: together>=1.2.12
-Requires-Dist: langfuse<3.0.0,>=2.53.9
-Requires-Dist: datasets>=3.2.0
-Requires-Dist: groq>=0.18.0
-Requires-Dist: pytest-timeout>=2.3.1
-Requires-Dist: mistralai
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-
-AI Infra used by the Synth AI Team
-```
-  _____             _   _                _____ 
- / ____|           | | | |         /\   |_   _|
-| (___  _   _ _ __ | |_| |__      /  \    | |  
- \___ \| | | | '_ \| __| '_ \    / /\ \   | |  
- ____) | |_| | | | | |_| | | |  / ____ \ _| |_ 
-|_____/ \__, |_| |_|\__|_| |_| /_/    \_\_____|
-         __/ |                                 
-        |___/                                  
-```