@dexto/core 1.2.4 → 1.2.6

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"}

package/dist/tools/schemas.js

@@ -1,9 +1,9 @@
 import "../chunk-C6A6W6XS.js";
 import { z } from "zod";
 import { INTERNAL_TOOL_NAMES } from "./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 = z.array(z.enum(INTERNAL_TOOL_NAMES).describe("Available internal tool names")).default([]).describe(
   `Array of internal tool names to enable. Empty array = disabled. Available tools: ${INTERNAL_TOOL_NAMES.join(", ")}`
@@ -18,7 +18,7 @@ const ToolPoliciesSchema = z.object({
 }).strict().default({ alwaysAllow: [], alwaysDeny: [] }).describe("Static tool policies for allow/deny lists");
 const ToolConfirmationConfigSchema = z.object({
   mode: 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: z.number().int().positive().default(12e4).describe(
     "Timeout for tool confirmation requests in milliseconds, defaults to 120000ms (2 mins)"
@@ -26,14 +26,25 @@ const ToolConfirmationConfigSchema = z.object({
   allowedToolsStorage: 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 = z.object({
+  enabled: z.boolean().default(true).describe(
+    "Enable elicitation support (ask_user tool and MCP server elicitations). When disabled, elicitation requests will be rejected."
+  ),
+  timeout: 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."
+);
 export {
   ALLOWED_TOOLS_STORAGE_TYPES,
   DEFAULT_ALLOWED_TOOLS_STORAGE,
   DEFAULT_TOOL_CONFIRMATION_MODE,
+  ElicitationConfigSchema,
   InternalToolsSchema,
   TOOL_CONFIRMATION_MODES,
   ToolConfirmationConfigSchema,

package/dist/tools/tool-manager.cjs

@@ -68,8 +68,8 @@ __export(tool_manager_exports, {
 module.exports = __toCommonJS(tool_manager_exports);
 var import_provider = require("./internal-tools/provider.js");
 var import_errors = require("./errors.js");
-var import_logger = require("../logger/index.js");
-var import_types2 = require("../approval/types.js");
+var import_types2 = require("../logger/v2/types.js");
+var import_types3 = require("../approval/types.js");
 var import_decorators = require("../telemetry/decorators.js");
 var _ToolManager_decorators, _init;
 _ToolManager_decorators = [(0, import_decorators.InstrumentClass)({
@@ -99,22 +99,25 @@ let _ToolManager = class _ToolManager {
   // Tool caching for performance
   toolsCache = {};
   cacheValid = false;
-  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, options) {
+  logger;
+  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, options, logger) {
     this.mcpManager = mcpManager;
     this.approvalManager = approvalManager;
     this.allowedToolsProvider = allowedToolsProvider;
     this.approvalMode = approvalMode;
     this.agentEventBus = agentEventBus;
     this.toolPolicies = toolPolicies;
+    this.logger = logger.createChild(import_types2.DextoLogComponent.TOOLS);
     if (options?.internalToolsConfig && options.internalToolsConfig.length > 0) {
       this.internalToolsProvider = new import_provider.InternalToolsProvider(
         options.internalToolsServices || {},
         approvalManager,
-        options.internalToolsConfig
+        options.internalToolsConfig,
+        this.logger
       );
     }
     this.setupNotificationListeners();
-    import_logger.logger.debug("ToolManager initialized");
+    this.logger.debug("ToolManager initialized");
   }
   /**
    * Initialize the ToolManager and its components
@@ -123,7 +126,7 @@ let _ToolManager = class _ToolManager {
     if (this.internalToolsProvider) {
       await this.internalToolsProvider.initialize();
     }
-    import_logger.logger.debug("ToolManager initialization complete");
+    this.logger.debug("ToolManager initialization complete");
   }
   /**
    * Set plugin support services (called after construction to avoid circular dependencies)
@@ -132,7 +135,7 @@ let _ToolManager = class _ToolManager {
     this.pluginManager = pluginManager;
     this.sessionManager = sessionManager;
     this.stateManager = stateManager;
-    import_logger.logger.debug("Plugin support configured for ToolManager");
+    this.logger.debug("Plugin support configured for ToolManager");
   }
   /**
    * Invalidate the tools cache when tool sources change
@@ -145,14 +148,18 @@ let _ToolManager = class _ToolManager {
    * Set up listeners for MCP notifications to invalidate cache on changes
    */
   setupNotificationListeners() {
-    this.agentEventBus.on("dexto:mcpServerConnected", async (payload) => {
+    this.agentEventBus.on("mcp:server-connected", async (payload) => {
       if (payload.success) {
-        import_logger.logger.debug(`\u{1F504} MCP server connected, invalidating tool cache: ${payload.name}`);
+        this.logger.debug(
+          `\u{1F504} MCP server connected, invalidating tool cache: ${payload.name}`
+        );
         this.invalidateCache();
       }
     });
-    this.agentEventBus.on("dexto:mcpServerRemoved", async (payload) => {
-      import_logger.logger.debug(`\u{1F504} MCP server removed: ${payload.serverName}, invalidating tool cache`);
+    this.agentEventBus.on("mcp:server-removed", async (payload) => {
+      this.logger.debug(
+        `\u{1F504} MCP server removed: ${payload.serverName}, invalidating tool cache`
+      );
       this.invalidateCache();
     });
   }
@@ -187,7 +194,7 @@ let _ToolManager = class _ToolManager {
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to get MCP tools: ${error instanceof Error ? error.message : String(error)}`
       );
       mcpTools = {};
@@ -195,7 +202,7 @@ let _ToolManager = class _ToolManager {
     try {
       internalTools = this.internalToolsProvider?.getAllTools() || {};
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to get internal tools: ${error instanceof Error ? error.message : String(error)}`
       );
       internalTools = {};
@@ -219,7 +226,7 @@ let _ToolManager = class _ToolManager {
     const totalTools = Object.keys(allTools).length;
     const mcpCount = Object.keys(mcpTools).length;
     const internalCount = Object.keys(internalTools).length;
-    import_logger.logger.debug(
+    this.logger.debug(
       `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP \u2192 ${_ToolManager.MCP_TOOL_PREFIX}*, ${internalCount} internal \u2192 ${_ToolManager.INTERNAL_TOOL_PREFIX}*)`
     );
     return allTools;
@@ -242,11 +249,11 @@ let _ToolManager = class _ToolManager {
    * ALL tools must have source prefix - no exceptions
    */
   async executeTool(toolName, args, sessionId) {
-    import_logger.logger.debug(`\u{1F527} Tool execution requested: '${toolName}'`);
-    import_logger.logger.debug(`Tool args: ${JSON.stringify(args, null, 2)}`);
+    this.logger.debug(`\u{1F527} Tool execution requested: '${toolName}'`);
+    this.logger.debug(`Tool args: ${JSON.stringify(args, null, 2)}`);
     await this.handleToolApproval(toolName, args, sessionId);
-    import_logger.logger.debug(`\u2705 Tool execution approved: ${toolName}`);
-    import_logger.logger.info(
+    this.logger.debug(`\u2705 Tool execution approved: ${toolName}`);
+    this.logger.info(
       `\u{1F527} Tool execution started for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
     const startTime = Date.now();
@@ -272,15 +279,15 @@ let _ToolManager = class _ToolManager {
     try {
       let result;
       if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
-        import_logger.logger.debug(`\u{1F527} Detected MCP tool: '${toolName}'`);
+        this.logger.debug(`\u{1F527} Detected MCP tool: '${toolName}'`);
         const actualToolName = toolName.substring(_ToolManager.MCP_TOOL_PREFIX.length);
         if (actualToolName.length === 0) {
           throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
         }
-        import_logger.logger.debug(`\u{1F3AF} MCP routing: '${toolName}' -> '${actualToolName}'`);
+        this.logger.debug(`\u{1F3AF} MCP routing: '${toolName}' -> '${actualToolName}'`);
         result = await this.mcpManager.executeTool(actualToolName, args, sessionId);
       } else if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
-        import_logger.logger.debug(`\u{1F527} Detected internal tool: '${toolName}'`);
+        this.logger.debug(`\u{1F527} Detected internal tool: '${toolName}'`);
         const actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
         if (actualToolName.length === 0) {
           throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
@@ -288,24 +295,26 @@ let _ToolManager = class _ToolManager {
         if (!this.internalToolsProvider) {
           throw import_errors.ToolError.internalToolsNotInitialized(toolName);
         }
-        import_logger.logger.debug(`\u{1F3AF} Internal routing: '${toolName}' -> '${actualToolName}'`);
+        this.logger.debug(`\u{1F3AF} Internal routing: '${toolName}' -> '${actualToolName}'`);
         result = await this.internalToolsProvider.executeTool(
           actualToolName,
           args,
           sessionId
         );
       } else {
-        import_logger.logger.debug(`\u{1F527} Detected tool without proper prefix: '${toolName}'`);
+        this.logger.debug(`\u{1F527} Detected tool without proper prefix: '${toolName}'`);
         const stats = await this.getToolStats();
-        import_logger.logger.error(
+        this.logger.error(
           `\u274C Tool missing source prefix: '${toolName}' (expected '${_ToolManager.MCP_TOOL_PREFIX}*' or '${_ToolManager.INTERNAL_TOOL_PREFIX}*')`
         );
-        import_logger.logger.debug(`Available: ${stats.mcp} MCP tools, ${stats.internal} internal tools`);
+        this.logger.debug(
+          `Available: ${stats.mcp} MCP tools, ${stats.internal} internal tools`
+        );
         throw import_errors.ToolError.notFound(toolName);
       }
       const duration = Date.now() - startTime;
-      import_logger.logger.debug(`\u{1F3AF} Tool execution completed in ${duration}ms: '${toolName}'`);
-      import_logger.logger.info(
+      this.logger.debug(`\u{1F3AF} Tool execution completed in ${duration}ms: '${toolName}'`);
+      this.logger.info(
         `\u2705 Tool execution completed successfully for ${toolName} in ${duration}ms, sessionId: ${sessionId ?? "global"}`
       );
       if (this.pluginManager && this.sessionManager && this.stateManager) {
@@ -331,7 +340,7 @@ let _ToolManager = class _ToolManager {
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      import_logger.logger.error(
+      this.logger.error(
         `\u274C Tool execution failed for ${toolName} after ${duration}ms, sessionId: ${sessionId ?? "global"}: ${error instanceof Error ? error.message : String(error)}`
       );
       if (this.pluginManager && this.sessionManager && this.stateManager) {
@@ -375,7 +384,7 @@ let _ToolManager = class _ToolManager {
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to get MCP tools for stats: ${error instanceof Error ? error.message : String(error)}`
       );
       mcpTools = {};
@@ -383,7 +392,7 @@ let _ToolManager = class _ToolManager {
     try {
       internalTools = this.internalToolsProvider?.getAllTools() || {};
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Failed to get internal tools for stats: ${error instanceof Error ? error.message : String(error)}`
       );
       internalTools = {};
@@ -466,39 +475,39 @@ let _ToolManager = class _ToolManager {
   }
   /**
    * Handle tool approval/confirmation flow
-   * Checks allowed list, manages approval modes (event-based, auto-approve, auto-deny),
+   * Checks allowed list, manages approval modes (manual, auto-approve, auto-deny),
    * and handles remember choice logic
    */
   async handleToolApproval(toolName, args, sessionId) {
     if (this.isInAlwaysDenyList(toolName)) {
-      import_logger.logger.info(
+      this.logger.info(
         `Tool '${toolName}' is in static deny list \u2013 blocking execution (session: ${sessionId ?? "global"})`
       );
-      import_logger.logger.debug(`\u{1F6AB} Tool execution blocked by policy: ${toolName}`);
+      this.logger.debug(`\u{1F6AB} Tool execution blocked by policy: ${toolName}`);
       throw import_errors.ToolError.executionDenied(toolName, sessionId);
     }
     if (this.isInAlwaysAllowList(toolName)) {
-      import_logger.logger.info(
+      this.logger.info(
         `Tool '${toolName}' is in static allow list \u2013 skipping confirmation (session: ${sessionId ?? "global"})`
       );
       return;
     }
     const isAllowed = await this.allowedToolsProvider.isToolAllowed(toolName, sessionId);
     if (isAllowed) {
-      import_logger.logger.info(
+      this.logger.info(
         `Tool '${toolName}' already allowed for session '${sessionId ?? "global"}' \u2013 skipping confirmation.`
       );
       return;
     }
     if (this.approvalMode === "auto-approve") {
-      import_logger.logger.debug(`\u{1F7E2} Auto-approving tool execution: ${toolName}`);
+      this.logger.debug(`\u{1F7E2} Auto-approving tool execution: ${toolName}`);
       return;
     }
     if (this.approvalMode === "auto-deny") {
-      import_logger.logger.debug(`\u{1F6AB} Auto-denying tool execution: ${toolName}`);
+      this.logger.debug(`\u{1F6AB} Auto-denying tool execution: ${toolName}`);
       throw import_errors.ToolError.executionDenied(toolName, sessionId);
     }
-    import_logger.logger.info(
+    this.logger.info(
       `Tool confirmation requested for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
     try {
@@ -511,26 +520,34 @@ let _ToolManager = class _ToolManager {
       }
       const response = await this.approvalManager.requestToolConfirmation(requestData);
       const rememberChoice = response.data && "rememberChoice" in response.data ? response.data.rememberChoice : false;
-      if (response.status === import_types2.ApprovalStatus.APPROVED && rememberChoice) {
+      if (response.status === import_types3.ApprovalStatus.APPROVED && rememberChoice) {
         const allowSessionId = sessionId ?? response.sessionId;
         await this.allowedToolsProvider.allowTool(toolName, allowSessionId);
-        import_logger.logger.info(
+        this.logger.info(
           `Tool '${toolName}' added to allowed tools for session '${allowSessionId ?? "global"}' (remember choice selected)`
         );
       }
-      const approved = response.status === import_types2.ApprovalStatus.APPROVED;
+      const approved = response.status === import_types3.ApprovalStatus.APPROVED;
       if (!approved) {
-        import_logger.logger.info(
-          `Tool confirmation denied for ${toolName}, sessionId: ${sessionId ?? "global"}`
+        if (response.status === import_types3.ApprovalStatus.CANCELLED && response.reason === "timeout") {
+          this.logger.info(
+            `Tool confirmation timed out for ${toolName}, sessionId: ${sessionId ?? "global"}`
+          );
+          this.logger.debug(`\u23F1\uFE0F Tool execution timed out: ${toolName}`);
+          const timeoutMs = response.timeoutMs ?? 0;
+          throw import_errors.ToolError.executionTimeout(toolName, timeoutMs, sessionId);
+        }
+        this.logger.info(
+          `Tool confirmation denied for ${toolName}, sessionId: ${sessionId ?? "global"}, reason: ${response.reason ?? "unknown"}`
         );
-        import_logger.logger.debug(`\u{1F6AB} Tool execution denied: ${toolName}`);
+        this.logger.debug(`\u{1F6AB} Tool execution denied: ${toolName}`);
         throw import_errors.ToolError.executionDenied(toolName, sessionId);
       }
-      import_logger.logger.info(
+      this.logger.info(
         `Tool confirmation approved for ${toolName}, sessionId: ${sessionId ?? "global"}`
       );
     } catch (error) {
-      import_logger.logger.error(
+      this.logger.error(
         `Tool confirmation error for ${toolName}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -543,7 +560,7 @@ let _ToolManager = class _ToolManager {
   async refresh() {
     await this.mcpManager.refresh();
     this.invalidateCache();
-    import_logger.logger.debug("ToolManager refreshed (including MCP server capabilities)");
+    this.logger.debug("ToolManager refreshed (including MCP server capabilities)");
   }
   /**
    * Get list of pending confirmation requests