pi-condense 2.11.5 → 2.12.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ Published to npm as [`pi-condense`](https://www.npmjs.com/package/pi-condense) (
 Pushing a `vX.Y.Z` tag triggers `.github/workflows/release.yml`, which runs the tests and
 publishes via OIDC trusted publishing. See `.agents/skills/release/SKILL.md`.
 
+## [2.12.0] - 2026-10-17
+
+### Fixed
+
+- Virtual (router-backed) models work as the summarizer - via `summarizerModel: "default"`, an explicit virtual `provider/id`, or as the outage-fallback session model. Summarizer calls now go through `ctx.modelRegistry.streamSimple()` instead of pi-ai's provider table, which had no `pi-virtual` entry and threw `No API provider registered for api: pi-virtual`. (#20)
+- A summarizer stream that ignores the abort signal (a virtual router whose `route()` never resolves) no longer wedges the flush: the idle and ceiling timers now end the wait themselves. (#20)
+
+### Changed
+
+- `summarizerThinking` applies on every provider; it was sent as an OpenAI-specific `reasoningEffort` option that Anthropic-style adapters ignored. `default` and `off` still send no reasoning option, which on Anthropic means `thinkingEnabled: false` as before. (#20)
+- Minimum supported host is pi 1.3.0; dev dependencies on `@earendil-works/pi-ai`, `pi-coding-agent`, and `pi-tui` move from `^0.83.0` to `^1.3.0`. (#20)
+
 ## [2.11.5] - 2026-10-08
 
 ### Changed

package/README.md

@@ -126,6 +126,8 @@ These are most informative for long single-chain sessions where Phase 3 (chain c
 
 Published to npm as [`pi-condense`](https://www.npmjs.com/package/pi-condense).
 
+Requires pi >= 1.3.0: the summarizer calls `ctx.modelRegistry.streamSimple()`, which is what lets a virtual (router-backed) model serve as the summarizer. Older hosts are unsupported; before pi 0.86.0 the method does not exist and every summarizer call fails with a `TypeError` notice.
+
 **User scope** (all repos under your pi profile):
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.11.5",
+  "version": "2.12.0",
   "description": "Pi coding-agent extension that summarizes completed tool-call batches, replaces raw outputs with short stubs, compresses closed tool-call chains, and recovers any original on demand via context_tree_query.",
   "author": "Jacek Juraszek",
   "license": "MIT",
@@ -57,9 +57,9 @@
     "@sinclair/typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.83.0",
-    "@earendil-works/pi-coding-agent": "^0.83.0",
-    "@earendil-works/pi-tui": "^0.83.0",
+    "@earendil-works/pi-ai": "^1.3.0",
+    "@earendil-works/pi-coding-agent": "^1.3.0",
+    "@earendil-works/pi-tui": "^1.3.0",
     "@sinclair/typebox": "^0.34.52"
   }
 }

package/src/error-purge.transport.test.ts

@@ -35,6 +35,7 @@ const meta = { api: "openai-completions", provider: "openai", model: "grammar-te
 
 function history(codeArgs: Record<string, unknown>) {
   return [
+    { role: "system", content: "", toolsAdded: [codemode], timestamp: 0 },
     { role: "user", content: "run it", timestamp: 1 },
     { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "codemode", arguments: codeArgs }], ...meta, stopReason: "toolUse", timestamp: 2 },
     { role: "toolResult", toolCallId: "tc1", toolName: "codemode", content: [{ type: "text", text: "Error: boom" }], isError: true, timestamp: 3 },
@@ -60,7 +61,7 @@ describe("error purge x pi-ai grammar tools (#19)", () => {
 
   it("purged codemode args pass getGrammarToolInput (reporter repro)", () => {
     const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
-    const args = purged[1].content[0].arguments;
+    const args = purged[2].content[0].arguments;
     expect(typeof args.code).toBe("string");
     expect(Object.keys(args)).toEqual(["code"]);
     expect(JSON.stringify(args).length).toBeLessThan(500);
@@ -69,7 +70,7 @@ describe("error purge x pi-ai grammar tools (#19)", () => {
 
   it("request building succeeds on purged history; failure is the connection, not the grammar", async () => {
     const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
-    expect(purged[1].content[0].arguments.code).toMatch(/^<purged-errored-args size=/);
+    expect(purged[2].content[0].arguments.code).toMatch(/^<purged-errored-args size=/);
     const { result, calls } = await request(purged);
     expect(result.stopReason).toBe("error");
     // The OpenAI SDK wraps fetch rejections in APIConnectionError and drops the cause message.
@@ -80,7 +81,7 @@ describe("error purge x pi-ai grammar tools (#19)", () => {
 
   it("negative control: the old { _purged } shape throws the grammar error before any request", async () => {
     const legacy = history({ code: "x".repeat(1000) });
-    legacy[1].content[0].arguments = { _purged: '<purged-errored-args size="1012"/>' };
+    legacy[2].content[0].arguments = { _purged: '<purged-errored-args size="1012"/>' };
     const { result, calls } = await request(legacy);
     expect(result.stopReason).toBe("error");
     expect(result.errorMessage).toMatch(/Grammar tool call "codemode" requires argument "code" to be a string/);

package/src/reload-rearm.integration.test.ts

@@ -1,8 +1,7 @@
-import { describe, it, expect, mock } from "bun:test";
+import { describe, it, expect } from "bun:test";
 import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import * as actualCompat from "@earendil-works/pi-ai/compat";
 import { supersededStub } from "./supersede.js";
 
 // This must run before any module that transitively reads PI_CODING_AGENT_DIR
@@ -67,11 +66,6 @@ let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
   return okStream();
 };
 
-mock.module("@earendil-works/pi-ai/compat", () => ({
-  ...actualCompat,
-  stream: (...args: any[]) => streamImpl(...args),
-}));
-
 type AppendedEntry = { type: string; data: unknown };
 
 // The captured-but-unflushed batch: a user message, an assistant message with
@@ -305,7 +299,7 @@ function bootExtension(
     modelRegistry: {
       find: () => undefined,
       getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "test", headers: {} }),
-      getProviderAuth: async () => undefined,
+      streamSimple: (model: any, input: any, opts: any) => streamImpl(model, input, opts),
     },
     ui: {
       setStatus() {},

package/src/summarizer-wiring.test.ts

@@ -1,22 +1,14 @@
-import { describe, it, expect, mock } from "bun:test";
-import * as actualCompat from "@earendil-works/pi-ai/compat";
-
-// Stub pi-ai's `stream` so runSummarization can be exercised without a network
-// call. `streamImpl` is swapped per test to simulate primary/fallback outcomes.
+import { describe, it, expect } from "bun:test";
 let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
   throw new Error("streamImpl not set");
 };
-mock.module("@earendil-works/pi-ai/compat", () => ({
-  ...actualCompat,
-  stream: (...args: any[]) => streamImpl(...args),
-}));
-
-const { summarizeBatch } = await import("./summarizer.js");
+const { summarizeBatch, summarizeRange } = await import("./summarizer.js");
 const { FallbackController } = await import("./summarizer-fallback.js");
 const { DEFAULT_CONFIG } = await import("./types.js");
 
-const PRIMARY = { id: "primary-model", provider: "provider-a", name: "Primary" };
-const SESSION = { id: "session-model", provider: "provider-b", name: "Session" };
+const PRIMARY = { id: "primary-model", provider: "provider-a", name: "Primary", api: "openai-responses" };
+const SESSION = { id: "session-model", provider: "provider-b", name: "Session", api: "openai-responses" };
+const VIRTUAL = { id: "auto", provider: "router", name: "Auto", api: "pi-virtual" };
 
 const USAGE = {
   input: 1,
@@ -67,6 +59,19 @@ function hangingStream(opts: any) {
   };
 }
 
+// Models a router that never settles and ignores cancellation.
+function deafStream() {
+  const never = new Promise<never>(() => {});
+  return {
+    async *[Symbol.asyncIterator]() {
+      await never;
+    },
+    async result() {
+      return never;
+    },
+  };
+}
+
 // Emits `events` thinking_delta events spaced `gapMs` apart, then completes
 // successfully — UNLESS `opts.signal` aborts mid-drip, in which case the
 // current sleep rejects, exactly like a real provider stream cancelling on
@@ -107,13 +112,19 @@ interface Note {
   level: string;
 }
 
-function makeCtx(notes: Note[], sessionModel: any = SESSION, primaryModel: any = PRIMARY) {
+function makeCtx(notes: Note[], sessionModel: any = SESSION, primaryModel: any = PRIMARY, authOk = true) {
+  const authCalls: any[] = [];
   return {
     model: sessionModel,
+    authCalls,
     modelRegistry: {
       find: () => primaryModel,
-      getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
-      getProviderAuth: async () => undefined,
+      getApiKeyAndHeaders: async (model: any) => {
+        authCalls.push(model);
+        return authOk ? { ok: true, apiKey: "k", headers: {} } : { ok: false, error: "no key for provider-a" };
+      },
+      getProviderAuth: async () => ({ auth: { baseUrl: "https://seat.example" } }),
+      streamSimple: (model: any, input: any, opts: any) => streamImpl(model, input, opts),
     },
     ui: { notify: (msg: string, level: string) => notes.push({ msg, level }) },
   } as any;
@@ -132,6 +143,90 @@ function makeBatch() {
 
 const distinctConfig = { ...DEFAULT_CONFIG, summarizerModel: "provider-a/primary-model" };
 
+describe("virtual models through the registry", () => {
+  for (const operation of ["batch", "range"] as const) {
+    const summarize = (config: any, ctx: any, options: any = {}) => operation === "batch"
+      ? summarizeBatch(makeBatch(), config, ctx, options)
+      : summarizeRange("- step one", config, ctx, options);
+
+    it(`${operation}: virtual session model rescues a transient primary`, async () => {
+      const seen: any[] = [];
+      streamImpl = (model) => {
+        seen.push(model);
+        return model === PRIMARY ? errStream("down") : okStream("- routed summary");
+      };
+      const notes: Note[] = [];
+      const controller = new FallbackController();
+      const result = await summarize(distinctConfig, makeCtx(notes, VIRTUAL), { controller });
+      expect(result?.summaryText).toBe("- routed summary");
+      expect(controller.inFallback).toBe(true);
+      expect(seen[1]).toBe(VIRTUAL);
+      expect(notes.filter(n => n.level === "warning")).toHaveLength(1);
+      expect(notes.filter(n => n.level === "error")).toHaveLength(0);
+    });
+
+    for (const selection of ["default", "router/auto"]) {
+      it(`${operation}: virtual ${selection} skips auth and sends only summarizer context`, async () => {
+        const calls: any[] = [];
+        streamImpl = (model, input, opts) => {
+          calls.push({ model, input, opts });
+          return okStream("- ok");
+        };
+        const notes: Note[] = [];
+        const ctx = makeCtx(notes, VIRTUAL, VIRTUAL);
+        const result = await summarize({ ...DEFAULT_CONFIG, summarizerModel: selection }, ctx);
+        expect(result?.summaryText).toBe("- ok");
+        expect(calls).toHaveLength(1);
+        expect(calls[0].model).toBe(VIRTUAL);
+        expect(ctx.authCalls).toHaveLength(0);
+        expect(Object.keys(calls[0].input)).toEqual(["messages"]);
+        expect(calls[0].input.messages).toHaveLength(1);
+        expect(calls[0].input.messages[0].role).toBe("user");
+        expect(calls[0].opts.apiKey).toBeUndefined();
+        expect(calls[0].opts.headers).toBeUndefined();
+        expect(notes).toHaveLength(0);
+      });
+    }
+  }
+
+  it("passes the physical model unchanged and pre-checks once", async () => {
+    const seen: any[] = [];
+    streamImpl = (model) => {
+      seen.push(model);
+      return okStream("- ok");
+    };
+    const ctx = makeCtx([]);
+    await summarizeBatch(makeBatch(), DEFAULT_CONFIG, ctx);
+    expect(seen[0]).toBe(SESSION);
+    expect(seen[0].baseUrl).toBeUndefined();
+    expect(ctx.authCalls).toEqual([SESSION]);
+  });
+
+  it("missing physical credentials never stream or trip the controller", async () => {
+    let called = 0;
+    streamImpl = () => { called++; return okStream("- never"); };
+    const notes: Note[] = [];
+    const controller = new FallbackController();
+    const result = await summarizeBatch(makeBatch(), distinctConfig, makeCtx(notes, SESSION, PRIMARY, false), { controller });
+    expect(result).toBeNull();
+    expect(called).toBe(0);
+    expect(controller.inFallback).toBe(false);
+    expect(notes).toHaveLength(1);
+    expect(notes[0].level).toBe("error");
+    expect(notes[0].msg).toContain("no key for provider-a");
+  });
+
+  it("virtual stream failure returns null with the existing error notice", async () => {
+    streamImpl = () => errStream("router: no credentials for routed model");
+    const notes: Note[] = [];
+    const result = await summarizeBatch(makeBatch(), DEFAULT_CONFIG, makeCtx(notes, VIRTUAL));
+    expect(result).toBeNull();
+    expect(notes).toHaveLength(1);
+    expect(notes[0].level).toBe("error");
+    expect(notes[0].msg).toContain("router: no credentials for routed model");
+  });
+});
+
 describe("runSummarization wiring — same-model no-op (legacy path)", () => {
   it("summarizerModel=default: transient failure notifies error, returns null, controller untouched", async () => {
     streamImpl = () => errStream("provider overloaded");
@@ -223,6 +318,33 @@ describe("runSummarization wiring — abort", () => {
 });
 
 describe("runSummarization wiring — timeouts", () => {
+  for (const [kind, idleMs, maxMs, message] of [
+    ["idle", 20, 0, /stalled/],
+    ["ceiling", 0, 20, /ceiling/],
+  ] as const) {
+    it(`stream that ignores the signal still times out (${kind})`, async () => {
+      streamImpl = () => deafStream();
+      const notes: Note[] = [];
+      const ctx = makeCtx(notes, VIRTUAL);
+      const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: idleMs, summarizerMaxTimeoutMs: maxMs };
+      expect(await summarizeBatch(makeBatch(), cfg, ctx, {})).toBeNull();
+      expect(notes).toHaveLength(1);
+      expect(notes[0].level).toBe("warning");
+      expect(notes[0].msg).toMatch(message);
+    });
+  }
+
+  it("caller abort during a stream that ignores the signal throws, no warning", async () => {
+    streamImpl = () => deafStream();
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes, VIRTUAL);
+    const ac = new AbortController();
+    setTimeout(() => ac.abort(), 20);
+    const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: 0, summarizerMaxTimeoutMs: 0 };
+    await expect(summarizeBatch(makeBatch(), cfg, ctx, { signal: ac.signal })).rejects.toThrow();
+    expect(notes).toHaveLength(0);
+  });
+
   it("idle timeout (default model): transient warning, returns null", async () => {
     streamImpl = (_m, _i, opts) => hangingStream(opts);
     const notes: Note[] = [];

package/src/summarizer.test.ts

@@ -1,25 +1,21 @@
-import { describe, it, expect, mock } from "bun:test";
-import * as actualCompat from "@earendil-works/pi-ai/compat";
+import { describe, it, expect } from "bun:test";
 
 let seenInput: any;
-mock.module("@earendil-works/pi-ai/compat", () => ({
-  ...actualCompat,
-  stream: (_model: any, input: any) => {
-    seenInput = input;
-    return {
-      async *[Symbol.asyncIterator]() {},
-      async result() {
-        return {
-          stopReason: "stop",
-          content: [{ type: "text", text: "- summary" }],
-          usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-        };
-      },
-    };
-  },
-}));
+function captureStream(_model: any, input: any) {
+  seenInput = input;
+  return {
+    async *[Symbol.asyncIterator]() {},
+    async result() {
+      return {
+        stopReason: "stop",
+        content: [{ type: "text", text: "- summary" }],
+        usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      };
+    },
+  };
+}
 
-const { isUsableSummary, summarizeBatch } = await import("./summarizer.js");
+const { isUsableSummary, summarizeBatch, summarizerThinkingOptions } = await import("./summarizer.js");
 const { DEFAULT_CONFIG } = await import("./types.js");
 
 describe("isUsableSummary", () => {
@@ -37,6 +33,18 @@ describe("isUsableSummary", () => {
   });
 });
 
+describe("summarizerThinkingOptions", () => {
+  it("omits reasoning for default and off", () => {
+    expect(summarizerThinkingOptions({ ...DEFAULT_CONFIG, summarizerThinking: "default" })).toEqual({});
+    expect(summarizerThinkingOptions({ ...DEFAULT_CONFIG, summarizerThinking: "off" })).toEqual({});
+  });
+  it("forwards every other level as reasoning", () => {
+    for (const level of ["minimal", "low", "medium", "high", "xhigh"] as const) {
+      expect(summarizerThinkingOptions({ ...DEFAULT_CONFIG, summarizerThinking: level })).toEqual({ reasoning: level });
+    }
+  });
+});
+
 describe("summarizer prompt", () => {
   it("tells the model that an image marker is an image it cannot see", async () => {
     const model = { id: "m", provider: "p", name: "M" };
@@ -45,7 +53,7 @@ describe("summarizer prompt", () => {
       modelRegistry: {
         find: () => model,
         getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
-        getProviderAuth: async () => undefined,
+        streamSimple: captureStream,
       },
       ui: { notify() {} },
     } as any;
@@ -66,7 +74,7 @@ describe("summarizer prompt", () => {
       modelRegistry: {
         find: () => model,
         getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
-        getProviderAuth: async () => undefined,
+        streamSimple: captureStream,
       },
       ui: { notify() {} },
     } as any;

package/src/summarizer.ts

@@ -1,5 +1,4 @@
-import { stream } from "@earendil-works/pi-ai/compat";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { AssistantMessage, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type {
   CapturedBatch,
@@ -32,17 +31,14 @@ const RANGE_SYSTEM_PROMPT = `You are fusing several per-step summaries of one CL
 - Keep any reference tokens like \`t12\` or \`b3\` intact.
 - Be concise: a short narrative or a few grouped bullets, not one bullet per step.`;
 
-export function summarizerThinkingOptions(config: ContextPruneConfig): Record<string, unknown> {
-  const level: SummarizerThinking = config.summarizerThinking;
-  if (level === "default") {
-    return {};
-  }
+// Pi does not export isVirtualModel.
+const VIRTUAL_MODEL_API = "pi-virtual";
 
-  // stream()/complete() accept provider-level options. For reasoning-capable providers,
-  // pi-ai adapters translate reasoningEffort into the provider-specific field.
-  // "off" intentionally sends no effort; adapters that support explicit disable
-  // handle that the same way as an absent effort, while preserving compatibility.
-  return { reasoningEffort: level === "off" ? undefined : level };
+/** "off" is not a ThinkingLevel; omitting the option is how pi-ai and Pi's own compaction express it. */
+export function summarizerThinkingOptions(config: ContextPruneConfig): { reasoning?: ThinkingLevel } {
+  const level: SummarizerThinking = config.summarizerThinking;
+  if (level === "default" || level === "off") return {};
+  return { reasoning: level };
 }
 
 /**
@@ -110,11 +106,23 @@ function combineSignals(...signals: (AbortSignal | undefined)[]): AbortSignal |
   return AbortSignal.any(present); // Node 20+; host runtime is node 24.5.0
 }
 
+// Virtual routing can ignore the signal, so cancellation must end our wait
+// without depending on the underlying stream settling.
+function untilAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(new Error("summarize: aborted"));
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(new Error("summarize: aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
 /**
  * One summarization attempt against a specific model. Returns a classified
  * outcome instead of throwing (except aborts, which propagate so flushPending
- * can restore state). Auth failure is detected pre-stream and never reaches
- * the fallback path. `unusable` = empty or length-truncated. Everything else
+ * can restore state). Physical-model auth failure is detected pre-stream and never
+ * reaches the fallback path; virtual models skip the pre-check. `unusable` = empty or length-truncated. Everything else
  * that reaches the catch is `transient` (the outage bucket) — pi-ai surfaces
  * no structured status code on the throw, so classification is coarse by design.
  */
@@ -149,25 +157,21 @@ async function runOnce(
       : `summarizer ${modelLabel(model)} stalled (no output for ${Math.round(idleMs / 1000)}s)`;
 
   try {
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-    if (!auth.ok) {
-      const authMessage = "error" in auth ? auth.error : "authentication failed";
-      return { kind: "auth", message: authMessage };
+    // Preserve auth classification for physical models without pre-checking
+    // a virtual model's provider instead of its routed physical target.
+    if (model.api !== VIRTUAL_MODEL_API) {
+      const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+      if (!auth.ok) {
+        const authMessage = "error" in auth ? auth.error : "authentication failed";
+        return { kind: "auth", message: authMessage };
+      }
     }
 
-    // Mirror the main loop (model-runtime stream): auth resolution can carry a
-    // seat-specific baseUrl (e.g. GitHub Copilot business/enterprise endpoints).
-    // The shipped model data pins the individual host, which 421s other seats,
-    // so the resolved auth baseUrl must win over the static model baseUrl.
-    const providerAuth = await ctx.modelRegistry.getProviderAuth(model.provider);
-    const effectiveModel = providerAuth?.auth.baseUrl
-      ? { ...model, baseUrl: providerAuth.auth.baseUrl }
-      : model;
-
     // Pass the combined signal so the underlying fetch is cancelled immediately
     // either when the user presses Esc, or when an idle/ceiling timeout fires.
-    const responseStream = stream(
-      effectiveModel,
+    const signal = combineSignals(options.signal, timeoutController.signal);
+    const responseStream = ctx.modelRegistry.streamSimple(
+      model,
       {
         messages: [
           {
@@ -178,9 +182,7 @@ async function runOnce(
         ],
       },
       {
-        apiKey: auth.apiKey,
-        headers: auth.headers,
-        signal: combineSignals(options.signal, timeoutController.signal),
+        signal,
         ...summarizerThinkingOptions(config),
       }
     );
@@ -206,8 +208,12 @@ async function runOnce(
       }
     };
 
-    for await (const event of responseStream) {
-      // Reset idle on ANY event (text_* and thinking_*), not just text — a
+    const events = responseStream[Symbol.asyncIterator]();
+    while (true) {
+      const next = await untilAbort(events.next(), signal);
+      if (next.done) break;
+      const event = next.value;
+      // Reset idle on ANY event (text_* and thinking_*), not just text - a
       // reasoning-heavy model stays alive via thinking_delta and is never
       // false-aborted for being quiet on text while it reasons.
       bumpIdle();
@@ -222,7 +228,7 @@ async function runOnce(
     // flushPending can detect it and restore batches.
     if (options.signal?.aborted) throw new Error("summarize: aborted during stream");
 
-    const response = await responseStream.result();
+    const response = await untilAbort(responseStream.result(), signal);
     reportTextProgress(response);
     // stopReason "aborted" means the provider cut the stream short (e.g. signal
     // fired just before the final chunk). Treat identically to the signal check