@larksuite/openclaw-lark 2026.4.1 → 2026.4.7-beta.0

package/index.js

@@ -22,6 +22,8 @@ const diagnose_1 = require("./src/commands/diagnose.js");
 const index_3 = require("./src/commands/index.js");
 const lark_logger_1 = require("./src/core/lark-logger.js");
 const security_check_1 = require("./src/core/security-check.js");
+const tool_use_trace_store_1 = require("./src/card/tool-use-trace-store.js");
+const reasoning_utils_1 = require("./src/card/reasoning-utils.js");
 const log = (0, lark_logger_1.larkLogger)('plugin');
 // ---------------------------------------------------------------------------
 // Re-exports for external consumers
@@ -105,20 +107,37 @@ const plugin = {
         (0, oauth_batch_auth_1.registerFeishuOAuthBatchAuthTool)(api);
         // Register AskUserQuestion tool (interactive card-based user prompting)
         (0, ask_user_question_1.registerAskUserQuestionTool)(api);
-        // ---- Tool call hooks (trace Feishu-owned tool invocations only) ----
-        api.on('before_tool_call', (event) => {
+        api.on('before_tool_call', (event, ctx) => {
+            (0, tool_use_trace_store_1.recordToolUseStart)({
+                sessionKey: ctx.sessionKey,
+                toolName: event.toolName,
+                toolParams: event.params,
+                toolCallId: event.toolCallId ?? ctx.toolCallId,
+                runId: event.runId ?? ctx.runId,
+            });
             if (!event.toolName.startsWith('feishu_'))
                 return;
-            log.info(`tool call: ${event.toolName} params=${JSON.stringify(event.params)}`);
+            const paramsPreview = (0, reasoning_utils_1.sanitizeParamsForLog)(event.params);
+            log.info(`tool call: ${event.toolName} session=${ctx.sessionKey ?? '-'} params=${paramsPreview}`);
         });
-        api.on('after_tool_call', (event) => {
+        api.on('after_tool_call', (event, ctx) => {
+            (0, tool_use_trace_store_1.recordToolUseEnd)({
+                sessionKey: ctx.sessionKey,
+                toolName: event.toolName,
+                toolParams: event.params,
+                toolCallId: event.toolCallId ?? ctx.toolCallId,
+                runId: event.runId ?? ctx.runId,
+                result: event.result,
+                error: event.error,
+                durationMs: event.durationMs,
+            });
             if (!event.toolName.startsWith('feishu_'))
                 return;
             if (event.error) {
-                log.error(`tool fail: ${event.toolName} ${event.error} (${event.durationMs ?? 0}ms)`);
+                log.error(`tool fail: ${event.toolName} session=${ctx.sessionKey ?? '-'} ${event.error} (${event.durationMs ?? 0}ms)`);
             }
             else {
-                log.info(`tool done: ${event.toolName} ok (${event.durationMs ?? 0}ms)`);
+                log.info(`tool done: ${event.toolName} session=${ctx.sessionKey ?? '-'} ok (${event.durationMs ?? 0}ms)`);
             }
         });
         // ---- Diagnostic commands ----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/openclaw-lark",
-  "version": "2026.4.1",
+  "version": "2026.4.7-beta.0",
   "description": "OpenClaw Lark/Feishu channel plugin",
   "exports": {
     ".": {

package/src/card/builder.d.ts

@@ -8,6 +8,7 @@
  * different agent response states (thinking, streaming, complete, confirm).
  */
 import type { FooterSessionMetrics } from './reply-dispatcher-types';
+import { type ToolUseDisplayStep } from './tool-use-display';
 /**
  * Element ID used for the streaming text area in cards. The CardKit
  * `cardElement.content()` API targets this element for typewriter-effect
@@ -15,12 +16,6 @@ import type { FooterSessionMetrics } from './reply-dispatcher-types';
  */
 export declare const STREAMING_ELEMENT_ID = "streaming_content";
 export declare const REASONING_ELEMENT_ID = "reasoning_content";
-export interface ToolCallInfo {
-    name: string;
-    status: 'running' | 'complete' | 'error';
-    args?: Record<string, unknown>;
-    result?: string;
-}
 export interface CardElement {
     tag: string;
     [key: string]: unknown;
@@ -76,6 +71,13 @@ export declare function formatReasoningDuration(ms: number): {
     zh: string;
     en: string;
 };
+/**
+ * Format tool-use duration into a human-readable i18n pair.
+ */
+export declare function formatToolUseDuration(ms: number): {
+    zh: string;
+    en: string;
+};
 /**
  * Format milliseconds into a human-readable duration string.
  */
@@ -108,7 +110,13 @@ export declare function buildCardContent(state: CardState, data?: {
     text?: string;
     reasoningText?: string;
     reasoningElapsedMs?: number;
-    toolCalls?: ToolCallInfo[];
+    toolUseSteps?: ToolUseDisplayStep[];
+    toolUseTitleSuffix?: {
+        zh: string;
+        en: string;
+    };
+    toolUseElapsedMs?: number;
+    showToolUse?: boolean;
     confirmData?: ConfirmData;
     elapsedMs?: number;
     isError?: boolean;
@@ -127,4 +135,18 @@ export declare function buildCardContent(state: CardState, data?: {
  * Convert an old-format FeishuCard to CardKit JSON 2.0 format.
  * JSON 2.0 uses `body.elements` instead of top-level `elements`.
  */
+/**
+ * Build the initial CardKit 2.0 streaming card with a loading icon.
+ * Optionally includes a tool-use pending panel above the streaming area.
+ */
+export declare function buildStreamingThinkingCard(showToolUse?: boolean): Record<string, unknown>;
+/**
+ * Build a CardKit 2.0 card for the pre-answer streaming phase.
+ * Used both for the initial card and for live updates during tool calls.
+ */
+export declare function buildStreamingPreAnswerCard(params: {
+    steps?: ToolUseDisplayStep[];
+    elapsedMs?: number;
+    showToolUse?: boolean;
+}): Record<string, unknown>;
 export declare function toCardKit2(card: FeishuCard): Record<string, unknown>;

package/src/card/builder.js

@@ -13,12 +13,16 @@ exports.REASONING_ELEMENT_ID = exports.STREAMING_ELEMENT_ID = void 0;
 exports.splitReasoningText = splitReasoningText;
 exports.stripReasoningTags = stripReasoningTags;
 exports.formatReasoningDuration = formatReasoningDuration;
+exports.formatToolUseDuration = formatToolUseDuration;
 exports.formatElapsed = formatElapsed;
 exports.compactNumber = compactNumber;
 exports.formatFooterRuntimeSegments = formatFooterRuntimeSegments;
 exports.buildCardContent = buildCardContent;
+exports.buildStreamingThinkingCard = buildStreamingThinkingCard;
+exports.buildStreamingPreAnswerCard = buildStreamingPreAnswerCard;
 exports.toCardKit2 = toCardKit2;
 const markdown_style_1 = require("./markdown-style.js");
+const tool_use_display_1 = require("./tool-use-display.js");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -124,6 +128,13 @@ function formatReasoningDuration(ms) {
     const d = formatElapsed(ms);
     return { zh: `思考了 ${d}`, en: `Thought for ${d}` };
 }
+/**
+ * Format tool-use duration into a human-readable i18n pair.
+ */
+function formatToolUseDuration(ms) {
+    const d = formatElapsed(ms);
+    return { zh: `执行耗时 ${d}`, en: `Tool use for ${d}` };
+}
 /**
  * Format milliseconds into a human-readable duration string.
  */
@@ -243,15 +254,23 @@ function buildCardContent(state, data = {}) {
         case 'thinking':
             return buildThinkingCard();
         case 'streaming':
-            return buildStreamingCard(data.text ?? '', data.toolCalls ?? [], data.reasoningText);
+            return buildStreamingCard(data.text ?? '', {
+                reasoningText: data.reasoningText,
+                showToolUse: data.showToolUse,
+                toolUseSteps: data.toolUseSteps,
+                toolUseTitleSuffix: data.toolUseTitleSuffix,
+            });
         case 'complete':
             return buildCompleteCard({
                 text: data.text ?? '',
-                toolCalls: data.toolCalls ?? [],
                 elapsedMs: data.elapsedMs,
                 isError: data.isError,
                 reasoningText: data.reasoningText,
                 reasoningElapsedMs: data.reasoningElapsedMs,
+                toolUseSteps: data.toolUseSteps,
+                toolUseTitleSuffix: data.toolUseTitleSuffix,
+                toolUseElapsedMs: data.toolUseElapsedMs,
+                showToolUse: data.showToolUse,
                 isAborted: data.isAborted,
                 footer: data.footer,
                 footerMetrics: data.footerMetrics,
@@ -277,8 +296,18 @@ function buildThinkingCard() {
         ],
     };
 }
-function buildStreamingCard(partialText, toolCalls, reasoningText) {
+function buildStreamingCard(partialText, params = {}) {
+    const { showToolUse = true, toolUseSteps, toolUseTitleSuffix, reasoningText } = params;
     const elements = [];
+    const hasToolUse = Boolean(toolUseSteps?.length);
+    if (showToolUse) {
+        elements.push(hasToolUse
+            ? buildToolUsePanel({
+                toolUseSteps,
+                titleSuffix: toolUseTitleSuffix,
+            })
+            : buildStreamingToolUsePendingPanel());
+    }
     if (!partialText && reasoningText) {
         // Reasoning phase: show reasoning content in notation style
         elements.push({
@@ -298,26 +327,21 @@ function buildStreamingCard(partialText, toolCalls, reasoningText) {
             content: (0, markdown_style_1.optimizeMarkdownStyle)(partialText),
         });
     }
-    // Tool calls in progress
-    if (toolCalls.length > 0) {
-        const toolLines = toolCalls.map((tc) => {
-            const statusIcon = tc.status === 'running' ? '\ud83d\udd04' : tc.status === 'complete' ? '\u2705' : '\u274c';
-            return `${statusIcon} ${tc.name} - ${tc.status}`;
-        });
-        elements.push({
-            tag: 'markdown',
-            content: toolLines.join('\n'),
-            text_size: 'notation',
-        });
-    }
     return {
         config: { wide_screen_mode: true, update_multi: true, locales: ['zh_cn', 'en_us'] },
         elements,
     };
 }
 function buildCompleteCard(params) {
-    const { text, toolCalls, elapsedMs, isError, reasoningText, reasoningElapsedMs, isAborted, footer, footerMetrics } = params;
+    const { text, elapsedMs, isError, reasoningText, reasoningElapsedMs, toolUseSteps, toolUseTitleSuffix, toolUseElapsedMs, showToolUse = true, isAborted, footer, footerMetrics, } = params;
     const elements = [];
+    if (showToolUse) {
+        elements.push(buildToolUsePanel({
+            toolUseSteps,
+            toolUseElapsedMs,
+            titleSuffix: toolUseTitleSuffix,
+        }));
+    }
     // Collapsible reasoning panel (before main content)
     if (reasoningText) {
         const dur = reasoningElapsedMs ? formatReasoningDuration(reasoningElapsedMs) : null;
@@ -361,18 +385,6 @@ function buildCompleteCard(params) {
         tag: 'markdown',
         content: (0, markdown_style_1.optimizeMarkdownStyle)(text),
     });
-    // Tool calls summary
-    if (toolCalls.length > 0) {
-        const toolSummaryLines = toolCalls.map((tc) => {
-            const statusIcon = tc.status === 'complete' ? '\u2705' : '\u274c';
-            return `${statusIcon} **${tc.name}** - ${tc.status}`;
-        });
-        elements.push({
-            tag: 'markdown',
-            content: toolSummaryLines.join('\n'),
-            text_size: 'notation',
-        });
-    }
     // Footer meta-info: split into two lines for readability.
     // Line 1 (primary): status · elapsed · model
     // Line 2 (detail):  tokens · cache · context
@@ -396,7 +408,7 @@ function buildCompleteCard(params) {
     if (footerZhLines.length > 0) {
         elements.push(...buildFooter(footerZhLines.join('\n'), footerEnLines.join('\n'), isError));
     }
-    // Use the answer text (not reasoning) as the feed preview summary.
+    // Use the answer text as the feed preview summary.
     // Strip markdown syntax so the preview reads as plain text.
     const summaryText = text.replace(/[*_`#>[\]()~]/g, '').trim();
     const summary = summaryText ? { content: summaryText.slice(0, 120) } : undefined;
@@ -486,6 +498,102 @@ function buildConfirmCard(confirmData) {
  * Convert an old-format FeishuCard to CardKit JSON 2.0 format.
  * JSON 2.0 uses `body.elements` instead of top-level `elements`.
  */
+/**
+ * Build the initial CardKit 2.0 streaming card with a loading icon.
+ * Optionally includes a tool-use pending panel above the streaming area.
+ */
+function buildStreamingThinkingCard(showToolUse = true) {
+    return buildStreamingPreAnswerCard({ showToolUse });
+}
+/**
+ * Build a CardKit 2.0 card for the pre-answer streaming phase.
+ * Used both for the initial card and for live updates during tool calls.
+ */
+function buildStreamingPreAnswerCard(params) {
+    const { steps, elapsedMs, showToolUse = true } = params;
+    const hasSteps = Boolean(steps?.length);
+    const elements = [];
+    if (showToolUse) {
+        elements.push(hasSteps ? buildStreamingToolUseActivePanel({ steps: steps, elapsedMs }) : buildStreamingToolUsePendingPanel());
+    }
+    elements.push({
+        tag: 'markdown',
+        content: '',
+        text_align: 'left',
+        text_size: 'normal_v2',
+        margin: '0px 0px 0px 0px',
+        element_id: exports.STREAMING_ELEMENT_ID,
+    });
+    elements.push({
+        tag: 'markdown',
+        content: ' ',
+        icon: {
+            tag: 'custom_icon',
+            img_key: 'img_v3_02vb_496bec09-4b43-4773-ad6b-0cdd103cd2bg',
+            size: '16px 16px',
+        },
+        element_id: 'loading_icon',
+    });
+    return {
+        schema: '2.0',
+        config: {
+            streaming_mode: true,
+            locales: ['zh_cn', 'en_us'],
+            summary: {
+                content: 'Processing...',
+                i18n_content: { zh_cn: '处理中...', en_us: 'Processing...' },
+            },
+        },
+        body: { elements },
+    };
+}
+/**
+ * Build the collapsible panel for the active pre-answer phase.
+ * Used by buildStreamingPreAnswerCard when at least one step exists.
+ */
+function buildStreamingToolUseActivePanel(params) {
+    const { steps, elapsedMs } = params;
+    const enParts = ['Tool use'];
+    const zhParts = ['工具执行'];
+    if (steps.length > 0) {
+        enParts.push(`${steps.length} step${steps.length === 1 ? '' : 's'}`);
+        zhParts.push(`${steps.length} 步`);
+    }
+    if (elapsedMs != null && elapsedMs > 0) {
+        const d = formatElapsed(elapsedMs);
+        enParts.push(`(${d})`);
+        zhParts.push(`(${d})`);
+    }
+    return {
+        tag: 'collapsible_panel',
+        expanded: true,
+        header: {
+            title: {
+                tag: 'plain_text',
+                content: `🛠️ ${enParts.join(' · ')}`,
+                i18n_content: {
+                    zh_cn: `🛠️ ${zhParts.join(' · ')}`,
+                    en_us: `🛠️ ${enParts.join(' · ')}`,
+                },
+                text_color: 'grey',
+                text_size: 'notation',
+            },
+            vertical_align: 'center',
+            icon: {
+                tag: 'standard_icon',
+                token: 'down-small-ccm_outlined',
+                color: 'grey',
+                size: '16px 16px',
+            },
+            icon_position: 'right',
+            icon_expanded_angle: -180,
+        },
+        border: { color: 'grey', corner_radius: '5px' },
+        vertical_spacing: '8px',
+        padding: '8px 8px 8px 8px',
+        elements: steps.map(buildToolUseStepElement),
+    };
+}
 function toCardKit2(card) {
     const result = {
         schema: '2.0',
@@ -496,3 +604,107 @@ function toCardKit2(card) {
         result.header = card.header;
     return result;
 }
+function buildStreamingToolUsePendingPanel() {
+    return {
+        tag: 'collapsible_panel',
+        expanded: false,
+        header: {
+            title: {
+                tag: 'plain_text',
+                content: '🛠️ Tool use pending',
+                i18n_content: {
+                    zh_cn: '🛠️ 等待工具执行',
+                    en_us: '🛠️ Tool use pending',
+                },
+                text_color: 'grey',
+                text_size: 'notation',
+            },
+            vertical_align: 'center',
+            icon: {
+                tag: 'standard_icon',
+                token: 'down-small-ccm_outlined',
+                color: 'grey',
+                size: '16px 16px',
+            },
+            icon_position: 'right',
+            icon_expanded_angle: -180,
+        },
+        border: { color: 'grey', corner_radius: '5px' },
+        vertical_spacing: '8px',
+        padding: '8px 8px 8px 8px',
+        elements: [],
+    };
+}
+function buildToolUsePanel(params) {
+    const { toolUseSteps = [], toolUseElapsedMs, titleSuffix } = params;
+    const duration = toolUseElapsedMs ? formatToolUseDuration(toolUseElapsedMs) : null;
+    const zhTitleParts = [duration?.zh ?? '工具执行'];
+    const enTitleParts = [duration?.en ?? 'Tool use'];
+    if (titleSuffix) {
+        zhTitleParts.push(titleSuffix.zh);
+        enTitleParts.push(titleSuffix.en);
+    }
+    const stepElements = toolUseSteps.length > 0 ? toolUseSteps.map((step) => buildToolUseStepElement(step)) : [buildToolUsePlaceholder()];
+    return {
+        tag: 'collapsible_panel',
+        expanded: false,
+        header: {
+            title: {
+                tag: 'plain_text',
+                content: `🛠️ ${enTitleParts.join(' · ')}`,
+                i18n_content: {
+                    zh_cn: `🛠️ ${zhTitleParts.join(' · ')}`,
+                    en_us: `🛠️ ${enTitleParts.join(' · ')}`,
+                },
+                text_color: 'grey',
+                text_size: 'notation',
+            },
+            vertical_align: 'center',
+            icon: {
+                tag: 'standard_icon',
+                token: 'down-small-ccm_outlined',
+                color: 'grey',
+                size: '16px 16px',
+            },
+            icon_position: 'right',
+            icon_expanded_angle: -180,
+        },
+        border: { color: 'grey', corner_radius: '5px' },
+        vertical_spacing: '8px',
+        padding: '8px 8px 8px 8px',
+        elements: stepElements,
+    };
+}
+function buildToolUseStepElement(step) {
+    return {
+        tag: 'div',
+        icon: {
+            tag: 'standard_icon',
+            token: step.iconToken,
+            color: 'grey',
+        },
+        text: {
+            tag: 'plain_text',
+            content: step.detail ? `${step.title}\n${step.detail}` : step.title,
+            text_color: 'grey',
+            text_size: 'notation',
+        },
+    };
+}
+function buildToolUsePlaceholder(labels) {
+    const zh = labels?.zh ?? '暂无工具步骤';
+    const en = labels?.en ?? tool_use_display_1.EMPTY_TOOL_USE_PLACEHOLDER;
+    return {
+        tag: 'div',
+        text: {
+            tag: 'plain_text',
+            content: en,
+            i18n_content: {
+                zh_cn: zh,
+                en_us: en,
+            },
+            text_color: 'grey',
+            text_size: 'notation',
+        },
+    };
+}

package/src/card/reasoning-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Shared utilities for the reasoning display subsystem.
+ */
+export declare function normalizeToolName(name?: string): string;
+export declare function truncateText(value: string, maxLength: number): string;
+export declare function redactInlineSecrets(value: string): string;
+/**
+ * Sanitize tool params for safe logging.
+ * Logs only param key names (no values) to avoid leaking sensitive data.
+ */
+export declare function sanitizeParamsForLog(params?: Record<string, unknown>): string;

package/src/card/reasoning-utils.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Shared utilities for the reasoning display subsystem.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToolName = normalizeToolName;
+exports.truncateText = truncateText;
+exports.redactInlineSecrets = redactInlineSecrets;
+exports.sanitizeParamsForLog = sanitizeParamsForLog;
+function normalizeToolName(name) {
+    return name?.trim().toLowerCase() ?? '';
+}
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+const INLINE_ASSIGNMENT_RE = /(^|[\s"'`])([A-Za-z_][A-Za-z0-9_]*)(=(?:"[^"]*"|'[^']*'|[^\s"'`]+))/g;
+const AUTH_HEADER_SECRET_RE = /(Authorization\s*:\s*(?:Bearer|Basic|Token)\s+)([^'"\s]+)/gi;
+const QUOTED_HEADER_ARG_RE = /((?:^|[\s"'`])(?:-H|--header)\s+)(['"])([A-Za-z0-9_-]+)(\s*:\s*)([^'"]*)(\2)/gi;
+const UNQUOTED_HEADER_ARG_RE = /((?:^|[\s"'`])(?:-H|--header)\s+)([A-Za-z0-9_-]+)(\s*:\s*)([^\s"'`]+)/gi;
+const SECRET_FLAG_RE = /((?:^|[\s"'`]))(--?[A-Za-z0-9][A-Za-z0-9-]*)(=|\s+)(?:"([^"]*)"|'([^']*)'|([^\s"'`]+))/g;
+const SENSITIVE_NAME_RE = /token|secret|password|api[_-]?key|authorization|cookie|credential|bearer|session[_-]?id|client[_-]?secret|access[_-]?key/i;
+function redactInlineSecrets(value) {
+    return value
+        .replace(INLINE_ASSIGNMENT_RE, (match, prefix, key) => isSensitiveName(key) ? `${prefix}${key}=[redacted]` : match)
+        .replace(AUTH_HEADER_SECRET_RE, '$1[redacted]')
+        .replace(QUOTED_HEADER_ARG_RE, (match, prefix, quote, name, separator) => shouldRedactHeaderValue(name) ? `${prefix}${quote}${name}${separator}[redacted]${quote}` : match)
+        .replace(UNQUOTED_HEADER_ARG_RE, (match, prefix, name, separator) => shouldRedactHeaderValue(name) ? `${prefix}${name}${separator}[redacted]` : match)
+        .replace(SECRET_FLAG_RE, (match, prefix, flag, separator, doubleQuoted, singleQuoted, bare) => {
+        const normalizedFlag = flag.replace(/^-+/, '');
+        if (!isSensitiveName(normalizedFlag))
+            return match;
+        const redactedValue = doubleQuoted !== undefined
+            ? '"[redacted]"'
+            : singleQuoted !== undefined
+                ? "'[redacted]'"
+                : bare !== undefined
+                    ? '[redacted]'
+                    : '[redacted]';
+        return `${prefix}${flag}${separator}${redactedValue}`;
+    });
+}
+function isSensitiveName(value) {
+    return SENSITIVE_NAME_RE.test(value);
+}
+function shouldRedactHeaderValue(name) {
+    return !/^authorization$/i.test(name) && isSensitiveName(name);
+}
+/**
+ * Sanitize tool params for safe logging.
+ * Logs only param key names (no values) to avoid leaking sensitive data.
+ */
+function sanitizeParamsForLog(params) {
+    if (!params || typeof params !== 'object')
+        return '';
+    const keys = Object.keys(params);
+    if (keys.length === 0)
+        return '{}';
+    return `{${keys.join(',')}}`;
+}

package/src/card/reply-dispatcher-types.d.ts

@@ -8,8 +8,10 @@
  * reply-dispatcher.ts, streaming-card-controller.ts, flush-controller.ts,
  * and unavailable-guard.ts.
  */
-import type { ClawdbotConfig, ReplyPayload } from 'openclaw/plugin-sdk';
+import type { ClawdbotConfig } from 'openclaw/plugin-sdk';
+import type { ReplyDispatcher } from 'openclaw/plugin-sdk/reply-runtime';
 import type { FeishuFooterConfig } from '../core/types';
+import type { ToolUseDisplayConfig } from './tool-use-config';
 export declare const CARD_PHASES: {
     readonly idle: "idle";
     readonly creating: "creating";
@@ -38,11 +40,17 @@ export interface ReasoningState {
     reasoningElapsedMs: number;
     isReasoningPhase: boolean;
 }
+export interface ToolUseState {
+    startedAt: number | null;
+    elapsedMs: number;
+    isActive: boolean;
+}
 export interface StreamingTextState {
     accumulatedText: string;
     completedText: string;
     streamingPrefix: string;
     lastPartialText: string;
+    lastFlushedText: string;
 }
 export interface CardKitState {
     cardKitCardId: string | null;
@@ -65,6 +73,7 @@ export declare const THROTTLE_CONSTANTS: {
     readonly PATCH_MS: 1500;
     readonly LONG_GAP_THRESHOLD_MS: 2000;
     readonly BATCH_AFTER_GAP_MS: 300;
+    readonly REASONING_STATUS_MS: 1500;
 };
 export declare const EMPTY_REPLY_FALLBACK_TEXT = "Done.";
 export interface CreateFeishuReplyDispatcherParams {
@@ -81,20 +90,7 @@ export interface CreateFeishuReplyDispatcherParams {
     skipTyping?: boolean;
     /** When true, replies are sent into the thread instead of main chat. */
     replyInThread?: boolean;
-}
-/**
- * Manual mirror of the SDK-internal ReplyDispatcher type
- * (from openclaw/plugin-sdk auto-reply/reply/reply-dispatcher.d.ts).
- *
- * Must be kept in sync when the SDK updates the dispatcher signature.
- */
-export interface ReplyDispatcher {
-    sendToolResult: (payload: ReplyPayload) => boolean;
-    sendBlockReply: (payload: ReplyPayload) => boolean;
-    sendFinalReply: (payload: ReplyPayload) => boolean;
-    waitForIdle: () => Promise<void>;
-    getQueuedCounts: () => Record<string, number>;
-    markComplete: () => void;
+    toolUseDisplay: ToolUseDisplayConfig;
 }
 /**
  * The structured return type of createFeishuReplyDispatcher.
@@ -128,5 +124,6 @@ export interface StreamingCardDeps {
     chatId: string;
     replyToMessageId: string | undefined;
     replyInThread: boolean | undefined;
+    toolUseDisplay: ToolUseDisplayConfig;
     resolvedFooter: Required<FeishuFooterConfig>;
 }

package/src/card/reply-dispatcher-types.js

@@ -56,5 +56,6 @@ exports.THROTTLE_CONSTANTS = {
     PATCH_MS: 1500,
     LONG_GAP_THRESHOLD_MS: 2000,
     BATCH_AFTER_GAP_MS: 300,
+    REASONING_STATUS_MS: 1500,
 };
 exports.EMPTY_REPLY_FALLBACK_TEXT = 'Done.';