@keyou007/agent-bot 0.1.24-alpha.7 → 0.1.24

package/src/feishu/FeishuConnector.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import type { Logger } from "pino";
 import type { WSClient as LarkWsClient, WSConnectionStatus } from "@larksuiteoapi/node-sdk";
 import type { AppConfig } from "../config/schema.js";
@@ -395,7 +396,7 @@ function toCardAction(data: unknown) {
   const openId = event.operator?.open_id ?? event.operator?.user_id;
   const chatId = event.context?.open_chat_id ?? event.chat_id;
   return {
-    actionId: getEventId(data) ?? event.action.action_id ?? event.action.name ?? `${Date.now()}`,
+    actionId: getEventId(data) ?? event.action.action_id ?? randomUUID(),
     contextKey: chatId ? `chat_id:${chatId}` : `open_id:${openId}`,
     userId: openId,
     ...(typeof event.context?.open_message_id === "string" ? { messageId: event.context.open_message_id } : {}),
@@ -415,8 +416,11 @@ function getCardActionValue(action: Record<string, unknown>): Record<string, unk
 }
 
 function getEventId(data: unknown): string | undefined {
-  const value = getNested<unknown>(data, ["header", "event_id"]) ?? getNested(data, ["data", "header", "event_id"]);
-  return typeof value === "string" ? value : undefined;
+  // The SDK flattens header fields into the event passed to handlers.
+  const value = getNested<unknown>(data, ["header", "event_id"])
+    ?? getNested(data, ["data", "header", "event_id"])
+    ?? getNested(data, ["event_id"]);
+  return typeof value === "string" && value ? value : undefined;
 }
 
 function getFeishuEvent(data: unknown): Record<string, any> | undefined {

package/src/local-files/TurnPreviewPage.ts

@@ -8,6 +8,8 @@ import type { ApprovalRequest, ToolState } from "../runtime/types.js";
 import type { FileSummary, TurnActivity, TurnReasoningItem, TurnViewState, TurnViewStatus } from "../presentation/turnViewTypes.js";
 import { displayFilePath, displayToolCommand, formatShellCommandForDisplay, toolStatusIcon } from "../feishu/CardRenderer.js";
 import { turnReasoningItems } from "../presentation/turnReasoning.js";
+import { visibleTurnActivities } from "../presentation/visibleTurnActivities.js";
+import { displayRuntimeError } from "../runtime/responseErrors.js";
 import { isFileUrl, rewriteMarkdownFileLinks } from "./MarkdownFileLinks.js";
 
 const MARKDOWN = new MarkdownIt({
@@ -285,6 +287,10 @@ export const TURN_PREVIEW_CLIENT_SCRIPT = DIAGRAM_PREVIEW_CLIENT_SCRIPT + `(() =
   };
   const compatible = (current, next) => current.nodeType === next.nodeType && current.nodeName === next.nodeName;
   const patchNode = (current, next) => {
+    if (!compatible(current, next)) {
+      current.replaceWith(next.cloneNode(true));
+      return;
+    }
     // Summary snapshots never own a detail body that has already been fetched.
     if (current.nodeType === 1 && current.hasAttribute("data-detail-body") && next.hasAttribute("data-detail-body")) return;
     if (current.isEqualNode(next)) return;
@@ -620,16 +626,19 @@ export function renderTurnPreviewPatch(
   state: TurnViewState, changed: Set<string>, removed: Set<string>,
   localFileUrl: (filePath: string) => string | undefined, language: TurnPreviewLanguage,
 ): TurnPreviewSnapshot & { removed: string[]; before: Record<string, string> } {
+  const visible = visibleTurnActivities(state);
+  const visibleIds = new Set(visible.map((activity) => activity.id));
+  const suppressed = state.activities.filter((activity) => !visibleIds.has(activity.id)).map((activity) => activity.id);
   const partial = { ...state,
-    activities: state.activities.filter((a) => changed.has(a.id)),
+    activities: visible.filter((a) => changed.has(a.id)),
     reasoningItems: state.reasoningItems?.filter((r) => changed.has(`reasoning:${r.itemId}`)),
   };
   const order = [
     ...(state.reasoningItems ?? []).filter((r) => !r.afterActivityId).map((r) => `reasoning:${r.itemId}`),
-    ...state.activities.flatMap((a) => [a.id, ...(state.reasoningItems ?? []).filter((r) => r.afterActivityId === a.id).map((r) => `reasoning:${r.itemId}`)]),
+    ...visible.flatMap((a) => [a.id, ...(state.reasoningItems ?? []).filter((r) => r.afterActivityId === a.id).map((r) => `reasoning:${r.itemId}`)]),
   ];
   const before = Object.fromEntries(order.flatMap((id, i) => changed.has(id) && order[i + 1] ? [[id, order[i + 1]]] : []));
-  return { ...renderTurnPreviewSnapshot(partial, localFileUrl, language, { deferDetails: true }), removed: [...removed], before };
+  return { ...renderTurnPreviewSnapshot(partial, localFileUrl, language, { deferDetails: true }), removed: [...new Set([...removed, ...suppressed])], before };
 }
 
 export function renderTurnPreviewSnapshot(
@@ -645,7 +654,7 @@ export function renderTurnPreviewSnapshot(
     return localFileUrl(path.resolve(state.projectCwd, filePath));
   } : undefined;
   const renderText = (value: string): string => renderMarkdown(value, state.projectCwd, localFileUrl, language);
-  const timeline = renderTimeline(state, renderText, resolveFileUrl, state.fullToolOutputs, state.fullToolErrors, language, state.projectCwd, options.deferDetails);
+  const timeline = renderTimeline({ ...state, activities: visibleTurnActivities(state) }, renderText, resolveFileUrl, state.fullToolOutputs, state.fullToolErrors, language, state.projectCwd, options.deferDetails);
   const terminal = isTerminal(state.status);
   const waitingForProgress = !terminal && !state.finalResponse && !state.assistantText
     && !state.error && !state.approval && state.status !== "waiting_for_approval"
@@ -666,7 +675,7 @@ export function renderTurnPreviewSnapshot(
     `<section class="timeline" data-preview-key="timeline"${timelineContent ? "" : " hidden"}>${timelineContent}</section>`,
     state.fileSummary.length > 0 ? renderFileSummary(state, language, resolveFileUrl, options.deferDetails) : "",
     state.approval ? renderApprovalNotice(state.approval, renderText, language) : "",
-    state.error ? `<section class="result error-result" data-preview-key="error"><h2>${escapeHtml(labels.error)}</h2><pre>${escapeHtml(state.error)}</pre></section>` : "",
+    state.error ? `<section class="result error-result" data-preview-key="error"><h2>${escapeHtml(labels.error)}</h2><pre>${escapeHtml(displayRuntimeError(state.error))}</pre></section>` : "",
     state.finalResponse
       ? renderFinalAnswer(state.finalResponse, state.turnId, renderText, language)
       : state.assistantText
@@ -792,8 +801,12 @@ function renderReasoningItem(
   deferDetails: boolean,
 ): string {
   const presentation = reasoningPresentation(item);
-  if (!presentation.title && !presentation.sections.some((section) => section.parts.length > 0)) return "";
+  const hasBody = presentation.sections.some((section) => section.parts.length > 0);
+  if (!presentation.title && !hasBody) return "";
   const title = presentation.title ?? previewLabels(language).reasoning;
+  if (!hasBody) {
+    return `<article class="reasoning-step" data-activity-id="reasoning:${escapeAttribute(item.itemId)}"><div class="reasoning-header" title="${escapeAttribute(title)}"><span class="reasoning-title">💭 ${escapeHtml(title)}</span></div></article>`;
+  }
   const lazy = deferDetails ? lazyDetailAttributes(`reasoning:${item.itemId}`, reasoningRevision(item, cwd)) : "";
   const body = deferDetails ? lazyDetailBody() : renderReasoningBody(item, cwd, localFileUrl, language, presentation);
   return `<details class="reasoning-step" data-activity-id="reasoning:${escapeAttribute(item.itemId)}"${lazy}><summary class="reasoning-header" title="${escapeAttribute(title)}"><span class="reasoning-title">💭 ${escapeHtml(title)}</span></summary>${body}</details>`;
@@ -831,7 +844,7 @@ function renderActivity(
   switch (activity.kind) {
     case "assistant":
       if (activity.id.startsWith("commentary:runtime-error:")) {
-        return `<article class="activity message runtime-error" data-activity="${escapeAttribute(activity.id)}"><pre>${escapeHtml(activity.text)}</pre></article>`;
+        return `<article class="activity message runtime-error" data-activity="${escapeAttribute(activity.id)}"><pre>${escapeHtml(displayRuntimeError(activity.text))}</pre></article>`;
       }
       return renderMessageActivity(activity.id, activity.text, "commentary", renderText);
     case "user":
@@ -1163,9 +1176,11 @@ export function renderTurnPreviewDetail(
   }
   if (key.startsWith("reasoning:")) {
     const item = turnReasoningItems(state).find((item) => `reasoning:${item.itemId}` === key);
-    if (!item || ![...item.summary, ...item.content].some((text) => text?.trim())) return undefined;
+    if (!item) return undefined;
+    const presentation = reasoningPresentation(item);
+    if (!presentation.sections.some((section) => section.parts.length > 0)) return undefined;
     return { key, revision: reasoningRevision(item, state.projectCwd),
-      content: renderReasoningBody(item, state.projectCwd, localFileUrl, language) };
+      content: renderReasoningBody(item, state.projectCwd, localFileUrl, language, presentation) };
   }
   const activity = state.activities?.find((item) => item.kind === "tool" && `tool:${item.id}` === key);
   if (activity?.kind !== "tool") return undefined;
@@ -1334,7 +1349,7 @@ main { max-width: 1320px; margin: 0 auto; padding: 0 20px 40px; }
 .markdown > :first-child { margin-top: 0; }
 .markdown > :last-child { margin-bottom: 0; }
 .reasoning-step { margin:8px 0; border:1px solid var(--line); border-radius:7px; min-width:0; }
-.reasoning-header { cursor:pointer; padding:8px 10px; color:var(--muted); }
+.reasoning-header { display:flex; align-items:center; gap:8px; min-height:32px; padding:8px 10px; color:var(--muted); }
 .reasoning-title { min-width:0; flex:1; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
 .reasoning-section { margin:0 10px 10px; max-height:30em; overflow:auto; overflow-wrap:anywhere; }
 .reasoning-part + .reasoning-part { border-top:1px solid var(--line); padding-top:8px; }

package/src/presentation/visibleTurnActivities.ts

@@ -0,0 +1,12 @@
+import { RUNTIME_WARNING_PREFIXES, sameRuntimeError } from "../runtime/responseErrors.js";
+import type { TurnActivity, TurnViewState } from "./turnViewTypes.js";
+
+export function visibleTurnActivities(state: TurnViewState): TurnActivity[] {
+  if (state.status !== "failed" || !state.error) return state.activities;
+  return state.activities.filter((activity) => {
+    if (activity.id !== `commentary:runtime-error:${state.turnId}`
+      || (activity.kind !== "assistant" && activity.kind !== "reasoning")) return true;
+    const prefix = RUNTIME_WARNING_PREFIXES.find((value) => activity.text.startsWith(value));
+    return !sameRuntimeError(prefix ? activity.text.slice(prefix.length) : activity.text, state.error!);
+  });
+}

package/src/proxy/ProxySessionController.ts

@@ -59,6 +59,7 @@ import type { TurnActivity, TurnViewState } from "../presentation/turnViewTypes.
 import { createTurnViewState, hydrateTurnViewState } from "../presentation/TurnStateReducer.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import type { AgentRuntimeRegistry } from "../runtime/AgentRuntimeRegistry.js";
+import { displayRuntimeError, isResponseContinuationError } from "../runtime/responseErrors.js";
 import type {
   AgentRuntime,
   ApprovalDecision,
@@ -76,6 +77,7 @@ import type {
   RuntimeExecutionSettings,
   RuntimePrompt,
   RuntimeSession,
+  RuntimeSettingsReplacement,
 } from "../runtime/types.js";
 import {
   isActiveShellCommandJob,
@@ -120,6 +122,7 @@ interface StartTurnOptions {
   displayPrompt?: string;
   preserveAttemptOnFailure?: boolean;
   approvedPlanTurnId?: string;
+  responseContinuationTurnId?: string;
 }
 
 interface PendingForwardAttachment {
@@ -566,6 +569,7 @@ export class ProxySessionController {
   private readonly lastSessionListings = new Map<string, string[]>();
   private readonly threadInitializations = new Map<string, Promise<void>>();
   private readonly llmRetryingSessions = new Set<string>();
+  private readonly responseContinuations = new Map<string, { turnId: string; abort: AbortController }>();
   private readonly planHandoffs = new Map<string, string>();
   private readonly retriedFailureTurnIds = new Set<string>();
   private readonly queuedPromptRetryTimers = new Map<string, NodeJS.Timeout>();
@@ -3976,6 +3980,16 @@ export class ProxySessionController {
     localImagePaths?: string[], options: StartTurnOptions = {},
   ): Promise<string> {
     return this.settingsOperations.run(loaded.record.localSessionId, async () => {
+      if (options.responseContinuationTurnId) {
+        const current = this.store.getSession(loaded.record.localSessionId);
+        if (!current || current.status === "closed" || current.lastTurnId !== options.responseContinuationTurnId
+          || this.sessionResets.has(current.localSessionId)
+          || this.responseContinuations.get(current.localSessionId)?.turnId !== options.responseContinuationTurnId
+          || this.store.getPendingProviderSettings(current.localSessionId)) {
+          throw new Error("任务或运行设置已变化，未自动恢复模型续接。请发送消息继续。");
+        }
+        return this.startTurnNow(loaded, text, replyTarget, localImagePaths, options);
+      }
       try {
         await this.applyPendingProviderSettings(loaded);
       } catch (error) {
@@ -4050,17 +4064,27 @@ export class ProxySessionController {
             || this.sessionResets.has(loaded.record.localSessionId))) {
             throw new Error("方案执行已取消。");
           }
-          turnId = await loaded.runtime.startTurn(
-            loaded.record.localSessionId,
-            options.approvedPlanTurnId
-              ? { text: runtimeText, collaborationMode: "default" }
-              : runtimePrompt(runtimeText, localImagePaths),
-          );
+          if (options.responseContinuationTurnId) {
+            const recovery = this.responseContinuations.get(loaded.record.localSessionId);
+            if (recovery?.turnId !== options.responseContinuationTurnId
+              || this.sessionResets.has(loaded.record.localSessionId) || !loaded.runtime.recoverResponseContinuation) {
+              throw new Error("模型续接恢复已取消。");
+            }
+            turnId = await loaded.runtime.recoverResponseContinuation(loaded.record.localSessionId, options.responseContinuationTurnId, recovery.abort.signal);
+          } else {
+            turnId = await loaded.runtime.startTurn(
+              loaded.record.localSessionId,
+              options.approvedPlanTurnId
+                ? { text: runtimeText, collaborationMode: "default" }
+                : runtimePrompt(runtimeText, localImagePaths),
+            );
+          }
           break;
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
           const attempt = this.store.getTurnAttempt(attemptId);
           const retryAttempt = attempt
+            && !options.responseContinuationTurnId
             && isRetryableLlmTurnFailure(message)
             && attempt.retryCount < MAX_LLM_TURN_RETRIES
             ? this.store.prepareUnstartedTurnAttemptRetry(attemptId)
@@ -4794,7 +4818,23 @@ export class ProxySessionController {
       : undefined;
     if (event.type === "turn_failed") {
       if (this.retriedFailureTurnIds.has(event.turnId)) return;
-      if (failedAttempt && isRetryableLlmTurnFailure(event.message) && failedAttempt.retryCount < MAX_LLM_TURN_RETRIES) {
+      const source = this.store.getSession(event.sessionId);
+      const responseContinuation = failedAttempt?.retryCount === 0 && failedAttempt.status !== "cancelling"
+        && source && source.status !== "closed" && source.lastTurnId === event.turnId
+        && !this.sessionResets.has(event.sessionId) && !this.store.getPendingProviderSettings(event.sessionId)
+        && Boolean(this.runtimes.forAgent(source.agentName).recoverResponseContinuation)
+        && isResponseContinuationError(event.message);
+      if (failedAttempt && responseContinuation) {
+        const retryAttempt = this.store.prepareTurnAttemptRetry(failedAttempt.attemptId, event.turnId);
+        if (retryAttempt) {
+          this.retriedFailureTurnIds.add(event.turnId);
+          this.responseContinuations.set(event.sessionId, { turnId: event.turnId, abort: new AbortController() });
+          await this.retryFailedLlmTurn(event, retryAttempt, true);
+          return;
+        }
+      }
+      if (failedAttempt && !this.responseContinuations.has(event.sessionId)
+        && isRetryableLlmTurnFailure(event.message) && failedAttempt.retryCount < MAX_LLM_TURN_RETRIES) {
         const retryAttempt = this.store.prepareTurnAttemptRetry(failedAttempt.attemptId, event.turnId);
         if (retryAttempt) {
           this.retriedFailureTurnIds.add(event.turnId);
@@ -4957,6 +4997,7 @@ export class ProxySessionController {
   private async retryFailedLlmTurn(
     event: Extract<RuntimeEvent, { type: "turn_failed" }>,
     attempt: TurnAttemptRecord,
+    responseContinuation = false,
   ): Promise<void> {
     const retryNumber = attempt.retryCount;
     const session = this.store.getSession(event.sessionId);
@@ -4974,14 +5015,17 @@ export class ProxySessionController {
       attemptId: attempt.attemptId,
       failedTurnId: event.turnId,
       retryNumber,
-      maxRetries: MAX_LLM_TURN_RETRIES,
+      maxRetries: responseContinuation ? 1 : MAX_LLM_TURN_RETRIES,
+      responseContinuation,
       error: event.message,
     });
 
     try {
       await this.outbound.onEvent({
         ...event,
-        message: `${event.message}\n\n检测到临时模型服务错误，正在自动重试（${retryNumber}/${MAX_LLM_TURN_RETRIES}）。`,
+        message: responseContinuation
+          ? `${event.message}\n\n模型续接状态失效，正在恢复连接并继续（1/1）。`
+          : `${event.message}\n\n检测到临时模型服务错误，正在自动重试（${retryNumber}/${MAX_LLM_TURN_RETRIES}）。`,
       });
     } catch (error) {
       this.logger.warn(
@@ -4998,21 +5042,26 @@ export class ProxySessionController {
       const loaded = await this.loadSession(current, Boolean(this.store.getPendingProviderSettings(current.localSessionId)));
       const retryTurnId = await this.startTurn(
         loaded,
-        llmRetryRuntimePrompt(attempt.promptText, retryNumber),
+        responseContinuation ? "" : llmRetryRuntimePrompt(attempt.promptText, retryNumber),
         replyTarget,
-        attempt.localImagePaths,
+        responseContinuation ? undefined : attempt.localImagePaths,
         {
           attemptId: attempt.attemptId,
           messageId: attempt.messageId,
-          displayPrompt: llmRetryCardPrompt(attempt.promptText, retryNumber),
+          displayPrompt: responseContinuation ? `恢复模型续接：${attempt.promptText}` : llmRetryCardPrompt(attempt.promptText, retryNumber),
           preserveAttemptOnFailure: true,
+          ...(responseContinuation ? { responseContinuationTurnId: event.turnId } : {}),
         },
       );
       this.store.rebindPendingTurnMessages(session.localSessionId, event.turnId, retryTurnId);
     } catch (error) {
-      this.store.updateTurnAttempt(attempt.attemptId, { status: "failed" });
-      this.store.updateSession(session.localSessionId, { status: "failed" });
-      await this.finalizeTurnMessageReactions(event.turnId, "failed").catch((reactionError: unknown) => {
+      const aborted = responseContinuation && !this.responseContinuations.has(session.localSessionId);
+      this.store.updateTurnAttempt(attempt.attemptId, { status: aborted ? "cancelled" : "failed" });
+      const latest = this.store.getSession(session.localSessionId);
+      if (!responseContinuation || (latest?.lastTurnId === event.turnId && latest.status !== "closed")) {
+        this.store.updateSession(session.localSessionId, { status: aborted ? "ready" : "failed" });
+      }
+      await this.finalizeTurnMessageReactions(event.turnId, aborted ? "cancelled" : "failed").catch((reactionError: unknown) => {
         this.logger.warn(
           { error: reactionError, sessionId: session.localSessionId, turnId: event.turnId },
           "Failed to finalize reactions after an LLM retry could not start.",
@@ -5022,9 +5071,16 @@ export class ProxySessionController {
         { error, sessionId: session.localSessionId, retryNumber },
         "Failed to start an automatic LLM turn retry.",
       );
+      if (responseContinuation && !aborted) {
+        await this.outbound.sendText(attempt.contextKey,
+          `模型续接恢复未能启动：${displayRuntimeError(runtimeErrorMessage(error))}。请发送消息继续。`);
+      }
       await this.scheduleNextQueuedPrompt(session.localSessionId);
     } finally {
       this.llmRetryingSessions.delete(session.localSessionId);
+      if (this.responseContinuations.get(session.localSessionId)?.turnId === event.turnId) {
+        this.responseContinuations.delete(session.localSessionId);
+      }
     }
   }
 
@@ -5291,6 +5347,8 @@ export class ProxySessionController {
   }
 
   private async cancelSession(record: SessionRecord): Promise<void> {
+    this.responseContinuations.get(record.localSessionId)?.abort.abort();
+    this.responseContinuations.delete(record.localSessionId);
     this.planHandoffs.delete(record.localSessionId);
     const runtime = this.runtimes.forAgent(record.agentName);
     if (runtime.kind === "codex" && record.remoteSessionId && runtime.interruptRemoteTurn) {
@@ -5370,6 +5428,8 @@ export class ProxySessionController {
   }
 
   private async runSessionReset(sessionId: string, operation: () => Promise<void>): Promise<void> {
+    this.responseContinuations.get(sessionId)?.abort.abort();
+    this.responseContinuations.delete(sessionId);
     this.planHandoffs.delete(sessionId);
     const previous = this.sessionResets.get(sessionId) ?? Promise.resolve();
     const reset = previous.catch(() => undefined).then(operation);
@@ -5844,9 +5904,16 @@ export class ProxySessionController {
     if (!loaded.runtime.setExecutionSettings) throw new Error("当前运行时不支持 Provider 设置。");
     loaded.session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
     const remoteSessionId = loaded.session.remoteSessionId;
-    const persist = (candidate: RuntimeSession): Promise<void> => this.agentDefaultsOperations.run(loaded.record.agentName, async () => {
+    const persist = (candidate: RuntimeSession, replacement?: RuntimeSettingsReplacement): Promise<void> => this.agentDefaultsOperations.run(loaded.record.agentName, async () => {
       if (candidate.remoteSessionId !== remoteSessionId) {
-        throw new Error("设置切换返回了不同的任务 ID，未保存设置；不允许替换任务或更改历史。");
+        const saved = this.store.getSession(loaded.record.localSessionId);
+        if (replacement?.emptyRemoteSessionId !== remoteSessionId || !saved || saved.remoteSessionId !== remoteSessionId
+          || saved.status === "closed" || saved.status === "running" || saved.lastTurnId || loaded.session.activeTurnId || candidate.activeTurnId
+          || candidate.localSessionId !== saved.localSessionId || !candidate.remoteSessionId
+          || candidate.agentName !== saved.agentName || candidate.cwd !== saved.cwd || candidate.runtimeKind !== loaded.session.runtimeKind
+          || this.store.hasTurnAttemptsForSession(saved.localSessionId) || this.store.getForkHistorySource(saved.localSessionId)) {
+          throw new Error("设置切换返回了不同的任务 ID，未保存设置；仅允许已验证的空会话更换底层任务。");
+        }
       }
       assertProviderSettingsApplied(candidate, settings);
       const agent = this.ensureAgent(loaded.record.agentName);
@@ -5854,6 +5921,7 @@ export class ProxySessionController {
       await this.persistAgentExecutionDefaultsNow(loaded.record.localSessionId, candidate);
       try {
         this.store.updateRuntimeSession(loaded.record.localSessionId, {
+          remoteSessionId: candidate.remoteSessionId,
           modelProvider: candidate.modelProvider,
           model: candidate.model,
           reasoningEffort: candidate.reasoningEffort,
@@ -5866,6 +5934,7 @@ export class ProxySessionController {
       }
     });
     const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
+    loaded.record = this.store.getSession(loaded.record.localSessionId) ?? loaded.record;
     this.settingsOnlySessions.delete(loaded.record.localSessionId);
     this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
     return session;
@@ -7107,6 +7176,7 @@ export class ProxySessionController {
   }
 
   private async createDirectoryFromCard(contextKey: string, action: CardAction): Promise<void> {
+    const updateMessageId = requiredCardMessageId(action.messageId);
     const directory = directoryActionPath(action.value.directory);
     await this.assertBrowsableDirectory(directory);
     const folderName = directoryFolderName(cardFormValue(action.value, "folderName"));
@@ -7120,9 +7190,9 @@ export class ProxySessionController {
       if (code === "EEXIST") throw new Error(`目录已存在：${newDirectory}`);
       throw new Error(`无法创建目录 ${newDirectory}：${runtimeErrorMessage(error)}`);
     }
-    await this.openDirectoryBrowser(contextKey, directory, {
-      updateMessageId: requiredCardMessageId(action.messageId),
-      page: directoryPageValue(action.value.page),
+    await this.openDirectoryBrowser(contextKey, newDirectory, {
+      updateMessageId,
+      page: 0,
     });
     await this.outbound.sendText(contextKey, `已创建目录：${newDirectory}`);
   }

package/src/runtime/responseErrors.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+export const RUNTIME_WARNING_PREFIXES = ["运行请求失败，等待 Agent 返回最终状态：", "运行请求出错，Agent 正在重试："];
+
+const responseErrorSchema = z.object({
+  type: z.literal("error"),
+  status: z.number().optional(),
+  error: z.object({
+    message: z.string().min(1),
+    code: z.string().nullish(),
+    param: z.string().nullish(),
+    type: z.string().nullish(),
+  }).passthrough(),
+}).passthrough();
+
+function parseResponseError(message: string): { value: z.infer<typeof responseErrorSchema>; notice: string } | undefined {
+  // Agent Bot may append a recovery notice after the upstream JSON error.
+  const boundary = message.indexOf("\n\n");
+  for (const end of [message.length, ...(boundary >= 0 ? [boundary] : [])]) {
+    try {
+      const parsed = responseErrorSchema.safeParse(JSON.parse(message.slice(0, end)));
+      if (parsed.success) return { value: parsed.data, notice: message.slice(end) };
+    } catch {
+      // Non-JSON runtime errors remain unchanged.
+    }
+  }
+  return undefined;
+}
+
+export function isResponseContinuationError(message: string): boolean {
+  const parsed = parseResponseError(message);
+  return parsed?.value.error.code === "unsupported_persisted_item_context"
+    && parsed.value.error.param === "previous_response_id"
+    && parsed.value.error.type === "invalid_request_error"
+    && parsed.value.status === 400
+    && !parsed.notice;
+}
+
+export function displayRuntimeError(message: string): string {
+  const prefix = RUNTIME_WARNING_PREFIXES.find((value) => message.startsWith(value));
+  const parsed = parseResponseError(prefix ? message.slice(prefix.length) : message);
+  if (!parsed) return message;
+  const { error, status } = parsed.value;
+  const details = [status === undefined ? undefined : `HTTP ${status}`, error.code, error.param];
+  return (prefix ?? "") + `${error.message}\n${details.filter(Boolean).join(" · ")}${parsed.notice}`.trim();
+}
+
+export function sameRuntimeError(warning: string, terminal: string): boolean {
+  if (warning.trim() === terminal.trim()) return true;
+  const parsed = parseResponseError(terminal);
+  if (parsed) {
+    const other = parseResponseError(warning);
+    return Boolean(other && !other.notice && (!parsed.notice || isRecoveryNotice(parsed.notice))
+      && JSON.stringify(other.value) === JSON.stringify(parsed.value));
+  }
+  const suffix = terminal.slice(warning.trim().length);
+  return terminal.startsWith(warning.trim()) && isRecoveryNotice(suffix);
+}
+
+function isRecoveryNotice(text: string): boolean {
+  return /^\n\n(?:检测到临时模型服务错误，正在自动重试|模型续接状态失效，正在恢复连接并继续|已自动重试)/u.test(text);
+}

package/src/runtime/types.ts

@@ -270,6 +270,10 @@ export interface RuntimeExecutionSettings {
   permissionMode: PermissionMode;
 }
 
+export interface RuntimeSettingsReplacement {
+  emptyRemoteSessionId: string;
+}
+
 export interface RuntimeReleaseResult {
   status: "released" | "busy";
   activeSessionIds?: string[];
@@ -304,6 +308,8 @@ export interface AgentRuntime {
   inspectRemoteSessionActivity?(remoteSessionId: string): Promise<RemoteSessionActivity>;
   synchronizeSession(sessionId: string): Promise<RuntimeSession>;
   startTurn(sessionId: string, prompt: RuntimePrompt): Promise<string>;
+  // Continue a verified Responses replay failure without resubmitting user input.
+  recoverResponseContinuation?(sessionId: string, failedTurnId: string, signal?: AbortSignal): Promise<string>;
   steerTurn(sessionId: string, turnId: string, prompt: RuntimePrompt): Promise<void>;
   cancelTurn(sessionId: string, turnId: string): Promise<void>;
   interruptRemoteTurn?(remoteSessionId: string, turnId: string): Promise<void>;
@@ -320,7 +326,7 @@ export interface AgentRuntime {
     sessionId: string,
     settings: RuntimeExecutionSettings,
     // Called after remote verification, before releasing the task's operation lock.
-    persist?: (session: RuntimeSession) => Promise<void>,
+    persist?: (session: RuntimeSession, replacement?: RuntimeSettingsReplacement) => Promise<void>,
   ): Promise<RuntimeSession>;
   respondToApproval(sessionId: string, requestId: string, decision: ApprovalDecision): Promise<void>;
   listModels(modelProvider?: string, fallbackModel?: string): Promise<ModelOption[]>;