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

synth_ai/tracing_v3/llm_call_record_helpers.py

@@ -5,37 +5,35 @@ format and compute aggregates from call records.
 """
 
 import uuid
-import json
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
+from synth_ai.lm.vendors.base import BaseLMResponse
 from synth_ai.tracing_v3.lm_call_record_abstractions import (
     LLMCallRecord,
-    LLMUsage,
-    LLMRequestParams,
-    LLMMessage,
+    LLMChunk,
     LLMContentPart,
+    LLMMessage,
+    LLMRequestParams,
+    LLMUsage,
     ToolCallSpec,
-    ToolCallResult,
-    LLMChunk,
 )
-from synth_ai.lm.vendors.base import BaseLMResponse
 
 
 def create_llm_call_record_from_response(
     response: BaseLMResponse,
     model_name: str,
     provider: str,
-    messages: List[Dict[str, Any]],
+    messages: list[dict[str, Any]],
     temperature: float = 0.8,
-    request_params: Optional[Dict[str, Any]] = None,
-    tools: Optional[List] = None,
-    started_at: Optional[datetime] = None,
-    completed_at: Optional[datetime] = None,
-    latency_ms: Optional[int] = None,
+    request_params: dict[str, Any] | None = None,
+    tools: list | None = None,
+    started_at: datetime | None = None,
+    completed_at: datetime | None = None,
+    latency_ms: int | None = None,
 ) -> LLMCallRecord:
     """Create an LLMCallRecord from a vendor response.
-    
+
     Args:
         response: The vendor response object
         model_name: Name of the model used
@@ -47,27 +45,27 @@ def create_llm_call_record_from_response(
         started_at: When the request started
         completed_at: When the request completed
         latency_ms: End-to-end latency in milliseconds
-    
+
     Returns:
         A populated LLMCallRecord instance
     """
     # Generate call ID
     call_id = str(uuid.uuid4())
-    
+
     # Determine API type from response
     api_type = "chat_completions"  # Default
-    if hasattr(response, 'api_type'):
+    if hasattr(response, "api_type"):
         if response.api_type == "responses":
             api_type = "responses"
         elif response.api_type == "completions":
             api_type = "completions"
-    
+
     # Convert input messages to LLMMessage format
     input_messages = []
     for msg in messages:
         role = msg.get("role", "user")
         content = msg.get("content", "")
-        
+
         # Handle different content formats
         if isinstance(content, str):
             parts = [LLMContentPart(type="text", text=content)]
@@ -78,41 +76,42 @@ def create_llm_call_record_from_response(
                     if item.get("type") == "text":
                         parts.append(LLMContentPart(type="text", text=item.get("text", "")))
                     elif item.get("type") == "image_url":
-                        parts.append(LLMContentPart(
-                            type="image",
-                            uri=item.get("image_url", {}).get("url", ""),
-                            mime_type="image/jpeg"
-                        ))
+                        parts.append(
+                            LLMContentPart(
+                                type="image",
+                                uri=item.get("image_url", {}).get("url", ""),
+                                mime_type="image/jpeg",
+                            )
+                        )
                     elif item.get("type") == "image":
-                        parts.append(LLMContentPart(
-                            type="image",
-                            data=item.get("source", {}),
-                            mime_type=item.get("source", {}).get("media_type", "image/jpeg")
-                        ))
+                        parts.append(
+                            LLMContentPart(
+                                type="image",
+                                data=item.get("source", {}),
+                                mime_type=item.get("source", {}).get("media_type", "image/jpeg"),
+                            )
+                        )
                 else:
                     parts.append(LLMContentPart(type="text", text=str(item)))
         else:
             parts = [LLMContentPart(type="text", text=str(content))]
-        
+
         input_messages.append(LLMMessage(role=role, parts=parts))
-    
+
     # Extract output messages from response
     output_messages = []
     output_text = None
-    
-    if hasattr(response, 'raw_response'):
+
+    if hasattr(response, "raw_response"):
         # Extract assistant message
         output_text = response.raw_response
         output_messages.append(
-            LLMMessage(
-                role="assistant",
-                parts=[LLMContentPart(type="text", text=output_text)]
-            )
+            LLMMessage(role="assistant", parts=[LLMContentPart(type="text", text=output_text)])
         )
-    
+
     # Extract tool calls if present
     output_tool_calls = []
-    if hasattr(response, 'tool_calls') and response.tool_calls:
+    if hasattr(response, "tool_calls") and response.tool_calls:
         for idx, tool_call in enumerate(response.tool_calls):
             if isinstance(tool_call, dict):
                 output_tool_calls.append(
@@ -120,13 +119,13 @@ def create_llm_call_record_from_response(
                         name=tool_call.get("function", {}).get("name", ""),
                         arguments_json=tool_call.get("function", {}).get("arguments", "{}"),
                         call_id=tool_call.get("id", f"tool_{idx}"),
-                        index=idx
+                        index=idx,
                     )
                 )
-    
+
     # Extract usage information
     usage = None
-    if hasattr(response, 'usage') and response.usage:
+    if hasattr(response, "usage") and response.usage:
         usage = LLMUsage(
             input_tokens=response.usage.get("input_tokens"),
             output_tokens=response.usage.get("output_tokens"),
@@ -139,23 +138,23 @@ def create_llm_call_record_from_response(
             cache_write_tokens=response.usage.get("cache_write_tokens"),
             cache_read_tokens=response.usage.get("cache_read_tokens"),
         )
-    
+
     # Build request parameters
     params = LLMRequestParams(
         temperature=temperature,
         top_p=request_params.get("top_p") if request_params else None,
         max_tokens=request_params.get("max_tokens") if request_params else None,
         stop=request_params.get("stop") if request_params else None,
-        raw_params=request_params or {}
+        raw_params=request_params or {},
     )
-    
+
     # Handle response-specific fields
     finish_reason = None
-    if hasattr(response, 'finish_reason'):
+    if hasattr(response, "finish_reason"):
         finish_reason = response.finish_reason
-    elif hasattr(response, 'stop_reason'):
+    elif hasattr(response, "stop_reason"):
         finish_reason = response.stop_reason
-    
+
     # Create the call record
     record = LLMCallRecord(
         call_id=call_id,
@@ -178,23 +177,23 @@ def create_llm_call_record_from_response(
         metadata={
             "has_tools": tools is not None,
             "num_tools": len(tools) if tools else 0,
-        }
+        },
     )
-    
+
     # Store response ID if available (for Responses API)
-    if hasattr(response, 'response_id') and response.response_id:
+    if hasattr(response, "response_id") and response.response_id:
         record.metadata["response_id"] = response.response_id
         record.provider_request_id = response.response_id
-    
+
     return record
 
 
-def compute_aggregates_from_call_records(call_records: List[LLMCallRecord]) -> Dict[str, Any]:
+def compute_aggregates_from_call_records(call_records: list[LLMCallRecord]) -> dict[str, Any]:
     """Compute aggregate statistics from a list of LLMCallRecord instances.
-    
+
     Args:
         call_records: List of LLMCallRecord instances
-    
+
     Returns:
         Dictionary containing aggregated statistics
     """
@@ -210,9 +209,9 @@ def compute_aggregates_from_call_records(call_records: List[LLMCallRecord]) -> D
         "tool_calls_count": 0,
         "error_count": 0,
         "success_count": 0,
-        "call_count": len(call_records)
+        "call_count": len(call_records),
     }
-    
+
     for record in call_records:
         # Token aggregation
         if record.usage:
@@ -226,54 +225,54 @@ def compute_aggregates_from_call_records(call_records: List[LLMCallRecord]) -> D
                 aggregates["reasoning_tokens"] += record.usage.reasoning_tokens
             if record.usage.cost_usd:
                 aggregates["cost_usd"] += record.usage.cost_usd
-        
+
         # Latency aggregation
         if record.latency_ms:
             aggregates["latency_ms"] += record.latency_ms
-        
+
         # Model and provider tracking
         if record.model_name:
             aggregates["models_used"].add(record.model_name)
         if record.provider:
             aggregates["providers_used"].add(record.provider)
-        
+
         # Tool calls
         aggregates["tool_calls_count"] += len(record.output_tool_calls)
-        
+
         # Success/error tracking
         if record.outcome == "error":
             aggregates["error_count"] += 1
         elif record.outcome == "success":
             aggregates["success_count"] += 1
-    
+
     # Convert sets to lists for JSON serialization
     aggregates["models_used"] = list(aggregates["models_used"])
     aggregates["providers_used"] = list(aggregates["providers_used"])
-    
+
     # Compute averages
     if aggregates["call_count"] > 0:
         aggregates["avg_latency_ms"] = aggregates["latency_ms"] / aggregates["call_count"]
         aggregates["avg_input_tokens"] = aggregates["input_tokens"] / aggregates["call_count"]
         aggregates["avg_output_tokens"] = aggregates["output_tokens"] / aggregates["call_count"]
-    
+
     return aggregates
 
 
 def create_llm_call_record_from_streaming(
-    chunks: List[LLMChunk],
+    chunks: list[LLMChunk],
     model_name: str,
     provider: str,
-    messages: List[Dict[str, Any]],
+    messages: list[dict[str, Any]],
     temperature: float = 0.8,
-    request_params: Optional[Dict[str, Any]] = None,
-    started_at: Optional[datetime] = None,
-    completed_at: Optional[datetime] = None,
+    request_params: dict[str, Any] | None = None,
+    started_at: datetime | None = None,
+    completed_at: datetime | None = None,
 ) -> LLMCallRecord:
     """Create an LLMCallRecord from streaming chunks.
-    
+
     This function reconstructs a complete LLMCallRecord from streaming
     response chunks, useful for Responses API or streaming Chat Completions.
-    
+
     Args:
         chunks: List of LLMChunk instances from streaming
         model_name: Name of the model used
@@ -283,49 +282,40 @@ def create_llm_call_record_from_streaming(
         request_params: Additional request parameters
         started_at: When the request started
         completed_at: When the request completed
-    
+
     Returns:
         A populated LLMCallRecord instance
     """
     # Reconstruct output text from chunks
-    output_text = "".join(
-        chunk.delta_text for chunk in chunks 
-        if chunk.delta_text
-    )
-    
+    output_text = "".join(chunk.delta_text for chunk in chunks if chunk.delta_text)
+
     # Calculate latency from chunk timestamps
     latency_ms = None
     if chunks and started_at:
         last_chunk_time = chunks[-1].received_at
         latency_ms = int((last_chunk_time - started_at).total_seconds() * 1000)
-    
+
     # Convert input messages
     input_messages = []
     for msg in messages:
         role = msg.get("role", "user")
         content = msg.get("content", "")
-        
+
         if isinstance(content, str):
             parts = [LLMContentPart(type="text", text=content)]
         else:
             parts = [LLMContentPart(type="text", text=str(content))]
-        
+
         input_messages.append(LLMMessage(role=role, parts=parts))
-    
+
     # Create output message
     output_messages = [
-        LLMMessage(
-            role="assistant",
-            parts=[LLMContentPart(type="text", text=output_text)]
-        )
+        LLMMessage(role="assistant", parts=[LLMContentPart(type="text", text=output_text)])
     ]
-    
+
     # Build request parameters
-    params = LLMRequestParams(
-        temperature=temperature,
-        raw_params=request_params or {}
-    )
-    
+    params = LLMRequestParams(temperature=temperature, raw_params=request_params or {})
+
     # Create the call record
     record = LLMCallRecord(
         call_id=str(uuid.uuid4()),
@@ -341,10 +331,7 @@ def create_llm_call_record_from_streaming(
         output_text=output_text,
         chunks=chunks,
         outcome="success",
-        metadata={
-            "chunk_count": len(chunks),
-            "streaming": True
-        }
+        metadata={"chunk_count": len(chunks), "streaming": True},
     )
-    
-    return record
+
+    return record

synth_ai/tracing_v3/lm_call_record_abstractions.py

@@ -23,8 +23,8 @@ Design goals:
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Optional, Literal
 from datetime import datetime
+from typing import Any, Literal
 
 
 @dataclass
@@ -222,7 +222,7 @@ class LLMCallRecord:
     redactions: list[dict[str, Any]] | None = None
 
 
-def compute_latency_ms(record: LLMCallRecord) -> Optional[int]:
+def compute_latency_ms(record: LLMCallRecord) -> int | None:
     """Compute and update latency_ms from timestamps if available."""
     if record.started_at and record.completed_at:
         delta = int((record.completed_at - record.started_at).total_seconds() * 1000)
@@ -253,5 +253,3 @@ def compute_latency_ms(record: LLMCallRecord) -> Optional[int]:
 #
 # Tool execution results should be attached as ToolCallResult entries when the
 # agent runtime executes the requested tool(s) and has ground-truth outputs.
-
-

synth_ai/tracing_v3/migration_helper.py

@@ -5,11 +5,9 @@ Helper script to identify files that need migration from v2 to v3 tracing.
 
 import os
 import re
-from pathlib import Path
-from typing import List, Tuple
 
 
-def find_v2_imports(root_path: str = ".") -> List[Tuple[str, List[str]]]:
+def find_v2_imports(root_path: str = ".") -> list[tuple[str, list[str]]]:
     """Find all Python files importing from tracing_v2."""
     v2_files = []
 
@@ -37,7 +35,7 @@ def find_v2_imports(root_path: str = ".") -> List[Tuple[str, List[str]]]:
             if file.endswith(".py"):
                 file_path = os.path.join(root, file)
                 try:
-                    with open(file_path, "r") as f:
+                    with open(file_path) as f:
                         content = f.read()
 
                     matches = []
@@ -53,7 +51,7 @@ def find_v2_imports(root_path: str = ".") -> List[Tuple[str, List[str]]]:
     return v2_files
 
 
-def categorize_files(v2_files: List[Tuple[str, List[str]]]) -> dict:
+def categorize_files(v2_files: list[tuple[str, list[str]]]) -> dict:
     """Categorize files by their type/location."""
     categories = {"tests": [], "core_library": [], "examples": [], "debug_scripts": [], "other": []}
 

synth_ai/tracing_v3/replica_sync.py

@@ -25,10 +25,10 @@ application to continue without blocking on sync operations.
 """
 
 import asyncio
-import libsql
-import os
 import logging
-from typing import Optional
+
+import libsql
+
 from .config import CONFIG
 
 logger = logging.getLogger(__name__)
@@ -36,13 +36,13 @@ logger = logging.getLogger(__name__)
 
 class ReplicaSync:
     """Manages synchronization of embedded SQLite replica with remote Turso database.
-    
+
     This class handles the lifecycle of replica synchronization, including:
     - Establishing connections to both local and remote databases
     - Running periodic sync operations
     - Handling sync failures gracefully
     - Managing the background sync task
-    
+
     The sync is designed to be resilient to network failures and will
     continue retrying with exponential backoff.
     """
@@ -50,9 +50,9 @@ class ReplicaSync:
     def __init__(
         self,
         db_path: str = "embedded.db",
-        sync_url: Optional[str] = None,
-        auth_token: Optional[str] = None,
-        sync_interval: Optional[int] = None,
+        sync_url: str | None = None,
+        auth_token: str | None = None,
+        sync_interval: int | None = None,
     ):
         """Initialize replica sync manager.
 
@@ -66,16 +66,16 @@ class ReplicaSync:
         self.sync_url = sync_url or CONFIG.sync_url
         self.auth_token = auth_token or CONFIG.auth_token
         self.sync_interval = sync_interval or CONFIG.sync_interval
-        self._sync_task: Optional[asyncio.Task] = None
-        self._conn: Optional[libsql.Connection] = None
+        self._sync_task: asyncio.Task | None = None
+        self._conn: libsql.Connection | None = None
 
     def _ensure_connection(self):
         """Ensure libsql connection is established.
-        
+
         Creates a connection to the local embedded database with sync
         capabilities. The libsql library handles the replication protocol
         with the remote Turso database.
-        
+
         Raises:
             ValueError: If no sync_url is configured
         """
@@ -97,12 +97,12 @@ class ReplicaSync:
 
     async def sync_once(self) -> bool:
         """Perform a single sync operation.
-        
+
         This method:
         1. Ensures a connection exists
         2. Runs the sync in a thread pool to avoid blocking
         3. Handles failures gracefully
-        
+
         The actual sync protocol is handled by libsql and includes:
         - Sending local changes to remote
         - Receiving remote changes (if configured)
@@ -123,10 +123,10 @@ class ReplicaSync:
 
     async def keep_fresh(self):
         """Background task to continuously sync the replica.
-        
+
         Runs in an infinite loop, performing sync operations at the configured
         interval. Handles cancellation gracefully for clean shutdown.
-        
+
         The task will continue running even if individual syncs fail, ensuring
         eventual consistency when connectivity is restored.
         """
@@ -148,10 +148,10 @@ class ReplicaSync:
 
     def start_background_sync(self) -> asyncio.Task:
         """Start the background sync task.
-        
+
         Creates an asyncio task that runs the sync loop. The task is stored
         internally for lifecycle management.
-        
+
         This method is idempotent - calling it multiple times will not create
         multiple sync tasks.
 
@@ -168,23 +168,21 @@ class ReplicaSync:
 
     async def stop(self):
         """Stop the background sync task and close connection.
-        
+
         Performs a clean shutdown:
         1. Cancels the background sync task
         2. Waits for task completion
         3. Closes the database connection
-        
+
         This method is safe to call multiple times.
         """
         if self._sync_task and not self._sync_task.done():
             # Request cancellation
             self._sync_task.cancel()
-            try:
+            import contextlib
+            with contextlib.suppress(asyncio.CancelledError):
                 # Wait for the task to finish
                 await self._sync_task
-            except asyncio.CancelledError:
-                # Expected when task is cancelled
-                pass
 
         if self._conn:
             # Close the libsql connection
@@ -194,22 +192,22 @@ class ReplicaSync:
 
 
 # Global replica sync instance
-_replica_sync: Optional[ReplicaSync] = None
+_replica_sync: ReplicaSync | None = None
 
 
-def get_replica_sync() -> Optional[ReplicaSync]:
+def get_replica_sync() -> ReplicaSync | None:
     """Get the global replica sync instance."""
     return _replica_sync
 
 
 async def start_replica_sync(
     db_path: str = "embedded.db",
-    sync_url: Optional[str] = None,
-    auth_token: Optional[str] = None,
-    sync_interval: Optional[int] = None,
+    sync_url: str | None = None,
+    auth_token: str | None = None,
+    sync_interval: int | None = None,
 ) -> ReplicaSync:
     """Start global replica sync.
-    
+
     Convenience function to create and start a replica sync instance.
     Performs an initial sync before starting the background task to ensure
     the local database is up-to-date.
@@ -222,7 +220,7 @@ async def start_replica_sync(
 
     Returns:
         The ReplicaSync instance
-        
+
     Raises:
         ValueError: If sync_url is not provided and not in environment
     """
@@ -247,7 +245,7 @@ async def start_replica_sync(
 
 async def stop_replica_sync():
     """Stop the global replica sync.
-    
+
     Stops the global replica sync instance if one is running.
     This should be called during application shutdown to ensure
     clean termination of the sync task.