Pattern: score a batch

import asyncio
import json

from thinqit_dex import AsyncClient, DexError, check, pick

MODEL = "dex-1.0.1"
BATCH = "reviews-2026-09"  # names this run; reuse it to resume
CONCURRENCY = 4            # 4 for a test key; a live key: 4, 8 or 16 by plan

QUESTIONS = {
    "topic": pick(
        "What is {{review.text}} mainly about?",
        {"quality": "The product itself", "delivery": "Shipping and delivery", "price": "Price or value",
         "service": "Customer service", "other": None},
        min_confidence=0.5,
    ),
    "wants_contact": check("Does the writer of {{review.text}} ask to be contacted?", min_confidence=0.6),
}


async def score(dex: AsyncClient, sem: asyncio.Semaphore, item: dict) -> dict:
    async with sem:
        try:
            d = await dex.decide(
                state={"review": {"text": item["text"]}},
                questions=QUESTIONS,
                model=MODEL,
                idempotency_key=f"{BATCH}-{item['id']}",
            )
        except DexError as err:
            return {"id": item["id"], "error": str(err)}
    topic, contact = d.pick("topic"), d.check("wants_contact")
    return {
        "id": item["id"],
        "topic": None if topic.abstained else topic.choice,
        "wants_contact": None if contact.abstained else contact.probability >= 0.5,
        "request_id": d.id,
        "model": d.model,
        "input_tokens": d.usage.input_tokens,
    }


async def main() -> None:
    items = [json.loads(line) for line in open("reviews.jsonl", encoding="utf-8")]
    sem = asyncio.Semaphore(CONCURRENCY)
    async with AsyncClient() as dex:  # reads DEX_API_KEY
        results = await asyncio.gather(*(score(dex, sem, item) for item in items))
    with open("scores.jsonl", "w", encoding="utf-8") as out:
        for r in results:
            out.write(json.dumps(r, ensure_ascii=False) + "\n")
    done = [r for r in results if "error" not in r]
    print(len(done), "scored,", len(results) - len(done), "failed,",
          sum(r["topic"] is None for r in done), "topic abstains,",
          sum(r["input_tokens"] for r in done), "input tokens")


asyncio.run(main())

import { readFile, writeFile } from "node:fs/promises";
import { Client, DexError, check, pick } from "@thinqit/dex";

const MODEL = "dex-1.0.1";
const BATCH = "reviews-2026-09"; // names this run; reuse it to resume
const CONCURRENCY = 4; // 4 for a test key; a live key: 4, 8 or 16 by plan

const dex = new Client(); // reads DEX_API_KEY
const questions = {
  topic: pick(
    "What is {{review.text}} mainly about?",
    {
      quality: "The product itself",
      delivery: "Shipping and delivery",
      price: "Price or value",
      service: "Customer service",
      other: null,
    },
    { min_confidence: 0.5 },
  ),
  wants_contact: check("Does the writer of {{review.text}} ask to be contacted?", { min_confidence: 0.6 }),
};

type Item = { id: string; text: string };

async function score(item: Item) {
  try {
    const d = await dex.decide(
      { model: MODEL, state: { review: { text: item.text } }, questions },
      { idempotencyKey: `${BATCH}-${item.id}` },
    );
    const { topic, wants_contact: contact } = d.answers;
    return {
      id: item.id,
      topic: topic.abstained ? null : topic.choice,
      wants_contact: contact.abstained ? null : contact.probability >= 0.5,
      request_id: d.id,
      model: d.model,
      input_tokens: d.usage.input_tokens,
    };
  } catch (err) {
    if (err instanceof DexError) return { id: item.id, error: String(err) };
    throw err;
  }
}

const items: Item[] = (await readFile("reviews.jsonl", "utf8"))
  .split("\n")
  .filter((line) => line.trim())
  .map((line) => JSON.parse(line));

// A small pool: CONCURRENCY workers take the next item until none are left.
const results: Awaited<ReturnType<typeof score>>[] = new Array(items.length);
let next = 0;
await Promise.all(
  Array.from({ length: CONCURRENCY }, async () => {
    while (next < items.length) {
      const i = next++;
      results[i] = await score(items[i]);
    }
  }),
);
await writeFile("scores.jsonl", results.map((r) => JSON.stringify(r)).join("\n") + "\n");
console.log(results.filter((r) => !("error" in r)).length, "scored of", items.length);