cc-viewer 1.6.324 → 1.6.325

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="/assets/index-Cw_igOCh.js"></script>
+  <script type="module" crossorigin src="/assets/index-rSvTNrmP.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-x2KtHa4R.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-z6VSi4ab.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-Zi3mchEB.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.324",
+  "version": "1.6.325",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",

package/server/interceptor.js

@@ -41,6 +41,26 @@ export function resetStreamingState() {
   streamingState.chunksReceived = 0;
 }
 
+// ─── IM 逐字流式的文本源 ───
+// 钉钉 AI 卡片流式（server/lib/adapters/dingtalk-adapter.js）需要「对话过程中」的主 agent 增量文本。
+// 复用本拦截器对主 agent SSE 的增量解析，累计 text_delta（跳过 thinking_delta，与 im-bridge-core
+// 的 extractLastAssistantText「只取 text 块」一致），供 IM bridge 节流推送给钉钉 /card/streaming。
+// 关键：按「注入轮次」重置 —— 由 bridge 在 armActiveInjection 时调 resetImLiveText()。**绝不**在
+// resetStreamingState() 内重置：带工具的回合中间 streamingState 会 false↔true（每个 Anthropic API
+// 调用各一次），那样会把半截回复清空，typewriter 跨工具间隙断流。
+// 默认仅 IM worker 进程（CCV_IM_PLATFORM 已设）采集，其它进程零成本、不解析。
+let _imLiveText = '';
+const _imCaptureEnabled = !!process.env.CCV_IM_PLATFORM;
+export function getImLiveText() { return _imLiveText; }
+export function resetImLiveText() { _imLiveText = ''; }
+// 判定一个 SSE event 是否为可见正文 text_delta（跳过 thinking_delta / 工具入参 / 其它），是则返回其
+// 文本片段，否则 null。抽成纯函数：既给下方采集循环复用，也便于单测覆盖「只收 text_delta」规则。
+export function imTextDeltaOf(ev) {
+  return (ev && ev.type === 'content_block_delta'
+    && ev.delta && ev.delta.type === 'text_delta'
+    && typeof ev.delta.text === 'string') ? ev.delta.text : null;
+}
+
 // 缓存从请求 headers 中提取的 API Key 或 Authorization header
 export let _cachedApiKey = null;
 export let _cachedAuthHeader = null;
@@ -882,6 +902,9 @@ export function setupInterceptor() {
           // 实时流式：仅对 mainAgent 且 server live-port 已注入时启用
           let liveStreamEnabled = !!_livePort && requestEntry.mainAgent && !_isTeammate;
           const liveAssembler = liveStreamEnabled ? createStreamAssembler() : null;
+          // IM 逐字采集：独立于前端 live-stream / _livePort，仅 worker 内对主 agent 累计 text_delta。
+          const imCapture = _imCaptureEnabled && requestEntry.mainAgent && !_isTeammate;
+          let imStreamAppended = false; // 本 stream 是否已追加过；跨 API 调用的消息间补一个 \n\n 分隔
           let livePendingBuffer = '';
           let liveChunkSeq = 0;
           let liveLastFlushMs = 0;
@@ -1010,8 +1033,9 @@ export function setupInterceptor() {
                   streamedContentLen += chunk.length;
                   controller.enqueue(value);
 
-                  // 实时流式：增量解析完整的 SSE events 并触发节流 flush
-                  if (liveAssembler && liveStreamEnabled) {
+                  // 实时流式：增量解析完整的 SSE events。前端 live-stream（liveAssembler）与 IM 逐字
+                  // 采集（imCapture）共用同一次 split 解析，避免重复扫描；任一开启即进入。
+                  if ((liveAssembler && liveStreamEnabled) || imCapture) {
                     livePendingBuffer += chunk;
                     let sawBlockStop = false;
                     let idx;
@@ -1027,17 +1051,31 @@ export function setupInterceptor() {
                         : dataLine.substring(5);
                       try {
                         const ev = JSON.parse(jsonStr);
-                        liveAssembler.feed(ev);
-                        if (ev.type === 'content_block_stop') sawBlockStop = true;
+                        if (liveAssembler && liveStreamEnabled) {
+                          liveAssembler.feed(ev);
+                          if (ev.type === 'content_block_stop') sawBlockStop = true;
+                        }
+                        // IM 逐字：只累计可见正文 text_delta（跳过 thinking_delta / 工具入参），与
+                        // extractLastAssistantText 的「只取 text 块」对齐，避免 finalize 时闪烁/重复。
+                        if (imCapture) {
+                          const td = imTextDeltaOf(ev);
+                          if (td !== null) {
+                            if (!imStreamAppended && _imLiveText) _imLiveText += '\n\n'; // 跨 API 调用的消息间分隔
+                            imStreamAppended = true;
+                            _imLiveText += td;
+                          }
+                        }
                       } catch {}
                     }
-                    const now = Date.now();
-                    const overdue = (now - liveLastFlushMs) >= 100;
-                    const bigChunk = (streamedContentLen - liveLastFlushBytes) > 16384;
-                    if (sawBlockStop || overdue || bigChunk) {
-                      liveLastFlushMs = now;
-                      liveLastFlushBytes = streamedContentLen;
-                      liveFlush();
+                    if (liveAssembler && liveStreamEnabled) {
+                      const now = Date.now();
+                      const overdue = (now - liveLastFlushMs) >= 100;
+                      const bigChunk = (streamedContentLen - liveLastFlushBytes) > 16384;
+                      if (sawBlockStop || overdue || bigChunk) {
+                        liveLastFlushMs = now;
+                        liveLastFlushBytes = streamedContentLen;
+                        liveFlush();
+                      }
                     }
                   }
                 }

package/server/lib/adapters/dingtalk-adapter.js

@@ -16,6 +16,8 @@ const GROUP_SEND_URL = 'https://api.dingtalk.com/v1.0/robot/groupMessages/send';
 const OTO_SEND_URL = 'https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend';
 const CARD_CREATE_URL = 'https://api.dingtalk.com/v1.0/card/instances';
 const CARD_DELIVER_URL = 'https://api.dingtalk.com/v1.0/card/instances/deliver';
+const CARD_CREATE_AND_DELIVER_URL = 'https://api.dingtalk.com/v1.0/card/instances/createAndDeliver';
+const CARD_STREAMING_URL = 'https://api.dingtalk.com/v1.0/card/streaming';
 
 async function getAccessToken(cfg, ctx) {
   const tc = ctx.store.tokenCache;
@@ -54,6 +56,117 @@ function normalizeInbound(res) {
   };
 }
 
+// AI 卡片模板里「流式 Markdown 变量」的名字：用户可经 aiCardStreamKey 配置；留空按钉钉惯例用 'content'。
+function streamKeyOf(cfg) {
+  const k = cfg && typeof cfg.aiCardStreamKey === 'string' ? cfg.aiCardStreamKey.trim() : '';
+  return k || 'content';
+}
+
+// ─── 卡片投递目标字段（群 / 单聊的 openSpaceId + deliver model）───
+// 单一来源，消除 createAndDeliver(AI)、legacy deliver 两处重复的 conversationType==='2' 分支。
+function cardDeliverFields(target) {
+  const isGroup = String(target.conversationType) === '2';
+  return isGroup
+    ? { userIdType: 1, openSpaceId: 'dtv1.card//IM_GROUP.' + target.conversationId, imGroupOpenDeliverModel: { robotCode: target.robotCode } }
+    : { userIdType: 1, openSpaceId: 'dtv1.card//IM_ROBOT.' + target.senderStaffId, imRobotOpenDeliverModel: { spaceType: 'IM_ROBOT', robotCode: target.robotCode } };
+}
+
+// createAndDeliver（AI 卡片）在 deliver 字段之上还需 OpenSpaceModel(supportForward)。legacy 的 deliver
+// 端点只用 cardDeliverFields（不带 OpenSpaceModel，保持原报文不变）。
+function cardSpaceFields(target) {
+  const isGroup = String(target.conversationType) === '2';
+  return { ...cardDeliverFields(target), [isGroup ? 'imGroupOpenSpaceModel' : 'imRobotOpenSpaceModel']: { supportForward: true } };
+}
+
+// AI 卡片：createAndDeliver 单调用建卡 + 投递（callbackType STREAM、flowStatus=处理中、content 空），
+// 再补一帧空 content「kick」开启流式生命周期（群尤其需要）。返回 { outTrackId, streaming:true }。
+async function createAiCard(cfg, target, ctx) {
+  const token = await getAccessToken(cfg, ctx);
+  const outTrackId = randomUUID();
+  const r = await ctx.fetch(CARD_CREATE_AND_DELIVER_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-acs-dingtalk-access-token': token },
+    body: JSON.stringify({
+      cardTemplateId: cfg.aiCardTemplateId,
+      outTrackId,
+      callbackType: 'STREAM',
+      cardData: { cardParamMap: { [streamKeyOf(cfg)]: '', flowStatus: '1' } }, // cardParamMap 值必须为字符串
+      ...cardSpaceFields(target),
+    }),
+  });
+  if (!r.ok) { const j = await r.json().catch(() => ({})); throw new Error(`ai-card create ${r.status}: ${j.message || j.code || 'failed'}`); }
+  const handle = { outTrackId, streaming: true };
+  // kick：开启流式生命周期。best-effort——权限缺失时 finalize 的 instances PUT 仍能兜底落最终内容。
+  await streamFrame(cfg, handle, '', ctx, {}).catch(() => {});
+  return handle;
+}
+
+// legacy 卡片：create + deliver 两步（沿用原 status+content 模板变量）。无 cardTemplateId 返回 null。
+async function createLegacyCard(cfg, target, statusText, ctx) {
+  if (!cfg.cardTemplateId) return null;
+  const token = await getAccessToken(cfg, ctx);
+  const outTrackId = randomUUID();
+  const headers = { 'Content-Type': 'application/json', 'x-acs-dingtalk-access-token': token };
+  const cr = await ctx.fetch(CARD_CREATE_URL, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      outTrackId,
+      cardTemplateId: cfg.cardTemplateId,
+      cardData: { cardParamMap: { status: statusText, content: '' } },
+    }),
+  });
+  if (!cr.ok) { const j = await cr.json().catch(() => ({})); throw new Error(`card create ${cr.status}: ${j.message || j.code || 'failed'}`); }
+
+  const dr = await ctx.fetch(CARD_DELIVER_URL, { method: 'POST', headers, body: JSON.stringify({ outTrackId, ...cardDeliverFields(target) }) });
+  if (!dr.ok) { const j = await dr.json().catch(() => ({})); throw new Error(`card deliver ${dr.status}: ${j.message || j.code || 'failed'}`); }
+  return { outTrackId };
+}
+
+// 一帧流式更新（PUT /card/streaming）。isFull:true 全量重发（幂等自愈丢帧）；7 字段含 isError。
+async function streamFrame(cfg, handle, fullText, ctx, opts = {}) {
+  try {
+    if (!handle?.outTrackId) return false;
+    const token = await getAccessToken(cfg, ctx);
+    const r = await ctx.fetch(CARD_STREAMING_URL, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json', 'x-acs-dingtalk-access-token': token },
+      body: JSON.stringify({
+        outTrackId: handle.outTrackId,
+        guid: randomUUID(),
+        key: streamKeyOf(cfg),
+        content: String(fullText ?? ''),
+        isFull: true,
+        isFinalize: !!opts.finalize,
+        isError: !!opts.error,
+      }),
+    });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
+// 局部更新卡片变量（PUT /card/instances，updateCardDataByKey 只改传入键）。值须全字符串。
+async function putCardInstances(cfg, handle, cardParamMap, ctx) {
+  try {
+    if (!handle?.outTrackId) return false;
+    const token = await getAccessToken(cfg, ctx);
+    const r = await ctx.fetch(CARD_CREATE_URL, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json', 'x-acs-dingtalk-access-token': token },
+      body: JSON.stringify({
+        outTrackId: handle.outTrackId,
+        cardData: { cardParamMap },
+        cardUpdateOptions: { updateCardDataByKey: true },
+      }),
+    });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
 const dingtalkAdapter = {
   id: 'dingtalk',
   i18nNs: 'server.dingtalk',
@@ -123,50 +236,40 @@ const dingtalkAdapter = {
   // 触发钉钉风控/限流，反过来阻断模型回复的下发。故 DingTalk 发送者头像在「对话记录」里降级为默认头像
   // （名字仍是真实昵称，不报错、不抢占发送配额）。后续如引入具备通讯录 scope 的凭证再补 resolveSender。
 
+  // ack 卡片：aiCardTemplateId 非空 → AI 卡片（flowStatus 状态标签 + /card/streaming 逐字）；建卡
+  // 失败则降级 legacy 卡片（cardTemplateId 单次更新）；都没有 → 返回 null，core 发纯文本 ack。
   async sendAckCard(cfg, target, statusText, ctx) {
-    if (!cfg.cardTemplateId) return null;
-    const token = await getAccessToken(cfg, ctx);
-    const outTrackId = randomUUID();
-    const headers = { 'Content-Type': 'application/json', 'x-acs-dingtalk-access-token': token };
-
-    const cr = await ctx.fetch(CARD_CREATE_URL, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        outTrackId,
-        cardTemplateId: cfg.cardTemplateId,
-        cardData: { cardParamMap: { status: statusText, content: '' } },
-      }),
-    });
-    if (!cr.ok) { const j = await cr.json().catch(() => ({})); throw new Error(`card create ${cr.status}: ${j.message || j.code || 'failed'}`); }
-
-    const isGroup = String(target.conversationType) === '2';
-    const deliverBody = isGroup
-      ? {
-          outTrackId,
-          userIdType: 1,
-          openSpaceId: 'dtv1.card//IM_GROUP.' + target.conversationId,
-          imGroupOpenDeliverModel: { robotCode: target.robotCode },
-        }
-      : {
-          outTrackId,
-          userIdType: 1,
-          openSpaceId: 'dtv1.card//IM_ROBOT.' + target.senderStaffId,
-          imRobotOpenDeliverModel: { spaceType: 'IM_ROBOT', robotCode: target.robotCode },
-        };
-
-    const dr = await ctx.fetch(CARD_DELIVER_URL, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(deliverBody),
-    });
-    if (!dr.ok) { const j = await dr.json().catch(() => ({})); throw new Error(`card deliver ${dr.status}: ${j.message || j.code || 'failed'}`); }
+    if (cfg.aiCardTemplateId) {
+      try {
+        return await createAiCard(cfg, target, ctx);
+      } catch (e) {
+        // 把失败原因留在 store，供 core 落审计（即便降级 legacy 也能诊断「为什么没流式」）。
+        if (ctx?.store) ctx.store.lastAiCardError = String(e?.message || e);
+        // AI 卡片创建失败：有 legacy 模板则降级单卡片，否则抛给 core 走纯文本。
+        if (!cfg.cardTemplateId) throw e;
+      }
+    }
+    return await createLegacyCard(cfg, target, statusText, ctx);
+  },
 
-    return { outTrackId };
+  // 对话过程中逐字推送（core 的 streamTimer 调用）。仅 AI 卡片句柄有效；best-effort 返回 bool。
+  async streamCardText(cfg, target, handle, fullText, ctx, opts = {}) {
+    if (!handle?.streaming) return false;
+    return streamFrame(cfg, handle, fullText, ctx, opts);
   },
 
   async updateAckCard(cfg, target, handle, content, status, ctx) {
     try {
+      if (handle?.streaming) {
+        const flowStatus = status === 'done' ? '3' : '5'; // 执行完成 / 执行失败（含中断·超时）
+        // 官方 finalize：流式帧 isFinalize:true 收尾。
+        const streamed = await streamFrame(cfg, handle, content, ctx, { finalize: true, error: status !== 'done' });
+        // 再用 /card/instances 落定权威全文 + 状态标签：即便缺 Card.Streaming.Write 权限这步仍生效，
+        // 保证最终内容与 tag 一定渲染、不会卡在「处理中」。
+        const settled = await putCardInstances(cfg, handle, { [streamKeyOf(cfg)]: String(content ?? ''), flowStatus }, ctx);
+        return streamed || settled;
+      }
+      // legacy 卡片：单次 PUT 更新 content。
       const token = await getAccessToken(cfg, ctx);
       const r = await ctx.fetch(CARD_CREATE_URL, {
         method: 'PUT',

package/server/lib/im-bridge-core.js

@@ -35,6 +35,13 @@ const IDLE_POLL_INTERVAL_MS = 5_000;     // check every 5s if streaming stopped
 const IDLE_POLL_THRESHOLD = 3;           // 3 consecutive idle ticks (15s) → synthetic turn_end
 const CONNECT_TIMEOUT_MS = 15_000;       // bound adapter.connect() so a hung start can't block others
 const STOP_WORDS = new Set(['/stop', 'stop', '停止', 'esc', '/esc']);
+// ─── 逐字流式（钉钉 AI 卡片）推送节流：每帧计费，故节流 + 帧上限 ───
+// 推送轮询间隔。300ms：数秒级回复约展示 10 帧打字机效果；过大→短/秒回回复在首 tick 前就 finalize、
+// 看不到流式；过小→帧数与计费上升，且建卡本身有网络往返、再低收益有限。测试经 __setStreamTickMsForTests 调低。
+let STREAM_TICK_MS = 300;
+const STREAM_MIN_DELTA = 20;             // 累计增长达 20 字才推一帧（对齐钉钉官方节流，省调用）
+const STREAM_MAX_FRAMES = 25;            // 每回合中途流式帧硬上限；超限停推，finalize 仍落全文
+const STREAM_MAX_CHARS = 20_000;         // 卡片内容字符上限，超出截断
 
 // ─── registry + core-global single-flight ───
 const instances = new Map();             // platformId → instance
@@ -64,6 +71,7 @@ function newInstance(adapter) {
     sendTimes: [],
     store: {},                           // adapter scratch (token cache, send client)
     ackCardPromise: null,                 // Promise<handle|null> for the in-flight ack card
+    streamTimer: null,                    // 逐字流式推送定时器（AI 卡片）；绑当前注入 slot 生命周期
   };
 }
 
@@ -168,11 +176,69 @@ async function finalizeAckCard(inst, target, text, status) {
 
 // ─── activeInjection lifecycle ───
 function clearActiveInjection() {
+  // 先停掉持有 slot 的实例的逐字流式定时器（slot 释放的每条路径都经此：turn-end / /stop / 超时 /
+  // inject-fail / stopBridge），杜绝定时器泄漏与 finalize 后的乱序推送。
+  if (activeInjection) {
+    const owner = instances.get(activeInjection.platformId);
+    if (owner && owner.streamTimer) { clearInterval(owner.streamTimer); owner.streamTimer = null; }
+  }
   activeInjection = null;
   if (activeInjectionTimer) { clearTimeout(activeInjectionTimer); activeInjectionTimer = null; }
   if (idlePollTimer) { clearInterval(idlePollTimer); idlePollTimer = null; }
   idlePollCount = 0;
 }
+
+// slot 仍属本次注入？streamTick 入口与每次 await 后都要重验——slot 可能在 await 期间被 finalize/释放，
+// 重验保证 finalize 永远是最后一次 PUT、定时器也不在易主后继续推。
+function isSlotOwned(inst, since) {
+  return !!activeInjection && activeInjection.platformId === inst.adapter.id && activeInjection.since === since;
+}
+
+/**
+ * 逐字流式推送一帧（钉钉 AI 卡片）。常驻 setInterval 驱动，贯穿本注入 slot 生命周期——**不**随
+ * isStreaming() 抖动停（带工具的回合中间 streamingState 每个 API 调用会 false↔true，停了就断流）。
+ * 全程 best-effort：任何失败都不影响最终 finalize（notifyTurnEnd 用 transcript 权威全文落定）。
+ */
+async function streamTick(inst, since) {
+  // slot 已释放/易主 → 自停（定时器自清）
+  if (!isSlotOwned(inst, since)) {
+    if (inst.streamTimer) { clearInterval(inst.streamTimer); inst.streamTimer = null; }
+    return;
+  }
+  if (inst._streamInFlight) return;          // 单 in-flight：避免乱序 PUT（钉钉靠 guid 排序）
+  if (inst._streamHandle === null) return;   // 已判定不可流式（无句柄 / 非 AI 卡片）
+  const d = inst.bridgeDeps;
+  if (!d || typeof d.getLiveText !== 'function') return;
+  // 解析一次 ack 卡片句柄并缓存：null/非流式 → 永久关停本轮推送，不再每 tick 重复 await。
+  if (inst._streamHandle === undefined) {
+    inst._streamHandle = (await inst.ackCardPromise?.catch(() => null)) ?? null;
+    // 落审计便于诊断：streaming=false 说明 AI 卡片建卡失败/回退 legacy（aiErr 给出钉钉返回的原因）；
+    // liveLen=0 说明文本源没采到（多半 mainAgent 判定或采集开关问题）。
+    audit(inst, 'stream-handle', { streaming: !!inst._streamHandle?.streaming, liveLen: (d.getLiveText?.() || '').length, aiErr: inst.store?.lastAiCardError || undefined });
+    if (!inst._streamHandle?.streaming) { inst._streamHandle = null; return; }
+  }
+  if (inst._streamFrames >= STREAM_MAX_FRAMES) return; // 计费上限：停中途推送，finalize 仍落全文
+  let text = d.getLiveText();
+  if (typeof text !== 'string') return;
+  if (text.length > STREAM_MAX_CHARS) text = text.slice(0, STREAM_MAX_CHARS);
+  if (text.length - (inst._streamPushedLen || 0) < STREAM_MIN_DELTA) return; // 增长不足，省调用
+  inst._streamInFlight = true;
+  const target = activeInjection.target;
+  const cfg = d.getConfig();
+  const ok = await inst.adapter.streamCardText(cfg, target, inst._streamHandle, text, ctxFor(inst)).catch(() => false);
+  inst._streamInFlight = false;
+  // await 后重新校验 slot：期间可能已 finalize/释放 → 本帧作废，不计数（保证 finalize 是最后一次 PUT）。
+  if (!isSlotOwned(inst, since)) return;
+  // 落审计：ok=false 说明 /card/streaming 被拒（多半 Card.Streaming.Write 权限缺失）；ok=true 却看不到
+  // 流式则多半是 AI 卡片模板里流式变量名不叫 content（见 streamFrame 的 key）。
+  audit(inst, 'stream-push', { len: text.length, ok });
+  if (ok) {
+    inst._streamPushedLen = text.length;
+    inst._streamFrames = (inst._streamFrames || 0) + 1;
+    if (inst._streamFrames === STREAM_MAX_FRAMES) audit(inst, 'stream-frame-cap', { conversationId: target?.conversationId, frames: inst._streamFrames });
+    idlePollCount = 0; // 有流式活动 → 重置空闲计数，避免 idlePoll 误判触发合成 turn_end
+  }
+}
 function armActiveInjection(inst, target, since) {
   activeInjection = { platformId: inst.adapter.id, since, target, transcriptPath: null };
   if (activeInjectionTimer) clearTimeout(activeInjectionTimer);
@@ -205,6 +271,34 @@ function armActiveInjection(inst, target, since) {
     }
   }, IDLE_POLL_INTERVAL_MS);
   if (typeof idlePollTimer.unref === 'function') idlePollTimer.unref();
+
+  // 逐字流式（钉钉 AI 卡片）：仅当配了 aiCardTemplateId、开了 ack 卡片、且平台具备流式能力（worker
+  // 注入了 getLiveText + 适配器实现 streamCardText）时启动常驻推送定时器。注入轮次开始即重置文本源。
+  const cfg = inst.bridgeDeps?.getConfig?.();
+  if (cfg && cfg.aiCardTemplateId) {
+    const canStream = cfg.ackCard !== false
+      && typeof inst.bridgeDeps.getLiveText === 'function'
+      && typeof inst.adapter.streamCardText === 'function';
+    if (canStream) {
+      inst.bridgeDeps.resetLiveText?.();
+      if (inst.store) inst.store.lastAiCardError = null; // 清上一轮的诊断残留
+      inst._streamPushedLen = 0;
+      inst._streamFrames = 0;
+      inst._streamHandle = undefined; // 首 tick 解析一次后缓存（null = 不可流式）
+      inst._streamInFlight = false;
+      if (inst.streamTimer) clearInterval(inst.streamTimer);
+      inst.streamTimer = setInterval(() => { void streamTick(inst, since); }, STREAM_TICK_MS);
+      if (typeof inst.streamTimer.unref === 'function') inst.streamTimer.unref();
+      audit(inst, 'stream-armed', { conversationId: target?.conversationId });
+    } else {
+      // 配了 aiCardTemplateId 却没起流式：把原因落审计，便于诊断「没有流式输出」。
+      audit(inst, 'stream-skip', {
+        reason: cfg.ackCard === false ? 'ackCardOff'
+          : typeof inst.bridgeDeps?.getLiveText !== 'function' ? 'noGetLiveText(非 worker?)'
+            : 'noStreamCardText',
+      });
+    }
+  }
 }
 
 // ─── small helpers ───
@@ -543,6 +637,22 @@ export async function notifyTurnEnd(sessionId, ts, transcriptPath) {
   const handle = await ackP?.catch(() => null);
   if (handle && typeof inst.adapter.updateAckCard === 'function') {
     const cfg = inst.bridgeDeps.getConfig();
+    if (handle.streaming) {
+      // AI 卡片：整条回复就在卡片内（流式期间已逐字呈现）。finalize 用 transcript 权威全文一次性
+      // 落定 + 状态标签（执行完成），**不分块、不另发消息**——避免把已显示的全文截回首块。
+      let full = text;
+      if (full.length > STREAM_MAX_CHARS) full = full.slice(0, STREAM_MAX_CHARS) + '\n\n' + tr(inst, 'truncated');
+      try {
+        const updated = await inst.adapter.updateAckCard(cfg, target, handle, full, 'done', ctxFor(inst));
+        if (!updated) await sendReply(inst, target, text);
+        audit(inst, 'out', { conversationId: target.conversationId, streaming: true, cardUpdated: !!updated });
+      } catch (e) {
+        inst.lastError = String(e?.message || e);
+        audit(inst, 'card-update-error', { error: inst.lastError });
+        try { await sendReply(inst, target, text); } catch { /* already logged in sendReply */ }
+      }
+      return;
+    }
     let chunks = chunkText(text, cfg.maxChunkChars);
     if (chunks.length > MAX_CHUNKS_PER_TURN) {
       chunks = chunks.slice(0, MAX_CHUNKS_PER_TURN);
@@ -610,6 +720,7 @@ export async function stopBridge(id) {
     inst.ackCardPromise = null;
   }
   try { await inst.adapter.disconnect?.(inst.client, ctxFor(inst)); } catch { /* best-effort */ }
+  if (inst.streamTimer) { clearInterval(inst.streamTimer); inst.streamTimer = null; } // 防御：流式定时器不泄漏
   inst.client = null;
   inst.running = false;
   inst.connected = false;
@@ -667,6 +778,8 @@ export async function stopAll() {
 }
 
 // ─── test seams ───
+export function __setStreamTickMsForTests(ms) { STREAM_TICK_MS = (ms == null ? 300 : ms); }
+
 export function __setMaxQueueForTests(id, n) {
   const inst = instances.get(id);
   if (inst) inst.maxQueueOverride = n;
@@ -681,6 +794,8 @@ export function __resetForTests(id) {
   inst.maxQueueOverride = null;
   inst.seenMsgIds.length = 0; inst.queue.length = 0; inst.sendTimes.length = 0;
   inst.store = {};
+  inst.ackCardPromise = null;
+  if (inst.streamTimer) { clearInterval(inst.streamTimer); inst.streamTimer = null; }
   if (activeInjection && activeInjection.platformId === id) clearActiveInjection();
 }
 

package/server/lib/im-config.js

@@ -34,7 +34,7 @@ const DESCRIPTORS = {
     allowListField: 'allowStaffIds',
     defaults: {
       enabled: false, appKey: '', appSecret: '', allowStaffIds: [],
-      maxChunkChars: 3800, blockOnSkipPermissions: false, ackCard: true, cardTemplateId: '',
+      maxChunkChars: 3800, blockOnSkipPermissions: false, ackCard: true, cardTemplateId: '', aiCardTemplateId: '', aiCardStreamKey: '',
     },
     fields: [
       { key: 'enabled', type: 'bool' },
@@ -45,6 +45,11 @@ const DESCRIPTORS = {
       { key: 'blockOnSkipPermissions', type: 'bool' },
       { key: 'ackCard', type: 'bool', default: true },
       { key: 'cardTemplateId', type: 'string' },
+      // AI 卡片场景模板 id（声明流式变量 + flowStatus 状态变量）。非空即启用「逐字流式 +
+      // flowStatus 状态标签」AI 卡片；留空回退到 cardTemplateId 普通卡片或纯文本。
+      { key: 'aiCardTemplateId', type: 'string' },
+      // AI 卡片模板里那个「流式 Markdown 变量」的名字。留空按钉钉/官方惯例用 'content'；模板若用别名在此填。
+      { key: 'aiCardStreamKey', type: 'string' },
     ],
   },
   feishu: {

package/server/routes/dingtalk.js

@@ -82,6 +82,8 @@ function dingtalkConfigPost(req, res, parsedUrl, isLocal, deps) {
       blockOnSkipPermissions: incoming.blockOnSkipPermissions,
       ackCard: incoming.ackCard,
       cardTemplateId: incoming.cardTemplateId,
+      aiCardTemplateId: incoming.aiCardTemplateId,
+      aiCardStreamKey: incoming.aiCardStreamKey,
     });
     // 驱动进程管理器（替代旧的在进程 reloadBridge）：启用→重启 worker，停用→停 worker。
     try {

package/server/server.js

@@ -71,7 +71,7 @@ function execWithStdin(cmd, args, input, options) {
     child.stdin.end();
   });
 }
-import { LOG_FILE, _initPromise, _resumeState, _projectName, _logDir, streamingState, resetStreamingState, PROFILE_PATH, setLivePort } from './interceptor.js';
+import { LOG_FILE, _initPromise, _resumeState, _projectName, _logDir, streamingState, resetStreamingState, PROFILE_PATH, setLivePort, getImLiveText, resetImLiveText } from './interceptor.js';
 import { recordInstance, listInstances } from './lib/instance-registry.js';
 import { LOG_DIR, setLogDir, getClaudeConfigDir } from '../findcc.js';
 import { t, getLang, setLang } from './i18n.js';
@@ -1035,6 +1035,10 @@ export async function startViewer() {
                 getPtySkipPermissions: pmb.getPtySkipPermissions,
                 isStreaming: () => streamingState.active,
                 getConfig: () => loadConfig(id),
+                // 钉钉 AI 卡片逐字流式的文本源（仅 worker 注入）：对话过程中读主 agent 累计文本，
+                // 注入轮次开始时重置。其它平台/主 ccv 无此 dep，core 判空即跳过流式。
+                getLiveText: () => getImLiveText(),
+                resetLiveText: () => resetImLiveText(),
               });
             } catch (e) {
               console.error(`[CC Viewer] IM worker startBridge(${id}) failed:`, e?.message || e);