@dexto/core 1.4.0 → 1.5.0

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

@@ -24,60 +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"],
-    requiredFeatures: ["elicitation"]
-  },
-  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),
-    requiredServices: ["processService"]
-  },
-  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"]
+    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,8 +1,7 @@
 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.
@@ -30,8 +29,7 @@ export type AgentFeature = 'elicitation';
 export interface InternalToolsServices {
     searchService?: SearchService;
     approvalManager?: ApprovalManager;
-    fileSystemService?: FileSystemService;
-    processService?: ProcessService;
+    resourceManager?: ResourceManager;
 }
 /**
  * Internal tool factory function type
@@ -44,6 +42,8 @@ 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)

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;;;;;;;;;;;;;;;;;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,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,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;CAC9C;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,iBAAiB,EAAE,yBAAyB,CAsDvF,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,yBAAyB,CAE1F"}
+{"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,60 +1,35 @@
 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"],
-    requiredFeatures: ["elicitation"]
-  },
-  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),
-    requiredServices: ["processService"]
-  },
-  bash_output: {
-    factory: (services) => createBashOutputTool(services.processService),
-    requiredServices: ["processService"]
-  },
-  kill_process: {
-    factory: (services) => createKillProcessTool(services.processService),
-    requiredServices: ["processService"]
+    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,6 +19,10 @@ 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,
@@ -32,6 +36,7 @@ __export(schemas_exports, {
 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";
@@ -39,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")'
@@ -80,6 +96,10 @@ const ToolsConfigSchema = import_zod.z.record(ToolLimitsSchema).describe("Per-to
 // 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,

package/dist/tools/schemas.d.ts

@@ -5,8 +5,50 @@ 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", "delegate_to_url"]>, "many">>;
+export declare const InternalToolsSchema: z.ZodDefault<z.ZodArray<z.ZodEnum<["search_history", "ask_user", "delegate_to_url", "list_resources", "get_resource"]>, "many">>;
 export type InternalToolsConfig = z.output<typeof InternalToolsSchema>;
+/**
+ * Custom tool configuration schema.
+ *
+ * This schema is built dynamically from registered providers:
+ * - If providers are registered → discriminated union with full validation
+ * - If no providers registered → passthrough schema (backward compatible)
+ *
+ * Provider-specific fields are validated based on their registered schemas.
+ */
+export declare const CustomToolConfigSchema: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
+export type CustomToolConfig = z.output<typeof CustomToolConfigSchema>;
+/**
+ * OpenAPI-safe version of CustomToolConfigSchema.
+ * Uses a generic object schema instead of lazy loading for OpenAPI compatibility.
+ */
+export declare const CustomToolConfigSchemaForOpenAPI: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Array of custom tool provider configurations.
+ *
+ * Custom tools must be registered via customToolRegistry before loading agent config
+ * for early validation to work. If providers are not registered, validation will
+ * fall back to runtime validation by the provider.
+ */
+export declare const CustomToolsSchema: z.ZodDefault<z.ZodArray<z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>, "many">>;
+export type CustomToolsConfig = z.output<typeof CustomToolsSchema>;
+/**
+ * OpenAPI-safe version of CustomToolsSchema.
+ * Uses generic object schema for OpenAPI compatibility.
+ */
+export declare const CustomToolsSchemaForOpenAPI: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>, "many">>;
 export declare const ToolPoliciesSchema: z.ZodDefault<z.ZodObject<{
     alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;

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,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;AAGlF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAShB,CAAC;AAEd,eAAO,MAAM,iBAAiB;;;;;;;;;;;;GAEgB,CAAC;AAE/C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,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,kIAK3B,CAAC;AAEN,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAkBvE;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,8CAA4C,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;;;;;gCAKgD,CAAC;AAE9F;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,gFAKzB,CAAC;AAEN,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;;0CAGqB,CAAC;AAG9D,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;AAGlF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAShB,CAAC;AAEd,eAAO,MAAM,iBAAiB;;;;;;;;;;;;GAEgB,CAAC;AAE/C,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/tools/schemas.js

@@ -1,6 +1,7 @@
 import "../chunk-PTJYTZNU.js";
 import { z } from "zod";
 import { INTERNAL_TOOL_NAMES } from "./internal-tools/constants.js";
+import { customToolSchemaRegistry } from "./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";
@@ -8,6 +9,17 @@ 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(", ")}`
 );
+function getCustomToolConfigSchema() {
+  return customToolSchemaRegistry.createUnionSchema();
+}
+const CustomToolConfigSchema = z.lazy(() => getCustomToolConfigSchema());
+const CustomToolConfigSchemaForOpenAPI = z.object({
+  type: z.string().describe("Tool provider type identifier")
+}).passthrough().describe("Custom tool provider configuration (generic representation for OpenAPI docs)");
+const CustomToolsSchema = z.array(CustomToolConfigSchema).default([]).describe(
+  "Array of custom tool provider configurations. Providers are validated against registered schemas."
+);
+const CustomToolsSchemaForOpenAPI = z.array(CustomToolConfigSchemaForOpenAPI).default([]).describe("Array of custom tool provider configurations");
 const ToolPoliciesSchema = z.object({
   alwaysAllow: z.array(z.string()).default([]).describe(
     'Tools that never require approval (low-risk). Use full qualified names (e.g., "internal--ask_user", "mcp--filesystem--read_file")'
@@ -48,6 +60,10 @@ const ToolLimitsSchema = z.object({
 const ToolsConfigSchema = z.record(ToolLimitsSchema).describe("Per-tool configuration limits");
 export {
   ALLOWED_TOOLS_STORAGE_TYPES,
+  CustomToolConfigSchema,
+  CustomToolConfigSchemaForOpenAPI,
+  CustomToolsSchema,
+  CustomToolsSchemaForOpenAPI,
   DEFAULT_ALLOWED_TOOLS_STORAGE,
   DEFAULT_TOOL_CONFIRMATION_MODE,
   ElicitationConfigSchema,

package/dist/tools/tool-manager.cjs

@@ -99,6 +99,7 @@ let _ToolManager = class _ToolManager {
   // Tool source prefixing - ALL tools get prefixed by source
   static MCP_TOOL_PREFIX = "mcp--";
   static INTERNAL_TOOL_PREFIX = "internal--";
+  static CUSTOM_TOOL_PREFIX = "custom--";
   // Tool caching for performance
   toolsCache = {};
   cacheValid = false;
@@ -111,14 +112,15 @@ let _ToolManager = class _ToolManager {
     this.agentEventBus = agentEventBus;
     this.toolPolicies = toolPolicies;
     this.logger = logger.createChild(import_types2.DextoLogComponent.TOOLS);
-    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0) {
+    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0 || options?.customToolsConfig && options.customToolsConfig.length > 0) {
       const internalToolsServices = {
         ...options.internalToolsServices,
         approvalManager
       };
       this.internalToolsProvider = new import_provider.InternalToolsProvider(
         internalToolsServices,
-        options.internalToolsConfig,
+        options.internalToolsConfig || [],
+        options.customToolsConfig || [],
         this.logger
       );
     }
@@ -143,6 +145,16 @@ let _ToolManager = class _ToolManager {
     this.stateManager = stateManager;
     this.logger.debug("Plugin support configured for ToolManager");
   }
+  /**
+   * Set agent reference for custom tools (called after construction to avoid circular dependencies)
+   * Must be called before initialize() if custom tools are configured
+   */
+  setAgent(agent) {
+    if (this.internalToolsProvider) {
+      this.internalToolsProvider.setAgent(agent);
+      this.logger.debug("Agent reference configured for custom tools");
+    }
+  }
   /**
    * Invalidate the tools cache when tool sources change
    */
@@ -174,7 +186,7 @@ let _ToolManager = class _ToolManager {
    * Check if a tool name represents a bash execution tool
    */
   isBashTool(toolName) {
-    return toolName === "bash_exec" || toolName === "internal--bash_exec";
+    return toolName === "bash_exec" || toolName === "internal--bash_exec" || toolName === "custom--bash_exec";
   }
   /**
    * Check if a bash command is covered by any approved pattern.
@@ -228,6 +240,7 @@ let _ToolManager = class _ToolManager {
     const allTools = {};
     let mcpTools = {};
     let internalTools = {};
+    let customTools = {};
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
@@ -237,13 +250,21 @@ let _ToolManager = class _ToolManager {
       mcpTools = {};
     }
     try {
-      internalTools = this.internalToolsProvider?.getAllTools() || {};
+      internalTools = this.internalToolsProvider?.getInternalTools() || {};
     } catch (error) {
       this.logger.error(
         `Failed to get internal tools: ${error instanceof Error ? error.message : String(error)}`
       );
       internalTools = {};
     }
+    try {
+      customTools = this.internalToolsProvider?.getCustomTools() || {};
+    } catch (error) {
+      this.logger.error(
+        `Failed to get custom tools: ${error instanceof Error ? error.message : String(error)}`
+      );
+      customTools = {};
+    }
     for (const [toolName, toolDef] of Object.entries(internalTools)) {
       const qualifiedName = `${_ToolManager.INTERNAL_TOOL_PREFIX}${toolName}`;
       allTools[qualifiedName] = {
@@ -252,6 +273,14 @@ let _ToolManager = class _ToolManager {
         description: `${toolDef.description || "No description provided"} (internal tool)`
       };
     }
+    for (const [toolName, toolDef] of Object.entries(customTools)) {
+      const qualifiedName = `${_ToolManager.CUSTOM_TOOL_PREFIX}${toolName}`;
+      allTools[qualifiedName] = {
+        ...toolDef,
+        name: qualifiedName,
+        description: `${toolDef.description || "No description provided"} (custom tool)`
+      };
+    }
     for (const [toolName, toolDef] of Object.entries(mcpTools)) {
       const qualifiedName = `${_ToolManager.MCP_TOOL_PREFIX}${toolName}`;
       allTools[qualifiedName] = {
@@ -263,8 +292,9 @@ let _ToolManager = class _ToolManager {
     const totalTools = Object.keys(allTools).length;
     const mcpCount = Object.keys(mcpTools).length;
     const internalCount = Object.keys(internalTools).length;
+    const customCount = Object.keys(customTools).length;
     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}*)`
+      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP, ${internalCount} internal, ${customCount} custom)`
     );
     return allTools;
   }
@@ -365,14 +395,30 @@ let _ToolManager = class _ToolManager {
           sessionId,
           abortSignal
         );
+      } else if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX)) {
+        this.logger.debug(`\u{1F527} Detected custom tool: '${toolName}'`);
+        const actualToolName = toolName.substring(_ToolManager.CUSTOM_TOOL_PREFIX.length);
+        if (actualToolName.length === 0) {
+          throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
+        }
+        if (!this.internalToolsProvider) {
+          throw import_errors.ToolError.internalToolsNotInitialized(toolName);
+        }
+        this.logger.debug(`\u{1F3AF} Custom routing: '${toolName}' -> '${actualToolName}'`);
+        result = await this.internalToolsProvider.executeTool(
+          actualToolName,
+          args,
+          sessionId,
+          abortSignal
+        );
       } else {
         this.logger.debug(`\u{1F527} Detected tool without proper prefix: '${toolName}'`);
         const stats = await this.getToolStats();
         this.logger.error(
-          `\u274C Tool missing source prefix: '${toolName}' (expected '${_ToolManager.MCP_TOOL_PREFIX}*' or '${_ToolManager.INTERNAL_TOOL_PREFIX}*')`
+          `\u274C Tool missing source prefix: '${toolName}' (expected '${_ToolManager.MCP_TOOL_PREFIX}*', '${_ToolManager.INTERNAL_TOOL_PREFIX}*', or '${_ToolManager.CUSTOM_TOOL_PREFIX}*')`
         );
         this.logger.debug(
-          `Available: ${stats.mcp} MCP tools, ${stats.internal} internal tools`
+          `Available: ${stats.mcp} MCP, ${stats.internal} internal, ${stats.custom} custom tools`
         );
         throw import_errors.ToolError.notFound(toolName);
       }
@@ -438,7 +484,11 @@ let _ToolManager = class _ToolManager {
     }
     if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
       const actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
-      return this.internalToolsProvider?.hasTool(actualToolName) ?? false;
+      return this.internalToolsProvider?.hasInternalTool(actualToolName) ?? false;
+    }
+    if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX)) {
+      const actualToolName = toolName.substring(_ToolManager.CUSTOM_TOOL_PREFIX.length);
+      return this.internalToolsProvider?.hasCustomTool(actualToolName) ?? false;
     }
     return false;
   }
@@ -448,6 +498,7 @@ let _ToolManager = class _ToolManager {
   async getToolStats() {
     let mcpTools = {};
     let internalTools = {};
+    let customTools = {};
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
@@ -457,24 +508,33 @@ let _ToolManager = class _ToolManager {
       mcpTools = {};
     }
     try {
-      internalTools = this.internalToolsProvider?.getAllTools() || {};
+      internalTools = this.internalToolsProvider?.getInternalTools() || {};
     } catch (error) {
       this.logger.error(
         `Failed to get internal tools for stats: ${error instanceof Error ? error.message : String(error)}`
       );
       internalTools = {};
     }
+    try {
+      customTools = this.internalToolsProvider?.getCustomTools() || {};
+    } catch (error) {
+      this.logger.error(
+        `Failed to get custom tools for stats: ${error instanceof Error ? error.message : String(error)}`
+      );
+      customTools = {};
+    }
     const mcpCount = Object.keys(mcpTools).length;
     const internalCount = Object.keys(internalTools).length;
+    const customCount = Object.keys(customTools).length;
     return {
-      total: mcpCount + internalCount,
-      // No conflicts with universal prefixing
+      total: mcpCount + internalCount + customCount,
       mcp: mcpCount,
-      internal: internalCount
+      internal: internalCount,
+      custom: customCount
     };
   }
   /**
-   * Get the source of a tool (mcp, internal, or unknown)
+   * Get the source of a tool (mcp, internal, custom, or unknown)
    * @param toolName The name of the tool to check
    * @returns The source of the tool
    */
@@ -485,6 +545,9 @@ let _ToolManager = class _ToolManager {
     if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX) && toolName.length > _ToolManager.INTERNAL_TOOL_PREFIX.length) {
       return "internal";
     }
+    if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX) && toolName.length > _ToolManager.CUSTOM_TOOL_PREFIX.length) {
+      return "custom";
+    }
     return "unknown";
   }
   /**
@@ -540,6 +603,62 @@ let _ToolManager = class _ToolManager {
       (pattern) => this.matchesToolPolicy(toolName, pattern)
     );
   }
+  /**
+   * Check if a tool has a custom approval override and handle it.
+   * Tools can implement getApprovalOverride() to request specialized approval flows
+   * (e.g., directory access approval for file tools) instead of default tool confirmation.
+   *
+   * @param toolName The fully qualified tool name
+   * @param args The tool arguments
+   * @param sessionId Optional session ID
+   * @returns { handled: true } if custom approval was processed, { handled: false } to continue normal flow
+   */
+  async checkCustomApprovalOverride(toolName, args, sessionId) {
+    let actualToolName;
+    if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
+      actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
+    } else if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX)) {
+      actualToolName = toolName.substring(_ToolManager.CUSTOM_TOOL_PREFIX.length);
+    }
+    if (!actualToolName || !this.internalToolsProvider) {
+      return { handled: false };
+    }
+    const tool = this.internalToolsProvider.getTool(actualToolName);
+    if (!tool?.getApprovalOverride) {
+      return { handled: false };
+    }
+    const approvalRequest = tool.getApprovalOverride(args);
+    if (!approvalRequest) {
+      return { handled: false };
+    }
+    this.logger.debug(
+      `Tool '${toolName}' requested custom approval: type=${approvalRequest.type}`
+    );
+    if (sessionId && !approvalRequest.sessionId) {
+      approvalRequest.sessionId = sessionId;
+    }
+    const response = await this.approvalManager.requestApproval(approvalRequest);
+    if (response.status === import_types3.ApprovalStatus.APPROVED) {
+      if (tool.onApprovalGranted) {
+        tool.onApprovalGranted(response);
+      }
+      this.logger.info(
+        `Custom approval granted for '${toolName}', type=${approvalRequest.type}, session=${sessionId ?? "global"}`
+      );
+      return { handled: true };
+    }
+    this.logger.info(
+      `Custom approval denied for '${toolName}', type=${approvalRequest.type}, reason=${response.reason ?? "unknown"}`
+    );
+    if (approvalRequest.type === "directory_access") {
+      const metadata = approvalRequest.metadata;
+      throw import_errors.ToolError.directoryAccessDenied(
+        metadata?.parentDir ?? "unknown directory",
+        sessionId
+      );
+    }
+    throw import_errors.ToolError.executionDenied(toolName, sessionId);
+  }
   /**
    * Handle tool approval/confirmation flow
    * Checks allowed list, manages approval modes (manual, auto-approve, auto-deny),
@@ -558,6 +677,14 @@ let _ToolManager = class _ToolManager {
       this.logger.debug(`\u{1F6AB} Tool execution blocked by policy: ${toolName}`);
       throw import_errors.ToolError.executionDenied(toolName, sessionId);
     }
+    const customApprovalResult = await this.checkCustomApprovalOverride(
+      toolName,
+      args,
+      sessionId
+    );
+    if (customApprovalResult.handled) {
+      return { requireApproval: true, approvalStatus: "approved" };
+    }
     if (this.isInAlwaysAllowList(toolName)) {
       this.logger.info(
         `Tool '${toolName}' is in static allow list \u2013 skipping confirmation (session: ${sessionId ?? "global"})`