@dexto/core 1.3.0 → 1.5.0

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

@@ -1,34 +1,60 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { ToolError } from "../errors.js";
 import { convertZodSchemaToJsonSchema } from "../../utils/schema.js";
 import { getInternalToolInfo } from "./registry.js";
+import { customToolRegistry } from "../custom-tool-registry.js";
+import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
+import { ToolErrorCode } from "../error-codes.js";
 class InternalToolsProvider {
   services;
-  tools = /* @__PURE__ */ new Map();
-  // ← Store original InternalTool
-  approvalManager;
+  internalTools = /* @__PURE__ */ new Map();
+  // Built-in internal tools
+  customTools = /* @__PURE__ */ new Map();
+  // Custom tool provider tools
   config;
+  customToolConfigs;
   logger;
-  constructor(services, approvalManager, config = [], logger) {
+  agent;
+  // Set after construction to avoid circular dependency
+  constructor(services, config = [], customToolConfigs = [], logger) {
     this.services = services;
-    this.approvalManager = approvalManager;
     this.config = config;
+    this.customToolConfigs = customToolConfigs;
     this.logger = logger;
-    this.logger.debug("InternalToolsProvider initialized with config:", { config });
+    this.logger.debug("InternalToolsProvider initialized with config:", {
+      config,
+      customToolConfigs
+    });
+  }
+  /**
+   * Set agent reference after construction (avoids circular dependency)
+   * Must be called before initialize() if custom tools need agent access
+   */
+  setAgent(agent) {
+    this.agent = agent;
   }
   /**
    * Initialize the internal tools provider by registering all available internal tools
+   * and custom tools from the registry
    */
   async initialize() {
     this.logger.info("Initializing InternalToolsProvider...");
     try {
-      if (this.config.length === 0) {
+      if (this.config.length > 0) {
+        this.registerInternalTools();
+      } else {
         this.logger.info("No internal tools enabled by configuration");
-        return;
       }
-      this.registerInternalTools();
-      const toolCount = this.tools.size;
-      this.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+      if (this.customToolConfigs.length > 0) {
+        this.registerCustomTools();
+      } else {
+        this.logger.debug("No custom tool providers configured");
+      }
+      const internalCount = this.internalTools.size;
+      const customCount = this.customTools.size;
+      this.logger.info(
+        `InternalToolsProvider initialized with ${internalCount + customCount} tools (${internalCount} internal, ${customCount} custom)`
+      );
     } catch (error) {
       this.logger.error(
         `Failed to initialize InternalToolsProvider: ${error instanceof Error ? error.message : String(error)}`
@@ -40,14 +66,13 @@ class InternalToolsProvider {
    * Register all available internal tools based on available services and configuration
    */
   registerInternalTools() {
-    const servicesWithApproval = {
-      ...this.services,
-      approvalManager: this.approvalManager
+    const featureFlags = {
+      elicitation: this.services.approvalManager?.getConfig().elicitation.enabled ?? false
     };
     for (const toolName of this.config) {
       const toolInfo = getInternalToolInfo(toolName);
       const missingServices = toolInfo.requiredServices.filter(
-        (serviceKey) => !servicesWithApproval[serviceKey]
+        (serviceKey) => !this.services[serviceKey]
       );
       if (missingServices.length > 0) {
         this.logger.debug(
@@ -55,9 +80,19 @@ class InternalToolsProvider {
         );
         continue;
       }
+      const missingFeatures = (toolInfo.requiredFeatures ?? []).filter(
+        (feature) => !featureFlags[feature]
+      );
+      if (missingFeatures.length > 0) {
+        throw ToolError.featureDisabled(
+          toolName,
+          missingFeatures,
+          `Tool '${toolName}' requires features which are currently disabled: ${missingFeatures.join(", ")}. Either remove '${toolName}' from internalTools, or enable: ${missingFeatures.map((f) => `${f}.enabled: true`).join(", ")}`
+        );
+      }
       try {
-        const tool = toolInfo.factory(servicesWithApproval);
-        this.tools.set(toolName, tool);
+        const tool = toolInfo.factory(this.services);
+        this.internalTools.set(toolName, tool);
         this.logger.debug(`Registered ${toolName} internal tool`);
       } catch (error) {
         this.logger.error(
@@ -67,20 +102,89 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Check if a tool exists
+   * Register custom tools from the custom tool registry.
+   * Tools are stored by their original ID - prefixing is handled by ToolManager.
+   */
+  registerCustomTools() {
+    if (!this.agent) {
+      throw ToolError.configInvalid(
+        "Agent reference not set. Call setAgent() before initialize() when using custom tools."
+      );
+    }
+    const context = {
+      logger: this.logger,
+      agent: this.agent,
+      services: this.services
+      // Includes approvalManager for tools that need approval flows
+    };
+    for (const toolConfig of this.customToolConfigs) {
+      try {
+        const validatedConfig = customToolRegistry.validateConfig(toolConfig);
+        const provider = customToolRegistry.get(validatedConfig.type);
+        if (!provider) {
+          const availableTypes = customToolRegistry.getTypes();
+          throw ToolError.unknownCustomToolProvider(validatedConfig.type, availableTypes);
+        }
+        const tools = provider.create(validatedConfig, context);
+        for (const tool of tools) {
+          if (this.customTools.has(tool.id)) {
+            this.logger.warn(
+              `Custom tool '${tool.id}' conflicts with existing custom tool. Skipping.`
+            );
+            continue;
+          }
+          this.customTools.set(tool.id, tool);
+          this.logger.debug(
+            `Registered custom tool: ${tool.id} from provider '${provider.metadata?.displayName || validatedConfig.type}'`
+          );
+        }
+      } catch (error) {
+        if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.CUSTOM_TOOL_PROVIDER_UNKNOWN) {
+          throw error;
+        }
+        this.logger.error(
+          `Failed to register custom tool provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if a tool exists (checks both internal and custom tools)
    */
   hasTool(toolName) {
-    return this.tools.has(toolName);
+    return this.internalTools.has(toolName) || this.customTools.has(toolName);
+  }
+  /**
+   * Check if an internal tool exists
+   */
+  hasInternalTool(toolName) {
+    return this.internalTools.has(toolName);
+  }
+  /**
+   * Check if a custom tool exists
+   */
+  hasCustomTool(toolName) {
+    return this.customTools.has(toolName);
+  }
+  /**
+   * Get an internal tool by name
+   * Returns undefined if tool doesn't exist
+   */
+  getTool(toolName) {
+    return this.internalTools.get(toolName) || this.customTools.get(toolName);
   }
   /**
    * Execute an internal tool - confirmation is handled by ToolManager
    */
-  async executeTool(toolName, args, sessionId) {
-    const tool = this.tools.get(toolName);
+  async executeTool(toolName, args, sessionId, abortSignal) {
+    const tool = this.internalTools.get(toolName) || this.customTools.get(toolName);
     if (!tool) {
-      this.logger.error(`\u274C No internal tool found: ${toolName}`);
+      this.logger.error(`\u274C No tool found: ${toolName}`);
+      this.logger.debug(
+        `Available internal tools: ${Array.from(this.internalTools.keys()).join(", ")}`
+      );
       this.logger.debug(
-        `Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`
+        `Available custom tools: ${Array.from(this.customTools.keys()).join(", ")}`
       );
       throw ToolError.notFound(toolName);
     }
@@ -95,7 +199,10 @@ class InternalToolsProvider {
       );
     }
     try {
-      const context = { sessionId };
+      const context = {
+        sessionId,
+        abortSignal
+      };
       const result = await tool.execute(validationResult.data, context);
       return result;
     } catch (error) {
@@ -106,31 +213,68 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Get all tools in ToolSet format with on-demand JSON Schema conversion
+   * Get internal tools in ToolSet format (excludes custom tools)
    */
-  getAllTools() {
+  getInternalTools() {
     const toolSet = {};
-    for (const [name, tool] of this.tools) {
+    for (const [name, tool] of this.internalTools) {
       toolSet[name] = {
         name: tool.id,
         description: tool.description,
         parameters: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
-        // ← Convert on-demand
       };
     }
     return toolSet;
   }
   /**
-   * Get tool names
+   * Get custom tools in ToolSet format (excludes internal tools)
+   */
+  getCustomTools() {
+    const toolSet = {};
+    for (const [name, tool] of this.customTools) {
+      toolSet[name] = {
+        name: tool.id,
+        description: tool.description,
+        parameters: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
+      };
+    }
+    return toolSet;
+  }
+  /**
+   * Get internal tool names
+   */
+  getInternalToolNames() {
+    return Array.from(this.internalTools.keys());
+  }
+  /**
+   * Get custom tool names
+   */
+  getCustomToolNames() {
+    return Array.from(this.customTools.keys());
+  }
+  /**
+   * Get all tool names (internal + custom)
    */
   getToolNames() {
-    return Array.from(this.tools.keys());
+    return [...this.internalTools.keys(), ...this.customTools.keys()];
   }
   /**
    * Get tool count
    */
   getToolCount() {
-    return this.tools.size;
+    return this.internalTools.size + this.customTools.size;
+  }
+  /**
+   * Get internal tool count
+   */
+  getInternalToolCount() {
+    return this.internalTools.size;
+  }
+  /**
+   * Get custom tool count
+   */
+  getCustomToolCount() {
+    return this.customTools.size;
   }
 }
 export {

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

@@ -24,59 +24,35 @@ __export(registry_exports, {
 module.exports = __toCommonJS(registry_exports);
 var import_search_history_tool = require("./implementations/search-history-tool.js");
 var import_ask_user_tool = require("./implementations/ask-user-tool.js");
-var import_read_file_tool = require("./implementations/read-file-tool.js");
-var import_glob_files_tool = require("./implementations/glob-files-tool.js");
-var import_grep_content_tool = require("./implementations/grep-content-tool.js");
-var import_write_file_tool = require("./implementations/write-file-tool.js");
-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");
+var import_list_resources_tool = require("./implementations/list-resources-tool.js");
+var import_get_resource_tool = require("./implementations/get-resource-tool.js");
 const INTERNAL_TOOL_REGISTRY = {
   search_history: {
     factory: (services) => (0, import_search_history_tool.createSearchHistoryTool)(services.searchService),
-    requiredServices: ["searchService"]
+    requiredServices: ["searchService"],
+    description: "Search through conversation history across sessions"
   },
   ask_user: {
     factory: (services) => (0, import_ask_user_tool.createAskUserTool)(services.approvalManager),
-    requiredServices: ["approvalManager"]
-  },
-  read_file: {
-    factory: (services) => (0, import_read_file_tool.createReadFileTool)(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  glob_files: {
-    factory: (services) => (0, import_glob_files_tool.createGlobFilesTool)(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  grep_content: {
-    factory: (services) => (0, import_grep_content_tool.createGrepContentTool)(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  write_file: {
-    factory: (services) => (0, import_write_file_tool.createWriteFileTool)(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  edit_file: {
-    factory: (services) => (0, import_edit_file_tool.createEditFileTool)(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  bash_exec: {
-    factory: (services) => (0, import_bash_exec_tool.createBashExecTool)(services.processService, services.approvalManager),
-    requiredServices: ["processService", "approvalManager"]
-  },
-  bash_output: {
-    factory: (services) => (0, import_bash_output_tool.createBashOutputTool)(services.processService),
-    requiredServices: ["processService"]
-  },
-  kill_process: {
-    factory: (services) => (0, import_kill_process_tool.createKillProcessTool)(services.processService),
-    requiredServices: ["processService"]
+    requiredServices: ["approvalManager"],
+    requiredFeatures: ["elicitation"],
+    description: "Collect structured input from the user through a form interface"
   },
   delegate_to_url: {
     factory: (_services) => (0, import_delegate_to_url_tool.createDelegateToUrlTool)(),
-    requiredServices: []
+    requiredServices: [],
+    description: "Delegate tasks to another A2A-compliant agent via URL"
+  },
+  list_resources: {
+    factory: (services) => (0, import_list_resources_tool.createListResourcesTool)(services.resourceManager),
+    requiredServices: ["resourceManager"],
+    description: "List available resources (images, files, etc.)"
+  },
+  get_resource: {
+    factory: (services) => (0, import_get_resource_tool.createGetResourceTool)(services.resourceManager),
+    requiredServices: ["resourceManager"],
+    description: "Access a stored resource to get URLs or metadata"
   }
 };
 function getInternalToolInfo(toolName) {

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

@@ -1,9 +1,27 @@
 import { InternalTool } from '../types.js';
 import { SearchService } from '../../search/index.js';
 import { ApprovalManager } from '../../approval/manager.js';
-import { FileSystemService } from '../../filesystem/index.js';
-import { ProcessService } from '../../process/index.js';
+import { ResourceManager } from '../../resources/manager.js';
 import type { KnownInternalTool } from './constants.js';
+/**
+ * Agent features that tools can depend on.
+ * Tools can declare required features via `requiredFeatures` in the registry.
+ * If a required feature is disabled, the tool will not be registered and agent startup will fail.
+ *
+ * To add new features:
+ * 1. Add the feature name to this union type (e.g., 'elicitation' | 'file_access' | 'network_access')
+ * 2. Add the feature flag derivation in provider.ts `registerInternalTools()`:
+ *    ```
+ *    const featureFlags: Record<AgentFeature, boolean> = {
+ *        elicitation: this.services.approvalManager?.getConfig().elicitation.enabled ?? false,
+ *        file_access: config.fileAccess?.enabled ?? false,  // example
+ *    };
+ *    ```
+ * 3. Add `requiredFeatures: ['feature_name'] as const` to tool entries that need it
+ *
+ * Tools can require multiple features - all must be enabled or startup fails with a clear error.
+ */
+export type AgentFeature = 'elicitation';
 /**
  * Services available to internal tools
  * Add new services here as needed for internal tools
@@ -11,26 +29,29 @@ import type { KnownInternalTool } from './constants.js';
 export interface InternalToolsServices {
     searchService?: SearchService;
     approvalManager?: ApprovalManager;
-    fileSystemService?: FileSystemService;
-    processService?: ProcessService;
+    resourceManager?: ResourceManager;
 }
 /**
  * Internal tool factory function type
  */
 type InternalToolFactory = (services: InternalToolsServices) => InternalTool;
 /**
- * Internal tool registry - Must match names array exactly (TypeScript enforces this)
+ * Internal tool registry entry type
  */
-export declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, {
+export interface InternalToolRegistryEntry {
     factory: InternalToolFactory;
     requiredServices: readonly (keyof InternalToolsServices)[];
-}>;
+    requiredFeatures?: readonly AgentFeature[];
+    /** Short description for discovery/UI purposes */
+    description: string;
+}
+/**
+ * Internal tool registry - Must match names array exactly (TypeScript enforces this)
+ */
+export declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, InternalToolRegistryEntry>;
 /**
  * Type-safe registry access
  */
-export declare function getInternalToolInfo(toolName: KnownInternalTool): {
-    factory: InternalToolFactory;
-    requiredServices: readonly (keyof InternalToolsServices)[];
-};
+export declare function getInternalToolInfo(toolName: KnownInternalTool): InternalToolRegistryEntry;
 export {};
 //# sourceMappingURL=registry.d.ts.map

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;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"}
+{"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,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAM7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACrC;AAED;;GAEG;AACH,KAAK,mBAAmB,GAAG,CAAC,QAAQ,EAAE,qBAAqB,KAAK,YAAY,CAAC;AAE7E;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,gBAAgB,EAAE,SAAS,CAAC,MAAM,qBAAqB,CAAC,EAAE,CAAC;IAC3D,gBAAgB,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,iBAAiB,EAAE,yBAAyB,CA8BvF,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,yBAAyB,CAE1F"}

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

@@ -1,59 +1,35 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { createSearchHistoryTool } from "./implementations/search-history-tool.js";
 import { createAskUserTool } from "./implementations/ask-user-tool.js";
-import { createReadFileTool } from "./implementations/read-file-tool.js";
-import { createGlobFilesTool } from "./implementations/glob-files-tool.js";
-import { createGrepContentTool } from "./implementations/grep-content-tool.js";
-import { createWriteFileTool } from "./implementations/write-file-tool.js";
-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";
+import { createListResourcesTool } from "./implementations/list-resources-tool.js";
+import { createGetResourceTool } from "./implementations/get-resource-tool.js";
 const INTERNAL_TOOL_REGISTRY = {
   search_history: {
     factory: (services) => createSearchHistoryTool(services.searchService),
-    requiredServices: ["searchService"]
+    requiredServices: ["searchService"],
+    description: "Search through conversation history across sessions"
   },
   ask_user: {
     factory: (services) => createAskUserTool(services.approvalManager),
-    requiredServices: ["approvalManager"]
-  },
-  read_file: {
-    factory: (services) => createReadFileTool(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  glob_files: {
-    factory: (services) => createGlobFilesTool(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  grep_content: {
-    factory: (services) => createGrepContentTool(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  write_file: {
-    factory: (services) => createWriteFileTool(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  edit_file: {
-    factory: (services) => createEditFileTool(services.fileSystemService),
-    requiredServices: ["fileSystemService"]
-  },
-  bash_exec: {
-    factory: (services) => createBashExecTool(services.processService, services.approvalManager),
-    requiredServices: ["processService", "approvalManager"]
-  },
-  bash_output: {
-    factory: (services) => createBashOutputTool(services.processService),
-    requiredServices: ["processService"]
-  },
-  kill_process: {
-    factory: (services) => createKillProcessTool(services.processService),
-    requiredServices: ["processService"]
+    requiredServices: ["approvalManager"],
+    requiredFeatures: ["elicitation"],
+    description: "Collect structured input from the user through a form interface"
   },
   delegate_to_url: {
     factory: (_services) => createDelegateToUrlTool(),
-    requiredServices: []
+    requiredServices: [],
+    description: "Delegate tasks to another A2A-compliant agent via URL"
+  },
+  list_resources: {
+    factory: (services) => createListResourcesTool(services.resourceManager),
+    requiredServices: ["resourceManager"],
+    description: "List available resources (images, files, etc.)"
+  },
+  get_resource: {
+    factory: (services) => createGetResourceTool(services.resourceManager),
+    requiredServices: ["resourceManager"],
+    description: "Access a stored resource to get URLs or metadata"
   }
 };
 function getInternalToolInfo(toolName) {

package/dist/tools/schemas.cjs

@@ -19,17 +19,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schemas_exports = {};
 __export(schemas_exports, {
   ALLOWED_TOOLS_STORAGE_TYPES: () => ALLOWED_TOOLS_STORAGE_TYPES,
+  CustomToolConfigSchema: () => CustomToolConfigSchema,
+  CustomToolConfigSchemaForOpenAPI: () => CustomToolConfigSchemaForOpenAPI,
+  CustomToolsSchema: () => CustomToolsSchema,
+  CustomToolsSchemaForOpenAPI: () => CustomToolsSchemaForOpenAPI,
   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,
-  ToolPoliciesSchema: () => ToolPoliciesSchema
+  ToolLimitsSchema: () => ToolLimitsSchema,
+  ToolPoliciesSchema: () => ToolPoliciesSchema,
+  ToolsConfigSchema: () => ToolsConfigSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
 var import_constants = require("./internal-tools/constants.js");
+var import_custom_tool_schema_registry = require("./custom-tool-schema-registry.js");
 const TOOL_CONFIRMATION_MODES = ["manual", "auto-approve", "auto-deny"];
 const ALLOWED_TOOLS_STORAGE_TYPES = ["memory", "storage"];
 const DEFAULT_TOOL_CONFIRMATION_MODE = "auto-approve";
@@ -37,6 +44,17 @@ 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(", ")}`
 );
+function getCustomToolConfigSchema() {
+  return import_custom_tool_schema_registry.customToolSchemaRegistry.createUnionSchema();
+}
+const CustomToolConfigSchema = import_zod.z.lazy(() => getCustomToolConfigSchema());
+const CustomToolConfigSchemaForOpenAPI = import_zod.z.object({
+  type: import_zod.z.string().describe("Tool provider type identifier")
+}).passthrough().describe("Custom tool provider configuration (generic representation for OpenAPI docs)");
+const CustomToolsSchema = import_zod.z.array(CustomToolConfigSchema).default([]).describe(
+  "Array of custom tool provider configurations. Providers are validated against registered schemas."
+);
+const CustomToolsSchemaForOpenAPI = import_zod.z.array(CustomToolConfigSchemaForOpenAPI).default([]).describe("Array of custom tool provider configurations");
 const ToolPoliciesSchema = import_zod.z.object({
   alwaysAllow: import_zod.z.array(import_zod.z.string()).default([]).describe(
     'Tools that never require approval (low-risk). Use full qualified names (e.g., "internal--ask_user", "mcp--filesystem--read_file")'
@@ -49,8 +67,8 @@ const ToolConfirmationConfigSchema = import_zod.z.object({
   mode: import_zod.z.enum(TOOL_CONFIRMATION_MODES).default(DEFAULT_TOOL_CONFIRMATION_MODE).describe(
     "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)"
+  timeout: import_zod.z.number().int().positive().optional().describe(
+    "Timeout for tool confirmation requests in milliseconds (optional - no timeout if not specified)"
   ),
   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)"
@@ -63,20 +81,32 @@ const ElicitationConfigSchema = import_zod.z.object({
   enabled: import_zod.z.boolean().default(false).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)"
+  timeout: import_zod.z.number().int().positive().optional().describe(
+    "Timeout for elicitation requests in milliseconds (optional - no timeout if not specified)"
   )
 }).strict().describe(
   "Elicitation configuration for user input requests. Independent from tool confirmation mode, allowing auto-approve for tools while still supporting elicitation."
 );
+const ToolLimitsSchema = import_zod.z.object({
+  maxOutputChars: import_zod.z.number().optional().describe("Maximum number of characters for tool output"),
+  maxLines: import_zod.z.number().optional().describe("Maximum number of lines for tool output"),
+  maxLineLength: import_zod.z.number().optional().describe("Maximum length of a single line")
+}).strict();
+const ToolsConfigSchema = import_zod.z.record(ToolLimitsSchema).describe("Per-tool configuration limits");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALLOWED_TOOLS_STORAGE_TYPES,
+  CustomToolConfigSchema,
+  CustomToolConfigSchemaForOpenAPI,
+  CustomToolsSchema,
+  CustomToolsSchemaForOpenAPI,
   DEFAULT_ALLOWED_TOOLS_STORAGE,
   DEFAULT_TOOL_CONFIRMATION_MODE,
   ElicitationConfigSchema,
   InternalToolsSchema,
   TOOL_CONFIRMATION_MODES,
   ToolConfirmationConfigSchema,
-  ToolPoliciesSchema
+  ToolLimitsSchema,
+  ToolPoliciesSchema,
+  ToolsConfigSchema
 });