@mastra/tavily 1.1.1 → 1.1.2-alpha.0

package/LICENSE.md

@@ -1,10 +1,12 @@
 Portions of this software are licensed as follows:
 
-- All content that resides under any directory named "ee/" within this
+- All content that resides under any directory named `ee/` within this
   repository, including but not limited to:
-  - `packages/core/src/auth/ee/`
-  - `packages/server/src/server/auth/ee/`
-    is licensed under the license defined in `ee/LICENSE`.
+  - `@mastra/core/auth/ee`
+  - `@mastra/core/agent-builder/ee`
+  - `@mastra/editor/ee`
+
+  is licensed under the license defined in [`ee/LICENSE`](https://github.com/mastra-ai/mastra/blob/main/ee/LICENSE).
 
 - All third-party components incorporated into the Mastra Software are
   licensed under the original license provided by the owner of the

package/dist/crawl.d.ts

@@ -10,7 +10,7 @@ export declare function createTavilyCrawlTool(config?: TavilyClientOptions): imp
     excludePaths?: string[] | undefined;
     excludeDomains?: string[] | undefined;
     allowExternal?: boolean | undefined;
-    extractDepth?: "basic" | "advanced" | undefined;
+    extractDepth?: "advanced" | "basic" | undefined;
     includeImages?: boolean | undefined;
     format?: "markdown" | "text" | undefined;
 }, {

package/dist/extract.d.ts

@@ -1,7 +1,7 @@
 import type { TavilyClientOptions } from './client.js';
 export declare function createTavilyExtractTool(config?: TavilyClientOptions): import("@mastra/core/tools").Tool<{
     urls: string[];
-    extractDepth?: "basic" | "advanced" | undefined;
+    extractDepth?: "advanced" | "basic" | undefined;
     query?: string | undefined;
     includeImages?: boolean | undefined;
     format?: "markdown" | "text" | undefined;

package/dist/index.cjs

@@ -1,287 +1,283 @@
-'use strict';
-
-var core = require('@tavily/core');
-var tools = require('@mastra/core/tools');
-var zod = require('zod');
-
-// src/client.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _tavily_core = require("@tavily/core");
+let _mastra_core_tools = require("@mastra/core/tools");
+let zod = require("zod");
+//#region src/client.ts
 function getTavilyClient(config) {
-  const apiKey = config?.apiKey ?? process.env.TAVILY_API_KEY;
-  if (!apiKey) {
-    throw new Error("Tavily API key is required. Pass { apiKey } or set TAVILY_API_KEY env var.");
-  }
-  return core.tavily({ ...config, apiKey, clientName: config?.clientName ?? "mastra" });
+	const apiKey = config?.apiKey ?? process.env.TAVILY_API_KEY;
+	if (!apiKey) throw new Error("Tavily API key is required. Pass { apiKey } or set TAVILY_API_KEY env var.");
+	return (0, _tavily_core.tavily)({
+		...config,
+		apiKey,
+		clientName: config?.clientName ?? "mastra"
+	});
 }
-var inputSchema = zod.z.object({
-  query: zod.z.string().describe("The search query"),
-  searchDepth: zod.z.enum(["basic", "advanced", "fast", "ultra-fast"]).optional().describe("Search depth \u2014 'basic' for standard, 'advanced' for thorough, 'fast'/'ultra-fast' for low latency"),
-  maxResults: zod.z.number().min(1).max(20).optional().describe("Maximum number of results to return (1-20)"),
-  includeAnswer: zod.z.union([zod.z.boolean(), zod.z.enum(["basic", "advanced"])]).optional().describe('Include an AI-generated answer summary. Pass true, "basic", or "advanced"'),
-  includeImages: zod.z.boolean().optional().describe("Include query-related images in the response"),
-  includeImageDescriptions: zod.z.boolean().optional().describe("Include descriptions for returned images"),
-  includeRawContent: zod.z.union([zod.z.literal(false), zod.z.enum(["markdown", "text"])]).optional().describe('Include cleaned HTML content of each result. Pass false to disable, or "markdown"/"text" for format'),
-  includeDomains: zod.z.array(zod.z.string()).optional().describe("Restrict results to these domains"),
-  excludeDomains: zod.z.array(zod.z.string()).optional().describe("Exclude results from these domains"),
-  timeRange: zod.z.enum(["day", "week", "month", "year"]).optional().describe("Time range to filter results by recency")
+//#endregion
+//#region src/search.ts
+const inputSchema$3 = zod.z.object({
+	query: zod.z.string().describe("The search query"),
+	searchDepth: zod.z.enum([
+		"basic",
+		"advanced",
+		"fast",
+		"ultra-fast"
+	]).optional().describe("Search depth — 'basic' for standard, 'advanced' for thorough, 'fast'/'ultra-fast' for low latency"),
+	maxResults: zod.z.number().min(1).max(20).optional().describe("Maximum number of results to return (1-20)"),
+	includeAnswer: zod.z.union([zod.z.boolean(), zod.z.enum(["basic", "advanced"])]).optional().describe("Include an AI-generated answer summary. Pass true, \"basic\", or \"advanced\""),
+	includeImages: zod.z.boolean().optional().describe("Include query-related images in the response"),
+	includeImageDescriptions: zod.z.boolean().optional().describe("Include descriptions for returned images"),
+	includeRawContent: zod.z.union([zod.z.literal(false), zod.z.enum(["markdown", "text"])]).optional().describe("Include cleaned HTML content of each result. Pass false to disable, or \"markdown\"/\"text\" for format"),
+	includeDomains: zod.z.array(zod.z.string()).optional().describe("Restrict results to these domains"),
+	excludeDomains: zod.z.array(zod.z.string()).optional().describe("Exclude results from these domains"),
+	timeRange: zod.z.enum([
+		"day",
+		"week",
+		"month",
+		"year"
+	]).optional().describe("Time range to filter results by recency")
 });
-var outputSchema = zod.z.object({
-  query: zod.z.string(),
-  answer: zod.z.string().optional(),
-  images: zod.z.array(
-    zod.z.object({
-      url: zod.z.string(),
-      description: zod.z.string().optional()
-    })
-  ).optional(),
-  results: zod.z.array(
-    zod.z.object({
-      title: zod.z.string(),
-      url: zod.z.string(),
-      content: zod.z.string(),
-      score: zod.z.number(),
-      rawContent: zod.z.string().optional()
-    })
-  ),
-  responseTime: zod.z.number()
+const outputSchema$3 = zod.z.object({
+	query: zod.z.string(),
+	answer: zod.z.string().optional(),
+	images: zod.z.array(zod.z.object({
+		url: zod.z.string(),
+		description: zod.z.string().optional()
+	})).optional(),
+	results: zod.z.array(zod.z.object({
+		title: zod.z.string(),
+		url: zod.z.string(),
+		content: zod.z.string(),
+		score: zod.z.number(),
+		rawContent: zod.z.string().optional()
+	})),
+	responseTime: zod.z.number()
 });
 function createTavilySearchTool(config) {
-  let client = null;
-  function getClient() {
-    if (!client) {
-      client = getTavilyClient(config);
-    }
-    return client;
-  }
-  return tools.createTool({
-    id: "tavily-search",
-    description: "Search the web using Tavily. Returns relevant results with content snippets, optional AI-generated answers, and images. Supports filtering by domain, time range, and search depth.",
-    inputSchema,
-    outputSchema,
-    execute: async (input) => {
-      const tavilyClient = getClient();
-      const response = await tavilyClient.search(input.query, {
-        searchDepth: input.searchDepth,
-        maxResults: input.maxResults,
-        includeAnswer: input.includeAnswer,
-        includeImages: input.includeImages,
-        includeImageDescriptions: input.includeImageDescriptions,
-        includeRawContent: input.includeRawContent,
-        includeDomains: input.includeDomains,
-        excludeDomains: input.excludeDomains,
-        timeRange: input.timeRange
-      });
-      return {
-        query: response.query,
-        answer: response.answer || void 0,
-        images: response.images?.map((img) => ({
-          url: typeof img === "string" ? img : img.url,
-          description: typeof img === "string" ? void 0 : img.description
-        })),
-        results: (response.results ?? []).map((r) => ({
-          title: r.title,
-          url: r.url,
-          content: r.content,
-          score: r.score ?? 0,
-          rawContent: r.rawContent || void 0
-        })),
-        responseTime: response.responseTime
-      };
-    }
-  });
+	let client = null;
+	function getClient() {
+		if (!client) client = getTavilyClient(config);
+		return client;
+	}
+	return (0, _mastra_core_tools.createTool)({
+		id: "tavily-search",
+		description: "Search the web using Tavily. Returns relevant results with content snippets, optional AI-generated answers, and images. Supports filtering by domain, time range, and search depth.",
+		inputSchema: inputSchema$3,
+		outputSchema: outputSchema$3,
+		execute: async (input) => {
+			const response = await getClient().search(input.query, {
+				searchDepth: input.searchDepth,
+				maxResults: input.maxResults,
+				includeAnswer: input.includeAnswer,
+				includeImages: input.includeImages,
+				includeImageDescriptions: input.includeImageDescriptions,
+				includeRawContent: input.includeRawContent,
+				includeDomains: input.includeDomains,
+				excludeDomains: input.excludeDomains,
+				timeRange: input.timeRange
+			});
+			return {
+				query: response.query,
+				answer: response.answer || void 0,
+				images: response.images?.map((img) => ({
+					url: typeof img === "string" ? img : img.url,
+					description: typeof img === "string" ? void 0 : img.description
+				})),
+				results: (response.results ?? []).map((r) => ({
+					title: r.title,
+					url: r.url,
+					content: r.content,
+					score: r.score ?? 0,
+					rawContent: r.rawContent || void 0
+				})),
+				responseTime: response.responseTime
+			};
+		}
+	});
 }
-var inputSchema2 = zod.z.object({
-  urls: zod.z.array(zod.z.string()).min(1).max(20).describe("URLs to extract content from (1-20)"),
-  extractDepth: zod.z.enum(["basic", "advanced"]).optional().describe("Extraction depth \u2014 'advanced' retrieves more data including tables and embedded content"),
-  query: zod.z.string().optional().describe("User intent for reranking extracted content chunks. When provided, chunks are reranked based on relevance to this query."),
-  includeImages: zod.z.boolean().optional().describe("Include images extracted from the pages"),
-  format: zod.z.enum(["markdown", "text"]).optional().describe("Output format for extracted content \u2014 'markdown' (default) or 'text'")
+//#endregion
+//#region src/extract.ts
+const inputSchema$2 = zod.z.object({
+	urls: zod.z.array(zod.z.string()).min(1).max(20).describe("URLs to extract content from (1-20)"),
+	extractDepth: zod.z.enum(["basic", "advanced"]).optional().describe("Extraction depth — 'advanced' retrieves more data including tables and embedded content"),
+	query: zod.z.string().optional().describe("User intent for reranking extracted content chunks. When provided, chunks are reranked based on relevance to this query."),
+	includeImages: zod.z.boolean().optional().describe("Include images extracted from the pages"),
+	format: zod.z.enum(["markdown", "text"]).optional().describe("Output format for extracted content — 'markdown' (default) or 'text'")
 });
-var outputSchema2 = zod.z.object({
-  results: zod.z.array(
-    zod.z.object({
-      url: zod.z.string(),
-      rawContent: zod.z.string(),
-      images: zod.z.array(zod.z.string()).optional()
-    })
-  ),
-  failedResults: zod.z.array(
-    zod.z.object({
-      url: zod.z.string(),
-      error: zod.z.string()
-    })
-  ),
-  responseTime: zod.z.number()
+const outputSchema$2 = zod.z.object({
+	results: zod.z.array(zod.z.object({
+		url: zod.z.string(),
+		rawContent: zod.z.string(),
+		images: zod.z.array(zod.z.string()).optional()
+	})),
+	failedResults: zod.z.array(zod.z.object({
+		url: zod.z.string(),
+		error: zod.z.string()
+	})),
+	responseTime: zod.z.number()
 });
 function createTavilyExtractTool(config) {
-  let client = null;
-  function getClient() {
-    if (!client) {
-      client = getTavilyClient(config);
-    }
-    return client;
-  }
-  return tools.createTool({
-    id: "tavily-extract",
-    description: "Extract content from one or more URLs using Tavily. Returns raw page content in markdown or text format. Supports up to 20 URLs per request with basic or advanced extraction depth.",
-    inputSchema: inputSchema2,
-    outputSchema: outputSchema2,
-    execute: async (input) => {
-      const tavilyClient = getClient();
-      const response = await tavilyClient.extract(input.urls, {
-        extractDepth: input.extractDepth,
-        query: input.query,
-        includeImages: input.includeImages,
-        format: input.format
-      });
-      return {
-        results: (response.results || []).map((r) => ({
-          url: r.url,
-          rawContent: r.rawContent,
-          images: r.images || void 0
-        })),
-        failedResults: (response.failedResults || []).map((r) => ({
-          url: r.url,
-          error: r.error
-        })),
-        responseTime: response.responseTime
-      };
-    }
-  });
+	let client = null;
+	function getClient() {
+		if (!client) client = getTavilyClient(config);
+		return client;
+	}
+	return (0, _mastra_core_tools.createTool)({
+		id: "tavily-extract",
+		description: "Extract content from one or more URLs using Tavily. Returns raw page content in markdown or text format. Supports up to 20 URLs per request with basic or advanced extraction depth.",
+		inputSchema: inputSchema$2,
+		outputSchema: outputSchema$2,
+		execute: async (input) => {
+			const response = await getClient().extract(input.urls, {
+				extractDepth: input.extractDepth,
+				query: input.query,
+				includeImages: input.includeImages,
+				format: input.format
+			});
+			return {
+				results: (response.results || []).map((r) => ({
+					url: r.url,
+					rawContent: r.rawContent,
+					images: r.images || void 0
+				})),
+				failedResults: (response.failedResults || []).map((r) => ({
+					url: r.url,
+					error: r.error
+				})),
+				responseTime: response.responseTime
+			};
+		}
+	});
 }
-var inputSchema3 = zod.z.object({
-  url: zod.z.string().describe("The root URL to begin the crawl"),
-  maxDepth: zod.z.number().optional().describe("Max depth of the crawl from the base URL"),
-  maxBreadth: zod.z.number().optional().describe("Max number of links to follow per page"),
-  limit: zod.z.number().optional().describe("Total number of pages the crawler will process before stopping"),
-  instructions: zod.z.string().optional().describe("Natural language instructions for the crawler"),
-  selectPaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to select specific URL paths"),
-  selectDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to restrict to specific domains"),
-  excludePaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific URL paths"),
-  excludeDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific domains"),
-  allowExternal: zod.z.boolean().optional().describe("Whether to follow links to external domains"),
-  extractDepth: zod.z.enum(["basic", "advanced"]).optional().describe("Extraction depth \u2014 'advanced' retrieves more data including tables and embedded content"),
-  includeImages: zod.z.boolean().optional().describe("Include images from crawled pages"),
-  format: zod.z.enum(["markdown", "text"]).optional().describe("Output format for extracted content \u2014 'markdown' (default) or 'text'")
+//#endregion
+//#region src/crawl.ts
+const inputSchema$1 = zod.z.object({
+	url: zod.z.string().describe("The root URL to begin the crawl"),
+	maxDepth: zod.z.number().optional().describe("Max depth of the crawl from the base URL"),
+	maxBreadth: zod.z.number().optional().describe("Max number of links to follow per page"),
+	limit: zod.z.number().optional().describe("Total number of pages the crawler will process before stopping"),
+	instructions: zod.z.string().optional().describe("Natural language instructions for the crawler"),
+	selectPaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to select specific URL paths"),
+	selectDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to restrict to specific domains"),
+	excludePaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific URL paths"),
+	excludeDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific domains"),
+	allowExternal: zod.z.boolean().optional().describe("Whether to follow links to external domains"),
+	extractDepth: zod.z.enum(["basic", "advanced"]).optional().describe("Extraction depth — 'advanced' retrieves more data including tables and embedded content"),
+	includeImages: zod.z.boolean().optional().describe("Include images from crawled pages"),
+	format: zod.z.enum(["markdown", "text"]).optional().describe("Output format for extracted content — 'markdown' (default) or 'text'")
 });
-var outputSchema3 = zod.z.object({
-  baseUrl: zod.z.string(),
-  results: zod.z.array(
-    zod.z.object({
-      url: zod.z.string(),
-      rawContent: zod.z.string(),
-      images: zod.z.array(zod.z.string()).optional()
-    })
-  ),
-  responseTime: zod.z.number()
+const outputSchema$1 = zod.z.object({
+	baseUrl: zod.z.string(),
+	results: zod.z.array(zod.z.object({
+		url: zod.z.string(),
+		rawContent: zod.z.string(),
+		images: zod.z.array(zod.z.string()).optional()
+	})),
+	responseTime: zod.z.number()
 });
 function createTavilyCrawlTool(config) {
-  let client = null;
-  function getClient() {
-    if (!client) {
-      client = getTavilyClient(config);
-    }
-    return client;
-  }
-  return tools.createTool({
-    id: "tavily-crawl",
-    description: "Crawl a website starting from a URL using Tavily. Extracts content from discovered pages with configurable depth, breadth, and domain constraints. Returns structured content from each crawled page.",
-    inputSchema: inputSchema3,
-    outputSchema: outputSchema3,
-    execute: async (input) => {
-      const tavilyClient = getClient();
-      const response = await tavilyClient.crawl(input.url, {
-        maxDepth: input.maxDepth,
-        maxBreadth: input.maxBreadth,
-        limit: input.limit,
-        instructions: input.instructions,
-        selectPaths: input.selectPaths,
-        selectDomains: input.selectDomains,
-        excludePaths: input.excludePaths,
-        excludeDomains: input.excludeDomains,
-        allowExternal: input.allowExternal,
-        extractDepth: input.extractDepth,
-        includeImages: input.includeImages,
-        format: input.format
-      });
-      return {
-        baseUrl: response.baseUrl,
-        results: (response.results || []).map((r) => ({
-          url: r.url,
-          rawContent: r.rawContent,
-          images: r.images || void 0
-        })),
-        responseTime: response.responseTime
-      };
-    }
-  });
+	let client = null;
+	function getClient() {
+		if (!client) client = getTavilyClient(config);
+		return client;
+	}
+	return (0, _mastra_core_tools.createTool)({
+		id: "tavily-crawl",
+		description: "Crawl a website starting from a URL using Tavily. Extracts content from discovered pages with configurable depth, breadth, and domain constraints. Returns structured content from each crawled page.",
+		inputSchema: inputSchema$1,
+		outputSchema: outputSchema$1,
+		execute: async (input) => {
+			const response = await getClient().crawl(input.url, {
+				maxDepth: input.maxDepth,
+				maxBreadth: input.maxBreadth,
+				limit: input.limit,
+				instructions: input.instructions,
+				selectPaths: input.selectPaths,
+				selectDomains: input.selectDomains,
+				excludePaths: input.excludePaths,
+				excludeDomains: input.excludeDomains,
+				allowExternal: input.allowExternal,
+				extractDepth: input.extractDepth,
+				includeImages: input.includeImages,
+				format: input.format
+			});
+			return {
+				baseUrl: response.baseUrl,
+				results: (response.results || []).map((r) => ({
+					url: r.url,
+					rawContent: r.rawContent,
+					images: r.images || void 0
+				})),
+				responseTime: response.responseTime
+			};
+		}
+	});
 }
-var inputSchema4 = zod.z.object({
-  url: zod.z.string().describe("The root URL to begin mapping"),
-  maxDepth: zod.z.number().optional().describe("Max depth of the mapping from the base URL"),
-  maxBreadth: zod.z.number().optional().describe("Max number of links to follow per page"),
-  limit: zod.z.number().optional().describe("Total number of links the mapper will process before stopping"),
-  instructions: zod.z.string().optional().describe("Natural language instructions for the mapper"),
-  selectPaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to select specific URL paths"),
-  selectDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to restrict to specific domains"),
-  excludePaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific URL paths"),
-  excludeDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific domains"),
-  allowExternal: zod.z.boolean().optional().describe("Whether to include external domain links")
+//#endregion
+//#region src/map.ts
+const inputSchema = zod.z.object({
+	url: zod.z.string().describe("The root URL to begin mapping"),
+	maxDepth: zod.z.number().optional().describe("Max depth of the mapping from the base URL"),
+	maxBreadth: zod.z.number().optional().describe("Max number of links to follow per page"),
+	limit: zod.z.number().optional().describe("Total number of links the mapper will process before stopping"),
+	instructions: zod.z.string().optional().describe("Natural language instructions for the mapper"),
+	selectPaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to select specific URL paths"),
+	selectDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to restrict to specific domains"),
+	excludePaths: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific URL paths"),
+	excludeDomains: zod.z.array(zod.z.string()).optional().describe("Regex patterns to exclude specific domains"),
+	allowExternal: zod.z.boolean().optional().describe("Whether to include external domain links")
 });
-var outputSchema4 = zod.z.object({
-  baseUrl: zod.z.string(),
-  results: zod.z.array(zod.z.string()).describe("Discovered URLs"),
-  responseTime: zod.z.number()
+const outputSchema = zod.z.object({
+	baseUrl: zod.z.string(),
+	results: zod.z.array(zod.z.string()).describe("Discovered URLs"),
+	responseTime: zod.z.number()
 });
 function createTavilyMapTool(config) {
-  let client = null;
-  function getClient() {
-    if (!client) {
-      client = getTavilyClient(config);
-    }
-    return client;
-  }
-  return tools.createTool({
-    id: "tavily-map",
-    description: "Map a website's structure starting from a URL using Tavily. Discovers and returns a list of URLs found on the site without extracting page content. Useful for understanding site structure before targeted extraction.",
-    inputSchema: inputSchema4,
-    outputSchema: outputSchema4,
-    execute: async (input) => {
-      const tavilyClient = getClient();
-      const response = await tavilyClient.map(input.url, {
-        maxDepth: input.maxDepth,
-        maxBreadth: input.maxBreadth,
-        limit: input.limit,
-        instructions: input.instructions,
-        selectPaths: input.selectPaths,
-        selectDomains: input.selectDomains,
-        excludePaths: input.excludePaths,
-        excludeDomains: input.excludeDomains,
-        allowExternal: input.allowExternal
-      });
-      return {
-        baseUrl: response.baseUrl,
-        results: response.results || [],
-        responseTime: response.responseTime
-      };
-    }
-  });
+	let client = null;
+	function getClient() {
+		if (!client) client = getTavilyClient(config);
+		return client;
+	}
+	return (0, _mastra_core_tools.createTool)({
+		id: "tavily-map",
+		description: "Map a website's structure starting from a URL using Tavily. Discovers and returns a list of URLs found on the site without extracting page content. Useful for understanding site structure before targeted extraction.",
+		inputSchema,
+		outputSchema,
+		execute: async (input) => {
+			const response = await getClient().map(input.url, {
+				maxDepth: input.maxDepth,
+				maxBreadth: input.maxBreadth,
+				limit: input.limit,
+				instructions: input.instructions,
+				selectPaths: input.selectPaths,
+				selectDomains: input.selectDomains,
+				excludePaths: input.excludePaths,
+				excludeDomains: input.excludeDomains,
+				allowExternal: input.allowExternal
+			});
+			return {
+				baseUrl: response.baseUrl,
+				results: response.results || [],
+				responseTime: response.responseTime
+			};
+		}
+	});
 }
-
-// src/tools.ts
+//#endregion
+//#region src/tools.ts
 function createTavilyTools(config) {
-  return {
-    tavilySearch: createTavilySearchTool(config),
-    tavilyExtract: createTavilyExtractTool(config),
-    tavilyCrawl: createTavilyCrawlTool(config),
-    tavilyMap: createTavilyMapTool(config)
-  };
+	return {
+		tavilySearch: createTavilySearchTool(config),
+		tavilyExtract: createTavilyExtractTool(config),
+		tavilyCrawl: createTavilyCrawlTool(config),
+		tavilyMap: createTavilyMapTool(config)
+	};
 }
-
+//#endregion
 exports.createTavilyCrawlTool = createTavilyCrawlTool;
 exports.createTavilyExtractTool = createTavilyExtractTool;
 exports.createTavilyMapTool = createTavilyMapTool;
 exports.createTavilySearchTool = createTavilySearchTool;
 exports.createTavilyTools = createTavilyTools;
 exports.getTavilyClient = getTavilyClient;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map