@dexto/tools-filesystem 1.5.8 → 1.6.0

package/dist/directory-approval.integration.test.js

@@ -6,21 +6,49 @@ import { createReadFileTool } from "./read-file-tool.js";
 import { createWriteFileTool } from "./write-file-tool.js";
 import { createEditFileTool } from "./edit-file-tool.js";
 import { FileSystemService } from "./filesystem-service.js";
-import { ApprovalType, ApprovalStatus } from "@dexto/core";
-const createMockLogger = () => ({
-  debug: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  createChild: vi.fn().mockReturnThis()
-});
+import {
+  ApprovalManager,
+  ApprovalStatus,
+  ApprovalType,
+  DextoRuntimeError
+} from "@dexto/core";
+const createMockLogger = () => {
+  const noopAsync = async () => void 0;
+  const logger = {
+    debug: vi.fn(),
+    silly: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    trackException: vi.fn(),
+    createChild: () => logger,
+    setLevel: vi.fn(),
+    getLevel: () => "info",
+    getLogFilePath: () => null,
+    destroy: noopAsync
+  };
+  return logger;
+};
+function createToolContext(logger, approval) {
+  return {
+    logger,
+    services: {
+      approval,
+      search: {},
+      resources: {},
+      prompts: {},
+      mcp: {},
+      taskForker: null
+    }
+  };
+}
 describe("Directory Approval Integration Tests", () => {
   let mockLogger;
   let tempDir;
   let fileSystemService;
-  let directoryApproval;
-  let isSessionApprovedMock;
-  let addApprovedMock;
+  let approvalManager;
+  let toolContext;
+  const getFileSystemService = async (_context) => fileSystemService;
   beforeEach(async () => {
     mockLogger = createMockLogger();
     const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-fs-test-"));
@@ -38,12 +66,14 @@ describe("Directory Approval Integration Tests", () => {
       mockLogger
     );
     await fileSystemService.initialize();
-    isSessionApprovedMock = vi.fn().mockReturnValue(false);
-    addApprovedMock = vi.fn();
-    directoryApproval = {
-      isSessionApproved: isSessionApprovedMock,
-      addApproved: addApprovedMock
-    };
+    approvalManager = new ApprovalManager(
+      {
+        permissions: { mode: "manual" },
+        elicitation: { enabled: true }
+      },
+      mockLogger
+    );
+    toolContext = createToolContext(mockLogger, approvalManager);
     vi.clearAllMocks();
   });
   afterEach(async () => {
@@ -55,22 +85,22 @@ describe("Directory Approval Integration Tests", () => {
   describe("Read File Tool", () => {
     describe("getApprovalOverride", () => {
       it("should return null for paths within working directory (no prompt needed)", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createReadFileTool(getFileSystemService);
         const testFile = path.join(tempDir, "test.txt");
         await fs.writeFile(testFile, "test content");
-        const override = await tool.getApprovalOverride?.({ file_path: testFile });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: testFile }),
+          toolContext
+        );
         expect(override).toBeNull();
       });
       it("should return directory access approval for external paths", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createReadFileTool(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
+        );
         expect(override).not.toBeNull();
         expect(override?.type).toBe(ApprovalType.DIRECTORY_ACCESS);
         const metadata = override?.metadata;
@@ -80,101 +110,96 @@ describe("Directory Approval Integration Tests", () => {
         expect(metadata?.toolName).toBe("read_file");
       });
       it("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        approvalManager.addApprovedDirectory("/external/project", "session");
+        const tool = createReadFileTool(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
-        expect(override).toBeNull();
-        expect(isSessionApprovedMock).toHaveBeenCalledWith(externalPath);
-      });
-      it("should return null when file_path is missing", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const override = await tool.getApprovalOverride?.({});
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
+        );
         expect(override).toBeNull();
       });
     });
     describe("onApprovalGranted", () => {
       it("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createReadFileTool(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "session"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
+        );
+        expect(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: ApprovalStatus.APPROVED,
+            data: { rememberDirectory: true }
+          },
+          toolContext,
+          approvalRequest
         );
+        expect(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("session");
       });
       it("should add directory as once-approved when rememberDirectory is false", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createReadFileTool(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: false }
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "once"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
         );
+        expect(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: ApprovalStatus.APPROVED,
+            data: { rememberDirectory: false }
+          },
+          toolContext,
+          approvalRequest
+        );
+        expect(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("once");
       });
       it("should default to once-approved when rememberDirectory is not specified", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createReadFileTool(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: {}
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "once"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
         );
-      });
-      it("should not call addApproved when directoryApproval is not provided", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval: void 0
-        });
-        const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        expect(addApprovedMock).not.toHaveBeenCalled();
+        expect(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: ApprovalStatus.APPROVED,
+            data: {}
+          },
+          toolContext,
+          approvalRequest
+        );
+        expect(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("once");
       });
     });
     describe("execute", () => {
       it("should read file contents within working directory", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createReadFileTool(getFileSystemService);
         const testFile = path.join(tempDir, "readable.txt");
         await fs.writeFile(testFile, "Hello, world!\nLine 2");
-        const result = await tool.execute({ file_path: testFile }, {});
+        const result = await tool.execute({ file_path: testFile }, toolContext);
         expect(result.content).toBe("Hello, world!\nLine 2");
         expect(result.lines).toBe(2);
       });
@@ -183,27 +208,21 @@ describe("Directory Approval Integration Tests", () => {
   describe("Write File Tool", () => {
     describe("getApprovalOverride", () => {
       it("should return null for paths within working directory", async () => {
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createWriteFileTool(getFileSystemService);
         const testFile = path.join(tempDir, "new-file.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          content: "test"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: testFile, content: "test" }),
+          toolContext
+        );
         expect(override).toBeNull();
       });
       it("should return directory access approval for external paths", async () => {
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createWriteFileTool(getFileSystemService);
         const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+          toolContext
+        );
         expect(override).not.toBeNull();
         expect(override?.type).toBe(ApprovalType.DIRECTORY_ACCESS);
         const metadata = override?.metadata;
@@ -211,65 +230,69 @@ describe("Directory Approval Integration Tests", () => {
         expect(metadata?.toolName).toBe("write_file");
       });
       it("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        approvalManager.addApprovedDirectory("/external/project", "session");
+        const tool = createWriteFileTool(getFileSystemService);
         const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+          toolContext
+        );
         expect(override).toBeNull();
       });
     });
     describe("onApprovalGranted", () => {
       it("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createWriteFileTool(getFileSystemService);
         const externalPath = "/external/project/new.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath, content: "test" });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "session"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+          toolContext
+        );
+        expect(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: ApprovalStatus.APPROVED,
+            data: { rememberDirectory: true }
+          },
+          toolContext,
+          approvalRequest
         );
+        expect(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("session");
       });
     });
   });
   describe("Edit File Tool", () => {
     describe("getApprovalOverride", () => {
       it("should return null for paths within working directory", async () => {
-        const tool = createEditFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createEditFileTool(getFileSystemService);
         const testFile = path.join(tempDir, "existing.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          old_string: "old",
-          new_string: "new"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({
+            file_path: testFile,
+            old_string: "old",
+            new_string: "new"
+          }),
+          toolContext
+        );
         expect(override).toBeNull();
       });
       it("should return directory access approval for external paths", async () => {
-        const tool = createEditFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = createEditFileTool(getFileSystemService);
         const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          old_string: "old",
-          new_string: "new"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({
+            file_path: externalPath,
+            old_string: "old",
+            new_string: "new"
+          }),
+          toolContext
+        );
         expect(override).not.toBeNull();
         expect(override?.type).toBe(ApprovalType.DIRECTORY_ACCESS);
         const metadata = override?.metadata;
@@ -277,116 +300,129 @@ describe("Directory Approval Integration Tests", () => {
         expect(metadata?.toolName).toBe("edit_file");
       });
       it("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = createEditFileTool({
-          fileSystemService,
-          directoryApproval
-        });
+        approvalManager.addApprovedDirectory("/external/project", "session");
+        const tool = createEditFileTool(getFileSystemService);
         const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          old_string: "old",
-          new_string: "new"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({
+            file_path: externalPath,
+            old_string: "old",
+            new_string: "new"
+          }),
+          toolContext
+        );
         expect(override).toBeNull();
       });
     });
   });
   describe("Session vs Once Approval Scenarios", () => {
     it("should not prompt for subsequent requests after session approval", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
+      const tool = createReadFileTool(getFileSystemService);
       const externalPath1 = "/external/project/file1.ts";
       const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath1 }),
+        toolContext
+      );
       expect(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: ApprovalStatus.APPROVED,
-        data: { rememberDirectory: true }
-      });
-      expect(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "session"
+      if (!override) {
+        throw new Error("Expected approval request");
+      }
+      tool.onApprovalGranted?.(
+        {
+          approvalId: "approval-1",
+          status: ApprovalStatus.APPROVED,
+          data: { rememberDirectory: true }
+        },
+        toolContext,
+        override
+      );
+      expect(
+        approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath1)))
+      ).toBe("session");
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath2 }),
+        toolContext
       );
-      isSessionApprovedMock.mockReturnValue(true);
-      override = await tool.getApprovalOverride?.({ file_path: externalPath2 });
       expect(override).toBeNull();
     });
     it("should prompt for subsequent requests after once approval", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
+      const tool = createReadFileTool(getFileSystemService);
       const externalPath1 = "/external/project/file1.ts";
       const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath1 }),
+        toolContext
+      );
       expect(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: ApprovalStatus.APPROVED,
-        data: { rememberDirectory: false }
-      });
-      expect(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "once"
+      if (!override) {
+        throw new Error("Expected approval request");
+      }
+      tool.onApprovalGranted?.(
+        {
+          approvalId: "approval-1",
+          status: ApprovalStatus.APPROVED,
+          data: { rememberDirectory: false }
+        },
+        toolContext,
+        override
+      );
+      expect(
+        approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath1)))
+      ).toBe("once");
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath2 }),
+        toolContext
       );
-      isSessionApprovedMock.mockReturnValue(false);
-      override = await tool.getApprovalOverride?.({ file_path: externalPath2 });
       expect(override).not.toBeNull();
     });
   });
   describe("Path Containment Scenarios", () => {
     it("should cover child paths when parent directory is session-approved", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      isSessionApprovedMock.mockImplementation((filePath) => {
-        const normalizedPath = path.resolve(filePath);
-        const approvedDir = "/external/project";
-        return normalizedPath.startsWith(approvedDir + path.sep) || normalizedPath === approvedDir;
-      });
-      let override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/file.ts"
-      });
+      const tool = createReadFileTool(getFileSystemService);
+      approvalManager.addApprovedDirectory("/external/project", "session");
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+        toolContext
+      );
       expect(override).toBeNull();
-      override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/deep/nested/file.ts"
-      });
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/project/deep/nested/file.ts" }),
+        toolContext
+      );
       expect(override).toBeNull();
     });
     it("should NOT cover sibling directories", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      isSessionApprovedMock.mockImplementation((filePath) => {
-        const normalizedPath = path.resolve(filePath);
-        const approvedDir = "/external/sub";
-        return normalizedPath.startsWith(approvedDir + path.sep) || normalizedPath === approvedDir;
-      });
-      let override = await tool.getApprovalOverride?.({ file_path: "/external/sub/file.ts" });
+      const tool = createReadFileTool(getFileSystemService);
+      approvalManager.addApprovedDirectory("/external/sub", "session");
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/sub/file.ts" }),
+        toolContext
+      );
       expect(override).toBeNull();
-      override = await tool.getApprovalOverride?.({ file_path: "/external/other/file.ts" });
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/other/file.ts" }),
+        toolContext
+      );
       expect(override).not.toBeNull();
     });
   });
   describe("Different External Directories Scenarios", () => {
     it("should require separate approval for different external directories", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
+      const tool = createReadFileTool(getFileSystemService);
       const dir1Path = "/external/project1/file.ts";
       const dir2Path = "/external/project2/file.ts";
-      const override1 = await tool.getApprovalOverride?.({ file_path: dir1Path });
+      const override1 = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: dir1Path }),
+        toolContext
+      );
       expect(override1).not.toBeNull();
       const metadata1 = override1?.metadata;
       expect(metadata1?.parentDir).toBe("/external/project1");
-      const override2 = await tool.getApprovalOverride?.({ file_path: dir2Path });
+      const override2 = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: dir2Path }),
+        toolContext
+      );
       expect(override2).not.toBeNull();
       const metadata2 = override2?.metadata;
       expect(metadata2?.parentDir).toBe("/external/project2");
@@ -394,55 +430,58 @@ describe("Directory Approval Integration Tests", () => {
   });
   describe("Mixed Operations Scenarios", () => {
     it("should share directory approval across different file operations", async () => {
-      const readTool = createReadFileTool({ fileSystemService, directoryApproval });
-      const writeTool = createWriteFileTool({ fileSystemService, directoryApproval });
-      const editTool = createEditFileTool({ fileSystemService, directoryApproval });
+      const readTool = createReadFileTool(getFileSystemService);
+      const writeTool = createWriteFileTool(getFileSystemService);
+      const editTool = createEditFileTool(getFileSystemService);
       const externalDir = "/external/project";
+      const approvalRequest = await readTool.getApprovalOverride?.(
+        readTool.inputSchema.parse({ file_path: `${externalDir}/file1.ts` }),
+        toolContext
+      );
+      expect(approvalRequest).not.toBeNull();
+      if (!approvalRequest) {
+        throw new Error("Expected approval request");
+      }
+      readTool.onApprovalGranted?.(
+        {
+          approvalId: "approval-1",
+          status: ApprovalStatus.APPROVED,
+          data: { rememberDirectory: true }
+        },
+        toolContext,
+        approvalRequest
+      );
       expect(
-        await readTool.getApprovalOverride?.({ file_path: `${externalDir}/file1.ts` })
-      ).not.toBeNull();
-      expect(
-        await writeTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file2.ts`,
-          content: "test"
-        })
-      ).not.toBeNull();
-      expect(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
-      ).not.toBeNull();
-      isSessionApprovedMock.mockReturnValue(true);
-      expect(
-        await readTool.getApprovalOverride?.({ file_path: `${externalDir}/file1.ts` })
-      ).toBeNull();
-      expect(
-        await writeTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file2.ts`,
-          content: "test"
-        })
+        await writeTool.getApprovalOverride?.(
+          writeTool.inputSchema.parse({
+            file_path: `${externalDir}/file2.ts`,
+            content: "test"
+          }),
+          toolContext
+        )
       ).toBeNull();
       expect(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
+        await editTool.getApprovalOverride?.(
+          editTool.inputSchema.parse({
+            file_path: `${externalDir}/file3.ts`,
+            old_string: "a",
+            new_string: "b"
+          }),
+          toolContext
+        )
       ).toBeNull();
     });
   });
-  describe("Without Directory Approval Callbacks", () => {
-    it("should work without directory approval callbacks (all paths need normal tool confirmation)", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval: void 0
-      });
-      const override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/file.ts"
-      });
-      expect(override).not.toBeNull();
+  describe("Without ApprovalManager in context", () => {
+    it("should throw for external paths", async () => {
+      const tool = createReadFileTool(getFileSystemService);
+      const contextWithoutApprovalManager = { logger: mockLogger };
+      await expect(
+        tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+          contextWithoutApprovalManager
+        )
+      ).rejects.toBeInstanceOf(DextoRuntimeError);
     });
   });
 });