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

synth_ai/core/ssl.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+class SSLConfig:
+    """Centralize SSL verification logic for all HTTP clients."""
+
+    @staticmethod
+    def get_verify_setting() -> bool | str:
+        """Return the correct verify setting for requests/httpx clients."""
+        skip_flag = os.getenv("SYNTH_SKIP_TASK_APP_HEALTH_CHECK", "").strip().lower()
+        if skip_flag in {"1", "true", "yes"}:
+            return False
+
+        ca_bundle = os.getenv("REQUESTS_CA_BUNDLE") or os.getenv("SSL_CERT_FILE")
+        if ca_bundle and Path(ca_bundle).expanduser().is_file():
+            return str(Path(ca_bundle).expanduser())
+
+        mitm_ca = Path.home() / ".mitmproxy" / "mitmproxy-ca-cert.pem"
+        if mitm_ca.is_file() and os.getenv("HTTPS_PROXY"):
+            return str(mitm_ca)
+
+        return True

synth_ai/core/storage/__init__.py

@@ -0,0 +1,71 @@
+"""Storage interfaces for Synth AI SDK.
+
+This module provides abstract interfaces for storage backends,
+allowing different storage implementations (SQLite, Postgres, etc.)
+to be used interchangeably.
+
+Note: The actual storage implementations remain in tracing_v3/storage/
+to avoid breaking changes. This module provides type hints and interfaces.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from synth_ai.data.traces import SessionTrace
+
+
+class StorageBackend(ABC):
+    """Abstract base class for storage backends."""
+
+    @abstractmethod
+    async def store_trace(self, trace: SessionTrace) -> str:
+        """Store a session trace.
+
+        Args:
+            trace: The session trace to store
+
+        Returns:
+            The session ID of the stored trace
+        """
+        pass
+
+    @abstractmethod
+    async def get_trace(self, session_id: str) -> SessionTrace | None:
+        """Retrieve a session trace by ID.
+
+        Args:
+            session_id: The session ID to look up
+
+        Returns:
+            The session trace, or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def list_sessions(
+        self,
+        experiment_id: str | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """List session summaries.
+
+        Args:
+            experiment_id: Optional filter by experiment
+            limit: Maximum number of results
+            offset: Offset for pagination
+
+        Returns:
+            List of session summary dicts
+        """
+        pass
+
+
+__all__ = [
+    "StorageBackend",
+]
+
+

synth_ai/core/task_app_state.py

@@ -0,0 +1,318 @@
+import json
+import os
+from collections.abc import Callable
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+DEFAULT_TASK_APP_SECRET_NAME = "synth-demo-task-app-secret"
+
+__all__ = [
+    "DEFAULT_TASK_APP_SECRET_NAME",
+    "current_task_app_id",
+    "load_demo_dir",
+    "load_template_id",
+    "now_iso",
+    "persist_api_key",
+    "persist_demo_dir",
+    "persist_env_api_key",
+    "persist_task_url",
+    "persist_template_id",
+    "read_task_app_config",
+    "record_task_app",
+    "resolve_task_app_entry",
+    "task_app_config_path",
+    "task_app_id_from_path",
+    "update_task_app_entry",
+    "write_task_app_config",
+]
+
+
+def task_app_config_path() -> str:
+    return os.path.expanduser("~/.synth-ai/task_app_config.json")
+
+
+def read_task_app_config() -> dict[str, Any]:
+    path = task_app_config_path()
+    try:
+        if os.path.isfile(path):
+            with open(path, encoding="utf-8") as handle:
+                loaded = json.load(handle) or {}
+                if isinstance(loaded, dict):
+                    apps = loaded.get("apps")
+                    if isinstance(apps, dict):
+                        return apps
+    except Exception:
+        pass
+    return {}
+
+
+def write_task_app_config(apps: dict[str, Any]) -> None:
+    payload = {"apps": apps}
+    try:
+        path = task_app_config_path()
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, indent=2, sort_keys=True)
+    except Exception:
+        pass
+
+
+def now_iso() -> str:
+    return (
+        datetime.now(UTC)
+        .replace(microsecond=0)
+        .isoformat()
+        .replace("+00:00", "Z")
+    )
+
+
+def task_app_id_from_path(path: str | Path | None) -> str | None:
+    if not path:
+        return None
+    try:
+        return str(Path(path).expanduser().resolve())
+    except Exception:
+        return None
+
+
+def current_task_app_id() -> str | None:
+    try:
+        return str(Path.cwd().resolve())
+    except Exception:
+        return None
+
+
+def update_task_app_entry(
+    path: str | Path | None,
+    *,
+    template_id: str | None = None,
+    mutate: Callable[[dict[str, Any]], None] | None = None,
+) -> dict[str, Any]:
+    task_id = task_app_id_from_path(path)
+    if task_id is None:
+        task_id = current_task_app_id()
+    if task_id is None:
+        return {}
+
+    apps = read_task_app_config()
+    now = now_iso()
+    entry = apps.get(task_id)
+    if entry is None:
+        entry = {
+            "task_app_path": task_id,
+            "template_id": template_id,
+            "created_at": now,
+            "last_used": now,
+            "modal": {
+                "app_name": None,
+                "base_url": None,
+                "secret_name": DEFAULT_TASK_APP_SECRET_NAME,
+                "created_at": None,
+                "last_used": None,
+            },
+        }
+        apps[task_id] = entry
+    else:
+        entry.setdefault(
+            "modal",
+            {
+                "app_name": None,
+                "base_url": None,
+                "secret_name": DEFAULT_TASK_APP_SECRET_NAME,
+                "created_at": None,
+                "last_used": None,
+            },
+        )
+        if template_id is not None:
+            entry["template_id"] = template_id
+
+    if mutate is not None:
+        mutate(entry)
+
+    entry["last_used"] = now
+    write_task_app_config(apps)
+    return entry
+
+
+def record_task_app(
+    path: str,
+    *,
+    template_id: str | None = None,
+    secret_name: str | None = None,
+) -> None:
+
+    def _mutate(entry: dict[str, Any]) -> None:
+        if secret_name:
+            modal_block = entry.setdefault(
+                "modal",
+                {
+                    "app_name": None,
+                    "base_url": None,
+                    "secret_name": DEFAULT_TASK_APP_SECRET_NAME,
+                    "created_at": None,
+                    "last_used": None,
+                },
+            )
+            modal_block["secret_name"] = secret_name
+
+    update_task_app_entry(path, template_id=template_id, mutate=_mutate if secret_name else None)
+
+
+def _select_entry(
+    *,
+    preferred_path: str | None = None,
+    predicate: Callable[[dict[str, Any]], bool] | None = None,
+) -> tuple[str | None, dict[str, Any]]:
+    entries = read_task_app_config()
+    if not entries:
+        return None, {}
+
+    def _matches(entry: dict[str, Any]) -> bool:
+        return predicate(entry) if predicate is not None else True
+
+    if preferred_path:
+        entry = entries.get(preferred_path)
+        if isinstance(entry, dict) and _matches(entry):
+            return preferred_path, entry
+
+    try:
+        cwd = str(Path.cwd().resolve())
+        entry = entries.get(cwd)
+        if isinstance(entry, dict) and _matches(entry):
+            return cwd, entry
+    except Exception:
+        pass
+
+    best_path: str | None = None
+    best_entry: dict[str, Any] = {}
+    best_ts = ""
+    for path, entry in entries.items():
+        if not isinstance(entry, dict) or not _matches(entry):
+            continue
+        ts = str(entry.get("last_used") or "")
+        if ts > best_ts:
+            best_ts = ts
+            best_path = path
+            best_entry = entry
+    return best_path, best_entry
+
+
+def resolve_task_app_entry(
+    preferred_path: str | None = None,
+    *,
+    predicate: Callable[[dict[str, Any]], bool] | None = None,
+) -> tuple[str | None, dict[str, Any]]:
+    path, entry = _select_entry(preferred_path=preferred_path, predicate=predicate)
+    return path, entry if isinstance(entry, dict) else {}
+
+
+def persist_demo_dir(demo_dir: str) -> None:
+    def _mutate(entry: dict[str, Any]) -> None:
+        entry["is_demo"] = True
+
+    update_task_app_entry(demo_dir, mutate=_mutate)
+
+
+def load_demo_dir() -> str | None:
+    path, _ = _select_entry(predicate=lambda entry: entry.get("is_demo") or entry.get("template_id"))
+    return path
+
+
+def persist_template_id(template_id: str | None) -> None:
+    demo_dir = load_demo_dir() or current_task_app_id()
+    if demo_dir is None:
+        return
+    update_task_app_entry(demo_dir, template_id=template_id)
+
+
+def load_template_id() -> str | None:
+    _, entry = _select_entry(predicate=lambda item: item.get("template_id"))
+    value = entry.get("template_id") if isinstance(entry, dict) else None
+    return str(value) if isinstance(value, str) else None
+
+
+def persist_api_key(key: str) -> None:
+    target = load_demo_dir() or current_task_app_id()
+
+    def _mutate(entry: dict[str, Any]) -> None:
+        secrets = entry.setdefault("secrets", {})
+        secrets["synth_api_key"] = key
+
+    update_task_app_entry(target, mutate=_mutate)
+
+
+def persist_env_api_key(key: str, path: str | Path | None = None) -> None:
+    target = path or load_demo_dir()
+
+    def _mutate(entry: dict[str, Any]) -> None:
+        secrets = entry.setdefault("secrets", {})
+        secrets["environment_api_key"] = key
+
+    update_task_app_entry(target, mutate=_mutate)
+
+
+def _derive_modal_app_name(url: str | None) -> str | None:
+    if not url:
+        return None
+    try:
+        from urllib.parse import urlparse
+
+        host = urlparse(url).hostname or ""
+        if "--" not in host:
+            return None
+        suffix = host.split("--", 1)[1]
+        core = suffix.split(".modal", 1)[0]
+        if core.endswith("-fastapi-app"):
+            core = core[: -len("-fastapi-app")]
+        return core.strip() or None
+    except Exception:
+        return None
+
+
+def persist_task_url(url: str, *, name: str | None = None, path: str | None = None) -> None:
+    normalized_url = (url or "").rstrip("/")
+    task_id = task_app_id_from_path(path) or current_task_app_id()
+    if task_id is None:
+        return
+
+    existing = read_task_app_config().get(task_id, {})
+    previous_modal = dict(existing.get("modal", {})) if isinstance(existing, dict) else {}
+
+    derived_name = name or _derive_modal_app_name(normalized_url)
+
+    def _mutate(entry: dict[str, Any]) -> None:
+        modal_block = entry.setdefault(
+            "modal",
+            {
+                "app_name": None,
+                "base_url": None,
+                "secret_name": DEFAULT_TASK_APP_SECRET_NAME,
+                "created_at": None,
+                "last_used": None,
+            },
+        )
+        now = now_iso()
+        if modal_block.get("created_at") is None:
+            modal_block["created_at"] = now
+        modal_block["last_used"] = now
+        modal_block["base_url"] = normalized_url
+        if derived_name:
+            modal_block["app_name"] = derived_name
+        modal_block["secret_name"] = DEFAULT_TASK_APP_SECRET_NAME
+
+    entry = update_task_app_entry(path or task_id, mutate=_mutate)
+
+    modal_after = entry.get("modal", {}) if isinstance(entry, dict) else {}
+    changed: list[str] = []
+    if previous_modal.get("base_url") != modal_after.get("base_url"):
+        changed.append("TASK_APP_BASE_URL")
+    if derived_name and previous_modal.get("app_name") != modal_after.get("app_name"):
+        changed.append("TASK_APP_NAME")
+    if previous_modal.get("secret_name") != modal_after.get("secret_name"):
+        changed.append("TASK_APP_SECRET_NAME")
+
+    if changed:
+        print(f"Saved {', '.join(changed)} to {task_app_config_path()}")
+        if "TASK_APP_SECRET_NAME" in changed:
+            print(f"TASK_APP_SECRET_NAME={DEFAULT_TASK_APP_SECRET_NAME}")

synth_ai/core/telemetry.py

@@ -0,0 +1,282 @@
+import contextlib
+import os
+import queue
+import threading
+import time
+import uuid
+from datetime import UTC, datetime
+from typing import Any, Mapping, Sequence
+
+from synth_ai.core.env import get_backend_from_env
+from synth_ai.core.http import http_request
+
+
+def _get_sdk_version() -> str:
+    """Lazy import of SDK version to avoid circular imports."""
+    try:
+        from synth_ai import __version__
+
+        return __version__
+    except ImportError:
+        return "0.0.0"
+
+
+_ENDPOINT_SUFFIX = "/api/v1/sdk-logs"
+_MAX_MESSAGE_LENGTH = 4_096
+_ALLOWED_LEVELS = {"debug", "info", "warning", "error", "critical"}
+
+# Queue and batching configuration
+_QUEUE_SIZE = 1000
+_BATCH_SIZE = 50
+_FLUSH_INTERVAL = 5.0
+_MAX_RETRIES = 3
+_BACKOFF_BASE = 1.0
+
+# Global state
+_LOG_QUEUE: queue.Queue[dict[str, Any]] = queue.Queue(maxsize=_QUEUE_SIZE)
+_worker_thread: threading.Thread | None = None
+_worker_lock = threading.Lock()
+_shutdown_event = threading.Event()
+
+DISABLE_LOGGING = os.getenv("SYNTH_ENABLE_SDK_LOGGING", None) is None  # Disabled by default
+
+
+def _start_worker() -> None:
+    """Lazy-start the background worker thread on first log."""
+    global _worker_thread
+    with _worker_lock:
+        if _worker_thread is not None and _worker_thread.is_alive():
+            return
+        _shutdown_event.clear()
+        _worker_thread = threading.Thread(
+            target=_worker_loop,
+            daemon=True,
+            name="sdk-logger",
+        )
+        _worker_thread.start()
+
+
+def _enqueue(entry: dict[str, Any]) -> None:
+    """Add entry to queue, dropping oldest if full."""
+    _start_worker()
+    try:
+        _LOG_QUEUE.put_nowait(entry)
+    except queue.Full:
+        # Drop oldest entry and try again
+        with contextlib.suppress(queue.Empty):
+            _LOG_QUEUE.get_nowait()
+        with contextlib.suppress(queue.Full):
+            _LOG_QUEUE.put_nowait(entry)
+            # Still full (race condition), just drop this entry
+
+
+def _worker_loop() -> None:
+    """Main worker loop: collect batch, post with retry."""
+    pending_batch: list[dict[str, Any]] = []
+    last_flush = time.time()
+
+    while not _shutdown_event.is_set():
+        try:
+            # Calculate timeout for next flush
+            elapsed = time.time() - last_flush
+            timeout = max(0.1, _FLUSH_INTERVAL - elapsed)
+
+            try:
+                entry = _LOG_QUEUE.get(timeout=timeout)
+                pending_batch.append(entry)
+                # Limit pending batch size to prevent memory issues
+                while len(pending_batch) > _QUEUE_SIZE:
+                    pending_batch.pop(0)
+            except queue.Empty:
+                pass
+
+            # Check if we should try to flush
+            now = time.time()
+            should_flush = len(pending_batch) >= _BATCH_SIZE or (
+                pending_batch and now - last_flush >= _FLUSH_INTERVAL
+            )
+
+            if should_flush and pending_batch:
+                success = _post_with_retry(pending_batch)
+                if success:
+                    pending_batch = []
+                # If not success (no API key), keep pending_batch for next cycle
+                last_flush = now
+
+        except Exception:
+            # Worker must never crash
+            continue
+
+    # Drain remaining entries on shutdown
+    while True:
+        try:
+            entry = _LOG_QUEUE.get_nowait()
+            pending_batch.append(entry)
+        except queue.Empty:
+            break
+
+    if pending_batch:
+        _post_with_retry(pending_batch)
+
+
+def _post_with_retry(entries: list[dict[str, Any]]) -> bool:
+    """POST entries with exponential backoff retry.
+
+    Returns True if successful or if retries exhausted (batch should be dropped).
+    Returns False if no API key available (batch should be held for later).
+    """
+    try:
+        base_url, api_key = get_backend_from_env()
+        base = (base_url or "").rstrip("/")
+        key = (api_key or "").strip()
+
+        # If no API key, signal to hold batch for next cycle
+        if not base or not key:
+            return False
+
+        url = f"{base}{_ENDPOINT_SUFFIX}"
+        headers = {
+            "authorization": f"Bearer {key}",
+            "accept": "application/json",
+            "content-type": "application/json",
+        }
+        payload: dict[str, Any] = {
+            "entries": entries,
+            "batch_id": uuid.uuid4().hex,
+        }
+
+        for attempt in range(_MAX_RETRIES):
+            try:
+                http_request("POST", url, headers=headers, body=payload)
+                return True  # Success
+            except Exception:
+                if attempt < _MAX_RETRIES - 1:
+                    backoff = _BACKOFF_BASE * (2**attempt)
+                    time.sleep(backoff)
+
+        # All retries failed, drop batch
+        return True
+    except Exception:
+        # Unexpected error, drop batch to avoid blocking
+        return True
+
+
+def log_event(
+    level: str,
+    msg: str,
+    *,
+    attributes: Mapping[str, Any] | None = None,
+    ctx: Mapping[str, Any] | None = None,
+    req_id: str | None = None,
+    batch_id: str | None = None,
+) -> None:
+    """Send a single log entry to the backend (best effort, batched async)."""
+    if DISABLE_LOGGING:
+        return
+    try:
+        entry = _build_entry(
+            level, msg, attributes=attributes, ctx=ctx, req_id=req_id
+        )
+        if entry is None:
+            return
+        _enqueue(entry)
+    except Exception:
+        # Logging must never raise for callers
+        return
+
+
+def log_info(msg: str, **kwargs: Any) -> None:
+    log_event("info", msg, **kwargs)
+
+
+def log_warning(msg: str, **kwargs: Any) -> None:
+    log_event("warning", msg, **kwargs)
+
+
+def log_error(msg: str, **kwargs: Any) -> None:
+    log_event("error", msg, **kwargs)
+
+
+def log_batch(
+    entries: Sequence[Mapping[str, Any]], *, batch_id: str | None = None
+) -> None:
+    """Send a batch of pre-built entries. Invalid entries are skipped silently."""
+    if DISABLE_LOGGING:
+        return
+    try:
+        for entry in entries:
+            if not isinstance(entry, Mapping):
+                continue
+            prepared = _build_entry(
+                entry.get("level", "info"),
+                entry.get("message", ""),
+                attributes=entry.get("attributes"),
+                ctx=entry.get("context"),
+                req_id=entry.get("request_id"),
+            )
+            if prepared:
+                _enqueue(prepared)
+    except Exception:
+        return
+
+
+def _build_entry(
+    level: str,
+    msg: str,
+    *,
+    attributes: Mapping[str, Any] | None,
+    ctx: Mapping[str, Any] | None,
+    req_id: str | None,
+) -> dict[str, Any] | None:
+    normalized_level = str(level or "").lower()
+    if normalized_level not in _ALLOWED_LEVELS:
+        normalized_level = "info"
+    safe_message = (msg or "").strip()
+    if not safe_message:
+        return None
+    safe_message = safe_message[:_MAX_MESSAGE_LENGTH]
+    return {
+        "level": normalized_level,
+        "message": safe_message,
+        "timestamp": datetime.now(UTC).isoformat(),
+        "sdk_version": _get_sdk_version(),
+        "request_id": req_id or uuid.uuid4().hex,
+        "attributes": _normalize_mapping(attributes),
+        "context": _normalize_mapping(ctx),
+    }
+
+
+def _normalize_mapping(values: Mapping[str, Any] | None) -> dict[str, Any]:
+    if not values:
+        return {}
+    normalized: dict[str, Any] = {}
+    for key, value in values.items():
+        try:
+            normalized[str(key)] = _coerce(value)
+        except Exception:
+            continue
+    return normalized
+
+
+def _coerce(value: Any) -> Any:
+    if isinstance(value, str | int | float | bool) or value is None:
+        return value
+    if isinstance(value, Mapping):
+        return {str(k): _coerce(v) for k, v in value.items()}
+    if isinstance(value, list | tuple | set):
+        return [_coerce(v) for v in value]
+    return str(value)
+
+
+def flush_logger(timeout: float | None = None) -> None:
+    """Signal shutdown and wait for worker to drain queue and finish."""
+    global _worker_thread
+
+    with _worker_lock:
+        thread = _worker_thread
+
+    if thread is None or not thread.is_alive():
+        return
+
+    _shutdown_event.set()
+    thread.join(timeout=timeout)