@dexto/tools-builtins 1.6.17 → 1.6.19

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

@@ -94,6 +94,17 @@ function createInvokeSkillTool() {
         }
       }
       const promptDef = await promptManager.getPromptDefinition(skillKey);
+      const taskForker = context.services?.taskForker;
+      if (promptDef?.context === "fork" && !taskForker) {
+        return {
+          error: `Skill '${skill}' requires fork execution (context: fork), but agent spawning is not available.`,
+          skill: skillKey
+        };
+      }
+      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(
@@ -111,8 +122,8 @@ function createInvokeSkillTool() {
       const flattened = (0, import_core.flattenPromptResult)(promptResult);
       const content = flattened.text;
       if (promptDef?.context === "fork") {
-        const taskForker = context.services?.taskForker;
-        if (!taskForker) {
+        const activeTaskForker = taskForker;
+        if (!activeTaskForker) {
           return {
             error: `Skill '${skill}' requires fork execution (context: fork), but agent spawning is not available.`,
             skill: skillKey
@@ -137,7 +148,7 @@ ${content}` : content;
         if (context.sessionId) {
           forkOptions.sessionId = context.sessionId;
         }
-        const result = await taskForker.fork(forkOptions);
+        const result = await activeTaskForker.fork(forkOptions);
         if (result.success) {
           return result.response ?? "Task completed successfully.";
         }
@@ -167,11 +178,61 @@ Parameters:
 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createInvokeSkillTool

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

@@ -1 +1 @@
-{"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,EAA+B,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE3F,QAAA,MAAM,sBAAsB;;;;;;;;;;;;EAgBf,CAAC;AAEd;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CA0J3E"}
+{"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,EAIR,IAAI,EAEP,MAAM,aAAa,CAAC;AAErB,QAAA,MAAM,sBAAsB;;;;;;;;;;;;EAgBf,CAAC;AAEd;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAuK3E"}

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

@@ -71,6 +71,17 @@ function createInvokeSkillTool() {
         }
       }
       const promptDef = await promptManager.getPromptDefinition(skillKey);
+      const taskForker = context.services?.taskForker;
+      if (promptDef?.context === "fork" && !taskForker) {
+        return {
+          error: `Skill '${skill}' requires fork execution (context: fork), but agent spawning is not available.`,
+          skill: skillKey
+        };
+      }
+      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(
@@ -88,8 +99,8 @@ function createInvokeSkillTool() {
       const flattened = flattenPromptResult(promptResult);
       const content = flattened.text;
       if (promptDef?.context === "fork") {
-        const taskForker = context.services?.taskForker;
-        if (!taskForker) {
+        const activeTaskForker = taskForker;
+        if (!activeTaskForker) {
           return {
             error: `Skill '${skill}' requires fork execution (context: fork), but agent spawning is not available.`,
             skill: skillKey
@@ -114,7 +125,7 @@ ${content}` : content;
         if (context.sessionId) {
           forkOptions.sessionId = context.sessionId;
         }
-        const result = await taskForker.fork(forkOptions);
+        const result = await activeTaskForker.fork(forkOptions);
         if (result.success) {
           return result.response ?? "Task completed successfully.";
         }
@@ -144,11 +155,61 @@ Parameters:
 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

@@ -0,0 +1,122 @@
+"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."
+            }
+          }
+        ]
+      })
+    };
+    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"
+      },
+      {
+        logger: {
+          warn: import_vitest.vi.fn()
+        },
+        services: {
+          prompts: promptManager
+        },
+        agent: {
+          addMcpServer,
+          getMcpServerStatus,
+          enableMcpServer
+        }
+      }
+    );
+    (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.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()
+    };
+    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"
+      },
+      {
+        logger: {
+          warn: import_vitest.vi.fn()
+        },
+        services: {
+          prompts: promptManager
+        },
+        agent: {
+          addMcpServer,
+          getMcpServerStatus,
+          enableMcpServer
+        }
+      }
+    );
+    (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).toEqual({
+      error: "Skill 'echo-custom-mcp' requires fork execution (context: fork), but agent spawning is not available.",
+      skill: "config:echo-custom-mcp"
+    });
+  });
+});

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

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

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

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

@@ -0,0 +1,121 @@
+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."
+            }
+          }
+        ]
+      })
+    };
+    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"
+      },
+      {
+        logger: {
+          warn: vi.fn()
+        },
+        services: {
+          prompts: promptManager
+        },
+        agent: {
+          addMcpServer,
+          getMcpServerStatus,
+          enableMcpServer
+        }
+      }
+    );
+    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."
+    });
+  });
+  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()
+    };
+    const addMcpServer = vi.fn();
+    const enableMcpServer = vi.fn();
+    const getMcpServerStatus = vi.fn();
+    const tool = createInvokeSkillTool();
+    const result = await tool.execute(
+      {
+        skill: "echo-custom-mcp"
+      },
+      {
+        logger: {
+          warn: vi.fn()
+        },
+        services: {
+          prompts: promptManager
+        },
+        agent: {
+          addMcpServer,
+          getMcpServerStatus,
+          enableMcpServer
+        }
+      }
+    );
+    expect(addMcpServer).not.toHaveBeenCalled();
+    expect(enableMcpServer).not.toHaveBeenCalled();
+    expect(getMcpServerStatus).not.toHaveBeenCalled();
+    expect(promptManager.getPrompt).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      error: "Skill 'echo-custom-mcp' requires fork execution (context: fork), but agent spawning is not available.",
+      skill: "config:echo-custom-mcp"
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-builtins",
-  "version": "1.6.17",
+  "version": "1.6.19",
   "description": "Built-in tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,10 +17,10 @@
     "builtins"
   ],
   "dependencies": {
-    "undici": "^7.24.0",
+    "undici": "^7.24.6",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.17",
-    "@dexto/core": "1.6.17"
+    "@dexto/agent-config": "1.6.19",
+    "@dexto/core": "1.6.19"
   },
   "devDependencies": {
     "tsup": "^8.0.0",