@dexto/tools-builtins 1.7.1 → 1.8.0

package/dist/implementations/http-request-tool.cjs

@@ -23,7 +23,8 @@ __export(http_request_tool_exports, {
 });
 module.exports = __toCommonJS(http_request_tool_exports);
 var import_zod = require("zod");
-var import_core = require("@dexto/core");
+var import_errors = require("@dexto/core/errors");
+var import_tools = require("@dexto/core/tools");
 var import_node_dns = require("node:dns");
 var import_node_net = require("node:net");
 var import_node_util = require("node:util");
@@ -116,10 +117,10 @@ function createSafeLookup(config) {
         if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
           emitError(
             toErrnoException(
-              new import_core.DextoRuntimeError(
+              new import_errors.DextoRuntimeError(
                 "HTTP_REQUEST_UNSAFE_TARGET",
-                import_core.ErrorScope.TOOLS,
-                import_core.ErrorType.FORBIDDEN,
+                import_errors.ErrorScope.TOOLS,
+                import_errors.ErrorType.FORBIDDEN,
                 `Blocked request to local hostname: ${hostname}`
               )
             )
@@ -135,10 +136,10 @@ function createSafeLookup(config) {
         if (!records.length) {
           emitError(
             toErrnoException(
-              new import_core.DextoRuntimeError(
+              new import_errors.DextoRuntimeError(
                 "HTTP_REQUEST_DNS_FAILED",
-                import_core.ErrorScope.TOOLS,
-                import_core.ErrorType.THIRD_PARTY,
+                import_errors.ErrorScope.TOOLS,
+                import_errors.ErrorType.THIRD_PARTY,
                 `Failed to resolve hostname: ${hostname}`
               )
             )
@@ -149,10 +150,10 @@ function createSafeLookup(config) {
           if (isPrivateAddress(record.address)) {
             emitError(
               toErrnoException(
-                new import_core.DextoRuntimeError(
+                new import_errors.DextoRuntimeError(
                   "HTTP_REQUEST_UNSAFE_TARGET",
-                  import_core.ErrorScope.TOOLS,
-                  import_core.ErrorType.FORBIDDEN,
+                  import_errors.ErrorScope.TOOLS,
+                  import_errors.ErrorType.FORBIDDEN,
                   `Blocked request to private address: ${record.address}`
                 )
               )
@@ -174,10 +175,10 @@ function createSafeLookup(config) {
         if (!selected) {
           emitError(
             toErrnoException(
-              new import_core.DextoRuntimeError(
+              new import_errors.DextoRuntimeError(
                 "HTTP_REQUEST_DNS_FAILED",
-                import_core.ErrorScope.TOOLS,
-                import_core.ErrorType.THIRD_PARTY,
+                import_errors.ErrorScope.TOOLS,
+                import_errors.ErrorType.THIRD_PARTY,
                 `Failed to resolve hostname: ${hostname}`
               )
             )
@@ -193,10 +194,10 @@ function createSafeLookup(config) {
         } catch {
         }
       } catch (error) {
-        const err = error instanceof import_core.DextoRuntimeError ? error : new import_core.DextoRuntimeError(
+        const err = error instanceof import_errors.DextoRuntimeError ? error : new import_errors.DextoRuntimeError(
           "HTTP_REQUEST_DNS_FAILED",
-          import_core.ErrorScope.TOOLS,
-          import_core.ErrorType.THIRD_PARTY,
+          import_errors.ErrorScope.TOOLS,
+          import_errors.ErrorType.THIRD_PARTY,
           `Failed to resolve hostname: ${hostname}`
         );
         emitError(toErrnoException(err));
@@ -210,35 +211,35 @@ function createSafeDispatcher() {
 }
 async function assertSafeUrl(requestUrl) {
   if (!["http:", "https:"].includes(requestUrl.protocol)) {
-    throw new import_core.DextoRuntimeError(
+    throw new import_errors.DextoRuntimeError(
       "HTTP_REQUEST_UNSUPPORTED_PROTOCOL",
-      import_core.ErrorScope.TOOLS,
-      import_core.ErrorType.USER,
+      import_errors.ErrorScope.TOOLS,
+      import_errors.ErrorType.USER,
       `Unsupported URL protocol: ${requestUrl.protocol}`
     );
   }
   const hostname = requestUrl.hostname.trim();
   if (!hostname) {
-    throw new import_core.DextoRuntimeError(
+    throw new import_errors.DextoRuntimeError(
       "HTTP_REQUEST_INVALID_TARGET",
-      import_core.ErrorScope.TOOLS,
-      import_core.ErrorType.USER,
+      import_errors.ErrorScope.TOOLS,
+      import_errors.ErrorType.USER,
       "Request URL hostname is required"
     );
   }
   if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
-    throw new import_core.DextoRuntimeError(
+    throw new import_errors.DextoRuntimeError(
       "HTTP_REQUEST_UNSAFE_TARGET",
-      import_core.ErrorScope.TOOLS,
-      import_core.ErrorType.FORBIDDEN,
+      import_errors.ErrorScope.TOOLS,
+      import_errors.ErrorType.FORBIDDEN,
       `Blocked request to local hostname: ${hostname}`
     );
   }
   if (isPrivateAddress(hostname)) {
-    throw new import_core.DextoRuntimeError(
+    throw new import_errors.DextoRuntimeError(
       "HTTP_REQUEST_UNSAFE_TARGET",
-      import_core.ErrorScope.TOOLS,
-      import_core.ErrorType.FORBIDDEN,
+      import_errors.ErrorScope.TOOLS,
+      import_errors.ErrorType.FORBIDDEN,
       `Blocked request to private address: ${hostname}`
     );
   }
@@ -248,10 +249,10 @@ async function readResponseTextWithLimit(response) {
   if (contentLength) {
     const parsed = Number.parseInt(contentLength, 10);
     if (!Number.isNaN(parsed) && parsed > MAX_RESPONSE_BYTES) {
-      throw new import_core.DextoRuntimeError(
+      throw new import_errors.DextoRuntimeError(
         "HTTP_REQUEST_RESPONSE_TOO_LARGE",
-        import_core.ErrorScope.TOOLS,
-        import_core.ErrorType.THIRD_PARTY,
+        import_errors.ErrorScope.TOOLS,
+        import_errors.ErrorType.THIRD_PARTY,
         `Response too large: ${parsed} bytes exceeds ${MAX_RESPONSE_BYTES} byte limit`
       );
     }
@@ -270,10 +271,10 @@ async function readResponseTextWithLimit(response) {
     total += value.length;
     if (total > MAX_RESPONSE_BYTES) {
       await reader.cancel();
-      throw new import_core.DextoRuntimeError(
+      throw new import_errors.DextoRuntimeError(
         "HTTP_REQUEST_RESPONSE_TOO_LARGE",
-        import_core.ErrorScope.TOOLS,
-        import_core.ErrorType.THIRD_PARTY,
+        import_errors.ErrorScope.TOOLS,
+        import_errors.ErrorType.THIRD_PARTY,
         `Response too large: exceeded ${MAX_RESPONSE_BYTES} byte limit`
       );
     }
@@ -283,14 +284,14 @@ async function readResponseTextWithLimit(response) {
   return result;
 }
 function createHttpRequestTool() {
-  return (0, import_core.defineTool)({
+  return (0, import_tools.defineTool)({
     id: "http_request",
     description: "Make a direct HTTP request using fetch. Supports method, headers, query params, JSON bodies, and timeouts. Returns status, headers, raw body text, and parsed JSON when available.",
     inputSchema: HttpRequestInputSchema,
     presentation: {
-      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+      describeHeader: (input) => (0, import_tools.createLocalToolCallHeader)({
         title: "Fetch",
-        argsText: (0, import_core.truncateForHeader)(input.url, 140)
+        argsText: (0, import_tools.truncateForHeader)(input.url, 140)
       })
     },
     async execute(input, _context) {
@@ -347,21 +348,21 @@ function createHttpRequestTool() {
         };
         return payload;
       } catch (error) {
-        if (error instanceof import_core.DextoRuntimeError) {
+        if (error instanceof import_errors.DextoRuntimeError) {
           throw error;
         }
         if (error instanceof Error && error.name === "AbortError") {
-          throw new import_core.DextoRuntimeError(
+          throw new import_errors.DextoRuntimeError(
             "HTTP_REQUEST_TIMEOUT",
-            import_core.ErrorScope.TOOLS,
-            import_core.ErrorType.TIMEOUT,
+            import_errors.ErrorScope.TOOLS,
+            import_errors.ErrorType.TIMEOUT,
             `HTTP request timed out after ${timeoutMs}ms`
           );
         }
-        throw new import_core.DextoRuntimeError(
+        throw new import_errors.DextoRuntimeError(
           "HTTP_REQUEST_FAILED",
-          import_core.ErrorScope.TOOLS,
-          import_core.ErrorType.THIRD_PARTY,
+          import_errors.ErrorScope.TOOLS,
+          import_errors.ErrorType.THIRD_PARTY,
           `HTTP request failed: ${error instanceof Error ? error.message : String(error)}`
         );
       } finally {

package/dist/implementations/http-request-tool.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { Tool } from '@dexto/core';
+import type { Tool } from '@dexto/core/tools';
 import { promises as dns, type LookupAddress, type LookupOptions } from 'node:dns';
 declare const HttpRequestInputSchema: z.ZodObject<{
     url: z.ZodString;

package/dist/implementations/http-request-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-request-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/http-request-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAS9D,OAAO,EAAE,QAAQ,IAAI,GAAG,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAKnF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;kBA2Bf,CAAC;AA8Bd,KAAK,cAAc,GACb,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,GAC9E,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC,CAAC;AAoDhF,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE;IACtC,SAAS,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,CAAC;CACjC,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAyI/E;AA2FD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAuG3E"}
+{"version":3,"file":"http-request-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/http-request-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,mBAAmB,CAAC;AAGpE,OAAO,EAAE,QAAQ,IAAI,GAAG,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAKnF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;kBA2Bf,CAAC;AA8Bd,KAAK,cAAc,GACb,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,GAC9E,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC,CAAC;AAoDhF,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE;IACtC,SAAS,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,CAAC;CACjC,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAyI/E;AA2FD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAuG3E"}

package/dist/implementations/http-request-tool.js

@@ -1,12 +1,6 @@
 import { z } from "zod";
-import {
-  DextoRuntimeError,
-  ErrorScope,
-  ErrorType,
-  createLocalToolCallHeader,
-  defineTool,
-  truncateForHeader
-} from "@dexto/core";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core/errors";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core/tools";
 import { promises as dns } from "node:dns";
 import { isIP } from "node:net";
 import { TextDecoder } from "node:util";

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

@@ -22,140 +22,53 @@ __export(invoke_skill_tool_exports, {
 });
 module.exports = __toCommonJS(invoke_skill_tool_exports);
 var import_zod = require("zod");
-var import_core = require("@dexto/core");
+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. Recommended for forked skills to provide context since they run in isolation without conversation history."
-  )
+  taskContext: import_zod.z.string().optional().describe("Context about what task this skill should accomplish")
 }).strict();
 function createInvokeSkillTool() {
-  return (0, import_core.defineTool)({
+  return (0, import_tools.defineTool)({
     id: "invoke_skill",
     description: buildToolDescription(),
     inputSchema: InvokeSkillInputSchema,
     presentation: {
       describeHeader: (input) => {
-        const skillName = input.skill;
-        const colonIndex = skillName.indexOf(":");
-        const displaySkillName = colonIndex >= 0 ? skillName.slice(colonIndex + 1) : skillName;
-        return (0, import_core.createLocalToolCallHeader)({
+        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 { skill, args, taskContext } = input;
-      const promptManager = context.services?.prompts;
-      if (!promptManager) {
-        throw import_core.ToolError.configInvalid(
-          "invoke_skill requires ToolExecutionContext.services.prompts"
+      const skillManager = context.services?.skills;
+      if (!skillManager) {
+        throw import_tools.ToolError.configInvalid(
+          "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 = (0, import_core.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."
       };
@@ -163,76 +76,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;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createInvokeSkillTool

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

@@ -1,17 +1,10 @@
 import { z } from 'zod';
-import type { Tool } from '@dexto/core';
+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>;
-/**
- * Create the `invoke_skill` tool.
- *
- * Loads an auto-invocable prompt (“skill”) via the PromptManager and returns its content, or
- * forks the skill into a sub-agent when the skill is marked as `context: fork`.
- * Requires `ToolExecutionContext.services.prompts` and, for forked skills, `services.taskForker`.
- */
 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 +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,EAIR,IAAI,EAEP,MAAM,aAAa,CAAC;AAErB,QAAA,MAAM,sBAAsB;;;;kBAmBf,CAAC;AAEd;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAuK3E"}
+{"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,CAgD3E"}