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

examples/finetuning_old/_backup_synth_qwen/readme.md

@@ -0,0 +1,49 @@
+### Quickstart (Crafter) with config.toml
+
+All defaults are in `examples/finetuning/synth_qwen/config.toml`. Place your API keys in `.env`.
+
+1) Generate traces (v3 tracing)
+```bash
+set -a; source .env 2>/dev/null || true; set +a
+uvpm examples.finetuning.synth_qwen.run_crafter_qwen4b
+```
+
+2) Filter traces → SFT JSONL
+```bash
+uvpm examples.finetuning.synth_qwen.filter_traces_achievements
+```
+
+3) Finetune via learning service (SFT)
+```bash
+set -a; source .env 2>/dev/null || true; set +a
+uvpm examples.finetuning.synth_qwen.sft_kickoff
+```
+
+4) Evaluate the fine-tuned model in Crafter
+```bash
+set -a; source .env 2>/dev/null || true; set +a
+CRAFTER_MODEL="ft:...your-returned-id..." uvpm examples.finetuning.synth_qwen.run_crafter_qwen4b
+```
+
+Notes:
+- If you see a 401, ensure your `.env` contains a valid production `SYNTH_API_KEY` or export it inline.
+- Traces are stored in `traces/v3/synth_ai.db` (sqld); the filter derives the correct internal data file.
+
+
+### Interactive Demo
+
+Use the interactive script to walk through rollouts → filtering → SFT → optional rollout of the fine-tuned model.
+
+```bash
+examples/finetuning/synth_qwen/run_demo.sh
+```
+
+What it does:
+- Prompts for rollout settings (model, episodes, max steps, difficulty, think).
+- Prompts for filter settings (required achievements, model restriction, min reward, max cost/tokens, output path).
+- Starts the SFT job and captures the returned fine-tuned model id.
+- Asks you to confirm before rolling out the fine-tuned model.
+- API key handling:
+  - If a `SYNTH_API_KEY` is detected, you’re asked to confirm using it.
+  - If not set, you can choose `SYNTH_API_KEY_PROD` (if present) or securely enter a key.
+  - `OPENAI_API_KEY` is set to the same value if missing to prevent 401s.

examples/finetuning_old/_backup_synth_qwen/run_crafter_qwen4b.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Run Crafter-Classic evaluation (v3 tracing) on Synth’s Qwen 4B model.
+
+This forwards flags into the canonical `test_crafter_react_agent_lm_synth.py`
+runner that already handles v3 tracing, warm-up, and reporting.
+
+Environment variables:
+- CRAFTER_MODEL (default: Qwen/Qwen3-4B-Instruct-2507)
+- CRAFTER_EPISODES (default: 10)
+- CRAFTER_MAX_STEPS (default: 30)
+- CRAFTER_DIFFICULTY (default: easy)
+- CRAFTER_THINK (default: 0 -> use --no-think)
+
+It also sets a few runner-specific env flags to enforce short outputs and a single tool call.
+"""
+
+import asyncio
+import os
+import sys
+import tomllib
+
+# from synth_ai.environments.examples.crafter_classic.agent_demos.crafter_modal_ft import (
+#     test_crafter_react_agent_lm_synth as runner,
+# )
+from examples.finetuning.synth_qwen import (
+    react_agent_lm as runner,
+)
+from synth_ai.config.base_url import (
+    PROD_BASE_URL_DEFAULT,
+    get_learning_v2_base_url,
+)
+
+# Force prod by default for this runner unless explicitly overridden
+_force_prod = os.getenv("CRAFTER_FORCE_PROD", "1").lower() in ("1", "true", "yes", "on")
+if _force_prod:
+    # Sanitize implicit local/dev overrides
+    os.environ.pop("SYNTH_LOCAL_BASE_URL", None)
+    os.environ.pop("SYNTH_DEV_BASE_URL", None)
+    # If caller hasn't explicitly set LEARNING_V2_BASE_URL, lock to prod default
+    if "LEARNING_V2_BASE_URL" not in os.environ:
+        os.environ["LEARNING_V2_BASE_URL"] = PROD_BASE_URL_DEFAULT
+
+# Resolve base URL from shared config (honors LEARNING_V2_BASE_URL and sanitized overrides)
+os.environ["SYNTH_BASE_URL"] = get_learning_v2_base_url()
+
+print(f"🔧 Using Synth base URL = {os.environ.get('SYNTH_BASE_URL')}")
+
+cfg_path = os.getenv("CRAFTER_CONFIG", "examples/finetuning/synth_qwen/config.toml")
+cfg = {}
+if os.path.exists(cfg_path):
+    with open(cfg_path, "rb") as f:
+        cfg = tomllib.load(f)
+else:
+    cfg = {"rollouts": {}}
+rcfg = cfg.get("rollouts", {})
+
+MODEL_ID = os.getenv("CRAFTER_MODEL", rcfg.get("model", "Qwen/Qwen3-4B-Instruct-2507"))
+EPISODES = os.getenv("CRAFTER_EPISODES", str(rcfg.get("episodes", 10)))
+MAX_STEPS = os.getenv("CRAFTER_MAX_STEPS", str(rcfg.get("max_steps", 30)))
+DIFFICULTY = os.getenv("CRAFTER_DIFFICULTY", rcfg.get("difficulty", "easy"))
+
+
+async def main() -> None:
+    think_env = os.getenv("CRAFTER_THINK", "0").lower()
+    enable_think = think_env in ("1", "true", "yes", "on")
+    think_flag = "--think" if enable_think else "--no-think"
+
+    # Tighten prompts and enforce tool calling like the tests do
+    os.environ["CRAFTER_STOP_AFTER_TOOL_CALLS"] = "1"
+    os.environ["SYNTH_OPENAI_DEBUG"] = "0"
+    os.environ["CRAFTER_MAX_TOKENS"] = os.environ.get(
+        "CRAFTER_MAX_TOKENS", str(rcfg.get("max_tokens", 2048))
+    )
+    os.environ["CRAFTER_TOOL_CHOICE"] = os.environ.get(
+        "CRAFTER_TOOL_CHOICE", rcfg.get("tool_choice", "required")
+    )
+    os.environ["CRAFTER_TEMPERATURE"] = os.environ.get(
+        "CRAFTER_TEMPERATURE", str(rcfg.get("temperature", 0.4))
+    )
+
+    # Default v3 traces path from config if not already set
+    tcfg = cfg.get("traces", {})
+    if "SQLD_DB_PATH" not in os.environ and tcfg.get("sqld_db_path"):
+        os.environ["SQLD_DB_PATH"] = tcfg["sqld_db_path"]
+    os.environ["CRAFTER_SYSTEM_PROMPT"] = (
+        "You are CrafterAgent playing the Crafter survival environment. Your goal is to stay alive and unlock as many achievements as possible. "
+        "Keep your reasoning very brief and focus on the tool call. Use the tool available to you to play Crafter"
+        "ALWAYS provide 2-5 actions. Available actions: move_left, move_right, move_up, move_down, do, 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, noop."
+    )
+    os.environ["CRAFTER_SUPPRESS_OBS_REMINDER"] = "1"
+    # Ensure we log full LM inputs and tools
+    os.environ["CRAFTER_LOG_FULL_INPUTS"] = os.environ.get("CRAFTER_LOG_FULL_INPUTS", "1")
+
+    sys.argv = [
+        "crafter_runner",
+        "--model",
+        MODEL_ID,
+        "--episodes",
+        str(EPISODES),
+        "--max-steps",
+        str(MAX_STEPS),
+        "--difficulty",
+        DIFFICULTY,
+        think_flag,
+        "--quiet",
+    ]
+
+    await runner.main()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/finetuning_old/_backup_synth_qwen/run_demo.sh

@@ -0,0 +1,195 @@
+#!/usr/bin/env bash
+
+# Interactive demo for Qwen 4B Crafter finetuning
+# Mirrors the flow in readme.md and example_log.md
+
+set -euo pipefail
+
+# Locate repo root and cd there
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+cd "$SCRIPT_DIR/../../.."
+
+echo "Synth Qwen4B finetuning demo (Crafter)"
+
+# Load env (prefer example-local .env, then repo .env)
+set +u
+set -a
+if [ -f "$SCRIPT_DIR/.env" ]; then source "$SCRIPT_DIR/.env"; fi
+if [ -f ".env" ]; then source ".env"; fi
+set +a
+set -u
+
+# Helper: prompt with default
+prompt() {
+  local msg="$1"; shift
+  local default="$1"; shift
+  local var
+  read -r -p "$msg" var || true
+  if [ -z "$var" ]; then
+    echo "$default"
+  else
+    echo "$var"
+  fi
+}
+
+# Ensure API key present (and set OPENAI_API_KEY fallback)
+ensure_api_key() {
+  local current_key="${SYNTH_API_KEY:-}"
+  if [ -n "$current_key" ]; then
+    local preview="${current_key:0:6}...${current_key: -4}"
+    read -r -p "Detected SYNTH_API_KEY ($preview). Use this key? [Y/n]: " USE_CUR || true
+    USE_CUR=${USE_CUR:-Y}
+    if [[ ! "$USE_CUR" =~ ^[Yy]$ ]]; then
+      current_key=""
+    fi
+  fi
+
+  if [ -z "$current_key" ]; then
+    if [ -n "${SYNTH_API_KEY_PROD:-}" ]; then
+      local prod_prev="${SYNTH_API_KEY_PROD:0:6}...${SYNTH_API_KEY_PROD: -4}"
+      read -r -p "Use SYNTH_API_KEY_PROD ($prod_prev)? [y/N]: " USE_PROD || true
+      if [[ "$USE_PROD" =~ ^[Yy]$ ]]; then
+        current_key="$SYNTH_API_KEY_PROD"
+      fi
+    fi
+  fi
+
+  while [ -z "$current_key" ]; do
+    echo
+    read -s -p "Enter your SYNTH_API_KEY: " KEY_IN || true
+    echo
+    if [ -n "$KEY_IN" ]; then
+      current_key="$KEY_IN"
+    else
+      echo "A valid SYNTH_API_KEY is required to continue."
+    fi
+  done
+
+  export SYNTH_API_KEY="$current_key"
+  if [ -z "${OPENAI_API_KEY:-}" ]; then
+    export OPENAI_API_KEY="$SYNTH_API_KEY"
+    echo "OPENAI_API_KEY set from SYNTH_API_KEY."
+  fi
+}
+
+# Step 1: Rollouts to generate v3 traces
+echo
+read -r -p "Run rollouts to generate v3 traces now? [Y/n]: " RUN_ROLLOUTS || true
+RUN_ROLLOUTS=${RUN_ROLLOUTS:-Y}
+if [[ "$RUN_ROLLOUTS" =~ ^[Yy]$ || -z "$RUN_ROLLOUTS" ]]; then
+  echo "Using config defaults from examples/finetuning/synth_qwen/config.toml (override below if desired)."
+  # Allow quick overrides via envs
+  MODEL_INPUT=$(prompt "Model id [Enter=use config]: " "")
+  EPISODES_INPUT=$(prompt "Episodes [Enter=use config]: " "")
+  MAX_STEPS_INPUT=$(prompt "Max steps [Enter=use config]: " "")
+  DIFFICULTY_INPUT=$(prompt "Difficulty [Enter=use config]: " "")
+  THINK_INPUT=$(prompt "Enable think mode? (1/0) [Enter=0]: " "0")
+
+  if [ -n "$MODEL_INPUT" ]; then export CRAFTER_MODEL="$MODEL_INPUT"; fi
+  if [ -n "$EPISODES_INPUT" ]; then export CRAFTER_EPISODES="$EPISODES_INPUT"; fi
+  if [ -n "$MAX_STEPS_INPUT" ]; then export CRAFTER_MAX_STEPS="$MAX_STEPS_INPUT"; fi
+  if [ -n "$DIFFICULTY_INPUT" ]; then export CRAFTER_DIFFICULTY="$DIFFICULTY_INPUT"; fi
+  export CRAFTER_THINK="${THINK_INPUT:-0}"
+
+  echo
+echo "Running rollouts (v3 tracing)..."
+  ensure_api_key
+  uv run python -m examples.finetuning.synth_qwen.run_crafter_qwen4b
+else
+  echo "Skipping rollouts."
+fi
+
+# Step 2: Filter traces -> SFT JSONL
+echo
+read -r -p "Filter v3 traces into SFT JSONL now? [Y/n]: " RUN_FILTER || true
+RUN_FILTER=${RUN_FILTER:-Y}
+if [[ "$RUN_FILTER" =~ ^[Yy]$ || -z "$RUN_FILTER" ]]; then
+  # Ensure DB path is correctly set for v3 traces (force set to repo-local path)
+  DB_PATH_DEFAULT="$PWD/traces/v3/synth_ai.db/dbs/default/data"
+  export CRAFTER_DB_URL="sqlite+aiosqlite:///$DB_PATH_DEFAULT"
+  echo "Using DB: $CRAFTER_DB_URL"
+  mkdir -p ft_data
+  echo "You can override filter options; Enter to use config defaults."
+  ACH_INPUT=$(prompt "Required achievements (space-separated) [Enter=config]: " "")
+  MODELS_INPUT=$(prompt "Restrict to models (space-separated) [Enter=all]: " "")
+  OUT_PATH_INPUT=$(prompt "Output JSONL path [Enter=config]: " "")
+  MIN_REWARD_INPUT=$(prompt "Min total reward [Enter=config]: " "")
+  MAX_COST_INPUT=$(prompt "Max total cost [Enter=config]: " "")
+  MAX_TOKENS_INPUT=$(prompt "Max total tokens [Enter=config]: " "")
+
+  if [ -n "$ACH_INPUT" ]; then export REQUIRED_ACHIEVEMENTS="$ACH_INPUT"; fi
+  if [ -n "$MODELS_INPUT" ]; then export MODELS="$MODELS_INPUT"; fi
+  if [ -n "$OUT_PATH_INPUT" ]; then export OUTPUT_JSONL="$OUT_PATH_INPUT"; fi
+  if [ -n "$MIN_REWARD_INPUT" ]; then export MIN_TOTAL_REWARD="$MIN_REWARD_INPUT"; fi
+  if [ -n "$MAX_COST_INPUT" ]; then export MAX_COST="$MAX_COST_INPUT"; fi
+  if [ -n "$MAX_TOKENS_INPUT" ]; then export MAX_TOKENS="$MAX_TOKENS_INPUT"; fi
+
+  echo
+echo "Filtering traces to SFT JSONL..."
+  uv run python -m examples.finetuning.synth_qwen.filter_traces_achievements
+else
+  echo "Skipping filter."
+fi
+
+# Step 3: Kick off SFT (learning service)
+echo
+read -r -p "Kick off SFT training job now? [Y/n]: " RUN_SFT || true
+RUN_SFT=${RUN_SFT:-Y}
+FT_MODEL_ID=""
+if [[ "$RUN_SFT" =~ ^[Yy]$ || -z "$RUN_SFT" ]]; then
+  echo "Enter overrides for training job; Enter to use config."
+  BASE_MODEL_INPUT=$(prompt "Base model [Enter=config]: " "")
+  TRAIN_JSONL_INPUT=$(prompt "Training JSONL path [Enter=config]: " "")
+
+  if [ -n "$BASE_MODEL_INPUT" ]; then export QWEN_BASE_MODEL="$BASE_MODEL_INPUT"; fi
+  if [ -n "$TRAIN_JSONL_INPUT" ]; then export QWEN_TRAINING_JSONL="$TRAIN_JSONL_INPUT"; fi
+
+  echo
+  echo "Starting SFT job..."
+  ensure_api_key
+  # Stream logs to terminal and save to file for parsing
+  mkdir -p logs
+  TS=$(date +%Y%m%d_%H%M%S)
+  SFT_LOG_FILE="logs/sft_kickoff_${TS}.log"
+  # Force unbuffered stdout so polling status prints live through the pipe
+  PYTHONUNBUFFERED=1 uv run python -u -m examples.finetuning.synth_qwen.sft_kickoff | tee "$SFT_LOG_FILE"
+  # Extract ft model id like ft:Qwen/... (no whitespace or quotes)
+  if grep -qE "ft:[^[:space:]\"]+" "$SFT_LOG_FILE"; then
+    FT_MODEL_ID=$(grep -Eo "ft:[^[:space:]\"]+" "$SFT_LOG_FILE" | tail -n1)
+    echo "Captured fine-tuned model id: $FT_MODEL_ID"
+    echo "SFT logs saved to: $SFT_LOG_FILE"
+  else
+    echo "Warning: could not parse fine-tuned model id from output. Logs: $SFT_LOG_FILE"
+  fi
+else
+  echo "Skipping SFT kickoff."
+fi
+
+# Step 4: Optional rollout with fine-tuned model
+echo
+if [ -n "$FT_MODEL_ID" ]; then
+  read -r -p "Roll out fine-tuned model '$FT_MODEL_ID' in Crafter now? [y/N]: " RUN_ROLLOUT_FT || true
+  if [[ "$RUN_ROLLOUT_FT" =~ ^[Yy]$ ]]; then
+    EPISODES2=$(prompt "Episodes [Enter=config]: " "")
+    MAX_STEPS2=$(prompt "Max steps [Enter=config]: " "")
+    DIFFICULTY2=$(prompt "Difficulty [Enter=config]: " "")
+    THINK2=$(prompt "Enable think mode? (1/0) [Enter=0]: " "0")
+
+    export CRAFTER_MODEL="$FT_MODEL_ID"
+    if [ -n "$EPISODES2" ]; then export CRAFTER_EPISODES="$EPISODES2"; fi
+    if [ -n "$MAX_STEPS2" ]; then export CRAFTER_MAX_STEPS="$MAX_STEPS2"; fi
+    if [ -n "$DIFFICULTY2" ]; then export CRAFTER_DIFFICULTY="$DIFFICULTY2"; fi
+    export CRAFTER_THINK="${THINK2:-0}"
+
+    echo
+  echo "Running rollouts with fine-tuned model..."
+    uv run python -m examples.finetuning.synth_qwen.run_crafter_qwen4b
+  else
+    echo "Skipping rollout of fine-tuned model."
+  fi
+else
+  echo "No fine-tuned model id available to roll out."
+fi
+
+echo
+echo "Done. You can re-run this script to repeat steps as needed."

examples/finetuning_old/_backup_synth_qwen/sft_kickoff.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Kick off Qwen 4B SFT against the learning-v2 service using the exact
+upload/job/polling flow mirrored from test_qwen3_sft_training_v2.py.
+
+Environment:
+- LEARNING_V2_BASE_URL (preferred)
+- SYNTH_BASE_URL (fallback if LEARNING_V2_BASE_URL is unset)
+- else defaults to http://localhost:8000/api
+- SYNTH_API_KEY
+- QWEN_BASE_MODEL (optional, defaults to Qwen/Qwen3-4B-Instruct-2507)
+- QWEN_TRAINING_JSONL (optional, defaults to ft_data/qwen4b_crafter_sft.jsonl)
+"""
+
+import asyncio
+import os
+import time
+import tomllib
+from typing import Any
+
+import aiohttp
+from synth_ai.config.base_url import get_learning_v2_base_url
+
+API_URL = get_learning_v2_base_url()
+API_KEY = os.getenv("SYNTH_API_KEY")
+
+_cfg_path = os.getenv("CRAFTER_CONFIG", "examples/finetuning/synth_qwen/config.toml")
+_cfg: dict[str, Any] = {}
+if os.path.exists(_cfg_path):
+    with open(_cfg_path, "rb") as _f:
+        _cfg = tomllib.load(_f)
+scfg = _cfg.get("sft", {})
+
+MODEL = os.getenv("QWEN_BASE_MODEL", scfg.get("base_model", "Qwen/Qwen3-4B-Instruct-2507"))
+TRAINING_PATH = os.getenv(
+    "QWEN_TRAINING_JSONL", scfg.get("training_jsonl", "ft_data/qwen4b_crafter_sft.jsonl")
+)
+
+
+async def upload_file() -> str:
+    headers = {"Authorization": f"Bearer {API_KEY}"}
+    async with aiohttp.ClientSession() as session:
+        form = aiohttp.FormData()
+        with open(TRAINING_PATH, "rb") as f:
+            form.add_field(
+                "file",
+                f,
+                filename=os.path.basename(TRAINING_PATH),
+                content_type="application/jsonl",
+            )
+            form.add_field("purpose", "fine-tune")
+            async with session.post(f"{API_URL}/files", data=form, headers=headers) as resp:
+                assert resp.status == 200, await resp.text()
+                data = await resp.json()
+                return data["id"]
+
+
+async def create_job(file_id: str) -> str:
+    body = {
+        "training_file": file_id,
+        "model": MODEL,
+        "hyperparameters": {
+            "training_type": "sft",
+            "n_epochs": int(scfg.get("n_epochs", 1)),
+            "batch_size": int(scfg.get("batch_size", 4)),
+        },
+        "upload_to_wasabi": bool(scfg.get("upload_to_wasabi", True)),
+    }
+    headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
+    async with aiohttp.ClientSession() as session, session.post(
+        f"{API_URL}/fine_tuning/jobs", json=body, headers=headers
+    ) as resp:
+        assert resp.status == 200, await resp.text()
+        data = await resp.json()
+        return data["id"]
+
+
+async def await_success(job_id: str) -> dict[str, object]:
+    headers = {"Authorization": f"Bearer {API_KEY}"}
+    async with aiohttp.ClientSession() as session:
+        check_interval_seconds = 15
+        for attempt in range(20):
+            async with session.get(f"{API_URL}/fine_tuning/jobs/{job_id}", headers=headers) as resp:
+                if resp.status != 200:
+                    await asyncio.sleep(check_interval_seconds)
+                    continue
+                job = await resp.json()
+                status = job.get("status")
+                print(f"⏳ poll {attempt + 1}/20 – status = {status}")
+                if status == "succeeded":
+                    return job
+                if status in {"failed", "cancelled"}:
+                    raise RuntimeError(f"Training failed: {job.get('error')}")
+            await asyncio.sleep(check_interval_seconds)
+    raise TimeoutError("Training did not finish in time")
+
+
+async def main() -> None:
+    if not API_URL or not API_KEY:
+        raise RuntimeError(
+            "LEARNING_V2_BASE_URL/SYNTH_BASE_URL and SYNTH_API_KEY must be set or use the default http://localhost:8000/api"
+        )
+    print("🚀 Starting Qwen 4B SFT")
+    fid = await upload_file()
+    job_id = await create_job(fid)
+    start = time.time()
+    job = await await_success(job_id)
+    wall = time.time() - start
+
+    ft_model = job["fine_tuned_model"]
+    tokens = job.get("trained_tokens")
+
+    print("🟢 Qwen4B SFT fine-tune succeeded →", ft_model)
+    print(f"⏱️ wall-clock: {wall:.1f}s | trained_tokens: {tokens}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/finetuning_old/synth_qwen_v1/README.md

@@ -0,0 +1,68 @@
+## Synth-Qwen v1 Finetuning Demo (Qwen3 0.6B)
+
+Prereqs
+- Python 3.11+ and uv installed (`curl -LsSf https://astral.sh/uv/install.sh | sh`)
+- Local Env Service is provided by this repo; no `sqld` required
+- One of the following ways to provide backend creds:
+  - Set `MONOREPO_BACKEND` to your monorepo backend path (defaults to `../monorepo/backend`) and ensure it has `.env.dev` with at least:
+    - `DEV_BACKEND_URL` (e.g., `http://localhost:8000`)
+    - `TESTING_LOCAL_SYNTH_API_KEY` (or `SYNTH_API_KEY`)
+  - OR export these directly in your shell before running:
+    - `LOCAL_BACKEND_URL` (e.g., `http://localhost:8000/api`)
+    - `SYNTH_API_KEY` (local dev key)
+  - Optional for prod: `.env` in repo root with
+    - `PROD_BACKEND_URL=https://agent-learning.onrender.com`
+    - `TESTING_PROD_SYNTH_API_KEY=...`
+
+Steps
+```bash
+# 0) Go to repo root so traces and logs land in the right place
+cd "$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+# Note: commands below resolve backend URL per-call using examples/common/backend.py
+
+# 1) Start local services (sqld + Env Service) in background
+uvx synth-ai serve --no-sqld --env-port 8901
+
+# 3) Rollout base Qwen to generate v3 traces (Crafter via Env Service)
+set -a; MONOREPO_BACKEND=${MONOREPO_BACKEND:-../monorepo/backend}; source "$MONOREPO_BACKEND/.env.dev"; set +a; export SYNTH_BASE_URL="$(uv run python -c 'from examples.common.backend import resolve_backend_url;print(resolve_backend_url())')"; export SYNTH_API_KEY="${DEV_SYNTH_API_KEY:-${SYNTH_API_KEY:-${SYNTH_API_KEY_TEST:-sk-local}}}"; uv run python examples/finetuning/synth_qwen/react_agent_lm.py --model "Qwen/Qwen3-0.6B" --episodes 10 --max-steps 10 --quiet --no-daemon
+
+# 4) Convert traces → SFT JSONL (writes training.jsonl) [use single-script alternative below]
+printf "[filter]\nrequired_achievements=[]\n" > /tmp/crater_filter.toml && CRAFTER_DB_URL=sqlite+aiosqlite:///$PWD/traces/v3/synth_ai.db CRAFTER_CONFIG=/tmp/crater_filter.toml WINDOW_MODE=1 MIN_TOTAL_REWARD=1 MIN_ACHIEVEMENTS=0 OUTPUT_JSONL=$PWD/examples/finetuning/synth_qwen_v1/data/training_crafter.jsonl uv run python examples/finetuning/synth_qwen/filter_traces_achievements.py
+
+# ALT: Single-script E2E run (prepare → upload → create/start → poll → infer)
+set -a; MONOREPO_BACKEND=${MONOREPO_BACKEND:-../monorepo/backend}; source "$MONOREPO_BACKEND/.env.dev"; set +a; SYNTH_BACKEND_URL_OVERRIDE=prod DEV_BACKEND_URL="$(uv run python -c 'from examples.common.backend import resolve_backend_url;print(resolve_backend_url())')" uv run python examples/finetuning/synth_qwen_v1/run_ft_job.py --mode dev
+
+# Test model
+set -a; MONOREPO_BACKEND=${MONOREPO_BACKEND:-../monorepo/backend}; source "$MONOREPO_BACKEND/.env.dev"; set +a; MODE=dev DEV_BACKEND_URL="$(uv run python -c 'from examples.common.backend import resolve_backend_url;print(resolve_backend_url())')" uv run python examples/finetuning/synth_qwen_v1/hello_ft_model.py | cat
+
+# 8) Rollout agent again using the fine-tuned model from state.json (env service already on 8901, no sqld)
+set -a; MONOREPO_BACKEND=${MONOREPO_BACKEND:-../monorepo/backend}; source "$MONOREPO_BACKEND/.env.dev"; set +a; FT_MODEL=$(uv run python - <<'PY'
+import json, os
+print(json.load(open(os.path.join(os.getcwd(),'examples/finetuning/synth_qwen_v1/state.json')))['fine_tuned_model'])
+PY
+); SYNTH_BACKEND_URL_OVERRIDE=prod SYNTH_BASE_URL="$(uv run python -c 'from examples.common.backend import resolve_backend_url;print(resolve_backend_url())')" SYNTH_API_KEY=${TESTING_LOCAL_SYNTH_API_KEY:-${SYNTH_API_KEY:-sk-local}} uv run python examples/finetuning/synth_qwen/react_agent_lm.py --model "$FT_MODEL" --episodes 10 --max-steps 10 --quiet --no-daemon --no-traces
+```
+
+
+
+
+
+
+
+
+
+
+
+export LOCAL_BACKEND_URL=http://localhost:8000/api
+export SYNTH_BACKEND_URL_OVERRIDE=local
+uv run python examples/finetuning/synth_qwen_v1/run_ft_job.py --mode local
+
+HATCHET_ENV_OVERRIDE=prod python -u -m app.orchestration.hatchet.workflows
+
+export LOCAL_BACKEND_URL=http://localhost:8000/api                       
+export SYNTH_BACKEND_URL_OVERRIDE=dev  
+uv run python examples/finetuning/synth_qwen_v1/run_ft_job.py --mode dev
+
+export PROD_BACKEND_URL=https://agent-learning.onrender.com/api
+export SYNTH_BACKEND_URL_OVERRIDE=prod
+uv run python examples/finetuning/synth_qwen_v1/run_ft_job.py --mode prod

examples/finetuning_old/synth_qwen_v1/filter_traces.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""
+Filter v3 Crafter traces into an SFT-ready JSONL using the maintained
+Modal/Synth filter logic (no CLI needed). Intended to be run after
+collecting trajectories with the Crafter runner.
+
+Environment:
+- CRAFTER_DB_URL (default: sqlite:///traces_v3_lm_synth/traces.db)
+- OUTPUT_JSONL (default: ft_data/qwen4b_crafter_sft.jsonl)
+- MIN_TOTAL_REWARD (float, default: 1.0)
+- MIN_ACHIEVEMENTS (int, default: 0)
+- MAX_COST (float, default: 10.0)
+- MAX_TOKENS (int, default: 100000)
+- MODELS (optional, space-separated model names; default empty = all)
+"""
+
+import asyncio
+import json
+import os
+from typing import Any
+
+# Reuse the existing filtering implementation
+from synth_ai.environments.examples.crafter_classic.agent_demos.crafter_modal_ft.filter_traces_sft_turso import (
+    filter_traces_from_turso,
+)
+
+
+def build_config() -> dict[str, Any]:
+    models_env = os.getenv("MODELS", "").strip()
+    models: list[str] = models_env.split() if models_env else []
+    return {
+        "mode": "trajectory",
+        "filters": {
+            "min_total_reward": float(os.getenv("MIN_TOTAL_REWARD", "1.0")),
+            "min_achievements": int(os.getenv("MIN_ACHIEVEMENTS", "0")),
+            "max_cost": float(os.getenv("MAX_COST", "10.0")),
+            "max_tokens": int(os.getenv("MAX_TOKENS", "100000")),
+            "models": models,
+        },
+    }
+
+
+async def main() -> None:
+    db_url = os.getenv("CRAFTER_DB_URL", "sqlite:///traces_v3_lm_synth/traces.db")
+    output_path = os.getenv("OUTPUT_JSONL", "ft_data/qwen4b_crafter_sft.jsonl")
+    config = build_config()
+
+    print("🤖 Modal/Synth Fine-Tuning Data Filter (v3)")
+    print("Using database:", db_url)
+    print("Output file:", output_path)
+    print("Config:", json.dumps(config, indent=2))
+
+    num_examples, stats = await filter_traces_from_turso(db_url, output_path, config)
+
+    print("\n✅ Wrote", num_examples, "training examples to", output_path)
+    print("📊 Stats keys:", list(stats.keys()))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())