@rk0429/agentic-relay 0.6.3 → 0.7.0

package/dist/relay.mjs

@@ -542,6 +542,97 @@ var init_spawn_agent = __esm({
   }
 });
 
+// src/mcp-server/tools/spawn-agents-parallel.ts
+async function executeSpawnAgentsParallel(agents, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2, backendSelector, childHttpUrl) {
+  const envContext = buildContextFromEnv();
+  if (envContext.depth >= guard.getConfig().maxDepth) {
+    const reason = `Max depth exceeded: ${envContext.depth} >= ${guard.getConfig().maxDepth}`;
+    logger.warn(`Batch spawn blocked by RecursionGuard: ${reason}`);
+    return {
+      results: agents.map((_, index) => ({
+        index,
+        sessionId: "",
+        exitCode: 1,
+        stdout: "",
+        stderr: `Batch spawn blocked: ${reason}`,
+        error: reason
+      })),
+      totalCount: agents.length,
+      successCount: 0,
+      failureCount: agents.length
+    };
+  }
+  const currentCount = guard.getCallCount(envContext.traceId);
+  const maxCalls = guard.getConfig().maxCallsPerSession;
+  if (currentCount + agents.length > maxCalls) {
+    const reason = `Batch would exceed max calls per session: ${currentCount} + ${agents.length} > ${maxCalls}`;
+    logger.warn(`Batch spawn blocked by RecursionGuard: ${reason}`);
+    return {
+      results: agents.map((_, index) => ({
+        index,
+        sessionId: "",
+        exitCode: 1,
+        stdout: "",
+        stderr: `Batch spawn blocked: ${reason}`,
+        error: reason
+      })),
+      totalCount: agents.length,
+      successCount: 0,
+      failureCount: agents.length
+    };
+  }
+  const settled = await Promise.allSettled(
+    agents.map(
+      (agent) => executeSpawnAgent(
+        agent,
+        registry2,
+        sessionManager2,
+        guard,
+        hooksEngine2,
+        contextMonitor2,
+        backendSelector,
+        childHttpUrl
+      )
+    )
+  );
+  const results = settled.map((outcome, index) => {
+    if (outcome.status === "fulfilled") {
+      const r = outcome.value;
+      return {
+        index,
+        sessionId: r.sessionId,
+        exitCode: r.exitCode,
+        stdout: r.stdout,
+        stderr: r.stderr,
+        ...r.nativeSessionId ? { nativeSessionId: r.nativeSessionId } : {}
+      };
+    }
+    const errorMessage = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+    return {
+      index,
+      sessionId: "",
+      exitCode: 1,
+      stdout: "",
+      stderr: errorMessage,
+      error: errorMessage
+    };
+  });
+  const successCount = results.filter((r) => r.exitCode === 0).length;
+  return {
+    results,
+    totalCount: agents.length,
+    successCount,
+    failureCount: agents.length - successCount
+  };
+}
+var init_spawn_agents_parallel = __esm({
+  "src/mcp-server/tools/spawn-agents-parallel.ts"() {
+    "use strict";
+    init_spawn_agent();
+    init_logger();
+  }
+});
+
 // src/mcp-server/tools/list-sessions.ts
 import { z as z3 } from "zod";
 async function executeListSessions(input, sessionManager2) {
@@ -702,6 +793,7 @@ var init_server = __esm({
     "use strict";
     init_recursion_guard();
     init_spawn_agent();
+    init_spawn_agents_parallel();
     init_list_sessions();
     init_get_context_status();
     init_list_available_backends();
@@ -717,12 +809,11 @@ var init_server = __esm({
         this.backendSelector = new BackendSelector();
         this.server = new McpServer({
           name: "agentic-relay",
-          version: "0.6.3"
+          version: "0.7.0"
         });
         this.registerTools(this.server);
       }
       server;
-      childServer;
       guard;
       backendSelector;
       _childHttpServer;
@@ -788,6 +879,56 @@ ${result.stdout}`;
             }
           }
         );
+        server.tool(
+          "spawn_agents_parallel",
+          "Spawn multiple sub-agents in parallel across available backends. Each agent entry accepts the same parameters as spawn_agent. All agents are executed concurrently via Promise.allSettled, and results are returned as an array with per-agent status. RecursionGuard batch pre-validation ensures the entire batch fits within call limits before execution begins.",
+          {
+            agents: z5.array(z5.object({
+              backend: z5.enum(["claude", "codex", "gemini"]),
+              prompt: z5.string(),
+              agent: z5.string().optional().describe("Named agent configuration (Claude only)"),
+              systemPrompt: z5.string().optional().describe("System prompt / role instructions for the sub-agent (all backends)"),
+              resumeSessionId: z5.string().optional(),
+              model: z5.string().optional(),
+              maxTurns: z5.number().optional(),
+              skillContext: z5.object({
+                skillPath: z5.string().describe("Path to the skill directory"),
+                subskill: z5.string().optional().describe("Specific subskill to activate")
+              }).optional().describe("Skill context to inject into the sub-agent's system prompt"),
+              agentDefinition: z5.object({
+                definitionPath: z5.string().describe("Path to the agent definition file")
+              }).optional().describe("Agent definition file to inject into the sub-agent's system prompt"),
+              preferredBackend: z5.enum(["claude", "codex", "gemini"]).optional().describe("Preferred backend override."),
+              taskType: z5.enum(["code", "document", "analysis", "mixed"]).optional().describe("Task type hint for automatic backend selection.")
+            })).min(1).max(10).describe("Array of agent configurations to execute in parallel (1-10 agents)")
+          },
+          async (params) => {
+            try {
+              const result = await executeSpawnAgentsParallel(
+                params.agents,
+                this.registry,
+                this.sessionManager,
+                this.guard,
+                this.hooksEngine,
+                this.contextMonitor,
+                this.backendSelector,
+                this._childHttpUrl
+              );
+              const isError = result.failureCount === result.totalCount;
+              const text = JSON.stringify(result, null, 2);
+              return {
+                content: [{ type: "text", text }],
+                isError
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true
+              };
+            }
+          }
+        );
         server.tool(
           "list_sessions",
           "List relay sessions, optionally filtered by backend.",
@@ -912,29 +1053,51 @@ ${result.stdout}`;
       }
       /**
        * Start an HTTP server for child agents.
-       * Creates a separate McpServer instance (since McpServer.connect() can only be called once)
-       * and binds it to a random port on 127.0.0.1.
+       * Each client connection gets its own McpServer + StreamableHTTPServerTransport pair
+       * because StreamableHTTPServerTransport only supports a single session per instance.
+       * Routes requests to the correct session based on the Mcp-Session-Id header.
        */
       async startChildHttpServer() {
-        this.childServer = new McpServer({
-          name: "agentic-relay",
-          version: "0.6.3"
-        });
-        this.registerTools(this.childServer);
-        const childTransport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => randomUUID()
-        });
+        const sessions = /* @__PURE__ */ new Map();
         const httpServer = createServer(async (req, res) => {
           const url = req.url ?? "";
-          if (url === "/mcp" || url.startsWith("/mcp?")) {
-            await childTransport.handleRequest(req, res);
-          } else {
+          if (url !== "/mcp" && !url.startsWith("/mcp?")) {
             res.writeHead(404, { "Content-Type": "text/plain" });
             res.end("Not found");
+            return;
+          }
+          const sessionId = req.headers["mcp-session-id"];
+          if (sessionId) {
+            const session = sessions.get(sessionId);
+            if (session) {
+              await session.transport.handleRequest(req, res);
+              return;
+            }
+          }
+          const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID()
+          });
+          const server = new McpServer({
+            name: "agentic-relay",
+            version: "0.7.0"
+          });
+          this.registerTools(server);
+          transport.onclose = () => {
+            const sid2 = transport.sessionId;
+            if (sid2) {
+              sessions.delete(sid2);
+              logger.debug(`Child MCP session closed: ${sid2}`);
+            }
+          };
+          await server.connect(transport);
+          await transport.handleRequest(req, res);
+          const sid = transport.sessionId;
+          if (sid) {
+            sessions.set(sid, { transport, server });
+            logger.debug(`Child MCP session created: ${sid}`);
           }
         });
         this._childHttpServer = httpServer;
-        await this.childServer.connect(childTransport);
         await new Promise((resolve) => {
           httpServer.listen(0, "127.0.0.1", () => {
             const addr = httpServer.address();
@@ -3898,7 +4061,7 @@ function createVersionCommand(registry2) {
       description: "Show relay and backend versions"
     },
     async run() {
-      const relayVersion = "0.6.3";
+      const relayVersion = "0.7.0";
       console.log(`agentic-relay v${relayVersion}`);
       console.log("");
       console.log("Backends:");
@@ -4248,7 +4411,7 @@ void configManager.getConfig().then((config) => {
 var main = defineCommand10({
   meta: {
     name: "relay",
-    version: "0.6.3",
+    version: "0.7.0",
     description: "Unified CLI proxy for Claude Code, Codex CLI, and Gemini CLI"
   },
   subCommands: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rk0429/agentic-relay",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Unified CLI proxy for Claude Code, Codex CLI, and Gemini CLI with MCP-based multi-layer sub-agent orchestration",
   "type": "module",
   "license": "Apache-2.0",