synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/core/tracing_v3/utils.py

@@ -0,0 +1,108 @@
+"""Utility functions for tracing v3."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+
+def iso_now() -> str:
+    """Get current timezone.utc time as ISO format string."""
+    return datetime.now(UTC).isoformat()
+
+
+def json_dumps(obj: Any) -> str:
+    """JSON dump with consistent formatting and datetime handling."""
+    return json.dumps(obj, default=str, separators=(",", ":"))
+
+
+def json_loads(s: str) -> Any:
+    """Safe JSON load with error handling."""
+    try:
+        return json.loads(s)
+    except (json.JSONDecodeError, TypeError):
+        return {}
+
+
+def generate_session_id(prefix: str = "session") -> str:
+    """Generate a unique session ID."""
+    return f"{prefix}_{uuid.uuid4().hex[:12]}"
+
+
+def generate_experiment_id(name: str) -> str:
+    """Generate experiment ID from name."""
+    hash_obj = hashlib.sha256(name.encode())
+    return f"exp_{hash_obj.hexdigest()[:12]}"
+
+
+def detect_provider(model_name: str | None) -> str:
+    """Detect LLM provider from model name."""
+    if not model_name:
+        return "unknown"
+
+    model_lower = model_name.lower()
+
+    if any(
+        x in model_lower for x in ["gpt-", "text-davinci", "text-curie", "text-babbage", "text-ada"]
+    ):
+        return "openai"
+    elif any(x in model_lower for x in ["claude", "anthropic"]):
+        return "anthropic"
+    elif any(x in model_lower for x in ["palm", "gemini", "bard"]):
+        return "google"
+    elif "azure" in model_lower:
+        return "azure"
+    elif any(x in model_lower for x in ["llama", "mistral", "mixtral", "local"]):
+        return "local"
+    else:
+        return "unknown"
+
+
+def calculate_cost(model_name: str, input_tokens: int, output_tokens: int) -> float | None:
+    """Calculate cost in USD based on model and token counts."""
+    # This is a simplified version - in production you'd want a proper pricing table
+    pricing = {
+        "gpt-4": {"input": 0.03, "output": 0.06},  # per 1K tokens
+        "gpt-4-turbo": {"input": 0.01, "output": 0.03},
+        "gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015},
+        "claude-3-opus": {"input": 0.015, "output": 0.075},
+        "claude-3-sonnet": {"input": 0.003, "output": 0.015},
+        "claude-3-haiku": {"input": 0.00025, "output": 0.00125},
+    }
+
+    for model_prefix, prices in pricing.items():
+        if model_prefix in model_name.lower():
+            input_cost = (input_tokens / 1000) * prices["input"]
+            output_cost = (output_tokens / 1000) * prices["output"]
+            return input_cost + output_cost
+
+    return None
+
+
+def truncate_content(content: str, max_length: int = 10000) -> str:
+    """Truncate content to maximum length."""
+    if len(content) <= max_length:
+        return content
+    return content[: max_length - 3] + "..."
+
+
+def format_duration(start: datetime, end: datetime) -> str:
+    """Format duration between two timestamps."""
+    delta = end - start
+    total_seconds = delta.total_seconds()
+
+    if total_seconds < 1:
+        return f"{int(total_seconds * 1000)}ms"
+    elif total_seconds < 60:
+        return f"{total_seconds:.1f}s"
+    elif total_seconds < 3600:
+        minutes = int(total_seconds // 60)
+        seconds = int(total_seconds % 60)
+        return f"{minutes}m {seconds}s"
+    else:
+        hours = int(total_seconds // 3600)
+        minutes = int((total_seconds % 3600) // 60)
+        return f"{hours}h {minutes}m"

synth_ai/core/urls.py

@@ -0,0 +1,18 @@
+import os
+
+# Base URL for all backends
+BACKEND_URL_BASE = os.getenv("SYNTH_BACKEND_OVERRIDE") or "https://www.api.usesynth.ai"
+
+# Synth Research API base (supports OpenAI, Anthropic, and custom formats)
+# Real routes: /api/synth-research/chat/completions, /api/synth-research/messages
+# V1 routes: /api/synth-research/v1/chat/completions, /api/synth-research/v1/messages
+BACKEND_URL_SYNTH_RESEARCH_BASE = BACKEND_URL_BASE + "/api/synth-research"
+
+# Provider-specific URLs (for SDKs that expect standard paths)
+BACKEND_URL_SYNTH_RESEARCH_OPENAI = BACKEND_URL_SYNTH_RESEARCH_BASE + "/v1"  # For OpenAI SDKs (appends /chat/completions)
+BACKEND_URL_SYNTH_RESEARCH_ANTHROPIC = BACKEND_URL_SYNTH_RESEARCH_BASE  # For Anthropic SDKs (appends /v1/messages)
+
+
+
+
+FRONTEND_URL_BASE = os.getenv("SYNTH_FRONTEND_OVERRIDE") or "https://www.usesynth.ai"

synth_ai/core/user_config.py

@@ -0,0 +1,137 @@
+import contextlib
+import json
+import os
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path(os.path.expanduser("~/.synth-ai"))
+USER_CONFIG_PATH = CONFIG_DIR / "user_config.json"
+
+
+def _ensure_config_dir() -> None:
+    with contextlib.suppress(Exception):
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_user_config() -> dict[str, Any]:
+    """Return the persisted user config as a dict (empty if missing or invalid)."""
+
+    try:
+        if USER_CONFIG_PATH.is_file():
+            with USER_CONFIG_PATH.open("r", encoding="utf-8") as fh:
+                data = json.load(fh)
+                return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+    return {}
+
+
+def save_user_config(config: Mapping[str, Any]) -> None:
+    """Persist a new user config dictionary (overwrites previous contents)."""
+
+    _ensure_config_dir()
+    try:
+        with USER_CONFIG_PATH.open("w", encoding="utf-8") as fh:
+            json.dump(dict(config), fh, indent=2, sort_keys=True)
+    except Exception:
+        pass
+
+
+def update_user_config(updates: Mapping[str, Any]) -> dict[str, Any]:
+    """Merge `updates` into the existing user config and persist the result."""
+
+    current = load_user_config()
+    current.update(updates)
+    save_user_config(current)
+    return current
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    try:
+        if path.is_file():
+            with path.open("r", encoding="utf-8") as handle:
+                data = json.load(handle)
+                return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+    return {}
+
+
+def _load_task_app_entries() -> dict[str, Any]:
+    data = _load_json(Path(os.path.expanduser("~/.synth-ai/task_app_config.json")))
+    if "apps" in data and isinstance(data["apps"], dict):
+        return data["apps"]
+    return {}
+
+
+def _select_task_app_entry(entries: dict[str, Any]) -> tuple[str | None, dict[str, Any]]:
+    if not entries:
+        return None, {}
+
+    demo_dir = os.environ.get("SYNTH_DEMO_DIR")
+    if demo_dir and demo_dir in entries:
+        return demo_dir, entries[demo_dir]
+
+    try:
+        cwd = str(Path.cwd().resolve())
+        if cwd in entries:
+            return cwd, entries[cwd]
+    except Exception:
+        pass
+
+    best_key = None
+    best_entry: dict[str, Any] = {}
+    best_ts = ""
+    for key, entry in entries.items():
+        if not isinstance(entry, dict):
+            continue
+        ts = str(entry.get("last_used") or "")
+        if ts > best_ts:
+            best_key = key
+            best_entry = entry
+            best_ts = ts
+    return best_key, best_entry
+
+
+def load_user_env(*, override: bool = True) -> dict[str, str]:
+    """Hydrate ``os.environ`` from persisted Synth SDK state."""
+
+    applied: dict[str, str] = {}
+
+    def _apply(mapping: Mapping[str, Any]) -> None:
+        for key, value in mapping.items():
+            if value is None:
+                continue
+            str_value = value if isinstance(value, str) else str(value)
+            if override or key not in os.environ:
+                os.environ[key] = str_value
+            applied[key] = str_value
+
+    config = load_user_config()
+    _apply(config)
+
+    entry_key, entry = _select_task_app_entry(_load_task_app_entries())
+    if entry:
+        modal_block = entry.get("modal") if isinstance(entry.get("modal"), dict) else {}
+        if modal_block:
+            _apply(
+                {
+                    "TASK_APP_BASE_URL": modal_block.get("base_url"),
+                    "TASK_APP_NAME": modal_block.get("app_name"),
+                    "TASK_APP_SECRET_NAME": modal_block.get("secret_name"),
+                }
+            )
+        if entry_key:
+            _apply({"SYNTH_DEMO_DIR": entry_key})
+
+    return applied
+
+
+__all__ = [
+    "USER_CONFIG_PATH",
+    "load_user_config",
+    "save_user_config",
+    "update_user_config",
+    "load_user_env",
+]

synth_ai/core/uvicorn.py

@@ -0,0 +1,222 @@
+import os
+import subprocess
+import sys
+import threading
+from pathlib import Path
+from typing import Any
+
+import uvicorn
+from starlette.types import ASGIApp
+
+from synth_ai.core.apps.common import get_asgi_app, load_module
+from synth_ai.core.cfgs import LocalDeployCfg
+from synth_ai.core.paths import REPO_ROOT, configure_import_paths
+from synth_ai.core.telemetry import log_error, log_info
+
+_THREADS: dict[int, threading.Thread] = {}
+_PROCESSES: dict[int, subprocess.Popen[str]] = {}
+
+
+def serve_app_uvicorn(
+    app: ASGIApp,
+    host: str,
+    port: int,
+) -> None:
+    ctx: dict[str, Any] = {"host": host, "port": port}
+    log_info("starting uvicorn server", ctx=ctx)
+    try:
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            reload=False,
+            log_level="info"
+        )
+        log_info("uvicorn server exited cleanly", ctx=ctx)
+    except Exception as exc:
+        ctx["error"] = type(exc).__name__
+        log_error("uvicorn server failed", ctx=ctx)
+        raise RuntimeError(f"Failed to serve app with Uvicorn: {exc}") from exc
+    
+
+def serve_app_uvicorn_background(
+    app: ASGIApp,
+    host: str,
+    port: int,
+    daemon: bool = True
+) -> None:
+    thread = threading.Thread(
+        target=serve_app_uvicorn,
+        args={app, host, port},
+        name=f"synth-uvicorn-{port}",
+        daemon=daemon
+    )
+    thread.start()
+
+
+def deploy_app_uvicorn(cfg: LocalDeployCfg) -> str | None:
+    ctx: dict[str, Any] = {
+        "task_app_path": str(cfg.task_app_path),
+        "host": cfg.host,
+        "port": cfg.port,
+        "trace": cfg.trace,
+    }
+    log_info("deploy_app_uvicorn invoked", ctx=ctx)
+    try:
+        os.environ["ENVIRONMENT_API_KEY"] = cfg.env_api_key
+        if cfg.trace:
+            os.environ["TASKAPP_TRACING_ENABLED"] = "1"
+        else:
+            os.environ.pop("TASKAPP_TRACING_ENABLED", None)
+
+        configure_import_paths(cfg.task_app_path, REPO_ROOT)
+        module = load_module(
+            cfg.task_app_path,
+            f"_synth_local_task_app_{cfg.task_app_path.stem}"
+        )
+        log_info("task app module loaded", ctx=ctx)
+        app = get_asgi_app(module)
+
+        msg = f"Serving task app at http://{'127.0.0.1' if cfg.host in {'0.0.0.0', '::'} else cfg.host}:{cfg.port}"
+
+        # Try to extract app_id from module or app
+        app_id: str | None = None
+        try:
+            # Try to get app_id from module's config factory or app state
+            if hasattr(module, "build_config"):
+                config = module.build_config()  # type: ignore[call-arg]
+                if hasattr(config, "app_id"):
+                    app_id = config.app_id
+            elif hasattr(app, "state") and hasattr(app.state, "task_app_config"):
+                config = app.state.task_app_config
+                if hasattr(config, "app_id"):
+                    app_id = str(config.app_id) if config.app_id is not None else None  # type: ignore[assignment]
+        except Exception:
+            pass
+
+        # Record local service will happen after process starts (to get correct PID)
+
+        if os.environ.get("CTX") == "mcp":
+            thread = threading.Thread(
+                target=serve_app_uvicorn,
+                args=(app, cfg.host, cfg.port),
+                name=f"synth-uvicorn-{cfg.port}",
+                daemon=True
+            )
+            thread.start()
+            _THREADS[cfg.port] = thread
+            ctx["mode"] = "mcp"
+            log_info("uvicorn server running in background thread", ctx=ctx)
+            return f"[deploy_local] {msg}"
+
+        # Use nohup to run in background
+        print(msg)
+        print("[deploy_local] Starting server in background with nohup...")
+
+        # Create a wrapper script to run uvicorn
+        import tempfile
+        task_app_path_str = str(cfg.task_app_path)
+        repo_root_str = str(REPO_ROOT)
+        task_app_parent_str = str(cfg.task_app_path.parent)
+        module_name = f"_synth_local_task_app_{cfg.task_app_path.stem}"
+
+        wrapper_content = f'''#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+# Add paths for imports
+sys.path.insert(0, {repr(repo_root_str)})
+sys.path.insert(0, {repr(task_app_parent_str)})
+
+# Configure import paths
+from synth_ai.core.paths import configure_import_paths
+configure_import_paths(Path({repr(task_app_path_str)}), Path({repr(repo_root_str)}))
+
+# Load module and app
+from synth_ai.core.apps.common import get_asgi_app, load_module
+
+module = load_module(
+    Path({repr(task_app_path_str)}),
+    {repr(module_name)}
+)
+app = get_asgi_app(module)
+
+# Set environment
+import os
+os.environ["ENVIRONMENT_API_KEY"] = {repr(cfg.env_api_key)}
+'''
+        if cfg.trace:
+            wrapper_content += 'os.environ["TASKAPP_TRACING_ENABLED"] = "1"\n'
+        else:
+            wrapper_content += 'os.environ.pop("TASKAPP_TRACING_ENABLED", None)\n'
+
+        wrapper_content += f'''
+# Run uvicorn
+import uvicorn
+uvicorn.run(app, host={repr(cfg.host)}, port={cfg.port}, reload=False, log_level="info")
+'''
+
+        # Write wrapper script
+        wrapper_file = Path(tempfile.gettempdir()) / f"synth_uvicorn_{cfg.port}.py"
+        wrapper_file.write_text(wrapper_content)
+        wrapper_file.chmod(0o755)
+
+        # Create log file
+        log_file = Path(tempfile.gettempdir()) / f"synth_uvicorn_{cfg.port}.log"
+
+        # Build command with nohup
+        cmd = [
+            "nohup",
+            sys.executable,
+            str(wrapper_file),
+        ]
+
+        # Start process with nohup
+        try:
+            with log_file.open("w") as log_f:
+                proc = subprocess.Popen(
+                    cmd,
+                    stdout=log_f,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    cwd=str(REPO_ROOT),
+                    env=os.environ.copy(),
+                )
+            _PROCESSES[cfg.port] = proc
+
+            # Record local service with correct PID
+            try:
+                from synth_ai.cli.lib.tunnel_records import record_service
+                local_url = f"http://{'127.0.0.1' if cfg.host in {'0.0.0.0', '::'} else cfg.host}:{cfg.port}"
+                record_service(
+                    url=local_url,
+                    port=cfg.port,
+                    service_type="local",
+                    local_host=cfg.host if cfg.host not in ('0.0.0.0', '::') else '127.0.0.1',
+                    task_app_path=str(cfg.task_app_path) if cfg.task_app_path else None,
+                    app_id=app_id,
+                    pid=proc.pid,
+                )
+            except Exception:
+                pass  # Fail silently - records are optional
+
+            print(f"[deploy_local] Server started (PID: {proc.pid})")
+            print(f"[deploy_local] Logs: {log_file}")
+            print(f"[deploy_local] URL: {msg}")
+            ctx["pid"] = proc.pid
+            ctx["log_file"] = str(log_file)
+            log_info("uvicorn server started with nohup", ctx=ctx)
+            return f"[deploy_local] {msg} (PID: {proc.pid}, logs: {log_file})"
+        except Exception as exc:
+            ctx["error"] = type(exc).__name__
+            log_error("failed to start server with nohup", ctx=ctx)
+            # Don't fallback to blocking mode - raise error instead to prevent indefinite stalls
+            raise RuntimeError(
+                f"Failed to start server in background: {exc}\n"
+                "The deploy command is designed to be non-blocking for AI agent use.\n"
+                "If you need blocking mode, use the task app's serve command directly."
+            ) from exc
+    except Exception as exc:
+        ctx["error"] = type(exc).__name__
+        log_error("deploy_app_uvicorn failed", ctx=ctx)
+        raise

synth_ai/data/__init__.py

@@ -0,0 +1,83 @@
+"""Synth AI Data Layer.
+
+This module provides pure data types with no IO dependencies.
+Contains actual data schemas for traces and rewards.
+
+Data vs SDK distinction:
+- data/: Pure data records (traces, rewards) - actual data
+- sdk/: API abstractions (jobs, training, graphs) - SDK interfaces
+
+Dependency rule: data/ imports nothing from synth_ai except typing helpers.
+"""
+
+from __future__ import annotations
+
+# Enums - pure types
+from synth_ai.data.enums import (
+    AdaptiveBatchLevel,
+    AdaptiveCurriculumLevel,
+    InferenceMode,
+    JobStatus,
+    JobType,
+    PromptLearningMethod,
+    ProviderName,
+    RewardSource,
+    RLMethod,
+    SFTMethod,
+)
+
+# Reward data types
+from synth_ai.data.rewards import (
+    CalibrationExample,
+    EventRewardRecord,
+    GoldExample,
+    OutcomeRewardRecord,
+    RewardAggregates,
+    RewardRecord,
+)
+
+# Trace data types (re-exports from tracing_v3)
+from synth_ai.data.traces import (
+    BaseEvent,
+    EnvironmentEvent,
+    LMCAISEvent,
+    RuntimeEvent,
+    SessionEventMarkovBlanketMessage,
+    SessionMessageContent,
+    SessionTimeStep,
+    SessionTrace,
+    TimeRecord,
+)
+
+__all__ = [
+    # Enums
+    "JobType",
+    "JobStatus",
+    "PromptLearningMethod",
+    "RLMethod",
+    "SFTMethod",
+    "InferenceMode",
+    "ProviderName",
+    "RewardSource",
+    "AdaptiveCurriculumLevel",
+    "AdaptiveBatchLevel",
+    # Reward data
+    "RewardRecord",
+    "OutcomeRewardRecord",
+    "EventRewardRecord",
+    "RewardAggregates",
+    "CalibrationExample",
+    "GoldExample",
+    # Trace data
+    "SessionTrace",
+    "SessionTimeStep",
+    "BaseEvent",
+    "RuntimeEvent",
+    "EnvironmentEvent",
+    "LMCAISEvent",
+    "SessionEventMarkovBlanketMessage",
+    "SessionMessageContent",
+    "TimeRecord",
+]
+
+

synth_ai/data/enums.py

@@ -0,0 +1,122 @@
+"""Centralized enums for Synth AI SDK.
+
+This module defines all enum types used across the SDK. Enums are pure data
+with no dependencies on other modules.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class JobType(str, Enum):
+    """Types of training/optimization jobs."""
+
+    PROMPT_LEARNING = "prompt_learning"
+    SFT = "sft"
+    RL = "rl"
+    GSPO = "gspo"
+    EVAL = "eval"
+    RESEARCH_AGENT = "research_agent"
+
+
+class JobStatus(str, Enum):
+    """Status of a job."""
+
+    PENDING = "pending"
+    QUEUED = "queued"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class PromptLearningMethod(str, Enum):
+    """Prompt optimization algorithms."""
+
+    GEPA = "gepa"
+    MIPRO = "mipro"
+
+
+class RLMethod(str, Enum):
+    """Reinforcement learning training algorithms."""
+
+    PPO = "ppo"
+    GRPO = "grpo"
+    REINFORCE = "reinforce"
+
+
+class SFTMethod(str, Enum):
+    """Supervised fine-tuning approaches."""
+
+    FULL = "full"
+    LORA = "lora"
+    QLORA = "qlora"
+
+
+class InferenceMode(str, Enum):
+    """Inference modes for policy evaluation."""
+
+    SYNTH_HOSTED = "synth_hosted"
+
+
+class ProviderName(str, Enum):
+    """LLM provider names."""
+
+    OPENAI = "openai"
+    GROQ = "groq"
+    GOOGLE = "google"
+    ANTHROPIC = "anthropic"
+
+
+class RewardSource(str, Enum):
+    """Source of reward signal for training."""
+
+    TASK_APP = "task_app"
+    VERIFIER = "verifier"
+    FUSED = "fused"
+
+
+class AdaptiveCurriculumLevel(str, Enum):
+    """Preset levels for adaptive pooling curriculum."""
+
+    NONE = "NONE"
+    LOW = "LOW"
+    MODERATE = "MODERATE"
+    HIGH = "HIGH"
+
+
+class AdaptiveBatchLevel(str, Enum):
+    """Preset levels for adaptive batch curriculum (GEPA only)."""
+
+    NONE = "NONE"
+    LOW = "LOW"
+    MODERATE = "MODERATE"
+    HIGH = "HIGH"
+
+
+class SynthModelName(str, Enum):
+    """Synth-hosted model names for routing through Synth backend."""
+
+    SYNTH_SMALL = "synth-small"
+    SYNTH_MEDIUM = "synth-medium"
+
+
+# Legacy: list of model names for CLI validation
+SYNTH_MODEL_NAMES: list[str] = [m.value for m in SynthModelName]
+
+
+__all__ = [
+    "JobType",
+    "JobStatus",
+    "PromptLearningMethod",
+    "RLMethod",
+    "SFTMethod",
+    "InferenceMode",
+    "ProviderName",
+    "RewardSource",
+    "AdaptiveCurriculumLevel",
+    "AdaptiveBatchLevel",
+    "SynthModelName",
+    "SYNTH_MODEL_NAMES",
+]