synth-ai 0.2.8.dev12__py3-none-any.whl → 0.2.8.dev13__py3-none-any.whl

synth_ai/cli/task_apps.py

@@ -0,0 +1,520 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+import os
+import signal
+from pathlib import Path
+from typing import Sequence
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+import click
+
+from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, registry
+from synth_ai.task.server import run_task_app
+
+
+@click.group(
+    name='task-app',
+    help='Utilities for serving and deploying Synth task apps.'
+)
+def task_app_group() -> None:
+    pass
+
+
+@task_app_group.command('list')
+def list_apps() -> None:
+    """List registered task apps."""
+
+    entries = registry.list()
+    if not entries:
+        click.echo("No task apps registered.")
+        return
+    for entry in entries:
+        aliases = f" (aliases: {', '.join(entry.aliases)})" if entry.aliases else ""
+        click.echo(f"- {entry.app_id}{aliases}: {entry.description}")
+def _load_env_files_into_process(paths: Sequence[str]) -> None:
+    for p in paths:
+        try:
+            txt = Path(p).expanduser().read_text()
+        except Exception:
+            continue
+        for line in txt.splitlines():
+            if not line or line.startswith('#') or '=' not in line:
+                continue
+            k, v = line.split('=', 1)
+            key = k.strip()
+            val = v.strip().strip('"').strip("'")
+            if key and key not in os.environ:
+                os.environ[key] = val
+
+
+
+@click.command('serve')
+@click.argument('app_id', type=str)
+@click.option('--host', default='0.0.0.0', show_default=True)
+@click.option('--port', default=8001, show_default=True, type=int)
+@click.option('--env-file', multiple=True, type=click.Path(), help='Extra .env files to load')
+@click.option('--reload/--no-reload', 'reload_flag', default=False, help='Enable uvicorn auto-reload')
+@click.option('--force/--no-force', 'force', default=False, help='Kill any process already bound to the selected port before starting')
+@click.option('--trace', 'trace_dir', type=click.Path(), default=None, help='Enable tracing and write SFT JSONL files to this directory')
+@click.option('--trace-db', 'trace_db', type=click.Path(), default=None, help='Override local trace DB path (maps to SQLD_DB_PATH)')
+def serve_command(
+    app_id: str,
+    host: str,
+    port: int,
+    env_file: Sequence[str],
+    reload_flag: bool,
+    force: bool,
+    trace_dir: str | None,
+    trace_db: str | None,
+) -> None:
+    _serve(app_id, host, port, env_file, reload_flag, force, trace_dir=trace_dir, trace_db=trace_db)
+
+
+@task_app_group.command('serve')
+@click.argument('app_id', type=str)
+@click.option('--host', default='0.0.0.0', show_default=True)
+@click.option('--port', default=8001, show_default=True, type=int)
+@click.option('--env-file', multiple=True, type=click.Path(), help='Extra .env files to load')
+@click.option('--reload/--no-reload', 'reload_flag', default=False, help='Enable uvicorn auto-reload')
+@click.option('--force/--no-force', 'force', default=False, help='Kill any process already bound to the selected port before starting')
+@click.option('--trace', 'trace_dir', type=click.Path(), default=None, help='Enable tracing and write SFT JSONL files to this directory')
+@click.option('--trace-db', 'trace_db', type=click.Path(), default=None, help='Override local trace DB path (maps to SQLD_DB_PATH)')
+def serve_task_group(
+    app_id: str,
+    host: str,
+    port: int,
+    env_file: Sequence[str],
+    reload_flag: bool,
+    force: bool,
+    trace_dir: str | None,
+    trace_db: str | None,
+) -> None:
+    _serve(app_id, host, port, env_file, reload_flag, force, trace_dir=trace_dir, trace_db=trace_db)
+
+def _determine_env_files(entry: TaskAppEntry, user_env_files: Sequence[str]) -> list[Path]:
+    resolved: list[Path] = []
+    for candidate in user_env_files:
+        p = Path(candidate).expanduser()
+        if not p.exists():
+            raise click.ClickException(f"Env file not found: {p}")
+        resolved.append(p)
+    if resolved:
+        return resolved
+
+    defaults = [Path(path).expanduser() for path in (entry.env_files or []) if Path(path).expanduser().exists()]
+    if defaults:
+        return defaults
+
+    env_candidates = sorted(REPO_ROOT.glob('**/*.env'))
+    if not env_candidates:
+        raise click.ClickException('No env file found. Pass --env-file explicitly.')
+
+    click.echo('Select env file to load:')
+    for idx, path in enumerate(env_candidates, start=1):
+        click.echo(f"  {idx}) {path}")
+    choice = click.prompt('Enter choice', type=click.IntRange(1, len(env_candidates)))
+    return [env_candidates[choice - 1]]
+
+
+def _ensure_port_free(port: int, host: str, *, force: bool) -> None:
+    import os
+    import socket
+    import subprocess
+    import time
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        in_use = s.connect_ex((host, port)) == 0
+    if not in_use:
+        return
+
+    try:
+        out = subprocess.run(["lsof", "-ti", f"TCP:{port}"], capture_output=True, text=True, check=False)
+        pids = [pid for pid in out.stdout.strip().splitlines() if pid]
+    except FileNotFoundError:
+        pids = []
+
+    if not force:
+        message = f"Port {port} appears to be in use"
+        if pids:
+            message += f" (PIDs: {', '.join(pids)})"
+        raise click.ClickException(message)
+
+    for pid in pids:
+        try:
+            os.kill(int(pid), signal.SIGTERM)
+        except Exception as exc:
+            raise click.ClickException(f'Failed to terminate PID {pid}: {exc}')
+
+    time.sleep(0.5)
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        still_in_use = s.connect_ex((host, port)) == 0
+
+    if still_in_use:
+        for pid in pids:
+            try:
+                os.kill(int(pid), signal.SIGKILL)
+            except Exception as exc:
+                raise click.ClickException(f'Failed to force terminate PID {pid}: {exc}')
+        time.sleep(0.5)
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        in_use_after = s.connect_ex((host, port)) == 0
+    if in_use_after:
+        raise click.ClickException(f'Port {port} is still in use after attempting to terminate processes.')
+
+def _serve(
+    app_id: str,
+    host: str,
+    port: int,
+    env_file: Sequence[str],
+    reload_flag: bool,
+    force: bool,
+    *,
+    trace_dir: str | None = None,
+    trace_db: str | None = None,
+) -> None:
+    try:
+        entry = registry.get(app_id)
+    except KeyError as exc:  # pragma: no cover - CLI input validation
+        raise click.ClickException(str(exc)) from exc
+
+    env_files = list(entry.env_files)
+    env_files.extend(env_file)
+
+    trace_enabled = trace_dir is not None or trace_db is not None
+    if trace_enabled:
+        os.environ['TASKAPP_TRACING_ENABLED'] = '1'
+        if trace_dir is not None:
+            dir_path = Path(trace_dir).expanduser()
+            try:
+                dir_path.mkdir(parents=True, exist_ok=True)
+            except Exception as exc:
+                raise click.ClickException(f"Failed to create trace directory {dir_path}: {exc}") from exc
+            os.environ['TASKAPP_SFT_OUTPUT_DIR'] = str(dir_path)
+            click.echo(f"Tracing enabled. SFT JSONL will be written to {dir_path}")
+        if trace_db is not None:
+            db_path = Path(trace_db).expanduser()
+            os.environ['SQLD_DB_PATH'] = str(db_path)
+            os.environ.pop('TURSO_LOCAL_DB_URL', None)
+            click.echo(f"Tracing DB path set to {db_path}")
+        from synth_ai.tracing_v3.config import CONFIG as TRACE_CONFIG
+        # recompute db_url based on current environment
+        new_db_url = os.getenv('TURSO_LOCAL_DB_URL') or TRACE_CONFIG.db_url
+        TRACE_CONFIG.db_url = new_db_url
+        if new_db_url:
+            os.environ['TURSO_LOCAL_DB_URL'] = new_db_url
+            click.echo(f"Tracing DB URL resolved to {new_db_url}")
+    elif os.getenv('TASKAPP_TRACING_ENABLED'):
+        click.echo("Tracing enabled via environment variables")
+
+    _ensure_port_free(port, host, force=force)
+
+    # Preflight: upsert and verify ENVIRONMENT_API_KEY with backend before serving
+    try:
+        raw_backend = os.environ.get("BACKEND_BASE_URL") or os.environ.get("SYNTH_BASE_URL") or "http://localhost:8000/api"
+        backend_base = raw_backend.rstrip("/")
+        if not backend_base.endswith("/api"):
+            backend_base = backend_base + "/api"
+        synth_key = os.environ.get("SYNTH_API_KEY") or ""
+        env_api_key = os.environ.get("ENVIRONMENT_API_KEY") or os.environ.get("dev_environment_api_key") or os.environ.get("DEV_ENVIRONMENT_API_KEY") or ""
+        if synth_key and env_api_key:
+            import base64, httpx
+            click.echo(f"[preflight] backend={backend_base}")
+            # Fetch sealed-box public key
+            with httpx.Client(timeout=15.0, headers={"Authorization": f"Bearer {synth_key}"}) as c:
+                click.echo("[preflight] fetching public key…")
+                rpk = c.get(f"{backend_base.rstrip('/')}/v1/crypto/public-key")
+                if rpk.status_code == 200:
+                    pk = (rpk.json() or {}).get("public_key")
+                else:
+                    pk = None
+            if pk:
+                # Encrypt env_api_key using libsodium sealed box
+                try:
+                    from nacl.public import SealedBox, PublicKey
+                    pub = PublicKey(base64.b64decode(pk, validate=True))
+                    sb = SealedBox(pub)
+                    ct = sb.encrypt(env_api_key.encode("utf-8"))
+                    ct_b64 = base64.b64encode(ct).decode()
+                    payload = {"name": "ENVIRONMENT_API_KEY", "ciphertext_b64": ct_b64}
+                    with httpx.Client(timeout=15.0, headers={"Authorization": f"Bearer {synth_key}", "Content-Type": "application/json"}) as c:
+                        click.echo("[preflight] upserting env key…")
+                        up = c.post(f"{backend_base.rstrip('/')}/v1/env-keys", json=payload)
+                        click.echo(f"[preflight] upsert status={up.status_code}")
+                        # Verify
+                        click.echo("[preflight] verifying env key presence…")
+                        ver = c.get(f"{backend_base.rstrip('/')}/v1/env-keys/verify")
+                        if ver.status_code == 200 and (ver.json() or {}).get("present"):
+                            click.echo("✅ ENVIRONMENT_API_KEY upserted and verified in backend")
+                        else:
+                            click.echo("[WARN] ENVIRONMENT_API_KEY verification failed; proceeding anyway")
+                except Exception:
+                    click.echo("[WARN] Failed to encrypt/upload ENVIRONMENT_API_KEY; proceeding anyway")
+    except Exception:
+        click.echo("[WARN] Backend preflight for ENVIRONMENT_API_KEY failed; proceeding anyway")
+
+    run_task_app(
+        entry.config_factory,
+        host=host,
+        port=port,
+        reload=reload_flag,
+        env_files=env_files,
+    )
+
+
+@task_app_group.command('deploy')
+@click.argument("app_id", type=str)
+@click.option("--name", "modal_name", default=None, help="Override Modal app name")
+@click.option("--dry-run", is_flag=True, help="Print modal deploy command without executing")
+@click.option("--modal-cli", default="modal", help="Path to modal CLI executable")
+@click.option('--env-file', multiple=True, type=click.Path(), help='Env file to load into the container (can be repeated)')
+def deploy_app(app_id: str, modal_name: str | None, dry_run: bool, modal_cli: str, env_file: Sequence[str]) -> None:
+    """Deploy a task app to Modal."""
+
+    try:
+        entry = registry.get(app_id)
+    except KeyError as exc:  # pragma: no cover - CLI input validation
+        raise click.ClickException(str(exc)) from exc
+
+    modal_cfg = entry.modal
+    if modal_cfg is None:
+        raise click.ClickException(f"Task app '{entry.app_id}' does not define Modal deployment settings")
+
+    env_paths = _determine_env_files(entry, env_file)
+    click.echo('Using env file(s): ' + ', '.join(str(p) for p in env_paths))
+
+    modal_path = shutil.which(modal_cli)
+    if modal_path is None:
+        raise click.ClickException(f"Modal CLI not found (looked for '{modal_cli}')")
+
+    # Preflight: upsert and verify ENVIRONMENT_API_KEY with backend before deploy
+    try:
+        raw_backend = os.environ.get("BACKEND_BASE_URL") or os.environ.get("SYNTH_BASE_URL") or "http://localhost:8000/api"
+        backend_base = raw_backend.rstrip("/")
+        if not backend_base.endswith("/api"):
+            backend_base = backend_base + "/api"
+        synth_key = os.environ.get("SYNTH_API_KEY") or ""
+        env_api_key = os.environ.get("ENVIRONMENT_API_KEY") or os.environ.get("dev_environment_api_key") or os.environ.get("DEV_ENVIRONMENT_API_KEY") or ""
+        if synth_key and env_api_key:
+            import base64, httpx
+            click.echo(f"[preflight] backend={backend_base}")
+            with httpx.Client(timeout=15.0, headers={"Authorization": f"Bearer {synth_key}"}) as c:
+                click.echo("[preflight] fetching public key…")
+                rpk = c.get(f"{backend_base.rstrip('/')}/v1/crypto/public-key")
+                pk = (rpk.json() or {}).get("public_key") if rpk.status_code == 200 else None
+            if pk:
+                try:
+                    from nacl.public import SealedBox, PublicKey
+                    pub = PublicKey(base64.b64decode(pk, validate=True))
+                    sb = SealedBox(pub)
+                    ct_b64 = base64.b64encode(sb.encrypt(env_api_key.encode("utf-8"))).decode()
+                    payload = {"name": "ENVIRONMENT_API_KEY", "ciphertext_b64": ct_b64}
+                    with httpx.Client(timeout=15.0, headers={"Authorization": f"Bearer {synth_key}", "Content-Type": "application/json"}) as c:
+                        click.echo("[preflight] upserting env key…")
+                        up = c.post(f"{backend_base.rstrip('/')}/v1/env-keys", json=payload)
+                        click.echo(f"[preflight] upsert status={up.status_code}")
+                        ver = c.get(f"{backend_base.rstrip('/')}/v1/env-keys/verify")
+                        if ver.status_code == 200 and (ver.json() or {}).get("present"):
+                            click.echo("✅ ENVIRONMENT_API_KEY upserted and verified in backend")
+                        else:
+                            click.echo("[WARN] ENVIRONMENT_API_KEY verification failed; proceeding anyway")
+                except Exception:
+                    click.echo("[WARN] Failed to encrypt/upload ENVIRONMENT_API_KEY; proceeding anyway")
+    except Exception:
+        click.echo("[WARN] Backend preflight for ENVIRONMENT_API_KEY failed; proceeding anyway")
+
+    script_path = _write_modal_entrypoint(
+        entry,
+        modal_cfg,
+        modal_name,
+        dotenv_paths=[str(path) for path in env_paths],
+    )
+    cmd = [modal_path, "deploy", str(script_path)]
+    if dry_run:
+        click.echo("Dry run: " + " ".join(cmd))
+        script_path.unlink(missing_ok=True)
+        return
+    try:
+        subprocess.run(cmd, check=True)
+    finally:
+        script_path.unlink(missing_ok=True)
+
+@task_app_group.command('modal-serve')
+@click.argument('app_id', type=str, required=False)
+@click.option('--modal-cli', default='modal', help='Path to modal CLI executable')
+@click.option('--name', 'modal_name', default=None, help='Override Modal app name (optional)')
+@click.option('--env-file', multiple=True, type=click.Path(), help='Env file to load into the container (can be repeated)')
+def modal_serve_app(app_id: str | None, modal_cli: str, modal_name: str | None, env_file: Sequence[str]) -> None:
+    entries = registry.list()
+    if app_id is None:
+        if len(entries) == 1:
+            entry = entries[0]
+        else:
+            available = ', '.join(e.app_id for e in entries) or 'none'
+            raise click.ClickException(f"APP_ID required (available: {available})")
+    else:
+        try:
+            entry = registry.get(app_id)
+        except KeyError as exc:
+            raise click.ClickException(str(exc)) from exc
+
+    modal_cfg = entry.modal
+    if modal_cfg is None:
+        raise click.ClickException(f"Task app '{entry.app_id}' does not define Modal deployment settings")
+
+    env_paths = _determine_env_files(entry, env_file)
+    click.echo('Using env file(s): ' + ', '.join(str(p) for p in env_paths))
+    # Make values available for preflight
+    _load_env_files_into_process([str(p) for p in env_paths])
+
+    modal_path = shutil.which(modal_cli)
+    if modal_path is None:
+        raise click.ClickException(f"Modal CLI not found (looked for '{modal_cli}')")
+
+    # Preflight: upsert and verify ENVIRONMENT_API_KEY with backend before serve
+    try:
+        raw_backend = os.environ.get("BACKEND_BASE_URL") or os.environ.get("SYNTH_BASE_URL") or "http://localhost:8000/api"
+        backend_base = raw_backend.rstrip('/')
+        if not backend_base.endswith('/api'):
+            backend_base = backend_base + '/api'
+        synth_key = os.environ.get("SYNTH_API_KEY") or ""
+        env_api_key = os.environ.get("ENVIRONMENT_API_KEY") or os.environ.get("dev_environment_api_key") or os.environ.get("DEV_ENVIRONMENT_API_KEY") or ""
+        if synth_key and env_api_key:
+            import base64, httpx
+            click.echo(f"[preflight] backend={backend_base}")
+            with httpx.Client(timeout=15.0, headers={"Authorization": f"Bearer {synth_key}"}) as c:
+                click.echo("[preflight] fetching public key…")
+                rpk = c.get(f"{backend_base}/v1/crypto/public-key")
+                pk = (rpk.json() or {}).get("public_key") if rpk.status_code == 200 else None
+            if pk:
+                try:
+                    from nacl.public import SealedBox, PublicKey
+                    pub = PublicKey(base64.b64decode(pk, validate=True))
+                    sb = SealedBox(pub)
+                    ct_b64 = base64.b64encode(sb.encrypt(env_api_key.encode('utf-8'))).decode()
+                    payload = {"name": "ENVIRONMENT_API_KEY", "ciphertext_b64": ct_b64}
+                    with httpx.Client(timeout=15.0, headers={"Authorization": f"Bearer {synth_key}", "Content-Type": "application/json"}) as c:
+                        click.echo("[preflight] upserting env key…")
+                        up = c.post(f"{backend_base}/v1/env-keys", json=payload)
+                        click.echo(f"[preflight] upsert status={up.status_code}")
+                        click.echo("[preflight] verifying env key presence…")
+                        ver = c.get(f"{backend_base}/v1/env-keys/verify")
+                        if ver.status_code == 200 and (ver.json() or {}).get("present"):
+                            click.echo("✅ ENVIRONMENT_API_KEY upserted and verified in backend")
+                        else:
+                            click.echo("[WARN] ENVIRONMENT_API_KEY verification failed; proceeding anyway")
+                except Exception:
+                    click.echo("[WARN] Failed to encrypt/upload ENVIRONMENT_API_KEY; proceeding anyway")
+    except Exception:
+        click.echo("[WARN] Backend preflight for ENVIRONMENT_API_KEY failed; proceeding anyway")
+
+    script_path = _write_modal_entrypoint(
+        entry,
+        modal_cfg,
+        modal_name,
+        dotenv_paths=[str(path) for path in env_paths],
+    )
+    cmd = [modal_path, 'serve', str(script_path)]
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as exc:
+        raise click.ClickException(f"modal serve failed with exit code {exc.returncode}") from exc
+    finally:
+        script_path.unlink(missing_ok=True)
+
+
+def _write_modal_entrypoint(
+    entry: TaskAppEntry,
+    modal_cfg: ModalDeploymentConfig,
+    override_name: str | None,
+    *,
+    dotenv_paths: Sequence[str] | None = None,
+) -> Path:
+    modal_name = override_name or modal_cfg.app_name
+
+    module_name = entry.config_factory.__module__
+    dotenv_paths = [str(Path(path)) for path in (dotenv_paths or [])]
+
+    pip_packages = list(modal_cfg.pip_packages)
+
+    local_dirs = [(str(Path(src)), dst) for src, dst in modal_cfg.extra_local_dirs]
+    secret_names = list(modal_cfg.secret_names)
+    volume_mounts = [(name, mount) for name, mount in modal_cfg.volume_mounts]
+
+    script = f"""from __future__ import annotations
+
+import importlib
+import sys
+sys.path.insert(0, '/opt/synth_ai_repo')
+
+from modal import App, Image, Secret, Volume, asgi_app
+
+from synth_ai.task.apps import registry
+from synth_ai.task.server import create_task_app
+
+ENTRY_ID = {entry.app_id!r}
+MODAL_APP_NAME = {modal_name!r}
+MODULE_NAME = {module_name!r}
+DOTENV_PATHS = {dotenv_paths!r}
+
+image = Image.debian_slim(python_version={modal_cfg.python_version!r})
+
+pip_packages = {pip_packages!r}
+if pip_packages:
+    image = image.pip_install(*pip_packages)
+
+local_dirs = {local_dirs!r}
+for local_src, remote_dst in local_dirs:
+    image = image.add_local_dir(local_src, remote_dst)
+
+secrets = {secret_names!r}
+secret_objs = [Secret.from_name(name) for name in secrets]
+
+if DOTENV_PATHS:
+    secret_objs.extend(Secret.from_dotenv(path) for path in DOTENV_PATHS)
+
+volume_mounts = {volume_mounts!r}
+volume_map = {{}}
+for vol_name, mount_path in volume_mounts:
+    volume_map[mount_path] = Volume.from_name(vol_name, create_if_missing=True)
+
+importlib.import_module(MODULE_NAME)
+
+entry = registry.get(ENTRY_ID)
+modal_cfg = entry.modal
+if modal_cfg is None:
+    raise RuntimeError("Modal configuration missing for task app {entry.app_id}")
+
+app = App(MODAL_APP_NAME)
+
+@app.function(
+    image=image,
+    timeout={modal_cfg.timeout},
+    memory={modal_cfg.memory},
+    cpu={modal_cfg.cpu},
+    min_containers={modal_cfg.min_containers},
+    max_containers={modal_cfg.max_containers},
+    secrets=secret_objs,
+    volumes=volume_map,
+)
+@asgi_app()
+def fastapi_app():
+    config = entry.config_factory()
+    return create_task_app(config)
+"""
+
+    tmp = tempfile.NamedTemporaryFile("w", suffix=f"_{entry.app_id}_modal.py", delete=False)
+    tmp.write(script)
+    tmp.flush()
+    tmp.close()
+    return Path(tmp.name)
+
+
+def register(cli: click.Group) -> None:
+    cli.add_command(serve_command)
+    cli.add_command(task_app_group)

synth_ai/task/__init__.py

@@ -1,10 +1,103 @@
 from .validators import validate_task_app_url
 from .health import task_app_health
-from .contracts import TaskAppContract, TaskAppEndpoints
+from .contracts import (
+    TaskAppContract,
+    TaskAppEndpoints,
+    RolloutEnvSpec,
+    RolloutPolicySpec,
+    RolloutRecordConfig,
+    RolloutSafetyConfig,
+    RolloutRequest,
+    RolloutResponse,
+    RolloutTrajectory,
+    RolloutStep,
+    RolloutMetrics,
+    TaskInfo,
+)
+from .json import to_jsonable
+from .auth import (
+    normalize_environment_api_key,
+    is_api_key_header_authorized,
+    require_api_key_dependency,
+)
+from .vendors import (
+    normalize_vendor_keys,
+    get_openai_key_or_503,
+    get_groq_key_or_503,
+)
+from .proxy import (
+    INTERACT_TOOL_SCHEMA,
+    prepare_for_openai,
+    prepare_for_groq,
+    inject_system_hint,
+    extract_message_text,
+    parse_tool_call_from_text,
+    synthesize_tool_call_if_missing,
+)
+from .datasets import TaskDatasetSpec, TaskDatasetRegistry
+from .rubrics import (
+    Criterion,
+    Rubric,
+    load_rubric,
+    blend_rubrics,
+    score_events_against_rubric,
+    score_outcome_against_rubric,
+)
+from .client import TaskAppClient
+from .errors import error_payload, http_exception, json_error_response
 
+
+from .server import (
+    TaskAppConfig,
+    ProxyConfig,
+    RubricBundle,
+    create_task_app,
+    run_task_app,
+)
 __all__ = [
     "validate_task_app_url",
     "task_app_health",
     "TaskAppContract",
     "TaskAppEndpoints",
+    "RolloutEnvSpec",
+    "RolloutPolicySpec",
+    "RolloutRecordConfig",
+    "RolloutSafetyConfig",
+    "RolloutRequest",
+    "RolloutResponse",
+    "RolloutTrajectory",
+    "RolloutStep",
+    "RolloutMetrics",
+    "TaskInfo",
+    "to_jsonable",
+    "normalize_environment_api_key",
+    "is_api_key_header_authorized",
+    "require_api_key_dependency",
+    "normalize_vendor_keys",
+    "get_openai_key_or_503",
+    "get_groq_key_or_503",
+    "INTERACT_TOOL_SCHEMA",
+    "prepare_for_openai",
+    "prepare_for_groq",
+    "inject_system_hint",
+    "extract_message_text",
+    "parse_tool_call_from_text",
+    "synthesize_tool_call_if_missing",
+    "TaskDatasetSpec",
+    "TaskDatasetRegistry",
+    "Criterion",
+    "Rubric",
+    "load_rubric",
+    "blend_rubrics",
+    "score_events_against_rubric",
+    "score_outcome_against_rubric",
+    "TaskAppClient",
+    "error_payload",
+    "http_exception",
+    "json_error_response",
+    "run_task_app",
+    "create_task_app",
+    "RubricBundle",
+    "ProxyConfig",
+    "TaskAppConfig",
 ]