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

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
@@ -117,7 +117,7 @@ def _maybe_datetime(value: Any) -> Any:
 
 
 def _load_json(value: Any) -> Any:
-    if value is None or isinstance(value, (dict, list)):
+    if value is None or isinstance(value, dict | list):
         return value or {}
     if isinstance(value, str):
         try:
@@ -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
@@ -584,7 +607,7 @@ class NativeLibsqlTraceManager(TraceStorage):
                 raise ValueError("No named parameters found in query for provided mapping")
             values = tuple(params[key] for key in keys)
             return new_query, values
-        if isinstance(params, (list, tuple)):
+        if isinstance(params, list | tuple):
             return query, tuple(params)
         raise TypeError("Unsupported parameter type for query execution")
 
@@ -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 {})
 
@@ -881,7 +904,7 @@ class NativeLibsqlTraceManager(TraceStorage):
     ) -> int:
         await self.initialize()
 
-        if not isinstance(event, (EnvironmentEvent, LMCAISEvent, RuntimeEvent)):
+        if not isinstance(event, EnvironmentEvent | LMCAISEvent | RuntimeEvent):
             raise TypeError(f"Unsupported event type for native manager: {type(event)!r}")
 
         metadata_json = metadata_override or event.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())

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.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())