@rk0429/agentic-relay 0.10.1 → 0.12.0

package/dist/relay.mjs

@@ -55,8 +55,8 @@ var init_recursion_guard = __esm({
     RecursionGuard = class _RecursionGuard {
       constructor(config = {
         maxDepth: 5,
-        maxCallsPerSession: 20,
-        timeoutSec: 300
+        maxCallsPerSession: 50,
+        timeoutSec: 1800
       }) {
         this.config = config;
       }
@@ -110,10 +110,15 @@ var init_recursion_guard = __esm({
             reason: `Max calls per session exceeded: ${currentCount} >= ${this.config.maxCallsPerSession}`
           };
         }
-        if (this.detectLoop(context.traceId, context.backend, context.promptHash)) {
+        if (this.detectLoop(
+          context.traceId,
+          context.backend,
+          context.promptHash,
+          context.taskType
+        )) {
           return {
             allowed: false,
-            reason: `Loop detected: same (backend=${context.backend}, promptHash=${context.promptHash}) appeared 3+ times in trace ${context.traceId}`
+            reason: `Loop detected: same (backend=${context.backend}, taskType=${context.taskType ?? ""}, promptHash=${context.promptHash}) appeared 5+ times in trace ${context.traceId}`
           };
         }
         return { allowed: true };
@@ -127,7 +132,7 @@ var init_recursion_guard = __esm({
         } else {
           this.callCounts.set(context.traceId, { count: 1, createdAt: Date.now() });
         }
-        const key = `${context.backend}:${context.promptHash}`;
+        const key = `${context.backend}:${context.taskType ?? ""}:${context.promptHash}`;
         const hashEntry = this.promptHashes.get(context.traceId);
         if (hashEntry) {
           hashEntry.hashes.push(key);
@@ -135,12 +140,12 @@ var init_recursion_guard = __esm({
           this.promptHashes.set(context.traceId, { hashes: [key], createdAt: Date.now() });
         }
       }
-      /** Detect if the same (backend + promptHash) combination has appeared 3+ times */
-      detectLoop(traceId, backend, promptHash) {
-        const key = `${backend}:${promptHash}`;
+      /** Detect if the same (backend + taskType + promptHash) combination has appeared 5+ times */
+      detectLoop(traceId, backend, promptHash, taskType) {
+        const key = `${backend}:${taskType ?? ""}:${promptHash}`;
         const hashes = this.promptHashes.get(traceId)?.hashes ?? [];
         const count = hashes.filter((h) => h === key).length;
-        return count >= 3;
+        return count >= 5;
       }
       /** Get current config (for testing/inspection) */
       getConfig() {
@@ -344,7 +349,8 @@ async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooks
     traceId: envContext.traceId,
     depth: envContext.depth,
     backend: effectiveBackend,
-    promptHash
+    promptHash,
+    taskType: input.taskType
   };
   const guardResult = guard.canSpawn(context);
   if (!guardResult.allowed) {
@@ -1041,6 +1047,24 @@ var init_backend_selector = __esm({
   }
 });
 
+// src/types/mcp.ts
+var DEFAULT_TASK_TTL, DEFAULT_POLL_INTERVAL;
+var init_mcp = __esm({
+  "src/types/mcp.ts"() {
+    "use strict";
+    DEFAULT_TASK_TTL = 5 * 60 * 1e3;
+    DEFAULT_POLL_INTERVAL = 3e3;
+  }
+});
+
+// src/types/index.ts
+var init_types = __esm({
+  "src/types/index.ts"() {
+    "use strict";
+    init_mcp();
+  }
+});
+
 // src/mcp-server/response-formatter.ts
 function formatSpawnAgentResponse(result) {
   const isError = result.exitCode !== 0;
@@ -1113,9 +1137,20 @@ __export(server_exports, {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { InMemoryTaskStore } from "@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js";
+import { InMemoryTaskMessageQueue } from "@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js";
 import { createServer } from "http";
 import { randomUUID } from "crypto";
 import { z as z5 } from "zod";
+function createMcpServerOptions() {
+  const taskStore = new InMemoryTaskStore();
+  return {
+    capabilities: { tasks: { requests: { tools: { call: {} } } } },
+    taskStore,
+    taskMessageQueue: new InMemoryTaskMessageQueue(),
+    defaultTaskPollInterval: DEFAULT_POLL_INTERVAL
+  };
+}
 var spawnAgentsParallelInputShape, MAX_CHILD_HTTP_SESSIONS, RelayMCPServer;
 var init_server = __esm({
   "src/mcp-server/server.ts"() {
@@ -1128,6 +1163,7 @@ var init_server = __esm({
     init_list_available_backends();
     init_backend_selector();
     init_logger();
+    init_types();
     init_response_formatter();
     spawnAgentsParallelInputShape = {
       agents: z5.array(spawnAgentInputSchema).min(1).max(10).describe(
@@ -1143,10 +1179,10 @@ var init_server = __esm({
         this.contextMonitor = contextMonitor2;
         this.guard = new RecursionGuard(guardConfig);
         this.backendSelector = new BackendSelector();
-        this.server = new McpServer({
-          name: "agentic-relay",
-          version: "0.10.1"
-        });
+        this.server = new McpServer(
+          { name: "agentic-relay", version: "0.12.0" },
+          createMcpServerOptions()
+        );
         this.registerTools(this.server);
       }
       server;
@@ -1162,94 +1198,148 @@ var init_server = __esm({
       get childHttpServer() {
         return this._childHttpServer;
       }
-      registerTools(server) {
-        server.tool(
-          "spawn_agent",
-          "Spawn a sub-agent on the specified backend CLI (Claude Code, Codex CLI, or Gemini CLI). The agent executes the given prompt in non-interactive mode and returns the result. Use 'agent' for named agent configurations (Claude only), 'systemPrompt' for custom role instructions (all backends), 'skillContext' to inject a skill definition (SKILL.md/SUBSKILL.md), 'agentDefinition' to inject an agent definition file into the sub-agent's system prompt, 'preferredBackend' to override automatic backend selection, or 'taskType' to hint at the task nature for backend selection.",
-          spawnAgentInputSchema.shape,
-          async (params, extra) => {
+      /**
+       * Run spawn_agent in the background and store the result in taskStore.
+       * Fire-and-forget: errors are caught and stored as failed task results.
+       */
+      runSpawnAgentInBackground(taskId, params, extra) {
+        const run = async () => {
+          try {
+            const result = await executeSpawnAgent(
+              params,
+              this.registry,
+              this.sessionManager,
+              this.guard,
+              this.hooksEngine,
+              this.contextMonitor,
+              this.backendSelector,
+              this._childHttpUrl
+            );
+            const { text, isError } = formatSpawnAgentResponse(result);
+            const callToolResult = {
+              content: [{ type: "text", text }],
+              isError
+            };
+            await extra.taskStore.storeTaskResult(
+              taskId,
+              "completed",
+              callToolResult
+            );
+          } catch (outerError) {
             try {
-              const onProgress = (progress) => {
-                const progressToken = params._meta ? params._meta.progressToken : void 0;
-                if (progressToken !== void 0) {
-                  void extra.sendNotification({
-                    method: "notifications/progress",
-                    params: {
-                      progressToken,
-                      progress: progress.percent ?? 0,
-                      total: 100,
-                      message: progress.stage
-                    }
-                  });
+              const message = outerError instanceof Error ? outerError.message : String(outerError);
+              await extra.taskStore.storeTaskResult(
+                taskId,
+                "failed",
+                {
+                  content: [{ type: "text", text: `Error: ${message}` }],
+                  isError: true
                 }
-              };
-              const result = await executeSpawnAgent(
-                params,
-                this.registry,
-                this.sessionManager,
-                this.guard,
-                this.hooksEngine,
-                this.contextMonitor,
-                this.backendSelector,
-                this._childHttpUrl,
-                onProgress
               );
-              const { text, isError } = formatSpawnAgentResponse(result);
-              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
-              };
+            } catch (storeError) {
+              logger.error(
+                `Failed to store task result for ${taskId}: ${storeError instanceof Error ? storeError.message : String(storeError)}`
+              );
             }
           }
-        );
-        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. Failed results include 'originalInput' for retry via retry_failed_agents.",
-          spawnAgentsParallelInputShape,
-          async (params, extra) => {
+        };
+        void run();
+      }
+      /**
+       * Run spawn_agents_parallel in the background and store the result in taskStore.
+       * Fire-and-forget: errors are caught and stored as failed task results.
+       */
+      runSpawnAgentsParallelInBackground(taskId, agents, extra) {
+        const run = async () => {
+          try {
+            const result = await executeSpawnAgentsParallel(
+              agents,
+              this.registry,
+              this.sessionManager,
+              this.guard,
+              this.hooksEngine,
+              this.contextMonitor,
+              this.backendSelector,
+              this._childHttpUrl
+            );
+            const { text, isError } = formatParallelResponse(result);
+            const callToolResult = {
+              content: [{ type: "text", text }],
+              isError
+            };
+            await extra.taskStore.storeTaskResult(
+              taskId,
+              "completed",
+              callToolResult
+            );
+          } catch (outerError) {
             try {
-              const onProgress = (progress) => {
-                const progressToken = params._meta ? params._meta.progressToken : void 0;
-                if (progressToken !== void 0) {
-                  void extra.sendNotification({
-                    method: "notifications/progress",
-                    params: {
-                      progressToken,
-                      progress: progress.percent ?? 0,
-                      total: 100,
-                      message: progress.stage
-                    }
-                  });
+              const message = outerError instanceof Error ? outerError.message : String(outerError);
+              await extra.taskStore.storeTaskResult(
+                taskId,
+                "failed",
+                {
+                  content: [{ type: "text", text: `Error: ${message}` }],
+                  isError: true
                 }
-              };
-              const result = await executeSpawnAgentsParallel(
-                params.agents,
-                this.registry,
-                this.sessionManager,
-                this.guard,
-                this.hooksEngine,
-                this.contextMonitor,
-                this.backendSelector,
-                this._childHttpUrl,
-                onProgress
               );
-              const { text, isError } = formatParallelResponse(result);
-              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
-              };
+            } catch (storeError) {
+              logger.error(
+                `Failed to store parallel task result for ${taskId}: ${storeError instanceof Error ? storeError.message : String(storeError)}`
+              );
+            }
+          }
+        };
+        void run();
+      }
+      registerTools(server) {
+        server.experimental.tasks.registerToolTask(
+          "spawn_agent",
+          {
+            description: "Spawn a sub-agent on the specified backend CLI (Claude Code, Codex CLI, or Gemini CLI). The agent executes the given prompt in non-interactive mode and returns the result. Use 'agent' for named agent configurations (Claude only), 'systemPrompt' for custom role instructions (all backends), 'skillContext' to inject a skill definition (SKILL.md/SUBSKILL.md), 'agentDefinition' to inject an agent definition file into the sub-agent's system prompt, 'preferredBackend' to override automatic backend selection, or 'taskType' to hint at the task nature for backend selection.",
+            inputSchema: spawnAgentInputSchema.shape,
+            execution: { taskSupport: "optional" }
+          },
+          {
+            createTask: async (params, extra) => {
+              const task = await extra.taskStore.createTask({
+                ttl: DEFAULT_TASK_TTL,
+                pollInterval: DEFAULT_POLL_INTERVAL
+              });
+              this.runSpawnAgentInBackground(task.taskId, params, extra);
+              return { task };
+            },
+            getTask: async (_params, extra) => {
+              const task = await extra.taskStore.getTask(extra.taskId);
+              return { task: task ?? void 0 };
+            },
+            getTaskResult: async (_params, extra) => {
+              return await extra.taskStore.getTaskResult(extra.taskId);
+            }
+          }
+        );
+        server.experimental.tasks.registerToolTask(
+          "spawn_agents_parallel",
+          {
+            description: "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. Failed results include 'originalInput' for retry via retry_failed_agents.",
+            inputSchema: spawnAgentsParallelInputShape,
+            execution: { taskSupport: "optional" }
+          },
+          {
+            createTask: async (params, extra) => {
+              const task = await extra.taskStore.createTask({
+                ttl: DEFAULT_TASK_TTL,
+                pollInterval: DEFAULT_POLL_INTERVAL
+              });
+              this.runSpawnAgentsParallelInBackground(task.taskId, params.agents, extra);
+              return { task };
+            },
+            getTask: async (_params, extra) => {
+              const task = await extra.taskStore.getTask(extra.taskId);
+              return { task: task ?? void 0 };
+            },
+            getTaskResult: async (_params, extra) => {
+              return await extra.taskStore.getTaskResult(extra.taskId);
             }
           }
         );
@@ -1451,10 +1541,10 @@ var init_server = __esm({
           const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => randomUUID()
           });
-          const server = new McpServer({
-            name: "agentic-relay",
-            version: "0.10.1"
-          });
+          const server = new McpServer(
+            { name: "agentic-relay", version: "0.12.0" },
+            createMcpServerOptions()
+          );
           this.registerTools(server);
           transport.onclose = () => {
             const sid2 = transport.sessionId;
@@ -4405,7 +4495,7 @@ function createVersionCommand(registry2) {
       description: "Show relay and backend versions"
     },
     async run() {
-      const relayVersion = "0.10.1";
+      const relayVersion = "0.12.0";
       console.log(`agentic-relay v${relayVersion}`);
       console.log("");
       console.log("Backends:");
@@ -4755,7 +4845,7 @@ void configManager.getConfig().then((config) => {
 var main = defineCommand10({
   meta: {
     name: "relay",
-    version: "0.10.1",
+    version: "0.12.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.10.1",
+  "version": "0.12.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",