@dexto/tools-builtins 1.6.0 → 1.6.2

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

@@ -1,5 +1,12 @@
 import { z } from "zod";
-import { DextoRuntimeError, ErrorScope, ErrorType, defineTool } from "@dexto/core";
+import {
+  DextoRuntimeError,
+  ErrorScope,
+  ErrorType,
+  createLocalToolCallHeader,
+  defineTool,
+  truncateForHeader
+} from "@dexto/core";
 import { promises as dns } from "node:dns";
 import { isIP } from "node:net";
 import { TextDecoder } from "node:util";
@@ -73,61 +80,101 @@ function isPrivateAddress(ip) {
   if (version === 6) return isPrivateIpv6(ip);
   return false;
 }
-function createSafeDispatcher() {
-  const lookup = (hostname, _options, callback) => {
+function createSafeLookup(config) {
+  const dnsLookup = config?.dnsLookup ?? dns.lookup;
+  return (hostname, options, callback) => {
     void (async () => {
+      const toErrnoException = (err) => err;
+      const emitError = (err) => {
+        try {
+          if (options.all) {
+            callback(err, []);
+            return;
+          }
+          callback(err, "", 0);
+        } catch {
+        }
+      };
       try {
         if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
-          callback(
-            new DextoRuntimeError(
-              "HTTP_REQUEST_UNSAFE_TARGET",
-              ErrorScope.TOOLS,
-              ErrorType.FORBIDDEN,
-              `Blocked request to local hostname: ${hostname}`
-            ),
-            "",
-            0
+          emitError(
+            toErrnoException(
+              new DextoRuntimeError(
+                "HTTP_REQUEST_UNSAFE_TARGET",
+                ErrorScope.TOOLS,
+                ErrorType.FORBIDDEN,
+                `Blocked request to local hostname: ${hostname}`
+              )
+            )
           );
           return;
         }
-        const records = await dns.lookup(hostname, {
+        const records = await dnsLookup(hostname, {
           all: true,
-          verbatim: true
+          verbatim: true,
+          family: options.family,
+          hints: options.hints
         });
         if (!records.length) {
-          callback(
-            new DextoRuntimeError(
-              "HTTP_REQUEST_DNS_FAILED",
-              ErrorScope.TOOLS,
-              ErrorType.THIRD_PARTY,
-              `Failed to resolve hostname: ${hostname}`
-            ),
-            "",
-            0
+          emitError(
+            toErrnoException(
+              new DextoRuntimeError(
+                "HTTP_REQUEST_DNS_FAILED",
+                ErrorScope.TOOLS,
+                ErrorType.THIRD_PARTY,
+                `Failed to resolve hostname: ${hostname}`
+              )
+            )
           );
           return;
         }
         for (const record of records) {
           if (isPrivateAddress(record.address)) {
-            callback(
-              new DextoRuntimeError(
-                "HTTP_REQUEST_UNSAFE_TARGET",
-                ErrorScope.TOOLS,
-                ErrorType.FORBIDDEN,
-                `Blocked request to private address: ${record.address}`
-              ),
-              "",
-              0
+            emitError(
+              toErrnoException(
+                new DextoRuntimeError(
+                  "HTTP_REQUEST_UNSAFE_TARGET",
+                  ErrorScope.TOOLS,
+                  ErrorType.FORBIDDEN,
+                  `Blocked request to private address: ${record.address}`
+                )
+              )
             );
             return;
           }
         }
+        if (options.all) {
+          try {
+            callback(
+              null,
+              records
+            );
+          } catch {
+          }
+          return;
+        }
         const selected = records[0];
-        callback(
-          null,
-          selected.address,
-          selected.family ?? (isIP(selected.address) === 6 ? 6 : 4)
-        );
+        if (!selected) {
+          emitError(
+            toErrnoException(
+              new DextoRuntimeError(
+                "HTTP_REQUEST_DNS_FAILED",
+                ErrorScope.TOOLS,
+                ErrorType.THIRD_PARTY,
+                `Failed to resolve hostname: ${hostname}`
+              )
+            )
+          );
+          return;
+        }
+        try {
+          callback(
+            null,
+            selected.address,
+            selected.family ?? (isIP(selected.address) === 6 ? 6 : 4)
+          );
+        } catch {
+        }
       } catch (error) {
         const err = error instanceof DextoRuntimeError ? error : new DextoRuntimeError(
           "HTTP_REQUEST_DNS_FAILED",
@@ -135,10 +182,13 @@ function createSafeDispatcher() {
           ErrorType.THIRD_PARTY,
           `Failed to resolve hostname: ${hostname}`
         );
-        callback(err, "", 0);
+        emitError(toErrnoException(err));
       }
     })();
   };
+}
+function createSafeDispatcher() {
+  const lookup = createSafeLookup();
   return new Agent({ connect: { lookup } });
 }
 async function assertSafeUrl(requestUrl) {
@@ -218,9 +268,14 @@ async function readResponseTextWithLimit(response) {
 function createHttpRequestTool() {
   return defineTool({
     id: "http_request",
-    displayName: "Fetch",
     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) => createLocalToolCallHeader({
+        title: "Fetch",
+        argsText: truncateForHeader(input.url, 140)
+      })
+    },
     async execute(input, _context) {
       const { url, method, headers, query, body, timeoutMs } = input;
       const requestUrl = new URL(url);
@@ -299,5 +354,6 @@ function createHttpRequestTool() {
   });
 }
 export {
-  createHttpRequestTool
+  createHttpRequestTool,
+  createSafeLookup
 };

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

@@ -0,0 +1,50 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_http_request_tool = require("./http-request-tool.js");
+(0, import_vitest.describe)("http_request tool", () => {
+  (0, import_vitest.it)("supports undici lookup({ all: true }) callback signature", async () => {
+    const records = [
+      { address: "93.184.216.34", family: 4 },
+      { address: "2606:2800:220:1:248:1893:25c8:1946", family: 6 }
+    ];
+    const dnsLookup = import_vitest.vi.fn().mockResolvedValue(records);
+    const safeLookup = (0, import_http_request_tool.createSafeLookup)({ dnsLookup });
+    const result = await new Promise((resolve, reject) => {
+      safeLookup(
+        "example.com",
+        { all: true },
+        ((err, addresses) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(addresses);
+        })
+      );
+    });
+    (0, import_vitest.expect)(dnsLookup).toHaveBeenCalledWith(
+      "example.com",
+      import_vitest.expect.objectContaining({
+        all: true,
+        verbatim: true
+      })
+    );
+    (0, import_vitest.expect)(result).toEqual(records);
+  });
+  (0, import_vitest.it)("blocks localhost hostnames", async () => {
+    const tool = (0, import_http_request_tool.createHttpRequestTool)();
+    await (0, import_vitest.expect)(
+      tool.execute(
+        {
+          url: "http://localhost:1234",
+          method: "GET",
+          timeoutMs: 1e3
+        },
+        {}
+      )
+    ).rejects.toMatchObject({
+      name: "DextoRuntimeError",
+      code: "HTTP_REQUEST_UNSAFE_TARGET"
+    });
+  });
+});

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

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

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

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

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

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from "vitest";
+import { createHttpRequestTool, createSafeLookup } from "./http-request-tool.js";
+describe("http_request tool", () => {
+  it("supports undici lookup({ all: true }) callback signature", async () => {
+    const records = [
+      { address: "93.184.216.34", family: 4 },
+      { address: "2606:2800:220:1:248:1893:25c8:1946", family: 6 }
+    ];
+    const dnsLookup = vi.fn().mockResolvedValue(records);
+    const safeLookup = createSafeLookup({ dnsLookup });
+    const result = await new Promise((resolve, reject) => {
+      safeLookup(
+        "example.com",
+        { all: true },
+        ((err, addresses) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(addresses);
+        })
+      );
+    });
+    expect(dnsLookup).toHaveBeenCalledWith(
+      "example.com",
+      expect.objectContaining({
+        all: true,
+        verbatim: true
+      })
+    );
+    expect(result).toEqual(records);
+  });
+  it("blocks localhost hostnames", async () => {
+    const tool = createHttpRequestTool();
+    await expect(
+      tool.execute(
+        {
+          url: "http://localhost:1234",
+          method: "GET",
+          timeoutMs: 1e3
+        },
+        {}
+      )
+    ).rejects.toMatchObject({
+      name: "DextoRuntimeError",
+      code: "HTTP_REQUEST_UNSAFE_TARGET"
+    });
+  });
+});

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

@@ -35,9 +35,19 @@ const InvokeSkillInputSchema = import_zod.z.object({
 function createInvokeSkillTool() {
   return (0, import_core.defineTool)({
     id: "invoke_skill",
-    displayName: "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)({
+          title: "Skill",
+          argsText: `/${displaySkillName}`
+        });
+      }
+    },
     async execute(input, context) {
       const { skill, args, taskContext } = input;
       const promptManager = context.services?.prompts;
@@ -48,11 +58,13 @@ function createInvokeSkillTool() {
       }
       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;
         }
       }
@@ -62,7 +74,39 @@ function createInvokeSkillTool() {
           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);
+      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;

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,EAAmB,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE/E,QAAA,MAAM,sBAAsB;;;;;;;;;;;;EAgBf,CAAC;AAEd;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CA0F3E"}
+{"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"}

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ToolError, defineTool, flattenPromptResult } from "@dexto/core";
+import { ToolError, createLocalToolCallHeader, defineTool, flattenPromptResult } from "@dexto/core";
 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")'
@@ -12,9 +12,19 @@ const InvokeSkillInputSchema = z.object({
 function createInvokeSkillTool() {
   return defineTool({
     id: "invoke_skill",
-    displayName: "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 createLocalToolCallHeader({
+          title: "Skill",
+          argsText: `/${displaySkillName}`
+        });
+      }
+    },
     async execute(input, context) {
       const { skill, args, taskContext } = input;
       const promptManager = context.services?.prompts;
@@ -25,11 +35,13 @@ function createInvokeSkillTool() {
       }
       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;
         }
       }
@@ -39,7 +51,39 @@ function createInvokeSkillTool() {
           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);
+      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;

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

@@ -33,9 +33,20 @@ const ListResourcesInputSchema = import_zod.z.object({
 function createListResourcesTool() {
   return (0, import_core.defineTool)({
     id: "list_resources",
-    displayName: "List Resources",
     description: "List available resources (images, files, etc.). Returns resource references that can be used with get_resource to obtain shareable URLs or metadata. Filter by source (tool/user) or kind (image/audio/video/binary).",
     inputSchema: ListResourcesInputSchema,
+    presentation: {
+      describeHeader: (input) => {
+        const parts = [];
+        if (input.source && input.source !== "all") parts.push(`source=${input.source}`);
+        if (input.kind && input.kind !== "all") parts.push(`kind=${input.kind}`);
+        if (typeof input.limit === "number") parts.push(`limit=${input.limit}`);
+        return (0, import_core.createLocalToolCallHeader)({
+          title: "List Resources",
+          ...parts.length > 0 ? { argsText: parts.join(", ") } : {}
+        });
+      }
+    },
     async execute(input, context) {
       const { source, kind, limit } = input;
       const resourceManager = context.services?.resources;

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

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

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ToolError, defineTool } from "@dexto/core";
+import { ToolError, createLocalToolCallHeader, defineTool } from "@dexto/core";
 const ListResourcesInputSchema = z.object({
   source: z.enum(["all", "tool", "user"]).optional().default("all").describe(
     'Filter by source: "tool" for tool-generated resources, "user" for user-uploaded, "all" for both'
@@ -10,9 +10,20 @@ const ListResourcesInputSchema = z.object({
 function createListResourcesTool() {
   return defineTool({
     id: "list_resources",
-    displayName: "List Resources",
     description: "List available resources (images, files, etc.). Returns resource references that can be used with get_resource to obtain shareable URLs or metadata. Filter by source (tool/user) or kind (image/audio/video/binary).",
     inputSchema: ListResourcesInputSchema,
+    presentation: {
+      describeHeader: (input) => {
+        const parts = [];
+        if (input.source && input.source !== "all") parts.push(`source=${input.source}`);
+        if (input.kind && input.kind !== "all") parts.push(`kind=${input.kind}`);
+        if (typeof input.limit === "number") parts.push(`limit=${input.limit}`);
+        return createLocalToolCallHeader({
+          title: "List Resources",
+          ...parts.length > 0 ? { argsText: parts.join(", ") } : {}
+        });
+      }
+    },
     async execute(input, context) {
       const { source, kind, limit } = input;
       const resourceManager = context.services?.resources;

package/dist/implementations/sleep-tool.cjs

@@ -29,9 +29,14 @@ const SleepInputSchema = import_zod.z.object({
 function createSleepTool() {
   return (0, import_core.defineTool)({
     id: "sleep",
-    displayName: "Sleep",
     description: "Pause execution for a specified number of milliseconds.",
     inputSchema: SleepInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Sleep",
+        argsText: `${input.ms}ms`
+      })
+    },
     async execute(input, _context) {
       const { ms } = input;
       await new Promise((resolve) => setTimeout(resolve, ms));

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

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

package/dist/implementations/sleep-tool.js

@@ -1,14 +1,19 @@
 import { z } from "zod";
-import { defineTool } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool } from "@dexto/core";
 const SleepInputSchema = z.object({
   ms: z.number().int().positive().max(6e5).describe("Milliseconds to sleep (max 10 minutes)")
 }).strict();
 function createSleepTool() {
   return defineTool({
     id: "sleep",
-    displayName: "Sleep",
     description: "Pause execution for a specified number of milliseconds.",
     inputSchema: SleepInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Sleep",
+        argsText: `${input.ms}ms`
+      })
+    },
     async execute(input, _context) {
       const { ms } = input;
       await new Promise((resolve) => setTimeout(resolve, ms));

package/dist/index.d.cts

@@ -1,3 +1,19 @@
-export { BUILTIN_TOOL_NAMES, BuiltinToolName, BuiltinToolsConfig, BuiltinToolsConfigSchema, builtinToolsFactory } from './builtin-tools-factory.cjs';
-import 'zod';
-import '@dexto/agent-config';
+import { z } from 'zod';
+import { ToolFactory } from '@dexto/agent-config';
+
+declare const BUILTIN_TOOL_NAMES: readonly ["ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill", "http_request", "sleep", "web_search", "code_search"];
+type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
+declare const BuiltinToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"builtin-tools">;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill", "http_request", "sleep", "web_search", "code_search"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    type: "builtin-tools";
+    enabledTools?: ("ask_user" | "delegate_to_url" | "get_resource" | "invoke_skill" | "list_resources" | "http_request" | "sleep" | "web_search" | "code_search")[] | undefined;
+}, {
+    type: "builtin-tools";
+    enabledTools?: ("ask_user" | "delegate_to_url" | "get_resource" | "invoke_skill" | "list_resources" | "http_request" | "sleep" | "web_search" | "code_search")[] | undefined;
+}>;
+type BuiltinToolsConfig = z.output<typeof BuiltinToolsConfigSchema>;
+declare const builtinToolsFactory: ToolFactory<BuiltinToolsConfig>;
+
+export { BUILTIN_TOOL_NAMES, type BuiltinToolName, type BuiltinToolsConfig, BuiltinToolsConfigSchema, builtinToolsFactory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-builtins",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Built-in tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,8 +19,8 @@
   "dependencies": {
     "undici": "^7.22.0",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.0",
-    "@dexto/core": "1.6.0"
+    "@dexto/agent-config": "1.6.2",
+    "@dexto/core": "1.6.2"
   },
   "devDependencies": {
     "tsup": "^8.0.0",
@@ -31,7 +31,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

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

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import { ToolFactory } from '@dexto/agent-config';
-
-declare const BUILTIN_TOOL_NAMES: readonly ["ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill", "http_request", "sleep", "web_search", "code_search"];
-type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
-declare const BuiltinToolsConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"builtin-tools">;
-    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["ask_user", "delegate_to_url", "list_resources", "get_resource", "invoke_skill", "http_request", "sleep", "web_search", "code_search"]>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    type: "builtin-tools";
-    enabledTools?: ("ask_user" | "delegate_to_url" | "list_resources" | "get_resource" | "invoke_skill" | "http_request" | "sleep" | "web_search" | "code_search")[] | undefined;
-}, {
-    type: "builtin-tools";
-    enabledTools?: ("ask_user" | "delegate_to_url" | "list_resources" | "get_resource" | "invoke_skill" | "http_request" | "sleep" | "web_search" | "code_search")[] | undefined;
-}>;
-type BuiltinToolsConfig = z.output<typeof BuiltinToolsConfigSchema>;
-declare const builtinToolsFactory: ToolFactory<BuiltinToolsConfig>;
-
-export { BUILTIN_TOOL_NAMES, type BuiltinToolName, type BuiltinToolsConfig, BuiltinToolsConfigSchema, builtinToolsFactory };

package/dist/builtin-tools-factory.test.d.cts

@@ -1,2 +0,0 @@
-
-export {  }