@xmanrui/dsh-im 4.23.0 → 4.24.1

package/src/channels/feishu/bridge.mjs

@@ -115,6 +115,7 @@ import {
   FEISHU_STEP_PUSH_MODES,
   normalizeFeishuStepPushMode,
 } from './step-push-mode.mjs';
+import { FeishuLiveCot } from './live-cot.mjs';
 
 // Lazily evaluated: t() must run after setImHostLanguage, not at import time.
 const INTERACTION_RESOLVED_TEXT = () => t('这个问题已在其他客户端处理，无需再次回答。');
@@ -123,6 +124,7 @@ const RESOLVED_REPLY_TTL_MS = 30 * 60_000;
 const ROOT_CANDIDATE_TTL_MS = 30 * 60_000;
 /** Bound main-feed roots awaiting a topic so silent drops cannot grow them. */
 const MAX_ROOT_CANDIDATES = 512;
+const MAX_TOPIC_ANCHORS = 4_000;
 
 const MENU_COMMAND = /^\/m(?:enu)?$/i;
 const REPAIR_COMMAND_PREFIX = /^\/repair(?:\s|$)/i;
@@ -607,7 +609,7 @@ export class FeishuHarnessBridge {
   #groupTopicReply = false;
   /** When true, streaming turns push tool calls and interim notes as discrete messages. */
   #stepPush = false;
-  /** Step push presentation: 'post' (discrete messages) or 'streaming_card'. */
+  /** Step push presentation: discrete posts, a CardKit card, or native live CoT. */
   #stepPushMode = FEISHU_STEP_PUSH_MODES.POST;
   /** Per-conversation step push state: key → { lastSentAt, count, breakerLogged }. */
   #stepPushSendState = new Map();
@@ -623,6 +625,8 @@ export class FeishuHarnessBridge {
   #anchorTopicReply = new Map();
   /** Main-feed roots this bot intends to auto-open as topics, awaiting thread_id. */
   #rootCandidates = new Map();
+  /** Last successfully injected topic root per conversation and AI session. */
+  #topicAnchors = new Map();
   #repair;
   #repairAttempt = null;
   #repairMonitorVersion = 0;
@@ -4874,6 +4878,72 @@ export class FeishuHarnessBridge {
     };
   }
 
+  async #preparePrompt(event, key, message) {
+    const snapshot = this.#acceptedMessageIds.get(event.message.message_id);
+    const build = async (input) => {
+      const rich = hasInboundImages(input) || hasReplyReference(input);
+      const original = rich
+        ? await promptContentForInboundMessage(input, { signal: this.#signal, deferImages: true })
+        : input.content;
+      const enhanced = enhanceContextContent(original, snapshot, () => ({
+        channel: 'feishu',
+        senderId: senderOpenId(event),
+        chatId: event.message.chat_id,
+        threadId: event.message.thread_id,
+      }));
+      return {
+        content: rich || enhanced !== original ? enhanced : undefined,
+        contextEnhanced: enhanced !== original,
+        sourceGuidance: snapshot?.config?.guidance,
+      };
+    };
+    const rootId = nonEmptyString(event.message.root_id);
+    const topicAnchor = event.message.chat_type === 'group'
+      && nonEmptyString(event.message.thread_id)
+      && rootId && message.replyTo?.messageId === rootId
+      // A reference-only message must not become an empty prompt.
+      && (nonEmptyString(message.content) || hasInboundImages(message) || hasInboundFiles(message));
+    if (!topicAnchor) return build(message);
+
+    const withoutAnchor = { ...message };
+    delete withoutAnchor.replyTo;
+    const base = await build(withoutAnchor);
+    let preparedSessionId;
+    let anchorLoaded = false;
+    return {
+      ...base,
+      prepareContent: async ({ sessionId }) => {
+        preparedSessionId = sessionId;
+        anchorLoaded = false;
+        const previous = this.#topicAnchors.get(key);
+        if (previous?.sessionId === sessionId && previous.rootMessageId === rootId) {
+          return base.content ?? message.content;
+        }
+        const prepared = await build({
+          ...message,
+          replyTo: {
+            ...message.replyTo,
+            load: async (options) => {
+              const reference = await message.replyTo.load(options);
+              anchorLoaded = !reference?.unavailableReason && Boolean(
+                nonEmptyString(reference?.content) || reference?.attachments?.length,
+              );
+              return reference;
+            },
+          },
+        });
+        return prepared.content;
+      },
+      onAskComplete: (sessionId) => {
+        if (!anchorLoaded || sessionId !== preparedSessionId) return;
+        if (!this.#topicAnchors.has(key) && this.#topicAnchors.size >= MAX_TOPIC_ANCHORS) {
+          this.#topicAnchors.delete(this.#topicAnchors.keys().next().value);
+        }
+        this.#topicAnchors.set(key, { sessionId, rootMessageId: rootId });
+      },
+    };
+  }
+
   /**
    * 分步直推：`#answerWithStream` 流式分支在开关开启时的完整替代路径。
    * 过程（工具调用、助手中间说明）与最终答案均以富文本 post 逐条直推
@@ -4885,30 +4955,18 @@ export class FeishuHarnessBridge {
     const messageId = event.message.message_id;
     const text = message.content;
     let askCompleted = false;
-    const markAskComplete = () => {
+    const markAskComplete = (sessionId) => {
       if (askCompleted) return;
       askCompleted = true;
+      prompt.onAskComplete?.(sessionId);
       this.#endImTurn(key);
       onAskComplete?.();
     };
     // 与流式分支一致的提示内容构造：图片与回复引用展开为富提示内容，已接受
     // 的上下文增强按原样重放。直推分流发生在 `#answerWithStream` 构造之前，
     // 这里就是本回合唯一一次构造（无重复的 prompt 往返）。
-    let content = hasInboundImages(message) || hasReplyReference(message)
-      ? await promptContentForInboundMessage(message, { signal: this.#signal, deferImages: true })
-      : undefined;
-    const snapshot = this.#acceptedMessageIds.get(messageId);
-    let contextEnhanced = false;
-    if (snapshot) {
-      const originalContent = content ?? text;
-      content = enhanceContextContent(originalContent, snapshot, () => ({
-        channel: 'feishu',
-        senderId: senderOpenId(event),
-        chatId: event.message.chat_id,
-        threadId: event.message.thread_id,
-      }));
-      contextEnhanced = content !== originalContent;
-    }
+    const prompt = await this.#preparePrompt(event, key, message);
+    const { content, contextEnhanced } = prompt;
     // Every turn reopens the per-conversation circuit breaker.
     const priorState = this.#stepPushSendState.get(key);
     if (this.#stepPushSendState.size >= MAX_STEP_PUSH_SEND_STATES && !priorState) {
@@ -4931,6 +4989,19 @@ export class FeishuHarnessBridge {
     // 流式卡片模式：每轮一张过程卡（原地 patch），过程与最终答案都进卡；
     // post 模式维持逐条直推。先预建卡片状态，纯问答回合也能在收尾时开卡。
     const streamingCard = this.#stepPushMode === FEISHU_STEP_PUSH_MODES.STREAMING_CARD;
+    const liveCot = this.#stepPushMode === FEISHU_STEP_PUSH_MODES.LIVE_COT
+      && typeof this.#channel?.createCot === 'function'
+      && typeof this.#channel?.writeCotEvents === 'function';
+    const cot = liveCot
+      ? new FeishuLiveCot(this.#channel, chatId, {
+          replyTo: messageId,
+          hidden: false,
+          onFailure: (error) => this.#logger.warn?.(
+            '[dsh-feishu] native live process failed; final answer will continue:',
+            error?.message ?? String(error),
+          ),
+        })
+      : null;
     if (streamingCard) {
       if (this.#stepCards.has(key)) {
         // 上一轮异常退出留下的「运行中」卡片先收尾，避免与本轮混淆。
@@ -4983,7 +5054,9 @@ export class FeishuHarnessBridge {
         messageId,
       );
     };
-    const watchdog = streamingCard ? null : this.#startThinkingStatusWatchdog(key, chatId, messageId);
+    const watchdog = streamingCard || liveCot
+      ? null
+      : this.#startThinkingStatusWatchdog(key, chatId, messageId);
     let completed;
     try {
       completed = await askInWorkspaceSession({
@@ -4994,13 +5067,14 @@ export class FeishuHarnessBridge {
       text,
       content,
       titleText: event.batchSubmission?.title,
-      sourceGuidance: snapshot?.config?.guidance,
+      sourceGuidance: prompt.sourceGuidance,
+      prepareContent: prompt.prepareContent,
       contextEnhanced,
       createOptions: { signal: this.#signal },
       existsOptions: { signal: this.#signal },
       askOptions: {
         ...baseAskOptions,
-        progressMode: 'all',
+        progressMode: liveCot ? 'live' : 'all',
         // 提问/审批卡弹出前先定格当前过程卡，答案随之流到交互消息之后
         // 的新卡上（与主流式路径的 rotate 语义一致）。
         ...(streamingCard ? {
@@ -5012,6 +5086,15 @@ export class FeishuHarnessBridge {
           },
         } : {}),
         onUpdate: async (update) => {
+          if (liveCot) {
+            await cot.handle(update);
+            if (update.type === 'assistant-message') {
+              pendingStep = update;
+            } else if (update.type === 'tool') {
+              pendingStep = null;
+            }
+            return;
+          }
           if (update.type === 'assistant-message') {
             if (pendingStep && Number(update.step) > Number(pendingStep.step)) {
               await flushPendingStep();
@@ -5054,6 +5137,7 @@ export class FeishuHarnessBridge {
       },
       });
     } catch (error) {
+      await cot?.finish(error);
       if (streamingCard) {
         this.#stepStopFlags.delete(key);
         await this.#finishStepCard(key, { stopped: true });
@@ -5063,7 +5147,8 @@ export class FeishuHarnessBridge {
       // 回合结束（成功/失败/中断）：停看门狗并撤回残留思考中心跳。
       await watchdog?.stop();
     }
-    markAskComplete();
+    markAskComplete(completed.sessionId);
+    await cot?.finish();
     const finalStepText = pendingStep ? pendingStep.text : null;
     pendingStep = null;
     const finalText = (typeof finalStepText === 'string' && finalStepText.trim())
@@ -5130,7 +5215,7 @@ export class FeishuHarnessBridge {
       }
       textReceipt = createDeliveryReceipt({
         deliveryId: messageId,
-        presentation: 'feishu-step-push-post',
+        presentation: liveCot ? 'feishu-live-cot-answer' : 'feishu-step-push-post',
         providerMessageIds,
       });
       this.#status.streamResponses = (this.#status.streamResponses ?? 0) + 1;
@@ -5201,9 +5286,10 @@ export class FeishuHarnessBridge {
     const messageId = event.message.message_id;
     const text = message.content;
     let askCompleted = false;
-    const markAskComplete = () => {
+    const markAskComplete = (sessionId) => {
       if (askCompleted) return;
       askCompleted = true;
+      prompt.onAskComplete?.(sessionId);
       this.#endImTurn(key);
       onAskComplete?.();
     };
@@ -5214,23 +5300,10 @@ export class FeishuHarnessBridge {
     if (this.#stepPush && this.#channel?.stream) {
       return this.#answerWithStepPush(event, key, message, { onAskComplete });
     }
-    let content = hasInboundImages(message) || hasReplyReference(message)
-      ? await promptContentForInboundMessage(message, { signal: this.#signal, deferImages: true })
-      : undefined;
-    const snapshot = this.#acceptedMessageIds.get(messageId);
-    let contextEnhanced = false;
-    if (snapshot) {
-      const originalContent = content ?? text;
-      content = enhanceContextContent(originalContent, snapshot, () => ({
-        channel: 'feishu',
-        senderId: senderOpenId(event),
-        chatId: event.message.chat_id,
-        threadId: event.message.thread_id,
-      }));
-      contextEnhanced = content !== originalContent;
-    }
+    const prompt = await this.#preparePrompt(event, key, message);
+    const { content, contextEnhanced } = prompt;
     if (!this.#channel?.stream) {
-      const { answer, artifacts = [] } = await askInWorkspaceSession({
+      const { sessionId, answer, artifacts = [] } = await askInWorkspaceSession({
         deferredDelivery: () => ({ coordinator: this.#deferred, chatId, replyToMessageId: messageId }),
         harness: this.#harness,
         state: this.#state,
@@ -5238,13 +5311,14 @@ export class FeishuHarnessBridge {
         text,
         content,
         titleText: event.batchSubmission?.title,
-        sourceGuidance: snapshot?.config?.guidance,
+        sourceGuidance: prompt.sourceGuidance,
+        prepareContent: prompt.prepareContent,
         contextEnhanced,
         createOptions: { signal: this.#signal },
         existsOptions: { signal: this.#signal },
         askOptions: this.#interactionAskOptions(event, key, message.files, message.images),
       });
-      markAskComplete();
+      markAskComplete(sessionId);
       let textReceipt;
       let textSendError = null;
       try {
@@ -5319,13 +5393,14 @@ export class FeishuHarnessBridge {
             text,
             content,
             titleText: event.batchSubmission?.title,
-            sourceGuidance: snapshot?.config?.guidance,
+            sourceGuidance: prompt.sourceGuidance,
+            prepareContent: prompt.prepareContent,
             contextEnhanced,
             createOptions: { signal: this.#signal },
             existsOptions: { signal: this.#signal },
             askOptions,
           });
-          markAskComplete();
+          markAskComplete(completed.sessionId);
           completedAnswer = completed.answer;
           completedArtifacts = completed.artifacts ?? [];
           await controller.setContent(answerTextForDelivery(completedAnswer, completedArtifacts));
@@ -5383,7 +5458,7 @@ export class FeishuHarnessBridge {
       if (promptStarted) throw error;
 
       this.#logger.warn?.('[dsh-feishu] native stream unavailable; using text fallback:', error.message);
-      const { answer, artifacts = [] } = await askInWorkspaceSession({
+      const { sessionId, answer, artifacts = [] } = await askInWorkspaceSession({
         deferredDelivery: () => ({ coordinator: this.#deferred, chatId, replyToMessageId: messageId }),
         harness: this.#harness,
         state: this.#state,
@@ -5391,13 +5466,14 @@ export class FeishuHarnessBridge {
         text,
         content,
         titleText: event.batchSubmission?.title,
-        sourceGuidance: snapshot?.config?.guidance,
+        sourceGuidance: prompt.sourceGuidance,
+        prepareContent: prompt.prepareContent,
         contextEnhanced,
         createOptions: { signal: this.#signal },
         existsOptions: { signal: this.#signal },
         askOptions: this.#interactionAskOptions(event, key, message.files, message.images),
       });
-      markAskComplete();
+      markAskComplete(sessionId);
       let textReceipt;
       let textSendError = null;
       try {

package/src/channels/feishu/feishu-channel.mjs

@@ -8,6 +8,7 @@ const STREAM_ELEMENT_ID = 'stream_md';
 const DEFAULT_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
 const MAX_STREAM_CHARS = 28000;
 const MAX_FILE_OPERATION_TIMEOUT_MS = 120_000;
+const COT_API = '/open-apis/im/v1/message_cot';
 
 const FILE_DELIVERY_ERRORS = new Map([
   [99991672, ['artifact-permission-required', 'Feishu file delivery requires the im:resource permission.']],
@@ -365,6 +366,40 @@ export class VerifiedFeishuChannel {
     });
   }
 
+  /** Open one native Feishu thinking-process message. */
+  async createCot(chatId, { replyTo, hidden = false } = {}) {
+    const response = assertApiSuccess('Feishu message_cot.create', await this.#client.request({
+      method: 'POST',
+      url: `${COT_API}?receive_id_type=chat_id`,
+      data: {
+        receive_id: chatId,
+        ...(replyTo ? { origin_message_id: replyTo } : {}),
+        cot_hidden: hidden === true,
+        enable_badge: false,
+        update_feed_rank: false,
+      },
+    }));
+    const cotId = response?.data?.cot_id;
+    const messageId = response?.data?.message_id;
+    if (!cotId || !messageId) {
+      throw new Error('Feishu message_cot.create returned no cot_id/message_id');
+    }
+    return { cotId, messageId };
+  }
+
+  /** Append ordered AG-UI events to one native thinking process. */
+  async writeCotEvents(handle, events) {
+    assertApiSuccess('Feishu message_cot.write', await this.#client.request({
+      method: 'PUT',
+      url: COT_API,
+      data: {
+        events,
+        message_id: handle.messageId,
+        cot_id: handle.cotId,
+      },
+    }));
+  }
+
   async #sendArtifact(chatId, file, {
     replyTo,
     signal,

package/src/channels/feishu/live-cot.mjs

@@ -0,0 +1,260 @@
+const MAX_EVENTS_PER_WRITE = 50;
+const MAX_EVENT_CONTENT_CHARS = 4096;
+const MAX_TOOL_RESULT_CHARS = 1500;
+
+const TOOL_ICONS = Object.freeze({
+  read: 'read',
+  edit: 'write',
+  delete: 'write',
+  move: 'write',
+  search: 'search',
+  fetch: 'search',
+  execute: 'bash',
+});
+
+let lastTimestamp = 0;
+
+function boundedEventContent(content) {
+  const encoded = JSON.stringify(content);
+  if (encoded.length <= MAX_EVENT_CONTENT_CHARS) return encoded;
+  const field = typeof content?.delta === 'string'
+    ? 'delta'
+    : typeof content?.message === 'string' ? 'message' : null;
+  if (!field) return JSON.stringify({ ...content, truncated: true });
+
+  const truncated = { ...content, truncated: true, [field]: content[field] };
+  while (truncated[field].length > 0
+    && JSON.stringify(truncated).length > MAX_EVENT_CONTENT_CHARS) {
+    truncated[field] = truncated[field].slice(0, Math.max(0, truncated[field].length - 256));
+  }
+  if (truncated[field].length === 0
+    && JSON.stringify(truncated).length > MAX_EVENT_CONTENT_CHARS) {
+    return JSON.stringify({ truncated: true });
+  }
+  return JSON.stringify(truncated);
+}
+
+function cotEvent(eventType, content) {
+  lastTimestamp = Math.max(Date.now(), lastTimestamp + 1);
+  return {
+    event_type: eventType,
+    content: boundedEventContent(content),
+    timestamp: String(lastTimestamp),
+  };
+}
+
+function boundedResult(value) {
+  const text = String(value ?? '');
+  return text.length <= MAX_TOOL_RESULT_CHARS
+    ? text
+    : `${text.slice(0, MAX_TOOL_RESULT_CHARS - 1)}…`;
+}
+
+function toolKind(name) {
+  const value = String(name ?? '').toLowerCase();
+  if (/read|view|list|get/.test(value)) return 'read';
+  if (/edit|write|create|patch|update/.test(value)) return 'edit';
+  if (/delete|remove/.test(value)) return 'delete';
+  if (/move|rename/.test(value)) return 'move';
+  if (/search|grep|glob|find/.test(value)) return 'search';
+  if (/fetch|web|http|download/.test(value)) return 'fetch';
+  if (/shell|bash|command|exec|terminal/.test(value)) return 'execute';
+  return '';
+}
+
+function turnFailure(reason) {
+  const kind = typeof reason === 'string' ? reason : reason?.kind;
+  if (reason === null || reason === undefined || kind === 'completed') return null;
+  if (kind !== 'error') {
+    return kind ? `Turn ended: ${kind}` : 'Turn failed';
+  }
+  const error = reason.error ?? reason.failure;
+  if (!error) return 'Turn failed';
+  return [error.code, error.message].filter(Boolean).join(': ') || 'Turn failed';
+}
+
+/**
+ * Maps Harness progress updates to Feishu's native thinking-process events.
+ * Process failures are contained here so they can never suppress the answer.
+ */
+export class FeishuLiveCot {
+  #channel;
+  #chatId;
+  #replyTo;
+  #hidden;
+  #onFailure;
+  #turn = null;
+  #opening = null;
+  #chain = Promise.resolve();
+  #pending = [];
+  #reasoningOpen = false;
+  #heldAssistant = null;
+  #finished = false;
+  #broken = false;
+  #messageIndex = 0;
+
+  constructor(channel, chatId, {
+    replyTo,
+    hidden = false,
+    onFailure = () => {},
+  } = {}) {
+    this.#channel = channel;
+    this.#chatId = chatId;
+    this.#replyTo = replyTo;
+    this.#hidden = hidden === true;
+    this.#onFailure = onFailure;
+  }
+
+  async #start(turn) {
+    if (this.#turn !== null || this.#broken) return;
+    this.#turn = Number.isSafeInteger(turn) ? turn : 0;
+    this.#opening = this.#channel.createCot(this.#chatId, {
+      ...(this.#replyTo ? { replyTo: this.#replyTo } : {}),
+      hidden: this.#hidden,
+    }).catch((error) => {
+      this.#broken = true;
+      this.#onFailure(error);
+      return null;
+    });
+    await this.#write([
+      cotEvent('RUN_STARTED', {
+        threadId: this.#chatId,
+        runId: `turn-${this.#turn}`,
+      }),
+    ]);
+  }
+
+  #write(events) {
+    if (this.#broken || events.length === 0) return;
+    this.#pending.push(...events);
+    this.#chain = this.#chain.then(async () => {
+      const handle = await this.#opening;
+      if (!handle || this.#broken) {
+        this.#pending.length = 0;
+        return;
+      }
+      while (this.#pending.length > 0) {
+        await this.#channel.writeCotEvents(
+          handle,
+          this.#pending.splice(0, MAX_EVENTS_PER_WRITE),
+        );
+      }
+    }).catch((error) => {
+      this.#broken = true;
+      this.#pending.length = 0;
+      this.#onFailure(error);
+    });
+  }
+
+  async #closeReasoning() {
+    if (!this.#reasoningOpen) return;
+    this.#reasoningOpen = false;
+    await this.#write([
+      cotEvent('REASONING_MESSAGE_END', {
+        messageId: `reasoning-${this.#turn}`,
+      }),
+    ]);
+  }
+
+  async #flushHeldAssistant() {
+    const held = this.#heldAssistant;
+    this.#heldAssistant = null;
+    if (!held?.text) return;
+    const messageId = `text-${this.#turn}-${this.#messageIndex++}`;
+    await this.#write([
+      cotEvent('TEXT_MESSAGE_START', { messageId, role: 'assistant' }),
+      cotEvent('TEXT_MESSAGE_CONTENT', { messageId, delta: held.text }),
+      cotEvent('TEXT_MESSAGE_END', { messageId }),
+    ]);
+  }
+
+  async handle(update) {
+    if (!update || this.#finished || this.#broken) return;
+    if (update.type === 'turn-start') {
+      await this.#start(update.turn);
+      return;
+    }
+    await this.#start(update.turn);
+    if (update.type === 'reasoning') {
+      if (!update.text) return;
+      const messageId = `reasoning-${this.#turn}`;
+      if (!this.#reasoningOpen) {
+        this.#reasoningOpen = true;
+        await this.#write([
+          cotEvent('REASONING_MESSAGE_START', { messageId, role: 'reasoning' }),
+        ]);
+      }
+      await this.#write([
+        cotEvent('REASONING_MESSAGE_CONTENT', { messageId, delta: update.text }),
+      ]);
+      return;
+    }
+    if (update.type === 'assistant-message') {
+      if (this.#heldAssistant) await this.#flushHeldAssistant();
+      this.#heldAssistant = update;
+      return;
+    }
+    if (update.type === 'tool') {
+      await this.#flushHeldAssistant();
+      await this.#closeReasoning();
+      const toolCallId = update.callId ?? `tool-${this.#turn}-${this.#messageIndex++}`;
+      const kind = toolKind(update.name);
+      await this.#write([
+        cotEvent('TOOL_CALL_START', {
+          toolCallId,
+          icon: TOOL_ICONS[kind] ?? 'default',
+          title: update.name || 'Tool',
+          toolCallName: update.name || 'tool',
+        }),
+        cotEvent('TOOL_CALL_ARGS', {
+          toolCallId,
+          delta: update.arguments ?? '',
+        }),
+        cotEvent('TOOL_CALL_END', { toolCallId }),
+      ]);
+      return;
+    }
+    if (update.type === 'tool-result' && update.callId) {
+      await this.#write([
+        cotEvent('TOOL_CALL_RESULT', {
+          messageId: `result-${update.callId}`,
+          toolCallId: update.callId,
+          role: 'tool',
+          content: { type: 'code', code: boundedResult(update.text) },
+          ...(update.errorCode ? { error: update.errorCode } : {}),
+        }),
+      ]);
+      return;
+    }
+    if (update.type === 'turn-end') {
+      await this.finish(update.reason);
+    }
+  }
+
+  async finish(reason) {
+    if (this.#finished) {
+      await this.#chain;
+      return;
+    }
+    this.#finished = true;
+    this.#heldAssistant = null;
+    if (this.#turn === null || this.#broken) {
+      await this.#chain;
+      return;
+    }
+    await this.#closeReasoning();
+    const failure = reason instanceof Error
+      ? reason.message
+      : turnFailure(reason);
+    await this.#write([
+      failure
+        ? cotEvent('RUN_ERROR', { message: failure, code: 'TURN_FAILED' })
+        : cotEvent('RUN_FINISHED', {
+            threadId: this.#chatId,
+            runId: `turn-${this.#turn}`,
+            status: 'done',
+          }),
+    ]);
+    await this.#chain;
+  }
+}

package/src/channels/feishu/slash-command-registry.mjs

@@ -50,6 +50,23 @@ export const SLASH_COMMAND_MANIFEST = Object.freeze([
   { command: 'unwatch', icon: 'clear_outlined', default: '取消关注会话', en_us: 'Unwatch a session' },
   { command: 'watchlist', icon: 'flag_outlined', default: '查看关注列表', en_us: 'List watched sessions' },
   { command: 'archived', icon: 'folder_outlined', default: '设置归档会话显隐（on/off）', en_us: 'Show or hide archived sessions (on/off)' },
+  { command: 'history', icon: 'chat-ai_outlined', default: '查看最近历史消息（仅私聊）', en_us: 'Show recent history (private chats only)' },
+  { command: 'workspace', icon: 'folder_outlined', default: '切换工作区', en_us: 'Switch workspace' },
+  { command: 'conv', icon: 'folder_outlined', default: '设置当前对话专属工作区', en_us: 'Set the workspace for this conversation' },
+  { command: 'session', icon: 'chat-ai_outlined', default: '绑定已有会话', en_us: 'Bind an existing session' },
+  { command: 'models', icon: 'ai-functions_outlined', default: '列出可用模型', en_us: 'List available models' },
+  { command: 'model', icon: 'ai-agent_outlined', default: '查看或切换当前模型', en_us: 'Show or switch the current model' },
+  { command: 'reasoninglist', icon: 'ai-deepthink_outlined', default: '列出可用推理等级', en_us: 'List available reasoning efforts' },
+  { command: 'reasoning', icon: 'ai-deepthink_outlined', default: '查看或切换推理等级', en_us: 'Show or switch the reasoning effort' },
+  { command: 'presetlist', icon: 'skill_outlined', default: '列出可用 Agent 预设', en_us: 'List available Agent Presets' },
+  { command: 'preset', icon: 'skill_outlined', default: '查看或切换 Agent 预设', en_us: 'Show or switch the Agent Preset' },
+  { command: 'stop', icon: 'clear_outlined', default: '停止当前任务', en_us: 'Stop the current task' },
+  { command: 'steer', icon: 'promptword_outlined', default: '给当前任务补充指令', en_us: 'Send additional instructions to the current task' },
+  { command: 'batch', icon: 'chat-ai_outlined', default: '开始批量输入（仅私聊）', en_us: 'Start batch input (private chats only)' },
+  { command: 'send', icon: 'chat-ai_outlined', default: '提交当前批次（仅私聊）', en_us: 'Submit the current batch (private chats only)' },
+  { command: 'cancel', icon: 'clear_outlined', default: '取消当前批次（仅私聊）', en_us: 'Cancel the current batch (private chats only)' },
+  { command: 'version', icon: 'ai-functions_outlined', default: '查看插件版本', en_us: 'Show the plugin version' },
+  { command: 'repair', icon: 'ai-functions_outlined', default: '补全飞书权限与卡片回调（仅私聊）', en_us: 'Complete Feishu permissions and card callbacks (private chats only)' },
 ]);
 
 // Commands that require a parameter are registered too, so the user can type