@dexto/tools-builtins 1.6.0

package/dist/implementations/get-resource-tool.cjs

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_resource_tool_exports = {};
+__export(get_resource_tool_exports, {
+  createGetResourceTool: () => createGetResourceTool
+});
+module.exports = __toCommonJS(get_resource_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+const GetResourceInputSchema = import_zod.z.object({
+  reference: import_zod.z.string().describe(
+    'The resource reference to access. Formats: "blob:abc123" (from list_resources), "resource_ref:blob:abc123" (from tool annotations)'
+  ),
+  format: import_zod.z.enum(["url", "metadata"]).default("url").describe(
+    'Output format: "url" for a shareable URL (requires remote storage like Supabase), "metadata" for resource information without loading the data'
+  )
+}).strict();
+function createGetResourceTool() {
+  return (0, import_core.defineTool)({
+    id: "get_resource",
+    displayName: "Get Resource",
+    description: 'Access a stored resource. Use format "url" to get a shareable URL for other agents or external systems (requires remote storage like Supabase). Use format "metadata" to get resource information without loading data. References can be obtained from tool result annotations or list_resources.',
+    inputSchema: GetResourceInputSchema,
+    async execute(input, context) {
+      const { reference, format } = input;
+      const resourceManager = context.services?.resources;
+      if (!resourceManager) {
+        throw import_core.ToolError.configInvalid(
+          "get_resource requires ToolExecutionContext.services.resources"
+        );
+      }
+      try {
+        const blobStore = resourceManager.getBlobStore();
+        const storeType = blobStore.getStoreType();
+        let blobUri = reference;
+        if (blobUri.startsWith("resource_ref:")) {
+          blobUri = blobUri.substring("resource_ref:".length);
+        }
+        if (blobUri.startsWith("@")) {
+          blobUri = blobUri.substring(1);
+        }
+        if (!blobUri.startsWith("blob:")) {
+          blobUri = `blob:${blobUri}`;
+        }
+        const exists = await blobStore.exists(blobUri);
+        if (!exists) {
+          return {
+            success: false,
+            error: `Resource not found: ${reference}`,
+            _hint: "Use list_resources to see available resources"
+          };
+        }
+        if (format === "metadata") {
+          const allBlobs = await blobStore.listBlobs();
+          const blobRef = allBlobs.find((b) => b.uri === blobUri);
+          if (!blobRef) {
+            return {
+              success: false,
+              error: `Resource metadata not found: ${reference}`,
+              _hint: "Use list_resources to see available resources"
+            };
+          }
+          return {
+            success: true,
+            format: "metadata",
+            reference: blobUri,
+            mimeType: blobRef.metadata.mimeType,
+            size: blobRef.metadata.size,
+            filename: blobRef.metadata.originalName,
+            source: blobRef.metadata.source,
+            createdAt: blobRef.metadata.createdAt.toISOString()
+          };
+        }
+        if (storeType === "memory" || storeType === "local") {
+          return {
+            success: false,
+            error: "URL generation not available with local/memory storage",
+            _hint: "Configure remote storage (e.g., Supabase) in your agent config to enable URL sharing. Local storage cannot generate shareable URLs.",
+            storeType
+          };
+        }
+        const blob = await blobStore.retrieve(blobUri, "url");
+        return {
+          success: true,
+          format: "url",
+          url: blob.data,
+          reference: blobUri,
+          mimeType: blob.metadata.mimeType,
+          size: blob.metadata.size,
+          filename: blob.metadata.originalName
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          success: false,
+          error: `Failed to access resource: ${message}`
+        };
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGetResourceTool
+});

package/dist/implementations/get-resource-tool.d.cts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+
+declare const GetResourceInputSchema: z.ZodObject<{
+    reference: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<["url", "metadata"]>>;
+}, "strict", z.ZodTypeAny, {
+    reference: string;
+    format: "url" | "metadata";
+}, {
+    reference: string;
+    format?: "url" | "metadata" | undefined;
+}>;
+/**
+ * Create the `get_resource` tool.
+ *
+ * Retrieves resource metadata or a shareable URL for a stored blob resource.
+ * Requires `ToolExecutionContext.services.resources`.
+ */
+declare function createGetResourceTool(): Tool<typeof GetResourceInputSchema>;
+
+export { createGetResourceTool };

package/dist/implementations/get-resource-tool.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+declare const GetResourceInputSchema: z.ZodObject<{
+    reference: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<["url", "metadata"]>>;
+}, "strict", z.ZodTypeAny, {
+    reference: string;
+    format: "url" | "metadata";
+}, {
+    reference: string;
+    format?: "url" | "metadata" | undefined;
+}>;
+/**
+ * Create the `get_resource` tool.
+ *
+ * Retrieves resource metadata or a shareable URL for a stored blob resource.
+ * Requires `ToolExecutionContext.services.resources`.
+ */
+export declare function createGetResourceTool(): Tool<typeof GetResourceInputSchema>;
+export {};
+//# sourceMappingURL=get-resource-tool.d.ts.map

package/dist/implementations/get-resource-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-resource-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/get-resource-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,sBAAsB;;;;;;;;;EAgBf,CAAC;AAEd;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAsG3E"}

package/dist/implementations/get-resource-tool.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { ToolError, defineTool } from "@dexto/core";
+const GetResourceInputSchema = z.object({
+  reference: z.string().describe(
+    'The resource reference to access. Formats: "blob:abc123" (from list_resources), "resource_ref:blob:abc123" (from tool annotations)'
+  ),
+  format: z.enum(["url", "metadata"]).default("url").describe(
+    'Output format: "url" for a shareable URL (requires remote storage like Supabase), "metadata" for resource information without loading the data'
+  )
+}).strict();
+function createGetResourceTool() {
+  return defineTool({
+    id: "get_resource",
+    displayName: "Get Resource",
+    description: 'Access a stored resource. Use format "url" to get a shareable URL for other agents or external systems (requires remote storage like Supabase). Use format "metadata" to get resource information without loading data. References can be obtained from tool result annotations or list_resources.',
+    inputSchema: GetResourceInputSchema,
+    async execute(input, context) {
+      const { reference, format } = input;
+      const resourceManager = context.services?.resources;
+      if (!resourceManager) {
+        throw ToolError.configInvalid(
+          "get_resource requires ToolExecutionContext.services.resources"
+        );
+      }
+      try {
+        const blobStore = resourceManager.getBlobStore();
+        const storeType = blobStore.getStoreType();
+        let blobUri = reference;
+        if (blobUri.startsWith("resource_ref:")) {
+          blobUri = blobUri.substring("resource_ref:".length);
+        }
+        if (blobUri.startsWith("@")) {
+          blobUri = blobUri.substring(1);
+        }
+        if (!blobUri.startsWith("blob:")) {
+          blobUri = `blob:${blobUri}`;
+        }
+        const exists = await blobStore.exists(blobUri);
+        if (!exists) {
+          return {
+            success: false,
+            error: `Resource not found: ${reference}`,
+            _hint: "Use list_resources to see available resources"
+          };
+        }
+        if (format === "metadata") {
+          const allBlobs = await blobStore.listBlobs();
+          const blobRef = allBlobs.find((b) => b.uri === blobUri);
+          if (!blobRef) {
+            return {
+              success: false,
+              error: `Resource metadata not found: ${reference}`,
+              _hint: "Use list_resources to see available resources"
+            };
+          }
+          return {
+            success: true,
+            format: "metadata",
+            reference: blobUri,
+            mimeType: blobRef.metadata.mimeType,
+            size: blobRef.metadata.size,
+            filename: blobRef.metadata.originalName,
+            source: blobRef.metadata.source,
+            createdAt: blobRef.metadata.createdAt.toISOString()
+          };
+        }
+        if (storeType === "memory" || storeType === "local") {
+          return {
+            success: false,
+            error: "URL generation not available with local/memory storage",
+            _hint: "Configure remote storage (e.g., Supabase) in your agent config to enable URL sharing. Local storage cannot generate shareable URLs.",
+            storeType
+          };
+        }
+        const blob = await blobStore.retrieve(blobUri, "url");
+        return {
+          success: true,
+          format: "url",
+          url: blob.data,
+          reference: blobUri,
+          mimeType: blob.metadata.mimeType,
+          size: blob.metadata.size,
+          filename: blob.metadata.originalName
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          success: false,
+          error: `Failed to access resource: ${message}`
+        };
+      }
+    }
+  });
+}
+export {
+  createGetResourceTool
+};

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

@@ -0,0 +1,327 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_request_tool_exports = {};
+__export(http_request_tool_exports, {
+  createHttpRequestTool: () => createHttpRequestTool
+});
+module.exports = __toCommonJS(http_request_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_node_dns = require("node:dns");
+var import_node_net = require("node:net");
+var import_node_util = require("node:util");
+var import_undici = require("undici");
+const HttpRequestInputSchema = import_zod.z.object({
+  url: import_zod.z.string().url().describe("Absolute URL to request"),
+  method: import_zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("GET").describe("HTTP method to use"),
+  headers: import_zod.z.record(import_zod.z.string()).optional().describe("Optional request headers (string values only)"),
+  query: import_zod.z.record(import_zod.z.string()).optional().describe("Optional query parameters to append to the URL"),
+  body: import_zod.z.union([import_zod.z.string(), import_zod.z.record(import_zod.z.unknown()), import_zod.z.array(import_zod.z.unknown())]).optional().describe("Optional request body (string or JSON-serializable value)"),
+  timeoutMs: import_zod.z.number().int().positive().optional().default(3e4).describe("Request timeout in milliseconds (default: 30000)")
+}).strict();
+function isJsonContentType(contentType) {
+  return Boolean(contentType && contentType.toLowerCase().includes("application/json"));
+}
+function safeJsonParse(text) {
+  if (!text.trim()) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+const BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set(["localhost"]);
+const MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+const SAFE_DISPATCHER = createSafeDispatcher();
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => Number.isNaN(part))) {
+    return false;
+  }
+  const a = parts[0];
+  const b = parts[1];
+  const c = parts[2];
+  const d = parts[3];
+  if (a === void 0 || b === void 0 || c === void 0 || d === void 0) {
+    return false;
+  }
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 192 && b === 0 && c === 2) return true;
+  if (a === 198 && b === 51 && c === 100) return true;
+  if (a === 203 && b === 0 && c === 113) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a >= 224 && a <= 239) return true;
+  if (a >= 240) return true;
+  return false;
+}
+function isPrivateIpv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === "::" || normalized === "::1") return true;
+  if (normalized.startsWith("fe80:")) return true;
+  if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
+  if (normalized.startsWith("::ffff:")) {
+    const ipv4Part = normalized.slice("::ffff:".length);
+    return isPrivateIpv4(ipv4Part);
+  }
+  return false;
+}
+function isPrivateAddress(ip) {
+  const version = (0, import_node_net.isIP)(ip);
+  if (version === 4) return isPrivateIpv4(ip);
+  if (version === 6) return isPrivateIpv6(ip);
+  return false;
+}
+function createSafeDispatcher() {
+  const lookup = (hostname, _options, callback) => {
+    void (async () => {
+      try {
+        if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
+          callback(
+            new import_core.DextoRuntimeError(
+              "HTTP_REQUEST_UNSAFE_TARGET",
+              import_core.ErrorScope.TOOLS,
+              import_core.ErrorType.FORBIDDEN,
+              `Blocked request to local hostname: ${hostname}`
+            ),
+            "",
+            0
+          );
+          return;
+        }
+        const records = await import_node_dns.promises.lookup(hostname, {
+          all: true,
+          verbatim: true
+        });
+        if (!records.length) {
+          callback(
+            new import_core.DextoRuntimeError(
+              "HTTP_REQUEST_DNS_FAILED",
+              import_core.ErrorScope.TOOLS,
+              import_core.ErrorType.THIRD_PARTY,
+              `Failed to resolve hostname: ${hostname}`
+            ),
+            "",
+            0
+          );
+          return;
+        }
+        for (const record of records) {
+          if (isPrivateAddress(record.address)) {
+            callback(
+              new import_core.DextoRuntimeError(
+                "HTTP_REQUEST_UNSAFE_TARGET",
+                import_core.ErrorScope.TOOLS,
+                import_core.ErrorType.FORBIDDEN,
+                `Blocked request to private address: ${record.address}`
+              ),
+              "",
+              0
+            );
+            return;
+          }
+        }
+        const selected = records[0];
+        callback(
+          null,
+          selected.address,
+          selected.family ?? ((0, import_node_net.isIP)(selected.address) === 6 ? 6 : 4)
+        );
+      } catch (error) {
+        const err = error instanceof import_core.DextoRuntimeError ? error : new import_core.DextoRuntimeError(
+          "HTTP_REQUEST_DNS_FAILED",
+          import_core.ErrorScope.TOOLS,
+          import_core.ErrorType.THIRD_PARTY,
+          `Failed to resolve hostname: ${hostname}`
+        );
+        callback(err, "", 0);
+      }
+    })();
+  };
+  return new import_undici.Agent({ connect: { lookup } });
+}
+async function assertSafeUrl(requestUrl) {
+  if (!["http:", "https:"].includes(requestUrl.protocol)) {
+    throw new import_core.DextoRuntimeError(
+      "HTTP_REQUEST_UNSUPPORTED_PROTOCOL",
+      import_core.ErrorScope.TOOLS,
+      import_core.ErrorType.USER,
+      `Unsupported URL protocol: ${requestUrl.protocol}`
+    );
+  }
+  const hostname = requestUrl.hostname.trim();
+  if (!hostname) {
+    throw new import_core.DextoRuntimeError(
+      "HTTP_REQUEST_INVALID_TARGET",
+      import_core.ErrorScope.TOOLS,
+      import_core.ErrorType.USER,
+      "Request URL hostname is required"
+    );
+  }
+  if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
+    throw new import_core.DextoRuntimeError(
+      "HTTP_REQUEST_UNSAFE_TARGET",
+      import_core.ErrorScope.TOOLS,
+      import_core.ErrorType.FORBIDDEN,
+      `Blocked request to local hostname: ${hostname}`
+    );
+  }
+  if (isPrivateAddress(hostname)) {
+    throw new import_core.DextoRuntimeError(
+      "HTTP_REQUEST_UNSAFE_TARGET",
+      import_core.ErrorScope.TOOLS,
+      import_core.ErrorType.FORBIDDEN,
+      `Blocked request to private address: ${hostname}`
+    );
+  }
+}
+async function readResponseTextWithLimit(response) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength) {
+    const parsed = Number.parseInt(contentLength, 10);
+    if (!Number.isNaN(parsed) && parsed > MAX_RESPONSE_BYTES) {
+      throw new import_core.DextoRuntimeError(
+        "HTTP_REQUEST_RESPONSE_TOO_LARGE",
+        import_core.ErrorScope.TOOLS,
+        import_core.ErrorType.THIRD_PARTY,
+        `Response too large: ${parsed} bytes exceeds ${MAX_RESPONSE_BYTES} byte limit`
+      );
+    }
+  }
+  if (!response.body) {
+    return "";
+  }
+  const reader = response.body.getReader();
+  const decoder = new import_node_util.TextDecoder();
+  let total = 0;
+  let result = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.length;
+    if (total > MAX_RESPONSE_BYTES) {
+      await reader.cancel();
+      throw new import_core.DextoRuntimeError(
+        "HTTP_REQUEST_RESPONSE_TOO_LARGE",
+        import_core.ErrorScope.TOOLS,
+        import_core.ErrorType.THIRD_PARTY,
+        `Response too large: exceeded ${MAX_RESPONSE_BYTES} byte limit`
+      );
+    }
+    result += decoder.decode(value, { stream: true });
+  }
+  result += decoder.decode();
+  return result;
+}
+function createHttpRequestTool() {
+  return (0, import_core.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,
+    async execute(input, _context) {
+      const { url, method, headers, query, body, timeoutMs } = input;
+      const requestUrl = new URL(url);
+      if (query) {
+        for (const [key, value] of Object.entries(query)) {
+          requestUrl.searchParams.set(key, value);
+        }
+      }
+      await assertSafeUrl(requestUrl);
+      const requestHeaders = headers ? { ...headers } : {};
+      let requestBody;
+      if (body !== void 0) {
+        if (typeof body === "string") {
+          requestBody = body;
+        } else {
+          requestBody = JSON.stringify(body);
+          const hasContentType = Object.keys(requestHeaders).some(
+            (key) => key.toLowerCase() === "content-type"
+          );
+          if (!hasContentType) {
+            requestHeaders["Content-Type"] = "application/json";
+          }
+        }
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const requestInit = {
+          method,
+          headers: requestHeaders,
+          signal: controller.signal
+        };
+        requestInit.dispatcher = SAFE_DISPATCHER;
+        if (requestBody !== void 0) {
+          requestInit.body = requestBody;
+        }
+        const response = await fetch(requestUrl.toString(), requestInit);
+        const responseText = await readResponseTextWithLimit(response);
+        const contentType = response.headers.get("content-type");
+        const json = isJsonContentType(contentType) ? safeJsonParse(responseText) : void 0;
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        const payload = {
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseHeaders,
+          body: responseText,
+          ...json !== void 0 ? { json } : {}
+        };
+        return payload;
+      } catch (error) {
+        if (error instanceof import_core.DextoRuntimeError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new import_core.DextoRuntimeError(
+            "HTTP_REQUEST_TIMEOUT",
+            import_core.ErrorScope.TOOLS,
+            import_core.ErrorType.TIMEOUT,
+            `HTTP request timed out after ${timeoutMs}ms`
+          );
+        }
+        throw new import_core.DextoRuntimeError(
+          "HTTP_REQUEST_FAILED",
+          import_core.ErrorScope.TOOLS,
+          import_core.ErrorType.THIRD_PARTY,
+          `HTTP request failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHttpRequestTool
+});

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+
+declare const HttpRequestInputSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown, "many">]>>;
+    timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
+    timeoutMs: number;
+    headers?: Record<string, string> | undefined;
+    query?: Record<string, string> | undefined;
+    body?: string | unknown[] | Record<string, unknown> | undefined;
+}, {
+    url: string;
+    method?: "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | undefined;
+    headers?: Record<string, string> | undefined;
+    query?: Record<string, string> | undefined;
+    body?: string | unknown[] | Record<string, unknown> | undefined;
+    timeoutMs?: number | undefined;
+}>;
+/**
+ * Internal tool for basic HTTP requests.
+ */
+declare function createHttpRequestTool(): Tool<typeof HttpRequestInputSchema>;
+
+export { createHttpRequestTool };

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+declare const HttpRequestInputSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown, "many">]>>;
+    timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
+    timeoutMs: number;
+    headers?: Record<string, string> | undefined;
+    query?: Record<string, string> | undefined;
+    body?: string | unknown[] | Record<string, unknown> | undefined;
+}, {
+    url: string;
+    method?: "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | undefined;
+    headers?: Record<string, string> | undefined;
+    query?: Record<string, string> | undefined;
+    body?: string | unknown[] | Record<string, unknown> | undefined;
+    timeoutMs?: number | undefined;
+}>;
+/**
+ * Internal tool for basic HTTP requests.
+ */
+export declare function createHttpRequestTool(): Tool<typeof HttpRequestInputSchema>;
+export {};
+//# sourceMappingURL=http-request-tool.d.ts.map

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

@@ -0,0 +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;AAO9D,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EA2Bf,CAAC;AAmPd;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAiG3E"}