synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

examples/qwen_coder/generate_dataset.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Generate a small, synthetic SFT JSONL dataset for coder-style prompts.
+
+Each line uses the minimal schema consumed by the SFT CLI:
+  {"messages": [{"role": "user", "content": "..."}], "response": "..."}
+
+Example:
+  uv run python examples/qwen_coder/generate_dataset.py \
+    --output examples/qwen_coder/ft_data/coder_sft.small.jsonl \
+    --n 50 --seed 42 --lang python
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import random
+from collections.abc import Iterable
+from pathlib import Path
+
+PROMPT_TEMPLATES: dict[str, list[str]] = {
+    "python": [
+        "Write a Python function `add(a, b)` that returns the sum of two numbers.",
+        "Write a Python function `reverse_string(s)` that returns the reversed string.",
+        "Implement a Python function `is_palindrome(s)` that returns True if s is a palindrome.",
+        "Write a Python function `fibonacci(n)` that returns a list of the first n Fibonacci numbers.",
+        "Write a Python function `count_words(text)` that returns a dict of word -> count.",
+    ],
+    "javascript": [
+        "Write a JavaScript function `add(a, b)` that returns the sum of two numbers.",
+        "Write a JavaScript function `reverseString(s)` that returns the reversed string.",
+        "Implement a JavaScript function `isPalindrome(s)` that returns true if s is a palindrome.",
+        "Write a JavaScript function `fibonacci(n)` that returns an array of the first n Fibonacci numbers.",
+        "Write a JavaScript function `countWords(text)` that returns an object mapping word -> count.",
+    ],
+}
+
+
+SOLUTIONS: dict[str, list[str]] = {
+    "python": [
+        """def add(a, b):\n    return a + b\n""",
+        """def reverse_string(s: str) -> str:\n    return s[::-1]\n""",
+        """def is_palindrome(s: str) -> bool:\n    t = ''.join(ch.lower() for ch in s if ch.isalnum())\n    return t == t[::-1]\n""",
+        """def fibonacci(n: int) -> list[int]:\n    a, b = 0, 1\n    out: list[int] = []\n    for _ in range(max(0, n)):\n        out.append(a)\n        a, b = b, a + b\n    return out\n""",
+        """from collections import Counter\n\n"""
+        """def count_words(text: str) -> dict[str, int]:\n    words = [w for w in text.split() if w]\n    return dict(Counter(words))\n""",
+    ],
+    "javascript": [
+        """function add(a, b) {\n  return a + b;\n}\n""",
+        """function reverseString(s) {\n  return s.split('').reverse().join('');\n}\n""",
+        """function isPalindrome(s) {\n  const t = (s.match(/[a-z0-9]/gi) || []).join('').toLowerCase();\n  return t === t.split('').reverse().join('');\n}\n""",
+        """function fibonacci(n) {\n  const out = [];\n  let a = 0, b = 1;\n  for (let i = 0; i < Math.max(0, n); i++) {\n    out.push(a);\n    [a, b] = [b, a + b];\n  }\n  return out;\n}\n""",
+        """function countWords(text) {\n  const words = text.split(/\s+/).filter(Boolean);\n  return words.reduce((acc, w) => { acc[w] = (acc[w] || 0) + 1; return acc; }, {});\n}\n""",
+    ],
+}
+
+
+def _iter_examples(n: int, lang: str) -> Iterable[dict]:
+    prompts = PROMPT_TEMPLATES.get(lang, PROMPT_TEMPLATES["python"]).copy()
+    answers = SOLUTIONS.get(lang, SOLUTIONS["python"]).copy()
+    for _ in range(n):
+        i = random.randrange(0, len(prompts))
+        j = random.randrange(0, len(answers))
+        user = prompts[i]
+        assistant = answers[j]
+        yield {
+            "messages": [
+                {"role": "user", "content": user},
+            ],
+            "response": assistant,
+        }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Generate synthetic coder SFT JSONL dataset")
+    ap.add_argument("--output", required=True, help="Path to write JSONL (will create parent dir)")
+    ap.add_argument("--n", type=int, default=50, help="Number of examples to generate")
+    ap.add_argument("--seed", type=int, default=42, help="Random seed")
+    ap.add_argument("--lang", choices=["python", "javascript"], default="python")
+    args = ap.parse_args()
+
+    random.seed(args.seed)
+    out_path = Path(args.output).expanduser().resolve()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write JSONL
+    with out_path.open("w", encoding="utf-8") as fh:
+        for rec in _iter_examples(max(1, int(args.n)), lang=args.lang):
+            fh.write(json.dumps(rec, ensure_ascii=False))
+            fh.write("\n")
+
+    print(f"Wrote {args.n} examples to {out_path}")
+
+
+if __name__ == "__main__":
+    main()
+
+

examples/qwen_coder/infer_ft_smoke.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Post-SFT smoke test: read ft_model_id.txt and run a short inference.
+
+Env:
+  SYNTH_API_KEY (required)
+  BACKEND_BASE_URL (defaults to https://agent-learning.onrender.com/api)
+
+Writes:
+  examples/qwen_coder/ft_data/ft_infer_smoke.txt
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from examples.qwen_coder._shared import resolve_infer_output_path, resolve_model_id_path
+from synth_ai.inference.client import InferenceClient
+
+
+def _backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in environment")
+
+    ft_id_path = resolve_model_id_path(os.getenv("QWEN_CODER_FT_FILENAME", "ft_model_id.txt"))
+    if not ft_id_path.exists():
+        raise SystemExit(f"Missing {ft_id_path}; run SFT first")
+    model_id = ft_id_path.read_text(encoding="utf-8").strip()
+    if not model_id:
+        raise SystemExit("ft_model_id.txt is empty")
+
+    client = InferenceClient(base_url=_backend(), api_key=api_key, timeout=60.0)
+
+    prompt = os.getenv(
+        "PROMPT",
+        "Write a Python function to check if a string is a palindrome, then test it.",
+    )
+    resp: dict[str, Any] = await client.create_chat_completion(
+        model=model_id,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.2,
+        max_tokens=256,
+        thinking_budget=256,
+    )
+
+    # Extract assistant content
+    content: str = (
+        resp.get("choices", [{}])[0].get("message", {}).get("content") or str(resp)
+    )
+    out_path = resolve_infer_output_path(os.getenv("QWEN_CODER_FT_INFER_FILENAME", "ft_infer_smoke.txt"))
+    out_path.write_text(content + "\n", encoding="utf-8")
+    print(f"Wrote {out_path} (len={len(content)})")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+

examples/qwen_coder/infer_prod_proxy.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Smoke test: Qwen3 Coder inference via the Synth prod proxy endpoint.
+
+No CLI args. Reads SYNTH_API_KEY from env. Optional overrides via env:
+  - BACKEND_BASE_URL (defaults to https://agent-learning.onrender.com/api)
+  - MODEL (defaults to Qwen/Qwen3-Coder-30B-A3B-Instruct)
+  - PROMPT (defaults to a simple coding prompt)
+
+Run:
+  SYNTH_API_KEY=sk_... uv run python examples/qwen_coder/infer_prod_proxy.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+import httpx
+
+
+def _backend_root() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    if raw.endswith("/api"):
+        raw = raw[:-4]
+    return raw.rstrip("/")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in environment")
+
+    model = os.getenv("MODEL", "Qwen/Qwen3-Coder-30B-A3B-Instruct")
+    prompt = os.getenv(
+        "PROMPT",
+        "Write a Python function to reverse a string, then show an example call.",
+    )
+
+    # Prod proxy endpoint
+    url = f"{_backend_root()}/api/inference/v1/chat/completions"
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2,
+        "max_tokens": 256,
+        "thinking_budget": 256,
+    }
+
+    async with httpx.AsyncClient(timeout=60.0) as http:
+        resp = await http.post(
+            url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        # Print assistant content (compact)
+        try:
+            msg = data.get("choices", [{}])[0].get("message", {})
+            print(msg.get("content") or data)
+        except Exception:
+            print(data)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+

examples/qwen_coder/infer_via_synth.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""One-shot inference for Qwen3 (and Coder) models via the Synth backend proxy.
+
+Usage examples:
+
+  SYNTH_API_KEY=sk_... BACKEND_BASE_URL=https://agent-learning.onrender.com/api \
+  uv run python examples/qwen_coder/infer_via_synth.py \
+    --model Qwen/Qwen3-Coder-30B-A3B-Instruct \
+    --prompt "Write a Python function to reverse a string." \
+    --max-tokens 128 --temperature 0.2
+
+Optionally you can point to a specific inference host (e.g., your vLLM or task-app proxy):
+
+  ... infer_via_synth.py --inference-url https://your-host/api/inference
+
+The script defaults the backend base URL to the hosted service if BACKEND_BASE_URL is not set.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+from typing import Any
+
+from synth_ai.inference.client import InferenceClient
+
+
+def _default_backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument(
+        "--model",
+        default=os.getenv("MODEL", "Qwen/Qwen3-Coder-30B-A3B-Instruct"),
+        help="Base or ft:<id> model identifier",
+    )
+    p.add_argument(
+        "--prompt",
+        default="Write a Python function to reverse a string.",
+        help="User prompt text",
+    )
+    p.add_argument("--max-tokens", type=int, default=256)
+    p.add_argument("--temperature", type=float, default=0.2)
+    p.add_argument(
+        "--inference-url",
+        default=os.getenv("INFERENCE_URL"),
+        help="Optional backend inference base (e.g., https://host/api/inference)",
+    )
+    p.add_argument(
+        "--timeout", type=float, default=60.0, help="HTTP timeout seconds for backend calls"
+    )
+    args = p.parse_args()
+
+    backend = _default_backend()
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required (export it or pass via env-file to uvx)")
+
+    client = InferenceClient(base_url=backend, api_key=api_key, timeout=args.timeout)
+
+    body: dict[str, Any] = {
+        "model": args.model,
+        "messages": [{"role": "user", "content": args.prompt}],
+        "max_tokens": int(args.max_tokens),
+        "temperature": float(args.temperature),
+    }
+    if args.inference_url:
+        # Backend supports forwarding to a specific host when provided
+        body["inference_url"] = str(args.inference_url)
+
+    resp = await client.create_chat_completion(**body)
+    try:
+        msg = resp.get("choices", [{}])[0].get("message", {})
+        content = msg.get("content")
+        print(content or resp)
+    except Exception:
+        print(resp)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+

examples/qwen_coder/scripts/infer_coder.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Optional: pass a .env path as first arg; otherwise relies on current env
+ENV_FILE=${1:-}
+
+if [[ -n "${ENV_FILE}" ]]; then
+  if [[ ! -f "${ENV_FILE}" ]]; then
+    echo "Env file not found: ${ENV_FILE}" >&2
+    exit 1
+  fi
+  set -a; source "${ENV_FILE}"; set +a
+fi
+
+# Use prod proxy smoke (base or ft:... via MODEL env)
+uv run python examples/qwen_coder/infer_prod_proxy.py
+
+
+

examples/qwen_coder/scripts/train_coder_30b.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Optional: pass a .env path as first arg; otherwise relies on current env
+ENV_FILE=${1:-}
+
+if [[ -n "${ENV_FILE}" ]]; then
+  if [[ ! -f "${ENV_FILE}" ]]; then
+    echo "Env file not found: ${ENV_FILE}" >&2
+    exit 1
+  fi
+  set -a; source "${ENV_FILE}"; set +a
+fi
+
+uvx synth-ai train \
+  --type sft \
+  --config examples/qwen_coder/configs/coder_lora_30b.toml \
+  --dataset examples/qwen_coder/ft_data/coder_sft.small.jsonl \
+  --env-file "${ENV_FILE:-}"
+
+
+

examples/qwen_coder/sft_full_17b.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Submit a full-parameter SFT job for Qwen/Qwen3-1.7B via Synth API."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from examples.qwen_coder._shared import (
+    ensure_tiny_dataset,
+    optional_validation_dataset,
+    resolve_output_path,
+)
+from synth_ai.learning.client import LearningClient
+
+
+def _backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in env")
+
+    backend = _backend()
+    client = LearningClient(base_url=backend, api_key=api_key, timeout=60.0)
+
+    data_path = ensure_tiny_dataset()
+    file_id = await client.upload_training_file(str(data_path))
+
+    validation_file_id: str | None = None
+    val_path = optional_validation_dataset()
+    if val_path and val_path.exists():
+        validation_file_id = await client.upload_training_file(str(val_path))
+
+    hyper: dict[str, Any] = {
+        "n_epochs": int(os.getenv("QWEN_CODER_FULL_EPOCHS", "1")),
+        "per_device_batch": int(os.getenv("QWEN_CODER_FULL_PER_DEVICE", "1")),
+        "gradient_accumulation_steps": int(os.getenv("QWEN_CODER_FULL_ACCUM", "8")),
+        "sequence_length": int(os.getenv("QWEN_CODER_FULL_SEQ_LEN", "4096")),
+        "learning_rate": float(os.getenv("QWEN_CODER_FULL_LR", "2e-5")),
+        "warmup_ratio": float(os.getenv("QWEN_CODER_FULL_WARMUP", "0.05")),
+        "train_kind": os.getenv("QWEN_CODER_FULL_TRAIN_KIND", "full"),
+    }
+
+    metadata = {
+        "example": "qwen_coder_full_17b",
+        "effective_config": {
+            "compute": {
+                "gpu_type": os.getenv("SYNTH_GPU_TYPE", "H100"),
+                "gpu_count": int(os.getenv("SYNTH_GPU_COUNT", "4")),
+                "nodes": int(os.getenv("SYNTH_GPU_NODES", "1")),
+            }
+        },
+    }
+
+    job = await client.create_job(
+        training_type="sft_offline",
+        model=os.getenv("QWEN_CODER_FULL_MODEL", "Qwen/Qwen3-1.7B"),
+        training_file_id=file_id,
+        hyperparameters=hyper,
+        metadata=metadata,
+        validation_file=validation_file_id,
+    )
+    job_id = str(job.get("id") or job.get("job_id") or "").strip()
+    if not job_id:
+        raise SystemExit(f"Invalid create_job response: {job}")
+
+    await client.start_job(job_id)
+
+    timeout_seconds = float(os.getenv("SYNTH_TIMEOUT", "7200"))
+    poll_interval = float(os.getenv("QWEN_CODER_FULL_POLL_INTERVAL", "10"))
+
+    job_final = await client.poll_until_terminal(
+        job_id,
+        interval_seconds=poll_interval,
+        max_seconds=timeout_seconds,
+    )
+
+    status = str(job_final.get("status"))
+    print(f"Job status: {status}")
+    result_model = (
+        job_final.get("result", {}).get("model_id")
+        if isinstance(job_final.get("result"), dict)
+        else None
+    )
+    print(f"Model ID: {result_model}")
+    try:
+        out_file = resolve_output_path("ft_model_id_full.txt")
+        text = (result_model or "").strip()
+        if text:
+            out_file.write_text(text + "\n", encoding="utf-8")
+            print(f"Wrote {out_file} with ft model id")
+    except Exception as exc:
+        print(f"Warning: failed to write ft_model_id_full.txt: {exc}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

examples/qwen_coder/sft_lora_30b.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Submit a LoRA SFT job for Qwen/Qwen3-Coder-30B-A3B-Instruct via Synth API.
+
+Steps:
+  - Generate a tiny coder dataset if missing
+  - Upload the JSONL
+  - Create the job with coder LoRA hyperparameters
+  - Start and poll until terminal, then print the resulting model id
+
+Env:
+  SYNTH_API_KEY (required)
+  BACKEND_BASE_URL (defaults to https://agent-learning.onrender.com/api)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from examples.qwen_coder._shared import (
+    ensure_tiny_dataset,
+    optional_validation_dataset,
+    resolve_output_path,
+)
+from synth_ai.learning.client import LearningClient
+
+
+def _backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in env")
+
+    backend = _backend()
+    client = LearningClient(base_url=backend, api_key=api_key, timeout=60.0)
+
+    # Ensure dataset exists
+    data_path = ensure_tiny_dataset()
+
+    # Upload training file
+    file_id = await client.upload_training_file(str(data_path))
+
+    # Optional validation file if present alongside training set
+    val_path = optional_validation_dataset()
+    validation_file_id: str | None = None
+    if val_path and val_path.exists():
+        validation_file_id = await client.upload_training_file(str(val_path))
+
+    # Minimal hyperparameters for LoRA SFT (aligned with coder_lora_30b.toml)
+    hyper: dict[str, Any] = {
+        "n_epochs": 1,
+        "per_device_batch": 1,
+        "gradient_accumulation_steps": 64,
+        "sequence_length": 4096,
+        "learning_rate": 5e-6,
+        "warmup_ratio": 0.03,
+        "train_kind": "peft",
+    }
+
+    # Create job
+    job = await client.create_job(
+        training_type="sft_offline",
+        model="Qwen/Qwen3-Coder-30B-A3B-Instruct",
+        training_file_id=file_id,
+        hyperparameters=hyper,
+        metadata={
+            "example": "qwen_coder_lora_30b",
+            # Include effective compute hints for backend routing/validation
+            "effective_config": {
+                "compute": {"gpu_type": "H100", "gpu_count": 4, "nodes": 1}
+            },
+        },
+        validation_file=validation_file_id,
+    )
+    job_id = str(job.get("id"))
+    if not job_id:
+        raise SystemExit(f"Invalid create_job response: {job}")
+
+    # Start
+    await client.start_job(job_id)
+
+    # Poll until terminal
+    job_final = await client.poll_until_terminal(job_id, interval_seconds=5.0, max_seconds=7200)
+    status = str(job_final.get("status"))
+    print(f"Job status: {status}")
+    # Print resulting model id if available and write to ft_data/ft_model_id.txt
+    result_model = (
+        job_final.get("result", {}).get("model_id")
+        if isinstance(job_final.get("result"), dict)
+        else None
+    )
+    print(f"Model ID: {result_model}")
+    try:
+        out_file = resolve_output_path("ft_model_id.txt")
+        text = (result_model or "").strip()
+        if text:
+            out_file.write_text(text + "\n", encoding="utf-8")
+            print(f"Wrote {out_file} with ft model id")
+    except Exception as exc:
+        # Best-effort write; don't crash if filesystem issues
+        print(f"Warning: failed to write ft_model_id.txt: {exc}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/qwen_coder/subset_jsonl.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Create a capped subset of a JSONL dataset for quick runs."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("src", help="Source JSONL path")
+    p.add_argument("dst", help="Destination JSONL path")
+    p.add_argument("--n", type=int, default=200, help="Max examples to keep")
+    args = p.parse_args()
+
+    src = Path(args.src)
+    if not src.exists():
+        raise SystemExit(f"No such file: {src}")
+    dst = Path(args.dst)
+    dst.parent.mkdir(parents=True, exist_ok=True)
+
+    kept = 0
+    with src.open("r", encoding="utf-8") as fin, dst.open("w", encoding="utf-8") as fout:
+        for line in fin:
+            if kept >= args.n:
+                break
+            if not line.strip():
+                continue
+            fout.write(line)
+            kept += 1
+    print(f"Wrote {dst} with {kept} lines")
+
+
+if __name__ == "__main__":
+    main()
+
+
+

examples/qwen_coder/todos.md

@@ -0,0 +1,38 @@
+# Qwen Coder – Remaining TODOs
+
+- [ ] Add small-base LoRA config for quick iteration
+  - Create `configs/coder_lora_4b.toml` (base=`Qwen/Qwen3-4B`, 1x H100, LoRA all-linear, same hyperparameters structure as 30B).
+
+- [ ] Improve SFT submission script (sft_lora_30b.py)
+  - Include `metadata.effective_config.compute` in job payload (gpu_type, gpu_count, nodes) so API doesn’t 400 without TOML.
+  - Write resulting `ft:<id>` to `examples/qwen_coder/ft_data/ft_model_id.txt` and print it clearly.
+  - Add optional validation file support when present.
+
+- [ ] Add post‑SFT inference script
+  - Read `ft_data/ft_model_id.txt` and call the prod proxy (or SDK InferenceClient) to verify the finetuned adapter returns.
+  - Save a short transcript to `ft_data/ft_infer_smoke.txt`.
+
+- [ ] Add inference smoke tests (local opt‑in)
+  - `tests/qwen_coder/test_infer_prod_proxy.py` (skips unless `SYNTH_API_KEY` set). Hits `/api/inference/v1/chat/completions` with `Qwen/Qwen3-Coder-30B-A3B-Instruct` and asserts 200/choices.
+  - Optional: same test for an `ft:<id>` if `FT_MODEL_ID` env is provided.
+
+- [ ] Document end‑to‑end flow in README
+  - Expand README with explicit env section (`SYNTH_API_KEY`, `BACKEND_BASE_URL`).
+  - Show: generate dataset → run LoRA (4B or 30B) → poll → infer with `ft:<id>`.
+  - Mention cost/time caveats for 30B.
+
+- [ ] Dataset utilities
+  - Add `validate_jsonl.py` to check first N lines parse and contain `messages`/`assistant` fields required by SFT.
+  - Add `subset_jsonl.py` to create capped training sets for quick runs.
+
+- [ ] Optional: CLI convenience wrappers
+  - `scripts/train_coder_30b.sh` to invoke `uvx synth-ai train --type sft --config configs/coder_lora_30b.toml --dataset ft_data/coder_sft.small.jsonl` with `.env` preload.
+  - `scripts/infer_coder.sh` to run `infer_prod_proxy.py` against base or `ft:<id>`.
+
+- [ ] Optional CI (requires secrets)
+  - GitHub workflow job (smoke) that runs `infer_prod_proxy.py` with `SYNTH_API_KEY` secret and prints the first 200 chars of assistant output.
+
+- [ ] (If needed) Add coder variants
+  - If backend supports additional coder SKUs, append to `synth_ai/api/models/supported.py:QWEN3_CODER_MODELS` so SDK validation passes (SFT/inference).
+
+