Add kupe-tts code, DhVaani benchmark outputs, and Hindi TTS corpus

README.md

@@ -0,0 +1,39 @@
+---
+license: apache-2.0
+task_categories:
+  - text-to-speech
+language:
+  - hi
+  - en
+tags:
+  - hindi
+  - hinglish
+  - tts
+  - corpus
+  - kupe
+pretty_name: kupe-tts
+size_categories:
+  - 10K<n<100K
+---
+
+# kupe-tts
+
+Kupe TTS workspace: DhVaani-0.5 local CPU benchmark + Hindi/Hinglish TTS text corpus generation.
+
+## Contents
+
+- `benchmark.py` — DhVaani-0.5 CPU latency benchmark
+- `reference.wav` / `outputs/` — clone reference + sample outputs
+- `tts_data_gen/` — Sarvam (`gemma4`) corpus generator, costs CSV, EDA
+  - `hindi_tts_corpus.jsonl` — ~25k utterance corpus
+  - `generation_costs.csv` — per-batch token/cost log
+  - `cost_eda_report.html` — cost EDA dashboard
+
+## Secrets
+
+Set env vars locally (do **not** commit keys):
+
+```bash
+export SARVAM_API_KEY=...
+export HF_TOKEN=...
+```

benchmark.py

@@ -0,0 +1,113 @@
+"""
+DhVaani-0.5 local CPU benchmark.
+
+Loads ARTPARK-IISc/DhVaani-0.5 via transformers AutoModel, runs a few
+synthesis calls, and records wall-clock latency + real-time factor (RTF)
+for each. Writes .wav (native) and .mp3 (via ffmpeg/pydub) outputs, plus
+a latency.json summary.
+
+Usage:
+    source venv/bin/activate
+    python benchmark.py
+"""
+import json
+import os
+import time
+
+os.environ.setdefault("HF_TOKEN", os.environ.get("HF_TOKEN", ""))
+
+import torch
+import soundfile as sf
+from transformers import AutoModel
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+OUT_DIR = os.path.join(HERE, "outputs")
+os.makedirs(OUT_DIR, exist_ok=True)
+
+DEV = "cuda" if torch.cuda.is_available() else "cpu"
+REFERENCE_WAV = os.path.join(HERE, "reference.wav")
+# We don't have a ground-truth transcript for samples/malayalam.wav from the
+# model repo, so this is an approximate placeholder — good enough to prove
+# the pipeline runs and to measure latency, not tuned for max clone fidelity.
+REFERENCE_TEXT = "ഇത് ഒരു മാതൃകാ ശബ്ദമാണ്."
+
+TEST_CASES = [
+    {"name": "malayalam_greeting", "text": "നമസ്‌കാരം, സുഖമാണോ?"},
+    {"name": "malayalam_longer", "text": "ഇന്ന് കാലാവസ്ഥ വളരെ നല്ലതാണ്. നമുക്ക് പുറത്തു പോകാം."},
+]
+
+
+def main():
+    print(f"[info] device = {DEV}")
+    print("[info] loading ARTPARK-IISc/DhVaani-0.5 (AutoModel, trust_remote_code=True) ...")
+
+    t0 = time.perf_counter()
+    model = AutoModel.from_pretrained(
+        "ARTPARK-IISc/DhVaani-0.5", trust_remote_code=True
+    ).to(DEV).eval()
+    load_s = time.perf_counter() - t0
+    print(f"[info] model loaded in {load_s:.2f}s")
+
+    sr = model.sampling_rate
+    results = {
+        "device": DEV,
+        "model": "ARTPARK-IISc/DhVaani-0.5",
+        "model_load_seconds": round(load_s, 3),
+        "sampling_rate": sr,
+        "runs": [],
+    }
+
+    for case in TEST_CASES:
+        name, text = case["name"], case["text"]
+        print(f"\n[run] {name!r}: {text!r}")
+
+        t0 = time.perf_counter()
+        audio = model.synthesize(
+            text=text,
+            prompt_wav=REFERENCE_WAV,
+            prompt_text=REFERENCE_TEXT,
+        )
+        gen_s = time.perf_counter() - t0
+
+        audio_duration_s = len(audio) / sr
+        rtf = gen_s / audio_duration_s if audio_duration_s > 0 else float("nan")
+
+        wav_path = os.path.join(OUT_DIR, f"{name}.wav")
+        sf.write(wav_path, audio, sr)
+
+        mp3_path = os.path.join(OUT_DIR, f"{name}.mp3")
+        try:
+            from pydub import AudioSegment
+
+            AudioSegment.from_wav(wav_path).export(mp3_path, format="mp3", bitrate="192k")
+            mp3_ok = True
+        except Exception as e:
+            print(f"[warn] mp3 export failed: {e}")
+            mp3_ok = False
+
+        print(
+            f"[result] gen_time={gen_s:.3f}s  audio_len={audio_duration_s:.3f}s  "
+            f"RTF={rtf:.3f}  (RTF<1 means faster than real-time)"
+        )
+
+        results["runs"].append(
+            {
+                "name": name,
+                "text": text,
+                "generation_seconds": round(gen_s, 3),
+                "audio_duration_seconds": round(audio_duration_s, 3),
+                "real_time_factor": round(rtf, 4),
+                "wav_path": os.path.relpath(wav_path, HERE),
+                "mp3_path": os.path.relpath(mp3_path, HERE) if mp3_ok else None,
+            }
+        )
+
+    summary_path = os.path.join(OUT_DIR, "latency.json")
+    with open(summary_path, "w") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+
+    print(f"\n[done] summary written to {summary_path}")
+
+
+if __name__ == "__main__":
+    main()

outputs/latency.json

@@ -0,0 +1,26 @@
+{
+  "device": "cpu",
+  "model": "ARTPARK-IISc/DhVaani-0.5",
+  "model_load_seconds": 11.677,
+  "sampling_rate": 24000,
+  "runs": [
+    {
+      "name": "malayalam_greeting",
+      "text": "നമസ്‌കാരം, സുഖമാണോ?",
+      "generation_seconds": 43.043,
+      "audio_duration_seconds": 3.328,
+      "real_time_factor": 12.9337,
+      "wav_path": "outputs/malayalam_greeting.wav",
+      "mp3_path": "outputs/malayalam_greeting.mp3"
+    },
+    {
+      "name": "malayalam_longer",
+      "text": "ഇന്ന് കാലാവസ്ഥ വളരെ നല്ലതാണ്. നമുക്ക് പുറത്തു പോകാം.",
+      "generation_seconds": 69.043,
+      "audio_duration_seconds": 9.12,
+      "real_time_factor": 7.5705,
+      "wav_path": "outputs/malayalam_longer.wav",
+      "mp3_path": "outputs/malayalam_longer.mp3"
+    }
+  ]
+}

outputs/malayalam_greeting.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21e045114a46928d578c537fb5521eea2fe65df912c9e4aacc3f37b428a572f0
+size 68204

outputs/malayalam_greeting.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a381afe7622dc5e1351e62ba1ac366ae1af719132aec395b8f4e50da3909269
+size 159788

outputs/malayalam_longer.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:021df74b91909a88f0e859937afd7d2afd5c2117bcc920f4d97b92e3a9bc721b
+size 183884

outputs/malayalam_longer.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7133da9823cdb78dcf9d185e8e7450d61ebc838dfeaac83f67335fa10efce164
+size 437804

reference.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cec481b61ddbd033f8a6ff2d91576459672deb61403d8be58619634061978179
+size 385424

requirements.txt

@@ -0,0 +1,16 @@
+# DhVaani-0.5 CPU inference — pinned to what was actually installed/tested.
+# Install torch/torchaudio for your machine FIRST (CPU wheels shown):
+#   pip install torch torchaudio
+# then:
+#   pip install -r requirements.txt
+
+transformers>=4.40,<5
+torch
+torchaudio
+numpy
+soundfile
+safetensors
+einops
+vocos
+huggingface_hub
+pydub          # only needed for the mp3 export step (uses system ffmpeg)

run_log.txt

@@ -0,0 +1,13 @@
+[info] device = cpu
+[info] loading ARTPARK-IISc/DhVaani-0.5 (AutoModel, trust_remote_code=True) ...
+
+WARNING:root:Failed import k2 with error No module named 'k2'. Swoosh functions will fallback to PyTorch implementation, leading to slower speed and higher memory consumption.
+[info] model loaded in 11.68s
+
+[run] 'malayalam_greeting': 'നമസ്\u200cകാരം, സുഖമാണോ?'
+[result] gen_time=43.043s  audio_len=3.328s  RTF=12.934  (RTF<1 means faster than real-time)
+
+[run] 'malayalam_longer': 'ഇന്ന് കാലാവസ്ഥ വളരെ നല്ലതാണ്. നമുക്ക് പുറത്തു പോകാം.'
+[result] gen_time=69.043s  audio_len=9.120s  RTF=7.571  (RTF<1 means faster than real-time)
+
+[done] summary written to /Users/pengu/Documents/kupe/kupe-tts/outputs/latency.json

tts_data_gen/build_cost_eda_html.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python3
+"""Build a self-contained HTML EDA report from generation_costs.csv."""
+
+from __future__ import annotations
+
+import csv
+import json
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+DIR = Path(__file__).resolve().parent
+CSV_PATH = DIR / "generation_costs.csv"
+OUT_PATH = DIR / "cost_eda_report.html"
+
+CATEGORY_TARGETS = {
+    "pure_hindi": 13750,
+    "hinglish": 5000,
+    "numeric_entity": 2500,
+    "prosody": 2500,
+    "named_entity": 1250,
+}
+TOTAL_TARGET = sum(CATEGORY_TARGETS.values())
+
+
+def fnum(v, d=0.0) -> float:
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return d
+
+
+def inum(v, d=0) -> int:
+    try:
+        return int(float(v))
+    except (TypeError, ValueError):
+        return d
+
+
+def load_rows(path: Path) -> list[dict]:
+    with path.open("r", encoding="utf-8", newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def build(rows: list[dict]) -> dict:
+    by_cat = defaultdict(lambda: {
+        "batches": 0, "items": 0, "prompt": 0, "cached": 0,
+        "completion": 0, "cost": 0.0,
+    })
+    prompt = cached = completion = items = 0
+    sum_cost = 0.0
+    cum = 0.0
+    req_costs = []
+
+    clean_rows = []
+    for r in rows:
+        cat = r.get("category") or "unknown"
+        it = inum(r.get("items"))
+        pt = inum(r.get("prompt_tokens"))
+        ct = inum(r.get("cached_tokens"))
+        ot = inum(r.get("completion_tokens"))
+        cost = fnum(r.get("cost_inr"))
+        cum = fnum(r.get("cum_cost_inr"), cum)
+        hit = fnum(r.get("cache_hit_pct"))
+
+        items += it
+        prompt += pt
+        cached += ct
+        completion += ot
+        sum_cost += cost
+        req_costs.append(cost)
+
+        b = by_cat[cat]
+        b["batches"] += 1
+        b["items"] += it
+        b["prompt"] += pt
+        b["cached"] += ct
+        b["completion"] += ot
+        b["cost"] += cost
+
+        clean_rows.append({
+            "ts": r.get("timestamp_utc") or "",
+            "batch": inum(r.get("batch_num")),
+            "category": cat,
+            "topic": r.get("topic") or "",
+            "items": it,
+            "prompt": pt,
+            "cached": ct,
+            "uncached": inum(r.get("uncached_input_tokens")),
+            "completion": ot,
+            "total": inum(r.get("total_tokens")) or (pt + ot),
+            "kv_pct": hit,
+            "cost": round(cost, 6),
+            "cum": round(fnum(r.get("cum_cost_inr")), 6),
+            "per_item": fnum(r.get("cost_per_item_inr")),
+            "corpus": inum(r.get("corpus_items")),
+            "left": inum(r.get("corpus_left")),
+        })
+
+    if cum <= 0:
+        cum = sum_cost
+
+    recent = rows[-20:] if rows else []
+    r_prompt = sum(inum(r.get("prompt_tokens")) for r in recent)
+    r_cached = sum(inum(r.get("cached_tokens")) for r in recent)
+
+    cats = []
+    for name, target in CATEGORY_TARGETS.items():
+        b = by_cat[name]
+        cats.append({
+            "category": name,
+            "target": target,
+            "have": b["items"],
+            "left": max(target - b["items"], 0),
+            "pct": round(100.0 * b["items"] / target, 1) if target else 0,
+            "batches": b["batches"],
+            "prompt": b["prompt"],
+            "cached": b["cached"],
+            "completion": b["completion"],
+            "cost": round(b["cost"], 4),
+            "kv_pct": round(100.0 * b["cached"] / b["prompt"], 1) if b["prompt"] else 0,
+        })
+    # any unexpected categories
+    for name, b in by_cat.items():
+        if name in CATEGORY_TARGETS:
+            continue
+        cats.append({
+            "category": name,
+            "target": 0,
+            "have": b["items"],
+            "left": 0,
+            "pct": 0,
+            "batches": b["batches"],
+            "prompt": b["prompt"],
+            "cached": b["cached"],
+            "completion": b["completion"],
+            "cost": round(b["cost"], 4),
+            "kv_pct": round(100.0 * b["cached"] / b["prompt"], 1) if b["prompt"] else 0,
+        })
+
+    done = items  # from CSV item sums; may exceed target slightly
+    left = max(TOTAL_TARGET - done, 0)
+    per_utt = cum / done if done else 0
+    per_req = (sum(req_costs) / len(req_costs)) if req_costs else 0
+
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "source": str(CSV_PATH.name),
+        "batches": len(rows),
+        "items": done,
+        "target": TOTAL_TARGET,
+        "left": left,
+        "pct": round(100.0 * done / TOTAL_TARGET, 1) if TOTAL_TARGET else 0,
+        "spent": round(cum, 4),
+        "sum_cost": round(sum_cost, 4),
+        "est_left": round(per_utt * left, 4),
+        "est_total": round(cum + per_utt * left, 4),
+        "per_utt": round(per_utt, 6),
+        "per_req": round(per_req, 4),
+        "last_req": round(req_costs[-1], 4) if req_costs else 0,
+        "prompt": prompt,
+        "cached": cached,
+        "completion": completion,
+        "kv_all": round(100.0 * cached / prompt, 1) if prompt else 0,
+        "kv_recent": round(100.0 * r_cached / r_prompt, 1) if r_prompt else 0,
+        "categories": cats,
+        "rows": clean_rows,
+    }
+
+
+HTML = r"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Corpus Cost EDA</title>
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js"></script>
+<style>
+  :root {
+    --bg: #0f1419;
+    --panel: #1a222c;
+    --line: #2a3542;
+    --text: #e7eef6;
+    --muted: #8b9aab;
+    --accent: #3dd6c6;
+    --warn: #f0b429;
+    --danger: #ff6b6b;
+    --ok: #6bcb77;
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; font-family: "IBM Plex Sans", "Segoe UI", system-ui, sans-serif;
+    background: radial-gradient(1200px 600px at 10% -10%, #1b2a33 0%, var(--bg) 55%);
+    color: var(--text); line-height: 1.45;
+  }
+  header {
+    padding: 28px 32px 12px; border-bottom: 1px solid var(--line);
+  }
+  header h1 { margin: 0 0 6px; font-size: 1.6rem; letter-spacing: -0.02em; }
+  header p { margin: 0; color: var(--muted); font-size: 0.92rem; }
+  main { padding: 24px 32px 48px; max-width: 1400px; margin: 0 auto; }
+  .grid { display: grid; gap: 14px; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); margin: 18px 0 28px; }
+  .card {
+    background: var(--panel); border: 1px solid var(--line); border-radius: 12px;
+    padding: 14px 16px;
+  }
+  .card .label { color: var(--muted); font-size: 0.78rem; text-transform: uppercase; letter-spacing: 0.06em; }
+  .card .value { font-size: 1.45rem; font-weight: 650; margin-top: 4px; }
+  .card .sub { color: var(--muted); font-size: 0.82rem; margin-top: 2px; }
+  .accent { color: var(--accent); }
+  .warn { color: var(--warn); }
+  .danger { color: var(--danger); }
+  .ok { color: var(--ok); }
+  h2 { font-size: 1.05rem; margin: 28px 0 12px; }
+  .charts { display: grid; gap: 16px; grid-template-columns: 1.2fr 1fr; }
+  @media (max-width: 900px) { .charts { grid-template-columns: 1fr; } }
+  .panel {
+    background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 16px;
+  }
+  table { width: 100%; border-collapse: collapse; font-size: 0.84rem; }
+  th, td { padding: 8px 10px; border-bottom: 1px solid var(--line); text-align: left; white-space: nowrap; }
+  th { color: var(--muted); font-weight: 600; position: sticky; top: 0; background: #1e2833; z-index: 1; }
+  tr:hover td { background: rgba(61,214,198,0.06); }
+  .table-wrap { max-height: 520px; overflow: auto; border: 1px solid var(--line); border-radius: 10px; }
+  .toolbar { display: flex; gap: 10px; flex-wrap: wrap; margin-bottom: 10px; align-items: center; }
+  input, select {
+    background: #12181f; color: var(--text); border: 1px solid var(--line);
+    border-radius: 8px; padding: 8px 10px; font: inherit;
+  }
+  .bar {
+    height: 8px; background: #243040; border-radius: 99px; overflow: hidden; min-width: 80px;
+  }
+  .bar > span { display: block; height: 100%; background: linear-gradient(90deg, #2bbbad, #6bcb77); }
+  .pill {
+    display: inline-block; padding: 2px 8px; border-radius: 999px; font-size: 0.75rem;
+    background: #243040; color: var(--muted);
+  }
+</style>
+</head>
+<body>
+<header>
+  <h1>Corpus generation — cost EDA</h1>
+  <p id="meta">Loading…</p>
+</header>
+<main>
+  <div class="grid" id="cards"></div>
+
+  <h2>Progress by category</h2>
+  <div class="panel table-wrap" style="max-height:none; overflow:visible">
+    <table id="catTable">
+      <thead>
+        <tr>
+          <th>Category</th><th>Have</th><th>Target</th><th>Left</th><th>Progress</th>
+          <th>Batches</th><th>Prompt</th><th>Cached</th><th>KV%</th><th>Cost ₹</th>
+        </tr>
+      </thead>
+      <tbody></tbody>
+    </table>
+  </div>
+
+  <h2>Charts</h2>
+  <div class="charts">
+    <div class="panel"><canvas id="costByCat" height="160"></canvas></div>
+    <div class="panel"><canvas id="kvByCat" height="160"></canvas></div>
+  </div>
+  <div class="panel" style="margin-top:16px"><canvas id="cumCost" height="90"></canvas></div>
+
+  <h2>All batches</h2>
+  <div class="toolbar">
+    <input id="q" placeholder="Filter topic / category…" style="min-width:220px"/>
+    <select id="catFilter"><option value="">All categories</option></select>
+    <span class="pill" id="rowCount"></span>
+  </div>
+  <div class="table-wrap">
+    <table id="allTable">
+      <thead>
+        <tr>
+          <th>#</th><th>UTC</th><th>Cat</th><th>Topic</th><th>Items</th>
+          <th>Prompt</th><th>Cached</th><th>Out</th><th>KV%</th>
+          <th>Cost ₹</th><th>Cum ₹</th><th>Corpus</th>
+        </tr>
+      </thead>
+      <tbody></tbody>
+    </table>
+  </div>
+</main>
+<script>
+const DATA = __DATA__;
+
+function fmt(n, d=2) {
+  if (n == null || Number.isNaN(n)) return "—";
+  return Number(n).toLocaleString(undefined, { maximumFractionDigits: d, minimumFractionDigits: d });
+}
+function fmtInt(n) {
+  return Number(n || 0).toLocaleString();
+}
+
+document.getElementById("meta").textContent =
+  `${DATA.source} · ${DATA.batches} batches · generated ${DATA.generated_at}`;
+
+const cards = [
+  ["Spent so far", `₹${fmt(DATA.spent)}`, "warn", `sum of rows ₹${fmt(DATA.sum_cost)}`],
+  ["Est. left", `₹${fmt(DATA.est_left)}`, "danger", `at ₹${fmt(DATA.per_utt, 5)} / utterance`],
+  ["Est. total", `₹${fmt(DATA.est_total)}`, "ok", "spent + est. left"],
+  ["Done", `${fmtInt(DATA.items)} / ${fmtInt(DATA.target)}`, "accent", `${DATA.pct}% · left ${fmtInt(DATA.left)}`],
+  ["Per request", `₹${fmt(DATA.per_req, 4)}`, "", `last ₹${fmt(DATA.last_req, 4)}`],
+  ["KV all-time", `${fmt(DATA.kv_all, 1)}%`, "accent", `${fmtInt(DATA.cached)} / ${fmtInt(DATA.prompt)}`],
+  ["KV recent 20", `${fmt(DATA.kv_recent, 1)}%`, "", "last 20 batches"],
+  ["Tokens out", fmtInt(DATA.completion), "", "completion tokens"],
+];
+document.getElementById("cards").innerHTML = cards.map(([label, value, cls, sub]) => `
+  <div class="card">
+    <div class="label">${label}</div>
+    <div class="value ${cls}">${value}</div>
+    <div class="sub">${sub}</div>
+  </div>
+`).join("");
+
+const catBody = document.querySelector("#catTable tbody");
+catBody.innerHTML = DATA.categories.map(c => `
+  <tr>
+    <td><strong>${c.category}</strong></td>
+    <td>${fmtInt(c.have)}</td>
+    <td>${fmtInt(c.target)}</td>
+    <td>${fmtInt(c.left)}</td>
+    <td>
+      <div style="display:flex;gap:8px;align-items:center">
+        <div class="bar" style="width:100px"><span style="width:${Math.min(c.pct,100)}%"></span></div>
+        ${c.pct}%
+      </div>
+    </td>
+    <td>${fmtInt(c.batches)}</td>
+    <td>${fmtInt(c.prompt)}</td>
+    <td>${fmtInt(c.cached)}</td>
+    <td>${fmt(c.kv_pct,1)}%</td>
+    <td>₹${fmt(c.cost,4)}</td>
+  </tr>
+`).join("");
+
+const catFilter = document.getElementById("catFilter");
+[...new Set(DATA.categories.map(c => c.category))].forEach(c => {
+  const o = document.createElement("option");
+  o.value = c; o.textContent = c; catFilter.appendChild(o);
+});
+
+const allBody = document.querySelector("#allTable tbody");
+function renderRows() {
+  const q = document.getElementById("q").value.trim().toLowerCase();
+  const cat = catFilter.value;
+  const filtered = DATA.rows.filter(r => {
+    if (cat && r.category !== cat) return false;
+    if (!q) return true;
+    return (r.topic + " " + r.category).toLowerCase().includes(q);
+  });
+  document.getElementById("rowCount").textContent = `${filtered.length} / ${DATA.rows.length} rows`;
+  allBody.innerHTML = filtered.map((r, i) => `
+    <tr>
+      <td>${r.batch}</td>
+      <td>${(r.ts || "").replace("T"," ").slice(0,19)}</td>
+      <td>${r.category}</td>
+      <td title="${r.topic}">${(r.topic || "").slice(0,28)}</td>
+      <td>${r.items}</td>
+      <td>${r.prompt}</td>
+      <td>${r.cached}</td>
+      <td>${r.completion}</td>
+      <td>${fmt(r.kv_pct,1)}</td>
+      <td>${fmt(r.cost,4)}</td>
+      <td>${fmt(r.cum,4)}</td>
+      <td>${fmtInt(r.corpus)}</td>
+    </tr>
+  `).join("");
+}
+document.getElementById("q").addEventListener("input", renderRows);
+catFilter.addEventListener("change", renderRows);
+renderRows();
+
+new Chart(document.getElementById("costByCat"), {
+  type: "bar",
+  data: {
+    labels: DATA.categories.map(c => c.category),
+    datasets: [{ label: "Cost ₹", data: DATA.categories.map(c => c.cost),
+      backgroundColor: "#3dd6c6aa", borderColor: "#3dd6c6", borderWidth: 1 }]
+  },
+  options: {
+    plugins: { title: { display: true, text: "Cost by category (₹)", color: "#e7eef6" }, legend: { display: false } },
+    scales: {
+      x: { ticks: { color: "#8b9aab" }, grid: { color: "#2a3542" } },
+      y: { ticks: { color: "#8b9aab" }, grid: { color: "#2a3542" } }
+    }
+  }
+});
+
+new Chart(document.getElementById("kvByCat"), {
+  type: "bar",
+  data: {
+    labels: DATA.categories.map(c => c.category),
+    datasets: [{ label: "KV %", data: DATA.categories.map(c => c.kv_pct),
+      backgroundColor: "#f0b429aa", borderColor: "#f0b429", borderWidth: 1 }]
+  },
+  options: {
+    plugins: { title: { display: true, text: "KV cache hit % by category", color: "#e7eef6" }, legend: { display: false } },
+    scales: {
+      x: { ticks: { color: "#8b9aab" }, grid: { color: "#2a3542" } },
+      y: { ticks: { color: "#8b9aab" }, grid: { color: "#2a3542" }, max: 100 }
+    }
+  }
+});
+
+const step = Math.max(1, Math.floor(DATA.rows.length / 80));
+const cumLabels = [], cumVals = [];
+DATA.rows.forEach((r, i) => {
+  if (i % step === 0 || i === DATA.rows.length - 1) {
+    cumLabels.push(String(i + 1));
+    cumVals.push(r.cum);
+  }
+});
+new Chart(document.getElementById("cumCost"), {
+  type: "line",
+  data: {
+    labels: cumLabels,
+    datasets: [{ label: "Cumulative ₹", data: cumVals, borderColor: "#6bcb77",
+      backgroundColor: "#6bcb7733", fill: true, tension: 0.25, pointRadius: 0 }]
+  },
+  options: {
+    plugins: { title: { display: true, text: "Cumulative spend over batches", color: "#e7eef6" }, legend: { display: false } },
+    scales: {
+      x: { ticks: { color: "#8b9aab", maxTicksLimit: 12 }, grid: { color: "#2a3542" }, title: { display: true, text: "batch index", color: "#8b9aab" } },
+      y: { ticks: { color: "#8b9aab" }, grid: { color: "#2a3542" } }
+    }
+  }
+});
+</script>
+</body>
+</html>
+"""
+
+
+def main():
+    rows = load_rows(CSV_PATH)
+    data = build(rows)
+    html = HTML.replace("__DATA__", json.dumps(data, ensure_ascii=False))
+    OUT_PATH.write_text(html, encoding="utf-8")
+    print(f"Wrote {OUT_PATH}")
+    print(
+        f"Spent ₹{data['spent']:.4f} · items {data['items']:,}/{data['target']:,} "
+        f"· KV {data['kv_all']}% · batches {data['batches']}"
+    )
+
+
+if __name__ == "__main__":
+    main()

tts_data_gen/cost_eda.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Live cost/progress monitor — clean, minimal, 1s refresh.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import sys
+import time
+from pathlib import Path
+
+from tqdm import tqdm
+
+DIR = Path(__file__).resolve().parent
+COST_CSV = DIR / "generation_costs.csv"
+CORPUS_JSONL = DIR / "hindi_tts_corpus.jsonl"
+INTERVAL_SEC = 1.0
+
+CATEGORY_TARGETS = {
+    "pure_hindi":     13750,
+    "hinglish":        5000,
+    "numeric_entity":  2500,
+    "prosody":         2500,
+    "named_entity":    1250,
+}
+TOTAL_TARGET = sum(CATEGORY_TARGETS.values())
+
+
+class C:
+    R = "\033[0m"
+    B = "\033[1m"
+    D = "\033[2m"
+    RED = "\033[91m"
+    GRN = "\033[92m"
+    YLW = "\033[93m"
+    CYN = "\033[96m"
+    MAG = "\033[95m"
+    WHT = "\033[97m"
+    BG = "\033[44m"
+
+
+CAT_COLOR = {
+    "pure_hindi": C.GRN,
+    "hinglish": C.CYN,
+    "numeric_entity": C.YLW,
+    "prosody": C.MAG,
+    "named_entity": "\033[94m",
+}
+
+
+def col(text, *styles):
+    return "".join(styles) + str(text) + C.R
+
+
+def fnum(v, d=0.0):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return d
+
+
+def inum(v, d=0):
+    try:
+        return int(float(v))
+    except (TypeError, ValueError):
+        return d
+
+
+def load_csv(path: Path) -> list[dict]:
+    if not path.exists() or path.stat().st_size == 0:
+        return []
+    with path.open("r", encoding="utf-8", newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def load_counts(path: Path) -> dict[str, int]:
+    counts = {k: 0 for k in CATEGORY_TARGETS}
+    if not path.exists():
+        return counts
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                r = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            t = r.get("type")
+            if t in counts:
+                counts[t] += 1
+    return counts
+
+
+def summarize(rows: list[dict], counts: dict[str, int]) -> dict:
+    prompt = cached = completion = 0
+    sum_cost = 0.0
+    cum = 0.0
+    req_costs = []
+    last_ts = ""
+
+    for r in rows:
+        prompt += inum(r.get("prompt_tokens"))
+        cached += inum(r.get("cached_tokens"))
+        completion += inum(r.get("completion_tokens"))
+        cost = fnum(r.get("cost_inr"))
+        sum_cost += cost
+        req_costs.append(cost)
+        cum = fnum(r.get("cum_cost_inr"), cum)
+        last_ts = r.get("timestamp_utc") or last_ts
+
+    if cum <= 0:
+        cum = sum_cost
+
+    # Recent window = last 20 batches (ignore old SSE zeros)
+    recent = rows[-20:] if rows else []
+    r_prompt = sum(inum(r.get("prompt_tokens")) for r in recent)
+    r_cached = sum(inum(r.get("cached_tokens")) for r in recent)
+    kv_all = 100.0 * cached / prompt if prompt else 0.0
+    kv_recent = 100.0 * r_cached / r_prompt if r_prompt else 0.0
+
+    done = sum(counts.values())
+    left = max(TOTAL_TARGET - done, 0)
+    pct = 100.0 * done / TOTAL_TARGET if TOTAL_TARGET else 0.0
+
+    per_utt = cum / done if done else 0.0
+    per_req = (sum(req_costs) / len(req_costs)) if req_costs else 0.0
+    last_req = req_costs[-1] if req_costs else 0.0
+    est_left = per_utt * left
+    est_total = cum + est_left
+
+    progress = {}
+    for cat, target in CATEGORY_TARGETS.items():
+        have = counts.get(cat, 0)
+        progress[cat] = {
+            "have": have,
+            "target": target,
+            "left": max(target - have, 0),
+            "pct": 100.0 * have / target if target else 0.0,
+        }
+
+    return {
+        "batches": len(rows),
+        "done": done,
+        "left": left,
+        "pct": pct,
+        "kv_all": kv_all,
+        "kv_recent": kv_recent,
+        "cached": cached,
+        "prompt": prompt,
+        "r_cached": r_cached,
+        "r_prompt": r_prompt,
+        "spent": cum,
+        "per_utt": per_utt,
+        "per_req": per_req,
+        "last_req": last_req,
+        "est_left": est_left,
+        "est_total": est_total,
+        "last_ts": last_ts,
+        "progress": progress,
+    }
+
+
+def render(s: dict, tick: int) -> str:
+    spent = f"₹{s['spent']:.2f}"
+    est_left = f"₹{s['est_left']:.2f}"
+    est_total = f"₹{s['est_total']:.2f}"
+    kv_r = f"{s['kv_recent']:.1f}%"
+    kv_a = f"{s['kv_all']:.1f}%"
+    lines = [
+        col("=" * 64, C.CYN, C.B),
+        col(" CORPUS COST ", C.BG, C.WHT, C.B) + col(f"  #{tick}  ·  1s", C.D),
+        col("=" * 64, C.CYN),
+        "",
+        f"  {col('SPENT SO FAR', C.B)}     {col(spent, C.YLW, C.B)}",
+        f"  {col('EST. LEFT', C.B)}        {col(est_left, C.RED, C.B)}",
+        f"  {col('EST. TOTAL', C.B)}       {col(est_total, C.GRN, C.B)}",
+        "",
+        f"  {col('DONE', C.GRN, C.B)}  {s['done']:,} / {TOTAL_TARGET:,}  ({s['pct']:.1f}%)"
+        f"   {col('LEFT', C.RED, C.B)}  {s['left']:,}",
+        "",
+        f"  {col('per utterance', C.B)}   ₹{s['per_utt']:.5f}",
+        f"  {col('per request', C.B)}     ₹{s['per_req']:.4f}  avg"
+        f"   ·  last ₹{s['last_req']:.4f}",
+        f"  {col('requests', C.B)}        {s['batches']:,}",
+        f"  {col('KV recent', C.B)}       {col(kv_r, C.CYN, C.B)}"
+        f"  last 20  ({s['r_cached']:,}/{s['r_prompt']:,})",
+        f"  {col('KV all-time', C.B)}      {kv_a}"
+        f"  ({s['cached']:,}/{s['prompt']:,})",
+        "",
+        col("-" * 64, C.D),
+    ]
+    return "\n".join(lines)
+
+
+def main():
+    cost_path = Path(sys.argv[1]) if len(sys.argv) > 1 else COST_CSV
+    corpus_path = Path(sys.argv[2]) if len(sys.argv) > 2 else CORPUS_JSONL
+
+    overall = tqdm(
+        total=TOTAL_TARGET,
+        desc=col("total 25k", C.GRN, C.B),
+        unit="utt",
+        position=0,
+        leave=True,
+        colour="green",
+        dynamic_ncols=True,
+        bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} {percentage:3.0f}%",
+    )
+    cat_bars = {}
+    for i, (cat, target) in enumerate(CATEGORY_TARGETS.items(), start=1):
+        cat_bars[cat] = tqdm(
+            total=target,
+            desc=col(f"{cat:16s}", CAT_COLOR.get(cat, C.WHT)),
+            unit="utt",
+            position=i,
+            leave=True,
+            colour="cyan",
+            dynamic_ncols=True,
+            bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} {percentage:3.0f}%",
+        )
+
+    tick = 0
+    try:
+        while True:
+            tick += 1
+            s = summarize(load_csv(cost_path), load_counts(corpus_path))
+            tqdm.write("\033[2J\033[H")
+            tqdm.write(render(s, tick))
+
+            overall.n = min(s["done"], TOTAL_TARGET)
+            overall.refresh()
+            for cat, bar in cat_bars.items():
+                bar.n = min(s["progress"][cat]["have"], bar.total)
+                bar.refresh()
+
+            time.sleep(INTERVAL_SEC)
+    except KeyboardInterrupt:
+        tqdm.write(col("\nstopped.", C.YLW))
+    finally:
+        overall.close()
+        for bar in cat_bars.values():
+            bar.close()
+
+
+if __name__ == "__main__":
+    main()

tts_data_gen/text_gen_agent.py

@@ -0,0 +1,789 @@
+#!/usr/bin/env python3
+"""
+Hindi/Hinglish TTS Text-Corpus Generator
+==========================================
+Generates diverse text utterances for a single-speaker Hindi streaming TTS
+finetune (Qwen3-TTS-0.6B-Base), to later be synthesized into audio via OmniVoice.
+
+Model : gemma4 via Sarvam open-source chat completions (v2)
+       https://docs.sarvam.ai/api-reference/open-source/chat-completions
+Output: hindi_tts_corpus.jsonl  (one JSON object per line -> crash-safe, resumable)
+Cost  : generation_costs.csv   (per-batch tokens + INR cost)
+
+Features:
+  - SSE streaming: tokens printed live as they arrive
+  - No reasoning (reasoning_effort=None)
+  - Concurrent requests (ThreadPoolExecutor)
+  - Per-category waves (stable prompt prefix for KV cache)
+  - Flush JSONL after every completed batch
+
+Requires Python 3.9+.
+"""
+
+from __future__ import annotations
+
+import csv
+import itertools
+import json
+import os
+import re
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+
+from openai import OpenAI
+
+# Devanagari only for pure_hindi. Reject Gujarati + other Indic scripts + Latin.
+_DEVANAGARI_RE = re.compile(r"[\u0900-\u097F]")
+_FORBIDDEN_SCRIPT_RE = re.compile(
+    r"[A-Za-z"
+    r"\u0980-\u09FF"  # Bengali
+    r"\u0A00-\u0A7F"  # Gurmukhi
+    r"\u0A80-\u0AFF"  # Gujarati  ← common leak
+    r"\u0B00-\u0B7F"  # Oriya
+    r"\u0B80-\u0BFF"  # Tamil
+    r"\u0C00-\u0C7F"  # Telugu
+    r"\u0C80-\u0CFF"  # Kannada
+    r"\u0D00-\u0D7F"  # Malayalam
+    r"]"
+)
+
+# ----------------------------------------------------------------------------
+# CONFIG
+# ----------------------------------------------------------------------------
+
+SARVAM_API_KEY = os.environ.get("SARVAM_API_KEY", "")
+# Open-source models endpoint (gemma4 / glm5.2 / sarvam-105b)
+BASE_URL = "https://api.sarvam.ai/v2"
+MODEL = "gemma4"
+
+OUTPUT_FILE = Path("hindi_tts_corpus.jsonl")
+COST_CSV = Path("generation_costs.csv")
+
+BATCH_SIZE = 40
+CONTEXT_EXAMPLES = 0     # keep suffix tiny → max KV hits (topics rotate for diversity)
+MAX_RETRIES = 5
+MAX_TOKENS = 4096
+CONCURRENCY = 30
+USE_STREAM = os.environ.get("SARVAM_STREAM", "1") == "1"
+WARM_CACHE_FIRST = True
+
+# Gemma-4 31B · INR per 1M tokens (input / cached / output)
+PRICE_INPUT_PER_M = 36.60
+PRICE_CACHED_PER_M = 13.73
+PRICE_OUTPUT_PER_M = 91.50
+
+CATEGORY_TARGETS = {
+    "pure_hindi":     13750,
+    "hinglish":        5000,
+    "numeric_entity":  2500,
+    "prosody":         2500,
+    "named_entity":    1250,
+}
+
+CATEGORY_RULES = {
+    "pure_hindi": (
+        "STRICT Pure Hindi ONLY. Write in Hindi language using Devanagari script "
+        "(अ आ इ ई क ख ग …) exclusively. "
+        "FORBIDDEN: Gujarati (અ આ ક ખ), Bengali, Tamil, Telugu, Kannada, Malayalam, "
+        "Punjabi/Gurmukhi, English/Latin letters, and ASCII digits (spell numbers as "
+        "words: बारह, पच्चीस). "
+        "If you output any non-Devanagari Indic script the batch is invalid. "
+        "Natural spoken Hindi prose. Vary length: short (5-8), medium (10-15), "
+        "long (18-25) words. Everyday fluent register. Maximize consonant conjuncts."
+    ),
+    "hinglish": (
+        "Hinglish / code-mixed: Devanagari + Latin mixed in the SAME sentence, with "
+        "English loanwords, brands, or English clauses inside Hindi structure "
+        "(e.g. 'yaar maine abhi Swiggy pe order kiya, bohot deri ho rahi hai'). "
+        "Authentic casual, never forced."
+    ),
+    "numeric_entity": (
+        "Every sentence MUST contain at least one of: number, date, currency "
+        "(rupees / Rs. / numeral), phone-style digits, time, or address+pin. "
+        "Mix digit-form and spoken-word form across the batch."
+    ),
+    "prosody": (
+        "Short-to-medium sentences with strong emotional shape: questions ending ?, "
+        "exclamations ending !, or short interjections. Real conversational reactions."
+    ),
+    "named_entity": (
+        "Every sentence MUST include at least one real-sounding Indian proper noun "
+        "(person, place, or brand) in a full sentence - never a bare name list."
+    ),
+}
+
+TOPICS = {
+    "pure_hindi": [
+        "सुबह की दिनचर्या", "मानसून का मौसम", "पारिवारिक रिश्ते", "त्योहार और उत्सव",
+        "भारतीय व्यंजन", "गांव का जीवन", "शहर की भागदौड़", "स्कूल के दिन", "दोस्ती",
+        "यात्रा के अनुभव", "किताबें और पढ़ाई", "संगीत और कला", "स्वास्थ्य और योग",
+        "प्रकृति और पर्यावरण", "त्यौहारों की खरीदारी", "क्रिकेट और खेल",
+        "बचपन की यादें", "बाजार का माहौल", "मानसिक शांति", "सामाजिक जिम्मेदारी",
+    ],
+    "hinglish": [
+        "food delivery apps par order", "office ki daily chat",
+        "college friends ki baatcheet", "Instagram reels par comments",
+        "WhatsApp family group", "cab booking Uber/Ola",
+        "online shopping Flipkart/Amazon", "gym aur fitness goals",
+        "startup aur job interview", "movies aur OTT shows",
+        "cricket match commentary", "wedding planning",
+        "travel vlogging", "college assignments aur deadlines",
+        "relationship advice",
+    ],
+    "numeric_entity": [
+        "bank account aur transactions", "train/flight ticket booking",
+        "restaurant bill aur tip", "property ki keemat", "mobile recharge plans",
+        "electricity bill", "birthday aur anniversary dates",
+        "school admission fees", "online shopping cart total",
+        "delivery address aur pin code", "salary aur EMI", "grocery shopping list",
+    ],
+    "prosody": [
+        "अचानक अच्छी खबर", "गुस्से में बहस", "हैरानी भरी घटना", "डर या चिंता",
+        "खुशी का पल", "निराशा और अफसोस", "जल्दी में निकलना",
+        "किसी को चेतावनी देना", "तारीफ करना", "मदद मांगना",
+        "अजनबी से प्रश्न पूछना", "उत्सव में उत्साह",
+    ],
+    "named_entity": [
+        "मशहूर भारतीय हस्तियां", "प्रसिद्ध भारतीय शहर और स्मारक",
+        "भारतीय ब्रांड्स और कंपनियां", "बॉलीवुड सितारे", "भारतीय क्रिकेटर",
+        "राजनेता और इतिहास", "प्रसिद्ध भारतीय रेस्टोरेंट चेन",
+        "टेक कंपनियां भारत में", "प्रसिद्ध पर्यटन स्थल",
+        "भारतीय राज्यों की राजधानियां",
+    ],
+}
+
+SYSTEM_PROMPT = (
+    "You generate spoken Hindi/Hinglish TTS training utterances. "
+    "Write exactly as spoken. No markdown, bullets, emojis, asterisks, hashtags, URLs. "
+    "Spell out ambiguous abbreviations the way a speaker says them. "
+    "Each sentence self-contained. Everyday spoken register. "
+    "Never repeat near-duplicates inside a batch. "
+    "CRITICAL: For category pure_hindi use ONLY Hindi in Devanagari. "
+    "Never Gujarati, never any other Indian script. "
+    "Return ONLY raw JSON. No prose. No code fences. "
+    # Static pad — longer identical system prefix → higher Sarvam prompt-cache hit rate.
+    "STYLE: natural conversational TTS lines, varied openings, no lists, no meta talk. "
+    "OUTPUT: JSON object with key items; each item has text and notes. "
+    "QUALITY: phoneme-rich Hindi where required; authentic code-mix for hinglish; "
+    "explicit numbers/dates for numeric_entity; strong ?/! for prosody; "
+    "real Indian names/places/brands for named_entity. "
+    "REPEAT THIS CONTRACT EVERY CALL: same system instructions, same schema, "
+    "only the trailing topic line of the user message may change."
+)
+
+
+def category_stable_prefix(category: str) -> str:
+    return (
+        f"Category: {category}\n"
+        f"Rules: {CATEGORY_RULES[category]}\n\n"
+        f"Return exactly this JSON shape with exactly {BATCH_SIZE} items:\n"
+        f'{{"items":[{{"text":"...","notes":"tag"}}, ...]}}\n'
+        f'"text" = spoken sentence (prefer <=20 words). "notes" = 1-3 word tag.\n'
+        f"Keep JSON compact. Vary openings inside the batch.\n"
+        f"Do not copy the topic wording verbatim into every line.\n"
+    )
+
+
+def build_user_message(category: str, topic: str, examples: list[str], salt: int) -> tuple[str, str, str]:
+    """Returns (full_user_message, stable_prefix, variable_suffix)."""
+    prefix = category_stable_prefix(category)
+    suffix = f"\nTopic: {topic}\nGenerate {BATCH_SIZE} now."
+    return prefix + suffix, prefix, suffix
+
+
+_ITEM_PAIR_RE = re.compile(
+    r'"text"\s*:\s*"((?:\\.|[^"\\])*)"\s*,\s*"notes"\s*:\s*"((?:\\.|[^"\\])*)"',
+)
+_TEXT_ONLY_RE = re.compile(r'"text"\s*:\s*"((?:\\.|[^"\\])*)"')
+
+
+def _unescape_json_str(s: str) -> str:
+    try:
+        return json.loads(f'"{s}"')
+    except json.JSONDecodeError:
+        return s.replace('\\"', '"').replace("\\n", "\n")
+
+
+def parse_items_lenient(raw: str) -> list[dict]:
+    """Parse items JSON; if truncated mid-string, recover complete text/notes pairs."""
+    text = (raw or "").strip()
+    if text.startswith("```"):
+        text = re.sub(r"^```(?:json)?\s*", "", text)
+        text = re.sub(r"\s*```$", "", text)
+
+    try:
+        data = json.loads(text)
+        items = data.get("items")
+        if isinstance(items, list) and items:
+            return items
+    except json.JSONDecodeError:
+        pass
+
+    items: list[dict] = []
+    for m in _ITEM_PAIR_RE.finditer(text):
+        items.append({
+            "text": _unescape_json_str(m.group(1)),
+            "notes": _unescape_json_str(m.group(2)),
+        })
+    if not items:
+        for m in _TEXT_ONLY_RE.finditer(text):
+            items.append({"text": _unescape_json_str(m.group(1)), "notes": ""})
+
+    if not items:
+        raise ValueError(f"no recoverable items (raw_chars={len(text)})")
+    return items
+
+CSV_FIELDS = [
+    "timestamp_utc",
+    "batch_num",
+    "category",
+    "topic",
+    "items",
+    "prompt_tokens",
+    "cached_tokens",
+    "uncached_input_tokens",
+    "completion_tokens",
+    "total_tokens",
+    "cache_hit_pct",
+    "cache_reported",
+    "prefix_share_pct",
+    "est_cacheable_tokens",
+    "cost_inr",
+    "cost_if_prefix_cached_inr",
+    "run_cost_inr",
+    "cum_cost_inr",
+    "cost_per_item_inr",
+    "cost_per_1k_out_inr",
+    "corpus_items",
+    "corpus_left",
+]
+
+print_lock = threading.Lock()
+io_lock = threading.Lock()
+
+
+def is_valid_text(category: str, text: str) -> bool:
+    """Hard reject wrong-script leaks (esp. Gujarati in pure_hindi)."""
+    if not text or not text.strip():
+        return False
+    if category == "pure_hindi":
+        if not _DEVANAGARI_RE.search(text):
+            return False
+        if _FORBIDDEN_SCRIPT_RE.search(text):
+            return False
+    return True
+
+
+def usage_to_dict(usage) -> dict:
+    if usage is None:
+        return {}
+    if isinstance(usage, dict):
+        return usage
+    try:
+        return usage.model_dump()
+    except Exception:
+        return {
+            "prompt_tokens": getattr(usage, "prompt_tokens", None),
+            "completion_tokens": getattr(usage, "completion_tokens", None),
+            "total_tokens": getattr(usage, "total_tokens", None),
+            "prompt_tokens_details": getattr(usage, "prompt_tokens_details", None),
+            "completion_tokens_details": getattr(usage, "completion_tokens_details", None),
+        }
+
+
+def extract_cached_tokens(usage) -> tuple[int, bool]:
+    """
+    Return (cached_tokens, reported).
+    reported=False means Sarvam left prompt_tokens_details null — cannot meter KV hits.
+    """
+    dumped = usage_to_dict(usage)
+    if not dumped:
+        return 0, False
+
+    # Common OpenAI-style locations
+    candidates = []
+    ptd = dumped.get("prompt_tokens_details")
+    if isinstance(ptd, dict):
+        for key in (
+            "cached_tokens",
+            "cache_read_input_tokens",
+            "cached_prompt_tokens",
+            "prompt_cache_hit_tokens",
+        ):
+            if ptd.get(key) is not None:
+                candidates.append(int(ptd.get(key) or 0))
+    for key in (
+        "cached_tokens",
+        "cache_read_input_tokens",
+        "cached_prompt_tokens",
+    ):
+        if dumped.get(key) is not None:
+            candidates.append(int(dumped.get(key) or 0))
+
+    if ptd is None and not candidates:
+        return 0, False
+    if not candidates:
+        return 0, True  # details present but zero
+    return max(candidates), True
+
+
+def estimate_prefix_cacheable(prompt_tokens: int, stable_chars: int, total_chars: int) -> tuple[int, float]:
+    """Heuristic: share of prompt that is our byte-stable prefix (KV-friendly design)."""
+    if prompt_tokens <= 0 or total_chars <= 0:
+        return 0, 0.0
+    share = min(max(stable_chars / total_chars, 0.0), 1.0)
+    est = int(round(prompt_tokens * share))
+    return est, 100.0 * share
+
+
+def calc_cost_inr(prompt_tokens: int, cached_tokens: int, completion_tokens: int) -> float:
+    """
+    Sarvam 105B ₹/1M: input 29.28 / cached 10.98 / output 73.20
+    cost = uncached_input * 29.28 + cached * 10.98 + output * 73.20  (per 1M)
+    """
+    cached = min(max(int(cached_tokens), 0), max(int(prompt_tokens), 0))
+    uncached = max(int(prompt_tokens) - cached, 0)
+    return (
+        uncached * PRICE_INPUT_PER_M
+        + cached * PRICE_CACHED_PER_M
+        + int(completion_tokens) * PRICE_OUTPUT_PER_M
+    ) / 1_000_000.0
+
+
+def load_existing() -> list:
+    if not OUTPUT_FILE.exists():
+        return []
+    records = []
+    with OUTPUT_FILE.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                records.append(json.loads(line))
+    return records
+
+
+def load_cum_cost_from_csv() -> float:
+    if not COST_CSV.exists():
+        return 0.0
+    last = 0.0
+    with COST_CSV.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            try:
+                last = float(row.get("cum_cost_inr") or 0)
+            except (TypeError, ValueError):
+                continue
+    return last
+
+
+def load_lifetime_completion() -> int:
+    if not COST_CSV.exists():
+        return 0
+    total = 0
+    with COST_CSV.open("r", encoding="utf-8", newline="") as f:
+        for row in csv.DictReader(f):
+            try:
+                total += int(float(row.get("completion_tokens") or 0))
+            except (TypeError, ValueError):
+                continue
+    return total
+
+
+def ensure_cost_csv() -> None:
+    """Create CSV or migrate header when new columns are added."""
+    if not COST_CSV.exists() or COST_CSV.stat().st_size == 0:
+        with COST_CSV.open("w", encoding="utf-8", newline="") as f:
+            csv.DictWriter(f, fieldnames=CSV_FIELDS).writeheader()
+        return
+    with COST_CSV.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        old_fields = list(reader.fieldnames or [])
+        rows = list(reader)
+    if old_fields == CSV_FIELDS:
+        return
+    with COST_CSV.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=CSV_FIELDS, extrasaction="ignore")
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({k: row.get(k, "") for k in CSV_FIELDS})
+
+
+def append_cost_row(row: dict) -> None:
+    with COST_CSV.open("a", encoding="utf-8", newline="") as f:
+        csv.DictWriter(f, fieldnames=CSV_FIELDS).writerow(row)
+        f.flush()
+
+
+def stream_emit(tag: str, text: str, line_start: list[bool]) -> None:
+    """Print SSE tokens live, prefixing each new line with [tag]."""
+    with print_lock:
+        for ch in text:
+            if line_start[0]:
+                sys.stdout.write(f"[{tag}] ")
+                line_start[0] = False
+            sys.stdout.write(ch)
+            if ch == "\n":
+                line_start[0] = True
+        sys.stdout.flush()
+
+
+def call_model_streaming(
+    client: OpenAI,
+    batch_id: int,
+    category: str,
+    topic: str,
+    examples: list[str],
+    salt: int,
+):
+    user_msg, stable_prefix, _suffix = build_user_message(category, topic, examples, salt)
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": user_msg},
+    ]
+    stable_chars = len(SYSTEM_PROMPT) + len(stable_prefix)
+    total_chars = len(SYSTEM_PROMPT) + len(user_msg)
+    tag = f"b{batch_id}"
+    last_err = None
+
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            with print_lock:
+                print(
+                    f"\n===== SSE START [{tag}] {category} | {topic} "
+                    f"(attempt {attempt}) =====",
+                    flush=True,
+                )
+
+            # Always SSE. reasoning_effort=None → no thinking (gemma4).
+            # Docs: https://docs.sarvam.ai/api-reference/open-source/chat-completions
+            stream = client.chat.completions.create(
+                model=MODEL,
+                messages=messages,
+                temperature=1.0,
+                top_p=0.95,
+                max_tokens=MAX_TOKENS,
+                response_format={"type": "json_object"},
+                stream=True,
+                stream_options={"include_usage": True},
+                extra_body={"reasoning_effort": None},
+            )
+            parts: list[str] = []
+            usage = None
+            line_start = [True]
+            for chunk in stream:
+                if getattr(chunk, "usage", None) is not None:
+                    usage = chunk.usage
+                if not chunk.choices:
+                    continue
+                delta = chunk.choices[0].delta
+                # Ignore reasoning_content if any slips through
+                content = getattr(delta, "content", None)
+                if content:
+                    stream_emit(tag, content, line_start)
+                    parts.append(content)
+            raw = "".join(parts).strip()
+
+            items = parse_items_lenient(raw)
+            items = items[:BATCH_SIZE]
+            if not items:
+                raise ValueError("no items after parse")
+
+            with print_lock:
+                cached, reported = extract_cached_tokens(usage)
+                pt = int(getattr(usage, "prompt_tokens", 0) or 0) if usage else 0
+                ct = int(getattr(usage, "completion_tokens", 0) or 0) if usage else 0
+                hit = (100.0 * cached / pt) if pt else 0.0
+                print(
+                    f"\n===== SSE END [{tag}] items={len(items)}/{BATCH_SIZE} "
+                    f"prompt={pt} out={ct} cached={cached} ({hit:.0f}%) =====",
+                    flush=True,
+                )
+
+            return items, usage, stable_chars, total_chars
+
+        except Exception as e:
+            last_err = e
+            wait = min(2 ** attempt, 20)
+            with print_lock:
+                print(
+                    f"  [retry {attempt}/{MAX_RETRIES}] [{tag}] {category}: {e} "
+                    f"-- retrying in {wait}s",
+                    flush=True,
+                )
+            time.sleep(wait)
+
+    raise RuntimeError(f"Failed after {MAX_RETRIES} retries [{tag}] {category}: {last_err}")
+
+
+def main():
+    if not SARVAM_API_KEY:
+        sys.exit("Set SARVAM_API_KEY environment variable first.")
+
+    # v2 open-source endpoint requires api-subscription-key header
+    client = OpenAI(
+        api_key=SARVAM_API_KEY,
+        base_url=BASE_URL,
+        default_headers={"api-subscription-key": SARVAM_API_KEY},
+    )
+    ensure_cost_csv()
+
+    records = load_existing()
+    by_category = {c: [] for c in CATEGORY_TARGETS}
+    for r in records:
+        if r.get("type") in by_category:
+            by_category[r["type"]].append(r["text"])
+
+    counts = {c: len(by_category[c]) for c in CATEGORY_TARGETS}
+    next_index = (max((r["index"] for r in records), default=-1)) + 1
+
+    topic_cycles = {c: itertools.cycle(TOPICS[c]) for c in CATEGORY_TARGETS}
+    for c in CATEGORY_TARGETS:
+        skip = (counts[c] // BATCH_SIZE) % len(TOPICS[c])
+        for _ in range(skip):
+            next(topic_cycles[c])
+
+    total_target = sum(CATEGORY_TARGETS.values())
+    cum_cost = load_cum_cost_from_csv()
+    lifetime_completion = load_lifetime_completion()
+    run_prompt = run_cached = run_completion = run_total = 0
+    run_cost = 0.0
+    batch_num = 0
+    start = time.time()
+
+    print(f"Resuming: {sum(counts.values())} / {total_target} in {OUTPUT_FILE}")
+    print(f"Cost log: {COST_CSV} | prior cum cost ₹{cum_cost:.4f}")
+    print(f"Model: {MODEL} @ {BASE_URL}")
+    print(
+        f"Pricing (₹/1M): input={PRICE_INPUT_PER_M}  "
+        f"cached={PRICE_CACHED_PER_M}  output={PRICE_OUTPUT_PER_M}"
+    )
+    print(
+        "SSE live streaming ON. Truncated JSON is recovered (partial items kept). "
+        "reasoning_effort=None (no thinking)."
+    )
+    print(
+        f"Batch={BATCH_SIZE} | concurrency={CONCURRENCY} | "
+        f"context_examples={CONTEXT_EXAMPLES} | reasoning=off | stream=SSE"
+    )
+    for c, target in CATEGORY_TARGETS.items():
+        print(f"  {c:16s} {counts[c]:>6}/{target}")
+    print()
+
+    with OUTPUT_FILE.open("a", encoding="utf-8") as out_f, ThreadPoolExecutor(
+        max_workers=CONCURRENCY
+    ) as pool:
+        for category, target in CATEGORY_TARGETS.items():
+            if counts[category] >= target:
+                continue
+            print(f"--- category {category} ({counts[category]}/{target}) ---", flush=True)
+
+            while counts[category] < target:
+                remaining = target - counts[category]
+                n_jobs = min(CONCURRENCY, max(1, (remaining + BATCH_SIZE - 1) // BATCH_SIZE))
+                examples_snapshot = list(by_category[category][-CONTEXT_EXAMPLES:]) if CONTEXT_EXAMPLES else []
+
+                jobs = []
+                for i in range(n_jobs):
+                    batch_num += 1
+                    topic = next(topic_cycles[category])
+                    jobs.append({
+                        "batch_id": batch_num,
+                        "category": category,
+                        "topic": topic,
+                        "examples": examples_snapshot,
+                        "salt": batch_num,
+                    })
+
+                def commit(job, items, usage, stable_chars, total_chars):
+                    nonlocal next_index, run_cost, cum_cost, lifetime_completion
+                    nonlocal run_prompt, run_cached, run_completion, run_total
+                    with io_lock:
+                        new_records = []
+                        dropped = 0
+                        for it in items:
+                            text = (it.get("text") or "").strip()
+                            if not text:
+                                continue
+                            if not is_valid_text(category, text):
+                                dropped += 1
+                                continue
+                            rec = {
+                                "index": next_index,
+                                "type": category,
+                                "topic": job["topic"],
+                                "text": text,
+                                "notes": it.get("notes", ""),
+                                "word_count": len(text.split()),
+                                "char_count": len(text),
+                            }
+                            next_index += 1
+                            new_records.append(rec)
+                        if dropped:
+                            with print_lock:
+                                print(
+                                    f"  !! dropped {dropped} bad-script items "
+                                    f"[b{job['batch_id']}] {category}",
+                                    flush=True,
+                                )
+
+                        for rec in new_records:
+                            out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                            by_category[category].append(rec["text"])
+                        out_f.flush()
+                        os.fsync(out_f.fileno())
+
+                        counts[category] += len(new_records)
+
+                        pt = int(getattr(usage, "prompt_tokens", 0) or 0) if usage else 0
+                        ct = int(getattr(usage, "completion_tokens", 0) or 0) if usage else 0
+                        tt = (
+                            int(getattr(usage, "total_tokens", 0) or (pt + ct))
+                            if usage
+                            else (pt + ct)
+                        )
+                        cached, cache_reported = extract_cached_tokens(usage)
+                        uncached = max(pt - cached, 0)
+                        est_cacheable, prefix_share_pct = estimate_prefix_cacheable(
+                            pt, stable_chars, total_chars
+                        )
+                        cost = calc_cost_inr(pt, cached, ct)
+                        cost_if_prefix = calc_cost_inr(pt, est_cacheable, ct)
+                        run_cost += cost
+                        cum_cost += cost
+                        cache_pct = (100.0 * cached / pt) if pt else 0.0
+
+                        run_prompt += pt
+                        run_cached += cached
+                        run_completion += ct
+                        run_total += tt
+                        lifetime_completion += ct
+
+                        corpus_items = sum(counts.values())
+                        corpus_left = max(total_target - corpus_items, 0)
+                        cost_per_item = (cum_cost / corpus_items) if corpus_items else 0.0
+                        cost_per_1k_out = (
+                            (cum_cost * 1000.0 / lifetime_completion)
+                            if lifetime_completion
+                            else 0.0
+                        )
+
+                        append_cost_row({
+                            "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+                            "batch_num": job["batch_id"],
+                            "category": category,
+                            "topic": job["topic"],
+                            "items": len(new_records),
+                            "prompt_tokens": pt,
+                            "cached_tokens": cached,
+                            "uncached_input_tokens": uncached,
+                            "completion_tokens": ct,
+                            "total_tokens": tt,
+                            "cache_hit_pct": f"{cache_pct:.1f}",
+                            "cache_reported": "1" if cache_reported else "0",
+                            "prefix_share_pct": f"{prefix_share_pct:.1f}",
+                            "est_cacheable_tokens": est_cacheable,
+                            "cost_inr": f"{cost:.6f}",
+                            "cost_if_prefix_cached_inr": f"{cost_if_prefix:.6f}",
+                            "run_cost_inr": f"{run_cost:.6f}",
+                            "cum_cost_inr": f"{cum_cost:.6f}",
+                            "cost_per_item_inr": f"{cost_per_item:.8f}",
+                            "cost_per_1k_out_inr": f"{cost_per_1k_out:.6f}",
+                            "corpus_items": corpus_items,
+                            "corpus_left": corpus_left,
+                        })
+
+                        flag = "API" if cache_reported else "no-API-cache-field"
+                        summary = (
+                            f"[batch {job['batch_id']:>5}] {category:15s} "
+                            f"+{len(new_records):<2} ({counts[category]}/{target}) | "
+                            f"{job['topic'][:24]:24s} | "
+                            f"in={pt} cached={cached} ({cache_pct:.0f}% {flag}) "
+                            f"prefix~{prefix_share_pct:.0f}% out={ct} | "
+                            f"₹{cost:.4f} | cum ₹{cum_cost:.4f}"
+                        )
+
+                    with print_lock:
+                        print(summary, flush=True)
+
+                # Warm KV with 1 sequential request, then fan out the rest.
+                parallel_jobs = jobs
+                if WARM_CACHE_FIRST and jobs:
+                    warm = jobs[0]
+                    parallel_jobs = jobs[1:]
+                    print(
+                        f"\n>>> warming KV cache [b{warm['batch_id']}] {category} ...",
+                        flush=True,
+                    )
+                    try:
+                        items, usage, stable_chars, total_chars = call_model_streaming(
+                            client,
+                            warm["batch_id"],
+                            warm["category"],
+                            warm["topic"],
+                            warm["examples"],
+                            warm["salt"],
+                        )
+                        commit(warm, items, usage, stable_chars, total_chars)
+                    except Exception as e:
+                        with print_lock:
+                            print(
+                                f"!! FAILED warm [b{warm['batch_id']}] {category}: {e}",
+                                flush=True,
+                            )
+
+                if not parallel_jobs:
+                    continue
+
+                print(
+                    f"\n>>> launching {len(parallel_jobs)} concurrent requests "
+                    f"for {category} ...",
+                    flush=True,
+                )
+
+                futures = {
+                    pool.submit(
+                        call_model_streaming,
+                        client,
+                        job["batch_id"],
+                        job["category"],
+                        job["topic"],
+                        job["examples"],
+                        job["salt"],
+                    ): job
+                    for job in parallel_jobs
+                }
+
+                for fut in as_completed(futures):
+                    job = futures[fut]
+                    try:
+                        items, usage, stable_chars, total_chars = fut.result()
+                    except Exception as e:
+                        with print_lock:
+                            print(
+                                f"!! FAILED [b{job['batch_id']}] {job['category']}: {e}",
+                                flush=True,
+                            )
+                        continue
+                    commit(job, items, usage, stable_chars, total_chars)
+
+    elapsed = time.time() - start
+    run_cache_pct = (100.0 * run_cached / run_prompt) if run_prompt else 0.0
+    print()
+    print("=" * 72)
+    print(f"DONE. {sum(counts.values())} items in {OUTPUT_FILE}")
+    print(f"This run: {batch_num} API calls in {elapsed / 60:.1f} min")
+    print(
+        f"Tokens — prompt={run_prompt:,}  cached={run_cached:,} "
+        f"({run_cache_pct:.1f}%)  completion={run_completion:,}  total={run_total:,}"
+    )
+    print(f"Cost   — this run ₹{run_cost:.4f}  |  cumulative ₹{cum_cost:.4f}")
+    print(f"Cost CSV: {COST_CSV.resolve()}")
+    print("=" * 72)
+
+
+if __name__ == "__main__":
+    main()