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

synth_ai/tracing_v3/tests/test_session_tracer.py

@@ -12,6 +12,7 @@ import time
 
 from synth_ai.tracing_v3.session_tracer import SessionTracer
 from synth_ai.tracing_v3.abstractions import RuntimeEvent, EnvironmentEvent, LMCAISEvent, TimeRecord
+from synth_ai.tracing_v3.lm_call_record_abstractions import LLMCallRecord, LLMUsage, LLMMessage, LLMContentPart
 from synth_ai.tracing_v3.hooks import HookManager
 from synth_ai.tracing_v3.decorators import get_session_id, SessionContext
 
@@ -49,8 +50,8 @@ class TestSessionTracer:
 
         # Record message
         await tracer.record_message(content="Test message", message_type="user")
-        assert len(tracer.current_session.message_history) == 1
-        assert len(tracer.current_step.step_messages) == 1
+        assert len(tracer.current_session.markov_blanket_message_history) == 1
+        assert len(tracer.current_step.markov_blanket_messages) == 1
 
         # End timestep
         await tracer.end_timestep()
@@ -123,7 +124,7 @@ class TestSessionTracer:
 
         assert len(trace.session_time_steps) == 3
         assert len(trace.event_history) == 3
-        assert len(trace.message_history) == 3
+        assert len(trace.markov_blanket_message_history) == 3
 
         # Verify step indices
         for i, step in enumerate(trace.session_time_steps):
@@ -225,8 +226,8 @@ class TestSessionTracer:
         await tracer1.record_message("Tracer 1 message", "user")
 
         # Verify isolation
-        assert len(tracer1.current_session.message_history) == 1
-        assert len(tracer2.current_session.message_history) == 0
+        assert len(tracer1.current_session.markov_blanket_message_history) == 1
+        assert len(tracer2.current_session.markov_blanket_message_history) == 0
 
         await tracer1.end_session(save=False)
         await tracer2.end_session(save=False)
@@ -242,7 +243,7 @@ class TestSessionTracer:
 
         # Should complete without errors
         assert trace is not None
-        assert len(trace.message_history) == 1
+        assert len(trace.markov_blanket_message_history) == 1
 
     async def test_session_context_variables(self):
         """Test session context variables."""
@@ -296,16 +297,45 @@ class TestSessionTracer:
         )
         await tracer.record_event(env_event)
 
-        # LM CAIS event
+        # LM CAIS event with call_records (new pattern)
+        import uuid
+        call_record = LLMCallRecord(
+            call_id=str(uuid.uuid4()),
+            api_type="chat_completions",
+            provider="openai",
+            model_name="gpt-4",
+            usage=LLMUsage(
+                input_tokens=100,
+                output_tokens=50,
+                total_tokens=150,
+                cost_usd=0.003
+            ),
+            input_messages=[
+                LLMMessage(
+                    role="user",
+                    parts=[LLMContentPart(type="text", text="Test prompt")]
+                )
+            ],
+            output_messages=[
+                LLMMessage(
+                    role="assistant",
+                    parts=[LLMContentPart(type="text", text="Test response")]
+                )
+            ],
+            latency_ms=500
+        )
+        
         lm_event = LMCAISEvent(
             system_instance_id="llm",
             time_record=TimeRecord(event_time=time.time()),
-            model_name="gpt-4",
+            # Aggregates at event level
             input_tokens=100,
             output_tokens=50,
             total_tokens=150,
             cost_usd=0.003,
             latency_ms=500,
+            # Store the call record
+            call_records=[call_record]
         )
         await tracer.record_event(lm_event)
 
@@ -320,7 +350,11 @@ class TestSessionTracer:
         # Verify metadata
         assert trace.event_history[0].metadata["type"] == "runtime"
         assert trace.event_history[1].reward == 0.5
-        assert trace.event_history[2].model_name == "gpt-4"
+        # Verify new call_records structure
+        lm_event_from_trace = trace.event_history[2]
+        assert len(lm_event_from_trace.call_records) == 1
+        assert lm_event_from_trace.call_records[0].model_name == "gpt-4"
+        assert lm_event_from_trace.call_records[0].usage.total_tokens == 150
 
     async def test_concurrent_timesteps_same_session(self):
         """Test that timesteps within a session are sequential, not concurrent."""

synth_ai/tracing_v3/tests/test_turso_manager.py

@@ -18,7 +18,7 @@ import pandas as pd
 from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
 from synth_ai.tracing_v3.session_tracer import SessionTracer
 from synth_ai.tracing_v3.abstractions import (
-    SessionEventMessage,
+    SessionEventMarkovBlanketMessage,
     TimeRecord,
     RuntimeEvent,
     EnvironmentEvent,

synth_ai/tracing_v3/turso/manager.py

@@ -91,7 +91,7 @@ class AsyncSQLTraceManager:
         concurrent scenarios.
         """
         if self.engine is None:
-            logger.info(f"🔗 Initializing database connection to: {self.db_url}")
+            logger.debug(f"🔗 Initializing database connection to: {self.db_url}")
 
             # For SQLite, use NullPool to avoid connection pool issues
             # SQLite doesn't handle concurrent connections well, so we create
@@ -103,12 +103,12 @@ class AsyncSQLTraceManager:
 
                 # Check if database file exists
                 if not os.path.exists(db_path):
-                    logger.warning(f"⚠️  Database file not found: {db_path}")
-                    logger.warning(
+                    logger.debug(f"⚠️  Database file not found: {db_path}")
+                    logger.debug(
                         "🔧 Make sure './serve.sh' is running to start the turso/sqld service"
                     )
                 else:
-                    logger.info(f"✅ Found database file: {db_path}")
+                    logger.debug(f"✅ Found database file: {db_path}")
 
                 # Set a high busy timeout to handle concurrent access
                 # This allows SQLite to wait instead of immediately failing
@@ -145,7 +145,7 @@ class AsyncSQLTraceManager:
             if self._schema_ready:
                 return
 
-            logger.info("📊 Initializing database schema...")
+            logger.debug("📊 Initializing database schema...")
 
             async with self.engine.begin() as conn:
                 # Use a transaction to ensure atomic schema creation
@@ -154,14 +154,14 @@ class AsyncSQLTraceManager:
                     await conn.run_sync(
                         lambda sync_conn: Base.metadata.create_all(sync_conn, checkfirst=True)
                     )
-                    logger.info("✅ Database schema created/verified successfully")
+                    #logger.info("✅ Database schema created/verified successfully")
                 except Exception as e:
                     # If tables already exist, that's fine - another worker created them
                     if "already exists" not in str(e):
                         logger.error(f"❌ Failed to create database schema: {e}")
                         raise
                     else:
-                        logger.info("✅ Database schema already exists")
+                        logger.debug("✅ Database schema already exists")
 
                 # Enable foreign keys for SQLite - critical for data integrity
                 # This must be done for each connection in SQLite
@@ -183,7 +183,7 @@ class AsyncSQLTraceManager:
                             logger.warning(f"Could not create view {view_name}: {e}")
 
             self._schema_ready = True
-            logger.info("🎯 Database ready for use!")
+            #logger.debug("🎯 Database ready for use!")
 
     @asynccontextmanager
     async def session(self):
@@ -223,7 +223,7 @@ class AsyncSQLTraceManager:
                     created_at=trace.created_at,
                     num_timesteps=len(trace.session_time_steps),
                     num_events=len(trace.event_history),
-                    num_messages=len(trace.message_history),
+                    num_messages=len(trace.markov_blanket_message_history),
                     session_metadata=trace.metadata or {},
                 )
                 sess.add(db_session)
@@ -242,7 +242,7 @@ class AsyncSQLTraceManager:
                         started_at=step.timestamp,
                         completed_at=step.completed_at,
                         num_events=len(step.events),
-                        num_messages=len(step.step_messages),
+                        num_messages=len(step.markov_blanket_messages),
                         step_metadata=step.step_metadata or {},
                     )
                     sess.add(db_step)
@@ -266,6 +266,12 @@ class AsyncSQLTraceManager:
                     }
 
                     if isinstance(event, LMCAISEvent):
+                        # Serialize call_records if present
+                        call_records_data = None
+                        if event.call_records:
+                            from dataclasses import asdict
+                            call_records_data = [asdict(record) for record in event.call_records]
+                        
                         event_data.update(
                             {
                                 "event_type": "cais",
@@ -280,6 +286,7 @@ class AsyncSQLTraceManager:
                                 "trace_id": event.trace_id,
                                 "system_state_before": event.system_state_before,
                                 "system_state_after": event.system_state_after,
+                                "call_records": call_records_data,  # Store in the proper column
                             }
                         )
                     elif isinstance(event, EnvironmentEvent):
@@ -307,7 +314,7 @@ class AsyncSQLTraceManager:
                     sess.add(db_event)
 
                 # Insert messages
-                for msg in trace.message_history:
+                for msg in trace.markov_blanket_message_history:
                     db_msg = DBMessage(
                         session_id=trace.session_id,
                         timestep_id=step_id_map.get(msg.metadata.get("step_id"))

synth_ai/tracing_v3/turso/models.py

@@ -171,6 +171,7 @@ class Event(Base):
     latency_ms = Column(Integer)
     span_id = Column(String)
     trace_id = Column(String)
+    call_records = Column(JSONText)  # Store serialized LLMCallRecord list
 
     # Environment event fields
     reward = Column(Float)

synth_ai/tui/__main__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""
+Entry point for Synth AI TUI dashboard.
+
+Usage:
+    python -m synth_ai.tui
+    python -m synth_ai.tui --url sqlite+aiosqlite:///path/to/db
+"""
+
+from .dashboard import main
+
+if __name__ == "__main__":
+    main()

synth_ai/tui/dashboard.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""
+Interactive TUI Dashboard for Synth AI experiments.
+
+Launch with: python -m synth_ai.tui.dashboard
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from urllib.parse import urlparse
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import (
+    Header, Footer, DataTable, Static, Input, Button, 
+    TabbedContent, TabPane, Label, ProgressBar
+)
+from textual.reactive import reactive
+from textual.binding import Binding
+from textual import on
+from textual.timer import Timer
+
+from ..tracing_v3.turso.manager import AsyncSQLTraceManager
+
+class ExperimentRow:
+    """Data structure for experiment display."""
+    def __init__(self, exp_id: str, name: str, description: str, 
+                 created_at: datetime, sessions: int, events: int, 
+                 messages: int, cost: float, tokens: int):
+        self.exp_id = exp_id
+        self.name = name or "Unnamed"
+        self.description = description or ""
+        self.created_at = created_at
+        self.sessions = sessions
+        self.events = events  
+        self.messages = messages
+        self.cost = cost
+        self.tokens = tokens
+        
+    def to_row(self) -> List[str]:
+        """Convert to table row format."""
+        return [
+            self.exp_id[:8],  # Shortened ID
+            self.name[:20],   # Truncated name
+            str(self.sessions),
+            str(self.events),
+            str(self.messages),
+            f"${self.cost:.4f}",
+            f"{self.tokens:,}",
+            self.created_at.strftime("%H:%M")
+        ]
+
+class ExperimentTable(DataTable):
+    """Custom DataTable for experiments with refresh capability."""
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.experiments: List[ExperimentRow] = []
+        self.selected_exp_id: Optional[str] = None
+        
+    def setup_table(self):
+        """Initialize table columns."""
+        self.add_columns(
+            "ID", "Name", "Sessions", "Events", 
+            "Messages", "Cost", "Tokens", "Time"
+        )
+        
+    async def refresh_data(self, db_manager: AsyncSQLTraceManager):
+        """Refresh experiment data from database."""
+        try:
+            # Get experiment list with stats using raw query
+            df = await db_manager.query_traces("""
+                SELECT 
+                    e.experiment_id,
+                    e.name,
+                    e.description,
+                    e.created_at,
+                    COUNT(DISTINCT st.session_id) as num_sessions,
+                    COUNT(DISTINCT ev.id) as num_events,
+                    COUNT(DISTINCT m.id) as num_messages,
+                    SUM(CASE WHEN ev.event_type = 'cais' THEN ev.cost_usd ELSE 0 END) / 100.0 as total_cost,
+                    SUM(CASE WHEN ev.event_type = 'cais' THEN ev.total_tokens ELSE 0 END) as total_tokens
+                FROM experiments e
+                LEFT JOIN session_traces st ON e.experiment_id = st.experiment_id
+                LEFT JOIN events ev ON st.session_id = ev.session_id
+                LEFT JOIN messages m ON st.session_id = m.session_id
+                GROUP BY e.experiment_id, e.name, e.description, e.created_at
+                ORDER BY e.created_at DESC
+            """)
+            
+            self.experiments.clear()
+            self.clear()
+            
+            if not df.empty:
+                for _, row in df.iterrows():
+                    exp_row = ExperimentRow(
+                        exp_id=row['experiment_id'],
+                        name=row['name'],
+                        description=row['description'],
+                        created_at=row['created_at'],
+                        sessions=int(row['num_sessions'] or 0),
+                        events=int(row['num_events'] or 0),
+                        messages=int(row['num_messages'] or 0),
+                        cost=float(row['total_cost'] or 0.0),
+                        tokens=int(row['total_tokens'] or 0)
+                    )
+                    self.experiments.append(exp_row)
+                    self.add_row(*exp_row.to_row(), key=exp_row.exp_id)
+                
+        except Exception as e:
+            logging.error(f"Failed to refresh experiments: {e}")
+            
+    def get_selected_experiment(self) -> Optional[ExperimentRow]:
+        """Get currently selected experiment."""
+        if self.cursor_row >= 0 and self.cursor_row < len(self.experiments):
+            return self.experiments[self.cursor_row]
+        return None
+
+class ExperimentDetail(Static):
+    """Detailed view of selected experiment."""
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.current_experiment: Optional[ExperimentRow] = None
+        
+    def update_experiment(self, experiment: Optional[ExperimentRow]):
+        """Update the displayed experiment details."""
+        self.current_experiment = experiment
+        if experiment:
+            details = f"""
+🔬 **{experiment.name}**
+ID: {experiment.exp_id}
+Description: {experiment.description or 'No description'}
+
+📊 **Statistics**
+Sessions: {experiment.sessions}
+Events: {experiment.events}  
+Messages: {experiment.messages}
+Cost: ${experiment.cost:.4f}
+Tokens: {experiment.tokens:,}
+
+🕒 **Created**: {experiment.created_at.strftime('%Y-%m-%d %H:%M:%S')}
+            """.strip()
+        else:
+            details = "Select an experiment to view details"
+            
+        self.update(details)
+
+class DatabaseStatus(Static):
+    """Display database connection status."""
+    
+    connection_status = reactive("🔴 Disconnected")
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        
+    def render(self) -> str:
+        return f"Database: {self.connection_status}"
+        
+    def set_connected(self, url: str):
+        parsed = urlparse(url)
+        host_info = f"{parsed.hostname}:{parsed.port}" if parsed.port else str(parsed.hostname)
+        self.connection_status = f"🟢 Connected ({host_info})"
+        
+    def set_disconnected(self, error: str = ""):
+        error_text = f" - {error}" if error else ""
+        self.connection_status = f"🔴 Disconnected{error_text}"
+
+class SynthDashboard(App):
+    """Main Synth AI TUI Dashboard application."""
+    
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 2 3;
+        grid-gutter: 1;
+    }
+    
+    #header {
+        column-span: 2;
+        height: 3;
+    }
+    
+    #experiments-table {
+        row-span: 2;
+    }
+    
+    #experiment-detail {
+        height: 1fr;
+    }
+    
+    #status-bar {
+        column-span: 2;
+        height: 3;
+    }
+    
+    ExperimentTable {
+        height: 100%;
+    }
+    
+    ExperimentDetail {
+        border: solid $primary;
+        padding: 1;
+        height: 100%;
+    }
+    
+    DatabaseStatus {
+        height: 1;
+        padding: 0 1;
+    }
+    """
+    
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("d", "toggle_debug", "Debug"),
+        ("ctrl+c", "quit", "Quit"),
+    ]
+    
+    def __init__(self, db_url: str = "sqlite+aiosqlite:///./synth_ai.db/dbs/default/data"):
+        super().__init__()
+        self.db_url = db_url
+        self.db_manager: Optional[AsyncSQLTraceManager] = None
+        self.refresh_timer: Optional[Timer] = None
+        
+    def compose(self) -> ComposeResult:
+        """Create the UI layout."""
+        yield Header(show_clock=True)
+        
+        with Container(id="experiments-table"):
+            yield Static("🧪 Experiments", classes="section-title")
+            yield ExperimentTable(id="experiments")
+            
+        with Container(id="experiment-detail"):
+            yield Static("📋 Details", classes="section-title")  
+            yield ExperimentDetail(id="detail")
+            
+        with Container(id="status-bar"):
+            yield DatabaseStatus(id="db-status")
+            yield Footer()
+            
+    async def on_mount(self) -> None:
+        """Initialize the app when mounted."""
+        # Setup database connection
+        try:
+            self.db_manager = AsyncSQLTraceManager(self.db_url)
+            await self.db_manager.initialize()
+            
+            db_status = self.query_one("#db-status", DatabaseStatus)
+            db_status.set_connected(self.db_url)
+            
+        except Exception as e:
+            logging.error(f"Failed to connect to database: {e}")
+            db_status = self.query_one("#db-status", DatabaseStatus)
+            db_status.set_disconnected(str(e))
+            
+        # Setup experiment table
+        exp_table = self.query_one("#experiments", ExperimentTable)
+        exp_table.setup_table()
+        
+        # Initial data load
+        await self.action_refresh()
+        
+        # Start auto-refresh timer (every 5 seconds)
+        self.refresh_timer = self.set_interval(5.0, self._auto_refresh)
+        
+    async def _auto_refresh(self) -> None:
+        """Auto-refresh data periodically."""
+        if self.db_manager:
+            exp_table = self.query_one("#experiments", ExperimentTable)
+            await exp_table.refresh_data(self.db_manager)
+            
+    async def action_refresh(self) -> None:
+        """Manual refresh action."""
+        if self.db_manager:
+            exp_table = self.query_one("#experiments", ExperimentTable)
+            await exp_table.refresh_data(self.db_manager)
+            
+    async def action_quit(self) -> None:
+        """Quit the application."""
+        if self.refresh_timer:
+            self.refresh_timer.stop()
+        if self.db_manager:
+            await self.db_manager.close()
+        self.exit()
+        
+    def action_toggle_debug(self) -> None:
+        """Toggle debug mode."""
+        # Could add debug panel or logging level toggle
+        pass
+        
+    @on(DataTable.RowHighlighted, "#experiments")
+    def on_experiment_selected(self, event: DataTable.RowHighlighted) -> None:
+        """Handle experiment selection."""
+        exp_table = self.query_one("#experiments", ExperimentTable)
+        selected_exp = exp_table.get_selected_experiment()
+        
+        detail_panel = self.query_one("#detail", ExperimentDetail)
+        detail_panel.update_experiment(selected_exp)
+
+def main():
+    """Main entry point for the dashboard."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Synth AI Interactive Dashboard")
+    parser.add_argument(
+        "-u", "--url", 
+        default="sqlite+libsql://http://127.0.0.1:8080",
+        help="Database URL (default: sqlite+libsql://http://127.0.0.1:8080)"
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+        
+    # Run the dashboard
+    app = SynthDashboard(db_url=args.url)
+    app.run()
+
+if __name__ == "__main__":
+    main()

synth_ai/{tracing → v0/tracing}/base_client.py

@@ -4,9 +4,9 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Dict, Optional
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.config import TracingConfig
-from synth_ai.tracing.events.store import event_store
+from .abstractions import Event
+from .config import TracingConfig
+from .events.store import event_store
 
 logger = logging.getLogger(__name__)
 

synth_ai/{tracing → v0/tracing}/client_manager.py

@@ -6,7 +6,7 @@ from typing import ClassVar, Dict, Optional
 
 import httpx
 
-from synth_ai.tracing.config import TracingConfig
+from .config import TracingConfig
 
 
 class ClientManager:

synth_ai/{tracing → v0/tracing}/context.py

@@ -3,7 +3,7 @@ import logging
 from contextlib import contextmanager
 from typing import Any, Dict, Generic, Optional, TypeVar
 
-from synth_ai.tracing.local import (
+from .local import (
     _local,
     active_events_var,
     system_id_var,

synth_ai/{tracing → v0/tracing}/decorators.py

@@ -7,9 +7,9 @@ from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, ParamSpec, TypeVar, Union
 
 if TYPE_CHECKING:
-    from synth_ai.tracing.trackers import SynthTrackerAsync, SynthTrackerSync
+    from .trackers import SynthTrackerAsync, SynthTrackerSync
 
-from synth_ai.tracing.abstractions import (
+from .abstractions import (
     AgentComputeStep,
     ArbitraryInputs,
     ArbitraryOutputs,
@@ -18,28 +18,28 @@ from synth_ai.tracing.abstractions import (
     MessageInputs,
     MessageOutputs,
 )
-from synth_ai.tracing.config import EventManagement, LoggingMode, Origin, TracingConfig
-from synth_ai.tracing.context import (
+from .config import EventManagement, LoggingMode, Origin, TracingConfig
+from .context import (
     get_current_context,
     trace_context,
 )
-from synth_ai.tracing.events.manage import set_current_event
-from synth_ai.tracing.events.store import event_store
-from synth_ai.tracing.immediate_client import (
+from .events.manage import set_current_event
+from .events.store import event_store
+from .immediate_client import (
     AsyncImmediateLogClient,
     ImmediateLogClient,
 )
-from synth_ai.tracing.local import (
+from .local import (
     _local,
     active_events_var,
     logger,
 )
-from synth_ai.tracing.retry_queue import initialize_retry_queue, retry_queue
-from synth_ai.tracing.trackers import (
+from .retry_queue import initialize_retry_queue, retry_queue
+from .trackers import (
     synth_tracker_async,
     synth_tracker_sync,
 )
-from synth_ai.tracing.utils import get_system_id
+from .utils import get_system_id
 
 logger = logging.getLogger(__name__)