synth-ai 0.2.2.dev0__py3-none-any.whl → 0.2.4.dev2__py3-none-any.whl

synth_ai/lm/vendors/synth_client.py

@@ -47,6 +47,73 @@ class AsyncSynthClient:
                 },
             )
 
+    async def responses_create(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        previous_response_id: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = "auto",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Create response using Synth Responses API.
+        
+        Args:
+            model: Model identifier
+            messages: List of message dicts with 'role' and 'content'
+            previous_response_id: Optional ID of previous response for thread management
+            tools: List of available tools
+            tool_choice: How to choose tools
+            **kwargs: Additional parameters
+            
+        Returns:
+            Responses API-compatible response dict
+        """
+        await self._ensure_client()
+        
+        # Build payload for Responses API
+        payload = {
+            "model": model,
+            "messages": messages,
+        }
+        
+        # Add optional parameters
+        if previous_response_id is not None:
+            payload["previous_response_id"] = previous_response_id
+        if tools is not None:
+            payload["tools"] = tools
+            payload["tool_choice"] = tool_choice
+            
+        # Add any additional kwargs
+        payload.update(kwargs)
+        
+        # Retry logic
+        for attempt in range(self.config.max_retries):
+            try:
+                url = f"{self.config.get_base_url_without_v1()}/v1/responses"
+                response = await self._client.post(url, json=payload)
+                
+                if response.status_code == 200:
+                    return response.json()
+                    
+                # Handle rate limits with exponential backoff
+                if response.status_code == 429:
+                    wait_time = 2**attempt
+                    await asyncio.sleep(wait_time)
+                    continue
+                    
+                # Other errors
+                response.raise_for_status()
+                
+            except Exception as e:
+                if attempt == self.config.max_retries - 1:
+                    logger.error(f"Failed after {self.config.max_retries} attempts: {e}")
+                    raise
+                await asyncio.sleep(2**attempt)
+                
+        raise Exception(f"Failed to create response after {self.config.max_retries} attempts")
+
     async def chat_completions_create(
         self,
         model: str,
@@ -118,12 +185,32 @@ class AsyncSynthClient:
         # Retry logic
         for attempt in range(self.config.max_retries):
             try:
-                response = await self._client.post(
-                    f"{self.config.get_base_url_without_v1()}/v1/chat/completions", json=payload
-                )
-
+                url = f"{self.config.get_base_url_without_v1()}/v1/chat/completions"
+                print(f"🔍 SYNTH DEBUG: Making request to URL: {url}")
+                print(f"🔍 SYNTH DEBUG: Payload keys: {list(payload.keys())}")
+                if 'tools' in payload:
+                    print(f"🔍 SYNTH DEBUG: Tools in payload: {len(payload['tools'])} tools")
+                    print(f"🔍 SYNTH DEBUG: First tool: {json.dumps(payload['tools'][0], indent=2)}")
+                
+                response = await self._client.post(url, json=payload)
+                
+                print(f"🔍 SYNTH DEBUG: Response status: {response.status_code}")
+                
                 if response.status_code == 200:
-                    return response.json()
+                    result = response.json()
+                    print(f"🔍 SYNTH DEBUG: Response keys: {list(result.keys())}")
+                    if 'choices' in result and result['choices']:
+                        choice = result['choices'][0]
+                        print(f"🔍 SYNTH DEBUG: Choice keys: {list(choice.keys())}")
+                        if 'message' in choice:
+                            message = choice['message']
+                            print(f"🔍 SYNTH DEBUG: Message keys: {list(message.keys())}")
+                            if 'tool_calls' in message:
+                                print(f"🔍 SYNTH DEBUG: Tool calls: {message['tool_calls']}")
+                            else:
+                                print(f"🔍 SYNTH DEBUG: No tool_calls in message")
+                                print(f"🔍 SYNTH DEBUG: Message content: {message.get('content', 'N/A')[:200]}...")
+                    return result
 
                 # Handle rate limits with exponential backoff
                 if response.status_code == 429:
@@ -191,6 +278,69 @@ class SyncSynthClient:
                 },
             )
 
+    def responses_create(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        previous_response_id: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = "auto",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Create response using Synth Responses API (sync version).
+        
+        See AsyncSynthClient.responses_create for full parameter documentation.
+        """
+        self._ensure_client()
+        
+        # Build payload for Responses API
+        payload = {
+            "model": model,
+            "messages": messages,
+        }
+        
+        # Add optional parameters
+        if previous_response_id is not None:
+            payload["previous_response_id"] = previous_response_id
+        if tools is not None:
+            payload["tools"] = tools
+            payload["tool_choice"] = tool_choice
+            
+        # Add any additional kwargs
+        payload.update(kwargs)
+        
+        # Retry logic
+        for attempt in range(self.config.max_retries):
+            try:
+                response = self._client.post(
+                    f"{self.config.get_base_url_without_v1()}/v1/responses", json=payload
+                )
+                
+                if response.status_code == 200:
+                    return response.json()
+                    
+                # Handle rate limits
+                if response.status_code == 429:
+                    wait_time = 2**attempt
+                    logger.warning(f"Rate limited, waiting {wait_time}s...")
+                    import time
+                    time.sleep(wait_time)
+                    continue
+                    
+                # Other errors
+                error_msg = f"API error {response.status_code}: {response.text}"
+                logger.error(error_msg)
+                raise Exception(error_msg)
+                
+            except httpx.TimeoutException:
+                if attempt < self.config.max_retries - 1:
+                    logger.warning(f"Timeout on attempt {attempt + 1}, retrying...")
+                    continue
+                raise
+                
+        raise Exception(f"Failed after {self.config.max_retries} attempts")
+
     def chat_completions_create(
         self, model: str, messages: List[Dict[str, Any]], **kwargs
     ) -> Dict[str, Any]:

synth_ai/lm/warmup.py

@@ -6,6 +6,8 @@ Handles model preloading and warmup polling.
 import httpx
 import asyncio
 import logging
+import sys
+import time
 from typing import Optional, Dict, Any
 from datetime import datetime, timedelta
 from .config import SynthConfig
@@ -46,9 +48,10 @@ _warmup_status = WarmupStatus()
 async def warmup_synth_model(
     model_name: str,
     config: Optional[SynthConfig] = None,
-    max_attempts: int = 30,
+    max_attempts: Optional[int] = None,
     force: bool = False,
     verbose: bool = True,
+    gpu_preference: Optional[str] = None,
 ) -> bool:
     """
     Warm up a model on the Synth backend using fire-and-forget approach.
@@ -73,6 +76,8 @@ async def warmup_synth_model(
 
     async with httpx.AsyncClient() as client:
         headers = {"Authorization": f"Bearer {config.api_key}"}
+        if gpu_preference:
+            headers["X-GPU-Preference"] = gpu_preference
 
         # Step 1: Start warmup (fire and forget)
         try:
@@ -84,8 +89,11 @@ async def warmup_synth_model(
 
             if response.status_code == 200:
                 response_data = response.json()
-                if response_data.get("status") in ["warming", "already_warming", "already_warmed"]:
+                if response_data.get("status") in ["warming", "already_warming"]:
                     pass
+                elif response_data.get("status") == "already_warmed":
+                    _warmup_status.mark_warm(model_name)
+                    return True
                 else:
                     logger.warning(f"Unexpected warmup response: {response_data}")
             else:
@@ -98,8 +106,13 @@ async def warmup_synth_model(
             logger.warning(f"Warmup start failed: {e}")
             return False
 
-        # Step 2: Poll status until ready
-        for attempt in range(max_attempts):
+        # Step 2: Poll status until ready (indefinite by default)
+        spinner = "|/-\\"
+        spin_idx = 0
+        start_time = time.time()
+        attempt = 0
+        while True:
+            attempt += 1
             try:
                 response = await client.get(
                     f"{config.get_base_url_without_v1()}/warmup/status/{model_name}",
@@ -113,34 +126,58 @@ async def warmup_synth_model(
 
                     if status == "warmed":
                         _warmup_status.mark_warm(model_name)
+                        # Final spinner line as success
+                        elapsed = int(time.time() - start_time)
+                        sys.stdout.write(f"\r✅ Warmed {model_name} in {elapsed}s        \n")
+                        sys.stdout.flush()
                         return True
                     elif status == "failed":
                         error = status_data.get("error", "Unknown error")
                         logger.error(f"❌ Warmup failed for {model_name}: {error}")
+                        sys.stdout.write(f"\r❌ Warmup failed: {error}            \n")
+                        sys.stdout.flush()
                         return False
-                    elif status == "warming":
-                        # Still warming up, continue polling
-                        pass
-                    elif status == "not_started":
-                        # Warmup hasn't started yet, continue polling
-                        pass
                     else:
-                        logger.warning(f"Unknown warmup status: {status}")
+                        # Treat unknown statuses (e.g., "cold") as still warming
+                        elapsed = int(time.time() - start_time)
+                        wheel = spinner[spin_idx % len(spinner)]
+                        spin_idx += 1
+                        label = status or "pending"
+                        sys.stdout.write(
+                            f"\r⏳ Warming {model_name} [{wheel}] status={label} elapsed={elapsed}s"
+                        )
+                        sys.stdout.flush()
 
                 # Short sleep between status checks
                 await asyncio.sleep(2.0)
 
             except httpx.TimeoutException:
-                if verbose:
-                    logger.warning(f"Status check {attempt + 1} timed out")
+                # Continue polling; update spinner line
+                elapsed = int(time.time() - start_time)
+                wheel = spinner[spin_idx % len(spinner)]
+                spin_idx += 1
+                sys.stdout.write(
+                    f"\r⏳ Warming {model_name} [{wheel}] status=timeout elapsed={elapsed}s"
+                )
+                sys.stdout.flush()
                 await asyncio.sleep(1.0)
             except Exception as e:
-                if verbose:
-                    logger.warning(f"Status check {attempt + 1} failed: {e}")
+                # Continue polling; update spinner line with error label
+                elapsed = int(time.time() - start_time)
+                wheel = spinner[spin_idx % len(spinner)]
+                spin_idx += 1
+                sys.stdout.write(
+                    f"\r⏳ Warming {model_name} [{wheel}] status=error elapsed={elapsed}s"
+                )
+                sys.stdout.flush()
                 await asyncio.sleep(1.0)
 
-        logger.error(f"Failed to warm up {model_name} after {max_attempts} status checks")
-        return False
+            # Optional max_attempts for callers who want a cap
+            if max_attempts is not None and attempt >= max_attempts:
+                logger.error(f"Failed to warm up {model_name} after {max_attempts} status checks")
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                return False
 
 
 def get_warmup_status() -> WarmupStatus:

synth_ai/tracing/__init__.py

@@ -0,0 +1,18 @@
+import sys as _sys
+import importlib as _importlib
+
+_pkg = _importlib.import_module('synth_ai.v0.tracing')
+_sys.modules[__name__] = _pkg
+
+_SUBMODULES = [
+    'abstractions', 'base_client', 'client_manager', 'config', 'context',
+    'decorators', 'immediate_client', 'local', 'log_client_base', 'retry_queue',
+    'trackers', 'upload', 'utils'
+]
+for _m in _SUBMODULES:
+    _sys.modules[f'{__name__}.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing.{_m}')
+
+_events_pkg = _importlib.import_module('synth_ai.v0.tracing.events')
+_sys.modules[f'{__name__}.events'] = _events_pkg
+for _m in ['manage', 'scope', 'store']:
+    _sys.modules[f'{__name__}.events.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing.events.{_m}')

synth_ai/tracing_v1/__init__.py

@@ -1,16 +1,31 @@
-import warnings
+import sys as _sys
+import importlib as _importlib
 
-# Issue deprecation warning when this module is imported
-warnings.warn(
-    "synth_ai.tracing (now tracing_v1) is deprecated. "
-    "Please use synth_ai.tracing_v2 instead. "
-    "Backend upload functionality is no longer supported in v1.",
-    DeprecationWarning,
-    stacklevel=2,
-)
+# Forward top-level package
+_pkg = _importlib.import_module('synth_ai.v0.tracing_v1')
+_sys.modules[__name__] = _pkg
 
-# Re-export the main components with deprecation warnings
-from .config import *
-from .decorators import *
-from .trackers import *
-from .abstractions import *
+# Explicitly forward submodules so `synth_ai.tracing_v1.X` works
+_SUBMODULES = [
+    'abstractions',
+    'base_client',
+    'client_manager',
+    'config',
+    'context',
+    'decorators',
+    'immediate_client',
+    'local',
+    'log_client_base',
+    'retry_queue',
+    'trackers',
+    'upload',
+    'utils',
+]
+for _m in _SUBMODULES:
+    _sys.modules[f'{__name__}.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing_v1.{_m}')
+
+# Forward events package and its submodules
+_events_pkg = _importlib.import_module('synth_ai.v0.tracing_v1.events')
+_sys.modules[f'{__name__}.events'] = _events_pkg
+for _m in ['manage', 'scope', 'store']:
+    _sys.modules[f'{__name__}.events.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing_v1.events.{_m}')

synth_ai/tracing_v3/__init__.py

@@ -77,7 +77,7 @@ from .abstractions import (
     BaseEvent,
     RuntimeEvent,
     EnvironmentEvent,
-    SessionEventMessage,
+    SessionEventMarkovBlanketMessage,
     TimeRecord,
 )
 from .config import TursoConfig
@@ -89,7 +89,7 @@ __all__ = [
     "BaseEvent",
     "RuntimeEvent",
     "EnvironmentEvent",
-    "SessionEventMessage",
+    "SessionEventMarkovBlanketMessage",
     "TimeRecord",
     "TursoConfig",
 ]

synth_ai/tracing_v3/abstractions.py

@@ -18,13 +18,27 @@ Session Structure:
 - SessionTrace: Top-level container for a complete session
   - SessionTimeStep: Logical steps within a session (e.g., conversation turns)
     - Events: Individual events that occurred during the timestep
-    - Messages: User/assistant messages exchanged
+    - Messages: Information passed between subsystems (user, agent, runtime, environments)
+
+Concepts:
+---------
+- Events capture something that happened inside a subsystem. They may or may not be externally
+  visible. Examples include an LLM API call (LMCAISEvent), a tool selection (RuntimeEvent), or
+  a tool execution outcome (EnvironmentEvent).
+
+- Messages represent information transmitted between subsystems within the session.
+  Messages are used to record communications like: a user sending input to the agent,
+  the agent/runtime sending a tool invocation to an environment, the environment sending a
+  tool result back, and the agent sending a reply to the user. Do not confuse these with
+  provider-specific LLM API "messages" (prompt formatting) — those belong inside an LMCAISEvent
+  as part of its input/output content, not as SessionEventMessages.
 """
 
 from __future__ import annotations
 from dataclasses import dataclass, field, asdict
 from datetime import datetime
 from typing import Any, Dict, List, Optional
+from .lm_call_record_abstractions import LLMCallRecord
 
 
 @dataclass
@@ -46,18 +60,39 @@ class TimeRecord:
 
 
 @dataclass
-class SessionEventMessage:
-    """Message exchanged during a session.
+class SessionEventMarkovBlanketMessage:
+    """Message crossing Markov blanket boundaries between systems in a session.
+    
+    IMPORTANT: This represents information transfer BETWEEN distinct systems/subsystems,
+    where each system is conceptualized as having a Markov blanket that separates its
+    internal states from the external environment. These messages cross those boundaries.
+    
+    This is NOT for chat messages within an LLM conversation (those belong in LLMCallRecord).
+    Instead, this captures inter-system communication such as:
+    - Human -> Agent system (user providing instructions)
+    - Agent -> Runtime (agent deciding on an action)
+    - Runtime -> Environment (executing a tool/action)
+    - Environment -> Runtime (returning results)
+    - Runtime -> Agent (passing back results)
+    - Agent -> Human (final response)
     
-    Represents any message passed between participants in a session, including
-    user inputs, assistant responses, and system messages.
+    Each system maintains its own internal state and processing, but can only influence
+    other systems through these explicit boundary-crossing messages. This follows the
+    Free Energy Principle where systems minimize surprise by maintaining boundaries.
     
     Attributes:
-        content: The actual message content (text, JSON, etc.)
-        message_type: Type identifier (e.g., 'user', 'assistant', 'system', 'tool')
-        time_record: Timing information for the message
-        metadata: Additional message metadata (e.g., model used, tokens consumed,
-                 tool calls, attachments, etc.)
+        content: The actual message content crossing the boundary (text, JSON, etc.)
+        message_type: Type of boundary crossing (e.g., 'observation', 'action', 'result')
+        time_record: Timing information for the boundary crossing
+        metadata: Boundary crossing metadata. Recommended keys:
+                  - 'step_id': Timestep identifier
+                  - 'from_system_instance_id': UUID of the sending system
+                  - 'to_system_instance_id': UUID of the receiving system
+                  - 'from_system_role': Role of sender (e.g., 'human', 'agent', 'runtime', 'environment')
+                  - 'to_system_role': Role of receiver
+                  - 'boundary_type': Type of Markov blanket boundary being crossed
+                  - 'call_id': Correlate request/response pairs across boundaries
+                  - 'causal_influence': Direction of causal flow
     """
 
     content: str
@@ -70,8 +105,9 @@ class SessionEventMessage:
 class BaseEvent:
     """Base class for all event types.
     
-    This is the foundation for all events in the tracing system. Every event
-    must have a system identifier and timing information.
+    This is the foundation for all events in the tracing system. Every event must
+    have a system identifier and timing information. Events are intra-system facts
+    (they occur within a subsystem) and are not necessarily direct communications.
     
     Attributes:
         system_instance_id: Identifier for the system/component that generated
@@ -95,8 +131,10 @@ class BaseEvent:
 class RuntimeEvent(BaseEvent):
     """Event from runtime system.
     
-    Captures events from the AI system's runtime, typically representing
-    decisions or actions taken by the system.
+    Captures events from the AI system's runtime, typically representing decisions
+    or actions taken by the system (e.g., selecting a tool with arguments).
+    Use paired SessionEventMessages to record the communication of this choice to
+    the environment.
     
     Attributes:
         actions: List of action identifiers or indices. The interpretation
@@ -111,7 +149,9 @@ class RuntimeEvent(BaseEvent):
 class EnvironmentEvent(BaseEvent):
     """Event from environment.
     
-    Captures feedback from the environment in response to system actions.
+    Captures feedback from the environment in response to system actions (e.g.,
+    command output, exit codes, observations). Use a paired SessionEventMessage
+    to record the environment-to-agent communication of the result.
     Follows the Gymnasium/OpenAI Gym convention for compatibility.
     
     Attributes:
@@ -135,6 +175,8 @@ class LMCAISEvent(BaseEvent):
     
     CAIS (Claude AI System) events capture detailed information about LLM calls,
     including performance metrics, cost tracking, and distributed tracing support.
+    Treat provider-specific prompt/completion structures as part of this event's
+    data. Do not emit them as SessionEventMessages.
     
     Attributes:
         model_name: The specific model used (e.g., 'gpt-4', 'claude-3-opus')
@@ -148,6 +190,8 @@ class LMCAISEvent(BaseEvent):
         trace_id: OpenTelemetry compatible trace identifier
         system_state_before: State snapshot before the LLM call
         system_state_after: State snapshot after the LLM call
+        call_records: List of normalized LLM call records capturing request/response
+                      details (messages, tool calls/results, usage, params, etc.).
     """
 
     model_name: str = ""
@@ -161,6 +205,7 @@ class LMCAISEvent(BaseEvent):
     trace_id: Optional[str] = None
     system_state_before: Optional[Dict[str, Any]] = None
     system_state_after: Optional[Dict[str, Any]] = None
+    call_records: List[LLMCallRecord] = field(default_factory=list)
 
 
 @dataclass
@@ -188,7 +233,7 @@ class SessionTimeStep:
     timestamp: datetime = field(default_factory=datetime.utcnow)
     turn_number: Optional[int] = None
     events: List[BaseEvent] = field(default_factory=list)
-    step_messages: List[SessionEventMessage] = field(default_factory=list)
+    markov_blanket_messages: List[SessionEventMarkovBlanketMessage] = field(default_factory=list)
     step_metadata: Dict[str, Any] = field(default_factory=dict)
     completed_at: Optional[datetime] = None
 
@@ -222,7 +267,7 @@ class SessionTrace:
     created_at: datetime = field(default_factory=datetime.utcnow)
     session_time_steps: List[SessionTimeStep] = field(default_factory=list)
     event_history: List[BaseEvent] = field(default_factory=list)
-    message_history: List[SessionEventMessage] = field(default_factory=list)
+    markov_blanket_message_history: List[SessionEventMarkovBlanketMessage] = field(default_factory=list)
     metadata: Dict[str, Any] = field(default_factory=dict)
     session_metadata: Optional[List[Dict[str, Any]]] = None
 

synth_ai/tracing_v3/config.py

@@ -9,15 +9,21 @@ class TursoConfig:
     """Configuration for Turso/sqld connection."""
 
     # Default values matching serve.sh
-    DEFAULT_DB_FILE = "synth_ai.db"
+    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
     DEFAULT_HTTP_PORT = 8080
 
     # Local embedded database for async SQLAlchemy
-    # Use the centralized configuration for the database URL
-    db_url: str = os.getenv(
-        "TURSO_LOCAL_DB_URL",
-        f"sqlite+aiosqlite:///{os.path.abspath(os.getenv('SQLD_DB_PATH', 'synth_ai.db'))}",
-    )
+    # Resolve to the actual SQLite file used by sqld if the base path is a directory
+    def _resolve_sqlite_db_url() -> str:  # type: ignore[no-redef]
+        base_path = os.path.abspath(os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db"))
+        # If sqld is managing this DB, the real SQLite file lives under dbs/default/data
+        candidate = os.path.join(base_path, "dbs", "default", "data")
+        if os.path.isdir(base_path) and os.path.exists(candidate):
+            return f"sqlite+aiosqlite:///{candidate}"
+        return f"sqlite+aiosqlite:///{base_path}"
+
+    # Use env override if provided; otherwise resolve based on SQLD layout
+    db_url: str = os.getenv("TURSO_LOCAL_DB_URL", _resolve_sqlite_db_url())
 
     # Remote database sync configuration
     sync_url: str = os.getenv("TURSO_DATABASE_URL", "")
@@ -40,7 +46,7 @@ class TursoConfig:
 
     # Daemon settings (for local sqld) - match serve.sh defaults
     sqld_binary: str = os.getenv("SQLD_BINARY", "sqld")
-    sqld_db_path: str = os.getenv("SQLD_DB_PATH", "synth_ai.db")
+    sqld_db_path: str = os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db")
     sqld_http_port: int = int(os.getenv("SQLD_HTTP_PORT", "8080"))
     sqld_idle_shutdown: int = int(os.getenv("SQLD_IDLE_SHUTDOWN", "0"))  # 0 = no idle shutdown
 

synth_ai/tracing_v3/db_config.py

@@ -18,7 +18,7 @@ class DatabaseConfig:
     """Centralized database configuration management."""
 
     # Default values from serve.sh
-    DEFAULT_DB_FILE = "synth_ai.db"
+    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
     DEFAULT_HTTP_PORT = 8080
 
     def __init__(
@@ -58,15 +58,15 @@ class DatabaseConfig:
 
         if os.path.exists(sqld_data_path):
             # sqld is managing the database
-            logger.info(f"✅ Using sqld-managed database at: {sqld_data_path}")
+            logger.debug(f"✅ Using sqld-managed database at: {sqld_data_path}")
             actual_db_path = sqld_data_path
         else:
             # Direct SQLite file
             if not os.path.exists(abs_path):
-                logger.warning(f"⚠️  Database file not found at: {abs_path}")
-                logger.warning("🔧 Make sure to run './serve.sh' to start the turso/sqld service")
+                logger.debug(f"⚠️  Database file not found at: {abs_path}")
+                logger.debug("🔧 Make sure to run './serve.sh' to start the turso/sqld service")
             else:
-                logger.info(f"📁 Using direct SQLite file at: {abs_path}")
+                logger.debug(f"📁 Using direct SQLite file at: {abs_path}")
             actual_db_path = abs_path
 
         # SQLite URLs need 3 slashes for absolute paths
@@ -147,7 +147,7 @@ def get_default_db_config() -> DatabaseConfig:
                 # sqld is already running, don't start a new one
                 sqld_running = True
                 use_sqld = False
-                logger.info(f"✅ Detected sqld already running on port {sqld_port}")
+                logger.debug(f"✅ Detected sqld already running on port {sqld_port}")
         except Exception as e:
             logger.debug(f"Could not check for sqld process: {e}")
 

synth_ai/tracing_v3/hooks.py

@@ -37,7 +37,7 @@ from dataclasses import dataclass
 import asyncio
 import inspect
 
-from .abstractions import SessionTrace, SessionTimeStep, BaseEvent, SessionEventMessage
+from .abstractions import SessionTrace, SessionTimeStep, BaseEvent, SessionEventMarkovBlanketMessage
 
 
 @dataclass