@vextlabs/theron-agent-sdk 0.3.0

package/dist/verifiers/index.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+// src/verifiers/index.ts
+function defineVerifier(opts) {
+  return {
+    name: opts.name,
+    description: opts.description,
+    async check(output, context) {
+      const t0 = Date.now();
+      const result = await opts.check(output, context);
+      return { kernel: opts.name, pass: result.pass, issues: result.issues, ms: Date.now() - t0 };
+    }
+  };
+}
+var VerifierKernels = {
+  /** Block em-dashes (common AI tell). */
+  emDash: defineVerifier({
+    name: "em_dash_check",
+    description: "Block em-dashes in output (common AI tell).",
+    check: async (output) => {
+      const matches = [...output.matchAll(/—/g)];
+      const issues = matches.map((m) => ({
+        kernel: "em_dash_check",
+        severity: "error",
+        message: "Em-dash detected",
+        span: { start: m.index, end: m.index + 1 }
+      }));
+      return { pass: issues.length === 0, issues };
+    }
+  }),
+  /** Block common AI-ism words. Word-boundary aware to avoid false positives
+   *  (e.g., "leverage" matches but not "delivered"). */
+  aiIsm: defineVerifier({
+    name: "ai_ism_check",
+    description: "Block common AI-ism words.",
+    check: async (output) => {
+      const aiisms = ["delve", "tapestry", "leverage", "robust", "seamless", "navigate", "embark"];
+      const issues = [];
+      for (const w of aiisms) {
+        const re = new RegExp(`\\b${w}\\b`, "gi");
+        if (re.test(output)) {
+          issues.push({
+            kernel: "ai_ism_check",
+            severity: "warning",
+            message: `AI-ism detected: "${w}"`
+          });
+        }
+      }
+      return { pass: issues.length === 0, issues };
+    }
+  }),
+  /** Re-evaluate arithmetic claims like "X op Y = Z". */
+  arithmetic: defineVerifier({
+    name: "arithmetic_recheck",
+    description: "Re-evaluate arithmetic in 'X op Y = Z' form.",
+    check: async (output) => {
+      const pattern = /(-?\d+(?:\.\d+)?)\s*([+\-*/])\s*(-?\d+(?:\.\d+)?)\s*=\s*(-?\d+(?:\.\d+)?)/g;
+      const issues = [];
+      for (const m of output.matchAll(pattern)) {
+        const a = parseFloat(m[1]);
+        const op = m[2];
+        const b = parseFloat(m[3]);
+        const claimed = parseFloat(m[4]);
+        const actual = op === "+" ? a + b : op === "-" ? a - b : op === "*" ? a * b : op === "/" ? b === 0 ? NaN : a / b : NaN;
+        if (!Number.isFinite(actual) || Math.abs(actual - claimed) > 1e-6) {
+          issues.push({
+            kernel: "arithmetic_recheck",
+            severity: "error",
+            message: `Claimed ${a} ${op} ${b} = ${claimed}; actual ${Number.isFinite(actual) ? actual : "undefined"}`
+          });
+        }
+      }
+      return { pass: issues.length === 0, issues };
+    }
+  }),
+  /** Require at least one citation pattern ([N], (Author Year), https://...). */
+  citationPresence: defineVerifier({
+    name: "citation_presence",
+    description: "Require at least one citation in output.",
+    check: async (output) => {
+      const patterns = [/\[\d+\]/, /\([A-Z][a-z]+(?: et al\.?)? \d{4}\)/, /https?:\/\//];
+      const found = patterns.some((p) => p.test(output));
+      const issues = found ? [] : [
+        {
+          kernel: "citation_presence",
+          severity: "error",
+          message: "No citation found. Expected one of: [N], (Author YEAR), or a URL."
+        }
+      ];
+      return { pass: found, issues };
+    }
+  })
+};
+
+exports.VerifierKernels = VerifierKernels;
+exports.defineVerifier = defineVerifier;

package/dist/verifiers/index.d.cts

@@ -0,0 +1,63 @@
+interface VerifierIssue {
+    /** Which verifier kernel raised this. */
+    kernel: string;
+    /** Severity. */
+    severity: "error" | "warning" | "info";
+    /** Human-readable message. */
+    message: string;
+    /** Optional pointer to the offending span in the output. */
+    span?: {
+        start: number;
+        end: number;
+    };
+}
+interface VerifierResult {
+    kernel: string;
+    pass: boolean;
+    issues: VerifierIssue[];
+    ms: number;
+}
+interface Verifier {
+    name: string;
+    description: string;
+    check(output: string, context?: unknown): Promise<VerifierResult>;
+}
+/**
+ * defineVerifier — ergonomic verifier factory.
+ *
+ * Example:
+ *   const noEmDashes = defineVerifier({
+ *     name: "em_dash_check",
+ *     description: "Block em-dashes in user-facing copy.",
+ *     check: async (output) => {
+ *       const issues = [...output.matchAll(/—/g)].map((m) => ({
+ *         kernel: "em_dash_check",
+ *         severity: "error" as const,
+ *         message: "Em-dash detected",
+ *         span: { start: m.index!, end: m.index! + 1 },
+ *       }));
+ *       return { pass: issues.length === 0, issues };
+ *     },
+ *   });
+ */
+declare function defineVerifier(opts: {
+    name: string;
+    description: string;
+    check: (output: string, context?: unknown) => Promise<{
+        pass: boolean;
+        issues: VerifierIssue[];
+    }>;
+}): Verifier;
+declare const VerifierKernels: {
+    /** Block em-dashes (common AI tell). */
+    emDash: Verifier;
+    /** Block common AI-ism words. Word-boundary aware to avoid false positives
+     *  (e.g., "leverage" matches but not "delivered"). */
+    aiIsm: Verifier;
+    /** Re-evaluate arithmetic claims like "X op Y = Z". */
+    arithmetic: Verifier;
+    /** Require at least one citation pattern ([N], (Author Year), https://...). */
+    citationPresence: Verifier;
+};
+
+export { type Verifier, type VerifierIssue, VerifierKernels, type VerifierResult, defineVerifier };

package/dist/verifiers/index.d.ts

@@ -0,0 +1,63 @@
+interface VerifierIssue {
+    /** Which verifier kernel raised this. */
+    kernel: string;
+    /** Severity. */
+    severity: "error" | "warning" | "info";
+    /** Human-readable message. */
+    message: string;
+    /** Optional pointer to the offending span in the output. */
+    span?: {
+        start: number;
+        end: number;
+    };
+}
+interface VerifierResult {
+    kernel: string;
+    pass: boolean;
+    issues: VerifierIssue[];
+    ms: number;
+}
+interface Verifier {
+    name: string;
+    description: string;
+    check(output: string, context?: unknown): Promise<VerifierResult>;
+}
+/**
+ * defineVerifier — ergonomic verifier factory.
+ *
+ * Example:
+ *   const noEmDashes = defineVerifier({
+ *     name: "em_dash_check",
+ *     description: "Block em-dashes in user-facing copy.",
+ *     check: async (output) => {
+ *       const issues = [...output.matchAll(/—/g)].map((m) => ({
+ *         kernel: "em_dash_check",
+ *         severity: "error" as const,
+ *         message: "Em-dash detected",
+ *         span: { start: m.index!, end: m.index! + 1 },
+ *       }));
+ *       return { pass: issues.length === 0, issues };
+ *     },
+ *   });
+ */
+declare function defineVerifier(opts: {
+    name: string;
+    description: string;
+    check: (output: string, context?: unknown) => Promise<{
+        pass: boolean;
+        issues: VerifierIssue[];
+    }>;
+}): Verifier;
+declare const VerifierKernels: {
+    /** Block em-dashes (common AI tell). */
+    emDash: Verifier;
+    /** Block common AI-ism words. Word-boundary aware to avoid false positives
+     *  (e.g., "leverage" matches but not "delivered"). */
+    aiIsm: Verifier;
+    /** Re-evaluate arithmetic claims like "X op Y = Z". */
+    arithmetic: Verifier;
+    /** Require at least one citation pattern ([N], (Author Year), https://...). */
+    citationPresence: Verifier;
+};
+
+export { type Verifier, type VerifierIssue, VerifierKernels, type VerifierResult, defineVerifier };

package/dist/verifiers/index.js

@@ -0,0 +1,93 @@
+// src/verifiers/index.ts
+function defineVerifier(opts) {
+  return {
+    name: opts.name,
+    description: opts.description,
+    async check(output, context) {
+      const t0 = Date.now();
+      const result = await opts.check(output, context);
+      return { kernel: opts.name, pass: result.pass, issues: result.issues, ms: Date.now() - t0 };
+    }
+  };
+}
+var VerifierKernels = {
+  /** Block em-dashes (common AI tell). */
+  emDash: defineVerifier({
+    name: "em_dash_check",
+    description: "Block em-dashes in output (common AI tell).",
+    check: async (output) => {
+      const matches = [...output.matchAll(/—/g)];
+      const issues = matches.map((m) => ({
+        kernel: "em_dash_check",
+        severity: "error",
+        message: "Em-dash detected",
+        span: { start: m.index, end: m.index + 1 }
+      }));
+      return { pass: issues.length === 0, issues };
+    }
+  }),
+  /** Block common AI-ism words. Word-boundary aware to avoid false positives
+   *  (e.g., "leverage" matches but not "delivered"). */
+  aiIsm: defineVerifier({
+    name: "ai_ism_check",
+    description: "Block common AI-ism words.",
+    check: async (output) => {
+      const aiisms = ["delve", "tapestry", "leverage", "robust", "seamless", "navigate", "embark"];
+      const issues = [];
+      for (const w of aiisms) {
+        const re = new RegExp(`\\b${w}\\b`, "gi");
+        if (re.test(output)) {
+          issues.push({
+            kernel: "ai_ism_check",
+            severity: "warning",
+            message: `AI-ism detected: "${w}"`
+          });
+        }
+      }
+      return { pass: issues.length === 0, issues };
+    }
+  }),
+  /** Re-evaluate arithmetic claims like "X op Y = Z". */
+  arithmetic: defineVerifier({
+    name: "arithmetic_recheck",
+    description: "Re-evaluate arithmetic in 'X op Y = Z' form.",
+    check: async (output) => {
+      const pattern = /(-?\d+(?:\.\d+)?)\s*([+\-*/])\s*(-?\d+(?:\.\d+)?)\s*=\s*(-?\d+(?:\.\d+)?)/g;
+      const issues = [];
+      for (const m of output.matchAll(pattern)) {
+        const a = parseFloat(m[1]);
+        const op = m[2];
+        const b = parseFloat(m[3]);
+        const claimed = parseFloat(m[4]);
+        const actual = op === "+" ? a + b : op === "-" ? a - b : op === "*" ? a * b : op === "/" ? b === 0 ? NaN : a / b : NaN;
+        if (!Number.isFinite(actual) || Math.abs(actual - claimed) > 1e-6) {
+          issues.push({
+            kernel: "arithmetic_recheck",
+            severity: "error",
+            message: `Claimed ${a} ${op} ${b} = ${claimed}; actual ${Number.isFinite(actual) ? actual : "undefined"}`
+          });
+        }
+      }
+      return { pass: issues.length === 0, issues };
+    }
+  }),
+  /** Require at least one citation pattern ([N], (Author Year), https://...). */
+  citationPresence: defineVerifier({
+    name: "citation_presence",
+    description: "Require at least one citation in output.",
+    check: async (output) => {
+      const patterns = [/\[\d+\]/, /\([A-Z][a-z]+(?: et al\.?)? \d{4}\)/, /https?:\/\//];
+      const found = patterns.some((p) => p.test(output));
+      const issues = found ? [] : [
+        {
+          kernel: "citation_presence",
+          severity: "error",
+          message: "No citation found. Expected one of: [N], (Author YEAR), or a URL."
+        }
+      ];
+      return { pass: found, issues };
+    }
+  })
+};
+
+export { VerifierKernels, defineVerifier };

package/examples/01_code_reviewer.ts

@@ -0,0 +1,90 @@
+/**
+ * Sample agent 01: Code Reviewer
+ *
+ * Reviews a diff and produces structured feedback. Works against any
+ * OpenRouter-compatible model — no Vext API key needed.
+ *
+ * Run:
+ *   OPENROUTER_API_KEY=sk-or-... npx tsx examples/01_code_reviewer.ts
+ *
+ * What this demonstrates:
+ *   - The 5-line agent pattern (Agent + tools + Runner)
+ *   - Tool definition via defineTool + Zod schema
+ *   - Streaming via runner.on("agent_thinking", ...)
+ *   - Verifier kernels gating the final output (no extra LLM cost)
+ */
+
+import { Agent, Runner, defineTool, zod as z, VerifierKernels } from "../src/index.js";
+import { openrouterAdapter } from "./adapters/openrouter.js";
+
+const readDiff = defineTool({
+  name: "read_diff",
+  description: "Read the unified-diff of a PR. For demo: returns a fixed diff.",
+  input: z.object({ pr_url: z.string().url() }),
+  async execute({ pr_url }) {
+    // In production: fetch the diff from GitHub API.
+    // For the sample: return a fixed diff that contains a deliberate
+    // SQL-injection regression the reviewer should catch.
+    return {
+      pr_url,
+      diff: `
+--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -10,7 +10,7 @@ export async function login(username: string, password: string) {
+-  const user = await db.users.findOne({ username });
++  const user = await db.query(\`SELECT * FROM users WHERE username = '\${username}'\`);
+   if (!user) return null;
+   if (user.password === password) return user;
+   return null;
+}
+`.trim(),
+    };
+  },
+});
+
+const reviewer = new Agent({
+  name: "code-reviewer",
+  instruction: `You are a senior code reviewer. Read the diff and identify:
+1. Security issues (SQL injection, auth bypass, etc.) — severity HIGH if present
+2. Bug risks (null deref, race conditions, etc.) — severity MEDIUM
+3. Style or clarity issues — severity LOW
+
+Output a structured review with file:line references and one-line explanations per issue.
+Do not use em-dashes or AI-ism words.`,
+  tools: [readDiff],
+  verifiers: [VerifierKernels.emDash, VerifierKernels.aiIsm],
+});
+
+async function main() {
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    console.error("Set OPENROUTER_API_KEY (https://openrouter.ai/keys) and rerun.");
+    process.exit(1);
+  }
+
+  const runner = new Runner({
+    model: openrouterAdapter({ apiKey }),
+    default_model: "openai/gpt-4o-mini",
+  });
+
+  runner.on((event) => {
+    if (event.type === "agent_thinking") process.stdout.write(event.delta);
+    if (event.type === "tool_call_start") console.log(`\n→ ${event.tool}(${JSON.stringify(event.input)})`);
+    if (event.type === "agent_output") console.log(`\n\n=== Review ===\n${event.output}`);
+    if (event.type === "verifier_run" && !event.result.pass) {
+      console.log(`\n[verifier ${event.kernel}] ${event.result.issues.length} issue(s)`);
+    }
+  });
+
+  const result = await runner.run(reviewer, "Review https://github.com/example/repo/pull/42");
+  const failed = result.verifier_results.filter((v) => !v.pass);
+  if (failed.length > 0) {
+    console.log(`\nVerifier failures: ${failed.map((v) => v.kernel).join(", ")}`);
+    process.exitCode = 1;
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/examples/02_research_assistant.ts

@@ -0,0 +1,85 @@
+/**
+ * Sample agent 02: Research Assistant
+ *
+ * Answers a research question with web-fetched citations. Output is gated
+ * by the citation_presence verifier kernel.
+ *
+ * Run:
+ *   OPENROUTER_API_KEY=sk-or-... npx tsx examples/02_research_assistant.ts
+ *
+ * What this demonstrates:
+ *   - Verifier kernel composition (citation_presence)
+ *   - Sub-tools that take web actions
+ *   - Free verifier guarantees (no LLM "judge" cost; pure regex check)
+ */
+
+import { Agent, Runner, defineTool, zod as z, VerifierKernels } from "../src/index.js";
+import { openrouterAdapter } from "./adapters/openrouter.js";
+
+const webSearch = defineTool({
+  name: "web_search",
+  description: "Search the web. Returns titles + URLs + snippets.",
+  input: z.object({ query: z.string() }),
+  async execute({ query }) {
+    // In production: call a real search API (Tavily, Serper, etc.).
+    // For the sample: return fixed mock results.
+    return {
+      query,
+      results: [
+        {
+          title: "Chinchilla scaling laws",
+          url: "https://arxiv.org/abs/2203.15556",
+          snippet: "Hoffmann et al. 2022 — compute-optimal model + token ratio.",
+        },
+        {
+          title: "Scaling Laws for Neural Language Models",
+          url: "https://arxiv.org/abs/2001.08361",
+          snippet: "Kaplan et al. 2020 — original power-law claims.",
+        },
+      ],
+    };
+  },
+});
+
+const researcher = new Agent({
+  name: "research-assistant",
+  instruction: `You are a careful research assistant. Answer the user's question
+with citations. Every factual claim must reference a source from web_search.
+Format citations inline as [N] with a numbered references list at the end.`,
+  tools: [webSearch],
+  verifiers: [VerifierKernels.citationPresence],
+});
+
+async function main() {
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    console.error("Set OPENROUTER_API_KEY (https://openrouter.ai/keys) and rerun.");
+    process.exit(1);
+  }
+
+  const runner = new Runner({
+    model: openrouterAdapter({ apiKey }),
+    default_model: "openai/gpt-4o-mini",
+  });
+
+  const result = await runner.run(
+    researcher,
+    "Did the Chinchilla paper overturn the 2020 scaling laws? Cite your sources.",
+  );
+
+  console.log("\n=== Answer ===");
+  console.log(result.output);
+
+  // result.verifier_results already includes the citation_presence outcome
+  // (the Runner ran every verifier on the agent). This is just for display.
+  for (const v of result.verifier_results) {
+    console.log(`\n=== Verifier: ${v.kernel} ===`);
+    console.log(`Pass: ${v.pass}`);
+    if (!v.pass) console.log("Issues:", v.issues);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/examples/03_council_of_three.ts

@@ -0,0 +1,91 @@
+/**
+ * Sample agent 03: Council of Three — deliberation with verifier kernels.
+ *
+ * Three generic agents (Engineer, Security, Product) deliberate on a question.
+ * Outputs are checked by verifier kernels before reconciliation.
+ *
+ * This is the 15-line Council pattern — the Theron Agent SDK moat in a single
+ * example.
+ *
+ * Run:
+ *   OPENROUTER_API_KEY=sk-or-... npx tsx examples/03_council_of_three.ts
+ *
+ * What this demonstrates:
+ *   - Council primitive (the flagship Theron Agent SDK feature)
+ *   - Multi-specialist deliberation
+ *   - Verifier kernels applied across the council
+ *   - Reconciler (deterministic claim-merge by default)
+ */
+
+import { Agent, Council, Runner, VerifierKernels } from "../src/index.js";
+import { openrouterAdapter } from "./adapters/openrouter.js";
+
+const engineer = new Agent({
+  name: "engineer",
+  instruction: `You are a senior backend engineer. Answer from a system-design + reliability perspective.
+Be specific about trade-offs. Cite RFCs / specs / public benchmarks where applicable.
+Do not use em-dashes or AI-ism words.`,
+});
+
+const security = new Agent({
+  name: "security",
+  instruction: `You are an application-security engineer. Answer from a threat-model + attack-surface perspective.
+Flag anything that could be exploited. Cite OWASP / CWE / CVE where applicable.
+Do not use em-dashes or AI-ism words.`,
+});
+
+const product = new Agent({
+  name: "product",
+  instruction: `You are a product manager. Answer from a user-impact + adoption perspective.
+Be specific about who this helps, who it doesn't, and what could backfire.
+Do not use em-dashes or AI-ism words.`,
+});
+
+const council = new Council({
+  name: "engineering-review",
+  specialists: [engineer, security, product],
+  verifiers: [VerifierKernels.emDash, VerifierKernels.aiIsm],
+  // No reconciler specified → defaults to deterministic claim-merge.
+});
+
+async function main() {
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    console.error("Set OPENROUTER_API_KEY (https://openrouter.ai/keys) and rerun.");
+    process.exit(1);
+  }
+
+  const runner = new Runner({
+    model: openrouterAdapter({ apiKey }),
+    default_model: "openai/gpt-4o-mini",
+  });
+
+  runner.on((event) => {
+    if (event.type === "specialist_done") {
+      console.log(`\n--- ${event.specialist} ---`);
+      console.log(event.output.output.slice(0, 300) + "...");
+    }
+    if (event.type === "council_done") {
+      console.log(`\n=== Council answer (${event.output.consensus}) ===`);
+      console.log(event.output.answer);
+      if (event.output.disagreements && event.output.disagreements.length > 0) {
+        console.log(`\n=== Disagreements ===`);
+        for (const d of event.output.disagreements) {
+          console.log(`Claim: "${d.claim}"`);
+          console.log(`  for:     ${d.specialists_for.join(", ")}`);
+          console.log(`  against: ${d.specialists_against.join(", ")}`);
+        }
+      }
+    }
+  });
+
+  await runner.runCouncil(
+    council,
+    "Should we let users store API keys in localStorage instead of a cookie?",
+  );
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/examples/_adapters/openrouter.ts

@@ -0,0 +1,90 @@
+/**
+ * OpenRouter ModelAdapter — works against 200+ models for free-tier users.
+ *
+ * Used by the sample agents in the SDK. Production users should write their
+ * own adapter for their preferred provider (OpenAI direct, Anthropic, Vext
+ * managed Theron, etc.).
+ */
+import type { ModelAdapter } from "../../src/runtime/index.js";
+
+export function openrouterAdapter(opts: { apiKey: string; siteName?: string; siteUrl?: string }): ModelAdapter {
+  return {
+    name: "openrouter",
+    async chat({ model, messages, tools, max_tokens, temperature, onDelta }) {
+      const body: Record<string, unknown> = {
+        model,
+        messages,
+        max_tokens: max_tokens ?? 2048,
+        temperature: temperature ?? 0.2,
+        stream: !!onDelta,
+      };
+      if (tools && tools.length > 0) {
+        body.tools = tools.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.input_schema },
+        }));
+      }
+      const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${opts.apiKey}`,
+          "Content-Type": "application/json",
+          ...(opts.siteUrl ? { "HTTP-Referer": opts.siteUrl } : {}),
+          ...(opts.siteName ? { "X-Title": opts.siteName } : {}),
+        },
+        body: JSON.stringify(body),
+      });
+      if (!res.ok) {
+        throw new Error(`OpenRouter ${res.status}: ${await res.text()}`);
+      }
+      if (onDelta && res.body) {
+        // Streaming path — parse SSE
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let content = "";
+        let inputTokens = 0;
+        let outputTokens = 0;
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          const chunk = decoder.decode(value);
+          for (const line of chunk.split("\n")) {
+            if (!line.startsWith("data: ")) continue;
+            const data = line.slice(6).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const json = JSON.parse(data);
+              const delta = json.choices?.[0]?.delta?.content;
+              if (delta) {
+                onDelta(delta);
+                content += delta;
+              }
+              if (json.usage) {
+                inputTokens = json.usage.prompt_tokens ?? inputTokens;
+                outputTokens = json.usage.completion_tokens ?? outputTokens;
+              }
+            } catch {
+              // ignore malformed SSE lines
+            }
+          }
+        }
+        return { content, tokens: { input: inputTokens, output: outputTokens } };
+      }
+      // Non-streaming path
+      const json = await res.json() as {
+        choices: Array<{ message: { content: string; tool_calls?: Array<{ function: { name: string; arguments: string } }> } }>;
+        usage: { prompt_tokens: number; completion_tokens: number };
+      };
+      const msg = json.choices[0].message;
+      const tool_calls = msg.tool_calls?.map((tc) => ({
+        name: tc.function.name,
+        input: JSON.parse(tc.function.arguments || "{}"),
+      }));
+      return {
+        content: msg.content ?? "",
+        tool_calls,
+        tokens: { input: json.usage.prompt_tokens, output: json.usage.completion_tokens },
+      };
+    },
+  };
+}