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

examples/warming_up_to_rl/run_local_rollout_parallel.py

@@ -31,12 +31,17 @@ def build_rollout_request(
     run_id: str,
     model: str,
     inference_url: str,
+    inference_api_key: str,
     ops: list[str],
     extra_headers: dict[str, str] | None = None,
     trace_format: str = "compact",
     return_trace: bool = False,
 ) -> RolloutRequest:
-    policy_config = {"model": model, "inference_url": inference_url}
+    policy_config = {
+        "model": model,
+        "inference_url": inference_url,
+        "api_key": inference_api_key,
+    }
     if extra_headers:
         policy_config["extra_headers"] = extra_headers
     record_cfg = RolloutRecordConfig(
@@ -123,7 +128,9 @@ def analyse_rollout_response(response: Any) -> dict[str, Any]:
         if isinstance(final_list, list):
             final_achievements = [str(item) for item in final_list]
 
-    decision_rewards = trace_payload.get("decision_rewards") if isinstance(trace_payload, dict) else []
+    decision_rewards = (
+        trace_payload.get("decision_rewards") if isinstance(trace_payload, dict) else []
+    )
     trace_all: list[str] = []
     if isinstance(decision_rewards, list):
         for item in decision_rewards:
@@ -180,7 +187,9 @@ def summarise_runs(run_summaries: list[dict[str, Any]]) -> dict[str, Any]:
     return stats
 
 
-def print_summary(stats: dict[str, Any], *, run_details: list[dict[str, Any]], total_runs: int) -> None:
+def print_summary(
+    stats: dict[str, Any], *, run_details: list[dict[str, Any]], total_runs: int
+) -> None:
     if not stats:
         print("No successful rollouts to summarise.")
         return
@@ -234,7 +243,22 @@ async def execute_rollouts(args: argparse.Namespace) -> None:
 
     api_key = args.api_key or os.getenv("ENVIRONMENT_API_KEY")
     if not api_key:
-        raise RuntimeError("Missing --api-key or ENVIRONMENT_API_KEY")
+        import sys
+
+        print("Please enter your RL Environment API key:", file=sys.stderr, flush=True)
+        api_key = input("> ").strip()
+        if not api_key:
+            raise RuntimeError("RL Environment API key is required")
+
+    # Prompt for Groq API key if not set
+    groq_api_key = os.getenv("GROQ_API_KEY")
+    if not groq_api_key:
+        import sys
+
+        print("Please enter your Groq API key:", file=sys.stderr, flush=True)
+        groq_api_key = input("> ").strip()
+        if not groq_api_key:
+            raise RuntimeError("Groq API key is required")
 
     synth_key = os.getenv("SYNTH_API_KEY")
     extra_headers: dict[str, str] | None = None
@@ -252,29 +276,41 @@ async def execute_rollouts(args: argparse.Namespace) -> None:
 
     ops = build_ops(args.max_llm_calls, args.ops)
 
+    print(f"\n🚀 Starting {args.count} rollouts with {args.parallel} parallel workers...")
+    print(f"📊 Each rollout: {len(ops)} ops ({args.max_llm_calls} LLM calls)\n")
+
     async with TaskAppClient(args.base_url, api_key=api_key, timeout=args.timeout) as client:
+
         async def run_single(index: int) -> dict[str, Any]:
             run_id = f"{args.run_id}-{index:03d}"
             seed = args.seed + index * args.seed_stride
+            print(f"\n▶️  [{index + 1}/{args.count}] Starting rollout {run_id} (seed={seed})...")
+
             request = build_rollout_request(
                 seed=seed,
                 run_id=run_id,
                 model=args.model,
                 inference_url=args.inference_url,
+                inference_api_key=groq_api_key,
                 ops=ops,
                 extra_headers=extra_headers,
                 trace_format=args.trace_format,
                 return_trace=True,
             )
             if args.max_policy_tokens is not None:
-                request.policy.config.update({
-                    "max_completion_tokens": args.max_policy_tokens,
-                    "max_tokens": args.max_policy_tokens,
-                })
+                request.policy.config.update(
+                    {
+                        "max_completion_tokens": args.max_policy_tokens,
+                        "max_tokens": args.max_policy_tokens,
+                    }
+                )
 
             try:
                 response = await client.rollout(request)
                 summary = analyse_rollout_response(response)
+                print(
+                    f"\n✅ [{index + 1}/{args.count}] Completed {run_id} (outcome={summary.get('outcome_score', 'N/A')})"
+                )
                 return {
                     "ok": True,
                     "run_id": run_id,
@@ -283,6 +319,7 @@ async def execute_rollouts(args: argparse.Namespace) -> None:
                     "summary": summary,
                 }
             except Exception as exc:  # pragma: no cover - surface errors
+                print(f"\n❌ [{index + 1}/{args.count}] Failed {run_id}: {exc}")
                 return {
                     "ok": False,
                     "run_id": run_id,
@@ -302,6 +339,7 @@ async def execute_rollouts(args: argparse.Namespace) -> None:
     successes = [item for item in results if item.get("ok")]
     failures = [item for item in results if not item.get("ok")]
 
+    print(f"\n{'=' * 100}\n")
     stats = summarise_runs([item["summary"] for item in successes])
     print_summary(stats, run_details=successes, total_runs=args.count)
 
@@ -317,17 +355,43 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--base-url", default="http://localhost:8001", help="Task app base URL")
     parser.add_argument("--api-key", help="Environment API key (or set via --env-file)")
     parser.add_argument("--env-file", help="Path to .env file providing API keys")
-    parser.add_argument("--model", default="gpt-4o-mini", help="Model identifier for the Crafter policy")
-    parser.add_argument("--inference-url", default="https://api.openai.com", help="Inference base URL for the policy")
+    parser.add_argument(
+        "--model", default="gpt-4o-mini", help="Model identifier for the Crafter policy"
+    )
+    parser.add_argument(
+        "--inference-url",
+        default="https://api.openai.com",
+        help="Inference base URL for the policy",
+    )
     parser.add_argument("--seed", type=int, default=42, help="Base seed for the first rollout")
-    parser.add_argument("--seed-stride", type=int, default=1, help="Increment applied to the seed for each rollout")
-    parser.add_argument("--count", type=int, default=20, help="Number of rollout trajectories to execute")
+    parser.add_argument(
+        "--seed-stride", type=int, default=1, help="Increment applied to the seed for each rollout"
+    )
+    parser.add_argument(
+        "--count", type=int, default=20, help="Number of rollout trajectories to execute"
+    )
     parser.add_argument("--parallel", type=int, default=4, help="Maximum concurrent rollouts")
     parser.add_argument("--ops", help="Comma-separated rollout ops (advanced override)")
-    parser.add_argument("--max-llm-calls", type=int, default=20, help="Number of agent/env pairs per rollout when --ops not provided")
-    parser.add_argument("--max-policy-tokens", type=int, help="Optional per-call token limit forwarded to the policy config")
-    parser.add_argument("--timeout", type=float, default=600.0, help="HTTP timeout (seconds) for task app requests")
-    parser.add_argument("--trace-format", default="compact", choices=["compact", "full"], help="Trace format requested from the task app")
+    parser.add_argument(
+        "--max-llm-calls",
+        type=int,
+        default=20,
+        help="Number of agent/env pairs per rollout when --ops not provided",
+    )
+    parser.add_argument(
+        "--max-policy-tokens",
+        type=int,
+        help="Optional per-call token limit forwarded to the policy config",
+    )
+    parser.add_argument(
+        "--timeout", type=float, default=600.0, help="HTTP timeout (seconds) for task app requests"
+    )
+    parser.add_argument(
+        "--trace-format",
+        default="compact",
+        choices=["compact", "full"],
+        help="Trace format requested from the task app",
+    )
     parser.add_argument("--run-id", default="batch-demo", help="Run ID prefix for rollouts")
     parser.add_argument("--verbose", action="store_true", help="Print resolved configuration")
     return parser.parse_args()

examples/warming_up_to_rl/run_local_rollout_traced.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import argparse
 import asyncio
 import json
+import os
 from pathlib import Path
 from typing import Any
 
@@ -29,6 +30,7 @@ def build_rollout_request(
     run_id: str,
     model: str,
     inference_url: str,
+    inference_api_key: str,
     ops: list[str],
     return_trace: bool,
     trace_format: str,
@@ -37,6 +39,7 @@ def build_rollout_request(
     policy_config = {
         "model": model,
         "inference_url": inference_url,
+        "api_key": inference_api_key,
     }
     if max_policy_tokens is not None:
         policy_config.update(
@@ -64,7 +67,11 @@ def build_rollout_request(
 
 
 def summarise_rollout(response: Any) -> dict[str, Any]:
-    metrics = response.metrics.model_dump() if hasattr(response, "metrics") else response.get("metrics", {})
+    metrics = (
+        response.metrics.model_dump()
+        if hasattr(response, "metrics")
+        else response.get("metrics", {})
+    )
     return {
         "run_id": getattr(response, "run_id", None) or response.get("run_id"),
         "num_episodes": metrics.get("num_episodes"),
@@ -83,17 +90,25 @@ def summarise_trace(trace: Any) -> dict[str, Any]:
 
     format_hint = "compact" if "events_count" in trace or "lm_calls" in trace else "full"
     events_count = trace.get("events_count")
-    if events_count is None and "event_history" in trace and isinstance(trace["event_history"], list):
+    if (
+        events_count is None
+        and "event_history" in trace
+        and isinstance(trace["event_history"], list)
+    ):
         events_count = len(trace["event_history"])
     messages_count = trace.get("messages_count")
-    if messages_count is None and "markov_blanket_message_history" in trace and isinstance(
-        trace["markov_blanket_message_history"], list
+    if (
+        messages_count is None
+        and "markov_blanket_message_history" in trace
+        and isinstance(trace["markov_blanket_message_history"], list)
     ):
         messages_count = len(trace["markov_blanket_message_history"])
 
     metadata = trace.get("metadata") if isinstance(trace.get("metadata"), dict) else {}
     lm_calls = trace.get("lm_calls") if isinstance(trace.get("lm_calls"), list) else []
-    decision_rewards = trace.get("decision_rewards") if isinstance(trace.get("decision_rewards"), list) else []
+    decision_rewards = (
+        trace.get("decision_rewards") if isinstance(trace.get("decision_rewards"), list) else []
+    )
 
     return {
         "session_id": trace.get("session_id"),
@@ -215,11 +230,13 @@ def print_reward_summary(
     if decision_rewards:
         print("  Decision rewards:")
         for entry in decision_rewards:
-            turn = entry.get('turn')
-            ach_delta = entry.get('ach_delta')
-            unique_delta = entry.get('unique_delta')
-            achievements = entry.get('achievements') or []
-            print(f"    turn={turn}, ach_delta={ach_delta}, unique_delta={unique_delta}, achievements={achievements}")
+            turn = entry.get("turn")
+            ach_delta = entry.get("ach_delta")
+            unique_delta = entry.get("unique_delta")
+            achievements = entry.get("achievements") or []
+            print(
+                f"    turn={turn}, ach_delta={ach_delta}, unique_delta={unique_delta}, achievements={achievements}"
+            )
     else:
         print("  Decision rewards: none recorded")
 
@@ -242,16 +259,40 @@ def print_reward_summary(
 
 
 async def main() -> None:
+    # Load .env file from current directory if it exists
+    env_file = Path.cwd() / ".env"
+    if env_file.exists():
+        from dotenv import load_dotenv
+
+        load_dotenv(env_file)
+
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--base-url", default="http://localhost:8010", help="Task app base URL")
-    parser.add_argument("--api-key", required=True, help="Environment API key")
+    parser.add_argument("--base-url", default="http://localhost:8001", help="Task app base URL")
+    parser.add_argument("--api-key", help="RL Environment API key (will prompt if not provided)")
+    parser.add_argument(
+        "--inference-api-key", help="Inference provider API key (will prompt if not provided)"
+    )
     parser.add_argument("--seed", type=int, default=42, help="Environment seed")
     parser.add_argument("--run-id", default="local-trace", help="Run identifier")
     parser.add_argument("--model", default="gpt-4o-mini", help="OpenAI-compatible model id")
-    parser.add_argument("--inference-url", default="https://api.openai.com", help="Inference base URL (OpenAI/Groq)")
-    parser.add_argument("--ops", help="Comma-separated rollout ops (fallback: alternating agent/env)")
-    parser.add_argument("--max-llm-calls", type=int, default=1, help="Number of agent/env pairs when --ops not supplied")
-    parser.add_argument("--max-policy-tokens", type=int, default=None, help="Optional max token budget forwarded to policy")
+    parser.add_argument(
+        "--inference-url", default="https://api.openai.com", help="Inference base URL (OpenAI/Groq)"
+    )
+    parser.add_argument(
+        "--ops", help="Comma-separated rollout ops (fallback: alternating agent/env)"
+    )
+    parser.add_argument(
+        "--max-llm-calls",
+        type=int,
+        default=1,
+        help="Number of agent/env pairs when --ops not supplied",
+    )
+    parser.add_argument(
+        "--max-policy-tokens",
+        type=int,
+        default=None,
+        help="Optional max token budget forwarded to policy",
+    )
     parser.add_argument(
         "--trace-format",
         choices=["compact", "full"],
@@ -286,10 +327,69 @@ async def main() -> None:
     )
     args = parser.parse_args()
 
+    # Prompt for required parameters if not provided
+    base_url = args.base_url
+    if args.base_url == "http://localhost:8001":
+        print("\nTask app configuration:")
+        base_url_input = input(f"Task app base URL [http://localhost:8001]: ").strip()
+        base_url = base_url_input if base_url_input else "http://localhost:8001"
+
+    api_key = args.api_key or os.getenv("ENVIRONMENT_API_KEY")
+    if not api_key:
+        api_key = input("RL Environment API key (from ENVIRONMENT_API_KEY): ").strip()
+        if not api_key:
+            parser.error("RL Environment API key is required")
+
+    # Use Groq by default
+    model = "llama-3.3-70b-versatile"
+    inference_url = "https://api.groq.com/openai"
+
+    print("\nInference configuration (Groq):")
+    inference_api_key = args.inference_api_key or os.getenv("GROQ_API_KEY")
+    if not inference_api_key:
+        inference_api_key = input("Groq API key: ").strip()
+        if not inference_api_key:
+            parser.error("Groq API key is required")
+
+        # Save to .env for future use
+        env_path = Path.cwd() / ".env"
+        try:
+            # Read existing .env
+            existing_lines = []
+            if env_path.exists():
+                existing_lines = env_path.read_text().splitlines()
+
+            # Check if GROQ_API_KEY already exists
+            key_exists = any(line.strip().startswith("GROQ_API_KEY=") for line in existing_lines)
+
+            if not key_exists:
+                # Append to .env
+                with open(env_path, "a") as f:
+                    if existing_lines and not existing_lines[-1].strip():
+                        # File exists and last line is not empty
+                        pass
+                    elif existing_lines:
+                        # Add newline before appending
+                        f.write("\n")
+                    f.write(f"GROQ_API_KEY={inference_api_key}\n")
+                print(f"[INFO] Saved GROQ_API_KEY to {env_path}")
+        except Exception as e:
+            print(f"[WARN] Could not save GROQ_API_KEY to .env: {e}")
+
+    print("\nRollout configuration:")
+    max_llm_calls = args.max_llm_calls
+    if args.max_llm_calls == 1:
+        max_llm_calls_input = input(f"Max LLM calls [10]: ").strip()
+        max_llm_calls = int(max_llm_calls_input) if max_llm_calls_input else 10
+
+    # Override args with prompted values
+    args.base_url = base_url
+    args.max_llm_calls = max_llm_calls
+
     ops = ensure_ops(args.ops, args.max_llm_calls)
     return_trace = not args.no_trace
 
-    async with TaskAppClient(args.base_url, api_key=args.api_key, timeout=args.timeout) as client:
+    async with TaskAppClient(args.base_url, api_key=api_key, timeout=args.timeout) as client:
         try:
             print(f"Fetching task_info for seed {args.seed}…")
             task_info = await client.task_info(seeds=[args.seed])
@@ -302,8 +402,9 @@ async def main() -> None:
             request = build_rollout_request(
                 seed=args.seed,
                 run_id=args.run_id,
-                model=args.model,
-                inference_url=args.inference_url,
+                model=model,
+                inference_url=inference_url,
+                inference_api_key=inference_api_key,
                 ops=ops,
                 return_trace=return_trace,
                 trace_format=args.trace_format,
@@ -350,7 +451,11 @@ async def main() -> None:
                 "Tip: export TASKAPP_TRACING_ENABLED=1 and optionally TASKAPP_SFT_OUTPUT_DIR before running `uvx synth-ai serve …` to persist traces/SFT."
             )
         except httpx.HTTPStatusError as exc:
-            detail = exc.response.json() if exc.response.headers.get("content-type", "").startswith("application/json") else exc.response.text
+            detail = (
+                exc.response.json()
+                if exc.response.headers.get("content-type", "").startswith("application/json")
+                else exc.response.text
+            )
             print(f"HTTP error {exc.response.status_code}: {detail}", file=sys.stderr)
             if exc.response.status_code in (401, 503):
                 print(

examples/warming_up_to_rl/run_rl_and_save.py

@@ -11,6 +11,8 @@ from typing import Any, Dict
 import tomllib
 import requests
 
+from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
+
 
 def _load_toml(path: Path) -> Dict[str, Any]:
     if not path.exists():
@@ -21,11 +23,23 @@ def _load_toml(path: Path) -> Dict[str, Any]:
 
 
 def main() -> None:
-    p = argparse.ArgumentParser(description="Create clustered RL training job via backend RL endpoint")
-    p.add_argument("--backend", default=os.getenv("BACKEND_BASE_URL", "http://localhost:8000/api"))
+    p = argparse.ArgumentParser(
+        description="Create clustered RL training job via backend RL endpoint"
+    )
+    p.add_argument(
+        "--backend", default=os.getenv("BACKEND_BASE_URL", f"{PROD_BASE_URL_DEFAULT}/api")
+    )
     p.add_argument("--config", required=True, help="Path to RL TOML config")
-    p.add_argument("--task-url", default=os.getenv("TASK_APP_URL", ""), help="Override task service URL (or set TASK_APP_URL)")
-    p.add_argument("--idempotency", default=os.getenv("RL_IDEMPOTENCY_KEY", ""), help="Optional Idempotency-Key header value")
+    p.add_argument(
+        "--task-url",
+        default=os.getenv("TASK_APP_URL", ""),
+        help="Override task service URL (or set TASK_APP_URL)",
+    )
+    p.add_argument(
+        "--idempotency",
+        default=os.getenv("RL_IDEMPOTENCY_KEY", ""),
+        help="Optional Idempotency-Key header value",
+    )
     args = p.parse_args()
 
     cfg_path = Path(args.config).expanduser()
@@ -36,9 +50,16 @@ def main() -> None:
     # Resolve task app base URL for the job
     cli_task_url = (args.task_url or "").strip()
     env_task_url = (os.getenv("TASK_APP_URL") or "").strip()
-    task_url = cli_task_url or env_task_url or ((services.get("task_url") or "").strip() if isinstance(services, dict) else "")
+    task_url = (
+        cli_task_url
+        or env_task_url
+        or ((services.get("task_url") or "").strip() if isinstance(services, dict) else "")
+    )
     if not task_url:
-        print("Missing task service URL. Provide --task-url or set TASK_APP_URL or services.task_url in TOML", file=sys.stderr)
+        print(
+            "Missing task service URL. Provide --task-url or set TASK_APP_URL or services.task_url in TOML",
+            file=sys.stderr,
+        )
         sys.exit(2)
 
     # TOML-only model selection validation
@@ -46,7 +67,10 @@ def main() -> None:
     has_source = bool((model_cfg.get("source") or "").strip())
     has_base = bool((model_cfg.get("base") or "").strip())
     if has_source == has_base:
-        print("Model selection must specify exactly one of [model].source or [model].base in TOML", file=sys.stderr)
+        print(
+            "Model selection must specify exactly one of [model].source or [model].base in TOML",
+            file=sys.stderr,
+        )
         sys.exit(2)
 
     # Build create-job payload. Send full TOML under data.config, plus endpoint_base_url.

examples/warming_up_to_rl/run_rollout_remote.py

@@ -11,10 +11,17 @@ import sys
 
 import httpx
 
+
 def check_health(base_url: str, api_key: str) -> None:
     try:
-        resp = httpx.get(f"{base_url.rstrip('/')}/health", headers={"X-API-Key": api_key}, timeout=10.0)
-        data = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else resp.text
+        resp = httpx.get(
+            f"{base_url.rstrip('/')}/health", headers={"X-API-Key": api_key}, timeout=10.0
+        )
+        data = (
+            resp.json()
+            if resp.headers.get("content-type", "").startswith("application/json")
+            else resp.text
+        )
         if resp.status_code != 200:
             print(f"warning: /health returned {resp.status_code}: {data}")
         else:
@@ -22,6 +29,7 @@ def check_health(base_url: str, api_key: str) -> None:
     except Exception as exc:
         print(f"warning: failed to call /health: {exc}")
 
+
 from synth_ai.task import (
     RolloutEnvSpec,
     RolloutPolicySpec,
@@ -79,8 +87,14 @@ def summarise(response) -> dict[str, any]:
 
 async def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--base-url", default=None, help="Remote task app base URL (e.g., https://xyz.modal.run); defaults to TASK_APP_BASE_URL env")
-    parser.add_argument("--api-key", required=True, help="Environment API key for the remote task app")
+    parser.add_argument(
+        "--base-url",
+        default=None,
+        help="Remote task app base URL (e.g., https://xyz.modal.run); defaults to TASK_APP_BASE_URL env",
+    )
+    parser.add_argument(
+        "--api-key", required=True, help="Environment API key for the remote task app"
+    )
     parser.add_argument("--seed", type=int, default=42)
     parser.add_argument("--run-id", default="remote-demo")
     parser.add_argument("--model", default="gpt-4o-mini")
@@ -89,9 +103,9 @@ async def main() -> None:
     parser.add_argument("--max-policy-tokens", type=int, default=None)
     args = parser.parse_args()
 
-    base_url = args.base_url or os.getenv('TASK_APP_BASE_URL')
+    base_url = args.base_url or os.getenv("TASK_APP_BASE_URL")
     if not base_url:
-        parser.error('Missing --base-url (and TASK_APP_BASE_URL not set).')
+        parser.error("Missing --base-url (and TASK_APP_BASE_URL not set).")
 
     request = build_request(
         run_id=args.run_id,
@@ -114,14 +128,27 @@ async def main() -> None:
             print(json.dumps(summarise(response), indent=2))
             print(f"Ops executed: {request.ops}")
         except httpx.HTTPStatusError as exc:
-            detail = exc.response.json() if exc.response.headers.get("content-type", "").startswith("application/json") else exc.response.text
+            detail = (
+                exc.response.json()
+                if exc.response.headers.get("content-type", "").startswith("application/json")
+                else exc.response.text
+            )
             print(f"HTTP error {exc.response.status_code}: {detail}", file=sys.stderr)
             if exc.response.status_code in (401, 403):
-                print("Hint: check --api-key and ensure the remote deployment expects that value.", file=sys.stderr)
+                print(
+                    "Hint: check --api-key and ensure the remote deployment expects that value.",
+                    file=sys.stderr,
+                )
             if exc.response.status_code == 404:
-                print("Hint: verify the --base-url includes the correct path (should be the root of the task app).", file=sys.stderr)
+                print(
+                    "Hint: verify the --base-url includes the correct path (should be the root of the task app).",
+                    file=sys.stderr,
+                )
             if exc.response.status_code == 500:
-                print("Hint: remote rollout failed server-side; inspect the deployment logs (Modal dashboard/logs).", file=sys.stderr)
+                print(
+                    "Hint: remote rollout failed server-side; inspect the deployment logs (Modal dashboard/logs).",
+                    file=sys.stderr,
+                )
             raise