@dexto/tools-builtins 1.10.4 → 1.11.0

package/dist/builtin-tools-factory.cjs

@@ -27,8 +27,7 @@ var import_zod = require("zod");
 var import_ask_user_tool = require("./implementations/ask-user-tool.js");
 var import_delegate_to_url_tool = require("./implementations/delegate-to-url-tool.js");
 var import_get_resource_tool = require("./implementations/get-resource-tool.js");
-var import_invoke_skill_tool = require("./implementations/invoke-skill-tool.js");
-var import_read_skill_tool = require("./implementations/read-skill-tool.js");
+var import_skill_load_tool = require("./implementations/skill-load-tool.js");
 var import_list_resources_tool = require("./implementations/list-resources-tool.js");
 var import_http_request_tool = require("./implementations/http-request-tool.js");
 var import_sleep_tool = require("./implementations/sleep-tool.js");
@@ -39,8 +38,7 @@ const BUILTIN_TOOL_NAMES = [
   "delegate_to_url",
   "list_resources",
   "get_resource",
-  "invoke_skill",
-  "read_skill",
+  "skill_load",
   "http_request",
   "sleep",
   "web_search",
@@ -61,10 +59,8 @@ function createToolByName(name) {
       return (0, import_list_resources_tool.createListResourcesTool)();
     case "get_resource":
       return (0, import_get_resource_tool.createGetResourceTool)();
-    case "invoke_skill":
-      return (0, import_invoke_skill_tool.createInvokeSkillTool)();
-    case "read_skill":
-      return (0, import_read_skill_tool.createReadSkillTool)();
+    case "skill_load":
+      return (0, import_skill_load_tool.createSkillLoadTool)();
     case "http_request":
       return (0, import_http_request_tool.createHttpRequestTool)();
     case "sleep":

package/dist/builtin-tools-factory.d.ts

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

package/dist/builtin-tools-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtin-tools-factory.d.ts","sourceRoot":"","sources":["../src/builtin-tools-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAavD,eAAO,MAAM,kBAAkB,gKAWrB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAIlE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;kBAKxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AA+B3E,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,kBAAkB,CAW/D,CAAC"}
+{"version":3,"file":"builtin-tools-factory.d.ts","sourceRoot":"","sources":["../src/builtin-tools-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAYvD,eAAO,MAAM,kBAAkB,gJAUrB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAIlE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;kBAKxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AA6B3E,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,kBAAkB,CAW/D,CAAC"}

package/dist/builtin-tools-factory.js

@@ -2,8 +2,7 @@ import { z } from "zod";
 import { createAskUserTool } from "./implementations/ask-user-tool.js";
 import { createDelegateToUrlTool } from "./implementations/delegate-to-url-tool.js";
 import { createGetResourceTool } from "./implementations/get-resource-tool.js";
-import { createInvokeSkillTool } from "./implementations/invoke-skill-tool.js";
-import { createReadSkillTool } from "./implementations/read-skill-tool.js";
+import { createSkillLoadTool } from "./implementations/skill-load-tool.js";
 import { createListResourcesTool } from "./implementations/list-resources-tool.js";
 import { createHttpRequestTool } from "./implementations/http-request-tool.js";
 import { createSleepTool } from "./implementations/sleep-tool.js";
@@ -14,8 +13,7 @@ const BUILTIN_TOOL_NAMES = [
   "delegate_to_url",
   "list_resources",
   "get_resource",
-  "invoke_skill",
-  "read_skill",
+  "skill_load",
   "http_request",
   "sleep",
   "web_search",
@@ -36,10 +34,8 @@ function createToolByName(name) {
       return createListResourcesTool();
     case "get_resource":
       return createGetResourceTool();
-    case "invoke_skill":
-      return createInvokeSkillTool();
-    case "read_skill":
-      return createReadSkillTool();
+    case "skill_load":
+      return createSkillLoadTool();
     case "http_request":
       return createHttpRequestTool();
     case "sleep":

package/dist/builtin-tools-factory.test.cjs

@@ -9,8 +9,7 @@ var import_builtin_tools_factory = require("./builtin-tools-factory.js");
       "delegate_to_url",
       "list_resources",
       "get_resource",
-      "invoke_skill",
-      "read_skill",
+      "skill_load",
       "http_request",
       "sleep",
       "web_search",
@@ -20,8 +19,8 @@ var import_builtin_tools_factory = require("./builtin-tools-factory.js");
   (0, import_vitest.it)("creates only the selected builtins when enabledTools is provided", () => {
     const tools = import_builtin_tools_factory.builtinToolsFactory.create({
       type: "builtin-tools",
-      enabledTools: ["ask_user", "read_skill"]
+      enabledTools: ["ask_user", "skill_load"]
     });
-    (0, import_vitest.expect)(tools.map((t) => t.id)).toEqual(["ask_user", "read_skill"]);
+    (0, import_vitest.expect)(tools.map((t) => t.id)).toEqual(["ask_user", "skill_load"]);
   });
 });

package/dist/builtin-tools-factory.test.js

@@ -8,8 +8,7 @@ describe("builtinToolsFactory", () => {
       "delegate_to_url",
       "list_resources",
       "get_resource",
-      "invoke_skill",
-      "read_skill",
+      "skill_load",
       "http_request",
       "sleep",
       "web_search",
@@ -19,8 +18,8 @@ describe("builtinToolsFactory", () => {
   it("creates only the selected builtins when enabledTools is provided", () => {
     const tools = builtinToolsFactory.create({
       type: "builtin-tools",
-      enabledTools: ["ask_user", "read_skill"]
+      enabledTools: ["ask_user", "skill_load"]
     });
-    expect(tools.map((t) => t.id)).toEqual(["ask_user", "read_skill"]);
+    expect(tools.map((t) => t.id)).toEqual(["ask_user", "skill_load"]);
   });
 });

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

@@ -0,0 +1,100 @@
+"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 skill_load_tool_exports = {};
+__export(skill_load_tool_exports, {
+  createSkillLoadTool: () => createSkillLoadTool
+});
+module.exports = __toCommonJS(skill_load_tool_exports);
+var import_core = require("@dexto/core");
+var import_tools = require("@dexto/core/tools");
+async function unavailableSkillResult(skills, error, hint) {
+  let availableSkills;
+  try {
+    availableSkills = (await skills.list()).map((skill) => skill.name);
+  } catch {
+  }
+  return {
+    error,
+    ...availableSkills === void 0 ? {} : { availableSkills },
+    _hint: hint
+  };
+}
+function createSkillLoadTool() {
+  return (0, import_tools.defineTool)({
+    id: "skill_load",
+    description: `Load one exact Skill by name.
+
+Without a path, this returns the Skill instructions and the location of its supporting files. With
+a path, it reads one supporting text file relative to that Skill. Use the exact name from the
+available Skills list; names are not aliases.`,
+    inputSchema: import_core.SkillLoadInputSchema,
+    presentation: {
+      activity: import_tools.TOOL_ACTIVITY.useSkill,
+      describeHeader: (input) => (0, import_tools.createLocalToolCallHeader)({
+        title: "Load Skill",
+        argsText: input.path ? `${input.name}/${input.path}` : input.name
+      })
+    },
+    async execute(input, context) {
+      const skills = context.services?.skills;
+      if (!skills) {
+        throw import_tools.ToolError.configInvalid(
+          "skill_load requires ToolExecutionContext.services.skills"
+        );
+      }
+      if (input.path) {
+        try {
+          const content = await skills.readFile(input.name, input.path);
+          return {
+            name: input.name,
+            path: input.path,
+            content
+          };
+        } catch {
+          return unavailableSkillResult(
+            skills,
+            `Skill file unavailable: ${input.name}/${input.path}`,
+            "Use a valid relative file path from the selected Skill."
+          );
+        }
+      }
+      try {
+        const loaded = await skills.load(input.name);
+        if (loaded) {
+          return loaded;
+        }
+      } catch {
+        return unavailableSkillResult(
+          skills,
+          `Skill unavailable: ${input.name}`,
+          "Use the exact name from the available Skills list."
+        );
+      }
+      return unavailableSkillResult(
+        skills,
+        `Skill unavailable: ${input.name}`,
+        "Use the exact name from the available Skills list."
+      );
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSkillLoadTool
+});

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

@@ -0,0 +1,4 @@
+import { SkillLoadInputSchema } from '@dexto/core';
+import type { Tool } from '@dexto/core/tools';
+export declare function createSkillLoadTool(): Tool<typeof SkillLoadInputSchema>;
+//# sourceMappingURL=skill-load-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill-load-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/skill-load-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,mBAAmB,CAAC;AAsBpE,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,OAAO,oBAAoB,CAAC,CA8DvE"}

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

@@ -0,0 +1,76 @@
+import { SkillLoadInputSchema } from "@dexto/core";
+import { TOOL_ACTIVITY, ToolError, createLocalToolCallHeader, defineTool } from "@dexto/core/tools";
+async function unavailableSkillResult(skills, error, hint) {
+  let availableSkills;
+  try {
+    availableSkills = (await skills.list()).map((skill) => skill.name);
+  } catch {
+  }
+  return {
+    error,
+    ...availableSkills === void 0 ? {} : { availableSkills },
+    _hint: hint
+  };
+}
+function createSkillLoadTool() {
+  return defineTool({
+    id: "skill_load",
+    description: `Load one exact Skill by name.
+
+Without a path, this returns the Skill instructions and the location of its supporting files. With
+a path, it reads one supporting text file relative to that Skill. Use the exact name from the
+available Skills list; names are not aliases.`,
+    inputSchema: SkillLoadInputSchema,
+    presentation: {
+      activity: TOOL_ACTIVITY.useSkill,
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Load Skill",
+        argsText: input.path ? `${input.name}/${input.path}` : input.name
+      })
+    },
+    async execute(input, context) {
+      const skills = context.services?.skills;
+      if (!skills) {
+        throw ToolError.configInvalid(
+          "skill_load requires ToolExecutionContext.services.skills"
+        );
+      }
+      if (input.path) {
+        try {
+          const content = await skills.readFile(input.name, input.path);
+          return {
+            name: input.name,
+            path: input.path,
+            content
+          };
+        } catch {
+          return unavailableSkillResult(
+            skills,
+            `Skill file unavailable: ${input.name}/${input.path}`,
+            "Use a valid relative file path from the selected Skill."
+          );
+        }
+      }
+      try {
+        const loaded = await skills.load(input.name);
+        if (loaded) {
+          return loaded;
+        }
+      } catch {
+        return unavailableSkillResult(
+          skills,
+          `Skill unavailable: ${input.name}`,
+          "Use the exact name from the available Skills list."
+        );
+      }
+      return unavailableSkillResult(
+        skills,
+        `Skill unavailable: ${input.name}`,
+        "Use the exact name from the available Skills list."
+      );
+    }
+  });
+}
+export {
+  createSkillLoadTool
+};

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

@@ -0,0 +1,73 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_skill_load_tool = require("./skill-load-tool.js");
+(0, import_vitest.describe)("skill_load tool", () => {
+  (0, import_vitest.it)("loads one exact skill without listing the skill catalog", async () => {
+    const skills = {
+      list: import_vitest.vi.fn(),
+      load: import_vitest.vi.fn().mockResolvedValue({
+        name: "alpha",
+        instructions: "Use alpha instructions.",
+        supportingFiles: [],
+        filesLocation: "hosted",
+        baseDirectory: null
+      }),
+      readFile: import_vitest.vi.fn()
+    };
+    const tool = (0, import_skill_load_tool.createSkillLoadTool)();
+    const result = await tool.execute({ name: "alpha" }, {
+      services: { skills }
+    });
+    (0, import_vitest.expect)(skills.load).toHaveBeenCalledWith("alpha");
+    (0, import_vitest.expect)(skills.list).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(result).toEqual({
+      name: "alpha",
+      instructions: "Use alpha instructions.",
+      supportingFiles: [],
+      filesLocation: "hosted",
+      baseDirectory: null
+    });
+  });
+  (0, import_vitest.it)("returns a structured unavailable result when loading fails", async () => {
+    const skills = {
+      list: import_vitest.vi.fn().mockResolvedValue([
+        { name: "alpha", description: "Alpha instructions" },
+        { name: "beta", description: "Beta instructions" }
+      ]),
+      load: import_vitest.vi.fn().mockRejectedValue(new Error("release unavailable")),
+      readFile: import_vitest.vi.fn()
+    };
+    const result = await (0, import_skill_load_tool.createSkillLoadTool)().execute({ name: "missing" }, {
+      services: { skills }
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      error: "Skill unavailable: missing",
+      availableSkills: ["alpha", "beta"],
+      _hint: "Use the exact name from the available Skills list."
+    });
+  });
+  (0, import_vitest.it)("reads a supporting file and isolates file failures", async () => {
+    const skills = {
+      list: import_vitest.vi.fn().mockResolvedValue([{ name: "alpha", description: "Alpha instructions" }]),
+      load: import_vitest.vi.fn(),
+      readFile: import_vitest.vi.fn().mockResolvedValueOnce("Checklist").mockRejectedValueOnce(new Error("artifact unavailable"))
+    };
+    const tool = (0, import_skill_load_tool.createSkillLoadTool)();
+    const context = { services: { skills } };
+    await (0, import_vitest.expect)(
+      tool.execute({ name: "alpha", path: "references/checklist.md" }, context)
+    ).resolves.toEqual({
+      name: "alpha",
+      path: "references/checklist.md",
+      content: "Checklist"
+    });
+    await (0, import_vitest.expect)(
+      tool.execute({ name: "alpha", path: "references/missing.md" }, context)
+    ).resolves.toEqual({
+      error: "Skill file unavailable: alpha/references/missing.md",
+      availableSkills: ["alpha"],
+      _hint: "Use a valid relative file path from the selected Skill."
+    });
+    (0, import_vitest.expect)(skills.load).not.toHaveBeenCalled();
+  });
+});

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

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

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

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

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

@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from "vitest";
+import { createSkillLoadTool } from "./skill-load-tool.js";
+describe("skill_load tool", () => {
+  it("loads one exact skill without listing the skill catalog", async () => {
+    const skills = {
+      list: vi.fn(),
+      load: vi.fn().mockResolvedValue({
+        name: "alpha",
+        instructions: "Use alpha instructions.",
+        supportingFiles: [],
+        filesLocation: "hosted",
+        baseDirectory: null
+      }),
+      readFile: vi.fn()
+    };
+    const tool = createSkillLoadTool();
+    const result = await tool.execute({ name: "alpha" }, {
+      services: { skills }
+    });
+    expect(skills.load).toHaveBeenCalledWith("alpha");
+    expect(skills.list).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      name: "alpha",
+      instructions: "Use alpha instructions.",
+      supportingFiles: [],
+      filesLocation: "hosted",
+      baseDirectory: null
+    });
+  });
+  it("returns a structured unavailable result when loading fails", async () => {
+    const skills = {
+      list: vi.fn().mockResolvedValue([
+        { name: "alpha", description: "Alpha instructions" },
+        { name: "beta", description: "Beta instructions" }
+      ]),
+      load: vi.fn().mockRejectedValue(new Error("release unavailable")),
+      readFile: vi.fn()
+    };
+    const result = await createSkillLoadTool().execute({ name: "missing" }, {
+      services: { skills }
+    });
+    expect(result).toEqual({
+      error: "Skill unavailable: missing",
+      availableSkills: ["alpha", "beta"],
+      _hint: "Use the exact name from the available Skills list."
+    });
+  });
+  it("reads a supporting file and isolates file failures", async () => {
+    const skills = {
+      list: vi.fn().mockResolvedValue([{ name: "alpha", description: "Alpha instructions" }]),
+      load: vi.fn(),
+      readFile: vi.fn().mockResolvedValueOnce("Checklist").mockRejectedValueOnce(new Error("artifact unavailable"))
+    };
+    const tool = createSkillLoadTool();
+    const context = { services: { skills } };
+    await expect(
+      tool.execute({ name: "alpha", path: "references/checklist.md" }, context)
+    ).resolves.toEqual({
+      name: "alpha",
+      path: "references/checklist.md",
+      content: "Checklist"
+    });
+    await expect(
+      tool.execute({ name: "alpha", path: "references/missing.md" }, context)
+    ).resolves.toEqual({
+      error: "Skill file unavailable: alpha/references/missing.md",
+      availableSkills: ["alpha"],
+      _hint: "Use a valid relative file path from the selected Skill."
+    });
+    expect(skills.load).not.toHaveBeenCalled();
+  });
+});

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", "read_skill", "http_request", "sleep", "web_search", "code_search"];
+declare const BUILTIN_TOOL_NAMES: readonly ["ask_user", "delegate_to_url", "list_resources", "get_resource", "skill_load", "http_request", "sleep", "web_search", "code_search"];
 type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 declare const BuiltinToolsConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"builtin-tools">;
@@ -9,8 +9,7 @@ declare const BuiltinToolsConfigSchema: z.ZodObject<{
         ask_user: "ask_user";
         delegate_to_url: "delegate_to_url";
         get_resource: "get_resource";
-        invoke_skill: "invoke_skill";
-        read_skill: "read_skill";
+        skill_load: "skill_load";
         list_resources: "list_resources";
         http_request: "http_request";
         sleep: "sleep";

package/dist/index.d.ts

@@ -9,8 +9,7 @@
  * - delegate_to_url
  * - list_resources
  * - get_resource
- * - invoke_skill
- * - read_skill
+ * - skill_load
  */
 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;;;;;;;;;;;;;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"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-builtins",
-  "version": "1.10.4",
+  "version": "1.11.0",
   "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.10.4",
-    "@dexto/core": "1.10.4"
+    "@dexto/agent-config": "1.11.0",
+    "@dexto/core": "1.11.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0",

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

@@ -1,92 +0,0 @@
-"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 invoke_skill_tool_exports = {};
-__export(invoke_skill_tool_exports, {
-  createInvokeSkillTool: () => createInvokeSkillTool
-});
-module.exports = __toCommonJS(invoke_skill_tool_exports);
-var import_zod = require("zod");
-var import_tools = require("@dexto/core/tools");
-const InvokeSkillInputSchema = import_zod.z.object({
-  skill: import_zod.z.string().min(1, "Skill name is required").describe(
-    'The name of the skill to invoke (e.g., "plugin-name:skill-name" or "skill-name")'
-  ),
-  args: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().describe("Optional arguments to pass to the skill"),
-  taskContext: import_zod.z.string().optional().describe("Context about what task this skill should accomplish")
-}).strict();
-function createInvokeSkillTool() {
-  return (0, import_tools.defineTool)({
-    id: "invoke_skill",
-    description: buildToolDescription(),
-    inputSchema: InvokeSkillInputSchema,
-    presentation: {
-      activity: import_tools.TOOL_ACTIVITY.useSkill,
-      describeHeader: (input) => {
-        const colonIndex = input.skill.indexOf(":");
-        const displaySkillName = colonIndex >= 0 ? input.skill.slice(colonIndex + 1) : input.skill;
-        return (0, import_tools.createLocalToolCallHeader)({
-          title: "Skill",
-          argsText: `/${displaySkillName}`
-        });
-      }
-    },
-    async execute(input, context) {
-      const skillManager = context.services?.skills;
-      if (!skillManager) {
-        throw import_tools.ToolError.configInvalid(
-          "invoke_skill requires ToolExecutionContext.services.skills"
-        );
-      }
-      const invoked = await skillManager.invoke(input.skill, input.args);
-      if (!invoked) {
-        const availableSkills = (await skillManager.list()).map(
-          (availableSkill) => availableSkill.displayName
-        );
-        return {
-          error: `Skill '${input.skill}' not found or not available for model invocation. Use a skill from the available list.`,
-          availableSkills
-        };
-      }
-      const content = input.taskContext ? `## Task Context
-${input.taskContext}
-
-## Skill Instructions
-${invoked.instructions}` : invoked.instructions;
-      return {
-        skill: invoked.id,
-        content,
-        instructions: "Follow the instructions in the skill content above to complete the task."
-      };
-    }
-  });
-}
-function buildToolDescription() {
-  return `Invoke a skill to load specialized instructions for a task.
-
-When to use:
-- When you recognize a task that matches an available skill
-- When you need specialized guidance for a complex operation
-- When the user references a skill by name
-
-Available skills are listed in your system prompt. Use the skill name exactly as shown.`;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createInvokeSkillTool
-});

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

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-import type { Tool } from '@dexto/core/tools';
-declare const InvokeSkillInputSchema: z.ZodObject<{
-    skill: z.ZodString;
-    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    taskContext: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare function createInvokeSkillTool(): Tool<typeof InvokeSkillInputSchema>;
-export {};
-//# sourceMappingURL=invoke-skill-tool.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"invoke-skill-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/invoke-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,sBAAsB;;;;kBAiBf,CAAC;AAEd,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAiD3E"}

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

@@ -1,68 +0,0 @@
-import { z } from "zod";
-import { TOOL_ACTIVITY, ToolError, createLocalToolCallHeader, defineTool } from "@dexto/core/tools";
-const InvokeSkillInputSchema = z.object({
-  skill: z.string().min(1, "Skill name is required").describe(
-    'The name of the skill to invoke (e.g., "plugin-name:skill-name" or "skill-name")'
-  ),
-  args: z.record(z.string(), z.string()).optional().describe("Optional arguments to pass to the skill"),
-  taskContext: z.string().optional().describe("Context about what task this skill should accomplish")
-}).strict();
-function createInvokeSkillTool() {
-  return defineTool({
-    id: "invoke_skill",
-    description: buildToolDescription(),
-    inputSchema: InvokeSkillInputSchema,
-    presentation: {
-      activity: TOOL_ACTIVITY.useSkill,
-      describeHeader: (input) => {
-        const colonIndex = input.skill.indexOf(":");
-        const displaySkillName = colonIndex >= 0 ? input.skill.slice(colonIndex + 1) : input.skill;
-        return createLocalToolCallHeader({
-          title: "Skill",
-          argsText: `/${displaySkillName}`
-        });
-      }
-    },
-    async execute(input, context) {
-      const skillManager = context.services?.skills;
-      if (!skillManager) {
-        throw ToolError.configInvalid(
-          "invoke_skill requires ToolExecutionContext.services.skills"
-        );
-      }
-      const invoked = await skillManager.invoke(input.skill, input.args);
-      if (!invoked) {
-        const availableSkills = (await skillManager.list()).map(
-          (availableSkill) => availableSkill.displayName
-        );
-        return {
-          error: `Skill '${input.skill}' not found or not available for model invocation. Use a skill from the available list.`,
-          availableSkills
-        };
-      }
-      const content = input.taskContext ? `## Task Context
-${input.taskContext}
-
-## Skill Instructions
-${invoked.instructions}` : invoked.instructions;
-      return {
-        skill: invoked.id,
-        content,
-        instructions: "Follow the instructions in the skill content above to complete the task."
-      };
-    }
-  });
-}
-function buildToolDescription() {
-  return `Invoke a skill to load specialized instructions for a task.
-
-When to use:
-- When you recognize a task that matches an available skill
-- When you need specialized guidance for a complex operation
-- When the user references a skill by name
-
-Available skills are listed in your system prompt. Use the skill name exactly as shown.`;
-}
-export {
-  createInvokeSkillTool
-};

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

@@ -1,98 +0,0 @@
-"use strict";
-var import_vitest = require("vitest");
-var import_invoke_skill_tool = require("./invoke-skill-tool.js");
-(0, import_vitest.describe)("invoke_skill tool", () => {
-  (0, import_vitest.it)("invokes skills through SkillManager", async () => {
-    const skillManager = {
-      list: import_vitest.vi.fn().mockResolvedValue([
-        { id: "alpha", displayName: "Alpha", description: "Use alpha" }
-      ]),
-      invoke: import_vitest.vi.fn().mockResolvedValue({
-        id: "alpha",
-        displayName: "Alpha",
-        instructions: "Use alpha instructions."
-      })
-    };
-    const tool = (0, import_invoke_skill_tool.createInvokeSkillTool)();
-    const result = await tool.execute(
-      {
-        skill: "Alpha",
-        args: { mode: "fast" }
-      },
-      {
-        logger: {
-          warn: import_vitest.vi.fn()
-        },
-        services: {
-          skills: skillManager
-        }
-      }
-    );
-    (0, import_vitest.expect)(skillManager.invoke).toHaveBeenCalledWith("Alpha", { mode: "fast" });
-    (0, import_vitest.expect)(result).toEqual({
-      skill: "alpha",
-      content: "Use alpha instructions.",
-      instructions: "Follow the instructions in the skill content above to complete the task."
-    });
-  });
-  (0, import_vitest.it)("adds task context to returned skill instructions", async () => {
-    const skillManager = {
-      list: import_vitest.vi.fn(),
-      invoke: import_vitest.vi.fn().mockResolvedValue({
-        id: "alpha",
-        displayName: "Alpha",
-        instructions: "Use alpha instructions."
-      })
-    };
-    const tool = (0, import_invoke_skill_tool.createInvokeSkillTool)();
-    const result = await tool.execute(
-      {
-        skill: "Alpha",
-        taskContext: "Refactor the storage layer."
-      },
-      {
-        logger: {
-          warn: import_vitest.vi.fn()
-        },
-        services: {
-          skills: skillManager
-        }
-      }
-    );
-    (0, import_vitest.expect)(result).toMatchObject({
-      content: "## Task Context\nRefactor the storage layer.\n\n## Skill Instructions\nUse alpha instructions."
-    });
-  });
-  (0, import_vitest.it)("returns available skills when the requested skill is missing", async () => {
-    const skillManager = {
-      list: import_vitest.vi.fn().mockResolvedValue([
-        { id: "alpha", displayName: "Alpha" },
-        { id: "beta", displayName: "Beta" }
-      ]),
-      invoke: import_vitest.vi.fn().mockResolvedValue(null)
-    };
-    const tool = (0, import_invoke_skill_tool.createInvokeSkillTool)();
-    const result = await tool.execute({ skill: "missing" }, {
-      logger: {
-        warn: import_vitest.vi.fn()
-      },
-      services: {
-        skills: skillManager
-      }
-    });
-    (0, import_vitest.expect)(result).toEqual({
-      error: "Skill 'missing' not found or not available for model invocation. Use a skill from the available list.",
-      availableSkills: ["Alpha", "Beta"]
-    });
-  });
-  (0, import_vitest.it)("requires ToolExecutionContext.services.skills", async () => {
-    const tool = (0, import_invoke_skill_tool.createInvokeSkillTool)();
-    await (0, import_vitest.expect)(
-      tool.execute({ skill: "alpha" }, {
-        logger: {
-          warn: import_vitest.vi.fn()
-        }
-      })
-    ).rejects.toThrow("invoke_skill requires ToolExecutionContext.services.skills");
-  });
-});

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

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

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

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

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

@@ -1,97 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createInvokeSkillTool } from "./invoke-skill-tool.js";
-describe("invoke_skill tool", () => {
-  it("invokes skills through SkillManager", async () => {
-    const skillManager = {
-      list: vi.fn().mockResolvedValue([
-        { id: "alpha", displayName: "Alpha", description: "Use alpha" }
-      ]),
-      invoke: vi.fn().mockResolvedValue({
-        id: "alpha",
-        displayName: "Alpha",
-        instructions: "Use alpha instructions."
-      })
-    };
-    const tool = createInvokeSkillTool();
-    const result = await tool.execute(
-      {
-        skill: "Alpha",
-        args: { mode: "fast" }
-      },
-      {
-        logger: {
-          warn: vi.fn()
-        },
-        services: {
-          skills: skillManager
-        }
-      }
-    );
-    expect(skillManager.invoke).toHaveBeenCalledWith("Alpha", { mode: "fast" });
-    expect(result).toEqual({
-      skill: "alpha",
-      content: "Use alpha instructions.",
-      instructions: "Follow the instructions in the skill content above to complete the task."
-    });
-  });
-  it("adds task context to returned skill instructions", async () => {
-    const skillManager = {
-      list: vi.fn(),
-      invoke: vi.fn().mockResolvedValue({
-        id: "alpha",
-        displayName: "Alpha",
-        instructions: "Use alpha instructions."
-      })
-    };
-    const tool = createInvokeSkillTool();
-    const result = await tool.execute(
-      {
-        skill: "Alpha",
-        taskContext: "Refactor the storage layer."
-      },
-      {
-        logger: {
-          warn: vi.fn()
-        },
-        services: {
-          skills: skillManager
-        }
-      }
-    );
-    expect(result).toMatchObject({
-      content: "## Task Context\nRefactor the storage layer.\n\n## Skill Instructions\nUse alpha instructions."
-    });
-  });
-  it("returns available skills when the requested skill is missing", async () => {
-    const skillManager = {
-      list: vi.fn().mockResolvedValue([
-        { id: "alpha", displayName: "Alpha" },
-        { id: "beta", displayName: "Beta" }
-      ]),
-      invoke: vi.fn().mockResolvedValue(null)
-    };
-    const tool = createInvokeSkillTool();
-    const result = await tool.execute({ skill: "missing" }, {
-      logger: {
-        warn: vi.fn()
-      },
-      services: {
-        skills: skillManager
-      }
-    });
-    expect(result).toEqual({
-      error: "Skill 'missing' not found or not available for model invocation. Use a skill from the available list.",
-      availableSkills: ["Alpha", "Beta"]
-    });
-  });
-  it("requires ToolExecutionContext.services.skills", async () => {
-    const tool = createInvokeSkillTool();
-    await expect(
-      tool.execute({ skill: "alpha" }, {
-        logger: {
-          warn: vi.fn()
-        }
-      })
-    ).rejects.toThrow("invoke_skill requires ToolExecutionContext.services.skills");
-  });
-});

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

@@ -1,90 +0,0 @@
-"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: {
-      activity: import_tools.TOOL_ACTIVITY.readSkill,
-      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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,66 +0,0 @@
-import { z } from "zod";
-import { TOOL_ACTIVITY, 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: {
-      activity: TOOL_ACTIVITY.readSkill,
-      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

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

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

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

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

@@ -1,81 +0,0 @@
-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
-    });
-  });
-});