synth-ai 0.2.8.dev11__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/demos/demo_task_apps/math/modal_task_app.py

@@ -205,12 +205,14 @@ def fastapi_app():
             """Return Hendrycks MATH problem/answer and tool schema for a seed."""
             q, a = _load_hendrycks_problem(int(seed), subject=subject)
             tools = [{
-                "name": "interact",
-                "description": "Submit one or more actions to the math environment.",
+                "name": "submit_answer",
+                "description": "Provide the final numerical or algebraic answer for the current math problem.",
                 "parameters": {
                     "type": "object",
-                    "properties": {"actions": {"type": "array", "items": {"type": "string"}}},
-                    "required": ["actions"],
+                    "properties": {
+                        "answer": {"type": "string", "description": "The proposed final answer"},
+                    },
+                    "required": ["answer"],
                 },
             }]
             return {
@@ -245,7 +247,7 @@ def fastapi_app():
 
     OPENAI_REMOVE_FIELDS = ("stop_after_tool_calls", "thinking_mode", "thinking_budget", "reasoning")
     OPENAI_REMOVE_SAMPLING_FIELDS = ("temperature", "top_p")
-    TOOL_CHOICE_FORCE = {"type": "function", "function": {"name": "interact_many"}}
+    TOOL_CHOICE_FORCE = {"type": "function", "function": {"name": "submit_answer"}}
 
     def _prepare_openai_payload(model: str | None, payload: dict[str, object]) -> dict[str, object]:
         sanitized = dict(payload)
@@ -258,9 +260,9 @@ def fastapi_app():
                 sanitized.pop("max_tokens", None)
             for field in OPENAI_REMOVE_SAMPLING_FIELDS:
                 sanitized.pop(field, None)
-            sanitized["tool_choice"] = TOOL_CHOICE_FORCE
-            sanitized["parallel_tool_calls"] = False
-        return sanitized
+                sanitized["tool_choice"] = TOOL_CHOICE_FORCE
+                sanitized["parallel_tool_calls"] = False
+            return sanitized
 
     @api.post("/proxy/v1/chat/completions")
     def proxy_chat_completions(request: dict[str, object] = Body(...)):
@@ -330,11 +332,11 @@ def fastapi_app():
                     sanitized.pop("max_tokens", None)
                 for field in ("temperature", "top_p"):
                     sanitized.pop(field, None)
-                sanitized["tool_choice"] = {"type": "function", "function": {"name": "interact"}}
+                sanitized["tool_choice"] = {"type": "function", "function": {"name": "submit_answer"}}
                 sanitized["parallel_tool_calls"] = False
             return sanitized
 
-        def _parse_tool_actions(resp: dict[str, Any]) -> list[str]:
+        def _parse_tool_answer(resp: dict[str, Any]) -> str:
             try:
                 choices = resp.get("choices")
                 if isinstance(choices, list) and choices:
@@ -343,7 +345,7 @@ def fastapi_app():
                     if isinstance(tcs, list) and tcs:
                         fn = tcs[0].get("function", {}) if isinstance(tcs[0], dict) else {}
                         args = fn.get("arguments")
-                        obj = {}
+                        obj: dict[str, Any] = {}
                         if isinstance(args, str):
                             try:
                                 obj = _json.loads(args)
@@ -351,12 +353,12 @@ def fastapi_app():
                                 obj = {}
                         elif isinstance(args, dict):
                             obj = args
-                        acts = obj.get("actions")
-                        if isinstance(acts, list):
-                            return [str(a) for a in acts][:5]
+                        ans = obj.get("answer")
+                        if isinstance(ans, str):
+                            return ans.strip()
             except Exception:
                 pass
-            return []
+            return ""
 
         # Single-step rollout: one agent call followed by evaluation of the returned tool answer
         history: list[dict[str, Any]] = []
@@ -373,7 +375,16 @@ def fastapi_app():
             "messages": [{"role": "user", "content": user_prompt}],
             "tools": [{
                 "type": "function",
-                "function": {"name": "interact", "parameters": {"type": "object", "properties": {"actions": {"type": "array", "items": {"type": "string"}}}, "required": ["actions"]}},
+                "function": {
+                    "name": "submit_answer",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "answer": {"type": "string"},
+                        },
+                        "required": ["answer"],
+                    },
+                },
             }],
             "max_tokens": 256,
             "temperature": 0.2,
@@ -431,11 +442,11 @@ def fastapi_app():
         except Exception:
             pass
 
-        tool_actions = _parse_tool_actions(data)
-        history.append({"actions": tool_actions})
+        tool_answer = _parse_tool_answer(data)
+        history.append({"answer": tool_answer})
         steps.append({
             "obs": {},
-            "tool_calls": [{"tool_name": "interact", "arguments": _json.dumps({"actions": tool_actions})}],
+            "tool_calls": [{"tool_name": "submit_answer", "arguments": _json.dumps({"answer": tool_answer})}],
             "reward": None,
             "done": False,
             "truncated": False,
@@ -444,13 +455,8 @@ def fastapi_app():
 
         # Evaluate answer correctness using tool output (or fall back to assistant text)
         reward_val = 0.0
-        candidate = ""
+        candidate = tool_answer or ""
         try:
-            if isinstance(tool_actions, list):
-                for s in reversed(tool_actions):
-                    if isinstance(s, str) and s.strip():
-                        candidate = s.strip()
-                        break
             if not candidate and llm_text is not None:
                 candidate = _extract_boxed(llm_text) or llm_text
             if expected_answer is not None: