openclaw-lark-multi-agent 1.4.5 → 1.4.6

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.6",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {