@dexto/tools-builtins 1.7.2 → 1.8.1

package/dist/implementations/list-resources-tool.cjs

@@ -22,7 +22,7 @@ __export(list_resources_tool_exports, {
 });
 module.exports = __toCommonJS(list_resources_tool_exports);
 var import_zod = require("zod");
-var import_core = require("@dexto/core");
+var import_tools = require("@dexto/core/tools");
 const ListResourcesInputSchema = import_zod.z.object({
   source: import_zod.z.enum(["all", "tool", "user"]).optional().default("all").describe(
     'Filter by source: "tool" for tool-generated resources, "user" for user-uploaded, "all" for both'
@@ -31,7 +31,7 @@ const ListResourcesInputSchema = import_zod.z.object({
   limit: import_zod.z.number().optional().default(50).describe("Maximum number of resources to return (default: 50)")
 }).strict();
 function createListResourcesTool() {
-  return (0, import_core.defineTool)({
+  return (0, import_tools.defineTool)({
     id: "list_resources",
     description: "List available resources (images, files, etc.). Returns resource references that can be used with get_resource to obtain shareable URLs or metadata. Filter by source (tool/user) or kind (image/audio/video/binary).",
     inputSchema: ListResourcesInputSchema,
@@ -41,7 +41,7 @@ function createListResourcesTool() {
         if (input.source && input.source !== "all") parts.push(`source=${input.source}`);
         if (input.kind && input.kind !== "all") parts.push(`kind=${input.kind}`);
         if (typeof input.limit === "number") parts.push(`limit=${input.limit}`);
-        return (0, import_core.createLocalToolCallHeader)({
+        return (0, import_tools.createLocalToolCallHeader)({
           title: "List Resources",
           ...parts.length > 0 ? { argsText: parts.join(", ") } : {}
         });
@@ -51,22 +51,22 @@ function createListResourcesTool() {
       const { source, kind, limit } = input;
       const resourceManager = context.services?.resources;
       if (!resourceManager) {
-        throw import_core.ToolError.configInvalid(
+        throw import_tools.ToolError.configInvalid(
           "list_resources requires ToolExecutionContext.services.resources"
         );
       }
       try {
-        const blobStore = resourceManager.getBlobStore();
-        const allBlobs = await blobStore.listBlobs();
+        const artifactStore = resourceManager.getArtifactStore();
+        const artifacts = await artifactStore.listArtifacts();
         const resources = [];
-        for (const blob of allBlobs) {
-          if (blob.metadata.source === "system") {
+        for (const artifact of artifacts) {
+          if (artifact.metadata.source === "system") {
             continue;
           }
-          if (source !== "all" && blob.metadata.source !== source) {
+          if (source !== "all" && artifact.metadata.source !== source) {
             continue;
           }
-          const mimeType = blob.metadata.mimeType;
+          const mimeType = artifact.metadata.mimeType;
           let resourceKind = "binary";
           if (mimeType.startsWith("image/")) resourceKind = "image";
           else if (mimeType.startsWith("audio/")) resourceKind = "audio";
@@ -75,13 +75,15 @@ function createListResourcesTool() {
             continue;
           }
           resources.push({
-            reference: blob.uri,
+            reference: artifact.uri,
             kind: resourceKind,
-            mimeType: blob.metadata.mimeType,
-            ...blob.metadata.originalName && { filename: blob.metadata.originalName },
-            source: blob.metadata.source || "tool",
-            size: blob.metadata.size,
-            createdAt: blob.metadata.createdAt.toISOString()
+            mimeType: artifact.metadata.mimeType,
+            ...artifact.metadata.originalName && {
+              filename: artifact.metadata.originalName
+            },
+            source: artifact.metadata.source || "tool",
+            size: artifact.metadata.size,
+            createdAt: artifact.metadata.createdAt.toISOString()
           });
         }
         resources.sort(

package/dist/implementations/list-resources-tool.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { Tool } from '@dexto/core';
+import type { Tool } from '@dexto/core/tools';
 declare const ListResourcesInputSchema: z.ZodObject<{
     source: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         user: "user";
@@ -18,7 +18,7 @@ declare const ListResourcesInputSchema: z.ZodObject<{
 /**
  * Create the `list_resources` tool.
  *
- * Lists stored resources (backed by the configured BlobStore) and returns references
+ * Lists stored resources (backed by the configured artifact store) and returns references
  * that can be passed to `get_resource`.
  * Requires `ToolExecutionContext.services.resources`.
  */

package/dist/implementations/list-resources-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-resources-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/list-resources-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;kBAoBjB,CAAC;AAYd;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAAC,OAAO,wBAAwB,CAAC,CA0F/E"}
+{"version":3,"file":"list-resources-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/list-resources-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,mBAAmB,CAAC;AAEpE,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;kBAoBjB,CAAC;AAYd;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAAC,OAAO,wBAAwB,CAAC,CA4F/E"}

package/dist/implementations/list-resources-tool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ToolError, createLocalToolCallHeader, defineTool } from "@dexto/core";
+import { ToolError, createLocalToolCallHeader, defineTool } from "@dexto/core/tools";
 const ListResourcesInputSchema = z.object({
   source: z.enum(["all", "tool", "user"]).optional().default("all").describe(
     'Filter by source: "tool" for tool-generated resources, "user" for user-uploaded, "all" for both'
@@ -33,17 +33,17 @@ function createListResourcesTool() {
         );
       }
       try {
-        const blobStore = resourceManager.getBlobStore();
-        const allBlobs = await blobStore.listBlobs();
+        const artifactStore = resourceManager.getArtifactStore();
+        const artifacts = await artifactStore.listArtifacts();
         const resources = [];
-        for (const blob of allBlobs) {
-          if (blob.metadata.source === "system") {
+        for (const artifact of artifacts) {
+          if (artifact.metadata.source === "system") {
             continue;
           }
-          if (source !== "all" && blob.metadata.source !== source) {
+          if (source !== "all" && artifact.metadata.source !== source) {
             continue;
           }
-          const mimeType = blob.metadata.mimeType;
+          const mimeType = artifact.metadata.mimeType;
           let resourceKind = "binary";
           if (mimeType.startsWith("image/")) resourceKind = "image";
           else if (mimeType.startsWith("audio/")) resourceKind = "audio";
@@ -52,13 +52,15 @@ function createListResourcesTool() {
             continue;
           }
           resources.push({
-            reference: blob.uri,
+            reference: artifact.uri,
             kind: resourceKind,
-            mimeType: blob.metadata.mimeType,
-            ...blob.metadata.originalName && { filename: blob.metadata.originalName },
-            source: blob.metadata.source || "tool",
-            size: blob.metadata.size,
-            createdAt: blob.metadata.createdAt.toISOString()
+            mimeType: artifact.metadata.mimeType,
+            ...artifact.metadata.originalName && {
+              filename: artifact.metadata.originalName
+            },
+            source: artifact.metadata.source || "tool",
+            size: artifact.metadata.size,
+            createdAt: artifact.metadata.createdAt.toISOString()
           });
         }
         resources.sort(

package/dist/implementations/read-skill-tool.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var read_skill_tool_exports = {};
+__export(read_skill_tool_exports, {
+  createReadSkillTool: () => createReadSkillTool
+});
+module.exports = __toCommonJS(read_skill_tool_exports);
+var import_zod = require("zod");
+var import_tools = require("@dexto/core/tools");
+const ReadSkillInputSchema = import_zod.z.object({
+  skill: import_zod.z.string().min(1, "Skill name is required"),
+  path: import_zod.z.string().min(1).optional()
+}).strict();
+function createReadSkillTool() {
+  return (0, import_tools.defineTool)({
+    id: "read_skill",
+    description: "Read skill instructions or a file from a skill bundle. This is read-only and does not invoke the skill.",
+    inputSchema: ReadSkillInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_tools.createLocalToolCallHeader)({
+        title: "Read Skill",
+        argsText: input.path ? `${input.skill}/${input.path}` : input.skill
+      })
+    },
+    async execute(input, context) {
+      const skillManager = getSkillManager(context);
+      if (!skillManager) {
+        throw import_tools.ToolError.configInvalid(
+          "read_skill requires ToolExecutionContext.services.skills"
+        );
+      }
+      if (input.path) {
+        try {
+          const content = await skillManager.readFile(input.skill, input.path);
+          return {
+            success: true,
+            skill: input.skill,
+            path: input.path,
+            content
+          };
+        } catch {
+          return {
+            success: false,
+            error: `Skill file not found: ${input.skill}/${input.path}`,
+            _hint: "Use a valid file path from the skill bundle."
+          };
+        }
+      }
+      const skill = await skillManager.get(input.skill);
+      if (!skill) {
+        return {
+          success: false,
+          error: `Skill not found: ${input.skill}`,
+          _hint: "Use a skill from the available skills list."
+        };
+      }
+      return {
+        success: true,
+        skill: skill.id,
+        displayName: skill.displayName,
+        content: skill.instructions
+      };
+    }
+  });
+}
+function getSkillManager(context) {
+  const services = context.services;
+  return services?.skills;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReadSkillTool
+});

package/dist/implementations/read-skill-tool.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { Tool } from '@dexto/core/tools';
+declare const ReadSkillInputSchema: z.ZodObject<{
+    skill: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare function createReadSkillTool(): Tool<typeof ReadSkillInputSchema>;
+export {};
+//# sourceMappingURL=read-skill-tool.d.ts.map

package/dist/implementations/read-skill-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-skill-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/read-skill-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,mBAAmB,CAAC;AAapE,QAAA,MAAM,oBAAoB;;;kBAKb,CAAC;AAEd,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAwDvE"}

package/dist/implementations/read-skill-tool.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { ToolError, createLocalToolCallHeader, defineTool } from "@dexto/core/tools";
+const ReadSkillInputSchema = z.object({
+  skill: z.string().min(1, "Skill name is required"),
+  path: z.string().min(1).optional()
+}).strict();
+function createReadSkillTool() {
+  return defineTool({
+    id: "read_skill",
+    description: "Read skill instructions or a file from a skill bundle. This is read-only and does not invoke the skill.",
+    inputSchema: ReadSkillInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Read Skill",
+        argsText: input.path ? `${input.skill}/${input.path}` : input.skill
+      })
+    },
+    async execute(input, context) {
+      const skillManager = getSkillManager(context);
+      if (!skillManager) {
+        throw ToolError.configInvalid(
+          "read_skill requires ToolExecutionContext.services.skills"
+        );
+      }
+      if (input.path) {
+        try {
+          const content = await skillManager.readFile(input.skill, input.path);
+          return {
+            success: true,
+            skill: input.skill,
+            path: input.path,
+            content
+          };
+        } catch {
+          return {
+            success: false,
+            error: `Skill file not found: ${input.skill}/${input.path}`,
+            _hint: "Use a valid file path from the skill bundle."
+          };
+        }
+      }
+      const skill = await skillManager.get(input.skill);
+      if (!skill) {
+        return {
+          success: false,
+          error: `Skill not found: ${input.skill}`,
+          _hint: "Use a skill from the available skills list."
+        };
+      }
+      return {
+        success: true,
+        skill: skill.id,
+        displayName: skill.displayName,
+        content: skill.instructions
+      };
+    }
+  });
+}
+function getSkillManager(context) {
+  const services = context.services;
+  return services?.skills;
+}
+export {
+  createReadSkillTool
+};

package/dist/implementations/read-skill-tool.test.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var import_tools = require("@dexto/core/tools");
+var import_vitest = require("vitest");
+var import_read_skill_tool = require("./read-skill-tool.js");
+(0, import_vitest.describe)("read_skill tool", () => {
+  (0, import_vitest.it)("returns primary skill instructions when no path is provided", async () => {
+    const skills = {
+      get: import_vitest.vi.fn().mockResolvedValue({
+        id: "alpha",
+        displayName: "Alpha",
+        instructions: "Use alpha instructions."
+      })
+    };
+    const tool = (0, import_read_skill_tool.createReadSkillTool)();
+    const result = await tool.execute({ skill: "Alpha" }, {
+      services: { skills }
+    });
+    (0, import_vitest.expect)(skills.get).toHaveBeenCalledWith("Alpha");
+    (0, import_vitest.expect)(result).toEqual({
+      success: true,
+      skill: "alpha",
+      displayName: "Alpha",
+      content: "Use alpha instructions."
+    });
+  });
+  (0, import_vitest.it)("delegates file reads to SkillManager when path is provided", async () => {
+    const skills = {
+      get: import_vitest.vi.fn(),
+      readFile: import_vitest.vi.fn().mockResolvedValue("# Details\nUse more context.")
+    };
+    const tool = (0, import_read_skill_tool.createReadSkillTool)();
+    const result = await tool.execute({ skill: "Alpha", path: "docs/details.md" }, {
+      services: { skills }
+    });
+    (0, import_vitest.expect)(skills.get).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(skills.readFile).toHaveBeenCalledWith("Alpha", "docs/details.md");
+    (0, import_vitest.expect)(result).toEqual({
+      success: true,
+      skill: "Alpha",
+      path: "docs/details.md",
+      content: "# Details\nUse more context."
+    });
+  });
+  (0, import_vitest.it)("returns a structured error when the skill is missing", async () => {
+    const skills = {
+      get: import_vitest.vi.fn().mockResolvedValue(null)
+    };
+    const tool = (0, import_read_skill_tool.createReadSkillTool)();
+    const result = await tool.execute({ skill: "Missing" }, {
+      services: { skills }
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      success: false,
+      error: "Skill not found: Missing",
+      _hint: "Use a skill from the available skills list."
+    });
+  });
+  (0, import_vitest.it)("returns a structured error when a skill file is missing", async () => {
+    const skills = {
+      readFile: import_vitest.vi.fn().mockRejectedValue(new Error("Skill file not found"))
+    };
+    const tool = (0, import_read_skill_tool.createReadSkillTool)();
+    const result = await tool.execute({ skill: "Alpha", path: "missing.md" }, {
+      services: { skills }
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      success: false,
+      error: "Skill file not found: Alpha/missing.md",
+      _hint: "Use a valid file path from the skill bundle."
+    });
+  });
+  (0, import_vitest.it)("requires ToolExecutionContext.services.skills", async () => {
+    const tool = (0, import_read_skill_tool.createReadSkillTool)();
+    await (0, import_vitest.expect)(
+      tool.execute({ skill: "Alpha" }, {})
+    ).rejects.toMatchObject({
+      code: import_tools.ToolError.configInvalid(
+        "read_skill requires ToolExecutionContext.services.skills"
+      ).code
+    });
+  });
+});

package/dist/implementations/read-skill-tool.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=read-skill-tool.test.d.ts.map

package/dist/implementations/read-skill-tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-skill-tool.test.d.ts","sourceRoot":"","sources":["../../src/implementations/read-skill-tool.test.ts"],"names":[],"mappings":""}

package/dist/implementations/read-skill-tool.test.js

@@ -0,0 +1,81 @@
+import { ToolError } from "@dexto/core/tools";
+import { describe, expect, it, vi } from "vitest";
+import { createReadSkillTool } from "./read-skill-tool.js";
+describe("read_skill tool", () => {
+  it("returns primary skill instructions when no path is provided", async () => {
+    const skills = {
+      get: vi.fn().mockResolvedValue({
+        id: "alpha",
+        displayName: "Alpha",
+        instructions: "Use alpha instructions."
+      })
+    };
+    const tool = createReadSkillTool();
+    const result = await tool.execute({ skill: "Alpha" }, {
+      services: { skills }
+    });
+    expect(skills.get).toHaveBeenCalledWith("Alpha");
+    expect(result).toEqual({
+      success: true,
+      skill: "alpha",
+      displayName: "Alpha",
+      content: "Use alpha instructions."
+    });
+  });
+  it("delegates file reads to SkillManager when path is provided", async () => {
+    const skills = {
+      get: vi.fn(),
+      readFile: vi.fn().mockResolvedValue("# Details\nUse more context.")
+    };
+    const tool = createReadSkillTool();
+    const result = await tool.execute({ skill: "Alpha", path: "docs/details.md" }, {
+      services: { skills }
+    });
+    expect(skills.get).not.toHaveBeenCalled();
+    expect(skills.readFile).toHaveBeenCalledWith("Alpha", "docs/details.md");
+    expect(result).toEqual({
+      success: true,
+      skill: "Alpha",
+      path: "docs/details.md",
+      content: "# Details\nUse more context."
+    });
+  });
+  it("returns a structured error when the skill is missing", async () => {
+    const skills = {
+      get: vi.fn().mockResolvedValue(null)
+    };
+    const tool = createReadSkillTool();
+    const result = await tool.execute({ skill: "Missing" }, {
+      services: { skills }
+    });
+    expect(result).toEqual({
+      success: false,
+      error: "Skill not found: Missing",
+      _hint: "Use a skill from the available skills list."
+    });
+  });
+  it("returns a structured error when a skill file is missing", async () => {
+    const skills = {
+      readFile: vi.fn().mockRejectedValue(new Error("Skill file not found"))
+    };
+    const tool = createReadSkillTool();
+    const result = await tool.execute({ skill: "Alpha", path: "missing.md" }, {
+      services: { skills }
+    });
+    expect(result).toEqual({
+      success: false,
+      error: "Skill file not found: Alpha/missing.md",
+      _hint: "Use a valid file path from the skill bundle."
+    });
+  });
+  it("requires ToolExecutionContext.services.skills", async () => {
+    const tool = createReadSkillTool();
+    await expect(
+      tool.execute({ skill: "Alpha" }, {})
+    ).rejects.toMatchObject({
+      code: ToolError.configInvalid(
+        "read_skill requires ToolExecutionContext.services.skills"
+      ).code
+    });
+  });
+});

package/dist/implementations/sleep-tool.cjs

@@ -22,17 +22,17 @@ __export(sleep_tool_exports, {
 });
 module.exports = __toCommonJS(sleep_tool_exports);
 var import_zod = require("zod");
-var import_core = require("@dexto/core");
+var import_tools = require("@dexto/core/tools");
 const SleepInputSchema = import_zod.z.object({
   ms: import_zod.z.number().int().positive().max(6e5).describe("Milliseconds to sleep (max 10 minutes)")
 }).strict();
 function createSleepTool() {
-  return (0, import_core.defineTool)({
+  return (0, import_tools.defineTool)({
     id: "sleep",
     description: "Pause execution for a specified number of milliseconds.",
     inputSchema: SleepInputSchema,
     presentation: {
-      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+      describeHeader: (input) => (0, import_tools.createLocalToolCallHeader)({
         title: "Sleep",
         argsText: `${input.ms}ms`
       })

package/dist/implementations/sleep-tool.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { Tool } from '@dexto/core';
+import type { Tool } from '@dexto/core/tools';
 declare const SleepInputSchema: z.ZodObject<{
     ms: z.ZodNumber;
 }, z.core.$strict>;

package/dist/implementations/sleep-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sleep-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/sleep-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,gBAAgB;;kBAST,CAAC;AAEd;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAkB/D"}
+{"version":3,"file":"sleep-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/sleep-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,mBAAmB,CAAC;AAEpE,QAAA,MAAM,gBAAgB;;kBAST,CAAC;AAEd;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAkB/D"}

package/dist/implementations/sleep-tool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { createLocalToolCallHeader, defineTool } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool } from "@dexto/core/tools";
 const SleepInputSchema = z.object({
   ms: z.number().int().positive().max(6e5).describe("Milliseconds to sleep (max 10 minutes)")
 }).strict();

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { ToolFactory } from '@dexto/agent-config';
 
-declare const BUILTIN_TOOL_NAMES: readonly ["ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill", "http_request", "sleep", "web_search", "code_search"];
+declare const BUILTIN_TOOL_NAMES: readonly ["ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill", "read_skill", "http_request", "sleep", "web_search", "code_search"];
 type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 declare const BuiltinToolsConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"builtin-tools">;
@@ -10,6 +10,7 @@ declare const BuiltinToolsConfigSchema: z.ZodObject<{
         delegate_to_url: "delegate_to_url";
         get_resource: "get_resource";
         invoke_skill: "invoke_skill";
+        read_skill: "read_skill";
         list_resources: "list_resources";
         http_request: "http_request";
         sleep: "sleep";

package/dist/index.d.ts

@@ -10,6 +10,7 @@
  * - list_resources
  * - get_resource
  * - invoke_skill
+ * - read_skill
  */
 export { builtinToolsFactory, BuiltinToolsConfigSchema } from './builtin-tools-factory.js';
 export { BUILTIN_TOOL_NAMES } from './builtin-tools-factory.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-builtins",
-  "version": "1.7.2",
+  "version": "1.8.1",
   "description": "Built-in tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,8 +19,8 @@
   "dependencies": {
     "undici": "^7.24.6",
     "zod": "^4.3.6",
-    "@dexto/agent-config": "1.7.2",
-    "@dexto/core": "1.7.2"
+    "@dexto/agent-config": "1.8.1",
+    "@dexto/core": "1.8.1"
   },
   "devDependencies": {
     "tsup": "^8.0.0",