@dexto/tools-builtins 1.6.0

package/dist/implementations/exa-code-search-tool.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { defineTool } from "@dexto/core";
+import { callExaTool } from "./exa-mcp.js";
+const CodeSearchInputSchema = z.object({
+  query: z.string().min(1).describe(
+    "Search query for code examples and documentation (e.g., 'React useState examples', 'Express middleware', 'Python pandas dataframe filtering')"
+  ),
+  tokensNum: z.number().int().min(1e3).max(5e4).optional().default(5e3).describe("Approximate token budget to return (1000\u201350000, default: 5000)")
+}).strict();
+function createCodeSearchTool() {
+  return defineTool({
+    id: "code_search",
+    displayName: "Code Search",
+    description: "Search for code examples and documentation across sources like official docs, GitHub, and Stack Overflow. Returns formatted text context.",
+    inputSchema: CodeSearchInputSchema,
+    async execute(input, context) {
+      const { query, tokensNum } = input;
+      return await callExaTool({
+        logger: context.logger,
+        toolId: "code_search",
+        toolName: "get_code_context_exa",
+        args: {
+          query,
+          tokensNum
+        },
+        timeoutMs: 3e4
+      });
+    }
+  });
+}
+export {
+  createCodeSearchTool
+};

package/dist/implementations/exa-mcp.cjs

@@ -0,0 +1,98 @@
+"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 exa_mcp_exports = {};
+__export(exa_mcp_exports, {
+  callExaTool: () => callExaTool
+});
+module.exports = __toCommonJS(exa_mcp_exports);
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+const EXA_SERVER_URL = "https://mcp.exa.ai/mcp";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asExaToolResult(value) {
+  if (!isPlainObject(value)) return null;
+  const content = value.content;
+  const isError = value.isError;
+  const result = {};
+  if (Array.isArray(content)) {
+    result.content = content.filter(isPlainObject).map((entry) => {
+      const mapped = {};
+      if (typeof entry.type === "string") {
+        mapped.type = entry.type;
+      }
+      if (typeof entry.text === "string") {
+        mapped.text = entry.text;
+      }
+      return mapped;
+    });
+  }
+  if (typeof isError === "boolean") {
+    result.isError = isError;
+  }
+  return result;
+}
+function extractFirstText(result) {
+  if (!result.content) return null;
+  for (const entry of result.content) {
+    if (entry.type === "text" && typeof entry.text === "string" && entry.text.trim()) {
+      return entry.text;
+    }
+  }
+  return null;
+}
+async function callExaTool(options) {
+  const { logger, toolId, toolName, args, timeoutMs } = options;
+  const mcpClient = new import_core.DextoMcpClient(logger);
+  const config = import_core.McpServerConfigSchema.parse({
+    type: "http",
+    enabled: true,
+    url: EXA_SERVER_URL,
+    headers: {},
+    timeout: timeoutMs,
+    connectionMode: "lenient"
+  });
+  try {
+    await mcpClient.connect(config, "exa");
+    const client = await mcpClient.getConnectedClient();
+    const result = await client.callTool({ name: toolName, arguments: args }, void 0, {
+      timeout: timeoutMs,
+      resetTimeoutOnProgress: true
+    });
+    const parsed = asExaToolResult(result);
+    if (parsed?.isError) {
+      const message = extractFirstText(parsed) ?? "Unknown error from Exa MCP tool";
+      throw import_core2.ToolError.executionFailed(toolId, message);
+    }
+    const text = parsed ? extractFirstText(parsed) : null;
+    return text ?? "No results found. Try a different query.";
+  } catch (error) {
+    if (error instanceof Error) {
+      throw import_core2.ToolError.executionFailed(toolId, error.message);
+    }
+    throw import_core2.ToolError.executionFailed(toolId, String(error));
+  } finally {
+    await mcpClient.disconnect();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callExaTool
+});

package/dist/implementations/exa-mcp.d.cts

@@ -0,0 +1,24 @@
+import { Logger } from '@dexto/core';
+
+type ExaToolName = 'web_search_exa' | 'get_code_context_exa';
+/**
+ * Exa search tools are implemented as internal tools (not exposed as `mcp--...` tools).
+ *
+ * Why:
+ * - We want stable tool IDs and consistent display/approval UX.
+ * - We intentionally do NOT register Exa as an MCP server in the agent-wide MCPManager, because that would:
+ *   - expose extra Exa MCP tools (e.g. company research) that we don't want in the tool surface
+ *   - allow the model to bypass curated wrappers by calling `mcp--...` tools directly
+ *
+ * Implementation detail:
+ * - We still use the MCP SDK via Dexto's MCP client wrapper (no bespoke fetch/SSE parsing).
+ */
+declare function callExaTool(options: {
+    logger: Logger;
+    toolId: string;
+    toolName: ExaToolName;
+    args: Record<string, unknown>;
+    timeoutMs: number;
+}): Promise<string>;
+
+export { callExaTool };

package/dist/implementations/exa-mcp.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from '@dexto/core';
+type ExaToolName = 'web_search_exa' | 'get_code_context_exa';
+/**
+ * Exa search tools are implemented as internal tools (not exposed as `mcp--...` tools).
+ *
+ * Why:
+ * - We want stable tool IDs and consistent display/approval UX.
+ * - We intentionally do NOT register Exa as an MCP server in the agent-wide MCPManager, because that would:
+ *   - expose extra Exa MCP tools (e.g. company research) that we don't want in the tool surface
+ *   - allow the model to bypass curated wrappers by calling `mcp--...` tools directly
+ *
+ * Implementation detail:
+ * - We still use the MCP SDK via Dexto's MCP client wrapper (no bespoke fetch/SSE parsing).
+ */
+export declare function callExaTool(options: {
+    logger: Logger;
+    toolId: string;
+    toolName: ExaToolName;
+    args: Record<string, unknown>;
+    timeoutMs: number;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=exa-mcp.d.ts.map

package/dist/implementations/exa-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exa-mcp.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-mcp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C,KAAK,WAAW,GAAG,gBAAgB,GAAG,sBAAsB,CAAC;AAmD7D;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,MAAM,CAAC,CAqClB"}

package/dist/implementations/exa-mcp.js

@@ -0,0 +1,74 @@
+import { DextoMcpClient, McpServerConfigSchema } from "@dexto/core";
+import { ToolError } from "@dexto/core";
+const EXA_SERVER_URL = "https://mcp.exa.ai/mcp";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asExaToolResult(value) {
+  if (!isPlainObject(value)) return null;
+  const content = value.content;
+  const isError = value.isError;
+  const result = {};
+  if (Array.isArray(content)) {
+    result.content = content.filter(isPlainObject).map((entry) => {
+      const mapped = {};
+      if (typeof entry.type === "string") {
+        mapped.type = entry.type;
+      }
+      if (typeof entry.text === "string") {
+        mapped.text = entry.text;
+      }
+      return mapped;
+    });
+  }
+  if (typeof isError === "boolean") {
+    result.isError = isError;
+  }
+  return result;
+}
+function extractFirstText(result) {
+  if (!result.content) return null;
+  for (const entry of result.content) {
+    if (entry.type === "text" && typeof entry.text === "string" && entry.text.trim()) {
+      return entry.text;
+    }
+  }
+  return null;
+}
+async function callExaTool(options) {
+  const { logger, toolId, toolName, args, timeoutMs } = options;
+  const mcpClient = new DextoMcpClient(logger);
+  const config = McpServerConfigSchema.parse({
+    type: "http",
+    enabled: true,
+    url: EXA_SERVER_URL,
+    headers: {},
+    timeout: timeoutMs,
+    connectionMode: "lenient"
+  });
+  try {
+    await mcpClient.connect(config, "exa");
+    const client = await mcpClient.getConnectedClient();
+    const result = await client.callTool({ name: toolName, arguments: args }, void 0, {
+      timeout: timeoutMs,
+      resetTimeoutOnProgress: true
+    });
+    const parsed = asExaToolResult(result);
+    if (parsed?.isError) {
+      const message = extractFirstText(parsed) ?? "Unknown error from Exa MCP tool";
+      throw ToolError.executionFailed(toolId, message);
+    }
+    const text = parsed ? extractFirstText(parsed) : null;
+    return text ?? "No results found. Try a different query.";
+  } catch (error) {
+    if (error instanceof Error) {
+      throw ToolError.executionFailed(toolId, error.message);
+    }
+    throw ToolError.executionFailed(toolId, String(error));
+  } finally {
+    await mcpClient.disconnect();
+  }
+}
+export {
+  callExaTool
+};

package/dist/implementations/exa-tools.test.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_core = require("@dexto/core");
+var import_exa_web_search_tool = require("./exa-web-search-tool.js");
+var import_exa_code_search_tool = require("./exa-code-search-tool.js");
+function createMockLogger() {
+  const logger = {
+    debug: import_vitest.vi.fn(),
+    silly: import_vitest.vi.fn(),
+    info: import_vitest.vi.fn(),
+    warn: import_vitest.vi.fn(),
+    error: import_vitest.vi.fn(),
+    trackException: import_vitest.vi.fn(),
+    createChild: import_vitest.vi.fn(() => logger),
+    setLevel: import_vitest.vi.fn(),
+    getLevel: import_vitest.vi.fn(() => "debug"),
+    getLogFilePath: import_vitest.vi.fn(() => null),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+}
+function createToolContext(logger) {
+  return { logger };
+}
+(0, import_vitest.describe)("Exa built-in tools", () => {
+  const connectSpy = import_vitest.vi.spyOn(import_core.DextoMcpClient.prototype, "connect");
+  const disconnectSpy = import_vitest.vi.spyOn(import_core.DextoMcpClient.prototype, "disconnect");
+  const getConnectedClientSpy = import_vitest.vi.spyOn(import_core.DextoMcpClient.prototype, "getConnectedClient");
+  (0, import_vitest.beforeEach)(() => {
+    connectSpy.mockResolvedValue({});
+    disconnectSpy.mockResolvedValue();
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.resetAllMocks();
+  });
+  (0, import_vitest.it)("web_search calls web_search_exa and returns the first text content", async () => {
+    const callTool = import_vitest.vi.fn().mockResolvedValue({
+      content: [{ type: "text", text: "hello from exa" }]
+    });
+    getConnectedClientSpy.mockResolvedValue({ callTool });
+    const tool = (0, import_exa_web_search_tool.createWebSearchTool)();
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const input = tool.inputSchema.parse({ query: "what is dexto" });
+    const result = await tool.execute(input, context);
+    (0, import_vitest.expect)(result).toBe("hello from exa");
+    (0, import_vitest.expect)(callTool).toHaveBeenCalledWith(
+      {
+        name: "web_search_exa",
+        arguments: import_vitest.expect.objectContaining({ query: "what is dexto" })
+      },
+      void 0,
+      import_vitest.expect.objectContaining({ timeout: 25e3, resetTimeoutOnProgress: true })
+    );
+  });
+  (0, import_vitest.it)("code_search calls get_code_context_exa and returns the first text content", async () => {
+    const callTool = import_vitest.vi.fn().mockResolvedValue({
+      content: [{ type: "text", text: "code context" }]
+    });
+    getConnectedClientSpy.mockResolvedValue({ callTool });
+    const tool = (0, import_exa_code_search_tool.createCodeSearchTool)();
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const input = tool.inputSchema.parse({ query: "react useState", tokensNum: 2e3 });
+    const result = await tool.execute(input, context);
+    (0, import_vitest.expect)(result).toBe("code context");
+    (0, import_vitest.expect)(callTool).toHaveBeenCalledWith(
+      {
+        name: "get_code_context_exa",
+        arguments: import_vitest.expect.objectContaining({ query: "react useState", tokensNum: 2e3 })
+      },
+      void 0,
+      import_vitest.expect.objectContaining({ timeout: 3e4, resetTimeoutOnProgress: true })
+    );
+  });
+  (0, import_vitest.it)("throws ToolError.executionFailed when Exa returns an MCP error result", async () => {
+    const callTool = import_vitest.vi.fn().mockResolvedValue({
+      isError: true,
+      content: [{ type: "text", text: "bad input" }]
+    });
+    getConnectedClientSpy.mockResolvedValue({ callTool });
+    const tool = (0, import_exa_web_search_tool.createWebSearchTool)();
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const input = tool.inputSchema.parse({ query: "x" });
+    await (0, import_vitest.expect)(tool.execute(input, context)).rejects.toMatchObject({
+      name: "DextoRuntimeError",
+      code: "tools_execution_failed"
+    });
+  });
+});

package/dist/implementations/exa-tools.test.d.cts

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

package/dist/implementations/exa-tools.test.d.ts

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

package/dist/implementations/exa-tools.test.d.ts.map

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

package/dist/implementations/exa-tools.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { DextoMcpClient } from "@dexto/core";
+import { createWebSearchTool } from "./exa-web-search-tool.js";
+import { createCodeSearchTool } from "./exa-code-search-tool.js";
+function createMockLogger() {
+  const logger = {
+    debug: vi.fn(),
+    silly: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    trackException: vi.fn(),
+    createChild: vi.fn(() => logger),
+    setLevel: vi.fn(),
+    getLevel: vi.fn(() => "debug"),
+    getLogFilePath: vi.fn(() => null),
+    destroy: vi.fn(async () => void 0)
+  };
+  return logger;
+}
+function createToolContext(logger) {
+  return { logger };
+}
+describe("Exa built-in tools", () => {
+  const connectSpy = vi.spyOn(DextoMcpClient.prototype, "connect");
+  const disconnectSpy = vi.spyOn(DextoMcpClient.prototype, "disconnect");
+  const getConnectedClientSpy = vi.spyOn(DextoMcpClient.prototype, "getConnectedClient");
+  beforeEach(() => {
+    connectSpy.mockResolvedValue({});
+    disconnectSpy.mockResolvedValue();
+  });
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+  it("web_search calls web_search_exa and returns the first text content", async () => {
+    const callTool = vi.fn().mockResolvedValue({
+      content: [{ type: "text", text: "hello from exa" }]
+    });
+    getConnectedClientSpy.mockResolvedValue({ callTool });
+    const tool = createWebSearchTool();
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const input = tool.inputSchema.parse({ query: "what is dexto" });
+    const result = await tool.execute(input, context);
+    expect(result).toBe("hello from exa");
+    expect(callTool).toHaveBeenCalledWith(
+      {
+        name: "web_search_exa",
+        arguments: expect.objectContaining({ query: "what is dexto" })
+      },
+      void 0,
+      expect.objectContaining({ timeout: 25e3, resetTimeoutOnProgress: true })
+    );
+  });
+  it("code_search calls get_code_context_exa and returns the first text content", async () => {
+    const callTool = vi.fn().mockResolvedValue({
+      content: [{ type: "text", text: "code context" }]
+    });
+    getConnectedClientSpy.mockResolvedValue({ callTool });
+    const tool = createCodeSearchTool();
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const input = tool.inputSchema.parse({ query: "react useState", tokensNum: 2e3 });
+    const result = await tool.execute(input, context);
+    expect(result).toBe("code context");
+    expect(callTool).toHaveBeenCalledWith(
+      {
+        name: "get_code_context_exa",
+        arguments: expect.objectContaining({ query: "react useState", tokensNum: 2e3 })
+      },
+      void 0,
+      expect.objectContaining({ timeout: 3e4, resetTimeoutOnProgress: true })
+    );
+  });
+  it("throws ToolError.executionFailed when Exa returns an MCP error result", async () => {
+    const callTool = vi.fn().mockResolvedValue({
+      isError: true,
+      content: [{ type: "text", text: "bad input" }]
+    });
+    getConnectedClientSpy.mockResolvedValue({ callTool });
+    const tool = createWebSearchTool();
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const input = tool.inputSchema.parse({ query: "x" });
+    await expect(tool.execute(input, context)).rejects.toMatchObject({
+      name: "DextoRuntimeError",
+      code: "tools_execution_failed"
+    });
+  });
+});

package/dist/implementations/exa-web-search-tool.cjs

@@ -0,0 +1,63 @@
+"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 exa_web_search_tool_exports = {};
+__export(exa_web_search_tool_exports, {
+  createWebSearchTool: () => createWebSearchTool
+});
+module.exports = __toCommonJS(exa_web_search_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_exa_mcp = require("./exa-mcp.js");
+const WebSearchInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1).describe("Web search query"),
+  numResults: import_zod.z.number().int().positive().optional().default(8).describe("Number of results to return (default: 8)"),
+  livecrawl: import_zod.z.enum(["fallback", "preferred"]).optional().default("fallback").describe(
+    "Live crawl mode - 'fallback' uses cached content when available, 'preferred' prioritizes live crawling"
+  ),
+  type: import_zod.z.enum(["auto", "fast"]).optional().default("auto").describe("Search type - 'auto' (default) or 'fast'"),
+  contextMaxCharacters: import_zod.z.number().int().positive().optional().default(1e4).describe("Maximum context length in characters (default: 10000)")
+}).strict();
+function createWebSearchTool() {
+  return (0, import_core.defineTool)({
+    id: "web_search",
+    displayName: "Web Search",
+    description: "Search the web for current information and return clean, ready-to-use text. Use for news, facts, and up-to-date context.",
+    inputSchema: WebSearchInputSchema,
+    async execute(input, context) {
+      const { query, numResults, livecrawl, type, contextMaxCharacters } = input;
+      return await (0, import_exa_mcp.callExaTool)({
+        logger: context.logger,
+        toolId: "web_search",
+        toolName: "web_search_exa",
+        args: {
+          query,
+          numResults,
+          livecrawl,
+          type,
+          contextMaxCharacters
+        },
+        timeoutMs: 25e3
+      });
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWebSearchTool
+});

package/dist/implementations/exa-web-search-tool.d.cts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+
+declare const WebSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    numResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    livecrawl: z.ZodDefault<z.ZodOptional<z.ZodEnum<["fallback", "preferred"]>>>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["auto", "fast"]>>>;
+    contextMaxCharacters: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    type: "auto" | "fast";
+    query: string;
+    numResults: number;
+    livecrawl: "fallback" | "preferred";
+    contextMaxCharacters: number;
+}, {
+    query: string;
+    type?: "auto" | "fast" | undefined;
+    numResults?: number | undefined;
+    livecrawl?: "fallback" | "preferred" | undefined;
+    contextMaxCharacters?: number | undefined;
+}>;
+/**
+ * Create the `web_search` tool.
+ *
+ * Performs a web search by calling Exa's MCP endpoint via the MCP SDK.
+ */
+declare function createWebSearchTool(): Tool<typeof WebSearchInputSchema>;
+
+export { createWebSearchTool };

package/dist/implementations/exa-web-search-tool.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+declare const WebSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    numResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    livecrawl: z.ZodDefault<z.ZodOptional<z.ZodEnum<["fallback", "preferred"]>>>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["auto", "fast"]>>>;
+    contextMaxCharacters: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    type: "auto" | "fast";
+    query: string;
+    numResults: number;
+    livecrawl: "fallback" | "preferred";
+    contextMaxCharacters: number;
+}, {
+    query: string;
+    type?: "auto" | "fast" | undefined;
+    numResults?: number | undefined;
+    livecrawl?: "fallback" | "preferred" | undefined;
+    contextMaxCharacters?: number | undefined;
+}>;
+/**
+ * Create the `web_search` tool.
+ *
+ * Performs a web search by calling Exa's MCP endpoint via the MCP SDK.
+ */
+export declare function createWebSearchTool(): Tool<typeof WebSearchInputSchema>;
+export {};
+//# sourceMappingURL=exa-web-search-tool.d.ts.map

package/dist/implementations/exa-web-search-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exa-web-search-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-web-search-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AACd;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAyBvE"}

package/dist/implementations/exa-web-search-tool.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineTool } from "@dexto/core";
+import { callExaTool } from "./exa-mcp.js";
+const WebSearchInputSchema = z.object({
+  query: z.string().min(1).describe("Web search query"),
+  numResults: z.number().int().positive().optional().default(8).describe("Number of results to return (default: 8)"),
+  livecrawl: z.enum(["fallback", "preferred"]).optional().default("fallback").describe(
+    "Live crawl mode - 'fallback' uses cached content when available, 'preferred' prioritizes live crawling"
+  ),
+  type: z.enum(["auto", "fast"]).optional().default("auto").describe("Search type - 'auto' (default) or 'fast'"),
+  contextMaxCharacters: z.number().int().positive().optional().default(1e4).describe("Maximum context length in characters (default: 10000)")
+}).strict();
+function createWebSearchTool() {
+  return defineTool({
+    id: "web_search",
+    displayName: "Web Search",
+    description: "Search the web for current information and return clean, ready-to-use text. Use for news, facts, and up-to-date context.",
+    inputSchema: WebSearchInputSchema,
+    async execute(input, context) {
+      const { query, numResults, livecrawl, type, contextMaxCharacters } = input;
+      return await callExaTool({
+        logger: context.logger,
+        toolId: "web_search",
+        toolName: "web_search_exa",
+        args: {
+          query,
+          numResults,
+          livecrawl,
+          type,
+          contextMaxCharacters
+        },
+        timeoutMs: 25e3
+      });
+    }
+  });
+}
+export {
+  createWebSearchTool
+};