@loomwork/reasoning 0.0.0-stage → 0.1.1

package/src/ReasoningRuntime.ts

@@ -0,0 +1,244 @@
+import type { LlmResponse } from "@loomwork/llm";
+import {
+  assertRequestSupported,
+  guardRequest,
+  resolveRequestContent,
+  textFreeReasoning,
+} from "@loomwork/llm";
+import { stopReasonConfidence } from "./confidence";
+import { tagRouter } from "./router";
+import type {
+  ConfidenceSignal,
+  DecideFn,
+  ModelRoute,
+  ReasonOptions,
+  ReasoningCache,
+  ReasoningRequest,
+  ReasoningResult,
+  ReasoningRuntimeConfig,
+  ReasoningTraceEntry,
+  Router,
+} from "./types";
+
+// No decision sink → run the decider inline (used by standalone callers outside a
+// durable flow). When a flow passes ctx.decide, the choice is recorded instead.
+const identityDecide: DecideFn = (_id, decider) => Promise.resolve(decider());
+
+/**
+ * ADR 0133 - what leaves this runtime (a result a caller journals, a cache entry) carries reasoning
+ * only in its text-free recorded form: readable text goes to a sidecar through `createLlmEffect`, or
+ * nowhere. The same object when there is no reasoning (G2).
+ */
+function withTextFreeReasoning(res: LlmResponse): LlmResponse {
+  return res.reasoning === undefined
+    ? res
+    : { ...res, reasoning: textFreeReasoning(res.reasoning) };
+}
+
+// The Reasoning Runtime (P3), built as composable stages: route → call → score →
+// elevate. Each route/elevation is a logged decision (P9), so replay is deterministic
+// while routing can improve run-to-run. The kernel stays untouched — this is an
+// optional advisory module (P10).
+export class ReasoningRuntime {
+  private readonly routes: ModelRoute[];
+  private readonly router: Router;
+  private readonly confidence: ConfidenceSignal;
+  private readonly threshold: number;
+  private readonly cache: ReasoningCache | undefined;
+  // id → position in the tier-sorted `routes`, so `byId` is O(1) not a linear scan.
+  private readonly indexById: Map<string, number>;
+  // For each route index, the index of the next route with a strictly higher tier
+  // (or -1). Precomputed once so elevation is an O(1) hop instead of an O(n) scan.
+  private readonly nextHigherIndex: number[];
+
+  constructor(config: ReasoningRuntimeConfig) {
+    if (config.routes.length === 0) {
+      throw new Error("ReasoningRuntime requires at least one route");
+    }
+    // Sorted by tier once so elevation is a simple forward hop.
+    this.routes = [...config.routes].sort((a, b) => a.tier - b.tier);
+    this.router = config.router ?? tagRouter;
+    this.confidence = config.confidence ?? stopReasonConfidence;
+    this.threshold = config.elevateThreshold ?? 0.5;
+    this.cache = config.cache;
+
+    const n = this.routes.length;
+    this.indexById = new Map(this.routes.map((r, i) => [r.id, i]));
+    // Right-to-left pass (O(n)): the next strictly-higher tier for i is either its
+    // neighbour i+1 (if that neighbour's tier is greater) or, when i+1 shares i's
+    // tier, whatever the next-higher of i+1 already resolved to.
+    this.nextHigherIndex = new Array(n).fill(-1);
+    for (let i = n - 2; i >= 0; i--) {
+      this.nextHigherIndex[i] =
+        (this.routes[i + 1] as ModelRoute).tier > (this.routes[i] as ModelRoute).tier
+          ? i + 1
+          : (this.nextHigherIndex[i + 1] as number);
+    }
+  }
+
+  /** Whether a response cache is configured (a host that shares it across tenants must scope it). */
+  get hasResponseCache(): boolean {
+    return this.cache !== undefined;
+  }
+
+  get availableRoutes(): ReadonlyArray<ModelRoute> {
+    return this.routes;
+  }
+
+  async reason(req: ReasoningRequest, opts: ReasonOptions = {}): Promise<ReasoningResult> {
+    const decide = opts.decide ?? identityDecide;
+    const key = opts.decisionKey ?? req.strategy ?? "default";
+    const signal = opts.signal ?? req.signal;
+    const maxTier = req.maxTier ?? (this.routes[this.routes.length - 1] as ModelRoute).tier;
+
+    // Stage 1 — route (a logged decision).
+    const initialId = await decide(
+      `reason:${key}:route`,
+      () => this.router.select(req, this.routes).id
+    );
+    let currentIdx = this.indexOf(initialId);
+    let current = this.routes[currentIdx] as ModelRoute;
+    const trace: ReasoningTraceEntry[] = [];
+
+    let res = await this.call(current, req, signal, opts);
+    let confidence = await this.confidence.score(req, res);
+    trace.push({ modelId: current.id, tier: current.tier, confidence, elevated: false });
+
+    // Stage 2 — elevate while low-confidence and a higher tier is within budget.
+    let step = 0;
+    while (confidence < this.threshold) {
+      const nextIdx = this.nextHigherIndex[currentIdx] as number;
+      if (nextIdx === -1) break;
+      const next = this.routes[nextIdx] as ModelRoute;
+      if (next.tier > maxTier) break;
+      step += 1;
+      const chosenId = await decide(`reason:${key}:elevate:${step}`, () => next.id);
+      currentIdx = this.indexOf(chosenId);
+      current = this.routes[currentIdx] as ModelRoute;
+      res = await this.call(current, req, signal, opts);
+      confidence = await this.confidence.score(req, res);
+      trace.push({ modelId: current.id, tier: current.tier, confidence, elevated: true });
+    }
+
+    return {
+      content: res.content,
+      ...(res.toolCalls !== undefined && { toolCalls: res.toolCalls }),
+      stopReason: res.stopReason,
+      ...(res.usage !== undefined && { usage: res.usage }),
+      ...(res.reasoning !== undefined && { reasoning: res.reasoning }),
+      ...(res.layout !== undefined && { layout: res.layout }),
+      modelId: current.id,
+      confidence,
+      elevated: trace.length > 1,
+      trace,
+    };
+  }
+
+  private indexOf(id: string): number {
+    const idx = this.indexById.get(id);
+    if (idx === undefined) {
+      throw new Error(`ReasoningRuntime: unknown route "${id}"`);
+    }
+    return idx;
+  }
+
+  private async call(
+    route: ModelRoute,
+    req: ReasoningRequest,
+    signal: AbortSignal | undefined,
+    opts: ReasonOptions
+  ): Promise<LlmResponse> {
+    // Every path (an invoker, a wrapper serving a record, the cache, the provider) is text-free on exit.
+    return withTextFreeReasoning(await this.callRaw(route, req, signal, opts));
+  }
+
+  private async callRaw(
+    route: ModelRoute,
+    req: ReasoningRequest,
+    signal: AbortSignal | undefined,
+    opts: ReasonOptions
+  ): Promise<LlmResponse> {
+    const invoke = opts.invoke;
+    if (invoke !== undefined) {
+      // R9 — the host makes the call (as an effect, inside the ring). No cache: see ModelInvoker.
+      // `guardRequest` still runs here, so a custom invoker that is NOT an effect cannot
+      // receive tainted content either; the effect it resolves to guards again, harmlessly
+      // (a guarded request is untainted, and guarding it is the identity).
+      const guarded = guardRequest({
+        messages: req.messages,
+        ...(req.system !== undefined && { system: req.system }),
+        ...(req.tools !== undefined && { tools: req.tools }),
+        ...(req.maxTokens !== undefined && { maxTokens: req.maxTokens }),
+        ...(req.temperature !== undefined && { temperature: req.temperature }),
+      });
+      return invoke(route, {
+        messages: guarded.messages,
+        ...(guarded.system !== undefined && { system: guarded.system }),
+        ...(guarded.tools !== undefined && { tools: guarded.tools }),
+        ...(guarded.maxTokens !== undefined && { maxTokens: guarded.maxTokens }),
+        ...(guarded.temperature !== undefined && { temperature: guarded.temperature }),
+      });
+    }
+    // R2 — the prompt boundary, on the reasoning path. This is the single site where
+    // this runtime hands a request to a provider, so it is the one place the check
+    // belongs. `ReasoningRequest` types its content as `string`, but a `string`
+    // annotation is a claim, not a check: a tainted MCP tool description reaches
+    // here through exactly such a field. `guardRequest` refuses taint in every
+    // instruction position and returns an untainted request unchanged.
+    const guarded = guardRequest({
+      messages: req.messages,
+      ...(req.system !== undefined && { system: req.system }),
+      ...(req.tools !== undefined && { tools: req.tools }),
+      ...(req.maxTokens !== undefined && { maxTokens: req.maxTokens }),
+      ...(req.temperature !== undefined && { temperature: req.temperature }),
+      ...(signal !== undefined && { signal }),
+    });
+    // R5 — a third-party provider may not check its own modalities; this runtime does.
+    assertRequestSupported(guarded, route.provider.capabilities);
+    // The cache key is the request AS WRITTEN (addresses, not bytes); computed before the host's
+    // wrapper so a journaled call and an unjournaled one share the same entries.
+    const cacheKey =
+      this.cache !== undefined ? this.keyFor(route.id, req, this.scopeOf(opts)) : undefined;
+    const run = async (): Promise<LlmResponse> => {
+      if (cacheKey !== undefined) {
+        const hit = this.cache?.get(cacheKey);
+        if (hit !== undefined) return hit;
+      }
+      // R5 — refs become bytes only now: after the capability check (a refusal must precede any
+      // fetch) and after the cache lookup, whose key is the request as written.
+      // ADR 0133: reasoning is reduced BEFORE the cache sees it, so a shared cache never holds text.
+      const res = withTextFreeReasoning(
+        await route.provider.complete(
+          await resolveRequestContent(guarded, opts.resolveContent, {
+            ...(signal !== undefined && { signal }),
+            // Absent only when there is no resolver; a ref then fails before any fetch.
+            context: opts.resolveContext ?? { executionId: "" },
+          })
+        )
+      );
+      if (cacheKey !== undefined) this.cache?.set(cacheKey, res);
+      return res;
+    };
+    return opts.wrapCall !== undefined ? opts.wrapCall(route, run) : run();
+  }
+
+  /** Who the cached response belongs to: the explicit scope and the principal identity, if any. */
+  private scopeOf(opts: ReasonOptions): string | undefined {
+    const p = opts.resolveContext?.principal;
+    const who =
+      p === undefined
+        ? undefined
+        : JSON.stringify([p.tenant ?? null, p.actor ?? null, p.onBehalfOf ?? null]);
+    if (opts.cacheScope === undefined && who === undefined) return undefined;
+    return JSON.stringify([opts.cacheScope ?? null, who ?? null]);
+  }
+
+  private keyFor(modelId: string, req: ReasoningRequest, scope?: string): string {
+    return JSON.stringify({
+      m: modelId,
+      s: req.system,
+      msgs: req.messages,
+      ...(scope !== undefined && { c: scope }),
+    });
+  }
+}

package/src/confidence.ts

@@ -0,0 +1,37 @@
+import type { LlmResponse } from "@loomwork/llm";
+import type { ConfidenceSignal, ReasoningRequest } from "./types";
+
+// Honest, pluggable confidence — NOT a magic self-reported number. The default uses
+// the model's stop reason, the one signal every provider emits: a truncated answer
+// (max_tokens) is low-confidence and should elevate; a clean finish is high.
+export const stopReasonConfidence: ConfidenceSignal = {
+  score(_req: ReasoningRequest, res: LlmResponse): number {
+    switch (res.stopReason) {
+      case "end_turn":
+        return 0.9;
+      case "tool_use":
+        return 0.9;
+      case "max_tokens":
+        return 0.3;
+      default:
+        return 0.5;
+    }
+  },
+};
+
+// Confidence from a caller-supplied validator: pass → 1, fail → 0. Use for structured
+// outputs ("did it parse as the expected JSON / a known capability id?"). This turns
+// elevation into "retry on a stronger model until the output validates."
+export function validatorConfidence(validate: (content: string) => boolean): ConfidenceSignal {
+  return {
+    score(_req: ReasoningRequest, res: LlmResponse): number {
+      return validate(res.content) ? 1 : 0;
+    },
+  };
+}
+
+// Agreement across a fixed constant — always returns the given value. Useful to force
+// (never elevate → 1) or always-elevate (→ 0) in tests and pins.
+export function constantConfidence(value: number): ConfidenceSignal {
+  return { score: () => value };
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+export { ReasoningRuntime } from "./ReasoningRuntime";
+export { tagRouter, fixedRouter, rankedRouter, ucb1, epsilonGreedy } from "./router";
+export type {
+  ArmStats,
+  EpsilonGreedyOptions,
+  RankedRouterOptions,
+  Rankings,
+  Ucb1Options,
+} from "./router";
+export { stopReasonConfidence, validatorConfidence, constantConfidence } from "./confidence";
+export type {
+  ConfidenceSignal,
+  DecideFn,
+  ModelCallRequest,
+  ModelInvoker,
+  ModelRoute,
+  ReasonOptions,
+  ReasoningCache,
+  ReasoningRequest,
+  ReasoningResult,
+  ReasoningRuntimeConfig,
+  ReasoningTraceEntry,
+  Router,
+} from "./types";

package/src/router.ts

@@ -0,0 +1,225 @@
+import type { ModelRoute, ReasoningRequest, Router } from "./types";
+
+// Default routing policy: the lowest-tier route whose tags include the request's
+// strategy, else the lowest-tier route overall. This implements "use the cheap
+// model first; elevate only when confidence is low" (the P3 elevation ladder).
+//
+// Contract: `routes` are expected tier-ascending. ReasoningRuntime owns the sort
+// (once, at construction) and always passes its sorted `routes`, so this router
+// takes the first tag/overall match without re-sorting on every call.
+export const tagRouter: Router = {
+  select(req: ReasoningRequest, routes: ModelRoute[]): ModelRoute {
+    if (req.strategy !== undefined) {
+      const tagged = routes.find((r) => r.tags?.includes(req.strategy as string));
+      if (tagged !== undefined) return tagged;
+    }
+    const first = routes[0];
+    if (first === undefined) {
+      throw new Error("ReasoningRuntime: no routes configured");
+    }
+    return first;
+  },
+};
+
+// ── Evidence ─────────────────────────────────────────────────────────────────
+//
+// Per-arm evidence: the mean reward AND how many samples produced it. This is
+// structurally what `outcomeAnalytics` (@loomwork/analytics) returns, so its output
+// feeds these routers with no conversion. The count is the half that a bare
+// `Record<string, number>` ranking throws away — and without it a router cannot
+// tell `1.0 from one sample` from `0.99 from ten thousand`.
+export interface ArmStats {
+  key: string;
+  /** Mean reward. Higher = better. */
+  rank: number;
+  /** How many outcomes produced `rank`. */
+  count: number;
+}
+
+/** Rankings with counts (preferred) or the legacy count-free record. */
+export type Rankings = Record<string, number> | readonly ArmStats[];
+
+interface Arm {
+  rank: number;
+  /** undefined when the caller supplied a count-free `Record<string, number>`. */
+  count?: number;
+}
+
+function indexRankings(rankings: Rankings): Map<string, Arm> {
+  if (Array.isArray(rankings)) {
+    const m = new Map<string, Arm>();
+    for (const s of rankings as readonly ArmStats[]) m.set(s.key, { rank: s.rank, count: s.count });
+    return m;
+  }
+  const m = new Map<string, Arm>();
+  for (const [key, rank] of Object.entries(rankings as Record<string, number>))
+    m.set(key, { rank });
+  return m;
+}
+
+export interface RankedRouterOptions {
+  /**
+   * Sample floor. Arms with fewer than this many outcomes are treated as UNRANKED
+   * rather than as evidence — the fix for "one lucky success at n=1 outranks a
+   * proven arm at n=10000 forever". Requires `ArmStats[]`; a count-free record
+   * throws at construction rather than silently no-opping the floor.
+   */
+  minSamples?: number;
+  /** Router for unranked/under-sampled requests. Default: cheap-first `tagRouter`. */
+  fallback?: Router;
+}
+
+// M10 self-optimization — a "learned" router. Given a ranking (e.g. from
+// @loomwork/analytics `rankModels`/`outcomeAnalytics`, mined from historical logs),
+// prefer the highest-ranked route that exists, falling back to cheap-first
+// (`tagRouter`) for unranked requests. Used inside ReasoningRuntime with
+// `ctx.decide`, its choice is recorded as a durable decision (P9) — auditable and
+// override-able, never silently autonomous (P10).
+//
+// PURE EXPLOIT. This router never tries an arm to learn about it: an arm absent
+// from `rankings` can never be selected while any other arm is ranked, so a
+// ranking mined from a log that this router itself produced will narrow over time
+// (the arms it stops choosing stop generating outcomes). `minSamples` bounds the
+// damage from thin evidence, but if you want the loop to keep learning, wrap it —
+// `epsilonGreedy(rankedRouter(stats), { epsilon: 0.1 })` — or use `ucb1`, which
+// allocates exploration by uncertainty instead of by coin flip.
+export function rankedRouter(rankings: Rankings, opts: RankedRouterOptions = {}): Router {
+  // Index the ranking once at construction; each select is then a single O(R)
+  // max-scan instead of an O(R log R) filter+sort per call (routing decisions
+  // are on the reasoning hot path). Ties keep the tier-ascending order the
+  // caller passes — the first route holding the max rank wins, which is exactly
+  // what a stable sort's `[0]` yielded.
+  const rank = indexRankings(rankings);
+  const minSamples = opts.minSamples ?? 0;
+  const fallback = opts.fallback ?? tagRouter;
+
+  if (minSamples > 0) {
+    for (const arm of rank.values()) {
+      if (arm.count === undefined) {
+        throw new Error(
+          "rankedRouter: minSamples needs sample counts — pass ArmStats[] " +
+            "(e.g. outcomeAnalytics(events)), not a count-free rankings record"
+        );
+      }
+    }
+  }
+
+  return {
+    select(req: ReasoningRequest, routes: ModelRoute[]): ModelRoute {
+      let best: ModelRoute | undefined;
+      let bestRank = Number.NEGATIVE_INFINITY;
+      for (const r of routes) {
+        const arm = rank.get(r.id);
+        if (arm === undefined) continue;
+        if (arm.count !== undefined && arm.count < minSamples) continue;
+        if (arm.rank > bestRank) {
+          bestRank = arm.rank;
+          best = r;
+        }
+      }
+      return best ?? fallback.select(req, routes);
+    },
+  };
+}
+
+export interface Ucb1Options {
+  /** Exploration weight. 1 = textbook UCB1; lower is greedier, 0 is pure exploit. */
+  exploration?: number;
+  /** Router for the cold start (no samples at all). Default: cheap-first `tagRouter`. */
+  fallback?: Router;
+}
+
+// UCB1 — the principled fix for the ranked router's collapse, and the recommended
+// default for a live learning loop. Scores each arm `mean + c·sqrt(2·ln N / n)`:
+// the bonus is large while an arm is under-sampled and shrinks as evidence
+// accumulates, so a lucky n=1 arm cannot pin the router (its rivals keep their own
+// large bonus until they are tried too) and an arm with NO samples scores +Inf and
+// is guaranteed a trial. Deterministic — no RNG — which is what you want in a
+// replay-first runtime: the same evidence always yields the same route.
+//
+// Assumes rewards on a comparable scale (the [0,1] of `success`/normalized `score`
+// that `outcomeAnalytics` produces); `exploration` is the knob if yours differ.
+export function ucb1(stats: readonly ArmStats[], opts: Ucb1Options = {}): Router {
+  const c = opts.exploration ?? 1;
+  const fallback = opts.fallback ?? tagRouter;
+
+  // Fold the evidence once at construction — per-select work is then one O(R)
+  // scan with no logarithm (`lnTotal` is loop-invariant across every select).
+  const arms = new Map<string, ArmStats>();
+  let total = 0;
+  for (const s of stats) {
+    arms.set(s.key, s);
+    total += s.count;
+  }
+  const lnTotal = Math.log(total);
+
+  return {
+    select(req: ReasoningRequest, routes: ModelRoute[]): ModelRoute {
+      if (total === 0) return fallback.select(req, routes);
+
+      let best: ModelRoute | undefined;
+      let bestScore = Number.NEGATIVE_INFINITY;
+      for (const r of routes) {
+        const arm = arms.get(r.id);
+        // Never sampled → must-try. Ties resolve to the first route, so a cold
+        // start walks the tier-ascending ladder one trial at a time.
+        const score =
+          arm === undefined || arm.count <= 0
+            ? Number.POSITIVE_INFINITY
+            : arm.rank + c * Math.sqrt((2 * lnTotal) / arm.count);
+        if (score > bestScore) {
+          bestScore = score;
+          best = r;
+        }
+      }
+      return best ?? fallback.select(req, routes);
+    },
+  };
+}
+
+export interface EpsilonGreedyOptions {
+  /** Probability in [0,1] of sampling a uniformly random route instead of exploiting. */
+  epsilon: number;
+  /** Injected RNG (default `Math.random`). Pass a seeded PRNG for tests and DST runs. */
+  rng?: () => number;
+}
+
+// ε-greedy — the simplest way to stop any exploit-only router from starving its
+// own evidence: with probability ε ignore `inner` and sample a route uniformly.
+//
+// The randomness is replay-safe WHERE IT MATTERS: ReasoningRuntime resolves the
+// route inside `ctx.decide`, so the sampled id is committed as DECISION_RECORDED
+// and replay serves that recording back — `select` is never called again and the
+// RNG is never re-rolled. Standalone callers (no `decide` sink) get no such
+// guarantee; inject `rng` if you need them reproducible.
+export function epsilonGreedy(inner: Router, opts: EpsilonGreedyOptions): Router {
+  const { epsilon } = opts;
+  if (!(epsilon >= 0 && epsilon <= 1)) {
+    throw new Error(`epsilonGreedy: epsilon must be in [0,1], got ${epsilon}`);
+  }
+  const rng = opts.rng ?? Math.random;
+
+  return {
+    select(req: ReasoningRequest, routes: ModelRoute[]): ModelRoute {
+      if (routes.length > 0 && rng() < epsilon) {
+        const picked = routes[Math.min(routes.length - 1, Math.floor(rng() * routes.length))];
+        if (picked !== undefined) return picked;
+      }
+      return inner.select(req, routes);
+    },
+  };
+}
+
+// A fixed router that always selects a specific model id — handy for tests and for
+// pinning a strategy to one model.
+export function fixedRouter(modelId: string): Router {
+  return {
+    select(_req, routes) {
+      const route = routes.find((r) => r.id === modelId);
+      if (route === undefined) {
+        throw new Error(`ReasoningRuntime: fixedRouter target "${modelId}" not in routes`);
+      }
+      return route;
+    },
+  };
+}

package/src/routing.bench.ts

@@ -0,0 +1,54 @@
+import type { LlmProvider, LlmResponse } from "@loomwork/llm";
+import { bench, describe } from "vitest";
+import { ReasoningRuntime } from "./ReasoningRuntime";
+import { tagRouter } from "./router";
+import type { ConfidenceSignal, ModelRoute } from "./types";
+
+// Benches for the two routing hot paths made O(1)/O(n):
+//   1. tagRouter no longer re-sorts the route list on every select().
+//   2. Elevation hops via a precomputed next-tier index instead of an O(n) scan,
+//      so walking a deep ladder is O(n) not O(n^2).
+
+class FakeProvider implements LlmProvider {
+  constructor(private readonly res: LlmResponse) {}
+  async complete(): Promise<LlmResponse> {
+    return this.res;
+  }
+}
+
+const weak: LlmResponse = { content: "weak", stopReason: "max_tokens" };
+// Force elevation all the way up the ladder every call.
+const alwaysLow: ConfidenceSignal = { score: () => 0 };
+
+function makeRoutes(n: number): ModelRoute[] {
+  const provider = new FakeProvider(weak);
+  return Array.from({ length: n }, (_, i) => ({
+    id: `m${i}`,
+    provider,
+    tier: i,
+    ...(i === 0 && { tags: ["planning"] }),
+  }));
+}
+
+const routes = makeRoutes(64);
+
+describe("tagRouter.select over 64 routes", () => {
+  const req = { messages: [{ role: "user" as const, content: "hi" }], strategy: "planning" };
+
+  bench("re-sort baseline (previous shape)", () => {
+    const sorted = [...routes].sort((a, b) => a.tier - b.tier);
+    sorted.find((r) => r.tags?.includes("planning"));
+  });
+
+  bench("tagRouter.select (pre-sorted, no re-sort)", () => {
+    tagRouter.select(req, routes);
+  });
+});
+
+describe("reason() full elevation up a 64-tier ladder", () => {
+  const runtime = new ReasoningRuntime({ routes, confidence: alwaysLow });
+
+  bench("reason (O(1) tier hops)", async () => {
+    await runtime.reason({ messages: [{ role: "user", content: "hi" }] });
+  });
+});