multiclaws 0.4.30 → 0.4.32

package/dist/index.js

@@ -200,6 +200,40 @@ function createTools(getService, logger) {
             }
         },
     };
+    const multiclawsA2ACallback = {
+        name: "multiclaws_a2a_callback",
+        description: "Report the result of an incoming A2A delegated task. " +
+            "Called by sub-agents spawned to handle remote tasks. " +
+            "Do NOT call this directly.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                taskId: { type: "string" },
+                result: { type: "string" },
+            },
+            required: ["taskId", "result"],
+        },
+        execute: async (_toolCallId, args) => {
+            const taskId = typeof args.taskId === "string" ? args.taskId.trim() : "";
+            const result = typeof args.result === "string" ? args.result : "";
+            log("info", `tool:multiclaws_a2a_callback(taskId=${taskId})`);
+            try {
+                const service = requireService(getService());
+                if (!taskId || !result)
+                    throw new Error("taskId and result are required");
+                const resolved = service.resolveA2ACallback(taskId, result);
+                if (!resolved) {
+                    return textResult(`No pending callback for task ${taskId}. It may have timed out.`);
+                }
+                return textResult(`Task ${taskId} result reported successfully.`);
+            }
+            catch (err) {
+                log("error", `tool:multiclaws_a2a_callback failed: ${err instanceof Error ? err.message : String(err)}`);
+                throw err;
+            }
+        },
+    };
     const multiclawsTaskStatus = {
         name: "multiclaws_task_status",
         description: "Check the status of a delegated task.",
@@ -436,6 +470,7 @@ function createTools(getService, logger) {
         multiclawsRemoveAgent,
         multiclawsDelegate,
         multiclawsDelegateSend,
+        multiclawsA2ACallback,
         multiclawsTaskStatus,
         multiclawsTeamCreate,
         multiclawsTeamJoin,
@@ -458,16 +493,34 @@ const plugin = {
         let service = null;
         // Ensure required tools are in gateway.tools.allow at registration time
         // so the gateway starts with them already present (no restart needed).
+        //
+        // Two categories:
+        // 1. Adapter-internal tools: sessions_spawn, sessions_history, message
+        //    — needed by a2a-adapter itself to spawn/poll/notify.
+        // 2. A2A execution tools: exec, read, write, glob, grep
+        //    — needed by spawned sub-agents to actually perform delegated tasks.
+        //    Without these the sub-agent session hits "permission denied" because
+        //    gateway.tools.allow restricts which tools the session can invoke.
+        //
+        // Users can override the execution tool list via plugin config:
+        //   plugins.multiclaws.a2aAllowedTools: ["exec", "read", "write", ...]
         if (api.config) {
             const gw = api.config.gateway;
             if (gw) {
                 const tools = (gw.tools ?? {});
                 const allow = Array.isArray(tools.allow) ? tools.allow : [];
-                const required = ["sessions_spawn", "sessions_history", "message"];
+                const adapterRequired = ["sessions_spawn", "sessions_history", "message", "chat.send"];
+                const defaultA2AExecutionTools = ["exec", "read", "write", "edit", "process"];
+                const pluginConf = api.pluginConfig ?? {};
+                const a2aExecTools = Array.isArray(pluginConf.a2aAllowedTools)
+                    ? pluginConf.a2aAllowedTools
+                    : defaultA2AExecutionTools;
+                const required = [...new Set([...adapterRequired, ...a2aExecTools])];
                 const missing = required.filter((t) => !allow.includes(t));
                 if (missing.length > 0) {
                     tools.allow = [...allow, ...missing];
                     gw.tools = tools;
+                    structured.logger.info(`auto-added gateway tools: ${missing.join(", ")}`);
                 }
             }
         }
@@ -542,14 +595,18 @@ const plugin = {
         api.on("gateway_stop", () => {
             structured.logger.info("[multiclaws] gateway_stop observed");
         });
-        // Collect all channel IDs for broadcasting notifications
+        // Collect notification targets from incoming messages (external channels)
         api.on("message_received", (_event, ctx) => {
-            if (service && ctx.channelId) {
-                service.addChannelId(ctx.channelId);
+            if (service && ctx.channelId && ctx.channelId !== "webchat" && ctx.conversationId) {
+                service.addNotificationTarget(`${ctx.channelId}:${ctx.conversationId}`, { type: "channel", conversationId: ctx.conversationId });
             }
         });
         // Inject onboarding prompt when profile is pending first-run setup
-        api.on("before_prompt_build", async (_event, _ctx) => {
+        // Also capture web session targets for notifications
+        api.on("before_prompt_build", async (_event, ctx) => {
+            if (service && ctx.sessionKey) {
+                service.addNotificationTarget(`web:${ctx.sessionKey}`, { type: "web", sessionKey: ctx.sessionKey });
+            }
             if (!service)
                 return;
             try {

package/dist/service/a2a-adapter.d.ts

@@ -1,11 +1,12 @@
 import type { AgentExecutor, ExecutionEventBus, RequestContext } from "@a2a-js/sdk/server";
 import { type GatewayConfig } from "../infra/gateway-client";
 import type { TaskTracker } from "../task/tracker";
+import type { NotificationTarget } from "./multiclaws-service";
 export type A2AAdapterOptions = {
     gatewayConfig: GatewayConfig | null;
     taskTracker: TaskTracker;
     cwd?: string;
-    getChannelIds?: () => ReadonlySet<string>;
+    getNotificationTargets?: () => ReadonlyMap<string, NotificationTarget>;
     logger: {
         info: (msg: string) => void;
         warn: (msg: string) => void;
@@ -19,35 +20,31 @@ export type A2AAdapterOptions = {
  * this executor:
  * 1. Records the task via TaskTracker
  * 2. Calls OpenClaw's `sessions_spawn` (run mode) to start execution
- * 3. Polls `sessions_history` until the subagent completes
+ * 3. Waits for the sub-agent to call back via `multiclaws_a2a_callback`
  * 4. Returns the final result as a Message
  */
 export declare class OpenClawAgentExecutor implements AgentExecutor {
     private gatewayConfig;
     private readonly taskTracker;
-    private readonly getChannelIds;
+    private readonly getNotificationTargets;
     private readonly logger;
     private readonly cwd;
+    private readonly pendingCallbacks;
     constructor(options: A2AAdapterOptions);
     execute(context: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
     /**
-     * Poll sessions_history until the subagent session completes.
-     * Collects ALL assistant text messages and returns them joined.
+     * Called by the `multiclaws_a2a_callback` tool when a sub-agent reports its result.
+     * Returns true if a pending callback was found and resolved.
      */
-    private waitForCompletion;
-    /**
-     * Extract all assistant text from session history once the session is complete.
-     * Returns null if the session is still running.
-     * Returns all assistant text messages joined (not just the last one).
-     *
-     * Gateway /tools/invoke returns: { content: [...], details: { messages: [...], isComplete?: boolean } }
-     */
-    private extractCompletedResult;
-    /** Extract text content from a single history message. */
-    private extractTextFromHistoryMessage;
+    resolveCallback(taskId: string, result: string): boolean;
     cancelTask(taskId: string, eventBus: ExecutionEventBus): Promise<void>;
     updateGatewayConfig(config: GatewayConfig): void;
-    /** Send a notification to all known channels. Individual failures are silently ignored. */
+    /**
+     * Create a pending callback that resolves when the sub-agent reports back,
+     * or rejects on timeout.
+     */
+    private createCallback;
+    /** Send a notification to all known targets. Individual failures are silently ignored. */
     private notifyUser;
     private publishMessage;
 }

package/dist/service/a2a-adapter.js

@@ -10,24 +10,6 @@ function extractTextFromMessage(message) {
         .map((p) => p.text)
         .join("\n");
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Extract the details object from a gateway /tools/invoke result.
- * The result shape is: { content: [...], details: { ...actual data... } }
- */
-function extractDetails(result) {
-    if (!result || typeof result !== "object")
-        return null;
-    const r = result;
-    // Direct details from /tools/invoke
-    if (r.details && typeof r.details === "object") {
-        return r.details;
-    }
-    // Fallback: result itself might be the details
-    return r;
-}
 /**
  * Bridges the A2A protocol to OpenClaw's sessions_spawn gateway tool.
  *
@@ -35,19 +17,20 @@ function extractDetails(result) {
  * this executor:
  * 1. Records the task via TaskTracker
  * 2. Calls OpenClaw's `sessions_spawn` (run mode) to start execution
- * 3. Polls `sessions_history` until the subagent completes
+ * 3. Waits for the sub-agent to call back via `multiclaws_a2a_callback`
  * 4. Returns the final result as a Message
  */
 class OpenClawAgentExecutor {
     gatewayConfig;
     taskTracker;
-    getChannelIds;
+    getNotificationTargets;
     logger;
     cwd;
+    pendingCallbacks = new Map();
     constructor(options) {
         this.gatewayConfig = options.gatewayConfig;
         this.taskTracker = options.taskTracker;
-        this.getChannelIds = options.getChannelIds ?? (() => new Set());
+        this.getNotificationTargets = options.getNotificationTargets ?? (() => new Map());
         this.logger = options.logger;
         this.cwd = options.cwd || process.cwd();
     }
@@ -76,34 +59,27 @@ class OpenClawAgentExecutor {
         void this.notifyUser(`📨 收到来自 **${fromAgent}** 的委派任务：${taskText.slice(0, 200)}`);
         try {
             this.logger.info(`[a2a-adapter] executing task ${taskId}: ${taskText.slice(0, 100)}`);
-            // 1. Spawn the subagent
-            // Use a dedicated session key to avoid inheriting the main session's
-            // thinking blocks, which would cause "thinking blocks cannot be modified"
-            // errors from the Claude API.
-            const spawnResult = await (0, gateway_client_1.invokeGatewayTool)({
+            // Create a promise that resolves when sub-agent calls multiclaws_a2a_callback
+            const resultPromise = this.createCallback(taskId, 180_000);
+            // Spawn the subagent with instructions to call back when done
+            const prompt = buildA2ASubagentPrompt(taskId, taskText);
+            await (0, gateway_client_1.invokeGatewayTool)({
                 gateway: this.gatewayConfig,
                 tool: "sessions_spawn",
                 args: {
-                    task: taskText,
+                    task: prompt,
                     mode: "run",
                     cwd: this.cwd,
                 },
                 sessionKey: `a2a-${taskId}`,
                 timeoutMs: 15_000,
             });
-            // Extract details from gateway response: { content: [...], details: { childSessionKey, ... } }
-            const details = extractDetails(spawnResult);
-            const childSessionKey = details?.childSessionKey;
-            if (!childSessionKey) {
-                throw new Error("sessions_spawn did not return a childSessionKey");
-            }
-            // 2. Poll for completion
-            const gatewaySessionKey = `a2a-${taskId}`;
-            this.logger.info(`[a2a-adapter] task ${taskId} spawned as ${childSessionKey}, waiting for result...`);
-            const output = await this.waitForCompletion(childSessionKey, 180_000, gatewaySessionKey);
-            // 3. Return result
+            this.logger.info(`[a2a-adapter] task ${taskId} spawned, waiting for callback...`);
+            // Wait for the sub-agent to call back
+            const output = await resultPromise;
+            // Return result
             this.taskTracker.update(taskId, { status: "completed", result: output });
-            this.logger.info(`[a2a-adapter] task ${taskId} completed`);
+            this.logger.info(`[a2a-adapter] task ${taskId} completed, resultLen=${output.length}`);
             this.publishMessage(eventBus, output || "Task completed with no output.");
         }
         catch (err) {
@@ -115,146 +91,27 @@ class OpenClawAgentExecutor {
         eventBus.finished();
     }
     /**
-     * Poll sessions_history until the subagent session completes.
-     * Collects ALL assistant text messages and returns them joined.
-     */
-    async waitForCompletion(sessionKey, timeoutMs, gatewaySessionKey) {
-        this.logger.info(`[a2a-adapter] waitForCompletion(sessionKey=${sessionKey}, timeoutMs=${timeoutMs})`);
-        const gateway = this.gatewayConfig;
-        const startTime = Date.now();
-        let attempt = 0;
-        const pollDelays = [100, 200, 300, 500];
-        while (Date.now() - startTime < timeoutMs) {
-            const delay = pollDelays[Math.min(attempt, pollDelays.length - 1)];
-            await sleep(delay);
-            attempt++;
-            try {
-                const histResult = await (0, gateway_client_1.invokeGatewayTool)({
-                    gateway,
-                    tool: "sessions_history",
-                    args: {
-                        sessionKey,
-                        limit: 50,
-                        includeTools: false,
-                    },
-                    sessionKey: gatewaySessionKey,
-                    timeoutMs: 8_000,
-                });
-                const result = this.extractCompletedResult(histResult);
-                if (result !== null) {
-                    this.logger.info(`[a2a-adapter] poll attempt ${attempt}: session ${sessionKey} completed, resultLen=${result.length}`);
-                    return result;
-                }
-                // Log details on first attempt, then every 10 attempts for diagnosis
-                if (attempt === 1 || attempt % 10 === 0) {
-                    const details = extractDetails(histResult);
-                    const messages = (details?.messages ?? []);
-                    const lastMsg = messages[messages.length - 1];
-                    this.logger.info(`[a2a-adapter] poll attempt ${attempt}: session ${sessionKey} still running. ` +
-                        `isComplete=${details?.isComplete}, status=${details?.status}, ` +
-                        `msgCount=${messages.length}, lastRole=${lastMsg?.role}, ` +
-                        `lastContentTypes=${JSON.stringify(Array.isArray(lastMsg?.content)
-                            ? lastMsg.content.map((c) => c?.type)
-                            : typeof lastMsg?.content)}`);
-                }
-                else {
-                    this.logger.info(`[a2a-adapter] poll attempt ${attempt}: session ${sessionKey} still running...`);
-                }
-            }
-            catch (err) {
-                this.logger.warn(`[a2a-adapter] poll attempt ${attempt} error: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        const elapsed = Math.round((Date.now() - startTime) / 1000);
-        this.logger.error(`[a2a-adapter] waitForCompletion timed out: session=${sessionKey}, elapsed=${elapsed}s, attempts=${attempt}`);
-        throw new Error(`task timed out after ${elapsed}s (${attempt} attempts) waiting for subagent`);
-    }
-    /**
-     * Extract all assistant text from session history once the session is complete.
-     * Returns null if the session is still running.
-     * Returns all assistant text messages joined (not just the last one).
-     *
-     * Gateway /tools/invoke returns: { content: [...], details: { messages: [...], isComplete?: boolean } }
+     * Called by the `multiclaws_a2a_callback` tool when a sub-agent reports its result.
+     * Returns true if a pending callback was found and resolved.
      */
-    extractCompletedResult(histResult) {
-        const details = extractDetails(histResult);
-        if (!details)
-            return null;
-        // Check for session-level error/status from gateway
-        const sessionError = details.error;
-        const sessionStatus = details.status;
-        // Immediately fail on terminal session statuses — do NOT keep polling
-        const terminalStatuses = ["forbidden", "failed", "error", "not_found", "unauthorized"];
-        if (sessionStatus && terminalStatuses.includes(sessionStatus)) {
-            this.logger.warn(`[a2a-adapter] extractCompletedResult: terminal status="${sessionStatus}", error="${sessionError ?? "none"}"`);
-            return `Error: session status "${sessionStatus}"${sessionError ? `: ${sessionError}` : ""}`;
-        }
-        const messages = (details.messages ?? []);
-        if (messages.length === 0 && !details.isComplete)
-            return null;
-        // If session is not explicitly complete, use heuristic: check if the session is still executing
-        if (details.isComplete !== true) {
-            if (messages.length === 0)
-                return null;
-            const lastMsg = messages[messages.length - 1];
-            if (lastMsg && Array.isArray(lastMsg.content)) {
-                const content = lastMsg.content;
-                const hasToolCalls = content.some((c) => c?.type === "toolCall" || c?.type === "tool_use");
-                // If the last message only has tool calls (no text), still running
-                const hasText = content.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim());
-                if (hasToolCalls && !hasText)
-                    return null;
-            }
-            // If the last message is a user message, the agent hasn't responded yet
-            if (lastMsg?.role === "user")
-                return null;
-        }
-        // Session is complete — collect ALL assistant text messages in order
-        const allTexts = [];
-        for (const msg of messages) {
-            if (msg.role !== "assistant")
-                continue;
-            const text = this.extractTextFromHistoryMessage(msg);
-            if (text)
-                allTexts.push(text);
-        }
-        // If we have assistant text, return it (even if there's also an error)
-        if (allTexts.length > 0) {
-            // Append error info if present so the delegating agent sees both
-            if (sessionError) {
-                allTexts.push(`[session error: ${sessionError}]`);
-            }
-            return allTexts.join("\n\n");
-        }
-        // No assistant text — check if the session reported an error
-        if (sessionError) {
-            return `Error: ${sessionError}`;
-        }
-        if (sessionStatus === "failed" || sessionStatus === "error") {
-            return `Error: session ended with status "${sessionStatus}"`;
-        }
-        // Session truly completed with no output at all
-        return "(task completed with no text output)";
-    }
-    /** Extract text content from a single history message. */
-    extractTextFromHistoryMessage(msg) {
-        const content = msg.content;
-        if (typeof content === "string" && content.trim()) {
-            return content;
-        }
-        if (Array.isArray(content)) {
-            const parts = content;
-            const textParts = parts
-                .filter((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim())
-                .map((c) => c.text);
-            if (textParts.length > 0) {
-                return textParts.join("\n");
-            }
-        }
-        return null;
+    resolveCallback(taskId, result) {
+        const pending = this.pendingCallbacks.get(taskId);
+        if (!pending)
+            return false;
+        clearTimeout(pending.timer);
+        this.pendingCallbacks.delete(taskId);
+        pending.resolve(result);
+        return true;
     }
     async cancelTask(taskId, eventBus) {
         this.logger.info(`[a2a-adapter] cancelTask(taskId=${taskId})`);
+        // Reject pending callback if any
+        const pending = this.pendingCallbacks.get(taskId);
+        if (pending) {
+            clearTimeout(pending.timer);
+            this.pendingCallbacks.delete(taskId);
+            pending.reject(new Error("canceled"));
+        }
         this.taskTracker.update(taskId, { status: "failed", error: "canceled" });
         this.publishMessage(eventBus, "Task was canceled.");
         eventBus.finished();
@@ -262,17 +119,37 @@ class OpenClawAgentExecutor {
     updateGatewayConfig(config) {
         this.gatewayConfig = config;
     }
-    /** Send a notification to all known channels. Individual failures are silently ignored. */
+    /**
+     * Create a pending callback that resolves when the sub-agent reports back,
+     * or rejects on timeout.
+     */
+    createCallback(taskId, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingCallbacks.delete(taskId);
+                reject(new Error(`task timed out after ${timeoutMs / 1000}s waiting for sub-agent callback`));
+            }, timeoutMs);
+            this.pendingCallbacks.set(taskId, { resolve, reject, timer });
+        });
+    }
+    /** Send a notification to all known targets. Individual failures are silently ignored. */
     async notifyUser(message) {
-        const channels = this.getChannelIds();
-        if (!this.gatewayConfig || channels.size === 0)
+        const targets = this.getNotificationTargets();
+        if (!this.gatewayConfig || targets.size === 0)
             return;
-        await Promise.allSettled([...channels].map((target) => (0, gateway_client_1.invokeGatewayTool)({
-            gateway: this.gatewayConfig,
-            tool: "message",
-            args: { action: "send", target, message },
-            timeoutMs: 5_000,
-        })));
+        await Promise.allSettled([...targets.values()].map((target) => target.type === "channel"
+            ? (0, gateway_client_1.invokeGatewayTool)({
+                gateway: this.gatewayConfig,
+                tool: "message",
+                args: { action: "send", target: target.conversationId, message },
+                timeoutMs: 5_000,
+            })
+            : (0, gateway_client_1.invokeGatewayTool)({
+                gateway: this.gatewayConfig,
+                tool: "chat.send",
+                args: { sessionKey: target.sessionKey, message },
+                timeoutMs: 5_000,
+            })));
     }
     publishMessage(eventBus, text) {
         const message = {
@@ -285,3 +162,28 @@ class OpenClawAgentExecutor {
     }
 }
 exports.OpenClawAgentExecutor = OpenClawAgentExecutor;
+/**
+ * Build the prompt for the sub-agent that handles an incoming A2A task.
+ * The sub-agent must call `multiclaws_a2a_callback` to report its result.
+ */
+function buildA2ASubagentPrompt(taskId, taskText) {
+    return `你收到了一个来自远端智能体的委派任务。请完成任务并汇报结果。
+
+## 任务内容
+
+${taskText}
+
+## 完成后必做
+
+完成任务后，你**必须**调用 \`multiclaws_a2a_callback\` 工具汇报结果：
+
+\`\`\`
+multiclaws_a2a_callback(taskId="${taskId}", result="你的完整回复内容")
+\`\`\`
+
+**重要**：
+- 无论任务成功还是失败，都必须调用 \`multiclaws_a2a_callback\`
+- result 参数填写你的完整回复文本
+- 如果任务失败，在 result 中说明失败原因
+- 这是唯一的结果回传方式，不调用则结果会丢失`;
+}

package/dist/service/multiclaws-service.d.ts

@@ -27,6 +27,13 @@ export type DelegateTaskResult = {
     status: string;
     error?: string;
 };
+export type NotificationTarget = {
+    type: "channel";
+    conversationId: string;
+} | {
+    type: "web";
+    sessionKey: string;
+};
 export declare class MulticlawsService extends EventEmitter {
     private readonly options;
     private started;
@@ -45,7 +52,7 @@ export declare class MulticlawsService extends EventEmitter {
     private profileDescription;
     private readonly gatewayConfig;
     private readonly resolvedCwd;
-    private readonly knownChannelIds;
+    private readonly notificationTargets;
     constructor(options: MulticlawsServiceOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -127,8 +134,9 @@ export declare class MulticlawsService extends EventEmitter {
     /** Fetch with up to 2 retries and exponential backoff. */
     private fetchWithRetry;
     /** Register a channel ID for notifications. */
-    addChannelId(channelId: string): void;
-    /** Send a notification to all known channels. Individual failures are silently ignored. */
+    resolveA2ACallback(taskId: string, result: string): boolean;
+    addNotificationTarget(key: string, target: NotificationTarget): void;
+    /** Send a notification to all known targets. Individual failures are silently ignored. */
     private notifyUser;
     private log;
 }

package/dist/service/multiclaws-service.js

@@ -68,7 +68,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
     profileDescription = "OpenClaw agent";
     gatewayConfig;
     resolvedCwd;
-    knownChannelIds = new Set();
+    notificationTargets = new Map();
     constructor(options) {
         super();
         this.options = options;
@@ -123,7 +123,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 gatewayConfig: this.options.gatewayConfig ?? null,
                 taskTracker: this.taskTracker,
                 cwd: this.resolvedCwd,
-                getChannelIds: () => this.knownChannelIds,
+                getNotificationTargets: () => this.notificationTargets,
                 logger,
             });
             this.agentCard = {
@@ -920,22 +920,34 @@ class MulticlawsService extends node_events_1.EventEmitter {
         throw lastError;
     }
     /** Register a channel ID for notifications. */
-    addChannelId(channelId) {
-        if (!this.knownChannelIds.has(channelId)) {
-            this.knownChannelIds.add(channelId);
-            this.log("debug", `channel registered: ${channelId} (total: ${this.knownChannelIds.size})`);
+    resolveA2ACallback(taskId, result) {
+        if (!this.agentExecutor)
+            return false;
+        return this.agentExecutor.resolveCallback(taskId, result);
+    }
+    addNotificationTarget(key, target) {
+        if (!this.notificationTargets.has(key)) {
+            this.notificationTargets.set(key, target);
+            this.log("debug", `notification target registered: ${key} (total: ${this.notificationTargets.size})`);
         }
     }
-    /** Send a notification to all known channels. Individual failures are silently ignored. */
+    /** Send a notification to all known targets. Individual failures are silently ignored. */
     async notifyUser(message) {
-        if (!this.gatewayConfig || this.knownChannelIds.size === 0)
+        if (!this.gatewayConfig || this.notificationTargets.size === 0)
             return;
-        await Promise.allSettled([...this.knownChannelIds].map((target) => (0, gateway_client_1.invokeGatewayTool)({
-            gateway: this.gatewayConfig,
-            tool: "message",
-            args: { action: "send", target, message },
-            timeoutMs: 5_000,
-        })));
+        await Promise.allSettled([...this.notificationTargets.values()].map((target) => target.type === "channel"
+            ? (0, gateway_client_1.invokeGatewayTool)({
+                gateway: this.gatewayConfig,
+                tool: "message",
+                args: { action: "send", target: target.conversationId, message },
+                timeoutMs: 5_000,
+            })
+            : (0, gateway_client_1.invokeGatewayTool)({
+                gateway: this.gatewayConfig,
+                tool: "chat.send",
+                args: { sessionKey: target.sessionKey, message },
+                timeoutMs: 5_000,
+            })));
     }
     log(level, message) {
         this.options.logger?.[level]?.(`[multiclaws] ${message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaws",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "description": "MultiClaws plugin for OpenClaw collaboration via A2A protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,6 +15,12 @@
     "openclaw.plugin.json",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  },
   "keywords": [
     "openclaw",
     "plugin",
@@ -46,11 +52,5 @@
     "@types/proper-lockfile": "^4.1.4",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clean": "rm -rf dist"
   }
-}
+}