@wu529778790/open-im 1.5.2-beta.2 → 1.5.2-beta.4

package/README.md

@@ -8,7 +8,8 @@
 - 多 AI 工具：支持 Claude、Codex、Cursor
 - 流式输出：实时回传 AI 回复与工具执行进度
 - 会话隔离：每个用户独立维护本地会话，`/new` 可重置
-- 常用命令：支持 `/help`、`/new`、`/cd`、`/pwd`、`/status`
+- 权限模式：支持 `ask`、`accept-edits`、`plan`、`yolo`
+- 常用命令：支持 `/help`、`/mode`、`/new`、`/cd`、`/pwd`、`/status`
 
 ## 环境要求
 
@@ -184,16 +185,26 @@ Claude 默认使用 Agent SDK，不依赖本地 `claude` 可执行文件；通
 说明：钉钉当前采用“Stream Mode 收消息 + OpenAPI 发送消息”的混合模式。
 
 - 会话内普通文本回复默认走 `sessionWebhook`
-- 若配置了 `cardTemplateId`，会尝试 AI 助理 `prepare/update/finish` 流式卡片；失败则 fallback 为普通文本（自定义机器人/普通群场景下互动卡片 API 报 param.error，暂不支持单条流式更新）
+- 如果配置了 `cardTemplateId` / `DINGTALK_CARD_TEMPLATE_ID`，AI 回复会升级为单条 `ai_card` 流式更新（`prepare / update / finish`）
 - 启动/关闭通知会发给最近一次已互动的钉钉会话；如果服务冷启动后还没有任何钉钉会话互动过，则没有可用目标可发
 
-钉钉 AI 卡片模板：已适配官方「搜索结果卡片」模板，使用变量 `lastMessage`、`content`、`resources`、`users`、`flowStatus`。若使用该模板，无需修改模板即可实现流式更新。
+钉钉 AI 卡片模板需至少兼容以下字段，建议模板按这些 key 取值：
+
+- `title`
+- `content`
+- `note`
+- `toolName`
+- `status`
+- `flowStatus`
+- `displayText`
 
 ## IM 内命令
 
 | 命令 | 说明 |
 | ---- | ---- |
 | `/help` | 显示帮助 |
+| `/mode` | 飞书显示卡片，Telegram 显示按钮，其它平台（含钉钉）显示文本模式列表 |
+| `/mode <模式>` | 直接切换：`ask` / `accept-edits` / `plan` / `yolo` |
 | `/new` | 开始新会话 |
 | `/status` | 显示 AI 工具、版本、会话目录、会话 ID |
 | `/cd <路径>` | 切换会话目录 |
@@ -201,6 +212,17 @@ Claude 默认使用 Agent SDK，不依赖本地 `claude` 可执行文件；通
 | `/allow` `/y` | 允许权限请求 |
 | `/deny` `/n` | 拒绝权限请求 |
 
+### 权限模式
+
+与 Claude Code 官方命名保持一致，参考 [permissions](https://code.claude.com/docs/en/permissions)：
+
+| 模式 | Claude 名 | 说明 |
+| ---- | --------- | ---- |
+| `ask` | `default` | 首次使用工具时询问 |
+| `accept-edits` | `acceptEdits` | 自动允许编辑 |
+| `plan` | `plan` | 只读分析，不执行命令、不改文件 |
+| `yolo` | `bypassPermissions` | 跳过所有权限确认 |
+
 ## 故障排除
 
 **Telegram 无响应**：检查网络，必要时在 Telegram 平台配置中添加 `"proxy": "http://127.0.0.1:7890"` 或设置 `TELEGRAM_PROXY`。
@@ -211,7 +233,7 @@ Claude 默认使用 Agent SDK，不依赖本地 `claude` 可执行文件；通
 
 **钉钉无法回复**：确认应用已启用机器人 Stream Mode，并检查 `DINGTALK_CLIENT_ID`、`DINGTALK_CLIENT_SECRET` 或 `platforms.dingtalk` 配置是否正确。
 
-**钉钉没有流式更新**：prepare 失败时 fallback 为普通文本回复。自定义机器人/普通群场景下，AI 助理和互动卡片 API 均不可用，仅支持单条文本回复。
+**钉钉没有流式更新**：如果未配置 `DINGTALK_CARD_TEMPLATE_ID`（或 `platforms.dingtalk.cardTemplateId`），会自动退回普通文本回复；配置 AI 卡片模板后才会启用单条流式更新。
 
 **Cursor 报 `Authentication required`**：先执行 `agent login`，或在 `env` 中设置 `CURSOR_API_KEY`。
 

package/dist/adapters/registry.d.ts

@@ -2,4 +2,7 @@ import type { Config } from '../config.js';
 import type { ToolAdapter } from './tool-adapter.interface.js';
 export declare function initAdapters(config: Config): void;
 export declare function getAdapter(aiCommand: string): ToolAdapter | undefined;
+/**
+ * Cleanup all adapter resources.
+ */
 export declare function cleanupAdapters(): void;

package/dist/adapters/registry.js

@@ -14,7 +14,7 @@ export function initAdapters(config) {
             console.log('🚀 使用标准 Claude 适配器');
             adapters.set('claude', new ClaudeAdapter(config.claudeCliPath, {
                 useProcessPool: true,
-                idleTimeoutMs: 2 * 60 * 1000,
+                idleTimeoutMs: 2 * 60 * 1000, // 2 minutes
             }));
         }
     }
@@ -30,8 +30,11 @@ export function initAdapters(config) {
 export function getAdapter(aiCommand) {
     return adapters.get(aiCommand);
 }
+/**
+ * Cleanup all adapter resources.
+ */
 export function cleanupAdapters() {
     ClaudeAdapter.destroy();
-    ClaudeSDKAdapter.destroy();
+    ClaudeSDKAdapter.destroy(); // 清理 SDK 查询
     adapters.clear();
 }

package/dist/codex/cli-runner.d.ts

@@ -1,5 +1,7 @@
 /**
- * Codex CLI Runner - 解析 `codex exec --json` 的 JSONL 输出。
+ * Codex CLI Runner - 解析 codex exec --json 的 JSONL 输出
+ * 参考: https://developers.openai.com/codex/cli/reference/
+ *       https://takopi.dev/reference/runners/codex/exec-json-cheatsheet/
  */
 export interface CodexRunCallbacks {
     onText: (accumulated: string) => void;

package/dist/codex/cli-runner.js

@@ -1,5 +1,7 @@
 /**
- * Codex CLI Runner - 解析 `codex exec --json` 的 JSONL 输出。
+ * Codex CLI Runner - 解析 codex exec --json 的 JSONL 输出
+ * 参考: https://developers.openai.com/codex/cli/reference/
+ *       https://takopi.dev/reference/runners/codex/exec-json-cheatsheet/
  */
 import { spawn } from 'node:child_process';
 import { execFileSync } from 'node:child_process';
@@ -49,6 +51,7 @@ function buildCodexArgs(_prompt, sessionId, workDir, options) {
         : ["exec", ...newSessionOptions, "-"];
 }
 function quoteForWindowsCmd(arg) {
+    // 普通 flag / sessionId / 无空格路径不需要加引号，否则引号可能被原样传给子进程。
     if (/^[A-Za-z0-9_./:=+\\-]+$/.test(arg)) {
         return arg;
     }
@@ -59,6 +62,7 @@ function quoteForWindowsCmd(arg) {
     return `"${escaped}"`;
 }
 function formatWindowsCommandName(command) {
+    // 裸命令名（如 codex）依赖 PATH 查找，不能再包双引号，否则 cmd 会按字面量查找。
     if (/^[A-Za-z0-9_.-]+$/.test(command)) {
         return command;
     }
@@ -114,6 +118,7 @@ function resolveWindowsCodexLaunch(cliPath, args) {
     }
 }
 export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options) {
+    // codex exec --json 非交互模式
     const args = buildCodexArgs(prompt, sessionId, workDir, options);
     const env = {};
     for (const [k, v] of Object.entries(process.env)) {
@@ -133,11 +138,13 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
         env.all_proxy = options.proxy;
     }
     if (process.platform === 'win32') {
+        // 强制子进程在 Windows 下使用 UTF-8，避免中文源码/命令输出乱码。
         env.LANG = env.LANG || 'C.UTF-8';
         env.LC_ALL = env.LC_ALL || 'C.UTF-8';
     }
     const argsForLog = args.join(' ');
     log.info(`Spawning Codex CLI: path=${cliPath}, cwd=${workDir}, session=${sessionId ?? 'new'}, args=${argsForLog}`);
+    // Windows: .cmd/.bat 或简单命令名（如 codex）需通过 cmd.exe 执行，否则 spawn 报 ENOENT
     const isWinCmd = process.platform === 'win32' &&
         (/\.(cmd|bat)$/i.test(cliPath) || cliPath === 'codex');
     const directWindowsLaunch = isWinCmd
@@ -164,11 +171,13 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
         env,
         windowsHide: process.platform === 'win32',
     });
+    // 通过 stdin 传 prompt，避免 Windows 下命令行参数引用导致中文/路径/空格被拆分。
     child.stdin?.write(prompt);
     child.stdin?.end();
     let accumulated = '';
     let accumulatedThinking = '';
     let completed = false;
+    let threadId = '';
     const toolStats = {};
     const startTime = Date.now();
     const MAX_TIMEOUT = 2_147_483_647;
@@ -217,7 +226,7 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
         const type = event.type;
         log.debug(`[Codex event] type=${type}`);
         if (type === 'thread.started') {
-            const threadId = event.thread_id ?? '';
+            threadId = event.thread_id ?? '';
             if (threadId)
                 callbacks.onSessionId?.(threadId);
             return;
@@ -293,6 +302,7 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
             completed = true;
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
+            const usage = event.usage;
             const durationMs = Date.now() - startTime;
             callbacks.onComplete({
                 success: true,

package/dist/dingtalk/client.d.ts

@@ -1,13 +1,6 @@
 import { type DWClientDownStream } from 'dingtalk-stream';
 import type { Config } from '../config.js';
 import type { DingTalkActiveTarget } from '../shared/active-chats.js';
-export interface DingTalkStreamingTarget {
-    chatId: string;
-    conversationType?: string;
-    senderStaffId?: string;
-    senderId?: string;
-    robotCode?: string;
-}
 export declare function registerSessionWebhook(chatId: string, sessionWebhook: string): void;
 export declare function sendText(chatId: string, content: string): Promise<unknown>;
 export declare function sendMarkdown(chatId: string, title: string, text: string): Promise<unknown>;
@@ -15,14 +8,6 @@ export declare function ackMessage(messageId: string, result?: unknown): void;
 export declare function initDingTalk(cfg: Config, eventHandler: (data: DWClientDownStream) => Promise<void>): Promise<void>;
 export declare function stopDingTalk(): void;
 export declare function sendProactiveText(target: string | DingTalkActiveTarget, content: string): Promise<void>;
-export declare function prepareStreamingCard(target: string | DingTalkStreamingTarget, templateId: string, cardData: Record<string, unknown>): Promise<string>;
+export declare function prepareStreamingCard(chatId: string, templateId: string, cardData: Record<string, unknown>): Promise<string>;
 export declare function updateStreamingCard(conversationToken: string, templateId: string, cardData: Record<string, unknown>): Promise<void>;
 export declare function finishStreamingCard(conversationToken: string): Promise<void>;
-/** 创建并投放卡片（卡片平台 API，支持普通群流式更新） */
-export declare function createAndDeliverCard(target: DingTalkStreamingTarget, templateId: string, outTrackId: string, cardData: Record<string, unknown>): Promise<void>;
-/** 更新卡片实例（用于流式更新） */
-export declare function updateCardInstance(outTrackId: string, cardData: Record<string, unknown>): Promise<void>;
-/** 互动卡片普通版：发送（用于 prepare 失败时的 fallback 流式） */
-export declare function sendRobotInteractiveCard(target: DingTalkStreamingTarget, cardBizId: string, cardData: Record<string, unknown>): Promise<void>;
-/** 互动卡片普通版：更新（单条消息流式更新） */
-export declare function updateRobotInteractiveCard(cardBizId: string, cardData: Record<string, unknown>): Promise<void>;

package/dist/dingtalk/client.js

@@ -2,12 +2,10 @@ import { DWClient, TOPIC_ROBOT } from 'dingtalk-stream';
 import { createLogger } from '../logger.js';
 const log = createLogger('DingTalk');
 const DINGTALK_OPENAPI_BASE = 'https://api.dingtalk.com';
-const DINGTALK_OAPI_BASE = 'https://oapi.dingtalk.com';
 const TEXT_MSG_KEY = 'sampleText';
 let client = null;
 let messageHandler = null;
 const sessionWebhookByChat = new Map();
-const unionIdByUserId = new Map();
 function getClient() {
     if (!client) {
         throw new Error('DingTalk client not initialized');
@@ -117,72 +115,9 @@ async function callOpenApi(path, body) {
                 : text;
     throw new Error(`DingTalk OpenAPI business error: ${String(errorCode)} ${errorMessage}`);
 }
-async function callOapi(path, body) {
-    const accessToken = await getClient().getAccessToken();
-    const res = await fetch(`${DINGTALK_OAPI_BASE}${path}?access_token=${encodeURIComponent(String(accessToken))}`, {
-        method: 'POST',
-        headers: {
-            'content-type': 'application/json',
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(30000),
-    });
-    const text = await res.text();
-    if (!res.ok) {
-        throw new Error(`DingTalk OAPI failed: ${res.status} ${text}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        throw new Error(`DingTalk OAPI returned non-JSON response: ${text}`);
-    }
-    const errorCode = parsed.errcode;
-    if (errorCode === 0 || errorCode === '0' || errorCode === undefined) {
-        return parsed;
-    }
-    const errorMessage = typeof parsed.errmsg === 'string'
-        ? parsed.errmsg
-        : typeof parsed.message === 'string'
-            ? parsed.message
-            : text;
-    throw new Error(`DingTalk OAPI business error: ${String(errorCode)} ${errorMessage}`);
-}
 function normalizeConversationType(type) {
     return type?.trim().toLowerCase();
 }
-function isSingleConversation(type) {
-    const normalizedType = normalizeConversationType(type);
-    return (normalizedType === '0' ||
-        normalizedType === 'single' ||
-        normalizedType === 'singlechat' ||
-        normalizedType === 'oto');
-}
-function isGroupConversation(type) {
-    const normalizedType = normalizeConversationType(type);
-    return (normalizedType === '1' ||
-        normalizedType === '2' ||
-        normalizedType === 'group' ||
-        normalizedType === 'groupchat');
-}
-async function resolveUnionIdByUserId(userId) {
-    if (!userId)
-        return undefined;
-    const cached = unionIdByUserId.get(userId);
-    if (cached)
-        return cached;
-    const result = await callOapi('/topapi/v2/user/get', {
-        userid: userId,
-        language: 'zh_CN',
-    });
-    const unionId = result.result?.unionid;
-    if (typeof unionId === 'string' && unionId.length > 0) {
-        unionIdByUserId.set(userId, unionId);
-        return unionId;
-    }
-    return undefined;
-}
 function buildProactiveAttempts(target, content) {
     const robotCode = getRobotCode(target);
     const payload = buildTextPayload(content);
@@ -279,7 +214,6 @@ export function stopDingTalk() {
     }
     finally {
         sessionWebhookByChat.clear();
-        unionIdByUserId.clear();
         client = null;
         messageHandler = null;
         log.info('DingTalk client stopped');
@@ -302,107 +236,19 @@ export async function sendProactiveText(target, content) {
         }
         catch (err) {
             lastError = err;
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg.includes('robot') || msg.includes('resource.not.found')) {
-                log.debug(`DingTalk proactive ${attempt.label} send failed:`, err);
-            }
-            else {
-                log.warn(`DingTalk proactive ${attempt.label} send failed:`, err);
-            }
+            log.warn(`DingTalk proactive ${attempt.label} send failed:`, err);
         }
     }
     throw lastError instanceof Error
         ? lastError
         : new Error(`DingTalk proactive send failed for chat ${target.chatId}`);
 }
-export async function prepareStreamingCard(target, templateId, cardData) {
-    const normalizedTarget = typeof target === 'string' ? { chatId: target } : target;
-    const contentType = 'ai_card';
-    const content = buildAiCardContent(templateId, cardData);
-    const attempts = [];
-    log.debug(`DingTalk prepare: conversationType=${normalizedTarget.conversationType ?? 'undefined'}, senderStaffId=${normalizedTarget.senderStaffId ?? 'undefined'}`);
-    if (isSingleConversation(normalizedTarget.conversationType)) {
-        let unionId;
-        try {
-            unionId = await resolveUnionIdByUserId(normalizedTarget.senderStaffId);
-        }
-        catch (err) {
-            log.debug('Failed to resolve DingTalk unionId from senderStaffId:', err);
-        }
-        if (unionId) {
-            attempts.push({
-                label: 'single-unionid',
-                body: { unionId, contentType, content },
-            });
-        }
-        if (normalizedTarget.chatId) {
-            attempts.push({
-                label: 'single-chatid',
-                body: { openConversationId: normalizedTarget.chatId, contentType, content },
-            });
-        }
-    }
-    else if (isGroupConversation(normalizedTarget.conversationType)) {
-        // 群聊时也优先尝试 unionId：部分场景下 conversationType 可能误报，或单聊被识别为群聊
-        let unionId;
-        try {
-            unionId = await resolveUnionIdByUserId(normalizedTarget.senderStaffId);
-        }
-        catch (err) {
-            log.debug('Failed to resolve DingTalk unionId for group (fallback):', err);
-        }
-        if (unionId) {
-            attempts.push({
-                label: 'group-unionid',
-                body: { unionId, contentType, content },
-            });
-        }
-        if (normalizedTarget.chatId) {
-            attempts.push({
-                label: 'group-chatid',
-                body: { openConversationId: normalizedTarget.chatId, contentType, content },
-            });
-        }
-    }
-    else {
-        let unionId;
-        try {
-            unionId = await resolveUnionIdByUserId(normalizedTarget.senderStaffId);
-        }
-        catch (err) {
-            log.debug('Failed to resolve DingTalk unionId for unknown conversation type:', err);
-        }
-        if (unionId) {
-            attempts.push({
-                label: 'unknown-unionid',
-                body: { unionId, contentType, content },
-            });
-        }
-        if (normalizedTarget.chatId) {
-            attempts.push({
-                label: 'unknown-chatid',
-                body: { openConversationId: normalizedTarget.chatId, contentType, content },
-            });
-        }
-    }
-    if (attempts.length === 0) {
-        throw new Error('DingTalk prepare target is incomplete');
-    }
-    let result;
-    let lastError;
-    for (const attempt of attempts) {
-        try {
-            result = await callOpenApi('/v1.0/aiInteraction/prepare', attempt.body);
-            break;
-        }
-        catch (err) {
-            lastError = err;
-            log.debug(`DingTalk prepare attempt failed (${attempt.label}):`, err);
-        }
-    }
-    if (!result) {
-        throw lastError instanceof Error ? lastError : new Error('DingTalk prepare failed');
-    }
+export async function prepareStreamingCard(chatId, templateId, cardData) {
+    const result = await callOpenApi('/v1.0/aiInteraction/prepare', {
+        openConversationId: chatId,
+        contentType: 'ai_card',
+        content: buildAiCardContent(templateId, cardData),
+    });
     const token = result.result?.conversationToken;
     if (typeof token !== 'string' || token.length === 0) {
         throw new Error(`DingTalk prepare did not return conversationToken: ${JSON.stringify(result)}`);
@@ -429,163 +275,3 @@ export async function finishStreamingCard(conversationToken) {
         throw new Error(`DingTalk finish returned success=false: ${JSON.stringify(result)}`);
     }
 }
-/** 创建并投放卡片（卡片平台 API，支持普通群流式更新） */
-export async function createAndDeliverCard(target, templateId, outTrackId, cardData) {
-    const { chatId, robotCode, conversationType, senderStaffId } = target;
-    if (!robotCode) {
-        throw new Error('DingTalk robotCode required for createAndDeliver');
-    }
-    const isSingle = isSingleConversation(conversationType);
-    const cardParamMap = buildCardParamMap(cardData);
-    if (!cardParamMap.content && !cardParamMap.lastMessage)
-        cardParamMap.content = '...';
-    const lastMsg = String(cardData.lastMessage ?? cardData.displayText ?? cardData.content ?? cardData.title ?? 'AI').slice(0, 50);
-    const body = {
-        userId: senderStaffId ?? 'system',
-        cardTemplateId: templateId,
-        outTrackId,
-        cardData: { cardParamMap },
-    };
-    if (isSingle && senderStaffId) {
-        body.openSpaceId = `dtv1.card//im_robot.${senderStaffId}`;
-        body.imRobotOpenSpaceModel = {
-            lastMessageI18n: { zh_CN: lastMsg },
-            searchSupport: { searchIcon: '', searchTypeName: '消息', searchDesc: '' },
-            notification: { alertContent: lastMsg },
-        };
-        body.imRobotOpenDeliverModel = { spaceType: 'IM_ROBOT' };
-    }
-    else {
-        body.openSpaceId = `dtv1.card//im_group.${chatId}`;
-        body.imGroupOpenSpaceModel = {
-            lastMessageI18n: { zh_CN: lastMsg },
-            searchSupport: { searchIcon: '', searchTypeName: '消息', searchDesc: '' },
-            notification: { alertContent: lastMsg },
-        };
-        body.imGroupOpenDeliverModel = {
-            robotCode,
-            atUserIds: {},
-            recipients: [],
-        };
-    }
-    await callOpenApiWithMethod('POST', '/v1.0/card/instances/createAndDeliver', body);
-}
-/** 将 cardData 转为 cardParamMap（对象/数组需 JSON 序列化） */
-function buildCardParamMap(cardData) {
-    const cardParamMap = {};
-    for (const [k, v] of Object.entries(cardData)) {
-        if (v === undefined || v === null)
-            continue;
-        if (typeof v === 'object') {
-            cardParamMap[k] = JSON.stringify(v);
-        }
-        else {
-            cardParamMap[k] = String(v);
-        }
-    }
-    return cardParamMap;
-}
-/** 更新卡片实例（用于流式更新） */
-export async function updateCardInstance(outTrackId, cardData) {
-    const cardParamMap = buildCardParamMap(cardData);
-    await callOpenApiWithMethod('PUT', '/v1.0/card/instances', {
-        outTrackId,
-        cardData: { cardParamMap },
-    });
-}
-/** StandardCard 模板结构（与钉钉官方 Go 打字机示例完全一致：text=标题，markdown=内容） */
-function buildStandardCardData(cardData) {
-    const title = String(cardData.title ?? 'AI');
-    const content = String(cardData.content ?? cardData.displayText ?? '').trim() || '...';
-    const schema = {
-        config: { autoLayout: true, enableForward: true },
-        header: {
-            title: { type: 'text', text: title },
-            logo: '@lALPDfJ6V_FPDmvNAfTNAfQ',
-        },
-        contents: [
-            { type: 'text', text: title, id: 'text_1693929551595' },
-            { type: 'divider', id: 'divider_1693929551595' },
-            { type: 'markdown', text: content, id: 'markdown_1693929674245' },
-        ],
-    };
-    return JSON.stringify(schema);
-}
-/** 互动卡片普通版：发送（用于 prepare 失败时的 fallback 流式） */
-export async function sendRobotInteractiveCard(target, cardBizId, cardData) {
-    const { chatId, robotCode, conversationType } = target;
-    if (!robotCode) {
-        throw new Error('DingTalk robotCode required for interactive card');
-    }
-    const cardDataStr = buildStandardCardData(cardData);
-    const isSingle = isSingleConversation(conversationType);
-    const body = {
-        cardTemplateId: 'StandardCard',
-        cardBizId,
-        outTrackId: cardBizId,
-        robotCode,
-        cardData: cardDataStr,
-    };
-    if (isSingle && target.senderStaffId) {
-        body.singleChatReceiver = JSON.stringify({ userid: target.senderStaffId });
-    }
-    else {
-        body.openConversationId = chatId;
-    }
-    log.debug(`DingTalk sendRobotInteractiveCard: isSingle=${isSingle}, robotCode=${robotCode?.slice(0, 8)}..., chatIdLen=${chatId?.length}`);
-    try {
-        await callOpenApiWithMethod('POST', '/v1.0/im/v1.0/robot/interactiveCards/send', body);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes('param.error') || msg.includes('参数无效')) {
-            log.warn('DingTalk robot interactive card param.error - request body (no secrets):', JSON.stringify({ ...body, robotCode: body.robotCode ? '[REDACTED]' : undefined }, null, 2));
-        }
-        throw err;
-    }
-}
-/** 互动卡片普通版：更新（单条消息流式更新） */
-export async function updateRobotInteractiveCard(cardBizId, cardData) {
-    const cardDataStr = buildStandardCardData(cardData);
-    const body = { cardBizId, cardData: cardDataStr };
-    await callOpenApiWithMethod('PUT', '/v1.0/im/robots/interactiveCards', body);
-}
-async function callOpenApiWithMethod(method, path, body) {
-    const accessToken = await getClient().getAccessToken();
-    const res = await fetch(`${DINGTALK_OPENAPI_BASE}${path}`, {
-        method,
-        headers: {
-            'content-type': 'application/json',
-            'x-acs-dingtalk-access-token': String(accessToken),
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(30000),
-    });
-    const text = await res.text();
-    if (!res.ok) {
-        throw new Error(`DingTalk OpenAPI failed: ${res.status} ${text}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-    const errorCode = parsed.errorcode ?? parsed.errcode;
-    const success = parsed.success;
-    if (errorCode === 0 ||
-        errorCode === '0' ||
-        success === true ||
-        (errorCode === undefined && success === undefined)) {
-        return parsed;
-    }
-    const errorMessage = typeof parsed.errmsg === 'string'
-        ? parsed.errmsg
-        : typeof parsed.errormsg === 'string'
-            ? parsed.errormsg
-            : typeof parsed.message === 'string'
-                ? parsed.message
-                : text;
-    throw new Error(`DingTalk OpenAPI business error: ${String(errorCode)} ${errorMessage}`);
-}

package/dist/dingtalk/event-handler.js

@@ -24,7 +24,6 @@ function parseRobotMessage(data) {
 export function setupDingTalkHandlers(config, sessionManager) {
     configureDingTalkMessageSender({
         cardTemplateId: config.dingtalkCardTemplateId,
-        robotCodeFallback: config.dingtalkClientId,
     });
     if (config.dingtalkCardTemplateId) {
         log.info('DingTalk AI card streaming enabled');
@@ -44,7 +43,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
         getRunningTasksSize: () => runningTasks.size,
     });
     registerPermissionSender('dingtalk', { sendTextReply, sendPermissionCard });
-    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId, dingtalkTarget) {
+    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
         const toolAdapter = getAdapter(config.aiCommand);
         if (!toolAdapter) {
@@ -56,7 +55,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
             : undefined;
         log.info(`[AI_REQUEST] Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
         const toolId = config.aiCommand;
-        const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, dingtalkTarget);
+        const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
         const stopTyping = startTypingLoop(chatId);
         const taskKey = `${userId}:${msgId}`;
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'dingtalk', taskKey }, prompt, toolAdapter, {
@@ -113,7 +112,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
             chatId,
             userId,
             conversationType: robotMessage.conversationType,
-            robotCode: robotMessage.robotCode || config.dingtalkClientId,
+            robotCode: robotMessage.robotCode,
         });
         setChatUser(chatId, userId, 'dingtalk');
         try {
@@ -128,15 +127,8 @@ export function setupDingTalkHandlers(config, sessionManager) {
         }
         const workDir = sessionManager.getWorkDir(userId);
         const convId = sessionManager.getConvId(userId);
-        const dingtalkTarget = {
-            chatId,
-            conversationType: robotMessage.conversationType,
-            senderStaffId: robotMessage.senderStaffId,
-            senderId: robotMessage.senderId,
-            robotCode: robotMessage.robotCode || config.dingtalkClientId,
-        };
         const enqueueResult = requestQueue.enqueue(userId, convId, text, async (prompt) => {
-            await handleAIRequest(userId, chatId, prompt, workDir, convId, undefined, undefined, dingtalkTarget);
+            await handleAIRequest(userId, chatId, prompt, workDir, convId);
         });
         if (enqueueResult === 'rejected') {
             await sendTextReply(chatId, '请求队列已满，请稍后再试。');

package/dist/dingtalk/message-sender.d.ts

@@ -1,13 +1,11 @@
-import type { DingTalkStreamingTarget } from './client.js';
 import type { ThreadContext } from '../shared/types.js';
 import type { DingTalkActiveTarget } from '../shared/active-chats.js';
 export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
 interface SenderSettings {
     cardTemplateId?: string;
-    robotCodeFallback?: string;
 }
 export declare function configureDingTalkMessageSender(settings: SenderSettings): void;
-export declare function sendThinkingMessage(chatId: string, _replyToMessageId?: string, toolId?: string, target?: DingTalkStreamingTarget): Promise<string>;
+export declare function sendThinkingMessage(chatId: string, _replyToMessageId?: string, toolId?: string): Promise<string>;
 export declare function updateMessage(chatId: string, messageId: string, content: string, status: MessageStatus, note?: string, toolId?: string): Promise<void>;
 export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
 export declare function sendErrorMessage(chatId: string, messageId: string, error: string, toolId?: string): Promise<void>;