minimal-agent 0.18.9 → 0.18.11

package/src/loop/requestPreparation.js

@@ -0,0 +1,180 @@
+import { buildContextBudgetPlan, fitToolsForEmergency } from '../context/budgetPlan.js';
+import { autoCompactIfNeeded, shouldAutoCompact } from '../context/compact.js';
+import { snipCompactIfNeeded } from '../context/snipCompact.js';
+import { countMessagesTokens, countTextTokens, estimateToolsTokens } from '../context/tokenCounter.js';
+import { createEffectiveToolSet } from '../tools/effectiveToolSet.js';
+/** Request-local degradation; never owns the accumulated turn resource ledger. */
+export async function* prepareModelRequest(input) {
+    const { history, provider, activeTools, effectiveToolSet, runtimeContext, sessionState, signal, lastPromptTokens, cacheEditsMode, options, chatFn, replaceHistory, buildRequestTransientContext, } = input;
+    // 2. 自动压缩（判据 = max(上一轮真实 usage, 历史估算 + 工具 schema)，
+    //    阈值 provider 无关、按 contextWindow × compactRatio 比例触发）
+    let currentEffectiveToolSet = effectiveToolSet;
+    let requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+    const preCompactBudget = buildContextBudgetPlan({
+        provider,
+        history,
+        tools: activeTools,
+        transientContext: requestTransientContext,
+    });
+    if (preCompactBudget.overBudget || lastPromptTokens !== undefined) {
+        try {
+            const compactOptions = {
+                actualPromptTokens: lastPromptTokens,
+                toolsTokens: estimateToolsTokens(activeTools),
+                transientTokens: countTextTokens(requestTransientContext),
+                // cacheEdits 判据校正：本地 history 未瘦身，扣掉服务端已删部分的估算，
+                // 防止虚高估算劫持 Math.max 导致压缩过早触发（压缩会重建整个前缀缓存）。
+                ...(cacheEditsMode && sessionState?.microCompact
+                    ? {
+                        serverDeletedTokens: sessionState.microCompact.cacheEdits.activeDeletedTokens,
+                    }
+                    : {}),
+                signal,
+                promptCache: options.promptCache,
+                chat: chatFn,
+            };
+            if (shouldAutoCompact(history, provider, compactOptions)) {
+                yield { type: 'compact_start' };
+                yield { type: 'stage_change', stage: 'compacting' };
+            }
+            const compact = await autoCompactIfNeeded(history, provider, compactOptions);
+            if (compact.compacted) {
+                replaceHistory(compact.messages);
+                yield {
+                    type: 'compact_done',
+                    before: compact.before,
+                    after: compact.after,
+                    trigger: 'threshold',
+                    mode: compact.mode,
+                    degraded: compact.degraded,
+                    ...(compact.fallbackReason ? { fallbackReason: compact.fallbackReason } : {}),
+                    ...(compact.messagesRemoved !== undefined ? { messagesRemoved: compact.messagesRemoved } : {}),
+                    ...(compact.tokensFreed !== undefined ? { tokensFreed: compact.tokensFreed } : {}),
+                };
+                yield { type: 'stage_change', stage: 'thinking' };
+            }
+        }
+        catch (e) {
+            if (signal?.aborted || e.name === 'AbortError') {
+                return { kind: 'interrupted' };
+            }
+            // 压缩失败不要让整个对话挂掉：先 snip 砍最老消息释放空间再继续。
+            let recovered = false;
+            try {
+                const before = countMessagesTokens(history);
+                const snipped = snipCompactIfNeeded(history, {
+                    force: true,
+                    snipPercent: 0.3,
+                });
+                if (snipped.messagesRemoved > 0) {
+                    replaceHistory(snipped.messages);
+                    recovered = true;
+                    yield {
+                        type: 'compact_done',
+                        before,
+                        after: countMessagesTokens(history),
+                        trigger: 'threshold',
+                        mode: 'snip-fallback',
+                        degraded: true,
+                        fallbackReason: 'llm-error',
+                        messagesRemoved: snipped.messagesRemoved,
+                        tokensFreed: snipped.tokensFreed,
+                    };
+                }
+            }
+            catch {
+                /* snip 也失败 → 真的只能硬上 */
+            }
+            if (!recovered) {
+                // 事件是 provider 原始报错唯一该去的地方：只到 stderr / UI，不进 history、
+                // 不落盘、不会在后续轮次重新发给模型（compact.ts 里那条降级消息因此保持无错误体）。
+                yield {
+                    type: 'error',
+                    error: `自动压缩失败，规则式截断也未能释放空间；已继续尝试回答：${e.message}`,
+                    code: 'compact_failed',
+                };
+            }
+        }
+    }
+    // Re-open transient capacity after compaction. If the compacted tail is still
+    // too large, trim old history before sacrificing any model-visible ability.
+    requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+    let postCompactBudget = buildContextBudgetPlan({
+        provider,
+        history,
+        tools: activeTools,
+        transientContext: requestTransientContext,
+    });
+    if (postCompactBudget.overBudget) {
+        const before = countMessagesTokens(history);
+        const snipped = snipCompactIfNeeded(history, {
+            force: true,
+            snipPercent: 0.3,
+        });
+        if (snipped.messagesRemoved > 0) {
+            replaceHistory(snipped.messages);
+            yield {
+                type: 'compact_done',
+                before,
+                after: countMessagesTokens(history),
+                trigger: 'post-budget',
+                mode: 'snip-fallback',
+                degraded: true,
+                fallbackReason: 'still-over-budget',
+                messagesRemoved: snipped.messagesRemoved,
+                tokensFreed: snipped.tokensFreed,
+            };
+            requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+            postCompactBudget = buildContextBudgetPlan({
+                provider,
+                history,
+                tools: activeTools,
+                transientContext: requestTransientContext,
+            });
+        }
+    }
+    const emergencyFit = fitToolsForEmergency({
+        provider,
+        history,
+        tools: activeTools,
+        transientContext: requestTransientContext,
+        requiredNames: effectiveToolSet.requiredNames,
+    });
+    currentEffectiveToolSet =
+        emergencyFit.removedNames.length === 0
+            ? effectiveToolSet
+            : createEffectiveToolSet({
+                availableTools: emergencyFit.tools,
+                runtime: runtimeContext,
+                requiredNames: [...effectiveToolSet.requiredNames],
+            });
+    // Tool availability may change during emergency fitting. Rebuild dynamic
+    // guidance against the actual request boundary, then account for its size.
+    requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+    const finalRequestBudget = buildContextBudgetPlan({
+        provider,
+        history,
+        tools: currentEffectiveToolSet.tools,
+        transientContext: requestTransientContext,
+    });
+    if (emergencyFit.removedNames.length > 0) {
+        yield {
+            type: 'warning',
+            message: `当前模型窗口压力过高，本次请求临时省略工具 Schema：${emergencyFit.removedNames.join(', ')}；下一轮会重新评估并恢复。`,
+        };
+    }
+    if (finalRequestBudget.overBudget) {
+        yield {
+            type: 'error',
+            error: `当前请求即使经过上下文降级仍需要约 ${finalRequestBudget.totalInputTokens} tokens，超过模型输入上限 ${finalRequestBudget.inputLimit}。已停止发送，避免 Provider 接收必然失败的超限请求。`,
+            code: 'context_overflow',
+        };
+        return { kind: 'overflow', requestTransientContext };
+    }
+    return {
+        kind: 'ready',
+        requestTransientContext,
+        currentEffectiveToolSet,
+        remainingTokens: finalRequestBudget.inputLimit - finalRequestBudget.totalInputTokens,
+    };
+}

package/src/loop/requestPreparation.ts

@@ -0,0 +1,226 @@
+import { buildContextBudgetPlan, fitToolsForEmergency } from '../context/budgetPlan.js';
+import { autoCompactIfNeeded, shouldAutoCompact } from '../context/compact.js';
+import { snipCompactIfNeeded } from '../context/snipCompact.js';
+import { countMessagesTokens, countTextTokens, estimateToolsTokens } from '../context/tokenCounter.js';
+import type { AgentRuntimeContext } from '../runtime/agentRuntimeContext.js';
+import type { SessionState } from '../session/sessionState.js';
+import { createEffectiveToolSet, type EffectiveToolSet } from '../tools/effectiveToolSet.js';
+import type { LoopEvent, Message, Provider, Tool } from '../types.js';
+import type { RunQueryOptions } from './options.js';
+
+/** Request-local degradation; never owns the accumulated turn resource ledger. */
+export async function* prepareModelRequest(input: {
+  history: Message[];
+  provider: Provider;
+  activeTools: Tool[];
+  effectiveToolSet: EffectiveToolSet;
+  runtimeContext: AgentRuntimeContext;
+  sessionState?: SessionState;
+  signal?: AbortSignal;
+  lastPromptTokens?: number;
+  cacheEditsMode: boolean;
+  options: Pick<RunQueryOptions, 'promptCache'>;
+  chatFn: NonNullable<RunQueryOptions['chat']>;
+  replaceHistory: (messages: Message[]) => void;
+  buildRequestTransientContext: (tools: EffectiveToolSet) => string;
+}): AsyncGenerator<
+  LoopEvent,
+  | {
+      kind: 'ready';
+      requestTransientContext: string;
+      currentEffectiveToolSet: EffectiveToolSet;
+      remainingTokens: number;
+    }
+  | { kind: 'interrupted' }
+  | { kind: 'overflow'; requestTransientContext: string }
+> {
+  const {
+    history,
+    provider,
+    activeTools,
+    effectiveToolSet,
+    runtimeContext,
+    sessionState,
+    signal,
+    lastPromptTokens,
+    cacheEditsMode,
+    options,
+    chatFn,
+    replaceHistory,
+    buildRequestTransientContext,
+  } = input;
+  // 2. 自动压缩（判据 = max(上一轮真实 usage, 历史估算 + 工具 schema)，
+  //    阈值 provider 无关、按 contextWindow × compactRatio 比例触发）
+  let currentEffectiveToolSet = effectiveToolSet;
+  let requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+  const preCompactBudget = buildContextBudgetPlan({
+    provider,
+    history,
+    tools: activeTools,
+    transientContext: requestTransientContext,
+  });
+  if (preCompactBudget.overBudget || lastPromptTokens !== undefined) {
+    try {
+      const compactOptions = {
+        actualPromptTokens: lastPromptTokens,
+        toolsTokens: estimateToolsTokens(activeTools),
+        transientTokens: countTextTokens(requestTransientContext),
+        // cacheEdits 判据校正：本地 history 未瘦身，扣掉服务端已删部分的估算，
+        // 防止虚高估算劫持 Math.max 导致压缩过早触发（压缩会重建整个前缀缓存）。
+        ...(cacheEditsMode && sessionState?.microCompact
+          ? {
+              serverDeletedTokens: sessionState.microCompact.cacheEdits.activeDeletedTokens,
+            }
+          : {}),
+        signal,
+        promptCache: options.promptCache,
+        chat: chatFn,
+      };
+      if (shouldAutoCompact(history, provider, compactOptions)) {
+        yield { type: 'compact_start' };
+        yield { type: 'stage_change', stage: 'compacting' };
+      }
+      const compact = await autoCompactIfNeeded(history, provider, compactOptions);
+      if (compact.compacted) {
+        replaceHistory(compact.messages);
+        yield {
+          type: 'compact_done',
+          before: compact.before,
+          after: compact.after,
+          trigger: 'threshold',
+          mode: compact.mode,
+          degraded: compact.degraded,
+          ...(compact.fallbackReason ? { fallbackReason: compact.fallbackReason } : {}),
+          ...(compact.messagesRemoved !== undefined ? { messagesRemoved: compact.messagesRemoved } : {}),
+          ...(compact.tokensFreed !== undefined ? { tokensFreed: compact.tokensFreed } : {}),
+        };
+        yield { type: 'stage_change', stage: 'thinking' };
+      }
+    } catch (e) {
+      if (signal?.aborted || (e as Error).name === 'AbortError') {
+        return { kind: 'interrupted' as const };
+      }
+      // 压缩失败不要让整个对话挂掉：先 snip 砍最老消息释放空间再继续。
+      let recovered = false;
+      try {
+        const before = countMessagesTokens(history);
+        const snipped = snipCompactIfNeeded(history, {
+          force: true,
+          snipPercent: 0.3,
+        });
+        if (snipped.messagesRemoved > 0) {
+          replaceHistory(snipped.messages);
+          recovered = true;
+          yield {
+            type: 'compact_done',
+            before,
+            after: countMessagesTokens(history),
+            trigger: 'threshold',
+            mode: 'snip-fallback',
+            degraded: true,
+            fallbackReason: 'llm-error',
+            messagesRemoved: snipped.messagesRemoved,
+            tokensFreed: snipped.tokensFreed,
+          };
+        }
+      } catch {
+        /* snip 也失败 → 真的只能硬上 */
+      }
+      if (!recovered) {
+        // 事件是 provider 原始报错唯一该去的地方：只到 stderr / UI，不进 history、
+        // 不落盘、不会在后续轮次重新发给模型（compact.ts 里那条降级消息因此保持无错误体）。
+        yield {
+          type: 'error',
+          error: `自动压缩失败，规则式截断也未能释放空间；已继续尝试回答：${(e as Error).message}`,
+          code: 'compact_failed',
+        };
+      }
+    }
+  }
+
+  // Re-open transient capacity after compaction. If the compacted tail is still
+  // too large, trim old history before sacrificing any model-visible ability.
+  requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+  let postCompactBudget = buildContextBudgetPlan({
+    provider,
+    history,
+    tools: activeTools,
+    transientContext: requestTransientContext,
+  });
+  if (postCompactBudget.overBudget) {
+    const before = countMessagesTokens(history);
+    const snipped = snipCompactIfNeeded(history, {
+      force: true,
+      snipPercent: 0.3,
+    });
+    if (snipped.messagesRemoved > 0) {
+      replaceHistory(snipped.messages);
+      yield {
+        type: 'compact_done',
+        before,
+        after: countMessagesTokens(history),
+        trigger: 'post-budget',
+        mode: 'snip-fallback',
+        degraded: true,
+        fallbackReason: 'still-over-budget',
+        messagesRemoved: snipped.messagesRemoved,
+        tokensFreed: snipped.tokensFreed,
+      };
+      requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+      postCompactBudget = buildContextBudgetPlan({
+        provider,
+        history,
+        tools: activeTools,
+        transientContext: requestTransientContext,
+      });
+    }
+  }
+
+  const emergencyFit = fitToolsForEmergency({
+    provider,
+    history,
+    tools: activeTools,
+    transientContext: requestTransientContext,
+    requiredNames: effectiveToolSet.requiredNames,
+  });
+  currentEffectiveToolSet =
+    emergencyFit.removedNames.length === 0
+      ? effectiveToolSet
+      : createEffectiveToolSet({
+          availableTools: emergencyFit.tools,
+          runtime: runtimeContext,
+          requiredNames: [...effectiveToolSet.requiredNames],
+        });
+
+  // Tool availability may change during emergency fitting. Rebuild dynamic
+  // guidance against the actual request boundary, then account for its size.
+  requestTransientContext = buildRequestTransientContext(currentEffectiveToolSet);
+  const finalRequestBudget = buildContextBudgetPlan({
+    provider,
+    history,
+    tools: currentEffectiveToolSet.tools,
+    transientContext: requestTransientContext,
+  });
+  if (emergencyFit.removedNames.length > 0) {
+    yield {
+      type: 'warning',
+      message: `当前模型窗口压力过高，本次请求临时省略工具 Schema：${emergencyFit.removedNames.join(', ')}；下一轮会重新评估并恢复。`,
+    };
+  }
+
+  if (finalRequestBudget.overBudget) {
+    yield {
+      type: 'error',
+      error: `当前请求即使经过上下文降级仍需要约 ${finalRequestBudget.totalInputTokens} tokens，超过模型输入上限 ${finalRequestBudget.inputLimit}。已停止发送，避免 Provider 接收必然失败的超限请求。`,
+      code: 'context_overflow',
+    };
+    return { kind: 'overflow' as const, requestTransientContext };
+  }
+
+  return {
+    kind: 'ready',
+    requestTransientContext,
+    currentEffectiveToolSet,
+    remainingTokens: finalRequestBudget.inputLimit - finalRequestBudget.totalInputTokens,
+  };
+}

package/src/loop/toolBatch.js

@@ -0,0 +1,99 @@
+import { progressStream } from './progressStream.js';
+import { getToolByName } from '../tools/index.js';
+import { executionSegments } from '../tools/executionSegments.js';
+import { orderedPool } from '../runtime/orderedPool.js';
+import { conciseToolPath } from '../runtime/toolDisplay.js';
+import { previewArgs, friendlyToolDescription } from './toolPresentation.js';
+/** Live events follow completion order; history commits follow request order. */
+export async function* executeToolBatch(input) {
+    const { toolCallsByIndex, currentEffectiveToolSet, options, runOne, commitOutcome } = input;
+    const startEvent = (tc) => ({
+        type: 'tool_start',
+        toolCallId: tc.id,
+        toolName: tc.function.name,
+        argsPreview: previewArgs(tc.function.arguments),
+        argsFriendly: friendlyToolDescription(tc.function.name, tc.function.arguments),
+        argsConcise: friendlyToolDescription(tc.function.name, tc.function.arguments, conciseToolPath),
+    });
+    const endEvent = (o) => ({
+        type: 'tool_end',
+        toolCallId: o.tc.id,
+        toolName: o.tc.function.name,
+        ok: o.result.ok,
+        content: o.result.ok ? o.result.content : o.result.error === 'aborted' ? '(已中断)' : `Error: ${o.result.error}`,
+        metadata: o.result.metadata,
+    });
+    const segments = executionSegments(toolCallsByIndex, (tc) => {
+        const tool = currentEffectiveToolSet.tools.find((tool) => tool.name === tc.function.name);
+        return (![
+            'AskUserQuestion',
+            'Advisor',
+            'AdvisorDecision',
+            'OptimizeConversation',
+            'AgentReport',
+            'AgentResolve',
+        ].includes(tc.function.name) &&
+            (tool?.isConcurrencySafe ?? getToolByName(tc.function.name)?.isConcurrencySafe) === true);
+    });
+    const settled = [];
+    let questionEncountered = false;
+    let advisorEncountered = false;
+    for (const segment of segments) {
+        if (!questionEncountered && !advisorEncountered && segment.length > 1) {
+            // Only concurrency-safe segments run together; hosts may bound throughput.
+            const outcomes = yield* progressStream((enqueue) => orderedPool(segment, options.toolConcurrency ?? segment.length, async (tc) => {
+                enqueue(startEvent(tc));
+                const o = await runOne(tc, (message, detail) => enqueue({
+                    type: 'tool_progress',
+                    toolCallId: tc.id,
+                    toolName: tc.function.name,
+                    message,
+                    detail,
+                }));
+                enqueue(endEvent(o));
+                return o;
+            }));
+            settled.push(...outcomes);
+            for (const outcome of outcomes)
+                yield* commitOutcome(outcome);
+        }
+        else {
+            // —— 串行：逐个执行（含写类工具，或只有一个工具）。保持实时进度，完成后才提交历史。
+            for (const tc of segment) {
+                if (questionEncountered || advisorEncountered) {
+                    const outcome = {
+                        tc,
+                        result: {
+                            ok: false,
+                            disposition: 'deferred',
+                            error: questionEncountered
+                                ? '此调用在用户回答前已生成，尚未执行。请先阅读提问结果并重新规划；仅在仍必要时重新调用。'
+                                : '此调用在顾问返回前已生成，尚未执行。请先阅读顾问结果，自主决定采纳、部分采纳或拒绝，再重新生成必要的工具调用。咨询失败则自行判断继续，不必重复咨询。',
+                        },
+                    };
+                    yield startEvent(tc);
+                    yield endEvent(outcome);
+                    settled.push(outcome);
+                    yield* commitOutcome(outcome);
+                    continue;
+                }
+                questionEncountered = tc.function.name === 'AskUserQuestion';
+                yield startEvent(tc);
+                const o = yield* progressStream((emit) => runOne(tc, (message, detail) => emit({
+                    type: 'tool_progress',
+                    toolCallId: tc.id,
+                    toolName: tc.function.name,
+                    message,
+                    detail,
+                })));
+                // Every later call was planned without this second opinion, including
+                // decision records and further consultations. Return control to the LLM.
+                advisorEncountered = tc.function.name === 'Advisor';
+                yield endEvent(o);
+                settled.push(o);
+                yield* commitOutcome(o);
+            }
+        }
+    }
+    return settled;
+}

package/src/loop/toolBatch.ts

@@ -0,0 +1,123 @@
+import { progressStream } from './progressStream.js';
+import type { LoopEvent, ToolCall } from '../types.js';
+import type { RunQueryOptions } from './options.js';
+import type { EffectiveToolSet } from '../tools/effectiveToolSet.js';
+import { getToolByName } from '../tools/index.js';
+import { executionSegments } from '../tools/executionSegments.js';
+import { orderedPool } from '../runtime/orderedPool.js';
+import { conciseToolPath } from '../runtime/toolDisplay.js';
+import { previewArgs, friendlyToolDescription } from './toolPresentation.js';
+import type { createToolExecutor, WorkerOutcome } from './toolExecutor.js';
+
+/** Live events follow completion order; history commits follow request order. */
+export async function* executeToolBatch(input: {
+  toolCallsByIndex: ToolCall[];
+  currentEffectiveToolSet: EffectiveToolSet;
+  options: Pick<RunQueryOptions, 'toolConcurrency'>;
+  runOne: ReturnType<typeof createToolExecutor>['runOne'];
+  commitOutcome: (outcome: WorkerOutcome) => AsyncGenerator<LoopEvent>;
+}): AsyncGenerator<LoopEvent, WorkerOutcome[]> {
+  const { toolCallsByIndex, currentEffectiveToolSet, options, runOne, commitOutcome } = input;
+  const startEvent = (tc: ToolCall): Extract<LoopEvent, { type: 'tool_start' }> => ({
+    type: 'tool_start',
+    toolCallId: tc.id,
+    toolName: tc.function.name,
+    argsPreview: previewArgs(tc.function.arguments),
+    argsFriendly: friendlyToolDescription(tc.function.name, tc.function.arguments),
+    argsConcise: friendlyToolDescription(tc.function.name, tc.function.arguments, conciseToolPath),
+  });
+  const endEvent = (o: WorkerOutcome): Extract<LoopEvent, { type: 'tool_end' }> => ({
+    type: 'tool_end',
+    toolCallId: o.tc.id,
+    toolName: o.tc.function.name,
+    ok: o.result.ok,
+    content: o.result.ok ? o.result.content : o.result.error === 'aborted' ? '(已中断)' : `Error: ${o.result.error}`,
+    metadata: o.result.metadata,
+  });
+
+  const segments = executionSegments(toolCallsByIndex, (tc) => {
+    const tool = currentEffectiveToolSet.tools.find((tool) => tool.name === tc.function.name);
+    return (
+      ![
+        'AskUserQuestion',
+        'Advisor',
+        'AdvisorDecision',
+        'OptimizeConversation',
+        'AgentReport',
+        'AgentResolve',
+      ].includes(tc.function.name) &&
+      (tool?.isConcurrencySafe ?? getToolByName(tc.function.name)?.isConcurrencySafe) === true
+    );
+  });
+
+  const settled: WorkerOutcome[] = [];
+  let questionEncountered = false;
+  let advisorEncountered = false;
+
+  for (const segment of segments) {
+    if (!questionEncountered && !advisorEncountered && segment.length > 1) {
+      // Only concurrency-safe segments run together; hosts may bound throughput.
+      const outcomes = yield* progressStream<LoopEvent, WorkerOutcome[]>((enqueue) =>
+        orderedPool(segment, options.toolConcurrency ?? segment.length, async (tc) => {
+          enqueue(startEvent(tc));
+          const o = await runOne(tc, (message, detail) =>
+            enqueue({
+              type: 'tool_progress',
+              toolCallId: tc.id,
+              toolName: tc.function.name,
+              message,
+              detail,
+            }),
+          );
+          enqueue(endEvent(o));
+          return o;
+        }),
+      );
+
+      settled.push(...outcomes);
+      for (const outcome of outcomes) yield* commitOutcome(outcome);
+    } else {
+      // —— 串行：逐个执行（含写类工具，或只有一个工具）。保持实时进度，完成后才提交历史。
+      for (const tc of segment) {
+        if (questionEncountered || advisorEncountered) {
+          const outcome = {
+            tc,
+            result: {
+              ok: false as const,
+              disposition: 'deferred' as const,
+              error: questionEncountered
+                ? '此调用在用户回答前已生成，尚未执行。请先阅读提问结果并重新规划；仅在仍必要时重新调用。'
+                : '此调用在顾问返回前已生成，尚未执行。请先阅读顾问结果，自主决定采纳、部分采纳或拒绝，再重新生成必要的工具调用。咨询失败则自行判断继续，不必重复咨询。',
+            },
+          };
+          yield startEvent(tc);
+          yield endEvent(outcome);
+          settled.push(outcome);
+          yield* commitOutcome(outcome);
+          continue;
+        }
+        questionEncountered = tc.function.name === 'AskUserQuestion';
+        yield startEvent(tc);
+        const o = yield* progressStream<LoopEvent, WorkerOutcome>((emit) =>
+          runOne(tc, (message, detail) =>
+            emit({
+              type: 'tool_progress',
+              toolCallId: tc.id,
+              toolName: tc.function.name,
+              message,
+              detail,
+            }),
+          ),
+        );
+        // Every later call was planned without this second opinion, including
+        // decision records and further consultations. Return control to the LLM.
+        advisorEncountered = tc.function.name === 'Advisor';
+        yield endEvent(o);
+        settled.push(o);
+        yield* commitOutcome(o);
+      }
+    }
+  }
+
+  return settled;
+}