synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

examples/qwen_coder/generate_dataset.py

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

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

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-# 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).
-
-