@dexto/tools-builtins 1.6.0

package/dist/implementations/delegate-to-url-tool.cjs

@@ -0,0 +1,183 @@
+"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 delegate_to_url_tool_exports = {};
+__export(delegate_to_url_tool_exports, {
+  createDelegateToUrlTool: () => createDelegateToUrlTool
+});
+module.exports = __toCommonJS(delegate_to_url_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+const DelegateToUrlInputSchema = import_zod.z.object({
+  url: import_zod.z.string().url().describe(
+    'The A2A-compliant agent URL (e.g., "http://localhost:3001" or "https://agent.example.com"). The tool will automatically append the correct JSON-RPC endpoint.'
+  ),
+  message: import_zod.z.string().min(1).describe(
+    "The message or task to delegate to the agent. This will be sent as natural language input."
+  ),
+  sessionId: import_zod.z.string().optional().describe(
+    "Optional session ID for maintaining conversation state across multiple delegations to the same agent"
+  ),
+  timeout: import_zod.z.number().optional().default(3e4).describe("Request timeout in milliseconds (default: 30000)")
+}).strict();
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+class SimpleA2AClient {
+  url;
+  timeout;
+  constructor(url, timeout = 3e4) {
+    this.url = url.replace(/\/$/, "");
+    this.timeout = timeout;
+  }
+  async sendMessage(message, sessionId) {
+    const messageId = this.generateId();
+    const taskId = sessionId || this.generateId();
+    const a2aMessage = {
+      role: "user",
+      parts: [
+        {
+          kind: "text",
+          text: message
+        }
+      ],
+      messageId,
+      taskId,
+      contextId: taskId,
+      kind: "message"
+    };
+    const rpcRequest = {
+      jsonrpc: "2.0",
+      id: this.generateId(),
+      method: "message/send",
+      params: {
+        message: a2aMessage,
+        configuration: {
+          blocking: true
+        }
+      }
+    };
+    const endpoints = [`${this.url}/v1/jsonrpc`, `${this.url}/jsonrpc`];
+    let lastError = null;
+    for (const endpoint of endpoints) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "@dexto/core"
+          },
+          body: JSON.stringify(rpcRequest),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          lastError = new Error(
+            `HTTP ${response.status}: ${response.statusText} (tried ${endpoint})`
+          );
+          continue;
+        }
+        const data = await response.json();
+        if (isPlainObject(data) && "error" in data && data.error) {
+          const errorMessage = isPlainObject(data.error) && typeof data.error.message === "string" ? data.error.message : "Unknown error";
+          throw new Error(`Agent returned error: ${errorMessage}`);
+        }
+        if (isPlainObject(data) && "result" in data) {
+          return this.extractTaskResponse(data.result);
+        }
+        return data;
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new import_core.DextoRuntimeError(
+            "DELEGATION_TIMEOUT",
+            import_core.ErrorScope.TOOLS,
+            import_core.ErrorType.TIMEOUT,
+            `Delegation timeout after ${this.timeout}ms`
+          );
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    throw new import_core.DextoRuntimeError(
+      "DELEGATION_FAILED",
+      import_core.ErrorScope.TOOLS,
+      import_core.ErrorType.THIRD_PARTY,
+      `Failed to connect to agent at ${this.url}. Tried endpoints: ${endpoints.join(", ")}. Last error: ${lastError?.message || "Unknown error"}`
+    );
+  }
+  extractTaskResponse(task) {
+    if (isPlainObject(task) && Array.isArray(task.history)) {
+      const agentMessages = task.history.filter(
+        (message) => isPlainObject(message) && message.role === "agent"
+      );
+      if (agentMessages.length > 0) {
+        const lastMessage = agentMessages[agentMessages.length - 1];
+        if (lastMessage && Array.isArray(lastMessage.parts)) {
+          const textParts = lastMessage.parts.filter(
+            (part) => isPlainObject(part) && part.kind === "text"
+          ).map((part) => part.text).filter((text) => typeof text === "string");
+          return textParts.join("\n");
+        }
+      }
+    }
+    return JSON.stringify(task, null, 2);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+}
+function createDelegateToUrlTool() {
+  return (0, import_core.defineTool)({
+    id: "delegate_to_url",
+    displayName: "Delegate",
+    description: 'Delegate a task to another A2A-compliant agent at a specific URL. Supports STATEFUL multi-turn conversations via sessionId parameter. USAGE: (1) First delegation: provide url + message. Tool returns a response AND a sessionId. (2) Follow-up: use the SAME sessionId to continue the conversation with that agent. The agent remembers previous context. EXAMPLE: First call {url: "http://agent:3001", message: "Analyze data X"} returns {sessionId: "xyz", response: "..."}. Second call {url: "http://agent:3001", message: "What was the top insight?", sessionId: "xyz"}. The agent will remember the first analysis and can answer specifically.',
+    inputSchema: DelegateToUrlInputSchema,
+    async execute(input, _context) {
+      const { url, message, sessionId, timeout } = input;
+      try {
+        const client = new SimpleA2AClient(url, timeout);
+        const effectiveSessionId = sessionId || `delegation-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const response = await client.sendMessage(message, effectiveSessionId);
+        return {
+          success: true,
+          agentUrl: url,
+          sessionId: effectiveSessionId,
+          response,
+          _hint: sessionId ? "Continued existing conversation" : "Started new conversation - use this sessionId for follow-ups"
+        };
+      } catch (error) {
+        if (error instanceof import_core.DextoRuntimeError) {
+          throw error;
+        }
+        throw new import_core.DextoRuntimeError(
+          "DELEGATION_ERROR",
+          import_core.ErrorScope.TOOLS,
+          import_core.ErrorType.SYSTEM,
+          `Delegation failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDelegateToUrlTool
+});

package/dist/implementations/delegate-to-url-tool.d.cts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+
+declare const DelegateToUrlInputSchema: z.ZodObject<{
+    url: z.ZodString;
+    message: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    timeout: number;
+    message: string;
+    url: string;
+    sessionId?: string | undefined;
+}, {
+    message: string;
+    url: string;
+    timeout?: number | undefined;
+    sessionId?: string | undefined;
+}>;
+/**
+ * Create the `delegate_to_url` tool.
+ *
+ * Delegates a message/task to another A2A-compliant agent URL via JSON-RPC and returns its response.
+ */
+declare function createDelegateToUrlTool(): Tool<typeof DelegateToUrlInputSchema>;
+
+export { createDelegateToUrlTool };

package/dist/implementations/delegate-to-url-tool.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+declare const DelegateToUrlInputSchema: z.ZodObject<{
+    url: z.ZodString;
+    message: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    url: string;
+    timeout: number;
+    sessionId?: string | undefined;
+}, {
+    message: string;
+    url: string;
+    sessionId?: string | undefined;
+    timeout?: number | undefined;
+}>;
+/**
+ * Create the `delegate_to_url` tool.
+ *
+ * Delegates a message/task to another A2A-compliant agent URL via JSON-RPC and returns its response.
+ */
+export declare function createDelegateToUrlTool(): Tool<typeof DelegateToUrlInputSchema>;
+export {};
+//# sourceMappingURL=delegate-to-url-tool.d.ts.map

package/dist/implementations/delegate-to-url-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-to-url-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/delegate-to-url-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;EA0BjB,CAAC;AAsJd;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAAC,OAAO,wBAAwB,CAAC,CAyC/E"}

package/dist/implementations/delegate-to-url-tool.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { DextoRuntimeError, ErrorScope, ErrorType, defineTool } from "@dexto/core";
+const DelegateToUrlInputSchema = z.object({
+  url: z.string().url().describe(
+    'The A2A-compliant agent URL (e.g., "http://localhost:3001" or "https://agent.example.com"). The tool will automatically append the correct JSON-RPC endpoint.'
+  ),
+  message: z.string().min(1).describe(
+    "The message or task to delegate to the agent. This will be sent as natural language input."
+  ),
+  sessionId: z.string().optional().describe(
+    "Optional session ID for maintaining conversation state across multiple delegations to the same agent"
+  ),
+  timeout: z.number().optional().default(3e4).describe("Request timeout in milliseconds (default: 30000)")
+}).strict();
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+class SimpleA2AClient {
+  url;
+  timeout;
+  constructor(url, timeout = 3e4) {
+    this.url = url.replace(/\/$/, "");
+    this.timeout = timeout;
+  }
+  async sendMessage(message, sessionId) {
+    const messageId = this.generateId();
+    const taskId = sessionId || this.generateId();
+    const a2aMessage = {
+      role: "user",
+      parts: [
+        {
+          kind: "text",
+          text: message
+        }
+      ],
+      messageId,
+      taskId,
+      contextId: taskId,
+      kind: "message"
+    };
+    const rpcRequest = {
+      jsonrpc: "2.0",
+      id: this.generateId(),
+      method: "message/send",
+      params: {
+        message: a2aMessage,
+        configuration: {
+          blocking: true
+        }
+      }
+    };
+    const endpoints = [`${this.url}/v1/jsonrpc`, `${this.url}/jsonrpc`];
+    let lastError = null;
+    for (const endpoint of endpoints) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "@dexto/core"
+          },
+          body: JSON.stringify(rpcRequest),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          lastError = new Error(
+            `HTTP ${response.status}: ${response.statusText} (tried ${endpoint})`
+          );
+          continue;
+        }
+        const data = await response.json();
+        if (isPlainObject(data) && "error" in data && data.error) {
+          const errorMessage = isPlainObject(data.error) && typeof data.error.message === "string" ? data.error.message : "Unknown error";
+          throw new Error(`Agent returned error: ${errorMessage}`);
+        }
+        if (isPlainObject(data) && "result" in data) {
+          return this.extractTaskResponse(data.result);
+        }
+        return data;
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new DextoRuntimeError(
+            "DELEGATION_TIMEOUT",
+            ErrorScope.TOOLS,
+            ErrorType.TIMEOUT,
+            `Delegation timeout after ${this.timeout}ms`
+          );
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    throw new DextoRuntimeError(
+      "DELEGATION_FAILED",
+      ErrorScope.TOOLS,
+      ErrorType.THIRD_PARTY,
+      `Failed to connect to agent at ${this.url}. Tried endpoints: ${endpoints.join(", ")}. Last error: ${lastError?.message || "Unknown error"}`
+    );
+  }
+  extractTaskResponse(task) {
+    if (isPlainObject(task) && Array.isArray(task.history)) {
+      const agentMessages = task.history.filter(
+        (message) => isPlainObject(message) && message.role === "agent"
+      );
+      if (agentMessages.length > 0) {
+        const lastMessage = agentMessages[agentMessages.length - 1];
+        if (lastMessage && Array.isArray(lastMessage.parts)) {
+          const textParts = lastMessage.parts.filter(
+            (part) => isPlainObject(part) && part.kind === "text"
+          ).map((part) => part.text).filter((text) => typeof text === "string");
+          return textParts.join("\n");
+        }
+      }
+    }
+    return JSON.stringify(task, null, 2);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+}
+function createDelegateToUrlTool() {
+  return defineTool({
+    id: "delegate_to_url",
+    displayName: "Delegate",
+    description: 'Delegate a task to another A2A-compliant agent at a specific URL. Supports STATEFUL multi-turn conversations via sessionId parameter. USAGE: (1) First delegation: provide url + message. Tool returns a response AND a sessionId. (2) Follow-up: use the SAME sessionId to continue the conversation with that agent. The agent remembers previous context. EXAMPLE: First call {url: "http://agent:3001", message: "Analyze data X"} returns {sessionId: "xyz", response: "..."}. Second call {url: "http://agent:3001", message: "What was the top insight?", sessionId: "xyz"}. The agent will remember the first analysis and can answer specifically.',
+    inputSchema: DelegateToUrlInputSchema,
+    async execute(input, _context) {
+      const { url, message, sessionId, timeout } = input;
+      try {
+        const client = new SimpleA2AClient(url, timeout);
+        const effectiveSessionId = sessionId || `delegation-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const response = await client.sendMessage(message, effectiveSessionId);
+        return {
+          success: true,
+          agentUrl: url,
+          sessionId: effectiveSessionId,
+          response,
+          _hint: sessionId ? "Continued existing conversation" : "Started new conversation - use this sessionId for follow-ups"
+        };
+      } catch (error) {
+        if (error instanceof DextoRuntimeError) {
+          throw error;
+        }
+        throw new DextoRuntimeError(
+          "DELEGATION_ERROR",
+          ErrorScope.TOOLS,
+          ErrorType.SYSTEM,
+          `Delegation failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  });
+}
+export {
+  createDelegateToUrlTool
+};

package/dist/implementations/delegate-to-url-tool.test.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_delegate_to_url_tool = require("./delegate-to-url-tool.js");
+var import_core = require("@dexto/core");
+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)("delegate_to_url tool", () => {
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.unstubAllGlobals();
+  });
+  (0, import_vitest.it)("throws DELEGATION_FAILED when it cannot reach the remote agent", async () => {
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const fetchMock = import_vitest.vi.fn(async () => {
+      throw new Error("boom");
+    });
+    import_vitest.vi.stubGlobal("fetch", fetchMock);
+    const tool = (0, import_delegate_to_url_tool.createDelegateToUrlTool)();
+    const input = tool.inputSchema.parse({
+      url: "http://example.com",
+      message: "hi",
+      timeout: 1
+    });
+    await (0, import_vitest.expect)(tool.execute(input, context)).rejects.toMatchObject({
+      name: "DextoRuntimeError",
+      code: "DELEGATION_FAILED",
+      scope: import_core.ErrorScope.TOOLS,
+      type: import_core.ErrorType.THIRD_PARTY
+    });
+  });
+  (0, import_vitest.it)("throws DELEGATION_TIMEOUT when the request times out", async () => {
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const abortError = new Error("aborted");
+    abortError.name = "AbortError";
+    const fetchMock = import_vitest.vi.fn(async () => {
+      throw abortError;
+    });
+    import_vitest.vi.stubGlobal("fetch", fetchMock);
+    const tool = (0, import_delegate_to_url_tool.createDelegateToUrlTool)();
+    const input = tool.inputSchema.parse({
+      url: "http://example.com",
+      message: "hi",
+      timeout: 1
+    });
+    try {
+      await tool.execute(input, context);
+      import_vitest.expect.fail("Expected tool.execute() to throw");
+    } catch (error) {
+      (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+      (0, import_vitest.expect)(error).toMatchObject({
+        code: "DELEGATION_TIMEOUT",
+        scope: import_core.ErrorScope.TOOLS,
+        type: import_core.ErrorType.TIMEOUT
+      });
+    }
+  });
+});

package/dist/implementations/delegate-to-url-tool.test.d.cts

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

package/dist/implementations/delegate-to-url-tool.test.d.ts

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

package/dist/implementations/delegate-to-url-tool.test.d.ts.map

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

package/dist/implementations/delegate-to-url-tool.test.js

@@ -0,0 +1,74 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDelegateToUrlTool } from "./delegate-to-url-tool.js";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
+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("delegate_to_url tool", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+  it("throws DELEGATION_FAILED when it cannot reach the remote agent", async () => {
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const fetchMock = vi.fn(async () => {
+      throw new Error("boom");
+    });
+    vi.stubGlobal("fetch", fetchMock);
+    const tool = createDelegateToUrlTool();
+    const input = tool.inputSchema.parse({
+      url: "http://example.com",
+      message: "hi",
+      timeout: 1
+    });
+    await expect(tool.execute(input, context)).rejects.toMatchObject({
+      name: "DextoRuntimeError",
+      code: "DELEGATION_FAILED",
+      scope: ErrorScope.TOOLS,
+      type: ErrorType.THIRD_PARTY
+    });
+  });
+  it("throws DELEGATION_TIMEOUT when the request times out", async () => {
+    const logger = createMockLogger();
+    const context = createToolContext(logger);
+    const abortError = new Error("aborted");
+    abortError.name = "AbortError";
+    const fetchMock = vi.fn(async () => {
+      throw abortError;
+    });
+    vi.stubGlobal("fetch", fetchMock);
+    const tool = createDelegateToUrlTool();
+    const input = tool.inputSchema.parse({
+      url: "http://example.com",
+      message: "hi",
+      timeout: 1
+    });
+    try {
+      await tool.execute(input, context);
+      expect.fail("Expected tool.execute() to throw");
+    } catch (error) {
+      expect(error).toBeInstanceOf(DextoRuntimeError);
+      expect(error).toMatchObject({
+        code: "DELEGATION_TIMEOUT",
+        scope: ErrorScope.TOOLS,
+        type: ErrorType.TIMEOUT
+      });
+    }
+  });
+});

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

@@ -0,0 +1,57 @@
+"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_code_search_tool_exports = {};
+__export(exa_code_search_tool_exports, {
+  createCodeSearchTool: () => createCodeSearchTool
+});
+module.exports = __toCommonJS(exa_code_search_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_exa_mcp = require("./exa-mcp.js");
+const CodeSearchInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1).describe(
+    "Search query for code examples and documentation (e.g., 'React useState examples', 'Express middleware', 'Python pandas dataframe filtering')"
+  ),
+  tokensNum: import_zod.z.number().int().min(1e3).max(5e4).optional().default(5e3).describe("Approximate token budget to return (1000\u201350000, default: 5000)")
+}).strict();
+function createCodeSearchTool() {
+  return (0, import_core.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 (0, import_exa_mcp.callExaTool)({
+        logger: context.logger,
+        toolId: "code_search",
+        toolName: "get_code_context_exa",
+        args: {
+          query,
+          tokensNum
+        },
+        timeoutMs: 3e4
+      });
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCodeSearchTool
+});

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+
+declare const CodeSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    tokensNum: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    query: string;
+    tokensNum: number;
+}, {
+    query: string;
+    tokensNum?: number | undefined;
+}>;
+/**
+ * Create the `code_search` tool.
+ *
+ * Finds relevant code snippets and documentation by calling Exa's MCP endpoint via the MCP SDK.
+ */
+declare function createCodeSearchTool(): Tool<typeof CodeSearchInputSchema>;
+
+export { createCodeSearchTool };

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+declare const CodeSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    tokensNum: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    query: string;
+    tokensNum: number;
+}, {
+    query: string;
+    tokensNum?: number | undefined;
+}>;
+/**
+ * Create the `code_search` tool.
+ *
+ * Finds relevant code snippets and documentation by calling Exa's MCP endpoint via the MCP SDK.
+ */
+export declare function createCodeSearchTool(): Tool<typeof CodeSearchInputSchema>;
+export {};
+//# sourceMappingURL=exa-code-search-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exa-code-search-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-code-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,qBAAqB;;;;;;;;;EAiBd,CAAC;AACd;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAsBzE"}