@keyou007/agent-bot 0.1.24-alpha.8 → 0.1.25-alpha.0

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,9 +122,10 @@ interface StartTurnOptions {
   displayPrompt?: string;
   preserveAttemptOnFailure?: boolean;
   approvedPlanTurnId?: string;
+  responseContinuationTurnId?: string;
 }
 
-interface PendingForwardAttachment {
+interface PendingMessageReference {
   contextKey: string;
   userId?: string;
   attachmentMessageId?: string;
@@ -130,11 +133,9 @@ interface PendingForwardAttachment {
   resolveAttachment: (message: IncomingMessage | undefined) => void;
 }
 
-interface ForwardAttachmentReservation {
+interface MessageReferenceReservation {
   sourceMessageId: string;
-  sourceKind: "merged_forward" | "resource";
-  pending: PendingForwardAttachment;
-  registry: Map<string, PendingForwardAttachment>;
+  pending: PendingMessageReference;
 }
 
 interface PreparedTopicRootPrompt {
@@ -189,6 +190,7 @@ const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
 const MESSAGE_CANCELLED_REACTION = "CrossMark";
+const INBOUND_MESSAGE_DELAY_WARNING_MS = 60_000;
 const SESSION_PAGE_SIZE = 10;
 const SESSION_PROMPT_PREVIEW_LENGTH = 50;
 const DIRECTORY_PAGE_SIZE = 15;
@@ -202,7 +204,7 @@ const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
 const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
 const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
 const APP_SERVER_RELEASE_POLL_INTERVAL_MS = 500;
-const FORWARD_ATTACHMENT_WINDOW_MS = 1_500;
+const REFERENCE_INSTRUCTION_WINDOW_MS = 1_500;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
 const TURN_STOP_REQUESTED_MESSAGE = "已发送停止信号，任务会自动停止。";
@@ -566,6 +568,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>();
@@ -573,8 +576,7 @@ export class ProxySessionController {
   private readonly recoveryRetryStartedAt = new Map<string, number>();
   private readonly recoveredLiveAttempts = new Set<string>();
   private recoveryClosed = false;
-  private readonly pendingMergedForwards = new Map<string, PendingForwardAttachment>();
-  private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
+  private readonly pendingMessageReferences = new Map<string, PendingMessageReference>();
   private readonly relatedReactionMessageIds = new Map<string, string[]>();
   private readonly shellCommandJobMonitors = new Map<string, ShellCommandJobMonitor>();
   private readonly appServerReleaseSchedules = new Map<string, AppServerReleaseSchedule>();
@@ -597,6 +599,7 @@ export class ProxySessionController {
       path.join(path.dirname(config.storage.sqlitePath), "command-jobs"),
     ),
     private readonly threadWriterProcesses: ThreadWriterProcessController = new SystemThreadWriterProcessController(),
+    private readonly referenceInstructionWindowMs = REFERENCE_INSTRUCTION_WINDOW_MS,
   ) {
     for (const [, runtime] of this.runtimes.entries()) {
       this.unsubscribe.push(
@@ -643,14 +646,29 @@ export class ProxySessionController {
     // For accepted messages, claim durable deduplication before acknowledgement so event
     // retries cannot add duplicate reactions.
     if (!this.store.claimInboundEvent(message.messageId, "message")) return;
-    const attachmentReservation = message.mergedForwardMessageId
-      ? undefined
-      : this.reserveForwardAttachment(message);
-    const pendingMergedForward = message.mergedForwardMessageId
-      ? this.registerPendingForwardAttachment(message, this.pendingMergedForwards)
-      : undefined;
-    const pendingResourceForward = !attachmentReservation && isForwardAttachmentSource(message)
-      ? this.registerPendingForwardAttachment(message, this.pendingResourceForwards)
+    const acceptedAt = Date.now();
+    const receivedAt = message.receivedAt ?? acceptedAt;
+    const deliveryDelayMs = message.createdAt === undefined
+      ? 0 : Math.max(0, receivedAt - message.createdAt);
+    const dispatchDelayMs = Math.max(0, acceptedAt - receivedAt);
+    if (deliveryDelayMs + dispatchDelayMs >= INBOUND_MESSAGE_DELAY_WARNING_MS) {
+      this.logger.warn(
+        {
+          messageId: message.messageId,
+          eventId: message.eventId,
+          contextKey: message.contextKey,
+          messageCreatedAt: message.createdAt,
+          receivedAt,
+          acceptedAt,
+          deliveryDelayMs,
+          dispatchDelayMs,
+        },
+        "Accepted a delayed Feishu message.",
+      );
+    }
+    const attachmentReservation = this.reserveReferenceInstruction(message);
+    const pendingReference = !attachmentReservation && isReferenceSource(message)
+      ? this.registerPendingReference(message)
       : undefined;
     try {
       const reactionId = await this.outbound.addReaction(
@@ -668,8 +686,9 @@ export class ProxySessionController {
       );
     }
     await this.waitForCurrentSessionReset(message.contextKey);
-    if (attachmentReservation && this.completeForwardAttachment(message, attachmentReservation)) {
-      this.store.audit(message.contextKey, `${attachmentReservation.sourceKind}_attachment_coalesced`, {
+    if (this.recoveryClosed) return;
+    if (attachmentReservation && this.completeReferenceInstruction(message, attachmentReservation)) {
+      this.store.audit(message.contextKey, "referenced_message_coalesced", {
         messageId: message.messageId,
         parentMessageId: message.parentMessageId,
       });
@@ -690,24 +709,24 @@ export class ProxySessionController {
       this.store.recordChatContext(chatContextKey, message.chatType);
       this.store.markChatActive(chatContextKey);
     }
-    if (pendingResourceForward) {
-      const resourceMessage = message;
-      const attachment = await this.waitForForwardAttachment(
+    if (pendingReference && !message.mergedForwardMessageId) {
+      const sourceMessage = message;
+      const attachment = await this.waitForReferenceInstruction(
         message.messageId,
-        pendingResourceForward,
-        this.pendingResourceForwards,
+        pendingReference,
       );
+      if (this.recoveryClosed) return;
       if (attachment) {
         coalescedForwardAttachment = true;
-        const sourceText = resourceMessage.text.trim();
-        const instruction = normalizeFeishuPostText(attachment.text)
-          || (sourceText ? DEFAULT_REFERENCED_MESSAGE_INSTRUCTION : defaultResourcePrompt(resourceMessage));
-        forwardedImages = (resourceMessage.images ?? []).map((image) => ({
-          messageId: resourceMessage.messageId,
+        const sourceText = sourceMessage.text.trim();
+        const instruction = normalizeFeishuPostText(attachment.displayText ?? attachment.text)
+          || (sourceText ? DEFAULT_REFERENCED_MESSAGE_INSTRUCTION : defaultResourcePrompt(sourceMessage));
+        forwardedImages = (sourceMessage.images ?? []).map((image) => ({
+          messageId: sourceMessage.messageId,
           imageKey: image.imageKey,
         }));
-        forwardedFiles = (resourceMessage.files ?? []).map((file) => ({
-          messageId: resourceMessage.messageId,
+        forwardedFiles = (sourceMessage.files ?? []).map((file) => ({
+          messageId: sourceMessage.messageId,
           fileKey: file.fileKey,
           fileName: file.fileName,
         }));
@@ -716,7 +735,7 @@ export class ProxySessionController {
           text: sourceText ? referencedMessagePrompt(instruction, sourceText) : instruction,
           displayText: instruction,
         };
-        this.relatedReactionMessageIds.set(message.messageId, [resourceMessage.messageId]);
+        this.relatedReactionMessageIds.set(message.messageId, [sourceMessage.messageId]);
       }
     }
     if (message.mergedForwardMessageId) {
@@ -728,16 +747,15 @@ export class ProxySessionController {
         (content) => ({ content } as const),
         (error: unknown) => ({ error } as const),
       );
-      const attachment = pendingMergedForward
-        ? await this.waitForForwardAttachment(
+      const attachment = pendingReference
+        ? await this.waitForReferenceInstruction(
             message.messageId,
-            pendingMergedForward,
-            this.pendingMergedForwards,
+            pendingReference,
           )
         : undefined;
       if (attachment) {
         coalescedForwardAttachment = true;
-        const instruction = normalizeFeishuPostText(attachment.text)
+        const instruction = normalizeFeishuPostText(attachment.displayText ?? attachment.text)
           || ((attachment.images?.length ?? 0) > 0 ? "请查看附带的内容。" : "请结合参考聊天记录处理。");
         message = {
           ...attachment,
@@ -747,6 +765,7 @@ export class ProxySessionController {
         this.relatedReactionMessageIds.set(message.messageId, [mergedForwardMessage.messageId]);
       }
       const result = await mergedForwardResult;
+      if (this.recoveryClosed) return;
       if ("error" in result) {
         const replyTarget = message.replyInThread
           ? { messageId: message.messageId, replyInThread: true as const }
@@ -823,6 +842,9 @@ export class ProxySessionController {
     const fileCount = fileReferences.length;
     this.store.audit(message.contextKey, "incoming_message", {
       messageId: message.messageId,
+      eventId: message.eventId,
+      messageCreatedAt: message.createdAt,
+      receivedAt: message.receivedAt,
       text: message.text,
       ...(imageCount > 0 ? { imageCount } : {}),
       ...(fileCount > 0 ? { fileCount } : {}),
@@ -1400,10 +1422,8 @@ export class ProxySessionController {
     this.remoteTurnHistoryRefreshes.clear();
     this.forkHistoryCursors.clear();
     this.turnHistoryHydrations.clear();
-    for (const pending of this.pendingMergedForwards.values()) pending.resolveAttachment(undefined);
-    this.pendingMergedForwards.clear();
-    for (const pending of this.pendingResourceForwards.values()) pending.resolveAttachment(undefined);
-    this.pendingResourceForwards.clear();
+    for (const pending of this.pendingMessageReferences.values()) pending.resolveAttachment(undefined);
+    this.pendingMessageReferences.clear();
     this.relatedReactionMessageIds.clear();
     for (const timer of this.queuedPromptRetryTimers.values()) clearTimeout(timer);
     this.queuedPromptRetryTimers.clear();
@@ -3976,6 +3996,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 +4080,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 +4834,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 +5013,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 +5031,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 +5058,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 +5087,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);
+      }
     }
   }
 
@@ -5146,10 +5218,7 @@ export class ProxySessionController {
     }
   }
 
-  private registerPendingForwardAttachment(
-    message: IncomingMessage,
-    registry: Map<string, PendingForwardAttachment>,
-  ): PendingForwardAttachment {
+  private registerPendingReference(message: IncomingMessage): PendingMessageReference {
     let resolveAttachment!: (message: IncomingMessage | undefined) => void;
     const attachmentPromise = new Promise<IncomingMessage | undefined>((resolve) => {
       resolveAttachment = resolve;
@@ -5160,61 +5229,51 @@ export class ProxySessionController {
       attachmentPromise,
       resolveAttachment,
     };
-    registry.set(message.messageId, pending);
+    this.pendingMessageReferences.set(message.messageId, pending);
     return pending;
   }
 
-  private reserveForwardAttachment(message: IncomingMessage): ForwardAttachmentReservation | undefined {
-    if (!message.parentMessageId || isCommandMessage(message)) return undefined;
-    const candidates = [
-      { sourceKind: "merged_forward" as const, registry: this.pendingMergedForwards },
-      { sourceKind: "resource" as const, registry: this.pendingResourceForwards },
-    ];
-    for (const candidate of candidates) {
-      const pending = candidate.registry.get(message.parentMessageId);
-      if (!pending || pending.contextKey !== message.contextKey
-        || pending.userId !== message.userId || pending.attachmentMessageId) continue;
-      pending.attachmentMessageId = message.messageId;
-      return {
-        sourceMessageId: message.parentMessageId,
-        sourceKind: candidate.sourceKind,
-        pending,
-        registry: candidate.registry,
-      };
-    }
-    return undefined;
+  private reserveReferenceInstruction(message: IncomingMessage): MessageReferenceReservation | undefined {
+    const parentMessageId = quotedMessageId(message);
+    if (!parentMessageId || isCommandMessage(message)) return undefined;
+    const pending = this.pendingMessageReferences.get(parentMessageId);
+    if (!pending || pending.contextKey !== message.contextKey
+      || pending.userId !== message.userId || pending.attachmentMessageId) return undefined;
+    pending.attachmentMessageId = message.messageId;
+    return { sourceMessageId: parentMessageId, pending };
   }
 
-  private completeForwardAttachment(
+  private completeReferenceInstruction(
     message: IncomingMessage,
-    reservation: ForwardAttachmentReservation,
+    reservation: MessageReferenceReservation,
   ): boolean {
-    if (!message.parentMessageId) return false;
-    if (reservation.sourceMessageId !== message.parentMessageId) return false;
-    if (reservation.registry.get(message.parentMessageId) !== reservation.pending) return false;
+    const parentMessageId = quotedMessageId(message);
+    if (!parentMessageId || reservation.sourceMessageId !== parentMessageId) return false;
+    if (this.pendingMessageReferences.get(parentMessageId) !== reservation.pending) return false;
     if (reservation.pending.attachmentMessageId !== message.messageId) return false;
     reservation.pending.resolveAttachment(message);
     return true;
   }
 
-  private async waitForForwardAttachment(
+  private async waitForReferenceInstruction(
     messageId: string,
-    pending: PendingForwardAttachment,
-    registry: Map<string, PendingForwardAttachment>,
+    pending: PendingMessageReference,
   ): Promise<IncomingMessage | undefined> {
-    const timer = setTimeout(() => {
+    const expire = (): void => {
       // Arrival reserves the pair before acknowledgement. A slow Reaction must not split it.
       if (pending.attachmentMessageId) return;
-      if (registry.get(messageId) === pending) registry.delete(messageId);
+      if (this.pendingMessageReferences.get(messageId) === pending) this.pendingMessageReferences.delete(messageId);
       pending.resolveAttachment(undefined);
-    }, FORWARD_ATTACHMENT_WINDOW_MS);
-    timer.unref?.();
+    };
+    const timer = this.referenceInstructionWindowMs > 0 ? setTimeout(expire, this.referenceInstructionWindowMs) : undefined;
+    if (timer) timer.unref?.();
+    else expire();
     try {
       return await pending.attachmentPromise;
     } finally {
-      clearTimeout(timer);
-      if (registry.get(messageId) === pending) {
-        registry.delete(messageId);
+      if (timer) clearTimeout(timer);
+      if (this.pendingMessageReferences.get(messageId) === pending) {
+        this.pendingMessageReferences.delete(messageId);
       }
     }
   }
@@ -5291,6 +5350,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 +5431,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 +5907,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 +5924,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 +5937,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 +7179,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 +7193,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}`);
   }
@@ -9758,13 +9831,10 @@ function isCommandMessage(message: IncomingMessage): boolean {
   return text.startsWith("/") || text.startsWith("!");
 }
 
-function isForwardAttachmentSource(message: IncomingMessage): boolean {
-  return !message.mergedForwardMessageId
-    && !message.parentMessageId
+function isReferenceSource(message: IncomingMessage): boolean {
+  return !quotedMessageId(message)
     && !message.contextKey.startsWith("console:")
-    && !isCommandMessage(message)
-    && (message.messageType === "post"
-      || (message.images?.length ?? 0) > 0 || (message.files?.length ?? 0) > 0);
+    && !isCommandMessage(message);
 }
 
 function deduplicateImageReferences(

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[]>;