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

examples/rl/task_app/math_task_app.py

@@ -0,0 +1,111 @@
+"""Legacy entrypoint for the math single-step task app."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.requests import Request
+from synth_ai.task.auth import is_api_key_header_authorized, normalize_environment_api_key
+from synth_ai.task.server import create_task_app, run_task_app
+
+from .math_single_step import build_config
+
+
+def fastapi_app():
+    """Return a FastAPI application for hosting the math task app."""
+
+    app = create_task_app(build_config())
+
+    # Replace default health endpoints with auth-tolerant handlers.
+    filtered_routes = []
+    for route in app.router.routes:
+        path = getattr(route, "path", None)
+        methods = getattr(route, "methods", set()) or set()
+        if path in {"/health", "/health/rollout"} and "GET" in methods:
+            continue
+        filtered_routes.append(route)
+    app.router.routes = filtered_routes
+
+    def _log_env_key_prefix(source: str, env_key: str | None) -> str | None:
+        if not env_key:
+            return None
+        prefix = env_key[: max(1, len(env_key) // 2)]
+        print(f"[{source}] expected ENVIRONMENT_API_KEY prefix: {prefix}")
+        return prefix
+
+    @app.get("/health")
+    async def health(request: Request):
+        env_key = normalize_environment_api_key()
+        if not env_key:
+            return JSONResponse(
+                status_code=503,
+                content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"},
+            )
+        if not is_api_key_header_authorized(request):
+            prefix = _log_env_key_prefix("health", env_key)
+            content = {"status": "healthy", "authorized": False}
+            if prefix:
+                content["expected_api_key_prefix"] = prefix
+            return JSONResponse(status_code=200, content=content)
+        return {"status": "healthy", "authorized": True}
+
+    @app.get("/health/rollout")
+    async def health_rollout(request: Request):
+        env_key = normalize_environment_api_key()
+        if not env_key:
+            return JSONResponse(
+                status_code=503,
+                content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"},
+            )
+        if not is_api_key_header_authorized(request):
+            prefix = _log_env_key_prefix("health/rollout", env_key)
+            content = {"status": "healthy", "authorized": False}
+            if prefix:
+                content["expected_api_key_prefix"] = prefix
+            return JSONResponse(status_code=200, content=content)
+        return {"ok": True, "authorized": True}
+
+    @app.exception_handler(RequestValidationError)
+    async def _on_validation_error(request: Request, exc: RequestValidationError):
+        try:
+            hdr = request.headers
+            snapshot = {
+                "path": str(request.url.path),
+                "have_x_api_key": bool(hdr.get("x-api-key")),
+                "have_x_api_keys": bool(hdr.get("x-api-keys")),
+                "have_authorization": bool(hdr.get("authorization")),
+                "errors": exc.errors()[:5],
+            }
+            print("[422] validation", snapshot, flush=True)
+        except Exception:
+            pass
+        return JSONResponse(
+            status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]}
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the math single-step task app locally")
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8101)
+    parser.add_argument("--reload", action="store_true", help="Enable uvicorn autoreload")
+    parser.add_argument(
+        "--env-file",
+        action="append",
+        default=[],
+        help="Path to .env file to load (can be specified multiple times)",
+    )
+    args = parser.parse_args()
+
+    run_task_app(
+        build_config,
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        env_files=args.env_file or [],
+    )

examples/run_crafter_demo.sh

@@ -4,7 +4,7 @@
 # This script demonstrates a reactive agent in the Crafter environment
 
 echo "🚀 Starting Crafter agent demo with Gemini 1.5 Flash..."
-echo "Make sure the synth-ai service is running: uvx synth-ai serve"
+echo "Make sure the synth-ai service is running: uvx synth-ai deploy --runtime uvicorn"
 echo ""
 
-uv run python -m synth_ai.environments.examples.crafter_classic.agent_demos.test_crafter_react_agent --model gemini-1.5-flash
+uv run python -m synth_ai.environments.examples.crafter_classic.agent_demos.test_crafter_react_agent --model gemini-1.5-flash

examples/sft/README.md

@@ -25,9 +25,9 @@ You can generate traces with the Crafter task app and then export them to SFT JS
 
 ```bash
 # Serve the task app locally with tracing enabled (example)
-uvx synth-ai serve grpo-crafter \
+uvx synth-ai deploy --runtime uvicorn grpo-crafter \
   --trace traces/v3 \
-  --trace-db traces/v3/synth_ai.db \
+  --trace-db traces/v3/task_app_traces_<timestamp>.db \
   --port 8001
 
 # Or run traced local rollouts to accumulate data
@@ -36,9 +36,9 @@ uv run python examples/warming_up_to_rl/run_local_rollout_traced.py \
 
 # Export SFT dataset from the trace DB
 uv run python examples/warming_up_to_rl/export_trace_sft.py \
-  --db traces/v3/synth_ai.db \
+  --db traces/v3/task_app_traces_<timestamp>.db \
   --min-unique 0 \
-  --output examples/sft/ft_data/crafter_traces.jsonl
+  --output examples/sft/ft_data/crafter_sft.jsonl
 ```
 
 Notes:
@@ -56,7 +56,7 @@ Use the standard CLI. Do not use a custom Python finetuning script. Point the CL
 uvx synth-ai train \
   --type sft \
   --config examples/sft/configs/crafter_lora_qwen0p6b.toml \
-  --dataset examples/sft/ft_data/crafter_traces.jsonl \
+  --dataset examples/sft/ft_data/crafter_sft.jsonl \
   --env-file /Users/joshpurtell/Documents/GitHub/monorepo/backend/.env.dev
 ```
 
@@ -76,7 +76,7 @@ Full finetuning updates all weights and uses a near-identical CLI flow with the
 uvx synth-ai train \
   --type sft \
   --config examples/sft/configs/crafter_fft_qwen0p6b.toml \
-  --dataset examples/sft/ft_data/crafter_traces.jsonl \
+  --dataset examples/sft/ft_data/crafter_sft.jsonl \
   --env-file /Users/joshpurtell/Documents/GitHub/monorepo/backend/.env.dev
 ```
 

examples/sft/configs/crafter_fft_qwen0p6b.toml

@@ -1,7 +1,12 @@
+[algorithm]
+type = "offline"
+method = "sft"
+variety = "fft"
+
 [job]
 model = "Qwen/Qwen3-0.6B"
 # Prefer passing --dataset at runtime for repeatability
-# data = "examples/sft/ft_data/crafter_traces.jsonl"
+# data = "examples/sft/ft_data/crafter_sft.jsonl"
 
 [compute]
 gpu_type = "H100"
@@ -11,7 +16,7 @@ nodes = 1
 [data]
 topology = {}
 # Optional validation set if you have one locally
-# validation_path = "examples/sft/ft_data/crafter_traces.val.jsonl"
+# validation_path = "examples/sft/ft_data/crafter_sft.val.jsonl"
 
 [training]
 mode = "sft_offline"

examples/sft/configs/crafter_lora_qwen0p6b.toml

@@ -1,7 +1,12 @@
+[algorithm]
+type = "offline"
+method = "sft"
+variety = "qlora"
+
 [job]
 model = "Qwen/Qwen3-0.6B"
 # Optionally set here, but prefer passing --dataset at runtime
-# data = "examples/sft/ft_data/crafter_traces.jsonl"
+# data = "examples/sft/ft_data/crafter_sft.jsonl"
 
 [compute]
 gpu_type = "H100"
@@ -12,7 +17,7 @@ nodes = 1
 # Forwarded into metadata.effective_config
 topology = {}
 # Optional validation set if you have one locally
-# validation_path = "examples/sft/ft_data/crafter_traces.val.jsonl"
+# validation_path = "examples/sft/ft_data/crafter_sft.val.jsonl"
 
 [training]
 mode = "lora"
@@ -42,4 +47,3 @@ fsdp = false
 bf16 = true
 fp16 = false
 activation_checkpointing = true
-

examples/sft/evaluate.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import argparse
 import asyncio
 import os
+from contextlib import suppress
 from dataclasses import dataclass
 from typing import Any
 
@@ -104,10 +105,8 @@ async def main() -> None:
     for r in results:
         ers = r.get("episode_returns") or []
         if isinstance(ers, list) and ers:
-            try:
+            with suppress(Exception):
                 flat_returns.append(float(ers[0]))
-            except Exception:
-                pass
     if flat_returns:
         mean_ret = sum(flat_returns) / len(flat_returns)
         print(f"mean_return={mean_ret:.3f} over {len(flat_returns)} episodes")
@@ -116,4 +115,3 @@ async def main() -> None:
 if __name__ == "__main__":
     asyncio.run(main())
 
-

examples/sft/export_dataset.py

@@ -20,12 +20,17 @@ from examples.warming_up_to_rl.export_trace_sft import (
     parse_event_filters,
     write_jsonl,
 )
+from synth_ai.tracing_v3.constants import TRACE_DB_DIR, canonical_trace_db_name
 
 
 def main() -> None:
     p = argparse.ArgumentParser(description=__doc__)
-    p.add_argument("--db", type=Path, default=Path("traces/v3/synth_ai.db"))
-    p.add_argument("--output", type=Path, default=Path("examples/sft/ft_data/crafter_traces.jsonl"))
+    p.add_argument(
+        "--db",
+        type=Path,
+        default=TRACE_DB_DIR / canonical_trace_db_name(),
+    )
+    p.add_argument("--output", type=Path, default=Path("examples/sft/ft_data/crafter_sft.jsonl"))
     p.add_argument("--model", action="append", dest="models")
     p.add_argument("--provider", action="append", dest="providers")
     p.add_argument("--min-unique", type=int, default=0)
@@ -113,5 +118,3 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
-
-

examples/swe/task_app/README.md

@@ -28,17 +28,17 @@ endpoints.
 ## Using the task app
 
 ```
-uvx synth-ai serve swe-mini --port 8020
+uvx synth-ai deploy --runtime uvicorn swe-mini --port 8020
 ```
 
 ### Recommended: non-interactive serve + .env
 
 ```bash
-uvx synth-ai serve swe-mini \
+uvx synth-ai deploy --runtime uvicorn swe-mini \
   --port 8020 \
   --env-file .env \
   --trace traces/v3 \
-  --trace-db traces/v3/synth_ai.db
+  --trace-db traces/v3/task_app_traces_<timestamp>.db
 ```
 
 This avoids interactive prompts (useful for CI) and loads `ENVIRONMENT_API_KEY`, `OPENAI_API_KEY`, etc. from `.env`.
@@ -60,6 +60,36 @@ Execution is handled by mini-swe's environment classes. Configure execution via
 `SWE_MINI_ENVIRONMENT_CLASS` (`local`, `docker`, `singularity`, …) and pass
 additional keyword arguments with `SWE_MINI_ENVIRONMENT_KWARGS` (JSON).
 
+### Morph Cloud backend
+
+The task app now ships with a Morph-powered environment class so you can run
+mini-SWE rollouts in managed sandboxes. When `MORPH_API_KEY` is present the app
+defaults to this backend automatically unless you override
+`SWE_MINI_ENVIRONMENT_CLASS`.
+
+1. Install the optional dependencies: `pip install "synth-ai[swe]"`.
+2. Export your API key: `export MORPH_API_KEY=...`.
+3. Point the task app at Morph by setting:
+
+   ```bash
+   export SWE_MINI_ENVIRONMENT_CLASS=morph
+   export SWE_MINI_ENVIRONMENT_KWARGS='{
+     "snapshot_id": "snap_your_pre_baked_swebench_image",
+     "cwd": "/workspace/swebench",
+     "env": {"PIP_PROGRESS_BAR": "off"},
+     "metadata": {"project": "synth-ai", "task": "swe-mini"}
+   }'
+   ```
+
+   If you do not have a pre-built snapshot, provide `"image_id"` (defaults to
+   `morphvm-minimal`) along with resource hints (`"vcpus"`, `"memory_mb"`,
+   `"disk_mb"`). You can also set `SWE_MINI_MORPH_SNAPSHOT_ID` globally.
+
+During cleanup the backend deletes the remote workspace and stops the Morph
+instance automatically. All shell commands (including submissions) now execute
+inside the Morph sandbox, enabling RL workflows that require persistent remote
+compute.
+
 ### Tracing & SFT
 
 Tracing works the same as Crafter; pass `--trace` / `--trace-db` to the CLI or

examples/swe/task_app/grpo_swe_mini.py

@@ -404,6 +404,10 @@ def _ensure_env_has_task(
         if not instance_id:
             raise ValueError("mini-swe rollout request requires env.config.instance_id")
         config["task"] = dataset.get(instance_id)
+    env_cfg = dict(config.get("environment") or {})
+    if "environment_class" not in env_cfg and os.getenv("MORPH_API_KEY"):
+        env_cfg["environment_class"] = "morph"
+    config["environment"] = env_cfg
     return env_spec.model_copy(update={"config": config})
 
 
@@ -556,7 +560,6 @@ register_task_app(
         description="mini-swe-agent task app with rollout + proxy endpoints",
         config_factory=build_config,
         aliases=("mini-swe", "swe-mini-task"),
-        env_files=(str(REPO_ROOT / "backend" / ".env.dev"),),
         modal=ModalDeploymentConfig(
             app_name="swe-mini-task-app",
             python_version="3.11",

examples/swe/task_app/grpo_swe_mini_task_app.py

@@ -114,23 +114,11 @@ if __name__ == "__main__":
     parser.add_argument("--host", default="0.0.0.0")
     parser.add_argument("--port", type=int, default=8020)
     parser.add_argument("--reload", action="store_true", help="Enable uvicorn autoreload")
-    parser.add_argument(
-        "--env-file",
-        action="append",
-        default=[],
-        help="Additional .env files to load before startup",
-    )
     args = parser.parse_args()
 
-    default_env = Path(__file__).resolve().parents[4] / "backend" / ".env.dev"
-    env_files = [str(default_env)] if default_env.exists() else []
-    env_files.extend(args.env_file or [])
-
     run_task_app(
         build_task_app_config,
         host=args.host,
         port=args.port,
         reload=args.reload,
-        env_files=env_files,
     )
-

examples/swe/task_app/hosted/envs/crafter/react_agent.py

@@ -46,7 +46,7 @@ class CrafterReActAgent:
             "- Always return a single tool call: interact_many({actions: [...]})\n"
             "- Use 2–5 actions per call; prefer long movement sequences to explore.\n"
             "- Mix in 'do' only when it makes sense (tree, stone, animal, enemy nearby).\n"
-            "- Do not spam the same exact sequence twice in a row—explore in varied directions.\n\n"
+            "\n"
             "Available actions: noop, move_up, move_down, move_left, move_right, do (interact), sleep, "
             "place_stone, place_table, place_furnace, place_plant, make_wood_pickaxe, make_stone_pickaxe, "
             "make_iron_pickaxe, make_wood_sword, make_stone_sword, make_iron_sword\n"

examples/swe/task_app/hosted/envs/mini_swe/environment.py

@@ -18,6 +18,7 @@ from typing import Any
 from minisweagent.environments import get_environment
 from synth_ai.environments.environment.tools import EnvToolCall
 
+from examples.swe.task_app.morph_backend import MorphSandboxBackend
 from .shared import summarise_history
 from .tools import TOOLS_SCHEMA
 
@@ -25,8 +26,9 @@ logger = logging.getLogger(__name__)
 
 
 def _environment_type_from_config(config: dict[str, Any]) -> str:
+    default = "morph" if os.getenv("MORPH_API_KEY") else "local"
     value = (config or {}).get("environment_class") or os.getenv(
-        "SWE_MINI_ENVIRONMENT_CLASS", "local"
+        "SWE_MINI_ENVIRONMENT_CLASS", default
     )
     return str(value).strip() or "local"
 
@@ -91,6 +93,7 @@ class MiniSweEnvironmentWrapper:
         self._local_workspace_dir: Path | None = None
         self._remote_workspace: str | None = None
         self._cleanup_workspace = False
+        self._using_morph_backend = False
 
         if self.environment_type == "local":
             workspace = self._prepare_local_workspace(kwargs)
@@ -117,11 +120,11 @@ class MiniSweEnvironmentWrapper:
             timeout = self.env_config.get("timeout")
             if timeout and "timeout" not in kwargs:
                 kwargs["timeout"] = int(timeout)
-            if self.repo_url and "image" not in kwargs:
+            if self.environment_type in {"docker", "bubblewrap"} and self.repo_url and "image" not in kwargs:
                 image = self.metadata.get("image_name") or os.getenv("SWE_MINI_DOCKER_IMAGE")
                 if image:
                     kwargs["image"] = image
-            if self.environment_type in {"docker", "bubblewrap"}:
+            if self.environment_type in {"docker", "bubblewrap", "morph"}:
                 remote_env = dict(kwargs.get("env") or {})
                 remote_env.setdefault("GIT_TERMINAL_PROMPT", "0")
                 kwargs["env"] = remote_env
@@ -131,13 +134,34 @@ class MiniSweEnvironmentWrapper:
             self.environment_type,
             kwargs,
         )
-        self.env = get_environment(
-            {
-                "environment_class": self.environment_type,
-                **kwargs,
-            },
-            default_type="local",
-        )
+        if self.environment_type == "morph":
+            morph_kwargs = dict(kwargs)
+            image_value = morph_kwargs.pop("image", None)
+            if image_value and "image_id" not in morph_kwargs:
+                morph_kwargs["image_id"] = image_value
+            timeout_value = morph_kwargs.pop("timeout", None)
+            if timeout_value is not None and "startup_timeout" not in morph_kwargs:
+                try:
+                    morph_kwargs["startup_timeout"] = int(timeout_value)
+                except Exception:
+                    logger.warning("Invalid timeout value for morph backend: %r", timeout_value)
+            metadata_override = morph_kwargs.pop("metadata", {}) or {}
+            metadata_payload = {
+                "app": "swe-mini",
+                "instance_id": self.instance_id,
+            }
+            metadata_payload.update({str(k): str(v) for k, v in dict(metadata_override).items()})
+            morph_kwargs["metadata"] = metadata_payload
+            self.env = MorphSandboxBackend(**morph_kwargs)
+            self._using_morph_backend = True
+        else:
+            self.env = get_environment(
+                {
+                    "environment_class": self.environment_type,
+                    **kwargs,
+                },
+                default_type="local",
+            )
 
         if self.environment_type != "local":
             self._bootstrap_remote_workspace()
@@ -181,6 +205,9 @@ class MiniSweEnvironmentWrapper:
             with contextlib.suppress(Exception):
                 self.env.execute(f"rm -rf {shlex.quote(self._remote_workspace)}")
         self._remote_workspace = None
+        if self._using_morph_backend and hasattr(self.env, "close"):
+            with contextlib.suppress(Exception):
+                self.env.close()
 
     def _resolve_repo_url(self, metadata: dict[str, Any]) -> str | None:
         candidates = [
@@ -776,7 +803,7 @@ class MiniSweEnvironmentWrapper:
             or os.getenv("SWE_REX_MODAL_SANDBOX_KWARGS")
         )
         modal_kwargs: dict[str, Any] = {}
-        if isinstance(modal_kwargs_raw, (dict, list)):
+        if isinstance(modal_kwargs_raw, dict | list):
             modal_kwargs = dict(modal_kwargs_raw or {})
         elif isinstance(modal_kwargs_raw, str) and modal_kwargs_raw.strip():
             try:
@@ -841,9 +868,9 @@ class MiniSweEnvironmentWrapper:
             instance_image_tag=instance_image_tag,
             env_image_tag=env_image_tag,
             model_name=model_name,
-            Command=Command,
-            WriteFileRequest=WriteFileRequest,
-            ReadFileRequest=ReadFileRequest,
+            command_cls=Command,
+            write_file_request_cls=WriteFileRequest,
+            read_file_request_cls=ReadFileRequest,
         )
         try:
             return self._run_coroutine_blocking(coro)
@@ -867,9 +894,9 @@ class MiniSweEnvironmentWrapper:
         instance_image_tag: str,
         env_image_tag: str,
         model_name: str,
-        Command,
-        WriteFileRequest,
-        ReadFileRequest,
+        command_cls,
+        write_file_request_cls,
+        read_file_request_cls,
     ) -> dict[str, Any]:
         deployment = deployment_config.get_deployment()
         await deployment.start()
@@ -880,7 +907,7 @@ class MiniSweEnvironmentWrapper:
 
             # Ensure working directory exists.
             mkdir_resp = await runtime.execute(
-                Command(command=["mkdir", "-p", remote_root], timeout=60, shell=False)
+                command_cls(command=["mkdir", "-p", remote_root], timeout=60, shell=False)
             )
             if mkdir_resp.exit_code not in (0, None):
                 logger.warning("Failed to ensure remote directory %s (exit=%s)", remote_root, mkdir_resp.exit_code)
@@ -888,8 +915,8 @@ class MiniSweEnvironmentWrapper:
             # Upload dataset & predictions.
             dataset_blob = json.dumps([instance], ensure_ascii=False)
             predictions_blob = json.dumps({instance_id: prediction}, ensure_ascii=False)
-            await runtime.write_file(WriteFileRequest(path=dataset_remote_path, content=dataset_blob))
-            await runtime.write_file(WriteFileRequest(path=predictions_remote_path, content=predictions_blob))
+            await runtime.write_file(write_file_request_cls(path=dataset_remote_path, content=dataset_blob))
+            await runtime.write_file(write_file_request_cls(path=predictions_remote_path, content=predictions_blob))
 
             eval_cmd = [
                 "python",
@@ -921,7 +948,7 @@ class MiniSweEnvironmentWrapper:
 
             command_timeout = max(eval_timeout + 900, 1200)
             response = await runtime.execute(
-                Command(
+                command_cls(
                     command=eval_cmd,
                     timeout=command_timeout,
                     cwd=remote_root,
@@ -945,7 +972,7 @@ class MiniSweEnvironmentWrapper:
                 for filename in ("report.json", "test_output.txt", "run_instance.log", "patch.diff"):
                     remote_path = f"{remote_log_dir}/{filename}"
                     try:
-                        content = await runtime.read_file(ReadFileRequest(path=remote_path))
+                        content = await runtime.read_file(read_file_request_cls(path=remote_path))
                     except Exception:
                         continue
                     if getattr(content, "content", None):
@@ -1073,7 +1100,7 @@ class MiniSweEnvironmentWrapper:
             return value
         if isinstance(value, str):
             return value.strip().lower() in {"1", "true", "yes", "on"}
-        if isinstance(value, (int, float)):
+        if isinstance(value, int | float):
             return bool(value)
         return False  # pragma: no cover - defensive default
 

examples/swe/task_app/hosted/inference/openai_client.py

@@ -156,13 +156,13 @@ class OpenAIClient:
             keys_preview = sorted(processed_request.keys())
             logger.info(f"Request keys: {keys_preview}")
 
-        # Final hard-guard for OpenAI: ensure unsupported field is not present
+        # Final hard-guard for OpenAI/Groq: ensure unsupported field is not present
         try:
-            if "openai" in url.lower() and "stop_after_tool_calls" in processed_request:
+            low_url = url.lower()
+            if ("openai" in low_url or "groq.com" in low_url or "/proxy/groq" in low_url) and "stop_after_tool_calls" in processed_request:
                 processed_request.pop("stop_after_tool_calls", None)
-                logger.info("Removed stop_after_tool_calls for OpenAI request")
+                logger.info("Removed stop_after_tool_calls for Groq/OpenAI request")
             # Groq-specific requirement: when using JSON mode, one of the messages must contain the word 'json'
-            low_url = url.lower()
             if ("groq.com" in low_url or "/openai" in low_url) and isinstance(
                 processed_request, dict
             ):

examples/swe/task_app/hosted/policy_routes.py

@@ -343,8 +343,6 @@ async def step_policy(
             inf_req = meta["inference_request"]
             msgs = inf_req["messages"]
             model_name = inf_req.get("model") or getattr(policy, "model", None) or ""
-            system_messages: list[str] = []
-            user_messages: list[str] = []
             if msgs and len(msgs) > 0 and msgs[0]["role"] == "system":
                 sys_text = msgs[0]["content"]
                 policy_name = getattr(policy, "name", "") or type(policy).__name__.lower()

examples/swe/task_app/hosted/rollout.py

@@ -888,14 +888,6 @@ async def execute_rollout(
             logger.debug(f"TRACER_FACTORY_FAIL: {exc}")
     tracing_context = RolloutTracingContext(tracer_instance, request, req)
     await tracing_context.start_session()
-    # Print whether tracing is active for this rollout
-    try:
-        print(
-            f"[rollout] tracing enabled={bool(tracing_context.enabled)} run_id={request.run_id}",
-            flush=True,
-        )
-    except Exception:
-        pass
 
     # Register run
     registry.register_run(request.run_id)