nexus-agents 2.63.5 → 2.63.6

package/dist/{chunk-LQPW7LIC.js → chunk-CUGQAPGY.js}

@@ -69,7 +69,7 @@ import {
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-3K6O2OL5.js";
+} from "./chunk-HRTGSG4L.js";
 import {
   DEFAULTS
 } from "./chunk-6MRF2PE2.js";
@@ -4561,7 +4561,7 @@ var ConsensusProtocol = class {
       requireUnanimous: config.requireUnanimous
     });
     const votingTask = createVotingTask(config.task);
-    const promises = config.experts.map(async (expertId) => {
+    const promises2 = config.experts.map(async (expertId) => {
       const agent = agents.get(expertId);
       if (agent === void 0) {
         return { expertId, result: err(new AgentError(`Agent not found: ${expertId}`)) };
@@ -4569,7 +4569,7 @@ var ConsensusProtocol = class {
       const result = await this.executeAgentTask(agent, votingTask);
       return { expertId, result };
     });
-    const results = await Promise.all(promises);
+    const results = await Promise.all(promises2);
     for (const { expertId, result } of results) {
       if (result.ok) {
         this.session.submitResult(expertId, result.value);
@@ -6137,7 +6137,7 @@ var ParallelProtocol = class extends BaseProtocol {
       sessionId: config.sessionId,
       expertCount: config.experts.length
     });
-    const promises = config.experts.map(async (expertId) => {
+    const promises2 = config.experts.map(async (expertId) => {
       const agent = agents.get(expertId);
       if (agent === void 0) {
         return { expertId, result: err(new AgentError(`Agent not found: ${expertId}`)) };
@@ -6145,7 +6145,7 @@ var ParallelProtocol = class extends BaseProtocol {
       const result = await this.executeAgentTask(agent, config.task);
       return { expertId, result };
     });
-    const results = await Promise.all(promises);
+    const results = await Promise.all(promises2);
     for (const { expertId, result } of results) {
       if (result.ok) {
         session.submitResult(expertId, result.value);
@@ -19169,10 +19169,10 @@ async function executeParallel(steps, context, stepExecutor, options) {
   }
 }
 async function runAllSteps(steps, context, stepExecutor, opts, state) {
-  const promises = steps.map(
+  const promises2 = steps.map(
     (step) => executeStepInQueue(step, context, stepExecutor, opts, state)
   );
-  await Promise.allSettled(promises);
+  await Promise.allSettled(promises2);
 }
 async function executeStepInQueue(step, context, stepExecutor, opts, state) {
   try {
@@ -26804,8 +26804,8 @@ function applyStateUpdates(graph, state, updates) {
   return newState;
 }
 async function executeNodes(graph, nodeIds, state, options) {
-  const promises = nodeIds.map((id) => executeSingleNode(graph, id, state, options));
-  return Promise.all(promises);
+  const promises2 = nodeIds.map((id) => executeSingleNode(graph, id, state, options));
+  return Promise.all(promises2);
 }
 function preconditionFailedResult(nodeId, results, startTime) {
   const failed = results.find((r) => !r.passed);
@@ -37009,7 +37009,7 @@ function createResearchQueryHandler(deps) {
     const logger56 = deps.logger ?? createLogger({ tool: "research_query" });
     return withToolError("Research query failed", logger56, async () => {
       const result = await executeQuery(validationResult.data);
-      return toolSuccess(JSON.stringify(result, null, 2));
+      return toolSuccessStructured(result);
     });
   };
 }
@@ -37033,9 +37033,14 @@ function registerResearchQueryTool(server, deps) {
     timeoutMs,
     logger: logger56
   });
+  const outputSchema = {
+    action: z62.string(),
+    success: z62.boolean(),
+    data: z62.unknown()
+  };
   server.registerTool(
     "research_query",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered research_query tool with secure handler and timeout protection");
@@ -37101,7 +37106,7 @@ function createResearchAddHandler(deps) {
       if (!result.success) {
         return toolError(result.message);
       }
-      return toolSuccess(JSON.stringify(result, null, 2));
+      return toolSuccessStructured(result);
     });
   };
 }
@@ -37124,9 +37129,16 @@ function registerResearchAddTool(server, deps) {
     timeoutMs,
     logger: logger56
   });
+  const outputSchema = {
+    success: z63.boolean(),
+    paperId: z63.string().optional(),
+    title: z63.string().optional(),
+    message: z63.string(),
+    dryRun: z63.boolean().optional()
+  };
   server.registerTool(
     "research_add",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered research_add tool with secure handler and timeout protection");
@@ -37283,7 +37295,7 @@ function createResearchAddSourceHandler(deps) {
       if (!result.success) {
         return toolError(result.message);
       }
-      return toolSuccess(JSON.stringify(result, null, 2));
+      return toolSuccessStructured(result);
     });
   };
 }
@@ -37322,10 +37334,19 @@ function registerResearchAddSourceTool(server, deps) {
   });
   server.registerTool(
     "research_add_source",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema: RESEARCH_ADD_SOURCE_OUTPUT_SCHEMA },
     toSdkCallback(wrappedHandler)
   );
 }
+var RESEARCH_ADD_SOURCE_OUTPUT_SCHEMA = {
+  success: z64.boolean(),
+  sourceId: z64.string().optional(),
+  name: z64.string().optional(),
+  quality_score: z64.number().optional(),
+  evidence_tier: z64.string().optional(),
+  message: z64.string().optional(),
+  dryRun: z64.boolean().optional()
+};
 
 // src/mcp/tools/research-discover.ts
 import { z as z65 } from "zod";
@@ -37593,7 +37614,7 @@ function createResearchDiscoverHandler(deps) {
     const response = await withToolError("Discovery failed", logger56, async () => {
       const result = await executeDiscovery(validationResult.data, logger56);
       recordDiscoverySuccess(result.topic, result.newItems, result.sourcesQueried);
-      return toolSuccess(JSON.stringify(result, null, 2));
+      return toolSuccessStructured(result);
     });
     const durationMs = Date.now() - startMs;
     if (response.isError === true) {
@@ -37638,11 +37659,21 @@ function registerResearchDiscoverTool(server, deps) {
   });
   server.registerTool(
     "research_discover",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema: RESEARCH_DISCOVER_OUTPUT_SCHEMA },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered research_discover tool with secure handler and timeout protection");
 }
+var RESEARCH_DISCOVER_OUTPUT_SCHEMA = {
+  topic: z65.string().optional(),
+  sourcesQueried: z65.array(z65.string()).optional(),
+  failedSources: z65.array(z65.string()).optional(),
+  items: z65.array(z65.unknown()).optional(),
+  totalFound: z65.number().optional(),
+  alreadyInRegistry: z65.number().optional(),
+  newItems: z65.number().optional(),
+  filteredByRelevance: z65.number().optional()
+};
 
 // src/mcp/tools/research-analyze.ts
 import { z as z66 } from "zod";
@@ -37885,7 +37916,7 @@ function createResearchAnalyzeHandler(deps) {
     const logger56 = deps.logger ?? createLogger({ tool: "research_analyze" });
     return withToolError("Analysis failed", logger56, async () => {
       const result = await executeAnalysis(validationResult.data);
-      return toolSuccess(JSON.stringify(result, null, 2));
+      return toolSuccessStructured(result);
     });
   };
 }
@@ -37906,9 +37937,15 @@ function registerResearchAnalyzeTool(server, deps) {
     timeoutMs,
     logger: logger56
   });
+  const outputSchema = {
+    focus: z66.string().optional(),
+    success: z66.boolean().optional(),
+    analysis: z66.unknown().optional(),
+    recommendations: z66.array(z66.string()).optional()
+  };
   server.registerTool(
     "research_analyze",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered research_analyze tool with secure handler and timeout protection");
@@ -38044,7 +38081,7 @@ function createCatalogReviewHandler(deps) {
       if (!result.success) {
         return toolError(result.message);
       }
-      return toolSuccess(JSON.stringify(result, null, 2));
+      return toolSuccessStructured(result);
     });
   };
 }
@@ -38067,9 +38104,15 @@ function registerResearchCatalogReviewTool(server, deps) {
     timeoutMs,
     logger: logger56
   });
+  const outputSchema = {
+    action: z67.string().optional(),
+    success: z67.boolean().optional(),
+    message: z67.string().optional(),
+    data: z67.unknown().optional()
+  };
   server.registerTool(
     "research_catalog_review",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered research_catalog_review tool");
@@ -38092,7 +38135,7 @@ function createResearchSynthesizeHandler(deps) {
       if (!result.ok) {
         return toolError(`Synthesis failed: ${result.error.message}`);
       }
-      return toolSuccess(JSON.stringify(result.value, null, 2));
+      return toolSuccessStructured(result.value);
     });
   };
 }
@@ -38112,9 +38155,15 @@ function registerResearchSynthesizeTool(server, deps) {
     timeoutMs,
     logger: logger56
   });
+  const outputSchema = {
+    clusters: z68.array(z68.unknown()).optional(),
+    alignmentSummary: z68.unknown().optional(),
+    crossCuttingThemes: z68.array(z68.unknown()).optional(),
+    generatedAt: z68.string().optional()
+  };
   server.registerTool(
     "research_synthesize",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered research_synthesize tool");
@@ -39272,7 +39321,7 @@ async function memoryQueryHandler(args, ctx) {
   }
   return withToolError("Memory query failed", ctx.logger, async () => {
     const result = await executeMemoryQuery(validationResult.data, ctx.logger);
-    return toolSuccess(JSON.stringify(result, null, 2));
+    return toolSuccessStructured(result);
   });
 }
 function registerMemoryQueryTool(server, deps) {
@@ -39290,9 +39339,16 @@ function registerMemoryQueryTool(server, deps) {
   });
   const timeoutMs = getToolTimeout("memory_query", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger56 });
+  const outputSchema = {
+    query: z72.string(),
+    expandedQuery: z72.string().optional(),
+    results: z72.array(z72.unknown()),
+    count: z72.number(),
+    source: z72.string()
+  };
   server.registerTool(
     "memory_query",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered memory_query tool");
@@ -39358,7 +39414,7 @@ async function memoryStatsHandler(args, ctx) {
   }
   return withToolError("Memory stats failed", ctx.logger, async () => {
     const result = await collectMemoryStats(validationResult.data, ctx.logger);
-    return toolSuccess(JSON.stringify(result, null, 2));
+    return toolSuccessStructured(result);
   });
 }
 function registerMemoryStatsTool(server, deps) {
@@ -39374,9 +39430,18 @@ function registerMemoryStatsTool(server, deps) {
   });
   const timeoutMs = getToolTimeout("memory_stats", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger56 });
+  const outputSchema = {
+    backends: z73.unknown(),
+    session: z73.unknown().optional(),
+    belief: z73.unknown().optional(),
+    typed: z73.unknown().optional(),
+    mobimem: z73.unknown().optional(),
+    decay: z73.unknown().optional(),
+    collectedAt: z73.string().optional()
+  };
   server.registerTool(
     "memory_stats",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered memory_stats tool");
@@ -39501,7 +39566,7 @@ async function memoryWriteHandler(args, ctx) {
     if (!result.success) {
       return toolError(JSON.stringify(result, null, 2));
     }
-    return toolSuccess(JSON.stringify(result, null, 2));
+    return toolSuccessStructured(result);
   });
 }
 function registerMemoryWriteTool(server, deps) {
@@ -39523,9 +39588,16 @@ function registerMemoryWriteTool(server, deps) {
   });
   const timeoutMs = getToolTimeout("memory_write", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_write", secureHandler, { timeoutMs, logger: logger56 });
+  const outputSchema = {
+    success: z74.boolean(),
+    backend: z74.string(),
+    key: z74.string(),
+    deduplicated: z74.boolean().optional(),
+    error: z74.string().optional()
+  };
   server.registerTool(
     "memory_write",
-    { description, inputSchema: toolSchema },
+    { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
   logger56.info("Registered memory_write tool");
@@ -43747,22 +43819,26 @@ function buildOutput2(result) {
     rateLimitHint: result.error?.toLowerCase().includes("rate limit") === true ? "Consider using quickMode or increasing delay between pipeline runs" : void 0
   };
 }
-function resolveTask(task, specFile) {
+async function resolveTask(task, specFile) {
   if (specFile === void 0) return task;
   const resolved = path11.resolve(specFile);
   const cwdRoot = path11.resolve(".");
   if (!resolved.startsWith(cwdRoot)) {
     throw new Error(`Path traversal denied: specFile must be within ${cwdRoot}`);
   }
-  if (!fs12.existsSync(resolved)) {
-    throw new Error(`Spec file not found: ${resolved}`);
-  }
-  const specContent = fs12.readFileSync(resolved, "utf-8");
-  return `${specContent}
+  try {
+    const specContent = await fs12.promises.readFile(resolved, "utf-8");
+    return `${specContent}
 
 ---
 
 ${task}`;
+  } catch (err2) {
+    if (err2.code === "ENOENT") {
+      throw new Error(`Spec file not found: ${resolved}`);
+    }
+    throw err2;
+  }
 }
 function selectStageRegistry(template, task, agentStages) {
   const effectiveTemplate = template ?? classifyTask(task).pipelineType;
@@ -43785,7 +43861,7 @@ function registerPipelineTool(server, _deps) {
         warnIfSimulatedOutsideTests("run_pipeline", createLogger({ tool: "run_pipeline" }));
       }
       try {
-        const task = resolveTask(input.task, input.specFile);
+        const task = await resolveTask(input.task, input.specFile);
         const agentStages = createAgentStages({
           simulateVotes: input.simulateVotes,
           votingStrategy: input.votingStrategy,
@@ -53703,4 +53779,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-LQPW7LIC.js.map
+//# sourceMappingURL=chunk-CUGQAPGY.js.map