multiclaws 0.4.0 → 0.4.1

package/dist/gateway/handlers.js

@@ -18,6 +18,10 @@ const sessionReplySchema = zod_1.z.object({
 });
 const sessionStatusSchema = zod_1.z.object({ sessionId: zod_1.z.string().trim().min(1).optional() });
 const sessionEndSchema = zod_1.z.object({ sessionId: nonEmptyString });
+const sessionWaitAllSchema = zod_1.z.object({
+    sessionIds: zod_1.z.array(nonEmptyString).min(1),
+    timeoutMs: zod_1.z.number().positive().optional(),
+});
 const profileSetSchema = zod_1.z.object({
     ownerName: zod_1.z.string().trim().optional(),
     bio: zod_1.z.string().optional(),
@@ -106,6 +110,17 @@ function createGatewayHandlers(getService) {
                 safeHandle(respond, "session_status_failed", error);
             }
         },
+        "multiclaws.session.wait_all": async ({ params, respond }) => {
+            try {
+                const parsed = sessionWaitAllSchema.parse(params);
+                const service = getService();
+                const result = await service.waitForSessions(parsed);
+                respond(true, result);
+            }
+            catch (error) {
+                safeHandle(respond, "session_wait_all_failed", error);
+            }
+        },
         "multiclaws.session.end": async ({ params, respond }) => {
             try {
                 const parsed = sessionEndSchema.parse(params);

package/dist/index.js

@@ -155,6 +155,30 @@ function createTools(getService) {
             return textResult(JSON.stringify({ sessions }, null, 2), { sessions });
         },
     };
+    const multiclawsSessionWaitAll = {
+        name: "multiclaws_session_wait_all",
+        description: "Wait for multiple sessions to complete, then return all results at once. Use this when you have started multiple sessions concurrently and need all results before synthesizing an answer. Returns early if any session needs input (input-required). Default timeout: 5 minutes.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                sessionIds: { type: "array", items: { type: "string" } },
+                timeoutMs: { type: "number" },
+            },
+            required: ["sessionIds"],
+        },
+        execute: async (_toolCallId, args) => {
+            const service = requireService(getService());
+            const sessionIds = Array.isArray(args.sessionIds)
+                ? args.sessionIds.map((s) => String(s).trim()).filter(Boolean)
+                : [];
+            if (!sessionIds.length)
+                throw new Error("sessionIds must be a non-empty array");
+            const timeoutMs = typeof args.timeoutMs === "number" ? args.timeoutMs : undefined;
+            const result = await service.waitForSessions({ sessionIds, timeoutMs });
+            return textResult(JSON.stringify(result, null, 2), result);
+        },
+    };
     const multiclawsSessionEnd = {
         name: "multiclaws_session_end",
         description: "Cancel and close a collaboration session.",
@@ -327,6 +351,7 @@ function createTools(getService) {
         multiclawsSessionStart,
         multiclawsSessionReply,
         multiclawsSessionStatus,
+        multiclawsSessionWaitAll,
         multiclawsSessionEnd,
         multiclawsTeamCreate,
         multiclawsTeamJoin,

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

@@ -63,6 +63,19 @@ export declare class MulticlawsService extends EventEmitter {
     }): Promise<SessionReplyResult>;
     getSession(sessionId: string): ConversationSession | null;
     listSessions(): ConversationSession[];
+    waitForSessions(params: {
+        sessionIds: string[];
+        timeoutMs?: number;
+    }): Promise<{
+        results: Array<{
+            sessionId: string;
+            status: string;
+            agentName: string;
+            lastMessage?: string;
+            error?: string;
+        }>;
+        timedOut: boolean;
+    }>;
     endSession(sessionId: string): boolean;
     private runSession;
     private handleSessionResult;

package/dist/service/multiclaws-service.js

@@ -262,6 +262,36 @@ class MulticlawsService extends node_events_1.EventEmitter {
     listSessions() {
         return this.sessionStore.list();
     }
+    async waitForSessions(params) {
+        const timeout = params.timeoutMs ?? 5 * 60 * 1000;
+        const deadline = Date.now() + timeout;
+        const terminalStates = new Set(["completed", "failed", "canceled"]);
+        const getResults = () => params.sessionIds.map((id) => {
+            const session = this.sessionStore.get(id);
+            if (!session)
+                return { sessionId: id, agentName: "unknown", status: "not_found" };
+            const lastAgent = [...session.messages].reverse().find((m) => m.role === "agent");
+            return {
+                sessionId: id,
+                agentName: session.agentName,
+                status: session.status,
+                lastMessage: lastAgent?.content,
+                error: session.error,
+            };
+        });
+        while (Date.now() < deadline) {
+            const results = getResults();
+            const allSettled = results.every((r) => terminalStates.has(r.status) || r.status === "not_found");
+            if (allSettled)
+                return { results, timedOut: false };
+            // Return early if any session needs input — AI must handle it before continuing
+            const needsInput = results.some((r) => r.status === "input-required");
+            if (needsInput)
+                return { results, timedOut: false };
+            await new Promise((r) => setTimeout(r, 1_000));
+        }
+        return { results: getResults(), timedOut: true };
+    }
     endSession(sessionId) {
         const session = this.sessionStore.get(sessionId);
         if (!session)

package/package.json

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

package/skills/multiclaws/SKILL.md

@@ -49,13 +49,19 @@ multiclaws_session_status(sessionId="...") → 查看单个会话及消息历史
 multiclaws_session_end(sessionId="...")  → 取消并关闭会话
 ```
 
-### 并发协作
-可同时开启多个 session，各自独立运行：
+### 并发协作（自动汇总）
+同时开启多个 session，等所有结果后汇总：
 ```
-multiclaws_session_start(agentUrl=B, message="任务1") → sessionId_1
-multiclaws_session_start(agentUrl=C, message="任务2") → sessionId_2
+id1 = multiclaws_session_start(agentUrl=B, message="子任务1")
+id2 = multiclaws_session_start(agentUrl=C, message="子任务2")
+results = multiclaws_session_wait_all(sessionIds=[id1, id2])
+→ 阻塞直到全部完成，返回所有结果
+→ AI 汇总后回复用户
 ```
 
+**注意**：若任何 session 变为 `input-required`，`wait_all` 会提前返回，
+AI 应先用 `session_reply` 处理，再继续等待剩余 session。
+
 ### 链式协作（A→B→C）
 B 内部可以自己调用 `multiclaws_session_start` 委派给 C，结果自然冒泡回 A。
 
@@ -99,6 +105,7 @@ multiclaws_profile_show()
 | `multiclaws_session_start` | 开始协作会话（替代旧 delegate） | `agentUrl`, `message` |
 | `multiclaws_session_reply` | 在会话中发送后续消息 | `sessionId`, `message` |
 | `multiclaws_session_status` | 查看会话状态和消息历史 | `sessionId`（可选，不传返回全部） |
+| `multiclaws_session_wait_all` | 等待多个会话全部完成，返回所有结果 | `sessionIds[]`, `timeoutMs`（可选） |
 | `multiclaws_session_end` | 取消/关闭会话 | `sessionId` |
 
 ### 档案