@dexto/core 1.2.3 → 1.2.5

package/dist/tools/internal-tools/implementations/delegate-to-url-tool.d.ts

@@ -0,0 +1,33 @@
+import { InternalTool } from '../../types.js';
+/**
+ * Internal tool for agent-to-agent delegation
+ *
+ * Delegates tasks to other A2A-compliant agents at known URLs.
+ * Supports stateful multi-turn conversations via sessionId parameter.
+ *
+ * Features:
+ * - A2A Protocol v0.3.0 compliant (JSON-RPC 2.0 transport)
+ * - Stateful conversations with session management
+ * - Automatic endpoint discovery (/v1/jsonrpc, /jsonrpc)
+ * - Configurable timeouts and error handling
+ *
+ * @example
+ * ```typescript
+ * // Single delegation
+ * delegate_to_url({
+ *   url: "http://pdf-analyzer:3001",
+ *   message: "Extract all tables from the Q4 sales report"
+ * })
+ * → Returns: {sessionId: "delegation-xyz", response: "..."}
+ *
+ * // Multi-turn conversation (use same sessionId)
+ * delegate_to_url({
+ *   url: "http://pdf-analyzer:3001",
+ *   message: "Which table had the highest values?",
+ *   sessionId: "delegation-xyz"
+ * })
+ * → Agent remembers the previous extraction and can answer specifically
+ * ```
+ */
+export declare function createDelegateToUrlTool(): InternalTool;
+//# sourceMappingURL=delegate-to-url-tool.d.ts.map

package/dist/tools/internal-tools/implementations/delegate-to-url-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-to-url-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/delegate-to-url-tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AA8MpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,uBAAuB,IAAI,YAAY,CA8CtD"}

package/dist/tools/internal-tools/implementations/delegate-to-url-tool.js

@@ -0,0 +1,169 @@
+import "../../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "../../../errors/index.js";
+const DelegateToUrlInputSchema = z.object({
+  url: z.string().url().describe(
+    'The A2A-compliant agent URL (e.g., "http://localhost:3001" or "https://agent.example.com"). The tool will automatically append the correct JSON-RPC endpoint.'
+  ),
+  message: z.string().min(1).describe(
+    "The message or task to delegate to the agent. This will be sent as natural language input."
+  ),
+  sessionId: z.string().optional().describe(
+    "Optional session ID for maintaining conversation state across multiple delegations to the same agent"
+  ),
+  timeout: z.number().optional().default(3e4).describe("Request timeout in milliseconds (default: 30000)")
+}).strict();
+class SimpleA2AClient {
+  url;
+  timeout;
+  constructor(url, timeout = 3e4) {
+    this.url = url.replace(/\/$/, "");
+    this.timeout = timeout;
+  }
+  /**
+   * Send a message to the A2A agent using JSON-RPC 2.0
+   */
+  async sendMessage(message, sessionId) {
+    const messageId = this.generateId();
+    const taskId = sessionId || this.generateId();
+    const a2aMessage = {
+      role: "user",
+      parts: [
+        {
+          kind: "text",
+          text: message
+        }
+      ],
+      messageId,
+      taskId,
+      contextId: taskId,
+      kind: "message"
+    };
+    const rpcRequest = {
+      jsonrpc: "2.0",
+      id: this.generateId(),
+      method: "message/send",
+      params: {
+        message: a2aMessage,
+        configuration: {
+          blocking: true
+          // Wait for completion
+        }
+      }
+    };
+    const endpoints = [
+      `${this.url}/v1/jsonrpc`,
+      // A2A v0.3.0 JSON-RPC endpoint
+      `${this.url}/jsonrpc`
+      // Alternative path
+    ];
+    let lastError = null;
+    for (const endpoint of endpoints) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "@dexto/core"
+          },
+          body: JSON.stringify(rpcRequest),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          lastError = new Error(
+            `HTTP ${response.status}: ${response.statusText} (tried ${endpoint})`
+          );
+          continue;
+        }
+        const data = await response.json();
+        if ("error" in data && data.error) {
+          throw new Error(
+            `Agent returned error: ${data.error.message || "Unknown error"}`
+          );
+        }
+        if ("result" in data) {
+          return this.extractTaskResponse(data.result);
+        }
+        return data;
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new DextoRuntimeError(
+            `Delegation timeout after ${this.timeout}ms`,
+            ErrorScope.TOOLS,
+            ErrorType.TIMEOUT,
+            "DELEGATION_TIMEOUT"
+          );
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+    throw new DextoRuntimeError(
+      `Failed to connect to agent at ${this.url}. Tried endpoints: ${endpoints.join(", ")}. Last error: ${lastError?.message || "Unknown error"}`,
+      ErrorScope.TOOLS,
+      ErrorType.THIRD_PARTY,
+      "DELEGATION_FAILED"
+    );
+  }
+  /**
+   * Extract response text from A2A Task structure
+   */
+  extractTaskResponse(task) {
+    if (task.history && Array.isArray(task.history)) {
+      const agentMessages = task.history.filter((m) => m.role === "agent");
+      if (agentMessages.length > 0) {
+        const lastMessage = agentMessages[agentMessages.length - 1];
+        if (lastMessage.parts && Array.isArray(lastMessage.parts)) {
+          const textParts = lastMessage.parts.filter((p) => p.kind === "text").map((p) => p.text);
+          if (textParts.length > 0) {
+            return textParts.join("\n");
+          }
+        }
+      }
+    }
+    return JSON.stringify(task, null, 2);
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+}
+function createDelegateToUrlTool() {
+  return {
+    id: "delegate_to_url",
+    description: 'Delegate a task to another A2A-compliant agent at a specific URL. Supports STATEFUL multi-turn conversations via sessionId parameter. USAGE: (1) First delegation: provide url + message. Tool returns a response AND a sessionId. (2) Follow-up: use the SAME sessionId to continue the conversation with that agent. The agent remembers previous context. EXAMPLE: First call {url: "http://agent:3001", message: "Analyze data X"} returns {sessionId: "xyz", response: "..."}. Second call {url: "http://agent:3001", message: "What was the top insight?", sessionId: "xyz"}. The agent will remember the first analysis and can answer specifically.',
+    inputSchema: DelegateToUrlInputSchema,
+    execute: async (input, _context) => {
+      const { url, message, sessionId, timeout } = input;
+      try {
+        const client = new SimpleA2AClient(url, timeout);
+        const effectiveSessionId = sessionId || `delegation-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const response = await client.sendMessage(message, effectiveSessionId);
+        return {
+          success: true,
+          agentUrl: url,
+          sessionId: effectiveSessionId,
+          response,
+          _hint: sessionId ? "Continued existing conversation" : "Started new conversation - use this sessionId for follow-ups"
+        };
+      } catch (error) {
+        if (error instanceof DextoRuntimeError) {
+          throw error;
+        }
+        throw new DextoRuntimeError(
+          `Delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+          ErrorScope.TOOLS,
+          ErrorType.SYSTEM,
+          "DELEGATION_ERROR"
+        );
+      }
+    }
+  };
+}
+export {
+  createDelegateToUrlTool
+};

package/dist/tools/internal-tools/provider.cjs

@@ -21,7 +21,6 @@ __export(provider_exports, {
   InternalToolsProvider: () => InternalToolsProvider
 });
 module.exports = __toCommonJS(provider_exports);
-var import_logger = require("../../logger/index.js");
 var import_errors = require("../errors.js");
 var import_schema = require("../../utils/schema.js");
 var import_registry = require("./registry.js");
@@ -31,27 +30,29 @@ class InternalToolsProvider {
   // ← Store original InternalTool
   approvalManager;
   config;
-  constructor(services, approvalManager, config = []) {
+  logger;
+  constructor(services, approvalManager, config = [], logger) {
     this.services = services;
     this.approvalManager = approvalManager;
     this.config = config;
-    import_logger.logger.debug("InternalToolsProvider initialized with config:", config);
+    this.logger = logger;
+    this.logger.debug("InternalToolsProvider initialized with config:", { config });
   }
   /**
    * Initialize the internal tools provider by registering all available internal tools
    */
   async initialize() {
-    import_logger.logger.info("Initializing InternalToolsProvider...");
+    this.logger.info("Initializing InternalToolsProvider...");
     try {
       if (this.config.length === 0) {
-        import_logger.logger.info("No internal tools enabled by configuration");
+        this.logger.info("No internal tools enabled by configuration");
         return;
       }
       this.registerInternalTools();
       const toolCount = this.tools.size;
-      import_logger.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+      this.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to initialize InternalToolsProvider: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -71,7 +72,7 @@ class InternalToolsProvider {
         (serviceKey) => !servicesWithApproval[serviceKey]
       );
       if (missingServices.length > 0) {
-        import_logger.logger.debug(
+        this.logger.debug(
           `Skipping ${toolName} internal tool - missing services: ${missingServices.join(", ")}`
         );
         continue;
@@ -79,9 +80,9 @@ class InternalToolsProvider {
       try {
         const tool = toolInfo.factory(servicesWithApproval);
         this.tools.set(toolName, tool);
-        import_logger.logger.debug(`Registered ${toolName} internal tool`);
+        this.logger.debug(`Registered ${toolName} internal tool`);
       } catch (error) {
-        import_logger.logger.error(
+        this.logger.error(
           `Failed to register ${toolName} internal tool: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -99,15 +100,16 @@ class InternalToolsProvider {
   async executeTool(toolName, args, sessionId) {
     const tool = this.tools.get(toolName);
     if (!tool) {
-      import_logger.logger.error(`\u274C No internal tool found: ${toolName}`);
-      import_logger.logger.debug(`Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`);
+      this.logger.error(`\u274C No internal tool found: ${toolName}`);
+      this.logger.debug(
+        `Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`
+      );
       throw import_errors.ToolError.notFound(toolName);
     }
     const validationResult = tool.inputSchema.safeParse(args);
     if (!validationResult.success) {
-      import_logger.logger.error(
-        `\u274C Invalid arguments for tool ${toolName}:`,
-        validationResult.error.message
+      this.logger.error(
+        `\u274C Invalid arguments for tool ${toolName}: ${validationResult.error.message}`
       );
       throw import_errors.ToolError.invalidName(
         toolName,
@@ -119,7 +121,9 @@ class InternalToolsProvider {
       const result = await tool.execute(validationResult.data, context);
       return result;
     } catch (error) {
-      import_logger.logger.error(`\u274C Internal tool execution failed: ${toolName}`, error);
+      this.logger.error(`\u274C Internal tool execution failed: ${toolName}`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
       throw error;
     }
   }
@@ -132,7 +136,7 @@ class InternalToolsProvider {
       toolSet[name] = {
         name: tool.id,
         description: tool.description,
-        parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema)
+        parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema, this.logger)
         // ← Convert on-demand
       };
     }

package/dist/tools/internal-tools/provider.d.ts

@@ -1,4 +1,5 @@
 import { ToolSet } from '../types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 import { InternalToolsServices } from './registry.js';
 import type { InternalToolsConfig } from '../schemas.js';
 import type { ApprovalManager } from '../../approval/manager.js';
@@ -19,7 +20,8 @@ export declare class InternalToolsProvider {
     private tools;
     private approvalManager;
     private config;
-    constructor(services: InternalToolsServices, approvalManager: ApprovalManager, config?: InternalToolsConfig);
+    private logger;
+    constructor(services: InternalToolsServices, approvalManager: ApprovalManager, config: InternalToolsConfig | undefined, logger: IDextoLogger);
     /**
      * Initialize the internal tools provider by registering all available internal tools
      */

package/dist/tools/internal-tools/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAgB,MAAM,aAAa,CAAC;AAI1E,OAAO,EAAE,qBAAqB,EAAuB,MAAM,eAAe,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAsB;gBAGhC,QAAQ,EAAE,qBAAqB,EAC/B,eAAe,EAAE,eAAe,EAChC,MAAM,GAAE,mBAAwB;IAQpC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAmC7B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,CAAC;IA+BnB;;OAEG;IACH,WAAW,IAAI,OAAO;IActB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;CAGzB"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAgB,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,qBAAqB,EAAuB,MAAM,eAAe,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,MAAM,CAAe;gBAGzB,QAAQ,EAAE,qBAAqB,EAC/B,eAAe,EAAE,eAAe,EAChC,MAAM,EAAE,mBAAmB,YAAK,EAChC,MAAM,EAAE,YAAY;IASxB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAmC7B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,CAAC;IAkCnB;;OAEG;IACH,WAAW,IAAI,OAAO;IActB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;CAGzB"}

package/dist/tools/internal-tools/provider.js

@@ -1,5 +1,4 @@
 import "../../chunk-C6A6W6XS.js";
-import { logger } from "../../logger/index.js";
 import { ToolError } from "../errors.js";
 import { convertZodSchemaToJsonSchema } from "../../utils/schema.js";
 import { getInternalToolInfo } from "./registry.js";
@@ -9,27 +8,29 @@ class InternalToolsProvider {
   // ← Store original InternalTool
   approvalManager;
   config;
-  constructor(services, approvalManager, config = []) {
+  logger;
+  constructor(services, approvalManager, config = [], logger) {
     this.services = services;
     this.approvalManager = approvalManager;
     this.config = config;
-    logger.debug("InternalToolsProvider initialized with config:", config);
+    this.logger = logger;
+    this.logger.debug("InternalToolsProvider initialized with config:", { config });
   }
   /**
    * Initialize the internal tools provider by registering all available internal tools
    */
   async initialize() {
-    logger.info("Initializing InternalToolsProvider...");
+    this.logger.info("Initializing InternalToolsProvider...");
     try {
       if (this.config.length === 0) {
-        logger.info("No internal tools enabled by configuration");
+        this.logger.info("No internal tools enabled by configuration");
         return;
       }
       this.registerInternalTools();
       const toolCount = this.tools.size;
-      logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+      this.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `Failed to initialize InternalToolsProvider: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -49,7 +50,7 @@ class InternalToolsProvider {
         (serviceKey) => !servicesWithApproval[serviceKey]
       );
       if (missingServices.length > 0) {
-        logger.debug(
+        this.logger.debug(
           `Skipping ${toolName} internal tool - missing services: ${missingServices.join(", ")}`
         );
         continue;
@@ -57,9 +58,9 @@ class InternalToolsProvider {
       try {
         const tool = toolInfo.factory(servicesWithApproval);
         this.tools.set(toolName, tool);
-        logger.debug(`Registered ${toolName} internal tool`);
+        this.logger.debug(`Registered ${toolName} internal tool`);
       } catch (error) {
-        logger.error(
+        this.logger.error(
           `Failed to register ${toolName} internal tool: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -77,15 +78,16 @@ class InternalToolsProvider {
   async executeTool(toolName, args, sessionId) {
     const tool = this.tools.get(toolName);
     if (!tool) {
-      logger.error(`\u274C No internal tool found: ${toolName}`);
-      logger.debug(`Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`);
+      this.logger.error(`\u274C No internal tool found: ${toolName}`);
+      this.logger.debug(
+        `Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`
+      );
       throw ToolError.notFound(toolName);
     }
     const validationResult = tool.inputSchema.safeParse(args);
     if (!validationResult.success) {
-      logger.error(
-        `\u274C Invalid arguments for tool ${toolName}:`,
-        validationResult.error.message
+      this.logger.error(
+        `\u274C Invalid arguments for tool ${toolName}: ${validationResult.error.message}`
       );
       throw ToolError.invalidName(
         toolName,
@@ -97,7 +99,9 @@ class InternalToolsProvider {
       const result = await tool.execute(validationResult.data, context);
       return result;
     } catch (error) {
-      logger.error(`\u274C Internal tool execution failed: ${toolName}`, error);
+      this.logger.error(`\u274C Internal tool execution failed: ${toolName}`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
       throw error;
     }
   }
@@ -110,7 +114,7 @@ class InternalToolsProvider {
       toolSet[name] = {
         name: tool.id,
         description: tool.description,
-        parameters: convertZodSchemaToJsonSchema(tool.inputSchema)
+        parameters: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
         // ← Convert on-demand
       };
     }

package/dist/tools/internal-tools/registry.cjs

@@ -32,6 +32,7 @@ var import_edit_file_tool = require("./implementations/edit-file-tool.js");
 var import_bash_exec_tool = require("./implementations/bash-exec-tool.js");
 var import_bash_output_tool = require("./implementations/bash-output-tool.js");
 var import_kill_process_tool = require("./implementations/kill-process-tool.js");
+var import_delegate_to_url_tool = require("./implementations/delegate-to-url-tool.js");
 const INTERNAL_TOOL_REGISTRY = {
   search_history: {
     factory: (services) => (0, import_search_history_tool.createSearchHistoryTool)(services.searchService),
@@ -72,6 +73,10 @@ const INTERNAL_TOOL_REGISTRY = {
   kill_process: {
     factory: (services) => (0, import_kill_process_tool.createKillProcessTool)(services.processService),
     requiredServices: ["processService"]
+  },
+  delegate_to_url: {
+    factory: (_services) => (0, import_delegate_to_url_tool.createDelegateToUrlTool)(),
+    requiredServices: []
   }
 };
 function getInternalToolInfo(toolName) {

package/dist/tools/internal-tools/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAWxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,cAAc,CAAC,EAAE,cAAc,CAAC;CAKnC;AAED;;GAEG;AACH,KAAK,mBAAmB,GAAG,CAAC,QAAQ,EAAE,qBAAqB,KAAK,YAAY,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACvC,iBAAiB,EACjB;IACI,OAAO,EAAE,mBAAmB,CAAC;IAC7B,gBAAgB,EAAE,SAAS,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAAC;CAC9D,CAmDJ,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB;aA1D9C,mBAAmB;sBACV,SAAS,CAAC,MAAM,qBAAqB,CAAC,EAAE;EA2DjE"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAYxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,cAAc,CAAC,EAAE,cAAc,CAAC;CAKnC;AAED;;GAEG;AACH,KAAK,mBAAmB,GAAG,CAAC,QAAQ,EAAE,qBAAqB,KAAK,YAAY,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACvC,iBAAiB,EACjB;IACI,OAAO,EAAE,mBAAmB,CAAC;IAC7B,gBAAgB,EAAE,SAAS,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAAC;CAC9D,CAuDJ,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB;aA9D9C,mBAAmB;sBACV,SAAS,CAAC,MAAM,qBAAqB,CAAC,EAAE;EA+DjE"}

package/dist/tools/internal-tools/registry.js

@@ -9,6 +9,7 @@ import { createEditFileTool } from "./implementations/edit-file-tool.js";
 import { createBashExecTool } from "./implementations/bash-exec-tool.js";
 import { createBashOutputTool } from "./implementations/bash-output-tool.js";
 import { createKillProcessTool } from "./implementations/kill-process-tool.js";
+import { createDelegateToUrlTool } from "./implementations/delegate-to-url-tool.js";
 const INTERNAL_TOOL_REGISTRY = {
   search_history: {
     factory: (services) => createSearchHistoryTool(services.searchService),
@@ -49,6 +50,10 @@ const INTERNAL_TOOL_REGISTRY = {
   kill_process: {
     factory: (services) => createKillProcessTool(services.processService),
     requiredServices: ["processService"]
+  },
+  delegate_to_url: {
+    factory: (_services) => createDelegateToUrlTool(),
+    requiredServices: []
   }
 };
 function getInternalToolInfo(toolName) {

package/dist/tools/schemas.cjs

@@ -21,6 +21,7 @@ __export(schemas_exports, {
   ALLOWED_TOOLS_STORAGE_TYPES: () => ALLOWED_TOOLS_STORAGE_TYPES,
   DEFAULT_ALLOWED_TOOLS_STORAGE: () => DEFAULT_ALLOWED_TOOLS_STORAGE,
   DEFAULT_TOOL_CONFIRMATION_MODE: () => DEFAULT_TOOL_CONFIRMATION_MODE,
+  ElicitationConfigSchema: () => ElicitationConfigSchema,
   InternalToolsSchema: () => InternalToolsSchema,
   TOOL_CONFIRMATION_MODES: () => TOOL_CONFIRMATION_MODES,
   ToolConfirmationConfigSchema: () => ToolConfirmationConfigSchema,
@@ -29,9 +30,9 @@ __export(schemas_exports, {
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
 var import_constants = require("./internal-tools/constants.js");
-const TOOL_CONFIRMATION_MODES = ["event-based", "auto-approve", "auto-deny"];
+const TOOL_CONFIRMATION_MODES = ["manual", "auto-approve", "auto-deny"];
 const ALLOWED_TOOLS_STORAGE_TYPES = ["memory", "storage"];
-const DEFAULT_TOOL_CONFIRMATION_MODE = "event-based";
+const DEFAULT_TOOL_CONFIRMATION_MODE = "auto-approve";
 const DEFAULT_ALLOWED_TOOLS_STORAGE = "storage";
 const InternalToolsSchema = import_zod.z.array(import_zod.z.enum(import_constants.INTERNAL_TOOL_NAMES).describe("Available internal tool names")).default([]).describe(
   `Array of internal tool names to enable. Empty array = disabled. Available tools: ${import_constants.INTERNAL_TOOL_NAMES.join(", ")}`
@@ -46,7 +47,7 @@ const ToolPoliciesSchema = import_zod.z.object({
 }).strict().default({ alwaysAllow: [], alwaysDeny: [] }).describe("Static tool policies for allow/deny lists");
 const ToolConfirmationConfigSchema = import_zod.z.object({
   mode: import_zod.z.enum(TOOL_CONFIRMATION_MODES).default(DEFAULT_TOOL_CONFIRMATION_MODE).describe(
-    "Tool confirmation mode: event-based (interactive), auto-approve (all tools), auto-deny (no tools)"
+    "Tool confirmation mode: manual (interactive), auto-approve (all tools), auto-deny (no tools)"
   ),
   timeout: import_zod.z.number().int().positive().default(12e4).describe(
     "Timeout for tool confirmation requests in milliseconds, defaults to 120000ms (2 mins)"
@@ -54,15 +55,26 @@ const ToolConfirmationConfigSchema = import_zod.z.object({
   allowedToolsStorage: import_zod.z.enum(ALLOWED_TOOLS_STORAGE_TYPES).default(DEFAULT_ALLOWED_TOOLS_STORAGE).describe(
     "Storage type for remembered tool approvals: memory (session-only) or storage (persistent)"
   ),
-  toolPolicies: ToolPoliciesSchema.optional().describe(
+  toolPolicies: ToolPoliciesSchema.describe(
     "Static tool policies for fine-grained allow/deny control. Deny list takes precedence over allow list."
   )
 }).strict().describe("Tool confirmation and approval configuration");
+const ElicitationConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true).describe(
+    "Enable elicitation support (ask_user tool and MCP server elicitations). When disabled, elicitation requests will be rejected."
+  ),
+  timeout: import_zod.z.number().int().positive().default(12e4).describe(
+    "Timeout for elicitation requests in milliseconds, defaults to 120000ms (2 mins)"
+  )
+}).strict().describe(
+  "Elicitation configuration for user input requests. Independent from tool confirmation mode, allowing auto-approve for tools while still supporting elicitation."
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALLOWED_TOOLS_STORAGE_TYPES,
   DEFAULT_ALLOWED_TOOLS_STORAGE,
   DEFAULT_TOOL_CONFIRMATION_MODE,
+  ElicitationConfigSchema,
   InternalToolsSchema,
   TOOL_CONFIRMATION_MODES,
   ToolConfirmationConfigSchema,

package/dist/tools/schemas.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
-export declare const TOOL_CONFIRMATION_MODES: readonly ["event-based", "auto-approve", "auto-deny"];
+export declare const TOOL_CONFIRMATION_MODES: readonly ["manual", "auto-approve", "auto-deny"];
 export type ToolConfirmationMode = (typeof TOOL_CONFIRMATION_MODES)[number];
 export declare const ALLOWED_TOOLS_STORAGE_TYPES: readonly ["memory", "storage"];
 export type AllowedToolsStorageType = (typeof ALLOWED_TOOLS_STORAGE_TYPES)[number];
 export declare const DEFAULT_TOOL_CONFIRMATION_MODE: ToolConfirmationMode;
 export declare const DEFAULT_ALLOWED_TOOLS_STORAGE: AllowedToolsStorageType;
-export declare const InternalToolsSchema: z.ZodDefault<z.ZodArray<z.ZodEnum<["search_history", "ask_user", "read_file", "glob_files", "grep_content", "write_file", "edit_file", "bash_exec", "bash_output", "kill_process"]>, "many">>;
+export declare const InternalToolsSchema: z.ZodDefault<z.ZodArray<z.ZodEnum<["search_history", "ask_user", "read_file", "glob_files", "grep_content", "write_file", "edit_file", "bash_exec", "bash_output", "kill_process", "delegate_to_url"]>, "many">>;
 export type InternalToolsConfig = z.output<typeof InternalToolsSchema>;
 export declare const ToolPoliciesSchema: z.ZodDefault<z.ZodObject<{
     alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -19,10 +19,10 @@ export declare const ToolPoliciesSchema: z.ZodDefault<z.ZodObject<{
 }>>;
 export type ToolPolicies = z.output<typeof ToolPoliciesSchema>;
 export declare const ToolConfirmationConfigSchema: z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<["event-based", "auto-approve", "auto-deny"]>>;
+    mode: z.ZodDefault<z.ZodEnum<["manual", "auto-approve", "auto-deny"]>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     allowedToolsStorage: z.ZodDefault<z.ZodEnum<["memory", "storage"]>>;
-    toolPolicies: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    toolPolicies: z.ZodDefault<z.ZodObject<{
         alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     }, "strict", z.ZodTypeAny, {
@@ -31,18 +31,18 @@ export declare const ToolConfirmationConfigSchema: z.ZodObject<{
     }, {
         alwaysAllow?: string[] | undefined;
         alwaysDeny?: string[] | undefined;
-    }>>>;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     timeout: number;
-    mode: "event-based" | "auto-approve" | "auto-deny";
+    mode: "manual" | "auto-approve" | "auto-deny";
     allowedToolsStorage: "storage" | "memory";
-    toolPolicies?: {
+    toolPolicies: {
         alwaysAllow: string[];
         alwaysDeny: string[];
-    } | undefined;
+    };
 }, {
     timeout?: number | undefined;
-    mode?: "event-based" | "auto-approve" | "auto-deny" | undefined;
+    mode?: "manual" | "auto-approve" | "auto-deny" | undefined;
     allowedToolsStorage?: "storage" | "memory" | undefined;
     toolPolicies?: {
         alwaysAllow?: string[] | undefined;
@@ -51,4 +51,16 @@ export declare const ToolConfirmationConfigSchema: z.ZodObject<{
 }>;
 export type ToolConfirmationConfig = z.input<typeof ToolConfirmationConfigSchema>;
 export type ValidatedToolConfirmationConfig = z.output<typeof ToolConfirmationConfigSchema>;
+export declare const ElicitationConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    timeout: number;
+    enabled: boolean;
+}, {
+    timeout?: number | undefined;
+    enabled?: boolean | undefined;
+}>;
+export type ElicitationConfig = z.input<typeof ElicitationConfigSchema>;
+export type ValidatedElicitationConfig = z.output<typeof ElicitationConfigSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/tools/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB,uDAAwD,CAAC;AAC7F,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5E,eAAO,MAAM,2BAA2B,gCAAiC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,eAAO,MAAM,8BAA8B,EAAE,oBAAoC,CAAC;AAClF,eAAO,MAAM,6BAA6B,EAAE,uBAAmC,CAAC;AAIhF,eAAO,MAAM,mBAAmB,+LAK3B,CAAC;AAEN,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,eAAO,MAAM,kBAAkB;;;;;;;;;GAiB2B,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BoB,CAAC;AAE9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB,kDAAmD,CAAC;AACxF,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5E,eAAO,MAAM,2BAA2B,gCAAiC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,eAAO,MAAM,8BAA8B,EAAE,oBAAqC,CAAC;AACnF,eAAO,MAAM,6BAA6B,EAAE,uBAAmC,CAAC;AAIhF,eAAO,MAAM,mBAAmB,kNAK3B,CAAC;AAEN,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,eAAO,MAAM,kBAAkB;;;;;;;;;GAiB2B,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BoB,CAAC;AAE9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAG5F,eAAO,MAAM,uBAAuB;;;;;;;;;EAoB/B,CAAC;AAEN,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}