openclaw-lark-multi-agent 1.4.5 → 1.4.7

package/dist/feishu-bot.js

@@ -1825,9 +1825,10 @@ export class FeishuBot {
     }
     completionSummary(meta, emoji = "✅") {
         const en = meta.locale === "en";
-        return en
+        const core = en
             ? `${emoji} ${meta.toolCalls} tool call${meta.toolCalls === 1 ? "" : "s"} · ⏱ ${meta.elapsed}`
             : `${emoji} 累计${meta.toolCalls} 次工具调用 · ⏱ 耗时${meta.elapsed}`;
+        return meta.model?.trim() ? `${core} · 🧠 ${this.escapeCardText(meta.model.trim())}` : core;
     }
     /** Best-effort terminal cleanup for status-only rows and legacy v1.4.3
      * outbox entries that once targeted the live-status card. */
@@ -2654,6 +2655,7 @@ export class FeishuBot {
             const summary = this.completionSummary({
                 toolCalls: view.toolCalls,
                 elapsed: view.elapsed,
+                model: view.model,
                 locale: en ? "en" : "zh",
             }, statusEmoji);
             return {
@@ -2686,10 +2688,12 @@ export class FeishuBot {
             elements.push({ tag: "markdown", content: en ? "_working…_" : "_正在启动…_" });
         }
         elements.push({ tag: "hr" });
-        // Running/failed status owns timing; model attribution belongs to the final
-        // reply card so the two messages have clear, non-duplicated responsibilities.
-        const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
-        elements.push({ tag: "markdown", content: `<font color='grey'>${footer}</font>` });
+        // Keep the active model visible while the run is in progress or failed.
+        // The final reply also keeps model attribution so it remains self-contained.
+        const footerBits = [en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`];
+        if (view.model?.trim())
+            footerBits.push(`🧠 ${this.escapeCardText(view.model.trim())}`);
+        elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
         const template = view.state === "failed" ? "orange" : "blue";
         return {
             schema: "2.0",

package/dist/openclaw-client.d.ts

@@ -88,6 +88,9 @@ export declare class OpenClawClient {
     private extractVisibleAssistantText;
     private isVerboseTranscriptEnabled;
     private clearVerboseAssistantState;
+    /** Render protocol-4 structured tool args/results without `[object Object]`.
+     * Prefer useful, non-secret fields and keep the fallback bounded. */
+    private formatToolValue;
     private claimToolEvent;
     private pruneVerboseCaches;
     private flushVerboseAssistantState;

package/dist/openclaw-client.js

@@ -312,11 +312,13 @@ export class OpenClawClient {
                         if (this.claimToolEvent(rawKey, eventId, phase)) {
                             const meta = data.meta || data.input || data.args || "";
                             const output = data.output || data.result || data.error || "";
+                            const inputText = this.formatToolValue(meta, String(data.name), "start");
+                            const outputText = this.formatToolValue(output, String(data.name), phase);
                             if (toolCb)
-                                toolCb(`${data.name} ${phase}`.trim(), String(meta || ""), String(output || ""));
+                                toolCb(`${data.name} ${phase}`.trim(), inputText, outputText);
                             const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
                             if (progressCb) {
-                                const detail = phase === "start" ? String(meta || "") : String(output || meta || "");
+                                const detail = phase === "start" ? inputText : (outputText || inputText);
                                 void progressCb({ kind: "tool", phase, name: String(data.name), text: `${data.name} ${phase}${detail ? `: ${detail}` : ""}` });
                             }
                         }
@@ -343,12 +345,14 @@ export class OpenClawClient {
                         }
                         const input = data.input || data.args || data.meta || "";
                         const output = data.output || data.result || data.error || "";
+                        const inputText = this.formatToolValue(input, name, "start");
+                        const outputText = this.formatToolValue(output, name, phase);
                         const toolCb = this.toolEventCallbacks.get(rawKey) || this.toolEventCallbacks.get(shortKey);
                         if (toolCb)
-                            toolCb(`${name} ${phase}`, String(input || ""), String(output || ""));
+                            toolCb(`${name} ${phase}`, inputText, outputText);
                         const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
                         if (progressCb) {
-                            const detail = phase === "start" ? String(input || "") : String(output || input || "");
+                            const detail = phase === "start" ? inputText : (outputText || inputText);
                             void progressCb({ kind: "tool", phase, name, text: `${name} ${phase}${detail ? `: ${detail}` : ""}` });
                         }
                     }
@@ -451,6 +455,75 @@ export class OpenClawClient {
             this.verboseAssistantLastTouched.delete(key);
         }
     }
+    /** Render protocol-4 structured tool args/results without `[object Object]`.
+     * Prefer useful, non-secret fields and keep the fallback bounded. */
+    formatToolValue(value, toolName, phase) {
+        if (value === null || value === undefined || value === "")
+            return "";
+        if (typeof value === "string")
+            return value.trim();
+        if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+            return String(value);
+        if (Array.isArray(value)) {
+            const items = value.slice(0, 4).map((item) => this.formatToolValue(item, toolName, phase)).filter(Boolean);
+            return items.join("; ");
+        }
+        if (typeof value !== "object")
+            return String(value);
+        const record = value;
+        const read = (key) => this.formatToolValue(record[key], toolName, phase);
+        const first = (...keys) => {
+            for (const key of keys) {
+                if (!(key in record))
+                    continue;
+                const text = read(key);
+                if (text)
+                    return text;
+            }
+            return "";
+        };
+        // Tool-specific start summaries put the primary operation first.
+        if (phase === "start") {
+            if (toolName === "exec") {
+                const command = first("command", "cmd", "script");
+                const cwd = first("workdir", "cwd");
+                if (command)
+                    return cwd ? `${command} (cwd: ${cwd})` : command;
+            }
+            if (toolName === "read" || toolName === "write" || toolName === "edit" || toolName === "apply_patch") {
+                const path = first("path", "file", "filename");
+                if (path)
+                    return path;
+            }
+            if (toolName === "web_fetch") {
+                const url = first("url");
+                if (url)
+                    return url;
+            }
+            if (toolName === "web_search") {
+                const query = first("query");
+                if (query)
+                    return query;
+            }
+        }
+        const primary = phase === "start"
+            ? first("command", "path", "url", "query", "action", "target", "sessionKey", "key", "name", "description", "text")
+            : first("error", "message", "status", "exitCode", "output", "stdout", "stderr", "text", "result");
+        if (primary)
+            return primary;
+        // Safe generic fallback: omit fields that commonly carry credentials or
+        // large payloads, then serialize a few scalar fields only.
+        const blocked = /token|secret|password|auth|credential|cookie|buffer|content|data|env/i;
+        const parts = [];
+        for (const [key, raw] of Object.entries(record)) {
+            if (blocked.test(key) || raw === null || raw === undefined || typeof raw === "object")
+                continue;
+            parts.push(`${key}=${String(raw)}`);
+            if (parts.length >= 4)
+                break;
+        }
+        return parts.join(", ");
+    }
     claimToolEvent(sessionKey, eventId, phase, now = Date.now()) {
         const normalizedPhase = phase === "error" ? "end" : phase;
         const normalizedId = eventId.replace(/^(?:tool|command):/, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {