synth-ai 0.2.13.dev2__py3-none-any.whl → 0.2.14__py3-none-any.whl

synth_ai/tracing_v3/session_tracer.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 from contextlib import asynccontextmanager
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from typing import Any
 
 from .abstractions import (
@@ -106,7 +106,7 @@ class SessionTracer:
 
             self._current_trace = SessionTrace(
                 session_id=session_id,
-                created_at=datetime.now(UTC),
+                created_at=datetime.now(timezone.utc),
                 session_time_steps=[],
                 event_history=[],
                 markov_blanket_message_history=[],
@@ -152,7 +152,7 @@ class SessionTracer:
         step = SessionTimeStep(
             step_id=step_id,
             step_index=len(self._current_trace.session_time_steps),
-            timestamp=datetime.now(UTC),
+            timestamp=datetime.now(timezone.utc),
             turn_number=turn_number,
             step_metadata=metadata or {},
         )
@@ -197,7 +197,7 @@ class SessionTracer:
             step = self._current_step
 
         if step and step.completed_at is None:
-            step.completed_at = datetime.now(UTC)
+            step.completed_at = datetime.now(timezone.utc)
 
             # Trigger hooks
             await self.hooks.trigger(
@@ -294,7 +294,7 @@ class SessionTracer:
             content=normalised_content,
             message_type=message_type,
             time_record=TimeRecord(
-                event_time=event_time or datetime.now(UTC).timestamp(), message_time=message_time
+                event_time=event_time or datetime.now(timezone.utc).timestamp(), message_time=message_time
             ),
             metadata=metadata or {},
         )
@@ -368,18 +368,28 @@ class SessionTracer:
             # End any open timesteps
             for step in self._current_trace.session_time_steps:
                 if step.completed_at is None:
-                    step.completed_at = datetime.now(UTC)
+                    step.completed_at = datetime.now(timezone.utc)
 
             # Trigger pre-save hooks
             await self.hooks.trigger("before_save", session=self._current_trace)
 
             # Save if requested
             should_save = save if save is not None else self.auto_save
+            
+            # Debug logging
+            import logging
+            _logger = logging.getLogger(__name__)
+            _logger.info(f"[TRACE_DEBUG] end_session: should_save={should_save}, self.db={self.db is not None}, auto_save={self.auto_save}")
+            
             if should_save and self.db:
+                _logger.info(f"[TRACE_DEBUG] Calling insert_session_trace with {len(self._current_trace.markov_blanket_message_history)} messages")
                 await self.db.insert_session_trace(self._current_trace)
+                _logger.info(f"[TRACE_DEBUG] insert_session_trace completed")
 
                 # Trigger post-save hooks
                 await self.hooks.trigger("after_save", session=self._current_trace)
+            else:
+                _logger.warning(f"[TRACE_DEBUG] Skipping save: should_save={should_save}, self.db={self.db is not None}")
 
             # Trigger session end hooks
             await self.hooks.trigger("session_end", session=self._current_trace)

synth_ai/tracing_v3/storage/base.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Any
+from typing import Any, Optional
 
 from ..abstractions import SessionTrace
 
@@ -28,7 +28,7 @@ class TraceStorage(ABC):
         pass
 
     @abstractmethod
-    async def get_session_trace(self, session_id: str) -> dict[str, Any] | None:
+    async def get_session_trace(self, session_id: str) -> Optional[dict[str, Any]]:
         """Retrieve a session trace by ID.
 
         Args:
@@ -40,7 +40,7 @@ class TraceStorage(ABC):
         pass
 
     @abstractmethod
-    async def query_traces(self, query: str, params: dict[str, Any] | None = None) -> Any:
+    async def query_traces(self, query: str, params: Optional[dict[str, Any]] = None) -> Any:
         """Execute a query and return results.
 
         Args:
@@ -55,9 +55,9 @@ class TraceStorage(ABC):
     @abstractmethod
     async def get_model_usage(
         self,
-        start_date: datetime | None = None,
-        end_date: datetime | None = None,
-        model_name: str | None = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        model_name: Optional[str] = None,
     ) -> Any:
         """Get model usage statistics.
 
@@ -95,8 +95,8 @@ class TraceStorage(ABC):
         self,
         session_id: str,
         *,
-        created_at: datetime | None = None,
-        metadata: dict[str, Any] | None = None,
+        created_at: Optional[datetime] = None,
+        metadata: Optional[dict[str, Any]] = None,
     ) -> None:
         """Ensure a session row exists for the given session id."""
         pass
@@ -108,10 +108,10 @@ class TraceStorage(ABC):
         *,
         step_id: str,
         step_index: int,
-        turn_number: int | None = None,
-        started_at: datetime | None = None,
-        completed_at: datetime | None = None,
-        metadata: dict[str, Any] | None = None,
+        turn_number: Optional[int] = None,
+        started_at: Optional[datetime] = None,
+        completed_at: Optional[datetime] = None,
+        metadata: Optional[dict[str, Any]] = None,
     ) -> int:
         """Ensure a timestep row exists and return its database id."""
         pass
@@ -121,9 +121,9 @@ class TraceStorage(ABC):
         self,
         session_id: str,
         *,
-        timestep_db_id: int | None,
+        timestep_db_id: Optional[int],
         event: Any,
-        metadata_override: dict[str, Any] | None = None,
+        metadata_override: Optional[dict[str, Any]] = None,
     ) -> int:
         """Insert an event and return its database id."""
         pass
@@ -133,12 +133,12 @@ class TraceStorage(ABC):
         self,
         session_id: str,
         *,
-        timestep_db_id: int | None,
+        timestep_db_id: Optional[int],
         message_type: str,
         content: Any,
-        event_time: float | None = None,
-        message_time: int | None = None,
-        metadata: dict[str, Any] | None = None,
+        event_time: Optional[float] = None,
+        message_time: Optional[int] = None,
+        metadata: Optional[dict[str, Any]] = None,
     ) -> int:
         """Insert a message row linked to a session/timestep."""
         pass
@@ -151,7 +151,7 @@ class TraceStorage(ABC):
         total_reward: int,
         achievements_count: int,
         total_steps: int,
-        reward_metadata: dict | None = None,
+        reward_metadata: Optional[dict] = None,
     ) -> int:
         """Record an outcome reward for a session."""
         pass
@@ -162,13 +162,13 @@ class TraceStorage(ABC):
         session_id: str,
         *,
         event_id: int,
-        message_id: int | None = None,
-        turn_number: int | None = None,
+        message_id: Optional[int] = None,
+        turn_number: Optional[int] = None,
         reward_value: float = 0.0,
-        reward_type: str | None = None,
-        key: str | None = None,
-        annotation: dict[str, Any] | None = None,
-        source: str | None = None,
+        reward_type: Optional[str] = None,
+        key: Optional[str] = None,
+        annotation: Optional[dict[str, Any]] = None,
+        source: Optional[str] = None,
     ) -> int:
         """Record a reward tied to a specific event."""
         pass
@@ -178,8 +178,8 @@ class TraceStorage(ABC):
         self,
         experiment_id: str,
         name: str,
-        description: str | None = None,
-        configuration: dict[str, Any] | None = None,
+        description: Optional[str] = None,
+        configuration: Optional[dict[str, Any]] = None,
     ) -> str:
         """Create a new experiment."""
         raise NotImplementedError("Experiment management not supported by this backend")
@@ -189,14 +189,14 @@ class TraceStorage(ABC):
         raise NotImplementedError("Experiment management not supported by this backend")
 
     async def get_sessions_by_experiment(
-        self, experiment_id: str, limit: int | None = None
+        self, experiment_id: str, limit: Optional[int] = None
     ) -> list[dict[str, Any]]:
         """Get all sessions for an experiment."""
         raise NotImplementedError("Experiment management not supported by this backend")
 
     # Batch operations
     async def batch_insert_sessions(
-        self, traces: list[SessionTrace], batch_size: int | None = 1000
+        self, traces: list[SessionTrace], batch_size: Optional[int] = 1000
     ) -> list[str]:
         """Batch insert multiple session traces.
 

synth_ai/tracing_v3/storage/config.py

@@ -3,7 +3,7 @@
 import os
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any
+from typing import Any, Optional
 
 
 class StorageBackend(str, Enum):
@@ -14,7 +14,7 @@ class StorageBackend(str, Enum):
     POSTGRES = "postgres"  # Future support
 
 
-def _is_enabled(value: str | None) -> bool:
+def _is_enabled(value: Optional[str]) -> bool:
     if value is None:
         return False
     return value.lower() in {"1", "true", "yes", "on"}
@@ -25,7 +25,7 @@ class StorageConfig:
     """Configuration for storage backend."""
 
     backend: StorageBackend = StorageBackend.TURSO_NATIVE
-    connection_string: str | None = None
+    connection_string: Optional[str] = None
 
     # Turso-specific settings
     turso_url: str = os.getenv("TURSO_DATABASE_URL", "sqlite+libsql://http://127.0.0.1:8080")

synth_ai/tracing_v3/turso/daemon.py

@@ -7,6 +7,7 @@ import time
 
 import requests
 from requests import RequestException
+from typing import Any, Optional
 
 from ..config import CONFIG
 
@@ -16,9 +17,9 @@ class SqldDaemon:
 
     def __init__(
         self,
-        db_path: str | None = None,
-        http_port: int | None = None,
-        binary_path: str | None = None,
+        db_path: Optional[str] = None,
+        http_port: Optional[int] = None,
+        binary_path: Optional[str] = None,
     ):
         """Initialize sqld daemon manager.
 
@@ -30,7 +31,7 @@ class SqldDaemon:
         self.db_path = db_path or CONFIG.sqld_db_path
         self.http_port = http_port or CONFIG.sqld_http_port
         self.binary_path = binary_path or self._find_binary()
-        self.process: subprocess.Popen | None = None
+        self.process: Optional[Any] = None
 
     def _find_binary(self) -> str:
         """Find sqld binary in PATH."""
@@ -123,10 +124,10 @@ class SqldDaemon:
 
 
 # Convenience functions
-_daemon: SqldDaemon | None = None
+_daemon: Optional[SqldDaemon] = None
 
 
-def start_sqld(db_path: str | None = None, port: int | None = None) -> SqldDaemon:
+def start_sqld(db_path: Optional[str] = None, port: Optional[int] = None) -> SqldDaemon:
     """Start a global sqld daemon instance."""
     global _daemon
     if _daemon and _daemon.is_running():
@@ -145,6 +146,6 @@ def stop_sqld():
         _daemon = None
 
 
-def get_daemon() -> SqldDaemon | None:
+def get_daemon() -> Optional[SqldDaemon]:
     """Get the global daemon instance."""
     return _daemon

synth_ai/tracing_v3/turso/native_manager.py

@@ -13,7 +13,7 @@ import logging
 import re
 from collections.abc import Callable
 from dataclasses import asdict, dataclass
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, cast
 
 import libsql
@@ -370,8 +370,18 @@ class NativeLibsqlTraceManager(TraceStorage):
 
     async def insert_session_trace(self, trace: SessionTrace) -> str:
         await self.initialize()
-
-        if await self._session_exists(trace.session_id):
+        
+        import logging as _logging
+        _logger = _logging.getLogger(__name__)
+        _logger.info(f"[TRACE_DEBUG] insert_session_trace START: session_id={trace.session_id}, {len(trace.markov_blanket_message_history)} messages")
+
+        session_exists = await self._session_exists(trace.session_id)
+        _logger.info(f"[TRACE_DEBUG] Session exists: {session_exists}")
+        
+        if session_exists:
+            _logger.warning(f"[TRACE_DEBUG] Session {trace.session_id} already exists, need to save messages anyway!")
+            # Don't return early - we need to save messages!
+            # Just update metadata
             async with self._op_lock:
                 conn = self._conn
                 assert conn is not None
@@ -380,32 +390,34 @@ class NativeLibsqlTraceManager(TraceStorage):
                     (_json_dumps(trace.metadata or {}), trace.session_id),
                 )
                 conn.commit()
-            return trace.session_id
+            # Continue to save messages instead of returning
 
-        created_at = trace.created_at or datetime.now(UTC)
+        if not session_exists:
+            created_at = trace.created_at or datetime.now(timezone.utc)
 
-        async with self._op_lock:
-            conn = self._conn
-            assert conn is not None
-            conn.execute(
-                """
-                INSERT INTO session_traces (
-                    session_id,
-                    created_at,
-                    num_timesteps,
-                    num_events,
-                    num_messages,
-                    metadata
+            async with self._op_lock:
+                conn = self._conn
+                assert conn is not None
+                conn.execute(
+                    """
+                    INSERT INTO session_traces (
+                        session_id,
+                        created_at,
+                        num_timesteps,
+                        num_events,
+                        num_messages,
+                        metadata
+                    )
+                    VALUES (?, ?, 0, 0, 0, ?)
+                    """,
+                    (
+                        trace.session_id,
+                        created_at.isoformat(),
+                        _json_dumps(trace.metadata or {}),
+                    ),
                 )
-                VALUES (?, ?, 0, 0, 0, ?)
-                """,
-                (
-                    trace.session_id,
-                    created_at.isoformat(),
-                    _json_dumps(trace.metadata or {}),
-                ),
-            )
-            conn.commit()
+                conn.commit()
+                _logger.info(f"[TRACE_DEBUG] Session row inserted")
 
         step_id_map: dict[str, int] = {}
 
@@ -434,7 +446,11 @@ class NativeLibsqlTraceManager(TraceStorage):
                 metadata_override=event.metadata or {},
             )
 
-        for msg in trace.markov_blanket_message_history:
+        import logging as _logging
+        _logger = _logging.getLogger(__name__)
+        _logger.info(f"[TRACE_DEBUG] insert_session_trace: saving {len(trace.markov_blanket_message_history)} messages")
+        
+        for idx, msg in enumerate(trace.markov_blanket_message_history):
             metadata = dict(getattr(msg, "metadata", {}) or {})
             step_ref = metadata.get("step_id")
             content_value = msg.content
@@ -452,15 +468,22 @@ class NativeLibsqlTraceManager(TraceStorage):
                 except (TypeError, ValueError):
                     content_value = str(content_value)
 
-            await self.insert_message_row(
-                trace.session_id,
-                timestep_db_id=step_id_map.get(step_ref) if step_ref else None,
-                message_type=msg.message_type,
-                content=content_value,
-                event_time=msg.time_record.event_time,
-                message_time=msg.time_record.message_time,
-                metadata=metadata,
-            )
+            _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: type={msg.message_type}, content_len={len(str(content_value))}")
+            
+            try:
+                await self.insert_message_row(
+                    trace.session_id,
+                    timestep_db_id=step_id_map.get(step_ref) if step_ref else None,
+                    message_type=msg.message_type,
+                    content=content_value,
+                    event_time=msg.time_record.event_time,
+                    message_time=msg.time_record.message_time,
+                    metadata=metadata,
+                )
+                _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: saved successfully")
+            except Exception as exc:
+                _logger.error(f"[TRACE_DEBUG]   Message {idx+1}: FAILED TO SAVE: {exc}", exc_info=True)
+                raise
 
         async with self._op_lock:
             conn = self._conn
@@ -783,7 +806,7 @@ class NativeLibsqlTraceManager(TraceStorage):
     ) -> None:
         await self.initialize()
 
-        created_at_val = (created_at or datetime.now(UTC)).isoformat()
+        created_at_val = (created_at or datetime.now(timezone.utc)).isoformat()
         metadata_json = _json_dumps(metadata or {})
 
         async with self._op_lock:
@@ -815,7 +838,7 @@ class NativeLibsqlTraceManager(TraceStorage):
     ) -> int:
         await self.initialize()
 
-        started_at_val = (started_at or datetime.now(UTC)).isoformat()
+        started_at_val = (started_at or datetime.now(timezone.utc)).isoformat()
         completed_at_val = completed_at.isoformat() if completed_at else None
         metadata_json = _json_dumps(metadata or {})
 
@@ -1127,7 +1150,7 @@ class NativeLibsqlTraceManager(TraceStorage):
                     total_reward,
                     achievements_count,
                     total_steps,
-                    datetime.now(UTC).isoformat(),
+                    datetime.now(timezone.utc).isoformat(),
                     _json_dumps(reward_metadata),
                 ),
             )
@@ -1179,7 +1202,7 @@ class NativeLibsqlTraceManager(TraceStorage):
                     key,
                     _json_dumps(annotation),
                     source,
-                    datetime.now(UTC).isoformat(),
+                    datetime.now(timezone.utc).isoformat(),
                 ),
             )
             conn.commit()

synth_ai/tracing_v3/utils.py

@@ -5,13 +5,13 @@ from __future__ import annotations
 import hashlib
 import json
 import uuid
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from typing import Any
 
 
 def iso_now() -> str:
-    """Get current UTC time as ISO format string."""
-    return datetime.now(UTC).isoformat()
+    """Get current timezone.utc time as ISO format string."""
+    return datetime.now(timezone.utc).isoformat()
 
 
 def json_dumps(obj: Any) -> str:

synth_ai/tui/__init__.py

@@ -0,0 +1,5 @@
+"""Text User Interface utilities for synth-ai."""
+
+from .dashboard import main
+
+__all__ = ["main"]

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/cli/__init__.py

@@ -0,0 +1 @@
+"""Command Line Interface tools for synth-ai."""

synth_ai/tui/cli/query_experiments.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+Query experiments and sessions from Turso/sqld using v3 tracing.
+"""
+
+import argparse
+import asyncio
+
+from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+
+
+async def list_experiments(db_url: str):
+    """List all experiments in the database."""
+    db = AsyncSQLTraceManager(db_url)
+    await db.initialize()
+
+    try:
+        df = await db.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,
+                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
+            GROUP BY e.experiment_id, e.name, e.description, e.created_at
+            ORDER BY e.created_at DESC
+        """)
+
+        if df.empty:
+            print("No experiments found in database.")
+            return
+
+        print(f"\n{'=' * 100}")
+        print(f"{'Experiments in ' + db_url:^100}")
+        print(f"{'=' * 100}\n")
+
+        for _, row in df.iterrows():
+            print(f"🧪 {row['name']} (id: {row['experiment_id'][:8]}...)")
+            print(f"   Created: {row['created_at']}")
+            print(f"   Description: {row['description']}")
+            print(f"   Sessions: {row['num_sessions']}")
+            print(f"   Events: {row['num_events']:,}")
+            if row["total_cost"] and row["total_cost"] > 0:
+                print(f"   Cost: ${row['total_cost']:.4f}")
+            if row["total_tokens"] and row["total_tokens"] > 0:
+                print(f"   Tokens: {int(row['total_tokens']):,}")
+            print()
+    finally:
+        await db.close()
+
+
+async def show_experiment_details(db_url: str, experiment_id: str):
+    """Show detailed information about a specific experiment."""
+    db = AsyncSQLTraceManager(db_url)
+    await db.initialize()
+
+    try:
+        # Get experiment info
+        exp_df = await db.query_traces(
+            """
+            SELECT * FROM experiments WHERE experiment_id LIKE :exp_id
+        """,
+            {"exp_id": f"{experiment_id}%"},
+        )
+
+        if exp_df.empty:
+            print(f"No experiment found matching ID: {experiment_id}")
+            return
+
+        exp = exp_df.iloc[0]
+        print(f"\n{'=' * 100}")
+        print(f"Experiment: {exp['name']} ({exp['experiment_id']})")
+        print(f"{'=' * 100}\n")
+
+        # Get session statistics
+        sessions_df = await db.get_sessions_by_experiment(exp["experiment_id"])
+
+        if sessions_df:
+            print(f"Sessions: {len(sessions_df)}")
+
+            # Get aggregated stats
+            stats_df = await db.query_traces(
+                """
+                SELECT 
+                    COUNT(DISTINCT ev.id) as total_events,
+                    COUNT(DISTINCT m.id) as total_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 session_traces st
+                LEFT JOIN events ev ON st.session_id = ev.session_id
+                LEFT JOIN messages m ON st.session_id = m.session_id
+                WHERE st.experiment_id = :exp_id
+            """,
+                {"exp_id": exp["experiment_id"]},
+            )
+
+            if not stats_df.empty:
+                stats = stats_df.iloc[0]
+                print(f"Total events: {int(stats['total_events']):,}")
+                print(f"Total messages: {int(stats['total_messages']):,}")
+                print(f"Total cost: ${stats['total_cost']:.4f}")
+                print(f"Total tokens: {int(stats['total_tokens']):,}")
+
+            # Show session list
+            print("\nSession list:")
+            for sess in sessions_df:
+                print(f"  - {sess['session_id']} ({sess['created_at']})")
+                print(
+                    f"    Timesteps: {sess['num_timesteps']}, Events: {sess['num_events']}, Messages: {sess['num_messages']}"
+                )
+    finally:
+        await db.close()
+
+
+async def show_model_usage(db_url: str, model_name: str | None = None):
+    """Show model usage statistics."""
+    db = AsyncSQLTraceManager(db_url)
+    await db.initialize()
+
+    try:
+        df = await db.get_model_usage(model_name=model_name)
+
+        if df.empty:
+            print("No model usage data found.")
+            return
+
+        print(f"\n{'=' * 100}")
+        print(f"{'Model Usage Statistics':^100}")
+        print(f"{'=' * 100}\n")
+
+        print(df.to_string(index=False))
+    finally:
+        await db.close()
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Query experiments from Turso/sqld (v3)")
+    parser.add_argument(
+        "-u", "--url", default="sqlite+libsql://http://127.0.0.1:8080", help="Turso database URL"
+    )
+    parser.add_argument(
+        "-e", "--experiment", help="Show details for specific experiment ID (can be partial)"
+    )
+    parser.add_argument("-m", "--model", help="Show usage for specific model")
+    parser.add_argument("--usage", action="store_true", help="Show model usage statistics")
+
+    args = parser.parse_args()
+
+    if args.usage or args.model:
+        await show_model_usage(args.url, args.model)
+    elif args.experiment:
+        await show_experiment_details(args.url, args.experiment)
+    else:
+        await list_experiments(args.url)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())