synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/task/tracing_utils.py

@@ -1,84 +0,0 @@
-"""Utilities for wiring tracing_v3 into task apps."""
-
-from __future__ import annotations
-
-import os
-from collections.abc import Callable
-from pathlib import Path
-from typing import Any
-
-
-def tracing_env_enabled(default: bool = False) -> bool:
-    """Return True when tracing is enabled for task apps via environment variable."""
-
-    raw = os.getenv("TASKAPP_TRACING_ENABLED")
-    if raw is None:
-        return default
-    raw = raw.strip().lower()
-    if raw in {"1", "true", "t", "yes", "y", "on"}:
-        return True
-    if raw in {"0", "false", "f", "no", "n", "off"}:
-        return False
-    return default
-
-
-def resolve_tracing_db_url() -> str | None:
-    """Resolve tracing database URL and prefer async drivers for SQLite."""
-
-    db_url = os.getenv("TURSO_LOCAL_DB_URL")
-    if db_url:
-        return db_url
-
-    sqld_path = os.getenv("SQLD_DB_PATH")
-    if sqld_path:
-        path = Path(sqld_path).expanduser()
-        if path.is_dir():
-            candidate = path / "dbs" / "default" / "data"
-            candidate.parent.mkdir(parents=True, exist_ok=True)
-            return f"sqlite+aiosqlite:///{candidate}"
-        else:
-            path.parent.mkdir(parents=True, exist_ok=True)
-            return f"sqlite+aiosqlite:///{path}"
-
-    fallback_path = Path("traces/v3/synth_ai.db").expanduser()
-    fallback_path.parent.mkdir(parents=True, exist_ok=True)
-    return f"sqlite+aiosqlite:///{fallback_path}"
-
-
-def build_tracer_factory(
-    make_tracer: Callable[..., Any], *, enabled: bool, db_url: str | None
-) -> Callable[[], Any] | None:
-    """Return a factory that instantiates a tracer when enabled, else None."""
-
-    if not enabled:
-        return None
-
-    def _factory() -> Any:
-        return make_tracer(db_url=db_url) if db_url else make_tracer()
-
-    return _factory
-
-
-def resolve_sft_output_dir() -> str | None:
-    """Resolve location for writing SFT records, creating directory if requested."""
-
-    raw = os.getenv("TASKAPP_SFT_OUTPUT_DIR") or os.getenv("SFT_OUTPUT_DIR")
-    if not raw:
-        return None
-    path = Path(raw).expanduser()
-    try:
-        path.mkdir(parents=True, exist_ok=True)
-    except Exception:
-        return None
-    return str(path)
-
-
-def unique_sft_path(base_dir: str, *, run_id: str) -> Path:
-    """Return a unique JSONL path for an SFT record batch."""
-
-    from datetime import datetime
-
-    now = datetime.now()
-    timestamp = now.strftime("%Y-%m-%d_%H-%M-%S")
-    name = f"{run_id}_{timestamp}.jsonl"
-    return Path(base_dir) / name

synth_ai/task/validators.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-from urllib.parse import urlparse
-
-
-def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
-    """Validate a Task App base URL (scheme + host present)."""
-
-    p = urlparse(url)
-    if p.scheme not in ("http", "https") or not p.netloc:
-        raise ValueError(f"Invalid {name}: malformed: {url}")

synth_ai/tracing_v3/__init__.py

@@ -1,97 +0,0 @@
-"""Tracing v3 - Turso/sqld based tracing implementation.
-
-This module provides a modern, async-first tracing system for capturing and storing
-detailed execution traces from AI systems. It's designed to handle high-throughput
-scenarios with proper async/await patterns throughout.
-
-Architecture Overview:
----------------------
-The v3 tracing system is built on several key components:
-
-1. **Data Abstractions** (`abstractions.py`):
-   - Dataclass-based models for traces, events, and messages
-   - Type-safe representations of session data
-   - Support for multiple event types (Runtime, Environment, LM/CAIS)
-
-2. **Session Tracer** (`session_tracer.py`):
-   - Main interface for creating and managing trace sessions
-   - Async context managers for session and timestep management
-   - Automatic event and message recording with proper ordering
-
-3. **Async Storage** (`turso/manager.py`):
-   - SQLAlchemy async engine with Turso/sqld backend
-   - Batch insert capabilities for high-throughput scenarios
-   - Analytics views for querying trace data
-
-4. **Decorators** (`decorators.py`):
-   - Context-aware decorators using asyncio's ContextVar
-   - Automatic LLM call tracing with token/cost tracking
-   - Session and turn number propagation across async boundaries
-
-5. **Hook System** (`hooks.py`):
-   - Extensible hook points throughout the tracing lifecycle
-   - Support for both sync and async hook callbacks
-   - Pre/post processing of events and messages
-
-6. **Replica Sync** (`replica_sync.py`):
-   - Optional background sync with remote Turso database
-   - Local embedded SQLite for low-latency writes
-   - Configurable sync intervals
-
-Key Features:
-------------
-- **Async-First**: All database operations are async, preventing blocking
-- **Context Propagation**: Session/turn info flows through async call chains
-- **Type Safety**: Full typing support with dataclasses and type hints
-- **Extensibility**: Hook system allows custom processing logic
-- **Performance**: Batch operations and connection pooling for efficiency
-
-Usage Example:
--------------
-    from synth_ai.tracing_v3 import SessionTracer
-
-    tracer = SessionTracer()
-    await tracer.initialize()
-
-    async with tracer.session() as session_id:
-        async with tracer.timestep("step1", turn_number=1):
-            # Record events during execution
-            await tracer.record_event(RuntimeEvent(...))
-            await tracer.record_message("User input", "user")
-
-Configuration:
--------------
-The system uses environment variables for configuration:
-- TURSO_LOCAL_DB_URL: Local SQLite database URL
-- TURSO_POOL_SIZE: Connection pool size (default: 8)
-- TURSO_ECHO_SQL: Enable SQL logging (default: false)
-- SQLD_DB_PATH: Path to SQLite database file
-
-See `config.py` for full configuration options.
-"""
-
-from .abstractions import (
-    BaseEvent,
-    EnvironmentEvent,
-    RuntimeEvent,
-    SessionEventMarkovBlanketMessage,
-    SessionMessageContent,
-    SessionTimeStep,
-    SessionTrace,
-    TimeRecord,
-)
-from .config import TursoConfig
-from .session_tracer import SessionTracer
-
-__all__ = [
-    "SessionTracer",
-    "SessionTrace",
-    "SessionTimeStep",
-    "BaseEvent",
-    "RuntimeEvent",
-    "EnvironmentEvent",
-    "SessionEventMarkovBlanketMessage",
-    "SessionMessageContent",
-    "TimeRecord",
-    "TursoConfig",
-]

synth_ai/tracing_v3/config.py

@@ -1,84 +0,0 @@
-"""Configuration for tracing v3 with Turso/sqld."""
-
-import os
-from dataclasses import dataclass
-
-
-@dataclass
-class TursoConfig:
-    """Configuration for Turso/sqld connection."""
-
-    # Default values matching serve.sh
-    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
-    DEFAULT_HTTP_PORT = 8080
-
-    # Local embedded database for async SQLAlchemy
-    # Resolve to the actual SQLite file used by sqld if the base path is a directory
-    def _resolve_sqlite_db_url() -> str:  # type: ignore[no-redef]
-        base_path = os.path.abspath(os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db"))
-        # If sqld is managing this DB, the real SQLite file lives under dbs/default/data
-        candidate = os.path.join(base_path, "dbs", "default", "data")
-        if os.path.isdir(base_path) and os.path.exists(candidate):
-            return f"sqlite+aiosqlite:///{candidate}"
-        return f"sqlite+aiosqlite:///{base_path}"
-
-    # Use env override if provided; otherwise resolve based on SQLD layout
-    db_url: str = os.getenv("TURSO_LOCAL_DB_URL", _resolve_sqlite_db_url())
-
-    # Remote database sync configuration
-    sync_url: str = os.getenv("TURSO_DATABASE_URL", "")
-    auth_token: str = os.getenv("TURSO_AUTH_TOKEN", "")
-    sync_interval: int = int(
-        os.getenv("TURSO_SYNC_SECONDS", "2")
-    )  # 2 seconds for responsive local development
-
-    # Connection pool settings
-    pool_size: int = int(os.getenv("TURSO_POOL_SIZE", "8"))
-    max_overflow: int = int(os.getenv("TURSO_MAX_OVERFLOW", "16"))
-    pool_timeout: float = float(os.getenv("TURSO_POOL_TIMEOUT", "30.0"))
-    pool_recycle: int = int(os.getenv("TURSO_POOL_RECYCLE", "3600"))
-
-    # SQLite settings
-    foreign_keys: bool = os.getenv("TURSO_FOREIGN_KEYS", "true").lower() == "true"
-    journal_mode: str = os.getenv("TURSO_JOURNAL_MODE", "WAL")
-
-    # Performance settings
-    echo_sql: bool = os.getenv("TURSO_ECHO_SQL", "false").lower() == "true"
-    batch_size: int = int(os.getenv("TURSO_BATCH_SIZE", "1000"))
-
-    # Daemon settings (for local sqld) - match serve.sh defaults
-    sqld_binary: str = os.getenv("SQLD_BINARY", "sqld")
-    sqld_db_path: str = os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db")
-    sqld_http_port: int = int(os.getenv("SQLD_HTTP_PORT", "8080"))
-    sqld_idle_shutdown: int = int(os.getenv("SQLD_IDLE_SHUTDOWN", "0"))  # 0 = no idle shutdown
-
-    def get_connect_args(self) -> dict:
-        """Get SQLAlchemy connection arguments."""
-        args = {}
-        if self.auth_token:
-            args["auth_token"] = self.auth_token
-        return args
-
-    def get_engine_kwargs(self) -> dict:
-        """Get SQLAlchemy engine creation kwargs."""
-        kwargs = {
-            "echo": self.echo_sql,
-            "future": True,
-        }
-
-        # Only add pool settings for non-SQLite URLs
-        if not (self.db_url.startswith("sqlite") or ":memory:" in self.db_url):
-            kwargs.update(
-                {
-                    "pool_size": self.pool_size,
-                    "max_overflow": self.max_overflow,
-                    "pool_timeout": self.pool_timeout,
-                    "pool_recycle": self.pool_recycle,
-                }
-            )
-
-        return kwargs
-
-
-# Global config instance
-CONFIG = TursoConfig()

synth_ai/tracing_v3/db_config.py

@@ -1,194 +0,0 @@
-"""
-Centralized database configuration for v3 tracing.
-"""
-
-import logging
-import os
-import shutil
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from .turso.daemon import SqldDaemon
-
-logger = logging.getLogger(__name__)
-
-
-class DatabaseConfig:
-    """Centralized database configuration management."""
-
-    # Default values from serve.sh
-    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
-    DEFAULT_HTTP_PORT = 8080
-
-    def __init__(
-        self, db_path: str | None = None, http_port: int | None = None, use_sqld: bool = True
-    ):
-        """
-        Initialize database configuration.
-
-        Args:
-            db_path: Path to database file. If None, uses DEFAULT_DB_FILE from serve.sh.
-            http_port: HTTP port for sqld daemon. If None, uses DEFAULT_HTTP_PORT from serve.sh.
-            use_sqld: Whether to use sqld daemon or direct SQLite.
-        """
-        self.use_sqld = use_sqld and self._sqld_binary_available()
-        self.http_port = http_port or int(os.getenv("SQLD_HTTP_PORT", self.DEFAULT_HTTP_PORT))
-        self._daemon: SqldDaemon | None = None
-
-        # Set up database path to match serve.sh configuration
-        if db_path is None:
-            # Use the same database file as serve.sh
-            self.db_file = os.getenv("SQLD_DB_PATH", self.DEFAULT_DB_FILE)
-            # For sqld, db_base_path is just the filename without directory
-            self.db_base_path = self.db_file
-        else:
-            self.db_file = db_path
-            self.db_base_path = db_path
-
-    @property
-    def database_url(self) -> str:
-        """Get the SQLAlchemy database URL."""
-        # Always use direct file access with aiosqlite
-        # (sqld HTTP interface is not compatible with SQLAlchemy)
-
-        # Check if sqld is running - it creates a directory structure
-        abs_path = os.path.abspath(self.db_file)
-        sqld_data_path = os.path.join(abs_path, "dbs", "default", "data")
-
-        if os.path.exists(sqld_data_path):
-            # sqld is managing the database
-            logger.debug(f"✅ Using sqld-managed database at: {sqld_data_path}")
-            actual_db_path = sqld_data_path
-        else:
-            # Direct SQLite file
-            if not os.path.exists(abs_path):
-                logger.debug(f"⚠️  Database file not found at: {abs_path}")
-                logger.debug("🔧 Make sure to run './serve.sh' to start the turso/sqld service")
-            else:
-                logger.debug(f"📁 Using direct SQLite file at: {abs_path}")
-            actual_db_path = abs_path
-
-        # SQLite URLs need 3 slashes for absolute paths
-        return f"sqlite+aiosqlite:///{actual_db_path}"
-
-    def _sqld_binary_available(self) -> bool:
-        """Check if the sqld (Turso) binary is available on PATH."""
-        # Respect explicit SQLD_BINARY override when present
-        binary_override = os.getenv("SQLD_BINARY")
-        candidates = [binary_override, "sqld", "libsql-server"]
-
-        for candidate in candidates:
-            if candidate and shutil.which(candidate):
-                return True
-
-        if binary_override:
-            logger.warning(
-                "Configured SQLD_BINARY='%s' but the executable was not found on PATH. "
-                "Falling back to direct SQLite.",
-                binary_override,
-            )
-        else:
-            logger.warning(
-                "sqld binary not detected; falling back to SQLite-only mode. "
-                "Install Turso's sqld or set SQLD_BINARY to enable the Turso daemon."
-            )
-
-        return False
-
-    def start_daemon(self, wait_time: float = 2.0):
-        """
-        Start the sqld daemon if configured.
-
-        Args:
-            wait_time: Time to wait for daemon startup.
-
-        Returns:
-            The daemon instance.
-        """
-        if not self.use_sqld:
-            raise RuntimeError("Database not configured to use sqld daemon")
-
-        if self._daemon is None:
-            # Import here to avoid circular dependency
-            from .turso.daemon import SqldDaemon
-
-            self._daemon = SqldDaemon(db_path=self.db_base_path, http_port=self.http_port)
-
-        self._daemon.start()
-
-        # Wait for daemon to be ready
-        import time
-
-        time.sleep(wait_time)
-
-        return self._daemon
-
-    def stop_daemon(self):
-        """Stop the sqld daemon if running."""
-        if self._daemon:
-            self._daemon.stop()
-            self._daemon = None
-
-    def get_daemon_and_url(self, wait_time: float = 2.0) -> tuple[Optional["SqldDaemon"], str]:
-        """
-        Get daemon (starting if needed) and database URL.
-
-        Returns:
-            Tuple of (daemon or None, database_url)
-        """
-        daemon = None
-        if self.use_sqld:
-            daemon = self.start_daemon(wait_time)
-
-        return daemon, self.database_url
-
-
-# Global default configuration
-_default_config: DatabaseConfig | None = None
-
-
-def get_default_db_config() -> DatabaseConfig:
-    """Get the default database configuration."""
-    global _default_config
-    if _default_config is None:
-        # Check environment variable for database path
-        db_path = os.environ.get("SYNTH_AI_V3_DB_PATH")
-        use_sqld = os.environ.get("SYNTH_AI_V3_USE_SQLD", "true").lower() == "true"
-
-        # Check if sqld is already running (started by serve.sh)
-        import subprocess
-
-        sqld_port = int(os.getenv("SQLD_HTTP_PORT", DatabaseConfig.DEFAULT_HTTP_PORT))
-        sqld_running = False
-        try:
-            result = subprocess.run(
-                ["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode == 0:
-                # sqld is already running, don't start a new one
-                sqld_running = True
-                use_sqld = False
-                logger.debug(f"✅ Detected sqld already running on port {sqld_port}")
-        except Exception as e:
-            logger.debug(f"Could not check for sqld process: {e}")
-
-        if not sqld_running and use_sqld:
-            logger.warning("⚠️  sqld service not detected!")
-            logger.warning("🔧 Please start the turso/sqld service by running:")
-            logger.warning("   ./serve.sh")
-            logger.warning("")
-            logger.warning("This will start:")
-            logger.warning("  - sqld daemon (SQLite server) on port 8080")
-            logger.warning("  - Environment service on port 8901")
-
-        _default_config = DatabaseConfig(db_path=db_path, use_sqld=use_sqld)
-
-    return _default_config
-
-
-def set_default_db_config(config: DatabaseConfig):
-    """Set the default database configuration."""
-    global _default_config
-    _default_config = config