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

synth_ai/tracing_v3/turso/daemon.py

@@ -30,7 +30,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: subprocess.Popen[str] | None = None
 
     def _find_binary(self) -> str:
         """Find sqld binary in PATH."""
@@ -84,7 +84,7 @@ class SqldDaemon:
                 pass
 
             # Check if process crashed
-            if self.process.poll() is not None:
+            if self.process and self.process.poll() is not None:
                 stdout, stderr = self.process.communicate()
                 raise RuntimeError(
                     f"sqld daemon failed to start:\nstdout: {stdout}\nstderr: {stderr}"

synth_ai/tracing_v3/turso/native_manager.py

@@ -370,8 +370,20 @@ 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}")
+        
+        step_id_map: dict[str, int] = {}
+        
+        if session_exists:
+            _logger.warning(f"[TRACE_DEBUG] Session {trace.session_id} already exists, skipping events/timesteps, only updating messages!")
+            # 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,87 +392,102 @@ class NativeLibsqlTraceManager(TraceStorage):
                     (_json_dumps(trace.metadata or {}), trace.session_id),
                 )
                 conn.commit()
-            return trace.session_id
+            # Skip events and timesteps to ensure idempotency
+        else:
+            created_at = trace.created_at or datetime.now(UTC)
 
-        created_at = trace.created_at or datetime.now(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
+                    )
+                    VALUES (?, ?, 0, 0, 0, ?)
+                    """,
+                    (
+                        trace.session_id,
+                        created_at.isoformat(),
+                        _json_dumps(trace.metadata or {}),
+                    ),
+                )
+                conn.commit()
+                _logger.info("[TRACE_DEBUG] Session row inserted")
 
-        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
+            # Only insert timesteps and events if this is a new session
+            for step in trace.session_time_steps:
+                step_db_id = await self.ensure_timestep(
+                    trace.session_id,
+                    step_id=step.step_id,
+                    step_index=step.step_index,
+                    turn_number=step.turn_number,
+                    started_at=step.timestamp,
+                    completed_at=step.completed_at,
+                    metadata=step.step_metadata or {},
                 )
-                VALUES (?, ?, 0, 0, 0, ?)
-                """,
-                (
+                step_id_map[step.step_id] = step_db_id
+
+            for event in trace.event_history:
+                step_ref = None
+                metadata = event.metadata or {}
+                if isinstance(metadata, dict):
+                    step_ref = metadata.get("step_id")
+                timestep_db_id = step_id_map.get(step_ref) if step_ref else None
+                await self.insert_event_row(
                     trace.session_id,
-                    created_at.isoformat(),
-                    _json_dumps(trace.metadata or {}),
-                ),
-            )
-            conn.commit()
-
-        step_id_map: dict[str, int] = {}
-
-        for step in trace.session_time_steps:
-            step_db_id = await self.ensure_timestep(
-                trace.session_id,
-                step_id=step.step_id,
-                step_index=step.step_index,
-                turn_number=step.turn_number,
-                started_at=step.timestamp,
-                completed_at=step.completed_at,
-                metadata=step.step_metadata or {},
-            )
-            step_id_map[step.step_id] = step_db_id
+                    timestep_db_id=timestep_db_id,
+                    event=event,
+                    metadata_override=event.metadata or {},
+                )
 
-        for event in trace.event_history:
-            step_ref = None
-            metadata = event.metadata or {}
-            if isinstance(metadata, dict):
+        import logging as _logging
+        _logger = _logging.getLogger(__name__)
+        _logger.info(f"[TRACE_DEBUG] insert_session_trace: saving {len(trace.markov_blanket_message_history)} messages (session_exists={session_exists})")
+        
+        # Only insert messages if this is a new session (for idempotency)
+        if not session_exists:
+            for idx, msg in enumerate(trace.markov_blanket_message_history):
+                metadata = dict(getattr(msg, "metadata", {}) or {})
                 step_ref = metadata.get("step_id")
-            timestep_db_id = step_id_map.get(step_ref) if step_ref else None
-            await self.insert_event_row(
-                trace.session_id,
-                timestep_db_id=timestep_db_id,
-                event=event,
-                metadata_override=event.metadata or {},
-            )
-
-        for msg in trace.markov_blanket_message_history:
-            metadata = dict(getattr(msg, "metadata", {}) or {})
-            step_ref = metadata.get("step_id")
-            content_value = msg.content
-            if isinstance(msg.content, SessionMessageContent):
-                if msg.content.json_payload:
-                    metadata.setdefault("json_payload", msg.content.json_payload)
-                    content_value = msg.content.json_payload
-                else:
-                    content_value = msg.content.as_text()
-                    if msg.content.text:
-                        metadata.setdefault("text", msg.content.text)
-            elif not isinstance(content_value, str):
+                content_value = msg.content
+                if isinstance(msg.content, SessionMessageContent):
+                    if msg.content.json_payload:
+                        metadata.setdefault("json_payload", msg.content.json_payload)
+                        content_value = msg.content.json_payload
+                    else:
+                        content_value = msg.content.as_text()
+                        if msg.content.text:
+                            metadata.setdefault("text", msg.content.text)
+                elif not isinstance(content_value, str):
+                    try:
+                        content_value = json.dumps(content_value, ensure_ascii=False)
+                    except (TypeError, ValueError):
+                        content_value = str(content_value)
+
+                _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: type={msg.message_type}, content_len={len(str(content_value))}")
+                
                 try:
-                    content_value = json.dumps(content_value, ensure_ascii=False)
-                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,
-            )
+                    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
+        else:
+            _logger.info("[TRACE_DEBUG] Skipping message insertion for existing session (idempotency)")
 
         async with self._op_lock:
             conn = self._conn
@@ -904,7 +931,11 @@ class NativeLibsqlTraceManager(TraceStorage):
         if isinstance(event, LMCAISEvent):
             call_records = None
             if getattr(event, "call_records", None):
-                call_records = [asdict(record) for record in event.call_records]
+                # Handle both dataclass instances and dicts (from deserialization)
+                call_records = [
+                    asdict(record) if not isinstance(record, dict) else record
+                    for record in event.call_records
+                ]
             payload.update(
                 {
                     "event_type": "cais",

synth_ai/tracing_v3/utils.py

@@ -10,7 +10,7 @@ from typing import Any
 
 
 def iso_now() -> str:
-    """Get current UTC time as ISO format string."""
+    """Get current timezone.utc time as ISO format string."""
     return datetime.now(UTC).isoformat()
 
 

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 import NativeLibsqlTraceManager
+
+
+async def list_experiments(db_url: str):
+    """List all experiments in the database."""
+    db = NativeLibsqlTraceManager(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 = NativeLibsqlTraceManager(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 = NativeLibsqlTraceManager(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())

synth_ai/tui/cli/query_experiments_v3.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 import NativeLibsqlTraceManager
+
+
+async def list_experiments(db_url: str):
+    """List all experiments in the database."""
+    db = NativeLibsqlTraceManager(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 = NativeLibsqlTraceManager(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 = NativeLibsqlTraceManager(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())