@neutrome/lilsdk 0.6.1 → 0.6.3

package/README.md

@@ -18,8 +18,10 @@ small — SDK contracts only — and each subpath owns one concern:
   `OutputSink`, and `createExecutionEvent`
 - `@neutrome/lilsdk/loops`: `retry`, `fallback`, and `createGoalExecutor`
 - `@neutrome/lilsdk/tools`: `createToolsExecutor` tool-call loop
-- `@neutrome/lilsdk/managed`: `createCapabilitiesExecutor` and
-  `createAttachmentToTextExecutor`
+- `@neutrome/lilsdk/managed`: `createCapabilitiesExecutor`,
+  `createAttachmentToTextExecutor`, and
+  `createCollapsedReasoner(reasoner, summarizer, options)` for safe reasoning
+  updates
 - `@neutrome/lilsdk/stream`: `observeExecutionStream`, `streamStage`, and
   `writeThinking`
 - `@neutrome/lilsdk/primitives`: structural program helpers — `walk`, `map`,

package/etc/api/managed.api.md

@@ -1,102 +1,113 @@
-## API Report File for "neutrome"
-
-> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
-
-```ts
-
-import type { Program } from '@neutrome/lil-engine';
-import { ProgramAttachment } from '@neutrome/lil-engine';
-
-// @public
-export type AttachmentReaderRule = {
-    mimeTypes: readonly string[];
-    executor: ExecutorInput;
-};
-
-// @public
-export type AttachmentToTextOptions = {
-    systemPrompt?: string;
-    cacheKey?: (attachment: ProgramAttachment, ctx: ExecutorContext) => string;
-};
-
-// @public
-type Cache_2 = {
-    get(key: string): Promise<string | null>;
-    put(key: string, value: string, options?: CachePutOptions): Promise<void>;
-    delete(key: string): Promise<void>;
-};
-
-// @public
-type CachePutOptions = {
-    expiration?: number;
-    expirationTtl?: number;
-};
-
-// @public
-export type CapabilitiesExecutorOptions = {
-    enabledIterations?: number;
-    cacheKey?: (ctx: ExecutorContext) => string;
-    skipPrefixes?: readonly string[];
-};
-
-// Warning: (ae-forgotten-export) The symbol "Executor" needs to be exported by the entry point index.d.ts
-//
-// @public
-export function createAttachmentToTextExecutor(inner: ExecutorInput, rules: readonly AttachmentReaderRule[], options?: AttachmentToTextOptions): Executor;
-
-// @public
-export function createCapabilitiesExecutor(inner: ExecutorInput, options?: CapabilitiesExecutorOptions): Executor;
-
-// @public
-type ExecutionEvent = {
-    kind: string;
-    requestId: string;
-    executionId: string;
-    timestamp: string;
-    parentExecutionId?: string;
-    target?: {
-        kind: "provider" | "executor";
-        id: string;
-    };
-    errorKind?: string;
-    data?: Record<string, unknown>;
-};
-
-// @public
-type Executor = {
-    execute(request: Program, ctx: ExecutorContext): Promise<Program>;
-    stream(request: Program, ctx: ExecutorContext): AsyncIterable<Program>;
-};
-
-// Warning: (ae-forgotten-export) The symbol "RuntimeContext" needs to be exported by the entry point index.d.ts
-//
-// @public
-type ExecutorContext = RuntimeContext & {
-    requestId: string;
-    executionId: string;
-    parentExecutionId?: string;
-};
-
-// @public
-type ExecutorInput = string | Executor;
-
-// @public
-type RuntimeContext = {
-    cache: Cache_2;
-    invoke(executor: ExecutorInput, request: Program): Promise<Program>;
-    invokeStream(executor: ExecutorInput, request: Program): AsyncIterable<Program>;
-    observe(event: ExecutionEvent): void;
-    signal: AbortSignal;
-};
-
-// Warnings were encountered during analysis:
-//
-// .reference-build/types/neutrome-lilsdk/src/managed/attachment-to-text.d.ts:8:5 - (ae-forgotten-export) The symbol "ExecutorInput" needs to be exported by the entry point index.d.ts
-// .reference-build/types/neutrome-lilsdk/src/managed/attachment-to-text.d.ts:15:5 - (ae-forgotten-export) The symbol "ExecutorContext" needs to be exported by the entry point index.d.ts
-// .reference-build/types/neutrome-lilsdk/src/types.d.ts:42:5 - (ae-forgotten-export) The symbol "CachePutOptions" needs to be exported by the entry point index.d.ts
-// .reference-build/types/neutrome-lilsdk/src/types.d.ts:55:5 - (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
-// .reference-build/types/neutrome-lilsdk/src/types.d.ts:77:5 - (ae-forgotten-export) The symbol "ExecutionEvent" needs to be exported by the entry point index.d.ts
-
-// (No @packageDocumentation comment for this package)
-
-```
+## API Report File for "neutrome"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { Program } from '@neutrome/lil-engine';
+import { ProgramAttachment } from '@neutrome/lil-engine';
+
+// @public
+export type AttachmentReaderRule = {
+    mimeTypes: readonly string[];
+    executor: ExecutorInput;
+};
+
+// @public
+export type AttachmentToTextOptions = {
+    systemPrompt?: string;
+    cacheKey?: (attachment: ProgramAttachment, ctx: ExecutorContext) => string;
+};
+
+// @public
+type Cache_2 = {
+    get(key: string): Promise<string | null>;
+    put(key: string, value: string, options?: CachePutOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+};
+
+// @public
+type CachePutOptions = {
+    expiration?: number;
+    expirationTtl?: number;
+};
+
+// @public
+export type CapabilitiesExecutorOptions = {
+    enabledIterations?: number;
+    cacheKey?: (ctx: ExecutorContext) => string;
+    skipPrefixes?: readonly string[];
+};
+
+// @public
+export type CollapsedReasonerOptions = {
+    prompt?: string;
+    forcedPrompt?: string;
+    interval?: number;
+    forcedInterval?: number;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Executor" needs to be exported by the entry point index.d.ts
+//
+// @public
+export function createAttachmentToTextExecutor(inner: ExecutorInput, rules: readonly AttachmentReaderRule[], options?: AttachmentToTextOptions): Executor;
+
+// @public
+export function createCapabilitiesExecutor(inner: ExecutorInput, options?: CapabilitiesExecutorOptions): Executor;
+
+// @public
+export function createCollapsedReasoner(reasoner: ExecutorInput, summarizer: ExecutorInput, options?: CollapsedReasonerOptions): Executor;
+
+// @public
+type ExecutionEvent = {
+    kind: string;
+    requestId: string;
+    executionId: string;
+    timestamp: string;
+    parentExecutionId?: string;
+    target?: {
+        kind: "provider" | "executor";
+        id: string;
+    };
+    errorKind?: string;
+    data?: Record<string, unknown>;
+};
+
+// @public
+type Executor = {
+    execute(request: Program, ctx: ExecutorContext): Promise<Program>;
+    stream(request: Program, ctx: ExecutorContext): AsyncIterable<Program>;
+};
+
+// Warning: (ae-forgotten-export) The symbol "RuntimeContext" needs to be exported by the entry point index.d.ts
+//
+// @public
+type ExecutorContext = RuntimeContext & {
+    requestId: string;
+    executionId: string;
+    parentExecutionId?: string;
+};
+
+// @public
+type ExecutorInput = string | Executor;
+
+// @public
+type RuntimeContext = {
+    cache: Cache_2;
+    invoke(executor: ExecutorInput, request: Program): Promise<Program>;
+    invokeStream(executor: ExecutorInput, request: Program): AsyncIterable<Program>;
+    observe(event: ExecutionEvent): void;
+    signal: AbortSignal;
+};
+
+// Warnings were encountered during analysis:
+//
+// .reference-build/types/neutrome-lilsdk/src/managed/attachment-to-text.d.ts:8:5 - (ae-forgotten-export) The symbol "ExecutorInput" needs to be exported by the entry point index.d.ts
+// .reference-build/types/neutrome-lilsdk/src/managed/attachment-to-text.d.ts:15:5 - (ae-forgotten-export) The symbol "ExecutorContext" needs to be exported by the entry point index.d.ts
+// .reference-build/types/neutrome-lilsdk/src/types.d.ts:42:5 - (ae-forgotten-export) The symbol "CachePutOptions" needs to be exported by the entry point index.d.ts
+// .reference-build/types/neutrome-lilsdk/src/types.d.ts:55:5 - (ae-forgotten-export) The symbol "Cache_2" needs to be exported by the entry point index.d.ts
+// .reference-build/types/neutrome-lilsdk/src/types.d.ts:77:5 - (ae-forgotten-export) The symbol "ExecutionEvent" needs to be exported by the entry point index.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/lilsdk",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",

package/src/managed/collapsed-reasoner.ts

@@ -0,0 +1,237 @@
+import {
+  appendInstructions,
+  appendUserMessage,
+  createProgram,
+  extractContentText,
+  extractThinkingText,
+  findThinkingBlocks,
+  Opcode,
+  prependSystemPrompt,
+  removeInstructions,
+  type Program,
+} from "@neutrome/lil-engine";
+import type { Executor, ExecutorContext, ExecutorInput } from "../types.ts";
+
+const DEFAULT_INTERVAL = 2_000;
+const DEFAULT_FORCED_INTERVAL = 8_000;
+
+const DEFAULT_PROMPT =
+  "Summarize the reasoning below as a concise user-facing progress update. Return an empty response when there is no useful update.";
+const DEFAULT_FORCED_PROMPT =
+  "Give a concise user-facing progress update based only on the reasoning below. Return an empty response when no update is useful.";
+
+/** Options accepted by {@link createCollapsedReasoner}. */
+export type CollapsedReasonerOptions = {
+  /** Prompt used for periodic progress updates. */
+  prompt?: string;
+  /** Prompt used when an update must be attempted. */
+  forcedPrompt?: string;
+  /** Milliseconds between ordinary progress updates. Defaults to 2 seconds. */
+  interval?: number;
+  /** Milliseconds between forced updates. Defaults to 8 seconds. */
+  forcedInterval?: number;
+};
+
+/**
+ * Hides a reasoner's raw chain of thought and replaces it with concise,
+ * user-facing progress updates generated by a separate summarizer.
+ *
+ * @param reasoner - Executor or model id that produces the original response.
+ * @param summarizer - Executor or model id that summarizes unexposed reasoning.
+ * @param options - Prompts and wall-clock update cadence.
+ */
+export function createCollapsedReasoner(
+  reasoner: ExecutorInput,
+  summarizer: ExecutorInput,
+  options: CollapsedReasonerOptions = {},
+): Executor {
+  const settings = parseOptions(options);
+
+  return {
+    async execute(request, ctx) {
+      const response = await ctx.invoke(reasoner, request);
+      const reasoning = extractThinkingText(response);
+      const concealed = withoutThinking(response);
+      if (!reasoning) return concealed;
+
+      const summary = await summarize(ctx, summarizer, settings.forcedPrompt, reasoning);
+      return summary ? appendAssistantThinking(concealed, summary) : concealed;
+    },
+
+    async *stream(request, ctx) {
+      const source = ctx.invokeStream(reasoner, request)[Symbol.asyncIterator]();
+      let raw = "";
+      let startedAt: number | undefined;
+      let normalAt = 0;
+      let forcedAt = 0;
+      let summaries: Promise<void> = Promise.resolve();
+      const ready: string[] = [];
+      let summaryError: unknown;
+      let wake: (() => void) | undefined;
+      let wakePromise = nextWake();
+      const terminal: Program[] = [];
+
+      const notify = () => {
+        wake?.();
+        wakePromise = nextWake();
+      };
+      const enqueue = (prompt: string, force: boolean) => {
+        if (!raw) return;
+        const interval = raw;
+        raw = "";
+        summaries = summaries.then(async () => {
+          const summary = await summarize(ctx, summarizer, prompt, interval);
+          if (summary) ready.push(summary);
+        });
+        void summaries.then(notify, (error: unknown) => {
+          summaryError = error;
+          notify();
+        });
+        if (force) normalAt = Date.now();
+      };
+
+      let next = source.next();
+      try {
+        for (;;) {
+          if (summaryError) throw summaryError;
+          while (ready.length > 0) yield thinkingChunk(ready.shift()!);
+
+          const now = Date.now();
+          if (startedAt !== undefined) {
+            if (now >= forcedAt) {
+              enqueue(settings.forcedPrompt, true);
+              forcedAt = now + settings.forcedInterval;
+              normalAt = now + settings.interval;
+              continue;
+            }
+            if (now >= normalAt) {
+              enqueue(settings.prompt, false);
+              normalAt = now + settings.interval;
+              continue;
+            }
+          }
+
+          const due = startedAt === undefined
+            ? undefined
+            : Math.max(0, Math.min(normalAt, forcedAt) - Date.now());
+          const event = await Promise.race([
+            next.then((result) => ({ type: "source" as const, result })),
+            wakePromise.then(() => ({ type: "summary" as const })),
+            ...(due === undefined ? [] : [delay(due).then(() => ({ type: "timer" as const }))]),
+          ]);
+          if (event.type !== "source") continue;
+          next = source.next();
+          if (event.result.done) break;
+
+          const visible = splitStreamChunk(event.result.value, terminal, (text) => {
+            raw += text;
+            if (startedAt === undefined) {
+              const timestamp = Date.now();
+              startedAt = timestamp;
+              normalAt = timestamp + settings.interval;
+              forcedAt = timestamp + settings.forcedInterval;
+            }
+          });
+          if (visible.code.length > 0) yield visible;
+        }
+
+        enqueue(settings.forcedPrompt, true);
+        await summaries;
+        if (summaryError) throw summaryError;
+        while (ready.length > 0) yield thinkingChunk(ready.shift()!);
+        yield* terminal;
+      } finally {
+        await source.return?.();
+      }
+
+      function nextWake(): Promise<void> {
+        return new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+    },
+  };
+}
+
+function parseOptions(options: CollapsedReasonerOptions) {
+  const interval = positiveDuration(options.interval ?? DEFAULT_INTERVAL, "interval");
+  const forcedInterval = positiveDuration(
+    options.forcedInterval ?? DEFAULT_FORCED_INTERVAL,
+    "forcedInterval",
+  );
+  if (forcedInterval < interval) {
+    throw new RangeError("forcedInterval must be greater than or equal to interval");
+  }
+  return {
+    interval,
+    forcedInterval,
+    prompt: options.prompt ?? DEFAULT_PROMPT,
+    forcedPrompt: options.forcedPrompt ?? DEFAULT_FORCED_PROMPT,
+  };
+}
+
+function positiveDuration(value: number, name: string): number {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive duration in milliseconds`);
+  }
+  return value;
+}
+
+async function summarize(
+  ctx: ExecutorContext,
+  summarizer: ExecutorInput,
+  prompt: string,
+  reasoning: string,
+): Promise<string> {
+  const request = prependSystemPrompt(appendUserMessage(createProgram(), reasoning), prompt);
+  return extractContentText(await ctx.invoke(summarizer, request)).trim();
+}
+
+function withoutThinking(program: Program): Program {
+  const indices = findThinkingBlocks(program).flatMap((block) =>
+    Array.from({ length: block.end - block.start + 1 }, (_, offset) => block.start + offset),
+  );
+  return removeInstructions(program, indices);
+}
+
+function appendAssistantThinking(program: Program, text: string): Program {
+  return appendInstructions(program, [
+    { opcode: Opcode.MSG_START, value: { kind: "none" } },
+    { opcode: Opcode.ROLE_AST, value: { kind: "none" } },
+    { opcode: Opcode.THINK_START, value: { kind: "none" } },
+    { opcode: Opcode.THINK_CHUNK, value: { kind: "string", value: text } },
+    { opcode: Opcode.THINK_END, value: { kind: "none" } },
+    { opcode: Opcode.MSG_END, value: { kind: "none" } },
+  ]);
+}
+
+function splitStreamChunk(
+  chunk: Program,
+  terminal: Program[],
+  onThinking: (text: string) => void,
+): Program {
+  const visible = [] as Program["code"];
+  const ending = [] as Program["code"];
+  for (const instruction of chunk.code) {
+    if (instruction.opcode === Opcode.STREAM_THINK_DELTA && instruction.value.kind === "string") {
+      onThinking(instruction.value.value);
+    } else if (instruction.opcode === Opcode.RESP_DONE || instruction.opcode === Opcode.STREAM_END) {
+      ending.push(instruction);
+    } else {
+      visible.push(instruction);
+    }
+  }
+  if (ending.length > 0) terminal.push({ code: ending, buffers: chunk.buffers });
+  return { code: visible, buffers: chunk.buffers };
+}
+
+function thinkingChunk(text: string): Program {
+  return {
+    code: [{ opcode: Opcode.STREAM_THINK_DELTA, value: { kind: "string", value: text } }],
+    buffers: [],
+  };
+}
+
+function delay(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/src/managed/index.ts

@@ -1,5 +1,7 @@
 export { createCapabilitiesExecutor } from "./capabilities.ts";
 export type { CapabilitiesExecutorOptions } from "./capabilities.ts";
+export { createCollapsedReasoner } from "./collapsed-reasoner.ts";
+export type { CollapsedReasonerOptions } from "./collapsed-reasoner.ts";
 export { createAttachmentToTextExecutor } from "./attachment-to-text.ts";
 export type {
   AttachmentReaderRule,

package/test/collapsed-reasoner.test.ts

@@ -0,0 +1,190 @@
+import {
+  appendAssistantMessage,
+  appendInstructions,
+  createProgram,
+  delta,
+  extractContentText,
+  extractThinkingText,
+  Opcode,
+  ProgramView,
+  type Instruction,
+  type Program,
+} from "@neutrome/lil-engine";
+import { describe, expect, it, vi } from "vitest";
+import { createCollapsedReasoner } from "../src/managed/collapsed-reasoner.ts";
+import type { Executor, ExecutorContext } from "../src/types.ts";
+
+describe("createCollapsedReasoner", () => {
+  it("replaces completed raw reasoning with a forced summary", async () => {
+    let summaryRequest: Program | undefined;
+    const executor = createCollapsedReasoner(
+      fromExecute(async () => withThinking("answer", "private reasoning")),
+      fromExecute(async (request) => {
+        summaryRequest = request;
+        return appendAssistantMessage(createProgram(), "Working through it.");
+      }),
+    );
+
+    const result = await executor.execute(createProgram(), context());
+
+    expect(extractContentText(result)).toBe("answer");
+    expect(extractThinkingText(result)).toBe("Working through it.");
+    expect(new ProgramView(summaryRequest!).messages.at(-1)?.text).toBe("private reasoning");
+  });
+
+  it("suppresses raw stream deltas, preserves visible chunks, and flushes before the end", async () => {
+    const executor = createCollapsedReasoner(
+      streaming(async function* () {
+        yield delta.start();
+        yield delta.thinking("private reasoning");
+        yield delta.text("answer");
+        yield delta.end();
+      }),
+      fromExecute(async () => appendAssistantMessage(createProgram(), "Checking details.")),
+    );
+
+    const chunks: Program[] = [];
+    for await (const chunk of executor.stream(createProgram(), context())) chunks.push(chunk);
+
+    expect(extractStreamThinking(chunks)).toEqual(["Checking details."]);
+    expect(chunks.map((chunk) => extractStreamText(chunk)).join("")).toBe("answer");
+    expect(chunks.at(-1)?.code.map((item) => item.opcode)).toEqual([
+      Opcode.RESP_DONE,
+      Opcode.STREAM_END,
+    ]);
+  });
+
+  it("uses elapsed time for periodic summaries and gives a forced tick priority", async () => {
+    vi.useFakeTimers();
+    let release: (() => void) | undefined;
+    const executor = createCollapsedReasoner(
+      streaming(async function* () {
+        yield delta.thinking("first");
+        await new Promise<void>((resolve) => {
+          release = resolve;
+        });
+        yield delta.end();
+      }),
+      fromExecute(async (request) =>
+        appendAssistantMessage(createProgram(), `summary:${extractContentText(request)}`),
+      ),
+      { interval: 10, forcedInterval: 20 },
+    );
+    const iterator = executor.stream(createProgram(), context())[Symbol.asyncIterator]();
+
+    const pendingSummary = iterator.next();
+    await vi.advanceTimersByTimeAsync(20);
+    const summary = await pendingSummary;
+    release?.();
+    const end = await iterator.next();
+    vi.useRealTimers();
+
+    expect(extractStreamThinking([summary.value!])).toEqual([expect.stringContaining("first")]);
+    expect(end.value?.code.some((item: Instruction) => item.opcode === Opcode.STREAM_END)).toBe(true);
+  });
+
+  it("validates its timing options and never emits blank summaries", async () => {
+    expect(() => createCollapsedReasoner("reasoner", "summarizer", { interval: 0 })).toThrow(RangeError);
+    expect(() =>
+      createCollapsedReasoner("reasoner", "summarizer", { interval: 10, forcedInterval: 9 }),
+    ).toThrow(RangeError);
+
+    const executor = createCollapsedReasoner(
+      streaming(async function* () {
+        yield delta.thinking("private");
+        yield delta.end();
+      }),
+      fromExecute(async () => appendAssistantMessage(createProgram(), "   ")),
+    );
+    const chunks: Program[] = [];
+    for await (const chunk of executor.stream(createProgram(), context())) chunks.push(chunk);
+    expect(extractStreamThinking(chunks)).toEqual([]);
+  });
+
+  it("propagates source and summarizer failures without exposing reasoning", async () => {
+    const sourceFailure = new Error("source failed");
+    const brokenSource = createCollapsedReasoner(
+      streaming(async function* () {
+        throw sourceFailure;
+      }),
+      "summarizer",
+    );
+    await expect(collect(brokenSource.stream(createProgram(), context()))).rejects.toBe(sourceFailure);
+
+    const summaryFailure = new Error("summary failed");
+    const brokenSummary = createCollapsedReasoner(
+      streaming(async function* () {
+        yield delta.thinking("private");
+        yield delta.end();
+      }),
+      fromExecute(async () => {
+        throw summaryFailure;
+      }),
+    );
+    await expect(collect(brokenSummary.stream(createProgram(), context()))).rejects.toBe(summaryFailure);
+  });
+});
+
+function withThinking(text: string, thinking: string): Program {
+  return appendInstructions(appendAssistantMessage(createProgram(), text), [
+    { opcode: Opcode.MSG_START, value: { kind: "none" } },
+    { opcode: Opcode.ROLE_AST, value: { kind: "none" } },
+    { opcode: Opcode.THINK_START, value: { kind: "none" } },
+    { opcode: Opcode.THINK_CHUNK, value: { kind: "string", value: thinking } },
+    { opcode: Opcode.THINK_END, value: { kind: "none" } },
+    { opcode: Opcode.MSG_END, value: { kind: "none" } },
+  ]);
+}
+
+function context(): ExecutorContext {
+  const ctx: ExecutorContext = {
+    cache: { get: async () => null, put: async () => {}, delete: async () => {} },
+    requestId: "request",
+    executionId: "execution",
+    invoke(executor, request) {
+      return typeof executor === "string"
+        ? Promise.resolve(request)
+        : executor.execute(request, ctx);
+    },
+    async *invokeStream(executor, request) {
+      if (typeof executor !== "string") yield* executor.stream(request, ctx);
+    },
+    observe() {},
+    signal: new AbortController().signal,
+  };
+  return ctx;
+}
+
+function fromExecute(execute: Executor["execute"]): Executor {
+  return { execute, async *stream() {} };
+}
+
+function streaming(stream: Executor["stream"]): Executor {
+  return { async execute() { return createProgram(); }, stream };
+}
+
+function extractStreamText(chunk: Program): string {
+  let text = "";
+  for (const item of chunk.code) {
+    if (item.opcode === Opcode.STREAM_DELTA && item.value.kind === "string") text += item.value.value;
+  }
+  return text;
+}
+
+function extractStreamThinking(chunks: Program[]): string[] {
+  const thinking: string[] = [];
+  for (const chunk of chunks) {
+    for (const item of chunk.code) {
+      if (item.opcode === Opcode.STREAM_THINK_DELTA && item.value.kind === "string") {
+        thinking.push(item.value.value);
+      }
+    }
+  }
+  return thinking;
+}
+
+async function collect(stream: AsyncIterable<Program>): Promise<Program[]> {
+  const chunks: Program[] = [];
+  for await (const chunk of stream) chunks.push(chunk);
+  return chunks;
+}