@kevin5251984/guild 0.2.18 → 0.2.20

package/src/mcp.ts

@@ -1,4 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
@@ -215,6 +221,8 @@ class McpSession {
 
 const sessions = new Map<string, McpSession>();
 
+const REDACTED_ENV_VALUE = "***";
+
 export function mcpPath(dataDir: string): string {
   return join(dataDir, "mcp.json");
 }
@@ -237,10 +245,29 @@ export function writeMcpFile(
   servers: Record<string, McpLaunch>,
 ): void {
   mkdirSync(dataDir, { recursive: true });
-  writeFileSync(
-    mcpPath(dataDir),
-    `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`,
-  );
+  const file = mcpPath(dataDir);
+  writeFileSync(file, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  chmodSync(file, 0o600);
+}
+
+/**
+ * The wire shape for HTTP. `launch.env` holds API keys, so every value becomes
+ * a placeholder; the keys stay so the UI can still show that env is set.
+ * Spawning keeps using the full launch from `listGuildMcp` / `listActiveMcp`.
+ */
+export function publicMcpServer(server: McpServer): McpServer {
+  const env = server.launch?.env;
+  const launch: McpLaunch = { ...server.launch };
+  if (env && Object.keys(env).length) {
+    launch.env = Object.fromEntries(
+      Object.keys(env).map((key) => [key, REDACTED_ENV_VALUE]),
+    );
+  } else {
+    delete launch.env;
+  }
+  return { ...server, launch };
 }
 
 export function listGuildMcp(dataDir: string): McpServer[] {

package/src/memory.ts

@@ -127,6 +127,75 @@ export async function harvestBotMemory(input: {
   return { updated: true, body: input.store.writeBotMemory(input.botId, next) };
 }
 
+export function localMergeQuestMemory(
+  parent: string,
+  child: string,
+  questName: string,
+): string | null {
+  const from = redactSecrets(String(child || "").replace(/\r\n/g, "\n")).trim();
+  if (!from) return null;
+  const into = String(parent || "").replace(/\r\n/g, "\n").trim();
+  const heading = String(questName || "side quest").replace(/\s+/g, " ").trim() || "side quest";
+  if (!into) return clipMemory(from);
+  if (into.includes(from)) return null;
+  return clipMemory(`${into}\n\n## ${heading}\n\n${from}`);
+}
+
+function mergeQuestPrompt(parent: string, child: string, questName: string): string {
+  return `You merge a closed side quest's MEMORY.md into the parent channel MEMORY.md.
+Standing notes only: names, preferences, decisions, recurring work, conventions, ownership, tech.
+Keep useful bullets from both. Drop stale, duplicated, or contradicted ones. Max 80 lines.
+Do not copy the whole transcript. Do not mention this merge.
+
+Parent MEMORY.md:
+<<<
+${parent.trim() || "(empty)"}
+>>>
+
+Closed quest "${questName}" MEMORY.md:
+<<<
+${child.trim()}
+>>>
+
+Reply with the complete updated parent MEMORY.md, or exactly NO_CHANGE.`;
+}
+
+export async function mergeQuestMemory(input: {
+  store: GuildStore;
+  parentId: string;
+  childId: string;
+  questName: string;
+  env?: NodeJS.ProcessEnv;
+  prefer?: ModelRef | null;
+}): Promise<{ updated: boolean; body: string }> {
+  const parent = input.store.readChannelMemory(input.parentId);
+  const child = input.store.readChannelMemory(input.childId);
+  if (!child.trim()) return { updated: false, body: parent };
+  const result = await llmComplete({
+    dataDir: input.store.dataDir,
+    env: input.env,
+    role: "compression",
+    prefer: input.prefer,
+    tools: false,
+    temperature: 0.1,
+    system:
+      "You rewrite MEMORY.md. Output markdown or NO_CHANGE. No preamble.",
+    messages: [
+      {
+        role: "user",
+        content: mergeQuestPrompt(parent, child, input.questName),
+      },
+    ],
+  });
+  const fromModel = applyMemoryUpdate(parent, result?.text ?? null);
+  const next = fromModel ?? localMergeQuestMemory(parent, child, input.questName);
+  if (next == null) return { updated: false, body: parent };
+  return {
+    updated: true,
+    body: input.store.writeChannelMemory(input.parentId, next),
+  };
+}
+
 export async function harvestChannelMemory(input: {
   store: GuildStore;
   roomId: string;

package/src/mention.ts

@@ -1,8 +1,22 @@
 /** @channel / @quest / @here / @all still mean the whole quest. */
 const BROADCAST = /(^|\s)@(channel|quest|here|all)\b/i;
 const HANDLE = /@([A-Za-z0-9_-]+)/g;
-/** Consecutive @handles at the start of a line. */
-const LINE_LEAD = /^[ \t]*((?:@[A-Za-z0-9_-]+[\s,、]*)+)/;
+/** Consecutive @handles at the start of a line (optional backticks). */
+const LINE_LEAD = /^[ \t]*((?:`?@[A-Za-z0-9_-]+`?[\s,、]*)+)/;
+/** `1. @design` / `- @infra`. */
+const LIST_MARK = /^[ \t]*(?:\d+[.)、]\s*|[-*•]\s+)/;
+/** Assignee right after the marker, or after 通過後/最後/再叫… — not the first @ anywhere on the line. */
+const LIST_ASSIGN =
+  /^(?:`?@([A-Za-z0-9_-]+)`?|(?:通過後|最後|再叫|交給|交棒(?:給)?|指派|(?:call|ask)\s+)\s*`?@([A-Za-z0-9_-]+)`?)/i;
+/** Numbered/bullet item that names a later wave — do not start them this turn. */
+const LIST_LATER =
+  /^(?:通過後|最後|然後|之後|完成後)\s*`?@([A-Za-z0-9_-]+)`?/i;
+/** Prose: 四席完成後由 @infra / 才交 @infra. 再叫 is a handoff, not a defer. */
+const DEFER_AT =
+  /(?:完成後|通過後|最後(?:才|由)?|才需要|才叫|才交)[^@\n]{0,24}@([A-Za-z0-9_-]+)/gi;
+/** Bare handle after the same cues: 才需要call infra. */
+const DEFER_BARE =
+  /(?:完成後|才需要|才叫)\s*(?:call|ask|由)\s*`?@?([A-Za-z0-9_-]+)`?/gi;
 
 /** Drop fenced / inline code so `@pm` in a snippet does not dispatch. */
 export function stripMentionNoise(text: string): string {
@@ -32,13 +46,26 @@ export type MentionBlock = {
   start: number;
   end: number;
   handles: string[];
+  kind: "lead" | "list";
 };
 
-/** Line-start @handle groups. Prose `@pm` in the middle of a line is not a block. */
+export type MentionBot = { id: string; handle: string };
+
+function knownHandlesIn(chunk: string, known: Set<string>): string[] {
+  const names: string[] = [];
+  for (const row of chunk.matchAll(HANDLE)) {
+    const key = row[1].toLowerCase();
+    if (!known.has(key) || names.includes(key)) continue;
+    names.push(key);
+  }
+  return names;
+}
+
+/** Line-start @handle groups, plus markdown list items that name a seat. */
 export function lineStartMentions(text: string, handles: string[]): MentionBlock[] {
   const raw = String(text ?? "");
   const known = new Set(handles.map((handle) => handle.toLowerCase()));
-  const starts: { start: number; handles: string[] }[] = [];
+  const starts: { start: number; handles: string[]; kind: "lead" | "list" }[] = [];
   let fence = false;
   let offset = 0;
   for (const part of raw.split(/(\r?\n)/)) {
@@ -53,15 +80,22 @@ export function lineStartMentions(text: string, handles: string[]): MentionBlock
       continue;
     }
     if (!fence) {
+      const listed = LIST_MARK.test(part);
       const lead = part.match(LINE_LEAD);
-      if (lead) {
-        const names: string[] = [];
-        for (const row of lead[1].matchAll(HANDLE)) {
-          const key = row[1].toLowerCase();
-          if (!known.has(key) || names.includes(key)) continue;
-          names.push(key);
-        }
-        if (names.length) starts.push({ start: offset, handles: names });
+      let names: string[] = [];
+      if (lead) names = knownHandlesIn(lead[1], known);
+      if (!names.length && listed) {
+        const rest = part.replace(LIST_MARK, "");
+        const hit = rest.match(LIST_ASSIGN);
+        const key = (hit?.[1] || hit?.[2] || "").toLowerCase();
+        if (key && known.has(key)) names = [key];
+      }
+      if (names.length) {
+        starts.push({
+          start: offset,
+          handles: names,
+          kind: listed ? "list" : "lead",
+        });
       }
     }
     offset += part.length;
@@ -70,20 +104,79 @@ export function lineStartMentions(text: string, handles: string[]): MentionBlock
     start: row.start,
     end: i + 1 < starts.length ? starts[i + 1].start : raw.length,
     handles: row.handles,
+    kind: row.kind,
   }));
 }
 
+/** Fenced samples only. Keep inline `code` so 「再叫 `@infra`」 still parses. */
+function stripFences(text: string): string {
+  return String(text ?? "").replace(/```[\s\S]*?```/g, " ");
+}
+
+/** Seats the same message says to start after someone else finishes. */
+export function deferredHandles(text: string, handles: string[]): string[] {
+  const raw = String(text ?? "");
+  const known = new Set(handles.map((handle) => handle.toLowerCase()));
+  const out: string[] = [];
+  const add = (name: string) => {
+    const key = name.toLowerCase();
+    if (!known.has(key) || out.includes(key)) return;
+    out.push(key);
+  };
+  const scan = stripFences(raw);
+  for (const row of scan.matchAll(new RegExp(DEFER_AT.source, "gi"))) {
+    if (row[1]) add(row[1]);
+  }
+  for (const row of scan.matchAll(new RegExp(DEFER_BARE.source, "gi"))) {
+    if (row[1]) add(row[1]);
+  }
+  let fence = false;
+  for (const part of raw.split(/(\r?\n)/)) {
+    if (part === "\n" || part === "\r\n") continue;
+    const trimmed = part.trim();
+    if (trimmed.startsWith("```")) {
+      fence = !fence;
+      continue;
+    }
+    if (fence || !LIST_MARK.test(part)) continue;
+    const hit = part.replace(LIST_MARK, "").match(LIST_LATER);
+    if (hit?.[1]) add(hit[1]);
+  }
+  return out;
+}
+
+export function withoutDeferredIds(
+  ids: string[],
+  text: string,
+  bots: MentionBot[],
+): string[] {
+  if (!ids.length) return ids;
+  const deferred = new Set(
+    deferredHandles(
+      text,
+      bots.map((bot) => bot.handle),
+    ),
+  );
+  if (!deferred.size) return ids;
+  return ids.filter((id) => {
+    const bot = bots.find((row) => row.id === id);
+    return !bot || !deferred.has(bot.handle.toLowerCase());
+  });
+}
+
 /**
  * Fallback when the client did not pick an assignee.
  * Every line-start @handle group, otherwise the first @handle in prose.
+ * Seats named as a later wave (完成後 / 最後 / 才叫) stay quiet this turn.
  */
 export function summonedHandles(text: string, handles: string[]): string[] {
   const known = new Set(handles.map((handle) => handle.toLowerCase()));
+  const deferred = new Set(deferredHandles(text, handles));
   const take = (names: string[]): string[] => {
     const out: string[] = [];
     for (const name of names) {
       const key = name.toLowerCase();
-      if (!known.has(key) || out.includes(key)) continue;
+      if (!known.has(key) || deferred.has(key) || out.includes(key)) continue;
       out.push(key);
     }
     return out;
@@ -93,7 +186,8 @@ export function summonedHandles(text: string, handles: string[]): string[] {
     const out: string[] = [];
     for (const block of blocks) {
       for (const handle of block.handles) {
-        if (!out.includes(handle)) out.push(handle);
+        if (deferred.has(handle) || out.includes(handle)) continue;
+        out.push(handle);
       }
     }
     return out;
@@ -104,6 +198,85 @@ export function summonedHandles(text: string, handles: string[]): string[] {
   return [];
 }
 
+/**
+ * Bot replies: line-start specs, else first prose @handle, plus assignment verbs
+ * even when the handle is wrapped in backticks (models quote @infra a lot).
+ * Fixture chatter like `(@pm / @rd)` has no verb, so it does not hop.
+ */
+const HANDOFF_ASK =
+  /(?:(?:再叫|交給|交棒(?:給)?|指派)\s*|(?:call|ask|ping|notify|handoff(?:\s+to)?)\s+)`?@([A-Za-z0-9_-]+)`?/gi;
+
+export function handoffHandles(text: string, handles: string[]): string[] {
+  const known = new Set(handles.map((handle) => handle.toLowerCase()));
+  const deferred = new Set(deferredHandles(text, handles));
+  const out = summonedHandles(text, handles);
+  const ask = new RegExp(HANDOFF_ASK.source, "gi");
+  for (const row of stripFences(text).matchAll(ask)) {
+    const key = row[1].toLowerCase();
+    if (!known.has(key) || deferred.has(key) || out.includes(key)) continue;
+    out.push(key);
+  }
+  return out;
+}
+
+export function sanitizeMentionIds(
+  raw: unknown,
+  bots: MentionBot[],
+): string[] {
+  if (!Array.isArray(raw)) return [];
+  const known = new Set(bots.map((bot) => bot.id));
+  const out: string[] = [];
+  for (const item of raw) {
+    if (typeof item !== "string") continue;
+    const id = item.trim();
+    if (!id || !known.has(id) || out.includes(id)) continue;
+    out.push(id);
+  }
+  return out;
+}
+
+export function parseMentionIds(
+  text: string,
+  bots: MentionBot[],
+  kind: "user" | "bot",
+): string[] {
+  if (isBroadcastMention(text)) return [];
+  const handles = bots.map((bot) => bot.handle);
+  const names =
+    kind === "bot" ? handoffHandles(text, handles) : summonedHandles(text, handles);
+  const out: string[] = [];
+  for (const name of names) {
+    const bot = bots.find(
+      (row) => row.handle.toLowerCase() === name.toLowerCase(),
+    );
+    if (!bot || out.includes(bot.id)) continue;
+    out.push(bot.id);
+  }
+  return withoutDeferredIds(out, text, bots);
+}
+
+/**
+ * Prefer the stored mention list. Older rows without the field still parse the body.
+ * An empty stored list means nobody.
+ */
+export function messageMentionIds(
+  message: { author: string; body: string; mentions?: string[] },
+  bots: MentionBot[],
+): string[] {
+  const ids = Array.isArray(message.mentions)
+    ? sanitizeMentionIds(message.mentions, bots)
+    : parseMentionIds(
+        message.body,
+        bots,
+        message.author === "you" ? "user" : "bot",
+      );
+  return withoutDeferredIds(
+    ids.filter((id) => id !== message.author),
+    message.body,
+    bots,
+  );
+}
+
 /**
  * Spec for one seat: shared preamble plus that @handle's line-start block.
  * Full text when the handle was only summoned in prose.
@@ -119,6 +292,8 @@ export function assignmentFor(
   if (!key || !blocks.length) return raw;
   const mine = blocks.filter((block) => block.handles.includes(key));
   if (!mine.length) return raw;
+  // Numbered plans share constraints ("don't ship until PM signs off"). Slice only classic specs.
+  if (!blocks.some((block) => block.kind === "lead")) return raw;
   const preamble = raw.slice(0, blocks[0].start).trim();
   const chunks = mine.map((block) => raw.slice(block.start, block.end).trim());
   return [preamble, ...chunks].filter(Boolean).join("\n\n");

package/src/oauth.ts

@@ -1057,6 +1057,109 @@ function thinkingText(message: AssistantMessage | undefined): string {
     .trim();
 }
 
+/**
+ * Codex `DEFAULT_STREAM_IDLE_TIMEOUT_MS`. No tokens on the stream — not a
+ * wall clock on the whole turn. Do not pass this as Pi `timeoutMs` for xAI:
+ * OpenAI-completions maps that to the SDK request timeout and kills thinking.
+ */
+export const STREAM_IDLE_TIMEOUT_MS = 300_000;
+
+export function isTransientLlmError(err: unknown): boolean {
+  if (err instanceof StreamIdleError) return false;
+  const text = err instanceof Error ? `${err.name} ${err.message}` : String(err);
+  return /econnreset|econnrefused|etimedout|enotfound|eai_again|fetch failed|socket|network|empty reply|429|502|503|504|5\d\d/i.test(
+    text,
+  );
+}
+
+export async function withTransientRetries<T>(
+  run: () => Promise<T>,
+  opts: {
+    signal?: AbortSignal;
+    attempts?: number;
+    onRetry?: (attempt: number, err: unknown) => void;
+  } = {},
+): Promise<T> {
+  const attempts = opts.attempts ?? 3;
+  let last: unknown;
+  for (let i = 0; i < attempts; i++) {
+    if (opts.signal?.aborted) {
+      throw userAborted(opts.signal);
+    }
+    try {
+      return await run();
+    } catch (err) {
+      last = err;
+      if (err instanceof Error && err.name === "AbortError") throw err;
+      if (opts.signal?.aborted) throw err;
+      if (!isTransientLlmError(err) || i === attempts - 1) throw err;
+      opts.onRetry?.(i + 1, err);
+      await new Promise((resolve) => setTimeout(resolve, 400 * (i + 1)));
+    }
+  }
+  throw last instanceof Error ? last : new Error(String(last));
+}
+
+export class StreamIdleError extends Error {
+  readonly idleMs: number;
+  constructor(idleMs: number) {
+    super(
+      `stream idle: no tokens for ${Math.round(idleMs / 1000)}s (Codex-style; not a turn wall clock). Resend or switch models.`,
+    );
+    this.name = "StreamIdleError";
+    this.idleMs = idleMs;
+  }
+}
+
+export function startStreamIdle(
+  idleMs: number,
+  parent?: AbortSignal,
+): {
+  signal: AbortSignal;
+  bump: () => void;
+  dispose: () => void;
+  timedOut: () => boolean;
+} {
+  const ctrl = new AbortController();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let timedOut = false;
+  const fire = () => {
+    if (timedOut || ctrl.signal.aborted) return;
+    timedOut = true;
+    ctrl.abort();
+  };
+  const bump = () => {
+    if (timedOut || parent?.aborted) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fire, idleMs);
+  };
+  const onParent = () => {
+    if (timer) clearTimeout(timer);
+    ctrl.abort();
+  };
+  if (parent?.aborted) {
+    ctrl.abort();
+  } else {
+    parent?.addEventListener("abort", onParent, { once: true });
+  }
+  bump();
+  return {
+    signal: ctrl.signal,
+    bump,
+    dispose: () => {
+      if (timer) clearTimeout(timer);
+      parent?.removeEventListener("abort", onParent);
+    },
+    timedOut: () => timedOut,
+  };
+}
+
+function userAborted(signal?: AbortSignal): Error {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+
 /** Pi streamSimple: Think chips only from thinking_delta, not a planted placeholder. */
 async function streamOAuthMessage(
   models: MutableModels,
@@ -1066,7 +1169,11 @@ async function streamOAuthMessage(
   toolCtx: ToolContext,
   traces: ToolTrace[],
 ): Promise<AssistantMessage> {
-  const stream = models.streamSimple(model, context, options);
+  const idle = startStreamIdle(STREAM_IDLE_TIMEOUT_MS, options?.signal);
+  const stream = models.streamSimple(model, context, {
+    ...options,
+    signal: idle.signal,
+  });
   let lastEmit = 0;
   const flush = (partial: AssistantMessage | undefined, force: boolean) => {
     const think = thinkingText(partial);
@@ -1076,19 +1183,40 @@ async function streamOAuthMessage(
     lastEmit = now;
     emitProgress(toolCtx, traces, think);
   };
-  for await (const event of stream) {
-    if (event.type === "thinking_start" || event.type === "thinking_delta") {
-      flush(event.partial, event.type === "thinking_start");
-    } else if (event.type === "thinking_end") {
-      flush(event.partial, true);
-    } else if (event.type === "done") {
-      flush(event.message, true);
-      return event.message;
-    } else if (event.type === "error") {
-      return event.error;
+  const failIfIdle = (): never => {
+    if (options?.signal?.aborted) throw userAborted(options.signal);
+    throw new StreamIdleError(STREAM_IDLE_TIMEOUT_MS);
+  };
+  try {
+    for await (const event of stream) {
+      idle.bump();
+      if (event.type === "thinking_start" || event.type === "thinking_delta") {
+        flush(event.partial, event.type === "thinking_start");
+      } else if (event.type === "thinking_end") {
+        flush(event.partial, true);
+      } else if (event.type === "done") {
+        flush(event.message, true);
+        return event.message;
+      } else if (event.type === "error") {
+        if (idle.timedOut() || options?.signal?.aborted) failIfIdle();
+        return event.error;
+      }
+    }
+    if (idle.timedOut() || options?.signal?.aborted) failIfIdle();
+    return stream.result();
+  } catch (err) {
+    if (err instanceof StreamIdleError) throw err;
+    if (err instanceof Error && err.name === "AbortError") {
+      if (options?.signal?.aborted) throw err;
+      if (idle.timedOut()) throw new StreamIdleError(STREAM_IDLE_TIMEOUT_MS);
+    }
+    if (idle.timedOut() && !(options?.signal?.aborted)) {
+      throw new StreamIdleError(STREAM_IDLE_TIMEOUT_MS);
     }
+    throw err;
+  } finally {
+    idle.dispose();
   }
-  return stream.result();
 }
 
 function abortWhen(signal?: AbortSignal): Promise<never> {
@@ -1114,7 +1242,7 @@ export async function completeOAuth(input: {
   system: string;
   messages: { role: "user" | "assistant"; content: string }[];
   temperature?: number;
-  reasoning?: "minimal" | "low" | "medium" | "high";
+  reasoning?: string;
   tools?: boolean;
   skills?: SkillRef[];
   toolCtx?: ToolContext;
@@ -1173,7 +1301,7 @@ export async function completeOAuth(input: {
   });
   const options: {
     temperature?: number;
-    reasoning?: "minimal" | "low" | "medium" | "high";
+    reasoning?: string;
     signal?: AbortSignal;
     transformHeaders?: (
       headers: Record<string, string | null>,
@@ -1252,21 +1380,70 @@ export async function completeOAuth(input: {
       if (fitted.length < transcript.length) {
         transcript.splice(0, transcript.length, ...fitted);
       }
-      const result = await Promise.race([
-        streamOAuthMessage(
-          models,
-          model,
+      let result: AssistantMessage;
+      try {
+        result = await withTransientRetries(
+          async () => {
+            const got = await Promise.race([
+              streamOAuthMessage(
+                models,
+                model,
+                {
+                  systemPrompt: input.system,
+                  messages: transcript,
+                  ...(useTools ? { tools } : {}),
+                },
+                options,
+                toolCtx,
+                traces,
+              ),
+              abortWhen(options.signal),
+            ]);
+            if (got.stopReason === "aborted") {
+              const err = new Error("aborted");
+              err.name = "AbortError";
+              throw err;
+            }
+            if (got.stopReason === "error") {
+              throw new Error(
+                formatOAuthError(sub.id, got.errorMessage) ||
+                  `${sub.id} request failed`,
+              );
+            }
+            const text = contentText(got.content).trim();
+            const toolCalls =
+              got.stopReason === "toolUse"
+                ? got.content.filter(
+                    (part): part is Extract<typeof part, { type: "toolCall" }> =>
+                      part.type === "toolCall",
+                  )
+                : [];
+            if (!toolCalls.length && !text && traces.length === 0) {
+              throw new Error(`${sub.id} returned an empty reply`);
+            }
+            return got;
+          },
           {
-            systemPrompt: input.system,
-            messages: transcript,
-            ...(useTools ? { tools } : {}),
+            signal: options.signal,
+            onRetry: () => {
+              emitProgress(
+                toolCtx,
+                traces,
+                thinkingChunks.join("\n\n") || "連線中斷，重試中…",
+              );
+            },
           },
-          options,
-          toolCtx,
-          traces,
-        ),
-        abortWhen(options.signal),
-      ]);
+        );
+      } catch (err) {
+        if (err instanceof StreamIdleError) {
+          return {
+            calls: [],
+            text: err.message,
+            thinking: thinkingChunks.join("\n\n"),
+          };
+        }
+        throw err;
+      }
       if (result.stopReason === "aborted" || toolCtx.signal?.aborted || options.signal?.aborted) {
         const err = new Error("aborted");
         err.name = "AbortError";