@keyou007/agent-bot 0.1.13 → 0.1.14-alpha.1

package/src/feishu/FeishuConnector.ts

@@ -2,6 +2,7 @@ import type { Logger } from "pino";
 import type { AppConfig } from "../config/schema.js";
 import { threadContextKey } from "./contextKey.js";
 import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
+import { allowsFeishuUser } from "./ownerAccess.js";
 import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
 type BotOpenIdResolver = (appId: string, appSecret: string) => Promise<string>;
@@ -33,18 +34,31 @@ export class FeishuConnector {
         this.logger.warn({ error }, "Failed to resolve the Lark bot Open ID for the Agent environment.");
       }
     }
-    await this.startFeishuWs(appId, appSecret, respondToAllGroupMessages ? undefined : botOpenId);
+    await this.startFeishuWs(appId, appSecret, botOpenId, !respondToAllGroupMessages);
   }
 
   stop(): void {
     // SDK connector currently relies on process lifetime.
   }
 
-  private async startFeishuWs(appId: string, appSecret: string, requiredMentionOpenId?: string): Promise<void> {
+  private async startFeishuWs(
+    appId: string,
+    appSecret: string,
+    botOpenId?: string,
+    requireMention = false,
+  ): Promise<void> {
     const lark = (await import("@larksuiteoapi/node-sdk")) as Record<string, any>;
     const eventDispatcher = new lark.EventDispatcher({}).register({
       "im.message.receive_v1": async (data: unknown) => {
-        const message = toIncomingMessage(data, requiredMentionOpenId);
+        const senderOpenId = getFeishuEvent(data)?.sender?.sender_id?.open_id;
+        if (!allowsFeishuUser(this.config, senderOpenId)) {
+          this.logger.debug(
+            { messageId: getFeishuEvent(data)?.message?.message_id },
+            "Ignored a Feishu message from a non-owner.",
+          );
+          return;
+        }
+        const message = toIncomingMessage(data, botOpenId, requireMention);
         if (!message) {
           this.logger.debug({ data }, "Ignored unsupported Feishu message event.");
           return;
@@ -74,6 +88,14 @@ export class FeishuConnector {
           });
       },
       "card.action.trigger": async (data: unknown) => {
+        const operatorOpenId = getFeishuEvent(data)?.operator?.open_id;
+        if (!allowsFeishuUser(this.config, operatorOpenId)) {
+          this.logger.debug(
+            { actionId: getEventId(data) },
+            "Ignored a Feishu card action from a non-owner.",
+          );
+          return {};
+        }
         const action = toCardAction(data);
         if (!action) {
           this.logger.debug({ data }, "Ignored unsupported Feishu card action.");
@@ -115,7 +137,11 @@ function toChatUpdatedEvent(data: unknown): ChatUpdatedEvent | undefined {
   };
 }
 
-function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): IncomingMessage | undefined {
+function toIncomingMessage(
+  data: unknown,
+  botOpenId?: string,
+  requireMention = false,
+): IncomingMessage | undefined {
   const event = getFeishuEvent(data);
   const message = event?.message;
   if (!message) {
@@ -128,11 +154,10 @@ function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): Incom
   if (!parsed) return undefined;
   const chatId = message.chat_id;
   const chatType = message.chat_type === "group" ? "group" : "p2p";
-  if (
-    chatType === "group" &&
-    requiredMentionOpenId &&
-    !mentionsOpenId(message.mentions, requiredMentionOpenId)
-  ) {
+  const mentionedBot = chatType === "group"
+    && Boolean(botOpenId)
+    && mentionsOpenId(message.mentions, botOpenId!);
+  if (chatType === "group" && requireMention && !mentionedBot) {
     return undefined;
   }
   const threadId = typeof message.thread_id === "string" && message.thread_id ? message.thread_id : undefined;
@@ -161,6 +186,7 @@ function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): Incom
     ...(threadId ? { threadId } : {}),
     ...(rootMessageId ? { rootMessageId } : {}),
     ...(parentMessageId ? { parentMessageId } : {}),
+    ...(mentionedBot ? { mentionedBot: true as const } : {}),
     text: parsed.text,
     ...(parsed.images.length > 0 ? { images: parsed.images.map((imageKey) => ({ imageKey })) } : {}),
   };
@@ -250,10 +276,18 @@ function toCardAction(data: unknown) {
     contextKey: chatId ? `chat_id:${chatId}` : `open_id:${openId}`,
     userId: openId,
     ...(typeof event.context?.open_message_id === "string" ? { messageId: event.context.open_message_id } : {}),
-    value: isRecord(event.action.value) ? event.action.value : {},
+    value: getCardActionValue(event.action),
   };
 }
 
+function getCardActionValue(action: Record<string, unknown>): Record<string, unknown> {
+  if (action.tag === "overflow" && typeof action.option === "string") {
+    const option = parseJsonObject(action.option);
+    if (Object.keys(option).length > 0) return option;
+  }
+  return isRecord(action.value) ? action.value : {};
+}
+
 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;

package/src/feishu/FeishuMessageClient.ts

@@ -48,6 +48,15 @@ interface UploadImageResponse {
   error?: unknown;
 }
 
+interface UploadFileResponse {
+  code: number;
+  msg: string;
+  data?: {
+    file_key?: string;
+  };
+  error?: unknown;
+}
+
 interface ReactionResponse {
   code: number;
   msg: string;
@@ -178,13 +187,25 @@ export class FeishuMessageClient implements FeishuOutbound {
     return this.sendMessage(contextKey, "text", { text });
   }
 
+  async sendFile(contextKey: string, filePath: string): Promise<string | undefined> {
+    const fileKey = await this.uploadFile(filePath);
+    return this.sendMessage(contextKey, "file", { file_key: fileKey });
+  }
+
   async sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined> {
+    const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
     const elements = await renderMarkdownWithLocalImages(
-      normalizeFeishuMarkdown(markdown),
+      normalizedMarkdown,
       (filePath) => this.uploadImageCached(filePath),
       (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
     );
-    return this.sendMessage(contextKey, "interactive", finalAnswerCard(elements), idempotencyKey);
+    return this.sendMessage(
+      contextKey,
+      "interactive",
+      finalAnswerCard(elements),
+      idempotencyKey,
+      normalizedMarkdown,
+    );
   }
 
   async sendInteractiveCard(
@@ -203,18 +224,35 @@ export class FeishuMessageClient implements FeishuOutbound {
     return this.replyMessage(contextKey, target, "text", { text }, idempotencyKey);
   }
 
+  async replyFile(
+    contextKey: string,
+    target: MessageReplyTarget,
+    filePath: string,
+  ): Promise<string | undefined> {
+    const fileKey = await this.uploadFile(filePath);
+    return this.replyMessage(contextKey, target, "file", { file_key: fileKey });
+  }
+
   async replyMarkdown(
     contextKey: string,
     target: MessageReplyTarget,
     markdown: string,
     idempotencyKey?: string,
   ): Promise<string | undefined> {
+    const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
     const elements = await renderMarkdownWithLocalImages(
-      normalizeFeishuMarkdown(markdown),
+      normalizedMarkdown,
       (filePath) => this.uploadImageCached(filePath),
       (error, filePath) => this.logger.warn({ error, filePath }, "Failed to upload local image to Feishu."),
     );
-    return this.replyMessage(contextKey, target, "interactive", finalAnswerCard(elements), idempotencyKey);
+    return this.replyMessage(
+      contextKey,
+      target,
+      "interactive",
+      finalAnswerCard(elements),
+      idempotencyKey,
+      normalizedMarkdown,
+    );
   }
 
   async replyInteractiveCard(
@@ -278,8 +316,26 @@ export class FeishuMessageClient implements FeishuOutbound {
     msgType: string,
     content: Record<string, unknown>,
     idempotencyKey?: string,
+    cardTableLimitFallbackText?: string,
   ): Promise<string | undefined> {
-    return this.enqueueSend(contextKey, () => this.sendMessageNow(contextKey, msgType, content, idempotencyKey));
+    return this.enqueueSend(contextKey, async () => {
+      try {
+        return await this.sendMessageNow(contextKey, msgType, content, idempotencyKey);
+      } catch (error) {
+        const normalized = normalizeTransportError(error, "send");
+        if (!cardTableLimitFallbackText || !normalized.isCardTableLimitFailure) throw error;
+        this.logger.warn(
+          { code: normalized.code, contextKey },
+          "Feishu rejected a card with too many tables; retrying as text.",
+        );
+        return this.sendMessageNow(
+          contextKey,
+          "text",
+          { text: cardTableLimitFallbackText },
+          idempotencyKey,
+        );
+      }
+    });
   }
 
   private async replyMessage(
@@ -288,9 +344,26 @@ export class FeishuMessageClient implements FeishuOutbound {
     msgType: string,
     content: Record<string, unknown>,
     idempotencyKey?: string,
+    cardTableLimitFallbackText?: string,
   ): Promise<string | undefined> {
-    return this.enqueueSend(contextKey, () =>
-      this.replyMessageNow(target, msgType, content, idempotencyKey));
+    return this.enqueueSend(contextKey, async () => {
+      try {
+        return await this.replyMessageNow(target, msgType, content, idempotencyKey);
+      } catch (error) {
+        const normalized = normalizeTransportError(error, "reply");
+        if (!cardTableLimitFallbackText || !normalized.isCardTableLimitFailure) throw error;
+        this.logger.warn(
+          { code: normalized.code, messageId: target.messageId },
+          "Feishu rejected a reply card with too many tables; retrying as text.",
+        );
+        return this.replyMessageNow(
+          target,
+          "text",
+          { text: cardTableLimitFallbackText },
+          idempotencyKey,
+        );
+      }
+    });
   }
 
   private async replyMessageNow(
@@ -504,6 +577,40 @@ export class FeishuMessageClient implements FeishuOutbound {
     }
   }
 
+  private async uploadFile(filePath: string): Promise<string> {
+    const fileName = path.basename(filePath);
+    try {
+      const fileStats = await stat(filePath);
+      if (!fileStats.isFile()) throw new Error(`Not a regular file: ${fileName}`);
+      if (fileStats.size === 0) throw new Error(`Feishu does not accept empty files: ${fileName}`);
+      if (fileStats.size > 30 * 1024 * 1024) {
+        throw new Error(`File exceeds Feishu's 30 MiB limit: ${fileName}`);
+      }
+
+      const contents = await readFile(filePath);
+      const token = await this.getTenantAccessToken();
+      const form = new FormData();
+      form.append("file_type", "stream");
+      form.append("file_name", fileName);
+      const bytes = new ArrayBuffer(contents.byteLength);
+      new Uint8Array(bytes).set(contents);
+      form.append("file", new Blob([bytes]), fileName);
+      const response = await fetch("https://open.feishu.cn/open-apis/im/v1/files", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}` },
+        body: form,
+      });
+      const payload = (await response.json()) as UploadFileResponse;
+      const fileKey = payload.data?.file_key;
+      if (!response.ok || payload.code !== 0 || !fileKey) {
+        throw new FeishuApiError(payload.msg || response.statusText, payload.code, payload, "upload file", response.status);
+      }
+      return fileKey;
+    } catch (error) {
+      throw normalizeTransportError(error, "upload file");
+    }
+  }
+
   private async uploadImageBytes(
     contents: Uint8Array,
     imageType: "message" | "avatar",
@@ -616,6 +723,7 @@ export class FeishuApiError extends Error {
   readonly isRateLimit: boolean;
   readonly isRetryable: boolean;
   readonly isEmailAddressAuditFailure: boolean;
+  readonly isCardTableLimitFailure: boolean;
 
   constructor(
     message: string,
@@ -624,6 +732,7 @@ export class FeishuApiError extends Error {
       | SendMessageResponse
       | CreateGroupResponse
       | UploadImageResponse
+      | UploadFileResponse
       | ReactionResponse
       | DownloadImageErrorResponse,
     operation = "send",
@@ -635,6 +744,8 @@ export class FeishuApiError extends Error {
     this.isRateLimit = code === 230020 || message.toLowerCase().includes("frequency limit");
     this.isRetryable = forceRetryable || this.isRateLimit || (httpStatus !== undefined && httpStatus >= 500);
     this.isEmailAddressAuditFailure = code === 230028 && message.includes("EMAIL_ADDRESS");
+    this.isCardTableLimitFailure = code === 230099
+      && /table number over limit|ErrorValue:\s*table/iu.test(message);
   }
 }
 

package/src/feishu/FeishuTurnPresenter.ts

@@ -47,6 +47,8 @@ export interface FeishuTurnPresenterOptions {
   finalRetryBackoffMs?: number[];
 }
 
+const MAX_FINAL_TABLES_PER_CARD = 5;
+
 interface TurnEntry {
   contextKey: string;
   state: TurnViewState;
@@ -114,7 +116,7 @@ export class FeishuTurnPresenter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
-  ): Promise<void> {
+  ): Promise<string | undefined> {
     const existing = this.pendingEntries.get(sessionId);
     if (existing) {
       await existing.initializing;
@@ -123,7 +125,7 @@ export class FeishuTurnPresenter {
         this.store.saveTurnSnapshot(existing.state.turnId, sessionId, existing.state, existing.contextKey);
         if (!existing.historySnapshot) existing.scheduler?.update(existing.state, "critical");
       }
-      return;
+      return existing.state.turnId;
     }
     this.sessionContexts.set(sessionId, contextKey);
     if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
@@ -144,6 +146,7 @@ export class FeishuTurnPresenter {
     entry.initializing = this.initializeEntry(entry);
     try {
       await entry.initializing;
+      return state.turnId;
     } catch (error) {
       if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
       this.entries.delete(state.turnId);
@@ -167,6 +170,34 @@ export class FeishuTurnPresenter {
     await this.syncThinkingCardReaction(entry);
   }
 
+  async interruptTurnForRecovery(
+    sessionId: string,
+    contextKey: string,
+    turnId: string,
+    message: string,
+  ): Promise<void> {
+    const snapshot = this.store.getTurnSnapshot(turnId);
+    if (!isTurnViewState(snapshot) || snapshot.sessionId !== sessionId || isTerminalViewStatus(snapshot.status)) return;
+    const state: TurnViewState = {
+      ...snapshot,
+      status: "cancelled",
+      progressText: message,
+      activeTool: undefined,
+      approval: undefined,
+      completedAt: Date.now(),
+    };
+    this.store.saveTurnSnapshot(turnId, sessionId, state, contextKey);
+    const delivery = this.store.getTurnDelivery(turnId);
+    if (delivery?.progressMessageId) {
+      await this.outbound.updateInteractiveCard(delivery.progressMessageId, this.renderer.renderTurn(state));
+    }
+    const entry = this.entries.get(turnId);
+    if (entry) {
+      this.entries.delete(turnId);
+      if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
+    }
+  }
+
   async appendSteerMessage(
     sessionId: string,
     turnId: string,
@@ -464,7 +495,11 @@ export class FeishuTurnPresenter {
   private async deliverFinal(contextKey: string, state: TurnViewState): Promise<void> {
     const delivery = this.store.getTurnDelivery(state.turnId);
     if (delivery?.finalDelivered || !state.finalResponse) return;
-    const chunks = splitMarkdown(state.finalResponse, this.options.finalChunkLength ?? 4_000);
+    const chunks = splitMarkdown(
+      state.finalResponse,
+      this.options.finalChunkLength ?? 4_000,
+      MAX_FINAL_TABLES_PER_CARD,
+    );
     const messageIds = [...(delivery?.finalMessageIds ?? [])];
     for (let index = messageIds.length; index < chunks.length; index += 1) {
       const chunk = chunks[index];
@@ -513,6 +548,10 @@ function isTerminalEvent(event: AgentEvent): boolean {
   return event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed";
 }
 
+function isTerminalViewStatus(status: TurnViewState["status"]): boolean {
+  return status === "completed" || status === "cancelled" || status === "failed";
+}
+
 function thinkingCardReactionForStatus(status: TurnViewState["status"]): string | undefined {
   if (status === "completed") return undefined;
   if (status === "failed") return THINKING_CARD_FAILED_REACTION;

package/src/feishu/ownerAccess.ts

@@ -0,0 +1,7 @@
+import type { AppConfig } from "../config/schema.js";
+
+export function allowsFeishuUser(config: AppConfig, userOpenId: string | undefined): boolean {
+  if (config.feishu?.respondToOwnerOnly !== true) return true;
+  const ownerOpenId = config.feishu.userOpenId?.trim();
+  return Boolean(ownerOpenId && userOpenId === ownerOpenId);
+}

package/src/feishu/types.ts

@@ -9,6 +9,7 @@ export interface IncomingMessage {
   threadId?: string;
   rootMessageId?: string;
   parentMessageId?: string;
+  mentionedBot?: true;
   text: string;
   images?: IncomingImageReference[];
 }
@@ -53,6 +54,7 @@ export interface FeishuOutbound {
   deleteReaction?(messageId: string, reactionId: string): Promise<void>;
   downloadImage?(messageId: string, imageKey: string): Promise<string>;
   sendText(contextKey: string, text: string): Promise<string | undefined>;
+  sendFile?(contextKey: string, filePath: string): Promise<string | undefined>;
   sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined>;
   sendInteractiveCard(contextKey: string, card: Record<string, unknown>): Promise<string | undefined>;
   replyText?(
@@ -61,6 +63,11 @@ export interface FeishuOutbound {
     text: string,
     idempotencyKey?: string,
   ): Promise<string | undefined>;
+  replyFile?(
+    contextKey: string,
+    target: MessageReplyTarget,
+    filePath: string,
+  ): Promise<string | undefined>;
   replyMarkdown?(
     contextKey: string,
     target: MessageReplyTarget,

package/src/index.ts

@@ -19,7 +19,7 @@ import { ConsoleFeishuClient } from "./feishu/ConsoleFeishuClient.js";
 import { FeishuConnector } from "./feishu/FeishuConnector.js";
 import { FeishuMessageClient } from "./feishu/FeishuMessageClient.js";
 import { FeishuTurnPresenter } from "./feishu/FeishuTurnPresenter.js";
-import { baseChatContextKey, isThreadContextKey } from "./feishu/contextKey.js";
+import { isThreadContextKey } from "./feishu/contextKey.js";
 import type { MessageReplyTarget } from "./feishu/types.js";
 import { requireServerFeishuTransport } from "./feishu/transport.js";
 import { createLogger } from "./logging/logger.js";
@@ -34,8 +34,10 @@ import { startFeishu } from "./startup/startFeishu.js";
 import { STOP_EXIT_CODE } from "./supervision/restartPolicy.js";
 import {
   RESTART_GROUP_CONTEXTS_ENV,
+  RESTART_NOTIFICATION_TARGETS_ENV,
   replacementSupervisorEnvironment,
   restartGroupContextKeysFromEnvironment,
+  restartNotificationTargetsFromEnvironment,
 } from "./supervision/replacementSupervisor.js";
 import { SafeRestartScheduler } from "./supervision/SafeRestartScheduler.js";
 import type { RestartNotificationTarget } from "./supervision/SafeRestartScheduler.js";
@@ -52,8 +54,10 @@ const agentBotVersion = readPackageVersion();
 const supervised = process.env.AGENT_BOT_SUPERVISED === "1";
 const startupReason = process.env.AGENT_BOT_RESTART_REASON?.trim()
   || (supervised ? "Supervisor 启动" : "直接启动");
-const restartGroupContextKeys = restartGroupContextKeysFromEnvironment(
-  process.env[RESTART_GROUP_CONTEXTS_ENV],
+const restartNotificationTargets = mergeRestartNotificationTargets(
+  restartNotificationTargetsFromEnvironment(process.env[RESTART_NOTIFICATION_TARGETS_ENV]),
+  restartGroupContextKeysFromEnvironment(process.env[RESTART_GROUP_CONTEXTS_ENV])
+    .map((contextKey) => ({ contextKey })),
 );
 const consoleOnly = process.env.AGENT_BOT_CONSOLE_ONLY === "1";
 const config = loadConfig();
@@ -80,7 +84,7 @@ let serverReady = false;
 
 const feishuOutbound = transport === "sdk" ? new FeishuMessageClient(config, logger) : undefined;
 if (feishuOutbound) {
-  const renderer = new CardRenderer();
+  const renderer = new CardRenderer({ thinkingCardLayout: config.feishu.thinkingCardLayout });
   const presenter = new FeishuTurnPresenter(feishuOutbound, store, renderer, {
     normalIntervalMs: 2_000,
     criticalGapMs: 500,
@@ -170,13 +174,16 @@ if (feishuConnector && startupNotifier) {
     startupReason,
     startControlServer,
     () => { serverReady = true; },
-    restartGroupContextKeys,
+    restartNotificationTargets,
   );
 } else {
   await startControlServer();
   await feishuConnector?.start();
   serverReady = true;
 }
+await controller.recoverInterruptedTasks().catch((error: unknown) => {
+  logger.error({ error }, "Startup task recovery failed; the server will remain available.");
+});
 consoleConnector?.start();
 
 async function requestRestart(
@@ -222,7 +229,6 @@ async function initiateRestart(
     notificationTargets,
     safeRestartNotifier?.getNotificationTargets() ?? [],
   );
-  const restartGroupContextKeys = groupContextKeysForRestartTargets(allNotificationTargets);
   await sendRestartTexts(
     allNotificationTargets,
     "Agent Bot 正在重启，恢复在线后会发送启动状态通知。",
@@ -230,7 +236,7 @@ async function initiateRestart(
   setTimeout(() => void shutdown(
     supervised ? STOP_EXIT_CODE : 0,
     reason,
-    restartGroupContextKeys,
+    allNotificationTargets,
   ), 100);
 }
 
@@ -317,7 +323,7 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
 async function shutdown(
   exitCode: number,
   restartReason?: string,
-  restartGroupContextKeys: string[] = [],
+  restartNotificationTargets: RestartNotificationTarget[] = [],
 ): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
@@ -333,11 +339,14 @@ async function shutdown(
   runtimes.close();
   await controlServer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close local control endpoint."));
   store.close();
-  if (restartReason) startReplacementSupervisor(restartReason, restartGroupContextKeys);
+  if (restartReason) startReplacementSupervisor(restartReason, restartNotificationTargets);
   process.exit(exitCode);
 }
 
-function startReplacementSupervisor(restartReason: string, restartGroupContextKeys: string[]): void {
+function startReplacementSupervisor(
+  restartReason: string,
+  restartNotificationTargets: RestartNotificationTarget[],
+): void {
   const supervisorEntry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
   const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
   prepareCrashReportDirectory(reportDirectory);
@@ -361,7 +370,7 @@ function startReplacementSupervisor(restartReason: string, restartGroupContextKe
     env: replacementSupervisorEnvironment(
       restartReason,
       environmentRefresh.environment,
-      restartGroupContextKeys,
+      restartNotificationTargets,
     ),
   });
   supervisor.unref();
@@ -430,15 +439,6 @@ async function sendRestartTexts(targets: RestartNotificationTarget[], text: stri
   }));
 }
 
-function groupContextKeysForRestartTargets(targets: RestartNotificationTarget[]): string[] {
-  const knownGroupContextKeys = new Set(
-    store.listChatContexts("group").map((chat) => chat.contextKey),
-  );
-  return [...new Set(targets
-    .map((target) => baseChatContextKey(target.contextKey))
-    .filter((contextKey) => knownGroupContextKeys.has(contextKey)))];
-}
-
 function mergeRestartNotificationTargets(
   ...targetGroups: RestartNotificationTarget[][]
 ): RestartNotificationTarget[] {

package/src/presentation/OutboundRouter.ts

@@ -23,8 +23,9 @@ export interface TurnPresenter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
-  ): Promise<void>;
+  ): Promise<string | undefined>;
   failPendingTurn(sessionId: string, message: string): Promise<void>;
+  interruptTurnForRecovery(sessionId: string, contextKey: string, turnId: string, message: string): Promise<void>;
   appendSteerMessage(sessionId: string, turnId: string, text: string, messageId?: string): Promise<void>;
   onEvent(event: AgentEvent): Promise<void>;
   showDetails(contextKey: string, turnId: string): Promise<void>;
@@ -75,6 +76,10 @@ export class OutboundRouter {
     return this.sessionReplyTargets.get(sessionId);
   }
 
+  canRoute(contextKey: string): boolean {
+    return this.routes.some((route) => route.matches(contextKey));
+  }
+
   updateSessionTitle(sessionId: string, taskTitle: string): void {
     this.sessionRoutes.get(sessionId)?.presenter.updateSessionTitle(sessionId, taskTitle);
   }
@@ -93,19 +98,28 @@ export class OutboundRouter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
-  ): Promise<void> {
+  ): Promise<string | undefined> {
     const route = this.route(contextKey);
     this.sessionRoutes.set(sessionId, route);
     this.sessionContextKeys.set(sessionId, contextKey);
     if (replyTarget) this.sessionReplyTargets.set(sessionId, replyTarget);
     else this.sessionReplyTargets.delete(sessionId);
-    await route.presenter.startPendingTurn(sessionId, contextKey, taskTitle, replyTarget, prompt);
+    return route.presenter.startPendingTurn(sessionId, contextKey, taskTitle, replyTarget, prompt);
   }
 
   async failPendingTurn(sessionId: string, message: string): Promise<void> {
     await this.sessionRoutes.get(sessionId)?.presenter.failPendingTurn(sessionId, message);
   }
 
+  async interruptTurnForRecovery(
+    sessionId: string,
+    contextKey: string,
+    turnId: string,
+    message: string,
+  ): Promise<void> {
+    await this.route(contextKey).presenter.interruptTurnForRecovery(sessionId, contextKey, turnId, message);
+  }
+
   async appendSteerMessage(
     sessionId: string,
     turnId: string,
@@ -175,6 +189,17 @@ export class OutboundRouter {
       : outbound.sendText(contextKey, text);
   }
 
+  sendFile(contextKey: string, filePath: string): Promise<string | undefined> {
+    const outbound = this.route(contextKey).outbound;
+    const target = this.currentReplyTarget(contextKey);
+    if (target) {
+      if (!outbound.replyFile) throw new Error("当前消息通道不支持在话题中发送文件。");
+      return outbound.replyFile(contextKey, target, filePath);
+    }
+    if (!outbound.sendFile) throw new Error("当前消息通道不支持发送文件。");
+    return outbound.sendFile(contextKey, filePath);
+  }
+
   sendMarkdown(contextKey: string, markdown: string): Promise<string | undefined> {
     const outbound = this.route(contextKey).outbound;
     const target = this.currentReplyTarget(contextKey);