synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.10__py3-none-any.whl

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).
+
+

examples/qwen_coder/validate_jsonl.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Validate that a JSONL file parses and contains chat-like records.
+
+Checks first N lines (default 50) for objects with `messages` including an
+assistant response (role == "assistant").
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("path", help="Path to JSONL file")
+    p.add_argument("--n", type=int, default=50, help="Number of lines to sample")
+    args = p.parse_args()
+
+    src = Path(args.path)
+    if not src.exists():
+        raise SystemExit(f"No such file: {src}")
+
+    checked = 0
+    ok = 0
+    with src.open("r", encoding="utf-8") as f:
+        for i, line in enumerate(f, start=1):
+            if i > args.n:
+                break
+            line = line.strip()
+            if not line:
+                continue
+            checked += 1
+            try:
+                obj = json.loads(line)
+            except Exception as exc:
+                raise SystemExit(f"Line {i} is not valid JSON: {exc}")
+            msgs = obj.get("messages") if isinstance(obj, dict) else None
+            if not isinstance(msgs, list):
+                raise SystemExit(f"Line {i} missing 'messages' list")
+            has_assistant = any(
+                isinstance(m, dict) and m.get("role") == "assistant" and m.get("content")
+                for m in msgs
+            )
+            if has_assistant:
+                ok += 1
+
+    if checked == 0:
+        raise SystemExit("No lines checked; file empty?")
+    if ok == 0:
+        raise SystemExit("No assistant messages found in sampled lines")
+    print(f"Validated: {ok}/{checked} sampled lines contain assistant messages")
+
+
+if __name__ == "__main__":
+    main()
+
+
+