@dexto/core 1.1.10 → 1.2.0

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

@@ -1,45 +1,36 @@
 import { InternalTool } from '../types.js';
-import { SearchService } from '../../search/search-service.js';
-import 'json-schema';
-import 'zod';
-import '../../storage/backend/database-backend.js';
-import '../../search/types.js';
-import '../../context/types.js';
-import '../../llm/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 type { KnownInternalTool } from './constants.js';
 /**
  * Services available to internal tools
  * Add new services here as needed for internal tools
  */
-interface InternalToolsServices {
+export interface InternalToolsServices {
     searchService?: SearchService;
+    approvalManager?: ApprovalManager;
+    fileSystemService?: FileSystemService;
+    processService?: ProcessService;
 }
 /**
  * Internal tool factory function type
  */
 type InternalToolFactory = (services: InternalToolsServices) => InternalTool;
-/**
- * Internal tool names - Manual array preserves literal types for z.enum()
- * Add new tool names here first, then implement in registry below
- */
-declare const INTERNAL_TOOL_NAMES: readonly ["search_history"];
-/**
- * Derive type from names array - preserves literal union
- */
-type KnownInternalTool = (typeof INTERNAL_TOOL_NAMES)[number];
 /**
  * Internal tool registry - Must match names array exactly (TypeScript enforces this)
  */
-declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, {
+export declare const INTERNAL_TOOL_REGISTRY: Record<KnownInternalTool, {
     factory: InternalToolFactory;
     requiredServices: readonly (keyof InternalToolsServices)[];
 }>;
 /**
  * Type-safe registry access
  */
-declare function getInternalToolInfo(toolName: KnownInternalTool): {
+export declare function getInternalToolInfo(toolName: KnownInternalTool): {
     factory: InternalToolFactory;
     requiredServices: readonly (keyof InternalToolsServices)[];
 };
-
-export { INTERNAL_TOOL_NAMES, INTERNAL_TOOL_REGISTRY, type InternalToolsServices, type KnownInternalTool, getInternalToolInfo };
+export {};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +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"}

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

@@ -1,17 +1,60 @@
+import "../../chunk-C6A6W6XS.js";
 import { createSearchHistoryTool } from "./implementations/search-history-tool.js";
-const INTERNAL_TOOL_NAMES = ["search_history"];
+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";
 const INTERNAL_TOOL_REGISTRY = {
   search_history: {
     factory: (services) => createSearchHistoryTool(services.searchService),
     requiredServices: ["searchService"]
+  },
+  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"]
   }
-  // Add new tools here - must match INTERNAL_TOOL_NAMES array above
 };
 function getInternalToolInfo(toolName) {
   return INTERNAL_TOOL_REGISTRY[toolName];
 }
 export {
-  INTERNAL_TOOL_NAMES,
   INTERNAL_TOOL_REGISTRY,
   getInternalToolInfo
 };

package/dist/tools/schemas.cjs

@@ -18,28 +18,53 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var schemas_exports = {};
 __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,
   InternalToolsSchema: () => InternalToolsSchema,
-  ToolConfirmationConfigSchema: () => ToolConfirmationConfigSchema
+  TOOL_CONFIRMATION_MODES: () => TOOL_CONFIRMATION_MODES,
+  ToolConfirmationConfigSchema: () => ToolConfirmationConfigSchema,
+  ToolPoliciesSchema: () => ToolPoliciesSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
-var import_registry = require("./internal-tools/registry.js");
-const InternalToolsSchema = import_zod.z.array(import_zod.z.enum(import_registry.INTERNAL_TOOL_NAMES).describe("Available internal tool names")).default([]).describe(
-  `Array of internal tool names to enable. Empty array = disabled. Available tools: ${import_registry.INTERNAL_TOOL_NAMES.join(", ")}`
+var import_constants = require("./internal-tools/constants.js");
+const TOOL_CONFIRMATION_MODES = ["event-based", "auto-approve", "auto-deny"];
+const ALLOWED_TOOLS_STORAGE_TYPES = ["memory", "storage"];
+const DEFAULT_TOOL_CONFIRMATION_MODE = "event-based";
+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(", ")}`
 );
+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")'
+  ),
+  alwaysDeny: import_zod.z.array(import_zod.z.string()).default([]).describe(
+    'Tools that are always denied (high-risk). Takes precedence over alwaysAllow. Use full qualified names (e.g., "mcp--filesystem--delete_file")'
+  )
+}).strict().default({ alwaysAllow: [], alwaysDeny: [] }).describe("Static tool policies for allow/deny lists");
 const ToolConfirmationConfigSchema = import_zod.z.object({
-  mode: import_zod.z.enum(["event-based", "auto-approve", "auto-deny"]).default("event-based").describe(
+  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)"
   ),
   timeout: import_zod.z.number().int().positive().default(12e4).describe(
     "Timeout for tool confirmation requests in milliseconds, defaults to 120000ms (2 mins)"
   ),
-  allowedToolsStorage: import_zod.z.enum(["memory", "storage"]).default("storage").describe(
+  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(
+    "Static tool policies for fine-grained allow/deny control. Deny list takes precedence over allow list."
   )
 }).strict().describe("Tool confirmation and approval configuration");
 // 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,
   InternalToolsSchema,
-  ToolConfirmationConfigSchema
+  TOOL_CONFIRMATION_MODES,
+  ToolConfirmationConfigSchema,
+  ToolPoliciesSchema
 });

package/dist/tools/schemas.d.ts

@@ -1,21 +1,54 @@
 import { z } from 'zod';
-
-declare const InternalToolsSchema: z.ZodDefault<z.ZodArray<z.ZodEnum<["search_history"]>, "many">>;
-type InternalToolsConfig = z.output<typeof InternalToolsSchema>;
-declare const ToolConfirmationConfigSchema: z.ZodObject<{
+export declare const TOOL_CONFIRMATION_MODES: readonly ["event-based", "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 type InternalToolsConfig = z.output<typeof InternalToolsSchema>;
+export declare const ToolPoliciesSchema: z.ZodDefault<z.ZodObject<{
+    alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    alwaysAllow: string[];
+    alwaysDeny: string[];
+}, {
+    alwaysAllow?: string[] | undefined;
+    alwaysDeny?: string[] | undefined;
+}>>;
+export type ToolPolicies = z.output<typeof ToolPoliciesSchema>;
+export declare const ToolConfirmationConfigSchema: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<["event-based", "auto-approve", "auto-deny"]>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     allowedToolsStorage: z.ZodDefault<z.ZodEnum<["memory", "storage"]>>;
+    toolPolicies: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        alwaysAllow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        alwaysDeny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        alwaysAllow: string[];
+        alwaysDeny: string[];
+    }, {
+        alwaysAllow?: string[] | undefined;
+        alwaysDeny?: string[] | undefined;
+    }>>>;
 }, "strict", z.ZodTypeAny, {
     timeout: number;
     mode: "event-based" | "auto-approve" | "auto-deny";
     allowedToolsStorage: "storage" | "memory";
+    toolPolicies?: {
+        alwaysAllow: string[];
+        alwaysDeny: string[];
+    } | undefined;
 }, {
     timeout?: number | undefined;
     mode?: "event-based" | "auto-approve" | "auto-deny" | undefined;
     allowedToolsStorage?: "storage" | "memory" | undefined;
+    toolPolicies?: {
+        alwaysAllow?: string[] | undefined;
+        alwaysDeny?: string[] | undefined;
+    } | undefined;
 }>;
-type ToolConfirmationConfig = z.input<typeof ToolConfirmationConfigSchema>;
-type ValidatedToolConfirmationConfig = z.output<typeof ToolConfirmationConfigSchema>;
-
-export { type InternalToolsConfig, InternalToolsSchema, type ToolConfirmationConfig, ToolConfirmationConfigSchema, type ValidatedToolConfirmationConfig };
+export type ToolConfirmationConfig = z.input<typeof ToolConfirmationConfigSchema>;
+export type ValidatedToolConfirmationConfig = z.output<typeof ToolConfirmationConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +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"}

package/dist/tools/schemas.js

@@ -1,20 +1,41 @@
+import "../chunk-C6A6W6XS.js";
 import { z } from "zod";
-import { INTERNAL_TOOL_NAMES } from "./internal-tools/registry.js";
+import { INTERNAL_TOOL_NAMES } from "./internal-tools/constants.js";
+const TOOL_CONFIRMATION_MODES = ["event-based", "auto-approve", "auto-deny"];
+const ALLOWED_TOOLS_STORAGE_TYPES = ["memory", "storage"];
+const DEFAULT_TOOL_CONFIRMATION_MODE = "event-based";
+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(", ")}`
 );
+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")'
+  ),
+  alwaysDeny: z.array(z.string()).default([]).describe(
+    'Tools that are always denied (high-risk). Takes precedence over alwaysAllow. Use full qualified names (e.g., "mcp--filesystem--delete_file")'
+  )
+}).strict().default({ alwaysAllow: [], alwaysDeny: [] }).describe("Static tool policies for allow/deny lists");
 const ToolConfirmationConfigSchema = z.object({
-  mode: z.enum(["event-based", "auto-approve", "auto-deny"]).default("event-based").describe(
+  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)"
   ),
   timeout: z.number().int().positive().default(12e4).describe(
     "Timeout for tool confirmation requests in milliseconds, defaults to 120000ms (2 mins)"
   ),
-  allowedToolsStorage: z.enum(["memory", "storage"]).default("storage").describe(
+  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(
+    "Static tool policies for fine-grained allow/deny control. Deny list takes precedence over allow list."
   )
 }).strict().describe("Tool confirmation and approval configuration");
 export {
+  ALLOWED_TOOLS_STORAGE_TYPES,
+  DEFAULT_ALLOWED_TOOLS_STORAGE,
+  DEFAULT_TOOL_CONFIRMATION_MODE,
   InternalToolsSchema,
-  ToolConfirmationConfigSchema
+  TOOL_CONFIRMATION_MODES,
+  ToolConfirmationConfigSchema,
+  ToolPoliciesSchema
 };