openclaw-lark-multi-agent 1.6.0 → 1.7.0

package/dist/openclaw-client.js

@@ -1,4 +1,5 @@
 import WebSocket from "ws";
+import { safeErrorSummary } from "./provider-errors.js";
 import { inspectError, genericFailure } from "./terminal-errors.js";
 import { SessionWaitPaused, normalizeSessionRuntimeStatus, isWaitTimeout, FOREGROUND_WAIT_MS } from "./session-status.js";
 import { createHash, randomUUID } from "crypto";
@@ -37,6 +38,12 @@ const MAX_INLINE_CONTEXT_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MA
  * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
  */
 export class OpenClawClient {
+    goEvidenceObservers = new Set();
+    /** Raw full event observer. Observation is NOT a Feishu delivery receipt. */
+    observeGoEvidence(callback) {
+        this.goEvidenceObservers.add(callback);
+        return () => { this.goEvidenceObservers.delete(callback); };
+    }
     config;
     ws = null;
     pending = new Map();
@@ -270,6 +277,16 @@ export class OpenClawClient {
                         this.agentEvents.get(sk).push(frame.payload);
                     }
                 }
+                if (frame.type === "event" && ["agent", "chat", "session.message"].includes(frame.event)) {
+                    for (const observer of this.goEvidenceObservers) {
+                        try {
+                            observer({ channel: frame.event, payload: frame.payload });
+                        }
+                        catch (error) {
+                            console.warn("[OpenClaw] Go evidence observer failed:", error.message);
+                        }
+                    }
+                }
                 // Log all events for debugging
                 if (frame.type === "event" && frame.event !== "tick") {
                     console.log(`[OpenClaw] Event: ${frame.event}`, JSON.stringify(frame.payload || {}).substring(0, 200));
@@ -307,7 +324,7 @@ export class OpenClawClient {
                             data: { deltaText: visibleAssistantText, delta: visibleAssistantText, replace: true },
                         });
                     }
-                    this.handleProactiveSessionMessage(rawKey, msg, frame.payload.runId);
+                    this.handleProactiveSessionMessage(rawKey, msg, frame.payload.runId, frame.payload.sessionId);
                     // Tool calls in assistant messages — skip, using agent item events instead
                     // (session.message toolCall events are batched, not real-time)
                 }
@@ -403,7 +420,7 @@ export class OpenClawClient {
                 if (!handshakeDone)
                     reject(err);
                 else
-                    console.error("[OpenClaw] WS error:", err.message);
+                    console.error("[OpenClaw] WS error:", safeErrorSummary(err));
             });
             this.ws.on("close", () => {
                 this.connected = false;
@@ -651,7 +668,7 @@ export class OpenClawClient {
             this.flushVerboseAssistantState(rawKey);
         }
     }
-    handleProactiveSessionMessage(rawKey, msg, runId) {
+    handleProactiveSessionMessage(rawKey, msg, runId, sessionId) {
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
         // Proactive assistant text messages. Cron/session-targeted runs often emit
         // structured content arrays rather than a plain string. Extract only visible
@@ -688,7 +705,7 @@ export class OpenClawClient {
         const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
         if (cb) {
             if (runId)
-                cb(proactiveText, { runId, sessionKey: this.canonicalSessionKey(rawKey), final: msg?.stopReason === "stop",
+                cb(proactiveText, { runId, sessionId, sessionKey: this.canonicalSessionKey(rawKey), final: msg?.stopReason === "stop",
                     ...(!msg?.stopReason && genericFailure(proactiveText) ? { genericErrorCandidate: true } : {}) });
             else
                 cb(proactiveText);
@@ -706,7 +723,7 @@ export class OpenClawClient {
                 console.log("[OpenClaw] Reconnected successfully");
             }
             catch (err) {
-                console.error("[OpenClaw] Reconnect failed:", err.message);
+                console.error("[OpenClaw] Reconnect failed:", safeErrorSummary(err));
                 if (this.shouldReconnect)
                     this.scheduleReconnect();
             }
@@ -1067,6 +1084,10 @@ export class OpenClawClient {
                         const evRunId = typeof ev.runId === "string" ? ev.runId : "";
                         const eventSessionMatches = Boolean(sessionKey && (ev.sessionKey === sessionKey || ev.sessionKey === targetSessionKey || ev.sessionKey === shortSessionKey));
                         const matchesRun = evRunId ? activeRunIds.has(evRunId) : false;
+                        if (options?.exactRunIdentity && !matchesRun) {
+                            i++;
+                            continue;
+                        }
                         if (!sessionKey && ev.sessionKey) {
                             shortSessionKey = String(ev.sessionKey).replace(/^agent:[^:]+:/, "");
                             sessionKey = `agent:main:${shortSessionKey}`;
@@ -1114,7 +1135,7 @@ export class OpenClawClient {
                             continue;
                         }
                         let matchesSession = false;
-                        if (eventSessionMatches && anchorSeen) {
+                        if (!options?.exactRunIdentity && eventSessionMatches && anchorSeen) {
                             if (!expectedUserText) {
                                 // Backward-compatible mode for tests/internal callers that do not
                                 // provide an anchor: allow session-key matching as before.
@@ -1233,7 +1254,7 @@ export class OpenClawClient {
                                     // Never abort a yielded original run, nor an empty final.
                                     if (!foregroundYielded && latestFinalText)
                                         this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
-                                            console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
+                                            console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, safeErrorSummary(err));
                                         });
                                     if (latestFinalText) {
                                         finish(latestFinalText);
@@ -1330,8 +1351,8 @@ export class OpenClawClient {
                             // real final wins; if the run truly stalls, the idle timeout falls
                             // back to this text.
                             if (this.isRecoverableAgentError(errText)) {
-                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
-                                console.warn(`[OpenClaw] recoverable lifecycle error for runId=${evRunId || runId}; deferring (agent may auto-recover): ${errText.slice(0, 120)}`);
+                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${safeErrorSummary(errText)}`;
+                                console.warn(`[OpenClaw] recoverable lifecycle error for runId=${evRunId || runId}; deferring (agent may auto-recover): ${safeErrorSummary(errText)}`);
                                 return;
                             }
                             if (isWaitTimeout(errText)) {
@@ -1387,8 +1408,8 @@ export class OpenClawClient {
                                 continue;
                             }
                             if (this.isRecoverableAgentError(errText)) {
-                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
-                                console.warn(`[OpenClaw] recoverable chat error for runId=${evRunId || runId}; deferring: ${errText.slice(0, 120)}`);
+                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${safeErrorSummary(errText)}`;
+                                console.warn(`[OpenClaw] recoverable chat error for runId=${evRunId || runId}; deferring: ${safeErrorSummary(errText)}`);
                                 bucket.splice(i, 1);
                                 continue;
                             }
@@ -1412,7 +1433,7 @@ export class OpenClawClient {
                             // reject, so an auto-retry probe does not race a zombie run on the
                             // same session. Idempotent/best-effort.
                             this.abortChat(targetSessionKey || sessionKey, evRunId || runId).catch((abortErr) => {
-                                console.warn(`[OpenClaw] abort after chat error failed:`, abortErr.message);
+                                console.warn(`[OpenClaw] abort after chat error failed:`, safeErrorSummary(abortErr));
                             });
                             reject(new Error(`Agent error: ${errText}`));
                             return;
@@ -2075,6 +2096,139 @@ export class OpenClawClient {
         if (next)
             next();
     }
+    /** Public native Goal protocol. Completion deliberately unavailable without host revision CAS. */
+    async createGoNativeGoal(p) {
+        return this.rpc("chat.send", { sessionKey: this.canonicalSessionKey(p.sessionKey), sessionId: p.sessionId,
+            message: p.objective, idempotencyKey: p.operationId, deliver: false,
+            intent: { kind: "session-goal-start", version: 1, issuedAtMs: p.issuedAtMs } });
+    }
+    async readGoNativeGoal(sessionKey, sessionId) {
+        const info = await this.getSessionInfo(sessionKey);
+        if (info?.session?.sessionId !== sessionId || info?.session?.archived)
+            throw new Error("Go session generation changed or archived");
+        return { session: info.session, goal: info.session.goal ?? null, revisionCAS: "unsupported" };
+    }
+    async updateGoNativeGoal(p) {
+        if (!["edit", "pause", "resume", "block"].includes(p.action))
+            throw new Error("Native Goal completion CAS unsupported");
+        const { objective, note, ...identity } = p;
+        return this.rpc("sessions.goal.update", { ...identity, sessionKey: this.canonicalSessionKey(p.sessionKey),
+            ...(p.action === "edit" ? { objective } : note === undefined ? {} : { note }) });
+    }
+    /** Admission receipt, not delivery. No restore, random retry key, or generation fallback. */
+    async sendGoGuarded(p) {
+        if (!p.sessionId || !p.idempotencyKey || p.expectedLeafEntryId === undefined)
+            throw new Error("Missing Go send guards");
+        // Own delivery before admission: events can beat the RPC response. Mute only
+        // this brief admission window; afterwards exact run ownership avoids hiding
+        // unrelated proactive work. A lost receipt retains the conservative fence.
+        const release = this.muteProactiveDelivery(p.sessionKey);
+        this.ownDeliveryRun(p.idempotencyKey);
+        try {
+            const result = await this.rpc("chat.send", { ...p, message: p.message + this.bridgeAttachmentHint(p.message),
+                sessionKey: this.canonicalSessionKey(p.sessionKey), deliver: false, suppressCommandInterpretation: true });
+            if (typeof result?.runId !== "string" || !result.runId)
+                throw new Error("Unknown Go admission receipt");
+            this.ownDeliveryRun(result.runId);
+            return { runId: result.runId, sessionId: p.sessionId, idempotencyKey: p.idempotencyKey, raw: result };
+        }
+        finally {
+            release();
+        }
+    }
+    /** Checker collection accepts only the admitted run, never a session-key fallback. */
+    async collectGoRun(p) {
+        if (p.sessionId && (await this.getGoSessionInfo(p.sessionKey))?.session?.sessionId !== p.sessionId)
+            throw new Error("Go result generation changed");
+        const text = await this.collectReply(p.runId, p.timeoutMs, p.sessionKey, { exactRunIdentity: true });
+        if (p.sessionId && (await this.getGoSessionInfo(p.sessionKey))?.session?.sessionId !== p.sessionId)
+            throw new Error("Go result generation changed");
+        return text;
+    }
+    /** Public committed terminalReply is the authority, including explicit empty
+     * and terminal error. Stream prefaces, lifecycle end alone and timeout are not. */
+    async readGoExecutorRunResult(p, waitMs = 1) {
+        const before = await this.getGoSessionInfo(p.sessionKey);
+        if (before?.session?.sessionId !== p.sessionId || before.session.archived)
+            return null;
+        this.ownDeliveryRun(p.runId);
+        const result = await this.rpc("agent.wait", { runId: p.runId, timeoutMs: waitMs }, Math.max(2500, waitMs + 1500));
+        const after = await this.getGoSessionInfo(p.sessionKey);
+        if (after?.session?.sessionId !== p.sessionId || after.session.archived || result?.runId !== p.runId ||
+            (result.sessionId !== undefined && result.sessionId !== p.sessionId) || !Number.isFinite(result.endedAt) || result.endedAt <= 0 ||
+            (Number.isFinite(result.startedAt) && result.endedAt < result.startedAt) || result.yielded || result.pendingError)
+            return null;
+        const identity = { sessionKey: this.canonicalSessionKey(p.sessionKey), sessionId: p.sessionId, runId: p.runId };
+        if (result.status === "error" || result.status === "timeout")
+            return { ...identity, disposition: "error", text: "", error: String(result.error || `Run ended: ${result.status}`) };
+        if (result.status !== "ok")
+            return null;
+        const reply = result.terminalReply;
+        if (reply?.disposition === "silent")
+            return { ...identity, disposition: "silent", text: "" };
+        if (reply?.disposition === "empty")
+            return { ...identity, disposition: "empty", text: "" };
+        if (reply?.disposition !== "visible" || typeof reply.text !== "string")
+            return null;
+        return { ...identity, disposition: reply.text.trim() === "NO_REPLY" ? "silent" : reply.text.trim() ? "visible" : "empty", text: reply.text };
+    }
+    async collectGoExecutorRun(p) {
+        const deadline = Date.now() + p.timeoutMs;
+        do {
+            const result = await this.readGoExecutorRunResult(p, Math.min(1500, Math.max(1, deadline - Date.now())));
+            if (result)
+                return result;
+            if (Date.now() < deadline)
+                await new Promise(r => setTimeout(r, 250));
+        } while (Date.now() < deadline);
+        throw new Error("Exact Go executor terminal result unknown; no replay");
+    }
+    async readGoRunResult(p) {
+        const result = await this.readGoExecutorRunResult(p);
+        return !result || result.disposition === "error" || result.disposition === "empty" ? null : result.disposition === "silent" ? "NO_REPLY" : result.text;
+    }
+    /** Public generation-pinned original input receipts; absence is unknown, not permission to resend. */
+    async reconcileGoSend(p) {
+        const result = await this.rpc("chat.history", { sessionKey: this.canonicalSessionKey(p.sessionKey),
+            sessionId: p.sessionId, inputRunIds: [p.idempotencyKey], limit: 1 });
+        const receipt = result?.inputReceipts?.find((r) => r.runId === p.idempotencyKey);
+        return receipt ? { runId: receipt.runId, sessionId: p.sessionId, raw: receipt } : null;
+    }
+    async bindGoPolicy(binding) { return this.rpc("lma.go.bind", { binding }); }
+    /** History publicly projects active leaf/run/recovery; describe alone does not. */
+    async getGoSessionInfo(sessionKey) {
+        const history = await this.rpc("chat.history", { sessionKey: this.canonicalSessionKey(sessionKey), limit: 1 });
+        return { session: history?.sessionInfo };
+    }
+    async verifyGoSafety(_executorKey) {
+        const capability = await this.rpc("lma.go.capabilities", {});
+        return { checkerToolsIsolated: capability?.mode === "independent" && capability.checkerToolsIsolated === true,
+            exactTaskAndDeliveryGate: capability?.taskQuery === true, guardedSend: true };
+    }
+    async initializeGoRuntime(p) {
+        const binding = { checkerSessionKey: this.canonicalSessionKey(p.checkerSessionKey), checkerSessionId: p.checkerSessionId,
+            executorSessionKey: this.canonicalSessionKey(p.executorSessionKey), executorSessionId: p.executorSessionId };
+        const result = await this.bindGoPolicy(binding);
+        if (result?.persisted !== true || JSON.stringify(result.binding) !== JSON.stringify(binding))
+            throw new Error("Checker restriction binding not confirmed");
+        return { executorSessionId: p.executorSessionId, checkerSessionId: p.checkerSessionId, checkerRunId: "", executorRunIds: [] };
+    }
+    async readGoRuntimeSnapshot(sessionKey, sessionId) {
+        const key = this.canonicalSessionKey(sessionKey);
+        const before = await this.getGoSessionInfo(key);
+        const query = await this.rpc("lma.go.snapshot", { sessionKey: key, sessionId });
+        const history = await this.rpc("chat.history", { sessionKey: key, sessionId, limit: 1 });
+        const live = history?.sessionInfo;
+        const after = await this.getGoSessionInfo(key);
+        return { sessionKey: key, sessionId, archived: after?.session?.archived === true,
+            complete: false, independent: true, atomicSnapshot: false,
+            queryAvailable: query?.queryAvailable === true && query.sessionKey === key && query.requestedSessionId === sessionId && live?.sessionId === sessionId && before?.session?.sessionId === sessionId && after?.session?.sessionId === sessionId &&
+                before.session.activeLeafEntryId === after.session.activeLeafEntryId && typeof live?.hasActiveRun === "boolean",
+            running: history?.inFlightRun ? true : live?.hasActiveRun, activeRunIds: live?.activeRunIds,
+            queuedInputs: history?.pendingInputs?.total,
+            tasks: (query?.tasks ?? []).map((t) => ({ taskId: t.id, runId: t.runId ?? "", parentTaskId: t.parentTaskId ?? null,
+                state: t.status === "succeeded" ? "completed" : t.status, deliveryState: t.deliveryStatus === "not_applicable" ? "not_required" : t.deliveryStatus })) };
+    }
     async chatSend(params) {
         const sk = this.shortKey(params.sessionKey);
         const fullSessionKey = this.canonicalSessionKey(params.sessionKey);

package/dist/provider-errors.d.ts

@@ -0,0 +1,24 @@
+import type { Locale } from "./i18n.js";
+export type ErrorCategory = "cancelled" | "model" | "model_unavailable" | "model_policy" | "tools" | "context" | "compaction_failed" | "quota" | "rate_limit" | "auth" | "network" | "ttft_timeout" | "total_timeout" | "collector_timeout" | "timeout" | "unknown";
+export interface SafeProviderError {
+    category: ErrorCategory;
+    status?: number;
+    code?: string;
+    type?: string;
+    param?: string;
+    requestId?: string;
+    safeMessage?: string;
+}
+/** Bounded parsing of SDK strings (e.g. Agent error: 400 {"error":...})
+ * and nested JSON errors. Deeper structured provider fields beat wrapper fields.
+ * Message text is used for classification, never returned verbatim. */
+export declare function classifyProviderError(error: unknown): SafeProviderError;
+/** Transparency (user directive 2026-10-09): the visible notice must always
+ *  carry the original diagnostic so "unclassified" is still actionable. The
+ *  excerpt is extracted from the error's diagnostic envelope fields and
+ *  sanitized (no HTML, no URLs, no keys/tokens, capped) — never verbatim
+ *  arbitrary provider prose. Kept out of classifyProviderError so the
+ *  classification shape stays stable. */
+export declare function rawErrorExcerpt(error: unknown): string | undefined;
+export declare function safeErrorSummary(error: unknown): string;
+export declare function formatProviderError(error: unknown, botName: string, model: string, locale: Locale): string;