synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

examples/warming_up_to_rl/export_trace_sft.py

@@ -8,8 +8,9 @@ import json
 import sqlite3
 import sys
 from collections import Counter, defaultdict
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Set, Tuple
+from typing import Any
 
 Row = sqlite3.Row
 
@@ -23,7 +24,7 @@ def connect(db_path: Path) -> sqlite3.Connection:
 def _parse_json(value: Any) -> Any:
     if value is None:
         return None
-    if isinstance(value, (dict, list)):
+    if isinstance(value, dict | list):
         return value
     try:
         return json.loads(value)
@@ -31,7 +32,7 @@ def _parse_json(value: Any) -> Any:
         return None
 
 
-AchievementMap = dict[Tuple[str, int], dict[str, list[str]]]
+AchievementMap = dict[tuple[str, int], dict[str, list[str]]]
 
 
 def fetch_achievement_data(
@@ -116,7 +117,7 @@ def fetch_achievement_data(
         achievement_name_counts.update(achievement_set)
 
     achievement_size_counts: Counter = Counter()
-    for session_id, count in unique_counts_per_session.items():
+    for _session_id, count in unique_counts_per_session.items():
         achievement_size_counts[count] += 1
 
     return (
@@ -203,25 +204,71 @@ def parse_event_filters(specs: list[str] | None) -> list[tuple[str, float]]:
         if min_val_str:
             try:
                 min_val = float(min_val_str)
-            except ValueError:
+            except ValueError as e:
                 print(f"Invalid event reward specification '{spec}'", file=sys.stderr)
-                raise SystemExit(1)
+                raise SystemExit(1) from e
         filters.append((reward_type, min_val))
     return filters
 
 
-def _collect_text(parts: Iterable[dict[str, Any]] | None) -> str:
-    texts: list[str] = []
+def _collect_content(
+    parts: Iterable[dict[str, Any]] | None,
+) -> tuple[Any, bool]:
+    """Normalise multimodal content parts into OpenAI-style segments."""
+
     if not parts:
-        return ""
+        return "", False
+
+    segments: list[dict[str, Any]] = []
+    has_image = False
+
     for part in parts:
         if not isinstance(part, dict):
             continue
-        if part.get("type") == "text":
+        ptype = part.get("type")
+        if ptype == "text":
             text = part.get("text")
-            if isinstance(text, str) and text:
-                texts.append(text)
-    return "\n".join(texts)
+            if isinstance(text, str):
+                segments.append({"type": "text", "text": text})
+        elif ptype == "image":
+            uri = part.get("uri")
+            mime_type = part.get("mime_type") or "image/png"
+            data_url = None
+            if isinstance(uri, str) and uri.startswith("data:"):
+                data_url = uri
+            else:
+                source = part.get("data") or part.get("source")
+                if isinstance(source, dict):
+                    base64_data = source.get("data")
+                    media_type = source.get("media_type") or mime_type
+                    if isinstance(base64_data, str) and base64_data:
+                        data_url = f"data:{media_type};base64,{base64_data}"
+            if data_url:
+                has_image = True
+                segments.append({"type": "image_url", "image_url": {"url": data_url}})
+        elif ptype == "image_url":
+            image_url = part.get("image_url", {})
+            if isinstance(image_url, dict):
+                url = image_url.get("url")
+                if isinstance(url, str) and url:
+                    has_image = True
+                    segments.append({"type": "image_url", "image_url": {"url": url}})
+
+    if not segments:
+        return "", False
+    if not has_image and len(segments) == 1 and segments[0]["type"] == "text":
+        return segments[0]["text"], False
+    return segments, has_image
+
+
+def _normalise_output_content(content: Any) -> tuple[Any, bool]:
+    if isinstance(content, list):
+        return _collect_content(content)
+    if isinstance(content, str):
+        return content, False
+    if content is None:
+        return "", False
+    return str(content), False
 
 
 def _normalise_tool_calls(tool_calls: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
@@ -233,7 +280,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
@@ -249,7 +298,7 @@ def _normalise_tool_calls(tool_calls: list[dict[str, Any]] | None) -> list[dict[
                     except Exception:
                         args = raw
 
-        if isinstance(args, (dict, list)):
+        if isinstance(args, dict | list):
             args_str = json.dumps(args, ensure_ascii=False)
         elif isinstance(args, str):
             args_str = args
@@ -277,7 +326,7 @@ def _normalise_tool_calls(tool_calls: list[dict[str, Any]] | None) -> list[dict[
 def build_sft_dataset(
     conn: sqlite3.Connection,
     achievements_map: AchievementMap,
-    sessions_filter: Set[str],
+    sessions_filter: set[str],
     *,
     allowed_models: set[str] | None = None,
     limit: int | None = None,
@@ -327,14 +376,18 @@ def build_sft_dataset(
 
         for record in call_records:
             messages: list[dict[str, Any]] = []
+            input_has_image = False
             for message in record.get("input_messages", []):
                 role = message.get("role", "unknown")
-                content = _collect_text(message.get("parts"))
-                if not content:
+                content, has_image = _collect_content(message.get("parts"))
+                if (content == "" or content is None) and not has_image:
                     continue
+                if has_image and role == "user":
+                    input_has_image = True
                 messages.append({"role": role, "content": content})
 
-            assistant_content = ""
+            assistant_content_value: Any = ""
+            assistant_has_image = False
             assistant_tool_calls: list[dict[str, Any]] = []
 
             output_text = record.get("output_text")
@@ -349,17 +402,23 @@ def build_sft_dataset(
                 choices = parsed_response.get("choices") or []
                 if choices:
                     message = choices[0].get("message") or {}
-                    assistant_content = message.get("content") or ""
+                    assistant_content_value, assistant_has_image = _normalise_output_content(
+                        message.get("content")
+                    )
                     assistant_tool_calls = _normalise_tool_calls(message.get("tool_calls"))
 
             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_value,
+            }
             if assistant_tool_calls:
                 assistant_message["tool_calls"] = assistant_tool_calls
 
-            if assistant_message.get("content") == "" and not assistant_message.get("tool_calls"):
+            content_empty = assistant_message.get("content") in ("", None)
+            if content_empty and not assistant_message.get("tool_calls"):
                 continue
 
             messages.append(assistant_message)
@@ -380,6 +439,9 @@ def build_sft_dataset(
                     "turned_true": achievements.get("all", []),
                     "cumulative_unique": cumulative_unique[session_id],
                 },
+                "user_has_image": input_has_image,
+                "assistant_has_image": assistant_has_image,
+                "has_image": input_has_image or assistant_has_image,
             }
 
             dataset.append({"messages": messages, "metadata": metadata})
@@ -426,27 +488,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 +664,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 +702,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 +712,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

@@ -1,7 +1,7 @@
-from __future__ import annotations
-
 """Quick smoke test that drives a rollout through the Groq proxy-backed Crafter Task App."""
 
+from __future__ import annotations
+
 import argparse
 import asyncio
 import os
@@ -29,8 +29,8 @@ def _build_policy_payload(seed: int, model: str) -> dict[str, Any]:
             {
                 "role": "user",
                 "content": (
-                    "Environment seed {seed}. Plan initial survival/crafting steps and then call interact with concrete actions."
-                ).format(seed=seed),
+                    f"Environment seed {seed}. Plan initial survival/crafting steps and then call interact with concrete actions."
+                ),
             },
         ],
     }
@@ -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

@@ -8,11 +8,10 @@ import subprocess
 import sys
 import tempfile
 from pathlib import Path
-from typing import Dict, Tuple
 
 
-def load_env_file(path: Path) -> Dict[str, str]:
-    env: Dict[str, str] = {}
+def load_env_file(path: Path) -> dict[str, str]:
+    env: dict[str, str] = {}
     if not path.exists():
         raise FileNotFoundError(f".env not found at {path}")
     for line in path.read_text(encoding="utf-8").splitlines():
@@ -24,7 +23,7 @@ def load_env_file(path: Path) -> Dict[str, str]:
     return env
 
 
-def write_temp_env(kv: Dict[str, str]) -> Path:
+def write_temp_env(kv: dict[str, str]) -> Path:
     fd, p = tempfile.mkstemp(prefix="modal_secret_", suffix=".env")
     path = Path(p)
     with os.fdopen(fd, "w", encoding="utf-8") as fh:
@@ -33,22 +32,27 @@ def write_temp_env(kv: Dict[str, str]) -> Path:
     return path
 
 
-def run(cmd: str) -> Tuple[int, str]:
-    proc = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+def run(cmd: str) -> tuple[int, str]:
+    proc = subprocess.run(
+        cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+    )
     return proc.returncode, proc.stdout
 
 
-def ensure_secret(secret_name: str, kv: Dict[str, str]) -> None:
+def ensure_secret(secret_name: str, kv: dict[str, str]) -> None:
     if not kv:
         print(f"[skip] {secret_name}: no values provided")
         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]:
+    def _create() -> tuple[int, str]:
         return run(f"modal secret create {shlex.quote(secret_name)} {kv_args}")
-    def _delete() -> Tuple[int, str]:
+
+    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,22 +74,17 @@ 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))
 
     # Secrets used by the task app
-    env_secret = {
-        k: v
-        for k, v in {
-            "ENVIRONMENT_API_KEY": env.get("ENVIRONMENT_API_KEY", ""),
-            "dev_environment_api_key": env.get("ENVIRONMENT_API_KEY", ""),
-        }.items()
-        if v
-    }
-
     groq_secret = {
         k: v
         for k, v in {
@@ -105,9 +104,16 @@ 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 {}
-
-    ensure_secret("crafter-environment-sdk", env_secret)
+    synth_secret = (
+        {"SYNTH_API_KEY": env.get("SYNTH_API_KEY", "")} if env.get("SYNTH_API_KEY") else {}
+    )
+
+    env_key = env.get("ENVIRONMENT_API_KEY", "")
+    if env_key:
+        print(
+            "Skipping Modal secret 'crafter-environment-sdk'; the task app now expects "
+            "ENVIRONMENT_API_KEY via --env-file so the CLI-minted value stays in sync."
+        )
     ensure_secret("groq-api-key", groq_secret)
     ensure_secret("openai-api-key", openai_secret)
     if synth_secret:
@@ -123,5 +129,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