@jeik/dingtalk-connector 0.8.21-fix2 → 0.8.21-fix22

package/README.en.md

@@ -4,7 +4,7 @@
   <p>Community maintained fork of the official <strong>v0.8.20</strong> release, tracking and fixing bugs the official team hasn't addressed.<br/>
   Identical to the official release in functionality — only community-critical fixes applied.</p>
 
-  <p><strong>Current published release: <a href="https://www.npmjs.com/package/@jeik/dingtalk-connector">@jeik/dingtalk-connector</a> v0.8.21</strong> (now on npm — see "Installation" below).</p>
+  <p><strong>Current published release: <a href="https://www.npmjs.com/package/@jeik/dingtalk-connector">@jeik/dingtalk-connector</a> v0.8.23</strong> (on npm; `latest` points to this version — includes every historical fix plus the community's exclusive enhancements. See "Installation" below).</p>
 
   <p>
     <a href="https://www.npmjs.com/package/@jeik/dingtalk-connector"><img src="https://img.shields.io/npm/v/@jeik/dingtalk-connector.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="npm version" /></a>
@@ -25,8 +25,13 @@
 
 | Date | Tag | Update |
 |------|------|--------|
-| 2026-06-28 | ✨ | Install wizard now detects existing config: skip QR when a bot already exists; after QR, choose to overwrite or add a bot (bindings maintained automatically, other configs untouched) |
-| 2026-06-28 | 📦 | Now published to npm (`@jeik/dingtalk-connector`) with one-command scan-to-install; `--force` overwrites for updates, no uninstall needed |
+| 2026-06-29 | 🐛 | **Fixed incomplete DingTalk AI Card streaming replies (e.g. "你...")**: switched to **deferred card creation** — accumulate streaming text first, only create the AI Card once the real reply tokens actually start arriving, eliminating the half-empty "你..." card |
+| 2026-06-29 | 🐛 | **Fixed message-tool cards rendering empty content**: `finishAICard` was simplified to PUT FINISHED directly. That works for the reply-dispatcher path (card already streamed, `inputingStarted=true`) but breaks the message-tool path (`createAICardForTarget` → `finishAICard` on a fresh card, `inputingStarted=false`) — skipping the INPUTING transition made DingTalk not render the `content` field (blank card). `finishAICard` now only triggers an extra `streamAICard(..., /*finished*/ false)` walk through INPUTING + content write when `!inputingStarted`; `finished=false` avoids "fake-stream replay" and the already-streamed path (`inputingStarted=true`) is unchanged. **Upgrade:** `npm install -g @jeik/dingtalk-connector` |
+| 2026-06-29 | ✨ | **Fixed webchat long-text never finishing due to DingTalk's bug-bounded streaming-card render speed**: introduced **answer-card mode (on by default)** — DingTalk replies now bind a streaming card plus an answer card (built-in). When the final answer exceeds `answerActToken` (default 600) tokens, the streaming card shows just "✅ Done thinking", and an independent **static answer card** carries the full reply, sidestepping DingTalk's fixed-speed streaming-card render bug. Short answers still render on the streaming card; long answers get a fast static reply without hurting UX on short replies. Template id and threshold are configurable (`answerCardTemplateId` / `answerActToken`) |
+| 2026-06-29 | ✨ | **Streamed tool-call progress on the AI Card**: while a tool runs, the card streams `🔧 Calling tool: <name>` and then seamlessly switches to the reply once done. Closes the gap the official connector never handled for tool callbacks |
+| 2026-06-29 | 🐛 | **Fixed premature AI Card render-stop when multiple answers / tool-call errors land in one turn**: dws and other tool-failure results (carrying `isError`/`isStatusNotice`) were occasionally taken as the final answer and stopped rendering early. Now excluded per OpenClaw's official rule — the upstream official `dingtalk-connector` never handled this; this community fork does, showing them transiently without counting as the answer |
+| 2026-06-29 | 🔧 | **Major install wizard upgrade vs upstream**: supports **enhanced AI Card toggle, skip-when-config-exists, QR scan config, manual clientId/clientSecret entry, dws now updated to the latest version, detects and can disable a local plugin copy shadowing the npm version**. Wizard is now more robust, more discoverable, and won't overwrite existing setups |
+| 2026-06-28 | 📦 | **Now published to the official npm registry**: package `@jeik/dingtalk-connector`, added one-command scan-to-install; `--force` overwrites for updates, no uninstall needed |
 | 2026-06-28 | 🐛 | Fixed the connector mistaking an intermediate progress message for the final answer and ending AI Card rendering too early when the model emits multiple progress messages in one turn (card now finalized only at turn end) |
 | 2026-05-14 | ✨ | Markdown image support for direct URLs and local paths, no download required |
 | 2026-05-11 | 🔧 | AI Card flashing and repeated re-rendering caused by duplicate intermediate messages after Agent multi-round loop completes |
@@ -68,11 +73,30 @@ Full update log: [FIXES.md](FIXES.md)（[🇨🇳 中文](FIXES.en.md)）
 | `cardContentVar` | Final response content variable, defaults to `msgContent` |
 | `cardProcessVar` | Intermediate process (block status) variable, defaults to `cardContentVar` if not set |
 | `cardToolVar` | Tool call output variable, not written to card if not set |
+| `answerCard` | Answer-card mode switch, **on by default**; set `false` to disable |
+| `answerActToken` | Answer-card trigger threshold (tokens), default `600`; final answer ≤ this stays on the original card, > this opens a separate answer card |
+| `answerCardTemplateId` | Answer-card template ID, uses the built-in default if not set (must contain a `content` variable) |
 
 > Card template must be created in [DingTalk Open Platform](https://open.dingtalk.com/) with matching variable fields.
 
 ---
 
+## 🎯 Reply markers + Answer card + Tool progress (core enhancements)
+
+These make the "process → final answer" rendering on DingTalk cleaner and more stable, working around DingTalk's official streaming AI Card bug:
+
+- **Reply markers**: work with the `[-process-]` (process) / `[-final-]` (final) markers injected by [prompt-rewriter](https://www.npmjs.com/package/@jeik/prompt-rewriter).
+  - Process segments stream token-by-token; once `[-final-]` appears, streaming stops and the card is **finalized in one shot** (no DingTalk "fake-stream replay").
+  - Markers are **never visible to the user** (stripped before writing to the card) and take **priority over** OpenClaw's default fallback — preventing intermediate process text from being mistaken for the final answer and stopping rendering early.
+  - With no markers, behavior follows OpenClaw's default entirely.
+- **Answer-card mode** (on by default): when the final answer exceeds `answerActToken` (default 600) tokens, the **streaming card finalizes to "✅ Done thinking"** and a separate **static answer card** carries the full reply — avoiding DingTalk's bug where a FINISHED streaming card keeps flickering/re-rendering. Short answers stay on the original card, no extra card.
+- **Tool-call progress**: while the Agent calls a tool, the card streams `🔧 Calling tool: <name>`, then updates to the reply when the tool finishes.
+- **Tool failures no longer mis-rendered**: failed tool results (carrying `isError`/`isStatusNotice`) are shown transiently but **never treated as the final answer**.
+
+> Markers require the prompt-rewriter plugin; answer card / tool progress are built into the connector and work out of the box.
+
+---
+
 ## Why Fork?
 
 Due to the sluggish pace of the official DingTalk connector's updates and bug fixes, this repository was forked to keep up with critical fixes.

package/README.md

@@ -4,7 +4,7 @@
   <p>基于官方 <strong>v0.8.20</strong> 的社区维护版本，由社区持续跟进修复官方无暇处理的 Bug。<br/>
   功能与官方完全一致，拥有最快的修复速度，及时合并官方pr和个人发现的bug和社区急需的 Bug。</p>
 
-  <p><strong>当前发布版：<a href="https://www.npmjs.com/package/@jeik/dingtalk-connector">@jeik/dingtalk-connector</a> v0.8.21</strong>（已发布到 npm，使用方式见下方「安装」）</p>
+  <p><strong>当前发布版：<a href="https://www.npmjs.com/package/@jeik/dingtalk-connector">@jeik/dingtalk-connector</a> v0.8.21-fix22</strong>（已发布到 npm，`fix` 标签指向此版本，`latest` 仍为 0.8.21-fix20；修复版用 `@fix` 或显式版本）</p>
 
   <p>
     <a href="https://www.npmjs.com/package/@jeik/dingtalk-connector"><img src="https://img.shields.io/npm/v/@jeik/dingtalk-connector.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="npm version" /></a>
@@ -25,11 +25,16 @@
 
 | 日期 | 标识 | 更新内容 |
 |------|------|---------|
-| 2026-06-28 | ✨ | 安装向导新增「已存在配置」检测：已有机器人配置可跳过扫码；扫码后可选覆盖或新增机器人（自动维护 bindings、不覆盖其它配置） |
-| 2026-06-28 | 📦 | 改为发布到 npm（`@jeik/dingtalk-connector`），新增一键扫码安装命令；`--force` 覆盖更新无需卸载 |
+| 2026-06-29 | 🐛 | **修复钉钉 AI 卡片流式回复不完整 例 “你...” 的问题** ：采用**延迟建卡**模式，让流式文本积累更多文本，把建卡时机放到真正的文本到来之后，再进行建卡流式卡片展示 |
+| 2026-06-29 | 🐛 | **修复 message 工具发卡 content 为空**：`finishAICard` 简化后直接 PUT FINISHED，对 reply-dispatcher 路径（已流式过）无影响，但 message 工具走的「新建卡立刻 finish」路径（`createAICardForTarget` → `finishAICard`，`inputingStarted=false`）会跳过 INPUTING 状态过渡，导致钉钉不渲染 content（卡片空白）。`finishAICard` 现仅在 `!inputingStarted` 时先调一次 `streamAICard(..., /*finished*/ false)` 走完 INPUTING + 内容写入再 FINISHED（`finished=false` 避免触发"假流式回放"，已流式过的路径 `inputingStarted=true` 完全不受影响）。**升级：** `npm install -g @jeik/dingtalk-connector@fix` |
+| 2026-06-29 | ✨ | **修复 webchat 中最终答案已生成，但由于钉钉上游流式卡片的原因导致长文本一直渲染的问题**：新增**答案卡模式（默认开启）**，钉钉回复默认会绑定一张流式卡片和答案卡片（默认内置），最终答案如果 token >  `answerActToken`（默认 600）时，原流式卡片直接显示"✅ 思考完成"、另投一张独立的**静态答案卡**，规避钉钉流式卡的官方固定速度渲染的 bug；短答案仍在原流式卡渲染。长文本新建答案卡快速回复，短文本回答不影响用户体验。模板id/阈值可配（`answerCardTemplateId` / `answerActToken`） |
+| 2026-06-29 | ✨ | **增加 AI 卡片工具流式展示工具调用进度**：增加调用工具时原卡流式显示 `🔧 正在调用工具：<工具名>`，结束后正常更新为回复 本功能补齐官方连接器未处理 tool 回调的短板|
+| 2026-06-29 | 🐛 | **修复多条文本回答、工具调用错误等异常情况导致 AI流式卡片提前停止渲染的问题，**：dws 等工具失败结果（带 `isError`/`isStatusNotice`）以前偶发被当最终答案、提前停渲染；现按 OpenClaw 官方标准排除，但原版官方 dingtalk-connector 并没有考虑这方面，本社区版已完美修复支持，仅展示不计入答案 |
+| 2026-06-29 | 🔧 | **安装向导对比官方超级增强**：安装向导支持**增强版AI card、已有配置跳过、扫码配置、填入clientID和clientSecret配置、dws 改为更新最新的 latest 版本、检测并可禁用遮蔽 npm 版的本地插件副本等**，安装向导更健壮 更易懂 更不会覆盖|
+| 2026-06-28 | 📦 | **本仓库已上线npm官方仓库包**：`@jeik/dingtalk-connector`，新增一键扫码安装命令；`--force` 覆盖更新无需卸载 |
 | 2026-06-28 | 🐛 | 修复模型一轮内发送多条过程消息时，连接器把中间过程消息当成最终答案、提前结束 AI Card 渲染的问题（改为整轮结束才定稿卡片） |
-| 2026-05-14 | ✨ | Markdown 图片发送支持直链和本地路径，无需下载到本地，请参考下列提示词|
-| 2026-05-11 | 🔧 | Agent 多轮循环完成后，中间过程消息重复发送到钉钉对话，造成刷屏和 AI Card 倒放重渲染 |
+| 2026-05-14 | ✨ | **Markdown 图片发送支持直链和本地路径，无需下载到本地，请参考下列提示词** |
+| 2026-05-11 | 🔧 | **Agent 多轮循环完成后，中间过程消息重复发送到钉钉对话，造成刷屏和 AI Card 倒放重渲染** |
 | 2026-05-11 | 🐛 | OpenClaw 4.29+ 版本导致钉钉插件失效，群聊 @Agent 回复显示"✅ 任务执行完成（无文本输出）" |
 | 2026-05-08 | 🌐 | 未注册的 Pong 监听器导致的 WebSocket 幻影重连，来源于 [PR #566](https://github.com/DingTalk-Real-AI/dingtalk-openclaw-connector/pull/566)（[Majorshi](https://github.com/Majorshi) 提交） |
 
@@ -104,9 +109,28 @@
 | `cardContentVar` | 最终回复内容变量名，不填默认 `msgContent` |
 | `cardProcessVar` | 中间过程（block 状态）变量名，不填默认使用 `cardContentVar` |
 | `cardToolVar` | 工具调用输出变量名，不填则不写入卡片 |
+| `answerCard` | 答案卡模式开关，**默认开启**；显式设 `false` 关闭 |
+| `answerActToken` | 答案卡触发阈值（token），默认 `600`；最终答案 ≤ 此值直接在原卡定稿，> 此值才另开答案卡 |
+| `answerCardTemplateId` | 答案卡模板 ID，不填用内置默认模板（需含 `content` 变量） |
 
 > 卡片模板需在[钉钉开放平台](https://open.dingtalk.com/)创建，并添加对应的变量字段。
 
+---
+
+## 🎯 回复标记 + 答案卡 + 工具进度（核心增强）
+
+这套机制让钉钉侧的「过程 → 最终答案」渲染更干净、更稳定，规避钉钉流式 AI Card 的官方渲染 bug：
+
+- **回复标记**：配合 [prompt-rewriter](https://www.npmjs.com/package/@jeik/prompt-rewriter) 注入的 `[-process-]`（过程段）/`[-final-]`（最终答案）标记。
+  - 过程段逐字流式滚动；出现 `[-final-]` 后**停止流式、一次性定稿**（去掉钉钉"假流式回放"）。
+  - 标记对用户**完全不可见**（进卡前统一剥离），且**优先级高于** OpenClaw 默认兜底——避免中间过程被误判成最终答案、提前停渲染。
+  - 无标记时完全走 OpenClaw 默认逻辑。
+- **答案卡模式**（默认开启）：最终答案 token 超过 `answerActToken`（默认 600）时，**原流式卡定格"✅ 思考完成"**，另投一张**静态答案卡**承载完整回复——规避钉钉流式卡 FINISHED 后仍抖动/重渲染的 bug。短答案仍在原卡定稿，不多开卡。
+- **工具调用进度**：Agent 调用工具时，原卡流式显示 `🔧 正在调用工具：<工具名>`，工具结束后正常更新为回复。
+- **工具失败不再误判**：工具调用失败的结果（带 `isError`/`isStatusNotice`）只在卡片短暂展示，**不会被当成最终答案**。
+
+> 标记功能需安装并启用 prompt-rewriter 插件；答案卡/工具进度为连接器内置，开箱即用。
+
 **效果预览：**
 
 ![自定义卡片效果](assets/image.png)
@@ -156,6 +180,8 @@
 
 ```bash
 npx -y @jeik/dingtalk-connector install
+
+npx -y @jeik/dingtalk-connector --force ##强制安装 适用于本地已有 dingtalk-connector 的情况 第一条命令安装不了就用这个强制安装
 ```
 
 **或仅安装插件**（自行配置凭证，见下方进阶文档）：

package/bin/dingtalk-connector.js

@@ -7,7 +7,7 @@
  *   node bin/dingtalk-connector.js install --local              # local dev
  */
 import { createRequire } from 'node:module';
-import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync, readdirSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import {
@@ -294,16 +294,68 @@ function saveCredentials(clientId, clientSecret, { isLocal = false, pluginInstal
 
 // ── plugin install ─────────────────────────────────────────────
 function getInstallSpec() {
-  // Read version from own package.json to pass the exact version to openclaw
+  // 永远钉住"本包自己的精确版本"，让 openclaw 内部装的版本 == 你 npx 实际下到的版本。
+  // npx @fix / @0.8.21-fix7 / @latest / 不带 → 各自下到对应包 → 这里读到的就是那个版本。
+  // 不带版本号会让 openclaw 装 latest，导致"跑 fix 向导却装了正式版"那个坑。
   try {
-    const require = createRequire(import.meta.url);
-    const { version } = require('../package.json');
-    if (version && /-(alpha|beta|rc|canary)/.test(version)) {
-      // prerelease → use exact version so openclaw accepts it
-      return `${PKG_NAME}@${version}`;
-    }
+    const { version } = createRequire(import.meta.url)('../package.json');
+    if (version) return `${PKG_NAME}@${version}`;
   } catch {}
-  return PKG_NAME;
+  return PKG_NAME; // 兜底：读不到版本才退回不带版本（极少见）
+}
+
+// 在 plugins.load.paths 扫描范围内找会"遮蔽"npm 版的本地 dingtalk 插件副本。
+// 原理：load.paths 扫到的插件 origin=config，优先级（rank 0）高于 npm 安装的 global（rank 2），
+// 所以一份本地克隆会永久压过 npm 版，--force 重装也没用。这里浅扫一层定位它。
+// ponytail: 只扫 load.paths 下一层目录；克隆嵌套更深的极少见，需要再加深度。
+function findShadowingLocalPlugin(paths = readConfig()?.plugins?.load?.paths) {
+  if (!Array.isArray(paths)) return null;
+  const npmRoot = join(homedir(), '.openclaw', 'npm');
+  for (const p of paths) {
+    if (typeof p !== 'string') continue;
+    const base = p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
+    let entries;
+    try { entries = readdirSync(base, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      // OpenClaw 扫描会跳过这些名字（discovery shouldIgnoreScannedDirectory），它们不会遮蔽，
+      // 已禁用的 .disabled 目录也在此跳过，避免重复禁用成 .disabled.disabled。
+      const lower = e.name.toLowerCase();
+      if (lower.endsWith('.bak') || lower.includes('.backup-') || lower.includes('.disabled')) continue;
+      const dir = join(base, e.name);
+      if (dir.startsWith(npmRoot)) continue; // npm 安装目录本身不算遮蔽
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+        const channels = pkg?.openclaw?.channels;
+        if (pkg?.name === PKG_NAME || (Array.isArray(channels) && channels.includes(CHANNEL_ID))) {
+          return dir;
+        }
+      } catch {}
+    }
+  }
+  return null;
+}
+
+// 检测并（经确认后）禁用遮蔽 npm 版的本地副本：把目录重命名为 .disabled（可随时改回）。
+async function resolvePluginShadow() {
+  const shadow = findShadowingLocalPlugin();
+  if (!shadow) return;
+  console.log('\n' + orange('⚠ 检测到本地插件副本会覆盖刚装的 npm 版：'));
+  console.log(dim(`    ${shadow}`));
+  console.log(dim('    它在 plugins.load.paths 扫描范围内，优先级高于 npm 版，网关会一直用这份旧本地代码。') + '\n');
+  const ans = await askUserConfirmation('  是否禁用它（重命名为 .disabled，随时可改回）？[Y/n] ');
+  if (ans === 'n' || ans === 'no') {
+    console.log(dim('  已跳过。网关仍会用本地版；如需用 npm 版，请手动移走该目录或从 plugins.load.paths 移除其父路径。') + '\n');
+    return;
+  }
+  const disabled = shadow + '.disabled';
+  try {
+    if (existsSync(disabled)) rmSync(disabled, { recursive: true, force: true });
+    renameSync(shadow, disabled);
+    console.log(green(`  ✔ 已禁用：${shadow} → ${disabled}`) + '\n');
+  } catch (err) {
+    console.log(red(`  ⚠ 重命名失败：${err.message}。请手动处理该目录。`) + '\n');
+  }
 }
 
 function installPlugin(force = false) {
@@ -611,14 +663,21 @@ async function ensureDwsCli() {
     const versionDisplay = installedVersion ? `v${installedVersion}` : 'unknown version';
 
     if (!targetVersion) {
-      // @latest 模式：解析不到固定版本号 → 始终重装拉最新（latest 不会降级，无需比较/询问）
-      console.log(dim(`  ℹ dws CLI detected (${versionDisplay}), ensuring latest (@latest)...`) + '\n');
-      const ok = installDwsCli();
-      if (ok) {
-        const nv = getInstalledDwsVersion();
-        console.log(green(`  ✔ dws CLI is now ${nv ? 'v' + nv : 'latest'}`) + '\n');
+      // @latest 模式：已安装则询问是否跳过更新（默认跳过，保留当前版本）
+      const ans = await askUserConfirmation(
+        `  检测到 dws CLI 已安装 (${versionDisplay})，是否跳过更新？(skip dws update?) [Y/n] `,
+      );
+      if (ans === 'n' || ans === 'no') {
+        console.log(dim(`  正在更新 dws CLI 到最新版...`) + '\n');
+        const ok = installDwsCli();
+        if (ok) {
+          const nv = getInstalledDwsVersion();
+          console.log(green(`  ✔ dws CLI is now ${nv ? 'v' + nv : 'latest'}`) + '\n');
+        } else {
+          console.log(red('  ⚠ Update failed. Continuing with current version.') + '\n');
+        }
       } else {
-        console.log(red('  ⚠ Update failed. Continuing with current version.') + '\n');
+        console.log(dim(`  已跳过更新，保留当前版本 ${versionDisplay}。`) + '\n');
       }
       // 鉴权状态检查（与下方同逻辑）
       if (isDwsAuthenticated()) {
@@ -731,10 +790,18 @@ Options:
     globalThis['proc' + 'ess'].exit(1);
   }
 
+  // 打印当前安装向导版本（= 本包版本），方便确认装的是哪一版
+  try {
+    const { version } = createRequire(import.meta.url)('../package.json');
+    console.log('\n' + cyan(`${PKG_NAME} v${version}`) + dim(' (install wizard)'));
+  } catch {}
+
   // Step 1: Install connector plugin (unless --local)
   let pluginInstalled = true;
   if (!isLocal) {
     pluginInstalled = installPlugin(force);
+    // 安装成功后检查是否有本地副本会遮蔽 npm 版（load.paths 优先级更高），有则确认禁用
+    if (pluginInstalled) await resolvePluginShadow();
   } else {
     console.log('\n' + dim('📦 --local mode: skipping plugin install') + '\n');
   }

package/dist/entry-bundled.mjs

@@ -23,7 +23,7 @@ var entry_bundled_default = defineBundledChannelEntry({
 		exportName: "setDingtalkRuntime"
 	},
 	async registerFull(api) {
-		const { registerGatewayMethods } = await import("./gateway-methods-Ci31A3vg.mjs");
+		const { registerGatewayMethods } = await import("./gateway-methods-Cq_QWaX1.mjs");
 		registerGatewayMethods(api);
 	}
 });

package/dist/{gateway-methods-C4tcgI7P.mjs → gateway-methods-CZlqdypF.mjs}

@@ -1,7 +1,7 @@
 import { a as resolveDingtalkAccount, t as listDingtalkAccountIds } from "./accounts-BAzdqkAV.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { r as getAccessToken, t as DINGTALK_API } from "./utils-CIfI_3Jh.mjs";
-import { c as prepareMultiBotMentions, i as sendProactive, s as buildBotMentionTable, u as finishAICard } from "./messaging-B6l1sRvX.mjs";
+import { c as prepareMultiBotMentions, d as finishAICard, i as sendProactive, s as buildBotMentionTable } from "./messaging-C5esCpZS.mjs";
 import { c as getUnionId, d as recallEmotionReply } from "./utils-legacy-CALCPP1t.mjs";
 //#region src/docs.ts
 var DingtalkDocsClient = class {

package/dist/{gateway-methods-Ci31A3vg.mjs → gateway-methods-Cq_QWaX1.mjs}

@@ -1,2 +1,2 @@
-import { t as registerGatewayMethods } from "./gateway-methods-C4tcgI7P.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-CZlqdypF.mjs";
 export { registerGatewayMethods };

package/dist/index.d.mts

@@ -78,6 +78,9 @@ declare const DingtalkConfigSchema: z$1.ZodObject<{
     cardContentVar: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
     cardProcessVar: z$1.ZodOptional<z$1.ZodString>;
     cardToolVar: z$1.ZodOptional<z$1.ZodString>;
+    answerCard: z$1.ZodOptional<z$1.ZodBoolean>;
+    answerActToken: z$1.ZodOptional<z$1.ZodNumber>;
+    answerCardTemplateId: z$1.ZodOptional<z$1.ZodString>;
     enabled: z$1.ZodOptional<z$1.ZodBoolean>;
     name: z$1.ZodOptional<z$1.ZodString>;
     clientId: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber]>>;
@@ -133,6 +136,9 @@ declare const DingtalkConfigSchema: z$1.ZodObject<{
   cardContentVar: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
   cardProcessVar: z$1.ZodOptional<z$1.ZodString>;
   cardToolVar: z$1.ZodOptional<z$1.ZodString>;
+  answerCard: z$1.ZodOptional<z$1.ZodBoolean>;
+  answerActToken: z$1.ZodOptional<z$1.ZodNumber>;
+  answerCardTemplateId: z$1.ZodOptional<z$1.ZodString>;
   enabled: z$1.ZodOptional<z$1.ZodBoolean>;
   defaultAccount: z$1.ZodOptional<z$1.ZodString>;
   clientId: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber]>>;

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-DUgpo5zC.mjs";
-import { t as registerGatewayMethods } from "./gateway-methods-C4tcgI7P.mjs";
+import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-Bm8q6lDq.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-CZlqdypF.mjs";
 //#region index.ts
 /**
 * 检测同一 plugin id 在多个路径被加载的情况。

package/dist/{message-handler-DESzFFDc.mjs → message-handler-D9opHiWI.mjs}

@@ -1,10 +1,10 @@
 import { u as uploadMediaToDingTalk } from "./media-cz72EVS3.mjs";
 import { a as resolveDingtalkAccount } from "./accounts-BAzdqkAV.mjs";
-import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-DUgpo5zC.mjs";
+import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-Bm8q6lDq.mjs";
 import { n as createLoggerFromConfig } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { i as getOapiAccessToken } from "./utils-CIfI_3Jh.mjs";
-import { a as sendTextMessage, f as isQpsLimitError, h as unregisterActiveCard, i as sendProactive, l as createAICardForTarget, m as streamAICard, p as registerActiveCard, r as sendMessage, t as sendMarkdownMessage, u as finishAICard } from "./messaging-B6l1sRvX.mjs";
+import { S as finalClean, _ as FINAL_TAG, a as sendTextMessage, b as estimateTokens, d as finishAICard, g as unregisterActiveCard, h as streamAICard, i as sendProactive, m as registerActiveCard, p as isQpsLimitError, r as sendMessage, t as sendMarkdownMessage, u as createAICardForTarget, v as PROCESS_TAG, x as extractFinal, y as displayClean } from "./messaging-C5esCpZS.mjs";
 import { a as QUEUE_BUSY_ACK_PHRASES, n as normalizeSlashCommand, t as buildSessionContext } from "./session-DJ4jYqPv.mjs";
 import { d as recallEmotionReply, o as getAccessToken, r as addEmotionReply, s as getOapiAccessToken$1, t as DINGTALK_API } from "./utils-legacy-CALCPP1t.mjs";
 import "./chunk-upload-BBQgGtcZ.mjs";
@@ -204,42 +204,6 @@ async function uploadAndReplaceFileMarkers(content, sessionWebhook, config, oapi
 	return result;
 }
 //#endregion
-//#region src/services/reply-markers.ts
-const PROCESS_TAG = "[-process-]";
-const FINAL_TAG = "[-final-]";
-const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
-/** 取最终答案：去掉那一个 [-final-]（开头/中间/结尾都行），其余原样，首尾空白清掉。
-*  没有 [-final-] 返回 null。多处出现取最后一个当信号。 */
-function extractFinal(text) {
-	if (!text) return null;
-	const i = text.lastIndexOf(FINAL_TAG);
-	if (i < 0) return null;
-	return (text.slice(0, i) + text.slice(i + 9)).replace(EDGE_WS, "");
-}
-/** 剥掉一个标记 token（[-process-] 或 [-final-]，位置无关，取最后一个），其余原样，首尾空白清掉。 */
-function stripOneMarker(text) {
-	if (!text) return "";
-	const pi = text.lastIndexOf(PROCESS_TAG);
-	const fi = text.lastIndexOf(FINAL_TAG);
-	if (pi < 0 && fi < 0) return text.replace(EDGE_WS, "");
-	const [i, len] = fi >= pi ? [fi, 9] : [pi, 11];
-	return (text.slice(0, i) + text.slice(i + len)).replace(EDGE_WS, "");
-}
-/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
-function stripPartialTail(text) {
-	if (!text) return "";
-	return text.replace(/\[-[a-z]*-?$/i, "");
-}
-/** 定稿用：有 [-final-] 去掉它；否则剥一个标记。正文不动。 */
-function finalClean(text) {
-	return extractFinal(text) ?? stripOneMarker(text);
-}
-/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
-function displayClean(text) {
-	const fin = extractFinal(text);
-	return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
-}
-//#endregion
 //#region src/reply-dispatcher.ts
 const { createReplyPrefixOptions, createTypingCallbacks, logTypingFailure } = await import("openclaw/plugin-sdk/channel-runtime");
 function createDingtalkReplyDispatcher(params) {
@@ -265,24 +229,34 @@ function createDingtalkReplyDispatcher(params) {
 	let lastAnswerText = "";
 	let processMarkerLogged = false;
 	let finalMarkerLogged = false;
-	const observeReply = (raw, isReasoning) => {
+	let markerSystemActive = false;
+	const isNonAnswerPayload = (p) => Boolean(p) && Boolean(p.isError || p.isStatusNotice || p.isCompactionNotice || p.isFallbackNotice);
+	const observeReply = (raw, payload) => {
 		const text = raw ?? "";
 		if (!text) return;
-		if (!processMarkerLogged && text.includes("[-process-]")) {
-			processMarkerLogged = true;
-			log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（已剥离，不展示给用户）`);
-		}
+		if (isNonAnswerPayload(payload)) return;
+		const isReasoning = payload?.isReasoning;
 		const fin = extractFinal(text);
 		if (fin !== null) {
 			if (!finalMarkerLogged) {
 				finalMarkerLogged = true;
-				log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（已剥离，以其后内容为最终答案）`);
+				log.info(`[DingTalk][marker] 检测到 ${FINAL_TAG}，最终答案=剥光标记的完整正文，跳过 OpenClaw 兜底`);
 			}
 			finalMarkedText = fin;
+			markerSystemActive = true;
+			return;
+		}
+		if (text.includes("[-process-]")) {
+			if (!processMarkerLogged) {
+				processMarkerLogged = true;
+				log.info(`[DingTalk][marker] 检测到 ${PROCESS_TAG}（过程段），抑制 OpenClaw 默认兜底`);
+			}
+			markerSystemActive = true;
+			return;
 		}
-		if (!isReasoning && text.trim()) lastAnswerText = text;
+		if (!markerSystemActive && !isReasoning && text.trim()) lastAnswerText = text;
 	};
-	const pickFinalText = () => finalMarkedText ?? (lastAnswerText || accumulatedText);
+	const pickFinalText = () => markerSystemActive ? finalMarkedText ?? accumulatedText : lastAnswerText || accumulatedText;
 	const applyReplyTemplate = async (text) => {
 		try {
 			const runner = getGlobalHookRunner?.();
@@ -428,6 +402,7 @@ function createDingtalkReplyDispatcher(params) {
 		log.info(`[DingTalk][closeStreaming] 开始关闭 AI Card...`);
 		try {
 			let finalText = finalClean(pickFinalText());
+			const hadRealAnswer = finalText.trim().length > 0;
 			log.info(`[DingTalk][closeStreaming] 最终答案来源=${finalMarkedText !== null ? "marker[-final-]" : lastAnswerText ? "非reasoning答案" : "accumulatedText兜底"}，长度=${finalText.length}`);
 			if (!finalText.trim()) {
 				finalText = "✅ 任务执行完成（无文本输出）";
@@ -479,9 +454,45 @@ function createDingtalkReplyDispatcher(params) {
 				log.warn(`[DingTalk][closeStreaming] 养成系统处理失败（不影响主流程）: ${gamErr?.message || gamErr}`);
 			}
 			finalText = await applyReplyTemplate(finalText);
-			log.info(`[DingTalk][closeStreaming] 准备调用 finishAICard，文本长度=${finalText.length}`);
-			log.debug(`[DingTalk][closeStreaming] 最终发送内容长度=${finalText.length}`);
-			await finishAICard(cardSnapshot, finalText, account.config, log);
+			if (account.config?.answerCard !== false) {
+				const finalizeOriginalToDone = async () => {
+					try {
+						await streamAICard(cardSnapshot, "✅ 思考完成", true, account.config, log);
+						await finishAICard(cardSnapshot, "✅ 思考完成", account.config, log);
+					} catch (e) {
+						log.warn(`[DingTalk][closeStreaming] 原卡定格思考完成失败（忽略）：${e?.message || e}`);
+					}
+				};
+				const answerTplId = (account.config?.answerCardTemplateId)?.trim() || "d246b7f5-1783-4e9b-bb46-bef52d63050e.schema";
+				const answerActToken = Number(account.config?.answerActToken) || 600;
+				const answerTokens = estimateTokens(finalText);
+				if (!hadRealAnswer) {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：无真实答案，仅定格原卡思考完成（不建答案卡）`);
+					await finalizeOriginalToDone();
+				} else if (answerTokens <= answerActToken) {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：答案约 ${answerTokens} token ≤ ${answerActToken}，原卡直接定稿（不建答案卡）`);
+					try {
+						await streamAICard(cardSnapshot, finalText, true, account.config, log);
+					} catch (e) {
+						if (!isQpsLimitError(e)) log.warn(`[DingTalk][closeStreaming] 原卡流式覆盖最终答案失败（忽略，继续 FINISHED）：${e?.message || e}`);
+					}
+					await finishAICard(cardSnapshot, finalText, account.config, log);
+				} else {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：答案约 ${answerTokens} token > ${answerActToken}，原卡思考完成 + 新建答案卡（模板=${answerTplId}）`);
+					await finalizeOriginalToDone();
+					const answerCard = await createAICardForTarget(account.config, target, log, answerTplId);
+					if (answerCard) {
+						await finishAICard(answerCard, finalText, account.config, log, void 0, true);
+						log.info(`[DingTalk][closeStreaming] ✅ 答案卡投放成功`);
+					} else {
+						log.warn(`[DingTalk][closeStreaming] 答案卡创建失败，降级定稿原卡`);
+						await finishAICard(cardSnapshot, finalText, account.config, log);
+					}
+				}
+			} else {
+				log.info(`[DingTalk][closeStreaming] 准备调用 finishAICard，文本长度=${finalText.length}`);
+				await finishAICard(cardSnapshot, finalText, account.config, log);
+			}
 			log.info(`[DingTalk][closeStreaming] ✅ AI Card 关闭成功`);
 		} catch (error) {
 			log.error(`[DingTalk][closeStreaming] ❌ AI Card 关闭失败：${error?.message || String(error)}`);
@@ -511,14 +522,28 @@ function createDingtalkReplyDispatcher(params) {
 			lastAnswerText = "";
 			processMarkerLogged = false;
 			finalMarkerLogged = false;
-			if (streamingEnabled) startStreaming();
+			markerSystemActive = false;
 			typingCallbacks.onActive?.();
 		},
 		deliver: async (payload, info) => {
 			let text = payload.text ?? "";
-			log.info(`[DingTalk][deliver] 被调用：kind=${info?.kind}, textLength=${text.length}, hasText=${Boolean(text.trim())}`);
-			log.debug(`[DingTalk][deliver] payload keys=${Object.keys(payload).join(",")}, info.kind=${info?.kind}`);
-			observeReply(payload.text, payload.isReasoning);
+			log.debug(`[DingTalk][deliver] kind=${info?.kind}, textLength=${text.length}`);
+			observeReply(payload.text, payload);
+			if (isNonAnswerPayload(payload)) {
+				if (streamingEnabled && currentCardTarget && !asyncMode && finalMarkedText === null) {
+					const now = Date.now();
+					if (now - lastUpdateTime >= updateInterval) {
+						lastUpdateTime = now;
+						try {
+							await streamAICard(currentCardTarget, displayClean(text), false, account.config, log, account.config?.cardContentVar || "msgContent");
+						} catch (e) {
+							if (!isQpsLimitError(e)) log.warn(`[DingTalk][deliver] 状态/错误 payload 写卡失败：${e?.message || e}`);
+						}
+					}
+				}
+				log.info(`[DingTalk][deliver] 非答案 payload（isError=${payload.isError},isStatusNotice=${payload.isStatusNotice}），仅展示不计入最终答案`);
+				return;
+			}
 			if (info?.kind === "final" && text.trim()) {
 				const target = isDirect ? {
 					type: "user",
@@ -638,32 +663,30 @@ function createDingtalkReplyDispatcher(params) {
 		replyOptions: {
 			...replyOptions,
 			onModelSelected,
+			allowToolLifecycleWhenProgressHidden: true,
+			suppressDefaultToolProgressMessages: true,
 			...streamingEnabled && { onPartialReply: async (payload) => {
-				log.info(`[DingTalk][onPartialReply] 被调用，payload.text=${payload.text ? payload.text.length : "null"}`);
-				log.debug(`[DingTalk][onPartialReply] textLength=${payload.text?.length ?? 0}`);
-				if (!payload.text) {
-					log.debug(`[DingTalk][onPartialReply] 空文本，跳过`);
-					return;
-				}
-				log.debug(`[DingTalk][onPartialReply] 收到部分响应，文本长度=${payload.text.length}`);
-				observeReply(payload.text, payload.isReasoning);
+				if (!payload.text) return;
+				observeReply(payload.text, payload);
+				if (isNonAnswerPayload(payload)) return;
 				if (asyncMode) {
-					log.debug(`[DingTalk][onPartialReply] 异步模式，累积响应`);
 					asyncModeFullResponse = finalClean(finalMarkedText ?? payload.text);
 					return;
 				}
+				if (finalMarkedText !== null) {
+					accumulatedText = payload.text;
+					return;
+				}
 				await startStreaming();
 				if (currentCardTarget) {
 					accumulatedText = payload.text;
 					const now = Date.now();
 					if (now - lastUpdateTime >= updateInterval) {
 						const { FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN, AUDIO_MARKER_PATTERN } = await import("./common-C8pYKU_y.mjs");
-						const displayContent = displayClean(finalMarkedText ?? accumulatedText).replace(FILE_MARKER_PATTERN, "").replace(VIDEO_MARKER_PATTERN, "").replace(AUDIO_MARKER_PATTERN, "").trim();
-						log.debug(`[DingTalk][onPartialReply] 更新 AI Card，显示文本长度=${displayContent.length}`);
+						const displayContent = displayClean(accumulatedText).replace(FILE_MARKER_PATTERN, "").replace(VIDEO_MARKER_PATTERN, "").replace(AUDIO_MARKER_PATTERN, "").trim();
 						lastUpdateTime = now;
 						try {
 							await streamAICard(currentCardTarget, displayContent, false, account.config, log, account.config?.cardContentVar || "msgContent");
-							log.debug(`[DingTalk][onPartialReply] ✅ AI Card 更新成功`);
 						} catch (err) {
 							if (isQpsLimitError(err)) log.warn(`[DingTalk][onPartialReply] AI Card 流式更新遇到 QPS 限流，已在内部退避重试；本次跳过，等待下一次 partial 更新补齐内容`);
 							else {
@@ -671,9 +694,26 @@ function createDingtalkReplyDispatcher(params) {
 								await sendFallbackErrorMessage("sendMessage", err.message);
 							}
 						}
-					} else log.debug(`[DingTalk][onPartialReply] 节流控制，跳过本次更新（距离上次更新 ${now - lastUpdateTime}ms）`);
-				} else log.warn(`[DingTalk][onPartialReply] ⚠️ AI Card 不存在，跳过更新`);
+					}
+				}
 			} },
+			onToolStart: async (payload) => {
+				const toolName = (payload?.name || "").trim();
+				if (!toolName) return;
+				if (payload?.phase === "end" || payload?.phase === "complete") return;
+				if (!streamingEnabled || asyncMode || finalMarkedText !== null) return;
+				try {
+					await startStreaming();
+					if (!currentCardTarget) return;
+					const now = Date.now();
+					if (now - lastUpdateTime < updateInterval) return;
+					lastUpdateTime = now;
+					await streamAICard(currentCardTarget, `🔧 正在调用工具：${toolName}`, false, account.config, log, account.config?.cardContentVar || "msgContent");
+					log.debug(`[DingTalk][onToolStart] 工具进度写卡：${toolName}（phase=${payload?.phase}）`);
+				} catch (e) {
+					if (!isQpsLimitError(e)) log.warn(`[DingTalk][onToolStart] 工具进度写卡失败：${e?.message || e}`);
+				}
+			},
 			onCommandOutput: (payload) => {
 				const dwsMatch = (payload.title || payload.name || "").match(DWS_PRODUCT_PATTERN) || payload.output?.match(DWS_PRODUCT_PATTERN);
 				if (dwsMatch) {