synth-ai 0.2.9.dev4__py3-none-any.whl → 0.2.9.dev7__py3-none-any.whl

examples/warming_up_to_rl/export_trace_sft.py

@@ -233,7 +233,9 @@ def _normalise_tool_calls(tool_calls: list[dict[str, Any]] | None) -> list[dict[
             continue
         entry = dict(call)
 
-        func_payload: dict[str, Any] | None = entry.get("function") if isinstance(entry.get("function"), dict) else None
+        func_payload: dict[str, Any] | None = (
+            entry.get("function") if isinstance(entry.get("function"), dict) else None
+        )
         name = entry.get("name") or (func_payload.get("name") if func_payload else None) or "tool"
 
         args = None
@@ -355,7 +357,10 @@ def build_sft_dataset(
             if not assistant_tool_calls:
                 assistant_tool_calls = _normalise_tool_calls(record.get("output_tool_calls"))
 
-            assistant_message: dict[str, Any] = {"role": "assistant", "content": assistant_content or ""}
+            assistant_message: dict[str, Any] = {
+                "role": "assistant",
+                "content": assistant_content or "",
+            }
             if assistant_tool_calls:
                 assistant_message["tool_calls"] = assistant_tool_calls
 
@@ -426,27 +431,141 @@ def _validate_dataset(records: list[dict[str, Any]]) -> None:
         raise SystemExit(f"Validation error while exporting dataset:\n - {summary}")
 
 
+def _find_trace_database() -> Path | None:
+    """Automatically discover the trace database in common locations."""
+
+    # Check for demo directory from state
+    try:
+        state_path = Path.home() / ".synth-ai" / "demo.json"
+        if state_path.exists():
+            import json
+
+            with state_path.open() as f:
+                data = json.load(f)
+                demo_dir = data.get("DEMO_DIR")
+                if demo_dir:
+                    candidate = Path(demo_dir) / "traces" / "v3" / "synth_ai.db"
+                    if candidate.exists():
+                        return candidate
+    except Exception:
+        pass
+
+    # Search upward from current directory
+    cwd = Path.cwd()
+    for parent in [cwd] + list(cwd.parents):
+        candidate = parent / "traces" / "v3" / "synth_ai.db"
+        if candidate.exists():
+            return candidate
+
+    # Check standard locations
+    standard_locations = [
+        Path("traces/v3/synth_ai.db"),
+        Path("../traces/v3/synth_ai.db"),
+        Path.home() / "synth-ai" / "traces" / "v3" / "synth_ai.db",
+    ]
+
+    for location in standard_locations:
+        try:
+            if location.exists():
+                return location.resolve()
+        except Exception:
+            continue
+
+    return None
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--db", type=Path, default=Path("traces/v3/synth_ai.db"), help="Path to tracing_v3 SQLite DB")
-    parser.add_argument("--output", type=Path, required=True, help="Destination JSONL path for the exported dataset")
-    parser.add_argument("--model", action="append", dest="models", help="Restrict to sessions whose dominant model matches (repeatable)")
-    parser.add_argument("--provider", action="append", dest="providers", help="Restrict to sessions whose dominant provider matches (repeatable)")
-    parser.add_argument("--min-unique", type=int, default=None, help="Minimum unique achievements per session")
-    parser.add_argument("--max-unique", type=int, default=None, help="Maximum unique achievements per session")
+    parser.add_argument("--db", type=Path, default=None, help="Path to tracing_v3 SQLite DB")
+    parser.add_argument(
+        "--output",
+        type=Path,
+        required=False,
+        help="Destination JSONL path for the exported dataset",
+    )
+    parser.add_argument(
+        "--model",
+        action="append",
+        dest="models",
+        help="Restrict to sessions whose dominant model matches (repeatable)",
+    )
+    parser.add_argument(
+        "--provider",
+        action="append",
+        dest="providers",
+        help="Restrict to sessions whose dominant provider matches (repeatable)",
+    )
+    parser.add_argument(
+        "--min-unique", type=int, default=None, help="Minimum unique achievements per session"
+    )
+    parser.add_argument(
+        "--max-unique", type=int, default=None, help="Maximum unique achievements per session"
+    )
     parser.add_argument(
         "--exclude-achievement",
         action="append",
         dest="exclude_achievements",
         help="Achievements to ignore when evaluating --min-unique/--max-unique (repeatable)",
     )
-    parser.add_argument("--require-achievement", action="append", dest="required_achievements", help="Require these outcome achievements (repeatable)")
-    parser.add_argument("--min-outcome-reward", type=float, default=None, help="Minimum total outcome reward per session")
-    parser.add_argument("--max-outcome-reward", type=float, default=None, help="Maximum total outcome reward per session")
-    parser.add_argument("--event-reward", action="append", dest="event_reward_filters", help="Require reward_type[:min_total] in event_rewards (repeatable)")
-    parser.add_argument("--limit", type=int, default=None, help="Maximum number of examples to emit")
+    parser.add_argument(
+        "--require-achievement",
+        action="append",
+        dest="required_achievements",
+        help="Require these outcome achievements (repeatable)",
+    )
+    parser.add_argument(
+        "--min-outcome-reward",
+        type=float,
+        default=None,
+        help="Minimum total outcome reward per session",
+    )
+    parser.add_argument(
+        "--max-outcome-reward",
+        type=float,
+        default=None,
+        help="Maximum total outcome reward per session",
+    )
+    parser.add_argument(
+        "--event-reward",
+        action="append",
+        dest="event_reward_filters",
+        help="Require reward_type[:min_total] in event_rewards (repeatable)",
+    )
+    parser.add_argument(
+        "--limit", type=int, default=None, help="Maximum number of examples to emit"
+    )
     args = parser.parse_args()
 
+    # Auto-discover database if not specified
+    db_path = args.db
+    if db_path is None:
+        db_path = _find_trace_database()
+        if db_path:
+            print(f"Found trace database: {db_path}")
+        else:
+            print("\nTrace database configuration:")
+            db_input = input("Trace database path [traces/v3/synth_ai.db]: ").strip()
+            db_path = Path(db_input) if db_input else Path("traces/v3/synth_ai.db")
+
+    if not db_path.exists():
+        print(f"Database not found: {db_path}", file=sys.stderr)
+        raise SystemExit(1)
+
+    output_path = args.output
+    if not output_path:
+        output_path = Path("ft_data/crafter_traces.jsonl")
+        print(f"Output will be written to: {output_path.resolve()}")
+
+    min_unique = args.min_unique
+    if min_unique is None:
+        min_unique = 0  # Default to including all traces
+        print(f"Minimum unique achievements filter: {min_unique} (all traces)")
+
+    # Override args with prompted values
+    args.db = db_path
+    args.output = output_path
+    args.min_unique = min_unique
+
     if not args.db.exists():
         print(f"Database not found: {args.db}", file=sys.stderr)
         raise SystemExit(1)
@@ -488,7 +607,11 @@ def main() -> None:
 
             outcome = outcome_data.get(session_id)
             total_reward = outcome["total_reward"] if outcome else 0.0
-            final_achievements = outcome["achievements"] if outcome else session_final_achievements.get(session_id, set())
+            final_achievements = (
+                outcome["achievements"]
+                if outcome
+                else session_final_achievements.get(session_id, set())
+            )
 
             if args.min_outcome_reward is not None and total_reward < args.min_outcome_reward:
                 continue
@@ -522,7 +645,9 @@ def main() -> None:
         )
 
         if not dataset:
-            print("No rollout steps matched the filters (after session selection).", file=sys.stderr)
+            print(
+                "No rollout steps matched the filters (after session selection).", file=sys.stderr
+            )
             raise SystemExit(1)
 
         _validate_dataset(dataset)
@@ -530,7 +655,7 @@ def main() -> None:
         session_ids = {item.get("metadata", {}).get("session_id") for item in dataset}
         session_ids.discard(None)
         print(
-            f"Wrote {len(dataset)} examples from {len(session_ids)} session(s) -> {args.output}",
+            f"Wrote {len(dataset)} examples from {len(session_ids)} session(s) -> {args.output.resolve()}",
             file=sys.stderr,
         )
     finally:

examples/warming_up_to_rl/groq_test.py

@@ -63,13 +63,21 @@ async def run(args: argparse.Namespace) -> None:
     response = await client.rollout(request)
     print("rollout.metrics →", to_jsonable(response.metrics.model_dump()))
     for idx, step in enumerate(response.trajectories[0].steps, start=1):
-        print(f"step[{idx}] tool_calls={step.tool_calls} reward={step.reward} info={to_jsonable(step.info)}")
+        print(
+            f"step[{idx}] tool_calls={step.tool_calls} reward={step.reward} info={to_jsonable(step.info)}"
+        )
 
 
 def _parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--base-url", default=os.getenv("TASK_APP_BASE_URL", "http://localhost:8000"))
-    parser.add_argument("--api-key", default=os.getenv("TASK_APP_API_KEY"), required=os.getenv("TASK_APP_API_KEY") is None)
+    parser.add_argument(
+        "--base-url", default=os.getenv("TASK_APP_BASE_URL", "http://localhost:8000")
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.getenv("TASK_APP_API_KEY"),
+        required=os.getenv("TASK_APP_API_KEY") is None,
+    )
     parser.add_argument("--model", default=os.getenv("GROQ_MODEL", "groq/mixtral-8x7b"))
     parser.add_argument("--inference-url", default=os.getenv("TASK_APP_INFERENCE_URL"))
     parser.add_argument("--seed", type=int, default=int(os.getenv("CRAFTER_TEST_SEED", "42")))
@@ -85,4 +93,3 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
-

examples/warming_up_to_rl/manage_secrets.py

@@ -34,7 +34,9 @@ def write_temp_env(kv: Dict[str, str]) -> Path:
 
 
 def run(cmd: str) -> Tuple[int, str]:
-    proc = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    proc = subprocess.run(
+        cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+    )
     return proc.returncode, proc.stdout
 
 
@@ -44,11 +46,14 @@ def ensure_secret(secret_name: str, kv: Dict[str, str]) -> None:
         return
     # Prefer passing KEY=VALUE pairs to avoid Typer --env-file bug under some shells
     kv_args = " ".join([f"{shlex.quote(k)}={shlex.quote(v)}" for k, v in kv.items()])
+
     # Try plain modal first; fallback to uv run modal
     def _create() -> Tuple[int, str]:
         return run(f"modal secret create {shlex.quote(secret_name)} {kv_args}")
+
     def _delete() -> Tuple[int, str]:
         return run(f"printf 'y\n' | modal secret delete {shlex.quote(secret_name)}")
+
     rc, out = _create()
     if rc != 0:
         # Fallback: use uv run modal
@@ -70,8 +75,12 @@ def ensure_secret(secret_name: str, kv: Dict[str, str]) -> None:
 
 
 def main() -> None:
-    ap = argparse.ArgumentParser(description="Sync .env keys into Modal secret bundles for the task app")
-    ap.add_argument("--env-path", default=str(Path(__file__).parent / ".env"), help="Path to .env with keys")
+    ap = argparse.ArgumentParser(
+        description="Sync .env keys into Modal secret bundles for the task app"
+    )
+    ap.add_argument(
+        "--env-path", default=str(Path(__file__).parent / ".env"), help="Path to .env with keys"
+    )
     args = ap.parse_args()
 
     env = load_env_file(Path(args.env_path))
@@ -105,7 +114,9 @@ def main() -> None:
     }
 
     # Optional: backend key (not mounted by task app today, but useful to keep consistent)
-    synth_secret = {"SYNTH_API_KEY": env.get("SYNTH_API_KEY", "")} if env.get("SYNTH_API_KEY") else {}
+    synth_secret = (
+        {"SYNTH_API_KEY": env.get("SYNTH_API_KEY", "")} if env.get("SYNTH_API_KEY") else {}
+    )
 
     ensure_secret("crafter-environment-sdk", env_secret)
     ensure_secret("groq-api-key", groq_secret)
@@ -123,5 +134,3 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"[error] {type(e).__name__}: {e}")
         sys.exit(1)
-
-

examples/warming_up_to_rl/readme.md

@@ -87,9 +87,16 @@ Evaluation scripts auto-load `.env` values. Update TOMLs under `configs/` with t
 
 ## 4. Tracing and SFT Dataset Export
 
-1. Serve the task app with tracing enabled (see Section 2) or run the traced rollout helper:
+1. Serve the task app with tracing enabled (see Section 2). Optionally, run the traced rollout helper against the running server:
    ```bash
-   uv run python examples/warming_up_to_rl/run_local_rollout_traced.py --episodes 10 --difficulty easy
+   uv run python examples/warming_up_to_rl/run_local_rollout_traced.py \
+     --base-url http://localhost:8001 \
+     --api-key "$ENVIRONMENT_API_KEY" \
+     --inference-api-key "$GROQ_API_KEY" \
+     --model qwen/qwen3-32b \
+     --inference-url https://api.groq.com/openai \
+     --max-llm-calls 3 \
+     --run-id local-trace
    ```
 2. Inspect local trace databases:
    ```bash

examples/warming_up_to_rl/run_eval.py

@@ -5,6 +5,7 @@ Baseline evaluation script (public-friendly skeleton)
 - Uses a TaskAppClient interface (to be implemented in synth-ai SDK)
 - Keeps structure aligned with research/testing/crafter eval harness
 """
+
 from __future__ import annotations
 import os
 import json
@@ -17,6 +18,7 @@ import argparse
 import tomllib
 from pathlib import Path
 
+
 class TaskAppClient:
     """Minimal async client for the task app initialize/step/terminate routes.
 
@@ -68,7 +70,9 @@ class TaskAppClient:
         resp.raise_for_status()
         return resp.json()
 
-    async def step(self, env_name: str, env_id: str, tool_calls: List[Dict[str, Any]]) -> Dict[str, Any]:
+    async def step(
+        self, env_name: str, env_id: str, tool_calls: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
         """POST /env/{env_name}/step with wrapped tool_calls in action."""
         payload = {"env_id": env_id, "action": {"tool_calls": tool_calls}}
         resp = await self.client.post(f"/env/{env_name}/step", json=payload)
@@ -102,7 +106,17 @@ class TaskAppClient:
                 return {"error": data}
             return data
 
-    async def rollout(self, *, run_id: str, env_name: str, seed: int, difficulty: str, policy_name: str, policy_config: Dict[str, Any], max_turns: int) -> Dict[str, Any]:
+    async def rollout(
+        self,
+        *,
+        run_id: str,
+        env_name: str,
+        seed: int,
+        difficulty: str,
+        policy_name: str,
+        policy_config: Dict[str, Any],
+        max_turns: int,
+    ) -> Dict[str, Any]:
         ops: List[str] = []
         for _ in range(max_turns):
             ops.extend(["agent", "env"])
@@ -128,30 +142,37 @@ class TaskAppClient:
         resp.raise_for_status()
         return resp.json()
 
+
 TASK_APP_URL = os.getenv("TASK_APP_URL", "https://YOUR-TASK-APP.modal.run").rstrip("/")
 MODEL = os.getenv("EVAL_MODEL", "qwen/qwen3-32b")
 NUM_EPISODES = int(os.getenv("NUM_EPISODES", "3"))
 MAX_TURNS = int(os.getenv("MAX_TURNS", "10"))
 CONCURRENCY = int(os.getenv("CONCURRENCY", "1"))
 
+
 def _interact_tool_schema() -> List[Dict[str, Any]]:
-    return [{
-        "type": "function",
-        "function": {
-            "name": "interact",
-            "description": "Perform actions in the Crafter environment.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "actions": {"type": "array", "items": {"type": "string"}},
-                    "reasoning": {"type": "string"},
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "interact",
+                "description": "Perform actions in the Crafter environment.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "actions": {"type": "array", "items": {"type": "string"}},
+                        "reasoning": {"type": "string"},
+                    },
+                    "required": ["actions", "reasoning"],
                 },
-                "required": ["actions", "reasoning"],
             },
-        },
-    }]
+        }
+    ]
+
 
-def _build_messages_from_observation(observation: Dict[str, Any], history: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def _build_messages_from_observation(
+    observation: Dict[str, Any], history: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
     inv = observation.get("inventory") or {}
     pos = observation.get("player_position") or []
     ach = observation.get("achievements_status") or {}
@@ -171,6 +192,7 @@ def _build_messages_from_observation(observation: Dict[str, Any], history: List[
     content = "\n".join(user_lines)
     return [{"role": "user", "content": content}]
 
+
 def _parse_tool_calls_from_openai_response(data: Dict[str, Any]) -> List[str]:
     try:
         choices = data.get("choices")
@@ -203,7 +225,11 @@ def _parse_tool_calls_from_openai_response(data: Dict[str, Any]) -> List[str]:
         if isinstance(content, str):
             text = content
         elif isinstance(content, list):
-            text = "\n".join(str(part.get("text")) for part in content if isinstance(part, dict) and part.get("text"))
+            text = "\n".join(
+                str(part.get("text"))
+                for part in content
+                if isinstance(part, dict) and part.get("text")
+            )
         for raw in re.findall(r"\{[\s\S]*\}", text or ""):
             try:
                 obj = json.loads(raw)
@@ -217,7 +243,14 @@ def _parse_tool_calls_from_openai_response(data: Dict[str, Any]) -> List[str]:
         pass
     return []
 
-async def _choose_actions_via_llm(client: TaskAppClient, provider: str, model: str, observation: Dict[str, Any], history: List[Dict[str, Any]]) -> List[str]:
+
+async def _choose_actions_via_llm(
+    client: TaskAppClient,
+    provider: str,
+    model: str,
+    observation: Dict[str, Any],
+    history: List[Dict[str, Any]],
+) -> List[str]:
     messages = _build_messages_from_observation(observation, history)
     payload: Dict[str, Any] = {
         "model": model,
@@ -245,25 +278,31 @@ async def _choose_actions_via_llm(client: TaskAppClient, provider: str, model: s
     actions = _parse_tool_calls_from_openai_response(data)
     return actions or []
 
+
 def _expand_actions_to_tool_calls(actions: List[str]) -> List[Dict[str, Any]]:
     out: List[Dict[str, Any]] = []
     for a in actions[:5]:
         out.append({"tool": "interact", "args": {"action": a}})
     return out
 
+
 def _detect_provider(model: str) -> str:
     m = (model or "").lower()
     if "qwen/qwen3-32b" in m or "qwen-2.5-" in m or m.startswith("groq:"):
         return "groq"
     return "vllm"
 
-def _rollout_inference_url_from_cfg(cfg: Dict[str, Any], default_vllm: Optional[str]) -> Optional[str]:
+
+def _rollout_inference_url_from_cfg(
+    cfg: Dict[str, Any], default_vllm: Optional[str]
+) -> Optional[str]:
     # Prefer explicit inference_url in TOML; else fall back to discovered vLLM base
     url = cfg.get("inference_url")
     if isinstance(url, str) and url:
         return url
     return default_vllm
 
+
 async def eval_episode(client: TaskAppClient, seed: int) -> Dict[str, Any]:
     env_name = "CrafterClassic"
     history: List[Dict[str, Any]] = []
@@ -271,7 +310,10 @@ async def eval_episode(client: TaskAppClient, seed: int) -> Dict[str, Any]:
     turns = 0
 
     # Initialize environment
-    init_cfg: Dict[str, Any] = {"seed": seed, "world_config": {"difficulty": os.getenv("DIFFICULTY", "easy")}}
+    init_cfg: Dict[str, Any] = {
+        "seed": seed,
+        "world_config": {"difficulty": os.getenv("DIFFICULTY", "easy")},
+    }
     created = await client.initialize(env_name, init_cfg)
     env_id = created.get("env_id")
     if not isinstance(env_id, str) or not env_id:
@@ -285,7 +327,9 @@ async def eval_episode(client: TaskAppClient, seed: int) -> Dict[str, Any]:
     try:
         while turns < MAX_TURNS and not done:
             # Ask LLM for actions; fallback to a simple exploratory pair
-            chosen_actions = await _choose_actions_via_llm(client, provider, MODEL, observation, history)
+            chosen_actions = await _choose_actions_via_llm(
+                client, provider, MODEL, observation, history
+            )
             if not chosen_actions:
                 chosen_actions = ["move_up", "do"]
             tool_calls = _expand_actions_to_tool_calls(chosen_actions)
@@ -306,6 +350,7 @@ async def eval_episode(client: TaskAppClient, seed: int) -> Dict[str, Any]:
 
     return {"seed": seed, "turns": turns, "achievements": sorted(achievements)}
 
+
 async def main() -> None:
     # Best-effort load local .env if present (ensures ENVIRONMENT_API_KEY for rollout)
     try:
@@ -322,9 +367,13 @@ async def main() -> None:
     except Exception:
         pass
 
-    parser = argparse.ArgumentParser(description="Baseline eval against task app with optional TOML config")
+    parser = argparse.ArgumentParser(
+        description="Baseline eval against task app with optional TOML config"
+    )
     parser.add_argument("--toml", help="Path to TOML config file", default=None)
-    parser.add_argument("--use-rollout", action="store_true", help="Use server-side rollout endpoint for eval")
+    parser.add_argument(
+        "--use-rollout", action="store_true", help="Use server-side rollout endpoint for eval"
+    )
     args = parser.parse_args()
 
     global TASK_APP_URL, MODEL, NUM_EPISODES, MAX_TURNS, CONCURRENCY
@@ -346,10 +395,14 @@ async def main() -> None:
             if env_url:
                 TASK_APP_URL = env_url.rstrip("/")
             else:
-                raise RuntimeError("TASK_APP_URL is a placeholder. Set task_app_url in TOML or export TASK_APP_URL.")
+                raise RuntimeError(
+                    "TASK_APP_URL is a placeholder. Set task_app_url in TOML or export TASK_APP_URL."
+                )
 
     print(f"Task App: {TASK_APP_URL}")
-    print(f"Model: {MODEL} Episodes: {NUM_EPISODES} Max turns: {MAX_TURNS} Concurrency: {CONCURRENCY}")
+    print(
+        f"Model: {MODEL} Episodes: {NUM_EPISODES} Max turns: {MAX_TURNS} Concurrency: {CONCURRENCY}"
+    )
     sem = asyncio.Semaphore(max(CONCURRENCY, 1))
     async with TaskAppClient(TASK_APP_URL, api_key=os.getenv("ENVIRONMENT_API_KEY")) as client:
         if args.use_rollout:
@@ -359,6 +412,7 @@ async def main() -> None:
             inf_url = _rollout_inference_url_from_cfg(cfg, default_vllm)
             if not inf_url:
                 raise RuntimeError("Could not resolve inference URL for rollout")
+
             async def _run(seed: int):
                 async with sem:
                     try:
@@ -368,7 +422,14 @@ async def main() -> None:
                             "model": cfg.get("model", MODEL),
                             "inference_url": inf_url,
                         }
-                        for k in ("max_tokens", "temperature", "top_p", "thinking_mode", "thinking_budget", "use_tools"):
+                        for k in (
+                            "max_tokens",
+                            "temperature",
+                            "top_p",
+                            "thinking_mode",
+                            "thinking_budget",
+                            "use_tools",
+                        ):
                             if k in cfg and cfg.get(k) is not None:
                                 policy_cfg[k] = cfg.get(k)
 
@@ -385,8 +446,16 @@ async def main() -> None:
                         ach = []
                         try:
                             trajs = r.get("trajectories") or []
-                            final_obs = (trajs[0].get("final") or {}).get("observation") if trajs and isinstance(trajs[0], dict) else None
-                            ach_map = (final_obs or {}).get("achievements_status") if isinstance(final_obs, dict) else None
+                            final_obs = (
+                                (trajs[0].get("final") or {}).get("observation")
+                                if trajs and isinstance(trajs[0], dict)
+                                else None
+                            )
+                            ach_map = (
+                                (final_obs or {}).get("achievements_status")
+                                if isinstance(final_obs, dict)
+                                else None
+                            )
                             if isinstance(ach_map, dict):
                                 ach = sorted([k for k, v in ach_map.items() if v])
                         except Exception:
@@ -401,7 +470,11 @@ async def main() -> None:
                         return {"seed": seed, "turns": length, "achievements": ach}
                     except Exception as e:
                         return {"seed": seed, "turns": 0, "achievements": [], "error": str(e)}
-            results = await asyncio.gather(*[asyncio.create_task(_run(i)) for i in range(1, NUM_EPISODES + 1)], return_exceptions=False)
+
+            results = await asyncio.gather(
+                *[asyncio.create_task(_run(i)) for i in range(1, NUM_EPISODES + 1)],
+                return_exceptions=False,
+            )
             # Aggregate summary
             counts = [len(r.get("achievements") or []) for r in results if isinstance(r, dict)]
             turns = [int(r.get("turns") or 0) for r in results if isinstance(r, dict)]
@@ -424,11 +497,16 @@ async def main() -> None:
             }
             print(json.dumps(summary, indent=2))
         else:
+
             async def _run(seed: int):
                 async with sem:
                     return await eval_episode(client, seed)
-            results = await asyncio.gather(*[asyncio.create_task(_run(i)) for i in range(1, NUM_EPISODES + 1)])
+
+            results = await asyncio.gather(
+                *[asyncio.create_task(_run(i)) for i in range(1, NUM_EPISODES + 1)]
+            )
             print(json.dumps({"episodes": results}, indent=2))
 
+
 if __name__ == "__main__":
     asyncio.run(main())