create-multicast 0.4.3 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-multicast",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Create a Multicast MCP gateway — one command to scaffold, configure, and deploy your parallel MCP server.",
   "type": "module",
   "bin": "./dist/cli.js",

package/templates/default/src/index.ts

@@ -919,66 +919,118 @@ Clears the cache and re-fetches tools/list from every registered server.`,
 
     this.server.tool(
       "fetch_result",
-      `Retrieve the full output of a large result that was stored by reference.
-When multicast returns an output_ref instead of inline output, call this
-tool with the ref ID to get the complete data. Results expire after 1 hour.`,
+      `Retrieve the full output of large results stored by reference.
+When multicast returns output_ref instead of inline output, call this tool
+to get the complete data. Accepts a SINGLE ref or MULTIPLE refs at once.
+Always pass ALL refs in one call — don't call this tool multiple times.
+Results expire after 1 hour.
+
+Example (single): { "ref": "ref_abc123" }
+Example (batch):  { "refs": ["ref_abc123", "ref_def456"] }`,
       {
         ref: z
           .string()
-          .describe("The output_ref ID from a multicast result (e.g., ref_abc123def456)"),
+          .optional()
+          .describe("Single output_ref ID (use this OR refs, not both)"),
+        refs: z
+          .array(z.string())
+          .optional()
+          .describe("Multiple output_ref IDs to fetch at once (use this OR ref, not both)"),
       },
-      async ({ ref }) => {
+      async ({ ref, refs }) => {
         const db = this.env.DB;
 
-        const row = await db
-          .prepare(
-            "SELECT server_name, tool_name, output, created_at FROM result_cache WHERE ref_id = ?"
-          )
-          .bind(ref)
-          .first<{
-            server_name: string;
-            tool_name: string;
-            output: string;
-            created_at: string;
-          }>();
-
-        if (!row) {
+        // Normalize: single ref or batch refs into one array
+        const refIds: string[] = [];
+        if (refs && refs.length > 0) {
+          refIds.push(...refs);
+        } else if (ref) {
+          refIds.push(ref);
+        } else {
           return {
-            content: [
-              {
-                type: "text" as const,
-                text: JSON.stringify({
-                  error: `Result not found for ref "${ref}". It may have expired (results are kept for 1 hour).`,
-                }),
-              },
-            ],
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({ error: "Provide either 'ref' (single) or 'refs' (array)." }),
+            }],
           };
         }
 
-        // Parse the stored output back
-        let parsedOutput: unknown;
-        try {
-          parsedOutput = JSON.parse(row.output);
-        } catch {
-          parsedOutput = row.output;
+        // Fetch all refs in one D1 batch
+        const results: Array<{
+          ref_id: string;
+          server: string;
+          tool: string;
+          output: unknown;
+          cached_at: string;
+          error?: string;
+        }> = [];
+
+        for (const refId of refIds) {
+          const row = await db
+            .prepare(
+              "SELECT server_name, tool_name, output, created_at FROM result_cache WHERE ref_id = ?"
+            )
+            .bind(refId)
+            .first<{
+              server_name: string;
+              tool_name: string;
+              output: string;
+              created_at: string;
+            }>();
+
+          if (!row) {
+            results.push({
+              ref_id: refId,
+              server: "unknown",
+              tool: "unknown",
+              output: null,
+              cached_at: "",
+              error: `Not found — may have expired (1 hour TTL).`,
+            });
+            continue;
+          }
+
+          let parsedOutput: unknown;
+          try {
+            parsedOutput = JSON.parse(row.output);
+          } catch {
+            parsedOutput = row.output;
+          }
+
+          results.push({
+            ref_id: refId,
+            server: row.server_name,
+            tool: row.tool_name,
+            output: parsedOutput,
+            cached_at: row.created_at,
+          });
+        }
+
+        // Single ref: return flat (backwards compatible)
+        if (refIds.length === 1 && results.length === 1 && !results[0].error) {
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({
+                server: results[0].server,
+                tool: results[0].tool,
+                output: results[0].output,
+                cached_at: results[0].cached_at,
+              }, null, 2),
+            }],
+          };
         }
 
+        // Batch: return array of results
         return {
-          content: [
-            {
-              type: "text" as const,
-              text: JSON.stringify(
-                {
-                  server: row.server_name,
-                  tool: row.tool_name,
-                  output: parsedOutput,
-                  cached_at: row.created_at,
-                },
-                null,
-                2
-              ),
-            },
-          ],
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              results,
+              fetched: results.filter((r) => !r.error).length,
+              errors: results.filter((r) => r.error).length,
+            }, null, 2),
+          }],
         };
       }
     );