synth-ai 0.2.4.dev6__py3-none-any.whl → 0.2.4.dev8__py3-none-any.whl

synth_ai/lm/vendors/openai_standard_responses.py

@@ -5,14 +5,11 @@ This module contains the Responses API and Harmony encoding methods
 that extend the OpenAIStandard class functionality.
 """
 
-from typing import Any, Dict, List, Optional
 import uuid
-from pydantic import BaseModel
+from typing import Any
 
 from synth_ai.lm.tools.base import BaseTool
 from synth_ai.lm.vendors.base import BaseLMResponse
-from synth_ai.lm.vendors.retries import MAX_BACKOFF
-import backoff
 
 
 def _silent_backoff_handler(_details):
@@ -27,23 +24,23 @@ DEFAULT_EXCEPTIONS_TO_RETRY = (
 
 class OpenAIResponsesAPIMixin:
     """Mixin class providing Responses API functionality for OpenAI vendors."""
-    
+
     async def _hit_api_async_responses(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        previous_response_id: Optional[str] = None,
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
+        previous_response_id: str | None = None,
         use_ephemeral_cache_only: bool = False,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
         """Use OpenAI Responses API for supported models."""
-        
+
         print(f"🔍 RESPONSES API: Called for model {model}")
         print(f"🔍 RESPONSES API: previous_response_id = {previous_response_id}")
-        
+
         # Check if the client has responses attribute
-        if not hasattr(self.async_client, 'responses'):
+        if not hasattr(self.async_client, "responses"):
             print("🔍 RESPONSES API: Client doesn't have responses attribute, using fallback")
             # Fallback - use chat completions with simulated response_id
             response = await self._hit_api_async(
@@ -53,21 +50,22 @@ class OpenAIResponsesAPIMixin:
                 use_ephemeral_cache_only=use_ephemeral_cache_only,
                 tools=tools,
             )
-            
+
             # Add Responses API fields
             if not response.response_id:
                 import uuid
+
                 response.response_id = str(uuid.uuid4())
             response.api_type = "responses"
             return response
-        
+
         # Use the official Responses API
         try:
             # Common API call params for Responses API
             api_params = {
                 "model": model,
             }
-            
+
             # For Responses API, we use 'input' parameter
             if previous_response_id:
                 # Continue existing thread
@@ -92,35 +90,37 @@ class OpenAIResponsesAPIMixin:
                         elif role == "assistant":
                             input_parts.append(f"Assistant: {content}")
                     api_params["input"] = "\n".join(input_parts)
-            
+
             # Add tools if provided
             if tools and all(isinstance(tool, BaseTool) for tool in tools):
                 api_params["tools"] = [tool.to_openai_tool() for tool in tools]
             elif tools:
                 api_params["tools"] = tools
-            
+
             # Add other parameters from lm_config if needed
             if "max_tokens" in lm_config:
                 api_params["max_tokens"] = lm_config["max_tokens"]
-            
+
             print(f"🔍 RESPONSES API: Calling with params: {list(api_params.keys())}")
-            
+
             # Call the Responses API
             response = await self.async_client.responses.create(**api_params)
-            
+
             print(f"🔍 RESPONSES API: Response received, type: {type(response)}")
-            
+
             # Extract fields from response
-            output_text = getattr(response, 'output_text', getattr(response, 'content', ''))
-            reasoning_obj = getattr(response, 'reasoning', None)
-            response_id = getattr(response, 'id', None)
-            
+            output_text = getattr(response, "output_text", getattr(response, "content", ""))
+            reasoning_obj = getattr(response, "reasoning", None)
+            response_id = getattr(response, "id", None)
+
             # Debug reasoning type (only first time)
-            if reasoning_obj and not hasattr(self, '_reasoning_logged'):
+            if reasoning_obj and not hasattr(self, "_reasoning_logged"):
                 print(f"🔍 RESPONSES API: Reasoning type: {type(reasoning_obj)}")
-                print(f"🔍 RESPONSES API: Reasoning attributes: {[x for x in dir(reasoning_obj) if not x.startswith('_')]}")
+                print(
+                    f"🔍 RESPONSES API: Reasoning attributes: {[x for x in dir(reasoning_obj) if not x.startswith('_')]}"
+                )
                 self._reasoning_logged = True
-            
+
             # Handle reasoning - it might be an object or a string
             reasoning = None
             if reasoning_obj:
@@ -130,22 +130,23 @@ class OpenAIResponsesAPIMixin:
                 else:
                     # OpenAI returns a Reasoning object
                     # Try to get summary first, but preserve entire object if no summary
-                    if hasattr(reasoning_obj, 'summary') and reasoning_obj.summary:
+                    if hasattr(reasoning_obj, "summary") and reasoning_obj.summary:
                         reasoning = reasoning_obj.summary
                     else:
                         # Preserve the full object structure as JSON
                         # This includes effort level and any other fields
-                        if hasattr(reasoning_obj, 'model_dump_json'):
+                        if hasattr(reasoning_obj, "model_dump_json"):
                             reasoning = reasoning_obj.model_dump_json()
-                        elif hasattr(reasoning_obj, 'to_dict'):
+                        elif hasattr(reasoning_obj, "to_dict"):
                             import json
+
                             reasoning = json.dumps(reasoning_obj.to_dict())
                         else:
                             reasoning = str(reasoning_obj)
-            
+
             # Handle tool calls if present
             tool_calls = None
-            if hasattr(response, 'tool_calls') and response.tool_calls:
+            if hasattr(response, "tool_calls") and response.tool_calls:
                 tool_calls = [
                     {
                         "id": tc.id,
@@ -157,9 +158,9 @@ class OpenAIResponsesAPIMixin:
                     }
                     for tc in response.tool_calls
                 ]
-            
+
             print(f"🔍 RESPONSES API: Extracted response_id = {response_id}")
-            
+
             return BaseLMResponse(
                 raw_response=output_text,
                 response_id=response_id,
@@ -167,7 +168,7 @@ class OpenAIResponsesAPIMixin:
                 api_type="responses",
                 tool_calls=tool_calls,
             )
-            
+
         except (AttributeError, Exception) as e:
             print(f"🔍 RESPONSES API: Error calling Responses API: {e}")
             # No fallback - raise the error
@@ -176,68 +177,80 @@ class OpenAIResponsesAPIMixin:
     async def _hit_api_async_harmony(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
-        previous_response_id: Optional[str] = None,
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
+        previous_response_id: str | None = None,
         use_ephemeral_cache_only: bool = False,
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
         """Use Harmony encoding for OSS-GPT models."""
         if not self.harmony_available:
-            raise ImportError("openai-harmony package required for OSS-GPT models. Install with: pip install openai-harmony")
-        
-        from openai_harmony import Message, Role, Conversation
-        
+            raise ImportError(
+                "openai-harmony package required for OSS-GPT models. Install with: pip install openai-harmony"
+            )
+
+        from openai_harmony import Conversation, Message, Role
+
         # Convert messages to Harmony format
         harmony_messages = []
         for msg in messages:
-            role = Role.SYSTEM if msg["role"] == "system" else (
-                Role.USER if msg["role"] == "user" else Role.ASSISTANT
+            role = (
+                Role.SYSTEM
+                if msg["role"] == "system"
+                else (Role.USER if msg["role"] == "user" else Role.ASSISTANT)
             )
             content = msg["content"]
             # Handle multimodal content
             if isinstance(content, list):
                 # Extract text content for now
-                text_parts = [part.get("text", "") for part in content if part.get("type") == "text"]
+                text_parts = [
+                    part.get("text", "") for part in content if part.get("type") == "text"
+                ]
                 content = " ".join(text_parts)
             harmony_messages.append(Message.from_role_and_content(role, content))
-        
+
         conv = Conversation.from_messages(harmony_messages)
         tokens = self.harmony_enc.render_conversation_for_completion(conv, Role.ASSISTANT)
-        
+
         # For now, we'll need to integrate with Synth GPU endpoint
         # This would require the actual endpoint to be configured
         # Placeholder for actual Synth GPU call
-        import aiohttp
         import os
-        
+
+        import aiohttp
+
         synth_gpu_endpoint = os.getenv("SYNTH_GPU_HARMONY_ENDPOINT")
         if not synth_gpu_endpoint:
             raise ValueError("SYNTH_GPU_HARMONY_ENDPOINT environment variable not set")
-        
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
+
+        async with aiohttp.ClientSession() as session, session.post(
                 f"{synth_gpu_endpoint}/v1/completions",
                 json={
                     "model": model,
                     "prompt": tokens,
                     "max_tokens": lm_config.get("max_tokens", 4096),
                     "temperature": lm_config.get("temperature", 0.8),
-                }
+                },
             ) as resp:
                 result = await resp.json()
-        
+
         # Parse response using Harmony
         response_tokens = result.get("choices", [{}])[0].get("text", "")
-        parsed = self.harmony_enc.parse_messages_from_completion_tokens(response_tokens, Role.ASSISTANT)
-        
+        parsed = self.harmony_enc.parse_messages_from_completion_tokens(
+            response_tokens, Role.ASSISTANT
+        )
+
         if parsed:
-            assistant_msg = parsed[-1].content_text() if hasattr(parsed[-1], 'content_text') else str(parsed[-1])
+            assistant_msg = (
+                parsed[-1].content_text()
+                if hasattr(parsed[-1], "content_text")
+                else str(parsed[-1])
+            )
         else:
             assistant_msg = response_tokens
-        
+
         return BaseLMResponse(
             raw_response=assistant_msg,
             response_id=previous_response_id or str(uuid.uuid4()),
             api_type="harmony",
-        )
+        )

synth_ai/lm/vendors/retries.py

@@ -1,6 +1,7 @@
-import backoff
 import os
 
+import backoff
+
 # Number of retry attempts that some legacy decorators rely on.
 BACKOFF_TOLERANCE: int = 20
 
@@ -12,3 +13,10 @@ try:
     MAX_BACKOFF: int = max(1, int(os.getenv("SYNTH_AI_MAX_BACKOFF", "120")))
 except ValueError:
     MAX_BACKOFF = 120
+
+# Re-export backoff for convenient import patterns elsewhere
+__all__ = [
+    "BACKOFF_TOLERANCE",
+    "MAX_BACKOFF",
+    "backoff",
+]

synth_ai/lm/vendors/supported/custom_endpoint.py

@@ -1,22 +1,22 @@
-import re
-import os
-import json
 import asyncio
+import json
+import os
+import random
+import re
 import time
-from typing import Any, Dict, List, Optional, Tuple, Type
-import requests
+from typing import Any
+
 import httpx
+import requests
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
-import random
-from urllib.parse import urlparse
 
-from synth_ai.lm.vendors.base import BaseLMResponse, VendorBase
-from synth_ai.lm.tools.base import BaseTool
 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
 
 # Exception types for retry
-CUSTOM_ENDPOINT_EXCEPTIONS_TO_RETRY: Tuple[Type[Exception], ...] = (
+CUSTOM_ENDPOINT_EXCEPTIONS_TO_RETRY: tuple[type[Exception], ...] = (
     requests.RequestException,
     requests.Timeout,
     httpx.RequestError,
@@ -28,7 +28,7 @@ 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)
+    exceptions_to_retry: list = list(CUSTOM_ENDPOINT_EXCEPTIONS_TO_RETRY)
 
     def __init__(self, endpoint_url: str):
         # Validate and sanitize URL
@@ -38,8 +38,18 @@ class CustomEndpointAPI(VendorBase):
         # 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"
+
+        # Handle full URLs that already include protocol
+        if endpoint_url.startswith(("http://", "https://")):
+            # Remove protocol and domain part, keep only the base path if any
+            parsed = endpoint_url.replace("https://", "").replace("http://", "")
+            base_url = parsed.split("/")[0]  # Get domain only
+            self.chat_completions_url = f"https://{base_url}/chat/completions"
+            self.health_url = f"https://{base_url}/health"
+        else:
+            # Original logic for domain-only URLs
+            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()
@@ -89,7 +99,7 @@ class CustomEndpointAPI(VendorBase):
 
         # Limit URL length
         if len(url) > 256:
-            raise ValueError(f"Endpoint URL too long (max 256 chars)")
+            raise ValueError("Endpoint URL too long (max 256 chars)")
 
         # Basic URL format check
         if not re.match(r"^[a-zA-Z0-9\-._~:/?#\[\]@!$&\'()*+,;=]+$", url):
@@ -123,13 +133,13 @@ class CustomEndpointAPI(VendorBase):
             )
         return self.async_client
 
-    def _get_timeout(self, lm_config: Dict[str, Any]) -> float:
+    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]:
+    def _get_temperature_override(self) -> float | None:
         """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"
@@ -140,7 +150,7 @@ class CustomEndpointAPI(VendorBase):
         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]:
+    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
@@ -157,7 +167,7 @@ class CustomEndpointAPI(VendorBase):
             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:
+    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
@@ -185,8 +195,8 @@ IMPORTANT: To use a tool, respond with JSON wrapped in ```json fences:
 For regular responses, just respond normally without JSON fences."""
 
     def _extract_tool_calls(
-        self, content: str, tools: List[BaseTool]
-    ) -> tuple[Optional[List], str]:
+        self, content: str, tools: list[BaseTool]
+    ) -> tuple[list | None, str]:
         """Extract and validate tool calls from response."""
         # Look for JSON fenced blocks
         json_pattern = r"```json\s*(\{.*?\})\s*```"
@@ -242,11 +252,11 @@ For regular responses, just respond normally without JSON fences."""
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        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,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
         """Async API call with comprehensive error handling and streaming support."""
 
@@ -314,7 +324,7 @@ For regular responses, just respond normally without JSON fences."""
 
                 return lm_response
 
-            except (httpx.RequestError, httpx.TimeoutException) as e:
+            except (httpx.RequestError, httpx.TimeoutException):
                 if attempt == 2:  # Last attempt
                     raise
                 await asyncio.sleep(self._exponential_backoff_with_jitter(attempt))
@@ -322,11 +332,11 @@ For regular responses, just respond normally without JSON fences."""
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        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,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
         """Sync version with same logic as async."""
 
@@ -393,7 +403,7 @@ For regular responses, just respond normally without JSON fences."""
 
                 return lm_response
 
-            except (requests.RequestException, requests.Timeout) as e:
+            except (requests.RequestException, requests.Timeout):
                 if attempt == 2:  # Last attempt
                     raise
                 time.sleep(self._exponential_backoff_with_jitter(attempt))

synth_ai/lm/vendors/supported/deepseek.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from openai import AsyncOpenAI, OpenAI
 
@@ -19,18 +19,18 @@ class DeepSeekAPI(OpenAIStandard):
             base_url="https://api.deepseek.com",
         )
 
-    def _convert_tools_to_openai_format(self, tools: List[BaseTool]) -> List[Dict]:
+    def _convert_tools_to_openai_format(self, tools: list[BaseTool]) -> list[dict]:
         return [tool.to_openai_tool() for tool in tools]
 
     async def _private_request_async(
         self,
-        messages: List[Dict],
+        messages: list[dict],
         temperature: float = 0,
         model_name: str = "deepseek-chat",
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        lm_config: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[List[Dict]]]:
+        tools: list[BaseTool] | None = None,
+        lm_config: dict[str, Any] | None = None,
+    ) -> tuple[str, list[dict] | None]:
         request_params = {
             "model": model_name,
             "messages": messages,
@@ -47,13 +47,13 @@ class DeepSeekAPI(OpenAIStandard):
 
     def _private_request_sync(
         self,
-        messages: List[Dict],
+        messages: list[dict],
         temperature: float = 0,
         model_name: str = "deepseek-chat",
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
-        lm_config: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Optional[List[Dict]]]:
+        tools: list[BaseTool] | None = None,
+        lm_config: dict[str, Any] | None = None,
+    ) -> tuple[str, list[dict] | None]:
         request_params = {
             "model": model_name,
             "messages": messages,

synth_ai/lm/vendors/supported/grok.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from openai import AsyncOpenAI, OpenAI
 
@@ -19,7 +19,7 @@ class GrokAPI(OpenAIStandard):
     def __init__(
         self,
         *,
-        api_key: Optional[str] = None,
+        api_key: str | None = None,
         base_url: str = "https://api.x.ai/v1",
     ) -> None:
         api_key = api_key or os.getenv("XAI_API_KEY")
@@ -35,11 +35,11 @@ class GrokAPI(OpenAIStandard):
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ):
         if not model:
             raise ValueError("Model name is required for Grok API calls")
@@ -56,11 +56,11 @@ class GrokAPI(OpenAIStandard):
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ):
         if not model:
             raise ValueError("Model name is required for Grok API calls")

synth_ai/lm/vendors/supported/ollama.py

@@ -1,4 +1,5 @@
-from openai import OpenAI, AsyncOpenAI
+from openai import AsyncOpenAI, OpenAI
+
 from synth_ai.lm.vendors.openai_standard import OpenAIStandard
 
 

synth_ai/lm/vendors/supported/openrouter.py

@@ -1,9 +1,11 @@
 import os
-from typing import Any, Dict, List, Optional
+from typing import Any
+
 from openai import AsyncOpenAI, OpenAI
-from synth_ai.lm.vendors.openai_standard import OpenAIStandard
-from synth_ai.lm.vendors.base import BaseLMResponse
+
 from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse
+from synth_ai.lm.vendors.openai_standard import OpenAIStandard
 
 
 class OpenRouterAPI(OpenAIStandard):
@@ -44,11 +46,11 @@ class OpenRouterAPI(OpenAIStandard):
     async def _hit_api_async(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
         # Strip the 'openrouter/' prefix before calling the API
         model = self._strip_prefix(model)
@@ -59,11 +61,11 @@ class OpenRouterAPI(OpenAIStandard):
     def _hit_api_sync(
         self,
         model: str,
-        messages: List[Dict[str, Any]],
-        lm_config: Dict[str, Any],
+        messages: list[dict[str, Any]],
+        lm_config: dict[str, Any],
         use_ephemeral_cache_only: bool = False,
         reasoning_effort: str = "high",
-        tools: Optional[List[BaseTool]] = None,
+        tools: list[BaseTool] | None = None,
     ) -> BaseLMResponse:
         # Strip the 'openrouter/' prefix before calling the API
         model = self._strip_prefix(model)