multiclaws 0.4.33 → 0.4.34

package/dist/index.js

@@ -625,16 +625,25 @@ const plugin = {
         api.on("gateway_stop", () => {
             structured.logger.info("[multiclaws] gateway_stop observed");
         });
-        // Collect notification targets from incoming messages (external channels)
+        // Collect notification targets from incoming messages
         api.on("message_received", (_event, ctx) => {
-            if (service && ctx.channelId && ctx.channelId !== "webchat" && ctx.conversationId) {
+            if (!service || !ctx.channelId)
+                return;
+            if (ctx.channelId === "webchat" && ctx.conversationId) {
+                // WebChat: use conversationId with the message tool
+                service.addNotificationTarget(`webchat:${ctx.conversationId}`, { type: "channel", conversationId: ctx.conversationId });
+            }
+            else if (ctx.channelId !== "webchat" && ctx.conversationId) {
+                // External channels (Telegram, etc.)
                 service.addNotificationTarget(`${ctx.channelId}:${ctx.conversationId}`, { type: "channel", conversationId: ctx.conversationId });
             }
         });
         // Inject onboarding prompt when profile is pending first-run setup
-        // Also capture web session targets for notifications
+        // Also capture web session targets for notifications (skip internal sub-agent sessions)
+        const INTERNAL_SESSION_PREFIXES = ["delegate-", "a2a-"];
         api.on("before_prompt_build", async (_event, ctx) => {
-            if (service && ctx.sessionKey) {
+            if (service && ctx.sessionKey &&
+                !INTERNAL_SESSION_PREFIXES.some((p) => ctx.sessionKey.startsWith(p))) {
                 service.addNotificationTarget(`web:${ctx.sessionKey}`, { type: "web", sessionKey: ctx.sessionKey });
             }
             if (!service)

package/dist/service/a2a-adapter.js

@@ -37,33 +37,43 @@ class OpenClawAgentExecutor {
     async execute(context, eventBus) {
         const taskText = extractTextFromMessage(context.userMessage);
         const taskId = context.taskId;
+        this.logger.info(`[a2a-adapter] ▶ execute() called — taskId=${taskId}, textLen=${taskText.length}`);
         if (!taskText.trim()) {
+            this.logger.warn(`[a2a-adapter] ✗ empty task text, rejecting — taskId=${taskId}`);
             this.publishMessage(eventBus, "Error: empty task received.");
             eventBus.finished();
             return;
         }
-        const fromAgent = context.userMessage.metadata?.agentUrl ?? "unknown";
+        const meta = context.userMessage.metadata ?? {};
+        const fromAgentUrl = meta.agentUrl ?? "unknown";
+        const fromAgentName = meta.agentName || fromAgentUrl;
+        this.logger.info(`[a2a-adapter] task ${taskId} from ${fromAgentName} (${fromAgentUrl}): ${taskText.slice(0, 120)}`);
         this.taskTracker.create({
-            fromPeerId: fromAgent,
+            fromPeerId: fromAgentUrl,
             toPeerId: "local",
             task: taskText,
         });
+        this.logger.info(`[a2a-adapter] task ${taskId} tracked`);
         if (!this.gatewayConfig) {
-            this.logger.error("[a2a-adapter] gateway config not available, cannot execute task");
+            this.logger.error(`[a2a-adapter] ✗ gateway config not available — taskId=${taskId}`);
             this.taskTracker.update(taskId, { status: "failed", error: "gateway config not available" });
             this.publishMessage(eventBus, "Error: gateway config not available, cannot execute task.");
             eventBus.finished();
             return;
         }
         // Notify local user about incoming task
-        void this.notifyUser(`📨 收到来自 **${fromAgent}** 的委派任务：${taskText.slice(0, 200)}`);
+        const notifyTargets = this.getNotificationTargets();
+        this.logger.info(`[a2a-adapter] task ${taskId} notifying user (${notifyTargets.size} targets)`);
+        void this.notifyUser(`📨 收到来自 **${fromAgentName}** 的委派任务：${taskText.slice(0, 200)}`);
         try {
-            this.logger.info(`[a2a-adapter] executing task ${taskId}: ${taskText.slice(0, 100)}`);
             // Create a promise that resolves when sub-agent calls multiclaws_a2a_callback
-            const resultPromise = this.createCallback(taskId, 180_000);
+            const timeoutMs = 180_000;
+            const resultPromise = this.createCallback(taskId, timeoutMs);
+            this.logger.info(`[a2a-adapter] task ${taskId} callback registered (timeout=${timeoutMs / 1000}s)`);
             // Spawn the subagent with instructions to call back when done
             const prompt = buildA2ASubagentPrompt(taskId, taskText);
-            await (0, gateway_client_1.invokeGatewayTool)({
+            this.logger.info(`[a2a-adapter] task ${taskId} spawning sub-agent via sessions_spawn (cwd=${this.cwd}, sessionKey=a2a-${taskId})`);
+            const spawnResult = await (0, gateway_client_1.invokeGatewayTool)({
                 gateway: this.gatewayConfig,
                 tool: "sessions_spawn",
                 args: {
@@ -74,20 +84,22 @@ class OpenClawAgentExecutor {
                 sessionKey: `a2a-${taskId}`,
                 timeoutMs: 15_000,
             });
-            this.logger.info(`[a2a-adapter] task ${taskId} spawned, waiting for callback...`);
+            this.logger.info(`[a2a-adapter] task ${taskId} sub-agent spawned — result=${JSON.stringify(spawnResult).slice(0, 200)}`);
+            this.logger.info(`[a2a-adapter] task ${taskId} waiting for callback from sub-agent...`);
             // 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, resultLen=${output.length}`);
+            this.logger.info(`[a2a-adapter] ✓ task ${taskId} completed — resultLen=${output.length}, preview=${output.slice(0, 120)}`);
             this.publishMessage(eventBus, output || "Task completed with no output.");
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
-            this.logger.error(`[a2a-adapter] task execution failed: ${errorMsg}`);
+            this.logger.error(`[a2a-adapter] ✗ task ${taskId} failed: ${errorMsg}`);
             this.taskTracker.update(taskId, { status: "failed", error: errorMsg });
             this.publishMessage(eventBus, `Error: ${errorMsg}`);
         }
+        this.logger.info(`[a2a-adapter] task ${taskId} eventBus.finished()`);
         eventBus.finished();
     }
     /**
@@ -96,10 +108,13 @@ class OpenClawAgentExecutor {
      */
     resolveCallback(taskId, result) {
         const pending = this.pendingCallbacks.get(taskId);
-        if (!pending)
+        if (!pending) {
+            this.logger.warn(`[a2a-adapter] resolveCallback: no pending callback for taskId=${taskId} (may have timed out)`);
             return false;
+        }
         clearTimeout(pending.timer);
         this.pendingCallbacks.delete(taskId);
+        this.logger.info(`[a2a-adapter] resolveCallback: taskId=${taskId} resolved — resultLen=${result.length}`);
         pending.resolve(result);
         return true;
     }
@@ -111,6 +126,7 @@ class OpenClawAgentExecutor {
             clearTimeout(pending.timer);
             this.pendingCallbacks.delete(taskId);
             pending.reject(new Error("canceled"));
+            this.logger.info(`[a2a-adapter] cancelTask: pending callback rejected for taskId=${taskId}`);
         }
         this.taskTracker.update(taskId, { status: "failed", error: "canceled" });
         this.publishMessage(eventBus, "Task was canceled.");
@@ -127,6 +143,7 @@ class OpenClawAgentExecutor {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pendingCallbacks.delete(taskId);
+                this.logger.error(`[a2a-adapter] ✗ task ${taskId} callback timed out after ${timeoutMs / 1000}s — pending callbacks remaining: ${this.pendingCallbacks.size}`);
                 reject(new Error(`task timed out after ${timeoutMs / 1000}s waiting for sub-agent callback`));
             }, timeoutMs);
             this.pendingCallbacks.set(taskId, { resolve, reject, timer });
@@ -135,21 +152,36 @@ class OpenClawAgentExecutor {
     /** Send a notification to all known targets. Individual failures are silently ignored. */
     async notifyUser(message) {
         const targets = this.getNotificationTargets();
-        if (!this.gatewayConfig || targets.size === 0)
+        if (!this.gatewayConfig || targets.size === 0) {
+            this.logger.info(`[a2a-adapter] notifyUser: skipped (gateway=${!!this.gatewayConfig}, targets=${targets.size})`);
             return;
-        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,
-            })));
+        }
+        const results = await Promise.allSettled([...targets.entries()].map(async ([key, target]) => {
+            this.logger.info(`[a2a-adapter] notifyUser: sending to ${key} (type=${target.type})`);
+            try {
+                await (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,
+                    }));
+                this.logger.info(`[a2a-adapter] notifyUser: sent to ${key} ✓`);
+            }
+            catch (err) {
+                this.logger.warn(`[a2a-adapter] notifyUser: failed to send to ${key}: ${err instanceof Error ? err.message : String(err)}`);
+                throw err;
+            }
+        }));
+        const ok = results.filter((r) => r.status === "fulfilled").length;
+        const fail = results.filter((r) => r.status === "rejected").length;
+        this.logger.info(`[a2a-adapter] notifyUser: done (${ok} ok, ${fail} failed)`);
     }
     publishMessage(eventBus, text) {
         const message = {

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

@@ -133,7 +133,7 @@ export declare class MulticlawsService extends EventEmitter {
     private extractArtifactText;
     /** Fetch with up to 2 retries and exponential backoff. */
     private fetchWithRetry;
-    /** Register a channel ID for notifications. */
+    /** Resolve a pending A2A callback from sub-agent. */
     resolveA2ACallback(taskId: string, result: string): boolean;
     addNotificationTarget(key: string, target: NotificationTarget): void;
     /** Send a notification to all known targets. Individual failures are silently ignored. */

package/dist/service/multiclaws-service.js

@@ -256,26 +256,32 @@ class MulticlawsService extends node_events_1.EventEmitter {
     /*  Task delegation                                                  */
     /* ---------------------------------------------------------------- */
     async delegateTask(params) {
-        this.log("info", `delegateTask(agentUrl=${params.agentUrl}, task=${params.task.slice(0, 80)})`);
+        this.log("info", `[delegate] ▶ delegateTask(agentUrl=${params.agentUrl}, taskLen=${params.task.length})`);
+        this.log("info", `[delegate] task preview: ${params.task.slice(0, 120)}`);
         await this.requireCompleteProfile();
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
         if (!agentRecord) {
-            this.log("warn", `delegateTask: unknown agent ${params.agentUrl}`);
+            this.log("warn", `[delegate] ✗ unknown agent: ${params.agentUrl}`);
             return { status: "failed", error: `unknown agent: ${params.agentUrl}` };
         }
+        this.log("info", `[delegate] agent found: ${agentRecord.name} (${agentRecord.url})`);
         const track = this.taskTracker.create({
             fromPeerId: "local",
             toPeerId: params.agentUrl,
             task: params.task,
         });
         this.taskTracker.update(track.taskId, { status: "running" });
+        this.log("info", `[delegate] task tracked: ${track.taskId}, status=running`);
         try {
+            this.log("info", `[delegate] ${track.taskId} creating A2A client for ${agentRecord.url}`);
             const client = await this.createA2AClient(agentRecord);
+            this.log("info", `[delegate] ${track.taskId} A2A client created, starting fire-and-forget send`);
             // Fire-and-forget execution: keep running in the background so that
             // the gateway call can return quickly and the task can outlive
             // the gateway's HTTP timeout.
             void (async () => {
                 try {
+                    this.log("info", `[delegate] ${track.taskId} sending A2A message (background)...`);
                     const result = await client.sendMessage({
                         message: {
                             kind: "message",
@@ -284,22 +290,24 @@ class MulticlawsService extends node_events_1.EventEmitter {
                             messageId: track.taskId,
                         },
                     });
+                    this.log("info", `[delegate] ${track.taskId} A2A response received (background)`);
                     this.processTaskResult(track.taskId, result);
                 }
                 catch (err) {
                     const errorMsg = err instanceof Error ? err.message : String(err);
                     this.taskTracker.update(track.taskId, { status: "failed", error: errorMsg });
-                    this.log("warn", `delegateTask background execution for ${track.taskId} failed: ${errorMsg}`);
+                    this.log("error", `[delegate] ✗ ${track.taskId} background send failed: ${errorMsg}`);
                 }
             })();
             // Return immediately so that gateway tool invocations are fast and
             // do not depend on the remote agent's total execution time.
+            this.log("info", `[delegate] ${track.taskId} returned immediately (fire-and-forget)`);
             return { taskId: track.taskId, status: "running" };
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
             this.taskTracker.update(track.taskId, { status: "failed", error: errorMsg });
-            this.log("error", `delegateTask failed for ${track.taskId}: ${errorMsg}`);
+            this.log("error", `[delegate] ✗ ${track.taskId} failed: ${errorMsg}`);
             return { taskId: track.taskId, status: "failed", error: errorMsg };
         }
     }
@@ -308,37 +316,47 @@ class MulticlawsService extends node_events_1.EventEmitter {
      * Used by sub-agents internally via the multiclaws_delegate_send tool.
      */
     async delegateTaskSync(params) {
-        this.log("info", `delegateTaskSync(agentUrl=${params.agentUrl}, task=${params.task.slice(0, 80)})`);
+        this.log("info", `[delegate-sync] ▶ delegateTaskSync(agentUrl=${params.agentUrl}, taskLen=${params.task.length})`);
+        this.log("info", `[delegate-sync] task preview: ${params.task.slice(0, 120)}`);
         await this.requireCompleteProfile();
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
         if (!agentRecord) {
-            this.log("warn", `delegateTaskSync: unknown agent ${params.agentUrl}`);
+            this.log("warn", `[delegate-sync] ✗ unknown agent: ${params.agentUrl}`);
             return { status: "failed", error: `unknown agent: ${params.agentUrl}` };
         }
+        this.log("info", `[delegate-sync] agent found: ${agentRecord.name} (${agentRecord.url})`);
         const track = this.taskTracker.create({
             fromPeerId: "local",
             toPeerId: params.agentUrl,
             task: params.task,
         });
         this.taskTracker.update(track.taskId, { status: "running" });
+        this.log("info", `[delegate-sync] task tracked: ${track.taskId}, status=running`);
         try {
+            this.log("info", `[delegate-sync] ${track.taskId} creating A2A client for ${agentRecord.url}`);
             const client = await this.createA2AClient(agentRecord);
+            this.log("info", `[delegate-sync] ${track.taskId} sending A2A message (sync, with metadata: selfUrl=${this.selfUrl}, selfName=${this.agentCard?.name ?? "unknown"})...`);
             const result = await client.sendMessage({
                 message: {
                     kind: "message",
                     role: "user",
                     parts: [{ kind: "text", text: params.task }],
                     messageId: track.taskId,
+                    metadata: {
+                        agentUrl: this.selfUrl,
+                        agentName: this.agentCard?.name ?? "unknown",
+                    },
                 },
             });
+            this.log("info", `[delegate-sync] ${track.taskId} A2A response received`);
             const taskResult = this.processTaskResult(track.taskId, result);
-            this.log("debug", `delegateTaskSync completed for ${track.taskId}`);
+            this.log("info", `[delegate-sync] ✓ ${track.taskId} completed — status=${taskResult.status}, outputLen=${taskResult.output?.length ?? 0}`);
             return taskResult;
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
             this.taskTracker.update(track.taskId, { status: "failed", error: errorMsg });
-            this.log("error", `delegateTaskSync failed for ${track.taskId}: ${errorMsg}`);
+            this.log("error", `[delegate-sync] ✗ ${track.taskId} failed: ${errorMsg}`);
             return { taskId: track.taskId, status: "failed", error: errorMsg };
         }
     }
@@ -348,26 +366,30 @@ class MulticlawsService extends node_events_1.EventEmitter {
      * reports results back to the user via the message tool.
      */
     async spawnDelegation(params) {
-        this.log("info", `spawnDelegation(agentUrl=${params.agentUrl}, task=${params.task.slice(0, 80)})`);
+        this.log("info", `[spawn-delegate] ▶ spawnDelegation(agentUrl=${params.agentUrl}, taskLen=${params.task.length})`);
+        this.log("info", `[spawn-delegate] task preview: ${params.task.slice(0, 120)}`);
         await this.requireCompleteProfile();
         const agent = await this.agentRegistry.get(params.agentUrl);
         if (!agent) {
-            this.log("warn", `spawnDelegation: unknown agent ${params.agentUrl}`);
+            this.log("warn", `[spawn-delegate] ✗ unknown agent: ${params.agentUrl}`);
             throw new Error(`unknown agent: ${params.agentUrl}`);
         }
+        this.log("info", `[spawn-delegate] agent found: ${agent.name} (${agent.url})`);
         if (!this.gatewayConfig) {
-            this.log("error", "spawnDelegation: gateway config not available");
+            this.log("error", `[spawn-delegate] ✗ gateway config not available`);
             throw new Error("gateway config not available — cannot spawn sub-agent");
         }
         const prompt = buildDelegationPrompt(agent, params.task);
-        await (0, gateway_client_1.invokeGatewayTool)({
+        const sessionKey = `delegate-${Date.now()}`;
+        this.log("info", `[spawn-delegate] spawning sub-agent via sessions_spawn (cwd=${this.resolvedCwd}, sessionKey=${sessionKey}, promptLen=${prompt.length})`);
+        const spawnResult = await (0, gateway_client_1.invokeGatewayTool)({
             gateway: this.gatewayConfig,
             tool: "sessions_spawn",
             args: { task: prompt, mode: "run", cwd: this.resolvedCwd },
-            sessionKey: `delegate-${Date.now()}`,
+            sessionKey,
             timeoutMs: 15_000,
         });
-        this.log("info", `spawnDelegation completed: sub-agent spawned for ${agent.name}`);
+        this.log("info", `[spawn-delegate] ✓ sub-agent spawned for ${agent.name} — result=${JSON.stringify(spawnResult).slice(0, 200)}`);
         return { message: `已启动子 agent 向 ${agent.name} 委派任务` };
     }
     getTaskStatus(taskId) {
@@ -858,24 +880,27 @@ class MulticlawsService extends node_events_1.EventEmitter {
      * return the final Task or Message as soon as B signals completion.
      */
     processTaskResult(trackId, result) {
-        this.log("debug", `processTaskResult(trackId=${trackId})`);
+        this.log("info", `[process-result] processing result for ${trackId}, resultType=${("status" in result && result.status) ? "Task" : "Message"}`);
         try {
             if ("status" in result && result.status) {
                 const task = result;
                 const state = task.status?.state ?? "unknown";
                 const output = this.extractArtifactText(task);
+                this.log("info", `[process-result] ${trackId} Task response — state=${state}, outputLen=${output.length}, preview=${output.slice(0, 120)}`);
                 if (state === "completed") {
                     this.taskTracker.update(trackId, { status: "completed", result: output });
+                    this.log("info", `[process-result] ✓ ${trackId} marked completed`);
                 }
                 else if (state === "failed") {
                     this.taskTracker.update(trackId, { status: "failed", error: output || "remote task failed" });
+                    this.log("warn", `[process-result] ✗ ${trackId} marked failed — error=${output || "remote task failed"}`);
                 }
                 else {
                     // For any other state (unknown, working, etc.), mark as failed to avoid
                     // tasks stuck in "running" forever until TTL prune.
                     this.taskTracker.update(trackId, { status: "failed", error: `unexpected remote state: ${state}` });
+                    this.log("warn", `[process-result] ✗ ${trackId} unexpected state=${state}, marked failed`);
                 }
-                this.log("debug", `processTaskResult completed, status=${state}`);
                 return { taskId: task.id, output, status: state };
             }
             const msg = result;
@@ -884,11 +909,11 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 .map((p) => p.text)
                 .join("\n") ?? "";
             this.taskTracker.update(trackId, { status: "completed", result: text });
-            this.log("debug", "processTaskResult completed, status=completed (message)");
+            this.log("info", `[process-result] ✓ ${trackId} Message response — completed, textLen=${text.length}, preview=${text.slice(0, 120)}`);
             return { taskId: trackId, output: text, status: "completed" };
         }
         catch (err) {
-            this.log("error", `processTaskResult failed for ${trackId}: ${err instanceof Error ? err.message : String(err)}`);
+            this.log("error", `[process-result] ✗ ${trackId} processing failed: ${err instanceof Error ? err.message : String(err)}`);
             throw err;
         }
     }
@@ -920,11 +945,16 @@ class MulticlawsService extends node_events_1.EventEmitter {
         }
         throw lastError;
     }
-    /** Register a channel ID for notifications. */
+    /** Resolve a pending A2A callback from sub-agent. */
     resolveA2ACallback(taskId, result) {
-        if (!this.agentExecutor)
+        this.log("info", `[a2a-callback] resolveA2ACallback(taskId=${taskId}, resultLen=${result.length})`);
+        if (!this.agentExecutor) {
+            this.log("warn", `[a2a-callback] ✗ no agentExecutor available for taskId=${taskId}`);
             return false;
-        return this.agentExecutor.resolveCallback(taskId, result);
+        }
+        const resolved = this.agentExecutor.resolveCallback(taskId, result);
+        this.log("info", `[a2a-callback] ${resolved ? "✓" : "✗"} taskId=${taskId} ${resolved ? "resolved" : "no pending callback found"}`);
+        return resolved;
     }
     addNotificationTarget(key, target) {
         if (!this.notificationTargets.has(key)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaws",
-  "version": "0.4.33",
+  "version": "0.4.34",
   "description": "MultiClaws plugin for OpenClaw collaboration via A2A protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",