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

examples/finetuning_old/_backup_synth_qwen/readme.md

@@ -1,49 +0,0 @@
-### 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

@@ -1,114 +0,0 @@
-#!/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

@@ -1,195 +0,0 @@
-#!/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

@@ -1,119 +0,0 @@
-#!/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

@@ -1,68 +0,0 @@
-## 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

@@ -1,60 +0,0 @@
-#!/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())