@dexto/tools-builtins 1.7.2 → 1.8.0

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

@@ -1,13 +1,11 @@
 import { z } from "zod";
-import { ToolError, createLocalToolCallHeader, defineTool, flattenPromptResult } from "@dexto/core";
+import { 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. Recommended for forked skills to provide context since they run in isolation without conversation history."
-  )
+  taskContext: z.string().optional().describe("Context about what task this skill should accomplish")
 }).strict();
 function createInvokeSkillTool() {
   return defineTool({
@@ -16,9 +14,8 @@ function createInvokeSkillTool() {
     inputSchema: InvokeSkillInputSchema,
     presentation: {
       describeHeader: (input) => {
-        const skillName = input.skill;
-        const colonIndex = skillName.indexOf(":");
-        const displaySkillName = colonIndex >= 0 ? skillName.slice(colonIndex + 1) : skillName;
+        const colonIndex = input.skill.indexOf(":");
+        const displaySkillName = colonIndex >= 0 ? input.skill.slice(colonIndex + 1) : input.skill;
         return createLocalToolCallHeader({
           title: "Skill",
           argsText: `/${displaySkillName}`
@@ -26,113 +23,29 @@ function createInvokeSkillTool() {
       }
     },
     async execute(input, context) {
-      const { skill, args, taskContext } = input;
-      const promptManager = context.services?.prompts;
-      if (!promptManager) {
+      const skillManager = context.services?.skills;
+      if (!skillManager) {
         throw ToolError.configInvalid(
-          "invoke_skill requires ToolExecutionContext.services.prompts"
+          "invoke_skill requires ToolExecutionContext.services.skills"
         );
       }
-      const autoInvocable = await promptManager.listAutoInvocablePrompts();
-      let skillKey;
-      let matchedInfo;
-      for (const key of Object.keys(autoInvocable)) {
-        const info = autoInvocable[key];
-        if (!info) continue;
-        if (key === skill || info.displayName === skill || info.commandName === skill || info.name === skill) {
-          skillKey = key;
-          matchedInfo = info;
-          break;
-        }
-      }
-      if (!skillKey) {
-        return {
-          error: `Skill '${skill}' not found or not available for model invocation. Use a skill from the available list.`,
-          availableSkills: Object.keys(autoInvocable)
-        };
-      }
-      const toolkits = Array.isArray(matchedInfo?.metadata?.toolkits) ? (matchedInfo?.metadata?.toolkits).filter((toolkit) => typeof toolkit === "string").map((toolkit) => toolkit.trim()).filter((toolkit) => toolkit.length > 0) : [];
-      if (toolkits.length > 0) {
-        if (!context.agent?.loadToolkits) {
-          return {
-            error: `Skill '${skill}' requires toolkits (${toolkits.join(
-              ", "
-            )}), but this agent does not support dynamic tool loading.`,
-            toolkits
-          };
-        }
-        try {
-          await context.agent.loadToolkits(toolkits);
-        } catch (error) {
-          return {
-            error: error instanceof Error ? error.message : "Failed to load required toolkits",
-            toolkits
-          };
-        }
-      }
-      const promptDef = await promptManager.getPromptDefinition(skillKey);
-      const taskForker = context.services?.taskForker;
-      if (promptDef?.context === "fork" && !taskForker) {
+      const invoked = await skillManager.invoke(input.skill, input.args);
+      if (!invoked) {
+        const availableSkills = (await skillManager.list()).map(
+          (availableSkill) => availableSkill.displayName
+        );
         return {
-          error: `Skill '${skill}' requires fork execution (context: fork), but agent spawning is not available.`,
-          skill: skillKey
+          error: `Skill '${input.skill}' not found or not available for model invocation. Use a skill from the available list.`,
+          availableSkills
         };
       }
-      const skillMcpError = await ensureSkillMcpServersConnected(skill, matchedInfo, context);
-      if (skillMcpError) {
-        return skillMcpError;
-      }
-      if (promptDef?.context !== "fork" && promptDef?.allowedTools && promptDef.allowedTools.length > 0 && context.sessionId && context.agent?.toolManager) {
-        try {
-          context.agent.toolManager.addSessionAutoApproveTools(
-            context.sessionId,
-            promptDef.allowedTools
-          );
-        } catch (error) {
-          context.logger?.warn("Failed to add auto-approve tools for skill", {
-            tools: promptDef.allowedTools,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-      const promptResult = await promptManager.getPrompt(skillKey, args);
-      const flattened = flattenPromptResult(promptResult);
-      const content = flattened.text;
-      if (promptDef?.context === "fork") {
-        const activeTaskForker = taskForker;
-        if (!activeTaskForker) {
-          return {
-            error: `Skill '${skill}' requires fork execution (context: fork), but agent spawning is not available.`,
-            skill: skillKey
-          };
-        }
-        const instructions = taskContext ? `## Task Context
-${taskContext}
+      const content = input.taskContext ? `## Task Context
+${input.taskContext}
 
 ## Skill Instructions
-${content}` : content;
-        const forkOptions = {
-          task: `Skill: ${skill}`,
-          instructions,
-          autoApprove: true
-        };
-        if (promptDef.agent) {
-          forkOptions.agentId = promptDef.agent;
-        }
-        if (context.toolCallId) {
-          forkOptions.toolCallId = context.toolCallId;
-        }
-        if (context.sessionId) {
-          forkOptions.sessionId = context.sessionId;
-        }
-        const result = await activeTaskForker.fork(forkOptions);
-        if (result.success) {
-          return result.response ?? "Task completed successfully.";
-        }
-        return `Error: ${result.error ?? "Unknown error during forked execution"}`;
-      }
+${invoked.instructions}` : invoked.instructions;
       return {
-        skill: skillKey,
+        skill: invoked.id,
         content,
         instructions: "Follow the instructions in the skill content above to complete the task."
       };
@@ -140,76 +53,15 @@ ${content}` : content;
   });
 }
 function buildToolDescription() {
-  return `Invoke a skill to load and execute specialized instructions for a task. Skills are predefined prompts that guide how to handle specific scenarios.
+  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
 
-Parameters:
-- skill: The name of the skill to invoke
-- args: Optional arguments to pass to the skill (e.g., for $ARGUMENTS substitution)
-- taskContext: Context about what you're trying to accomplish (important for forked skills that run in isolation)
-
-Execution modes:
-- **Inline skills**: Return instructions for you to follow in the current conversation
-- **Fork skills**: Automatically execute in an isolated subagent and return the result (no additional tool calls needed)
-- **Bundled MCP skills**: Automatically connect any MCP servers carried inside the skill bundle when the skill is invoked
-
-Fork skills run in complete isolation without access to conversation history. They're useful for tasks that should run independently.
-
 Available skills are listed in your system prompt. Use the skill name exactly as shown.`;
 }
-function getSkillBundledMcpServers(promptInfo) {
-  const rawServers = promptInfo?.metadata?.mcpServers;
-  if (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers)) {
-    return {};
-  }
-  return Object.fromEntries(
-    Object.entries(rawServers).filter(
-      ([, config]) => typeof config === "object" && config !== null && !Array.isArray(config)
-    )
-  );
-}
-async function ensureSkillMcpServersConnected(skill, promptInfo, context) {
-  const mcpServers = getSkillBundledMcpServers(promptInfo);
-  const serverNames = Object.keys(mcpServers);
-  if (serverNames.length === 0) {
-    return void 0;
-  }
-  if (!context.agent?.addMcpServer || !context.agent.getMcpServerStatus || !context.agent.enableMcpServer) {
-    return {
-      error: `Skill '${skill}' requires bundled MCP servers (${serverNames.join(", ")}), but this agent does not support dynamic MCP loading.`,
-      mcpServers: serverNames
-    };
-  }
-  try {
-    for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
-      let serverStatus = context.agent.getMcpServerStatus(serverName);
-      if (!serverStatus) {
-        await context.agent.addMcpServer(serverName, serverConfig);
-        serverStatus = context.agent.getMcpServerStatus(serverName);
-      }
-      if (!serverStatus?.enabled || serverStatus.status !== "connected") {
-        await context.agent.enableMcpServer(serverName);
-        serverStatus = context.agent.getMcpServerStatus(serverName);
-      }
-      if (!serverStatus || serverStatus.status !== "connected") {
-        return {
-          error: `Skill '${skill}' requires MCP server '${serverName}', but it is currently ${serverStatus?.status ?? "unavailable"}${serverStatus?.error ? `: ${serverStatus.error}` : ""}.`,
-          mcpServers: serverNames
-        };
-      }
-    }
-  } catch (error) {
-    return {
-      error: error instanceof Error ? error.message : "Failed to connect bundled MCP servers for skill",
-      mcpServers: serverNames
-    };
-  }
-  return void 0;
-}
 export {
   createInvokeSkillTool
 };

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

@@ -1,122 +1,98 @@
 "use strict";
 var import_vitest = require("vitest");
 var import_invoke_skill_tool = require("./invoke-skill-tool.js");
-function createPromptInfo() {
-  return {
-    name: "echo-custom-mcp",
-    displayName: "echo-custom-mcp",
-    commandName: "echo-custom-mcp",
-    source: "config",
-    metadata: {
-      type: "file",
-      filePath: "/tmp/skills/echo-custom-mcp/SKILL.md",
-      mcpServers: {
-        skill_echo_demo: {
-          type: "stdio",
-          command: "node",
-          args: ["scripts/echo-mcp-server.mjs"]
-        }
-      }
-    }
-  };
-}
 (0, import_vitest.describe)("invoke_skill tool", () => {
-  (0, import_vitest.it)("retries previously registered bundled MCP servers before returning an error", async () => {
-    const promptInfo = createPromptInfo();
-    const promptManager = {
-      listAutoInvocablePrompts: import_vitest.vi.fn().mockResolvedValue({ "config:echo-custom-mcp": promptInfo }),
-      getPromptDefinition: import_vitest.vi.fn().mockResolvedValue(void 0),
-      getPrompt: import_vitest.vi.fn().mockResolvedValue({
-        messages: [
-          {
-            content: {
-              type: "text",
-              text: "Use the bundled echo MCP 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 addMcpServer = import_vitest.vi.fn();
-    const enableMcpServer = import_vitest.vi.fn().mockResolvedValue(void 0);
-    const getMcpServerStatus = import_vitest.vi.fn().mockReturnValueOnce({
-      name: "skill_echo_demo",
-      type: "stdio",
-      enabled: true,
-      status: "error",
-      error: "Request timed out"
-    }).mockReturnValueOnce({
-      name: "skill_echo_demo",
-      type: "stdio",
-      enabled: true,
-      status: "connected"
-    });
     const tool = (0, import_invoke_skill_tool.createInvokeSkillTool)();
     const result = await tool.execute(
       {
-        skill: "echo-custom-mcp"
+        skill: "Alpha",
+        args: { mode: "fast" }
       },
       {
         logger: {
           warn: import_vitest.vi.fn()
         },
         services: {
-          prompts: promptManager
-        },
-        agent: {
-          addMcpServer,
-          getMcpServerStatus,
-          enableMcpServer
+          skills: skillManager
         }
       }
     );
-    (0, import_vitest.expect)(addMcpServer).not.toHaveBeenCalled();
-    (0, import_vitest.expect)(enableMcpServer).toHaveBeenCalledWith("skill_echo_demo");
-    (0, import_vitest.expect)(getMcpServerStatus).toHaveBeenCalledTimes(2);
-    (0, import_vitest.expect)(result).toMatchObject({
-      skill: "config:echo-custom-mcp",
-      content: "Use the bundled echo MCP tool."
+    (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)("does not connect bundled MCP servers when fork execution is unavailable", async () => {
-    const promptInfo = createPromptInfo();
-    const promptManager = {
-      listAutoInvocablePrompts: import_vitest.vi.fn().mockResolvedValue({ "config:echo-custom-mcp": promptInfo }),
-      getPromptDefinition: import_vitest.vi.fn().mockResolvedValue({
-        name: "echo-custom-mcp",
-        context: "fork"
-      }),
-      getPrompt: import_vitest.vi.fn()
+  (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 addMcpServer = import_vitest.vi.fn();
-    const enableMcpServer = import_vitest.vi.fn();
-    const getMcpServerStatus = import_vitest.vi.fn();
     const tool = (0, import_invoke_skill_tool.createInvokeSkillTool)();
     const result = await tool.execute(
       {
-        skill: "echo-custom-mcp"
+        skill: "Alpha",
+        taskContext: "Refactor the storage layer."
       },
       {
         logger: {
           warn: import_vitest.vi.fn()
         },
         services: {
-          prompts: promptManager
-        },
-        agent: {
-          addMcpServer,
-          getMcpServerStatus,
-          enableMcpServer
+          skills: skillManager
         }
       }
     );
-    (0, import_vitest.expect)(addMcpServer).not.toHaveBeenCalled();
-    (0, import_vitest.expect)(enableMcpServer).not.toHaveBeenCalled();
-    (0, import_vitest.expect)(getMcpServerStatus).not.toHaveBeenCalled();
-    (0, import_vitest.expect)(promptManager.getPrompt).not.toHaveBeenCalled();
+    (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 'echo-custom-mcp' requires fork execution (context: fork), but agent spawning is not available.",
-      skill: "config:echo-custom-mcp"
+      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.js

@@ -1,121 +1,97 @@
 import { describe, expect, it, vi } from "vitest";
 import { createInvokeSkillTool } from "./invoke-skill-tool.js";
-function createPromptInfo() {
-  return {
-    name: "echo-custom-mcp",
-    displayName: "echo-custom-mcp",
-    commandName: "echo-custom-mcp",
-    source: "config",
-    metadata: {
-      type: "file",
-      filePath: "/tmp/skills/echo-custom-mcp/SKILL.md",
-      mcpServers: {
-        skill_echo_demo: {
-          type: "stdio",
-          command: "node",
-          args: ["scripts/echo-mcp-server.mjs"]
-        }
-      }
-    }
-  };
-}
 describe("invoke_skill tool", () => {
-  it("retries previously registered bundled MCP servers before returning an error", async () => {
-    const promptInfo = createPromptInfo();
-    const promptManager = {
-      listAutoInvocablePrompts: vi.fn().mockResolvedValue({ "config:echo-custom-mcp": promptInfo }),
-      getPromptDefinition: vi.fn().mockResolvedValue(void 0),
-      getPrompt: vi.fn().mockResolvedValue({
-        messages: [
-          {
-            content: {
-              type: "text",
-              text: "Use the bundled echo MCP 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 addMcpServer = vi.fn();
-    const enableMcpServer = vi.fn().mockResolvedValue(void 0);
-    const getMcpServerStatus = vi.fn().mockReturnValueOnce({
-      name: "skill_echo_demo",
-      type: "stdio",
-      enabled: true,
-      status: "error",
-      error: "Request timed out"
-    }).mockReturnValueOnce({
-      name: "skill_echo_demo",
-      type: "stdio",
-      enabled: true,
-      status: "connected"
-    });
     const tool = createInvokeSkillTool();
     const result = await tool.execute(
       {
-        skill: "echo-custom-mcp"
+        skill: "Alpha",
+        args: { mode: "fast" }
       },
       {
         logger: {
           warn: vi.fn()
         },
         services: {
-          prompts: promptManager
-        },
-        agent: {
-          addMcpServer,
-          getMcpServerStatus,
-          enableMcpServer
+          skills: skillManager
         }
       }
     );
-    expect(addMcpServer).not.toHaveBeenCalled();
-    expect(enableMcpServer).toHaveBeenCalledWith("skill_echo_demo");
-    expect(getMcpServerStatus).toHaveBeenCalledTimes(2);
-    expect(result).toMatchObject({
-      skill: "config:echo-custom-mcp",
-      content: "Use the bundled echo MCP tool."
+    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("does not connect bundled MCP servers when fork execution is unavailable", async () => {
-    const promptInfo = createPromptInfo();
-    const promptManager = {
-      listAutoInvocablePrompts: vi.fn().mockResolvedValue({ "config:echo-custom-mcp": promptInfo }),
-      getPromptDefinition: vi.fn().mockResolvedValue({
-        name: "echo-custom-mcp",
-        context: "fork"
-      }),
-      getPrompt: vi.fn()
+  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 addMcpServer = vi.fn();
-    const enableMcpServer = vi.fn();
-    const getMcpServerStatus = vi.fn();
     const tool = createInvokeSkillTool();
     const result = await tool.execute(
       {
-        skill: "echo-custom-mcp"
+        skill: "Alpha",
+        taskContext: "Refactor the storage layer."
       },
       {
         logger: {
           warn: vi.fn()
         },
         services: {
-          prompts: promptManager
-        },
-        agent: {
-          addMcpServer,
-          getMcpServerStatus,
-          enableMcpServer
+          skills: skillManager
         }
       }
     );
-    expect(addMcpServer).not.toHaveBeenCalled();
-    expect(enableMcpServer).not.toHaveBeenCalled();
-    expect(getMcpServerStatus).not.toHaveBeenCalled();
-    expect(promptManager.getPrompt).not.toHaveBeenCalled();
+    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 'echo-custom-mcp' requires fork execution (context: fork), but agent spawning is not available.",
-      skill: "config:echo-custom-mcp"
+      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");
+  });
 });