@xmanrui/dsh-im 4.23.0 → 4.24.0

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

package/src/channels/feishu/step-push-mode.mjs

@@ -1,6 +1,7 @@
 export const FEISHU_STEP_PUSH_MODES = Object.freeze({
   POST: 'post',
   STREAMING_CARD: 'streaming_card',
+  LIVE_COT: 'live_cot',
 });
 
 /** New connections explicitly opt into the process-card presentation. */
@@ -8,12 +9,17 @@ export const DEFAULT_FEISHU_STEP_PUSH_MODE = FEISHU_STEP_PUSH_MODES.STREAMING_CA
 
 export function normalizeFeishuStepPushMode(value) {
   // Bots created before modes existed used posts when step push was enabled.
-  return value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD
-    ? FEISHU_STEP_PUSH_MODES.STREAMING_CARD
-    : FEISHU_STEP_PUSH_MODES.POST;
+  if (value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD) {
+    return FEISHU_STEP_PUSH_MODES.STREAMING_CARD;
+  }
+  if (value === FEISHU_STEP_PUSH_MODES.LIVE_COT) {
+    return FEISHU_STEP_PUSH_MODES.LIVE_COT;
+  }
+  return FEISHU_STEP_PUSH_MODES.POST;
 }
 
 export function isFeishuStepPushMode(value) {
   return value === FEISHU_STEP_PUSH_MODES.POST
-    || value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD;
+    || value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD
+    || value === FEISHU_STEP_PUSH_MODES.LIVE_COT;
 }