@dexto/tools-filesystem 1.7.1 → 1.8.0

package/dist/write-file-tool.test.cjs

@@ -29,6 +29,7 @@ var import_write_file_tool = require("./write-file-tool.js");
 var import_filesystem_service = require("./filesystem-service.js");
 var import_core = require("@dexto/core");
 var import_core2 = require("@dexto/core");
+var import_workspace = require("@dexto/core/workspace");
 const createMockLogger = () => {
   const logger = {
     debug: import_vitest.vi.fn(),
@@ -46,8 +47,68 @@ const createMockLogger = () => {
   };
   return logger;
 };
-function createToolContext(logger, overrides = {}) {
-  return { logger, ...overrides };
+function createToolContext(logger, overrides = {}, workspaceRoot = currentWorkspaceRoot) {
+  return {
+    logger,
+    services: createWorkspaceServices(workspaceRoot),
+    ...overrides
+  };
+}
+let currentWorkspaceRoot = process.cwd();
+function createWorkspaceServices(workspaceRoot, overrides = {}) {
+  const workspaceManager = {
+    open: import_vitest.vi.fn(async () => ({
+      context: {
+        id: "test-workspace",
+        path: workspaceRoot,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now()
+      },
+      capabilities: ["files"],
+      files: {
+        readFile: async (filePath) => readWorkspaceFile(workspaceRoot, filePath),
+        readText: async (filePath) => readWorkspaceFile(workspaceRoot, filePath),
+        glob: import_vitest.vi.fn(async () => []),
+        writeFile: async (filePath, content) => {
+          const resolvedPath = resolveWorkspacePath(workspaceRoot, filePath);
+          await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+          try {
+            await fs.writeFile(resolvedPath, content, "utf-8");
+          } catch (error) {
+            if (error.code === "ENOENT") {
+              throw import_workspace.WorkspaceError.fileNotFound(filePath);
+            }
+            throw error;
+          }
+        },
+        listFiles: import_vitest.vi.fn(async () => [])
+      }
+    })),
+    ...overrides
+  };
+  return {
+    approval: {},
+    search: {},
+    resources: {},
+    prompts: {},
+    skills: {},
+    mcp: {},
+    taskForker: null,
+    workspaceManager
+  };
+}
+function resolveWorkspacePath(workspaceRoot, filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+}
+async function readWorkspaceFile(workspaceRoot, filePath) {
+  try {
+    return await fs.readFile(resolveWorkspacePath(workspaceRoot, filePath), "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw import_workspace.WorkspaceError.fileNotFound(filePath);
+    }
+    throw error;
+  }
 }
 (0, import_vitest.describe)("write_file tool", () => {
   let mockLogger;
@@ -70,6 +131,7 @@ function createToolContext(logger, overrides = {}) {
       mockLogger
     );
     await fileSystemService.initialize();
+    currentWorkspaceRoot = tempDir;
     import_vitest.vi.clearAllMocks();
   });
   (0, import_vitest.afterEach)(async () => {
@@ -78,6 +140,186 @@ function createToolContext(logger, overrides = {}) {
     } catch {
     }
   });
+  (0, import_vitest.it)("writes through WorkspaceManager.open without FileSystemService execution", async () => {
+    const getFileSystemService = import_vitest.vi.fn(async () => {
+      throw new Error("write_file execute must not use FileSystemService");
+    });
+    const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
+    const parsedInput = tool.inputSchema.parse({
+      file_path: "workspace.txt",
+      content: "workspace write"
+    });
+    const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+    (0, import_vitest.expect)(getFileSystemService).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(result).toMatchObject({ success: true, path: "workspace.txt" });
+    await (0, import_vitest.expect)(fs.readFile(path.join(tempDir, "workspace.txt"), "utf-8")).resolves.toBe(
+      "workspace write"
+    );
+  });
+  (0, import_vitest.it)("creates missing parent directories by default", async () => {
+    const tool = (0, import_write_file_tool.createWriteFileTool)(import_vitest.vi.fn());
+    const parsedInput = tool.inputSchema.parse({
+      file_path: "missing-parent/file.txt",
+      content: "content"
+    });
+    await (0, import_vitest.expect)(
+      tool.execute(parsedInput, createToolContext(mockLogger))
+    ).resolves.toMatchObject({
+      success: true,
+      path: "missing-parent/file.txt"
+    });
+    await (0, import_vitest.expect)(
+      fs.readFile(path.join(tempDir, "missing-parent", "file.txt"), "utf-8")
+    ).resolves.toBe("content");
+  });
+  (0, import_vitest.it)("rejects obsolete create_dirs input", async () => {
+    const tool = (0, import_write_file_tool.createWriteFileTool)(import_vitest.vi.fn());
+    (0, import_vitest.expect)(
+      () => tool.inputSchema.parse({
+        file_path: "file.txt",
+        content: "content",
+        create_dirs: true
+      })
+    ).toThrow();
+  });
+  (0, import_vitest.it)("passes normalized workspace paths to the provider without write options", async () => {
+    const writeFile = import_vitest.vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: import_vitest.vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: import_vitest.vi.fn(async () => {
+            throw import_workspace.WorkspaceError.fileNotFound("nested/file.txt");
+          }),
+          readText: import_vitest.vi.fn(async () => {
+            throw import_workspace.WorkspaceError.fileNotFound("nested/file.txt");
+          }),
+          glob: import_vitest.vi.fn(async () => []),
+          writeFile,
+          listFiles: import_vitest.vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = (0, import_write_file_tool.createWriteFileTool)(import_vitest.vi.fn());
+    const context = createToolContext(mockLogger, {
+      services: {
+        ...createWorkspaceServices(tempDir),
+        workspaceManager
+      }
+    });
+    await tool.execute(
+      tool.inputSchema.parse({
+        file_path: path.join(tempDir, "nested", "file.txt"),
+        content: "content"
+      }),
+      context
+    );
+    (0, import_vitest.expect)(writeFile).toHaveBeenCalledWith("nested/file.txt", "content");
+  });
+  (0, import_vitest.it)("generates file creation previews through WorkspaceManager.open in hosted mode", async () => {
+    const getFileSystemService = import_vitest.vi.fn(async () => {
+      throw new Error("write_file preview must not use FileSystemService in workspace mode");
+    });
+    const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
+    const preview = await tool.presentation.preview(
+      tool.inputSchema.parse({
+        file_path: "workspace-new.txt",
+        content: "workspace content"
+      }),
+      createToolContext(mockLogger, { toolCallId: "workspace-preview-create" })
+    );
+    (0, import_vitest.expect)(getFileSystemService).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(preview).toMatchObject({
+      content: "workspace content",
+      operation: "create",
+      path: "workspace-new.txt",
+      title: "Create file",
+      type: "file"
+    });
+  });
+  (0, import_vitest.it)("rejects external absolute paths before file provider calls", async () => {
+    const readText = import_vitest.vi.fn(async () => "existing");
+    const writeFile = import_vitest.vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: import_vitest.vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: readText,
+          readText,
+          glob: import_vitest.vi.fn(async () => []),
+          writeFile,
+          listFiles: import_vitest.vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = (0, import_write_file_tool.createWriteFileTool)(import_vitest.vi.fn());
+    const context = createToolContext(mockLogger, {
+      services: {
+        ...createWorkspaceServices(tempDir),
+        workspaceManager
+      }
+    });
+    await (0, import_vitest.expect)(
+      tool.execute(
+        tool.inputSchema.parse({ file_path: "/outside/file.txt", content: "content" }),
+        context
+      )
+    ).rejects.toMatchObject({ code: import_core.ToolErrorCode.VALIDATION_FAILED });
+    (0, import_vitest.expect)(readText).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(writeFile).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("propagates non-not-found read errors and does not overwrite", async () => {
+    const readError = new Error("permission denied");
+    const writeFile = import_vitest.vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: import_vitest.vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: import_vitest.vi.fn(async () => {
+            throw readError;
+          }),
+          readText: import_vitest.vi.fn(async () => {
+            throw readError;
+          }),
+          glob: import_vitest.vi.fn(async () => []),
+          writeFile,
+          listFiles: import_vitest.vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = (0, import_write_file_tool.createWriteFileTool)(import_vitest.vi.fn());
+    const context = createToolContext(mockLogger, {
+      services: {
+        ...createWorkspaceServices(tempDir),
+        workspaceManager
+      }
+    });
+    await (0, import_vitest.expect)(
+      tool.execute(
+        tool.inputSchema.parse({ file_path: "file.txt", content: "content" }),
+        context
+      )
+    ).rejects.toBe(readError);
+    (0, import_vitest.expect)(writeFile).not.toHaveBeenCalled();
+  });
   (0, import_vitest.describe)("File Modification Detection - Existing Files", () => {
     (0, import_vitest.it)("should generate preview for existing files outside config-allowed roots (preview read only)", async () => {
       const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
@@ -95,7 +337,13 @@ function createToolContext(logger, overrides = {}) {
         });
         const preview = await tool.presentation.preview(
           parsedInput,
-          createToolContext(mockLogger, { toolCallId })
+          createToolContext(mockLogger, {
+            services: {
+              ...createWorkspaceServices(tempDir),
+              workspaceManager: void 0
+            },
+            toolCallId
+          })
         );
         (0, import_vitest.expect)(preview).toBeDefined();
         (0, import_vitest.expect)(preview?.type).toBe("diff");
@@ -193,11 +441,10 @@ function createToolContext(logger, overrides = {}) {
     });
   });
   (0, import_vitest.describe)("File Modification Detection - New Files", () => {
-    (0, import_vitest.it)("should expand home-directory shorthand when creating a file", async () => {
+    (0, import_vitest.it)("should create a workspace-relative file", async () => {
       const homeTempDir = await fs.mkdtemp(
         path.join(os.homedir(), ".dexto-write-home-test-")
       );
-      const homeRelativeDir = `~/${path.basename(homeTempDir)}`;
       const fileSystemServiceForHome = new import_filesystem_service.FileSystemService(
         {
           allowedPaths: [homeTempDir],
@@ -214,14 +461,18 @@ function createToolContext(logger, overrides = {}) {
       const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemServiceForHome);
       try {
         const parsedInput = tool.inputSchema.parse({
-          file_path: `${homeRelativeDir}/nested/new-file.txt`,
-          content: "brand new content",
-          create_dirs: true
+          file_path: "nested/new-file.txt",
+          content: "brand new content"
         });
-        const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+        const result = await tool.execute(
+          parsedInput,
+          createToolContext(mockLogger, {}, homeTempDir)
+        );
         (0, import_vitest.expect)(result.success).toBe(true);
-        (0, import_vitest.expect)(result.path).toBe(path.join(homeTempDir, "nested", "new-file.txt"));
-        (0, import_vitest.expect)(await fs.readFile(result.path, "utf-8")).toBe("brand new content");
+        (0, import_vitest.expect)(result.path).toBe("nested/new-file.txt");
+        (0, import_vitest.expect)(await fs.readFile(path.join(homeTempDir, result.path), "utf-8")).toBe(
+          "brand new content"
+        );
       } finally {
         await fs.rm(homeTempDir, { recursive: true, force: true });
       }

package/dist/write-file-tool.test.js

@@ -6,6 +6,7 @@ import { createWriteFileTool } from "./write-file-tool.js";
 import { FileSystemService } from "./filesystem-service.js";
 import { ToolErrorCode } from "@dexto/core";
 import { DextoRuntimeError } from "@dexto/core";
+import { WorkspaceError } from "@dexto/core/workspace";
 const createMockLogger = () => {
   const logger = {
     debug: vi.fn(),
@@ -23,8 +24,68 @@ const createMockLogger = () => {
   };
   return logger;
 };
-function createToolContext(logger, overrides = {}) {
-  return { logger, ...overrides };
+function createToolContext(logger, overrides = {}, workspaceRoot = currentWorkspaceRoot) {
+  return {
+    logger,
+    services: createWorkspaceServices(workspaceRoot),
+    ...overrides
+  };
+}
+let currentWorkspaceRoot = process.cwd();
+function createWorkspaceServices(workspaceRoot, overrides = {}) {
+  const workspaceManager = {
+    open: vi.fn(async () => ({
+      context: {
+        id: "test-workspace",
+        path: workspaceRoot,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now()
+      },
+      capabilities: ["files"],
+      files: {
+        readFile: async (filePath) => readWorkspaceFile(workspaceRoot, filePath),
+        readText: async (filePath) => readWorkspaceFile(workspaceRoot, filePath),
+        glob: vi.fn(async () => []),
+        writeFile: async (filePath, content) => {
+          const resolvedPath = resolveWorkspacePath(workspaceRoot, filePath);
+          await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+          try {
+            await fs.writeFile(resolvedPath, content, "utf-8");
+          } catch (error) {
+            if (error.code === "ENOENT") {
+              throw WorkspaceError.fileNotFound(filePath);
+            }
+            throw error;
+          }
+        },
+        listFiles: vi.fn(async () => [])
+      }
+    })),
+    ...overrides
+  };
+  return {
+    approval: {},
+    search: {},
+    resources: {},
+    prompts: {},
+    skills: {},
+    mcp: {},
+    taskForker: null,
+    workspaceManager
+  };
+}
+function resolveWorkspacePath(workspaceRoot, filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+}
+async function readWorkspaceFile(workspaceRoot, filePath) {
+  try {
+    return await fs.readFile(resolveWorkspacePath(workspaceRoot, filePath), "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw WorkspaceError.fileNotFound(filePath);
+    }
+    throw error;
+  }
 }
 describe("write_file tool", () => {
   let mockLogger;
@@ -47,6 +108,7 @@ describe("write_file tool", () => {
       mockLogger
     );
     await fileSystemService.initialize();
+    currentWorkspaceRoot = tempDir;
     vi.clearAllMocks();
   });
   afterEach(async () => {
@@ -55,6 +117,186 @@ describe("write_file tool", () => {
     } catch {
     }
   });
+  it("writes through WorkspaceManager.open without FileSystemService execution", async () => {
+    const getFileSystemService = vi.fn(async () => {
+      throw new Error("write_file execute must not use FileSystemService");
+    });
+    const tool = createWriteFileTool(getFileSystemService);
+    const parsedInput = tool.inputSchema.parse({
+      file_path: "workspace.txt",
+      content: "workspace write"
+    });
+    const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+    expect(getFileSystemService).not.toHaveBeenCalled();
+    expect(result).toMatchObject({ success: true, path: "workspace.txt" });
+    await expect(fs.readFile(path.join(tempDir, "workspace.txt"), "utf-8")).resolves.toBe(
+      "workspace write"
+    );
+  });
+  it("creates missing parent directories by default", async () => {
+    const tool = createWriteFileTool(vi.fn());
+    const parsedInput = tool.inputSchema.parse({
+      file_path: "missing-parent/file.txt",
+      content: "content"
+    });
+    await expect(
+      tool.execute(parsedInput, createToolContext(mockLogger))
+    ).resolves.toMatchObject({
+      success: true,
+      path: "missing-parent/file.txt"
+    });
+    await expect(
+      fs.readFile(path.join(tempDir, "missing-parent", "file.txt"), "utf-8")
+    ).resolves.toBe("content");
+  });
+  it("rejects obsolete create_dirs input", async () => {
+    const tool = createWriteFileTool(vi.fn());
+    expect(
+      () => tool.inputSchema.parse({
+        file_path: "file.txt",
+        content: "content",
+        create_dirs: true
+      })
+    ).toThrow();
+  });
+  it("passes normalized workspace paths to the provider without write options", async () => {
+    const writeFile = vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: vi.fn(async () => {
+            throw WorkspaceError.fileNotFound("nested/file.txt");
+          }),
+          readText: vi.fn(async () => {
+            throw WorkspaceError.fileNotFound("nested/file.txt");
+          }),
+          glob: vi.fn(async () => []),
+          writeFile,
+          listFiles: vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = createWriteFileTool(vi.fn());
+    const context = createToolContext(mockLogger, {
+      services: {
+        ...createWorkspaceServices(tempDir),
+        workspaceManager
+      }
+    });
+    await tool.execute(
+      tool.inputSchema.parse({
+        file_path: path.join(tempDir, "nested", "file.txt"),
+        content: "content"
+      }),
+      context
+    );
+    expect(writeFile).toHaveBeenCalledWith("nested/file.txt", "content");
+  });
+  it("generates file creation previews through WorkspaceManager.open in hosted mode", async () => {
+    const getFileSystemService = vi.fn(async () => {
+      throw new Error("write_file preview must not use FileSystemService in workspace mode");
+    });
+    const tool = createWriteFileTool(getFileSystemService);
+    const preview = await tool.presentation.preview(
+      tool.inputSchema.parse({
+        file_path: "workspace-new.txt",
+        content: "workspace content"
+      }),
+      createToolContext(mockLogger, { toolCallId: "workspace-preview-create" })
+    );
+    expect(getFileSystemService).not.toHaveBeenCalled();
+    expect(preview).toMatchObject({
+      content: "workspace content",
+      operation: "create",
+      path: "workspace-new.txt",
+      title: "Create file",
+      type: "file"
+    });
+  });
+  it("rejects external absolute paths before file provider calls", async () => {
+    const readText = vi.fn(async () => "existing");
+    const writeFile = vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: readText,
+          readText,
+          glob: vi.fn(async () => []),
+          writeFile,
+          listFiles: vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = createWriteFileTool(vi.fn());
+    const context = createToolContext(mockLogger, {
+      services: {
+        ...createWorkspaceServices(tempDir),
+        workspaceManager
+      }
+    });
+    await expect(
+      tool.execute(
+        tool.inputSchema.parse({ file_path: "/outside/file.txt", content: "content" }),
+        context
+      )
+    ).rejects.toMatchObject({ code: ToolErrorCode.VALIDATION_FAILED });
+    expect(readText).not.toHaveBeenCalled();
+    expect(writeFile).not.toHaveBeenCalled();
+  });
+  it("propagates non-not-found read errors and does not overwrite", async () => {
+    const readError = new Error("permission denied");
+    const writeFile = vi.fn(async () => void 0);
+    const workspaceManager = {
+      open: vi.fn(async () => ({
+        context: {
+          id: "test-workspace",
+          path: tempDir,
+          createdAt: Date.now(),
+          lastActiveAt: Date.now()
+        },
+        capabilities: ["files"],
+        files: {
+          readFile: vi.fn(async () => {
+            throw readError;
+          }),
+          readText: vi.fn(async () => {
+            throw readError;
+          }),
+          glob: vi.fn(async () => []),
+          writeFile,
+          listFiles: vi.fn(async () => [])
+        }
+      }))
+    };
+    const tool = createWriteFileTool(vi.fn());
+    const context = createToolContext(mockLogger, {
+      services: {
+        ...createWorkspaceServices(tempDir),
+        workspaceManager
+      }
+    });
+    await expect(
+      tool.execute(
+        tool.inputSchema.parse({ file_path: "file.txt", content: "content" }),
+        context
+      )
+    ).rejects.toBe(readError);
+    expect(writeFile).not.toHaveBeenCalled();
+  });
   describe("File Modification Detection - Existing Files", () => {
     it("should generate preview for existing files outside config-allowed roots (preview read only)", async () => {
       const tool = createWriteFileTool(async () => fileSystemService);
@@ -72,7 +314,13 @@ describe("write_file tool", () => {
         });
         const preview = await tool.presentation.preview(
           parsedInput,
-          createToolContext(mockLogger, { toolCallId })
+          createToolContext(mockLogger, {
+            services: {
+              ...createWorkspaceServices(tempDir),
+              workspaceManager: void 0
+            },
+            toolCallId
+          })
         );
         expect(preview).toBeDefined();
         expect(preview?.type).toBe("diff");
@@ -170,11 +418,10 @@ describe("write_file tool", () => {
     });
   });
   describe("File Modification Detection - New Files", () => {
-    it("should expand home-directory shorthand when creating a file", async () => {
+    it("should create a workspace-relative file", async () => {
       const homeTempDir = await fs.mkdtemp(
         path.join(os.homedir(), ".dexto-write-home-test-")
       );
-      const homeRelativeDir = `~/${path.basename(homeTempDir)}`;
       const fileSystemServiceForHome = new FileSystemService(
         {
           allowedPaths: [homeTempDir],
@@ -191,14 +438,18 @@ describe("write_file tool", () => {
       const tool = createWriteFileTool(async () => fileSystemServiceForHome);
       try {
         const parsedInput = tool.inputSchema.parse({
-          file_path: `${homeRelativeDir}/nested/new-file.txt`,
-          content: "brand new content",
-          create_dirs: true
+          file_path: "nested/new-file.txt",
+          content: "brand new content"
         });
-        const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+        const result = await tool.execute(
+          parsedInput,
+          createToolContext(mockLogger, {}, homeTempDir)
+        );
         expect(result.success).toBe(true);
-        expect(result.path).toBe(path.join(homeTempDir, "nested", "new-file.txt"));
-        expect(await fs.readFile(result.path, "utf-8")).toBe("brand new content");
+        expect(result.path).toBe("nested/new-file.txt");
+        expect(await fs.readFile(path.join(homeTempDir, result.path), "utf-8")).toBe(
+          "brand new content"
+        );
       } finally {
         await fs.rm(homeTempDir, { recursive: true, force: true });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-filesystem",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "FileSystem tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,8 +22,8 @@
     "glob": "^12.0.0",
     "safe-regex": "^2.1.1",
     "zod": "^4.3.6",
-    "@dexto/agent-config": "1.7.1",
-    "@dexto/core": "1.7.1"
+    "@dexto/agent-config": "1.8.0",
+    "@dexto/core": "1.8.0"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",