@illuma-ai/agents 1.0.81

package/dist/types/tools/ToolSearch.d.ts

@@ -0,0 +1,219 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import type * as t from '@/types';
+import { Constants } from '@/common';
+export declare const ToolSearchToolName = Constants.TOOL_SEARCH;
+export declare const ToolSearchToolDescription = "Searches deferred tools using BM25 ranking. Multi-word queries supported. Use mcp_server param to filter by server.";
+export declare const ToolSearchToolSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly type: "string";
+            readonly maxLength: 200;
+            readonly default: "";
+            readonly description: "Search term to find in tool names and descriptions. Case-insensitive substring matching. Optional if mcp_server is provided.";
+        };
+        readonly fields: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly enum: readonly ["name", "description", "parameters"];
+            };
+            readonly default: readonly ["name", "description"];
+            readonly description: "Which fields to search. Default: name and description";
+        };
+        readonly max_results: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 50;
+            readonly default: 10;
+            readonly description: "Maximum number of matching tools to return";
+        };
+        readonly mcp_server: {
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            }];
+            readonly description: "Filter to tools from specific MCP server(s). Can be a single server name or array of names. If provided without a query, lists all tools from those servers.";
+        };
+    };
+    readonly required: readonly [];
+};
+export declare const ToolSearchToolDefinition: {
+    readonly name: Constants.TOOL_SEARCH;
+    readonly description: "Searches deferred tools using BM25 ranking. Multi-word queries supported. Use mcp_server param to filter by server.";
+    readonly schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly maxLength: 200;
+                readonly default: "";
+                readonly description: "Search term to find in tool names and descriptions. Case-insensitive substring matching. Optional if mcp_server is provided.";
+            };
+            readonly fields: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly enum: readonly ["name", "description", "parameters"];
+                };
+                readonly default: readonly ["name", "description"];
+                readonly description: "Which fields to search. Default: name and description";
+            };
+            readonly max_results: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 50;
+                readonly default: 10;
+                readonly description: "Maximum number of matching tools to return";
+            };
+            readonly mcp_server: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                }];
+                readonly description: "Filter to tools from specific MCP server(s). Can be a single server name or array of names. If provided without a query, lists all tools from those servers.";
+            };
+        };
+        readonly required: readonly [];
+    };
+};
+/**
+ * Extracts the MCP server name from a tool name.
+ * MCP tools follow the pattern: toolName_mcp_serverName
+ * @param toolName - The full tool name
+ * @returns The server name if it's an MCP tool, undefined otherwise
+ */
+declare function extractMcpServerName(toolName: string): string | undefined;
+/**
+ * Checks if a tool belongs to a specific MCP server.
+ * @param toolName - The full tool name
+ * @param serverName - The server name to match
+ * @returns True if the tool belongs to the specified server
+ */
+declare function isFromMcpServer(toolName: string, serverName: string): boolean;
+/**
+ * Checks if a tool belongs to any of the specified MCP servers.
+ * @param toolName - The full tool name
+ * @param serverNames - Array of server names to match
+ * @returns True if the tool belongs to any of the specified servers
+ */
+declare function isFromAnyMcpServer(toolName: string, serverNames: string[]): boolean;
+/**
+ * Normalizes server filter input to always be an array.
+ * @param serverFilter - String, array of strings, or undefined
+ * @returns Array of server names (empty if none specified)
+ */
+declare function normalizeServerFilter(serverFilter: string | string[] | undefined): string[];
+/**
+ * Extracts all unique MCP server names from a tool registry.
+ * @param toolRegistry - The tool registry to scan
+ * @param onlyDeferred - If true, only considers deferred tools
+ * @returns Array of unique server names, sorted alphabetically
+ */
+declare function getAvailableMcpServers(toolRegistry: t.LCToolRegistry | undefined, onlyDeferred?: boolean): string[];
+/**
+ * Escapes special regex characters in a string to use as a literal pattern.
+ * @param pattern - The string to escape
+ * @returns The escaped string safe for use in a RegExp
+ */
+declare function escapeRegexSpecialChars(pattern: string): string;
+/**
+ * Counts the maximum nesting depth of groups in a regex pattern.
+ * @param pattern - The regex pattern to analyze
+ * @returns The maximum nesting depth
+ */
+declare function countNestedGroups(pattern: string): number;
+/**
+ * Detects nested quantifiers that can cause catastrophic backtracking.
+ * Patterns like (a+)+, (a*)*, (a+)*, etc.
+ * @param pattern - The regex pattern to check
+ * @returns True if nested quantifiers are detected
+ */
+declare function hasNestedQuantifiers(pattern: string): boolean;
+/**
+ * Checks if a regex pattern contains potentially dangerous constructs.
+ * @param pattern - The regex pattern to validate
+ * @returns True if the pattern is dangerous
+ */
+declare function isDangerousPattern(pattern: string): boolean;
+/**
+ * Sanitizes a regex pattern for safe execution.
+ * If the pattern is dangerous, it will be escaped to a literal string search.
+ * @param pattern - The regex pattern to sanitize
+ * @returns Object containing the safe pattern and whether it was escaped
+ */
+declare function sanitizeRegex(pattern: string): {
+    safe: string;
+    wasEscaped: boolean;
+};
+/**
+ * Performs BM25-based search for better relevance ranking.
+ * Uses Okapi BM25 algorithm for term frequency and document length normalization.
+ * @param tools - Array of tool metadata to search
+ * @param query - The search query
+ * @param fields - Which fields to search
+ * @param maxResults - Maximum results to return
+ * @returns Search response with matching tools ranked by BM25 score
+ */
+declare function performLocalSearch(tools: t.ToolMetadata[], query: string, fields: string[], maxResults: number): t.ToolSearchResponse;
+/**
+ * Extracts the base tool name (without MCP server suffix) from a full tool name.
+ * @param toolName - The full tool name
+ * @returns The base tool name without server suffix
+ */
+declare function getBaseToolName(toolName: string): string;
+/**
+ * Generates a compact listing of deferred tools grouped by server.
+ * Format: "server: tool1, tool2, tool3"
+ * Non-MCP tools are grouped under "other".
+ * @param toolRegistry - The tool registry
+ * @param onlyDeferred - Whether to only include deferred tools
+ * @returns Formatted string with tools grouped by server
+ */
+declare function getDeferredToolsListing(toolRegistry: t.LCToolRegistry | undefined, onlyDeferred: boolean): string;
+/**
+ * Formats a server listing response as structured JSON.
+ * NOTE: This is a PREVIEW only - tools are NOT discovered/loaded.
+ * @param tools - Array of tool metadata from the server(s)
+ * @param serverNames - The MCP server name(s)
+ * @returns JSON string showing all tools grouped by server
+ */
+declare function formatServerListing(tools: t.ToolMetadata[], serverNames: string | string[]): string;
+/**
+ * Creates a Tool Search tool for discovering tools from a large registry.
+ *
+ * This tool enables AI agents to dynamically discover tools from a large library
+ * without loading all tool definitions into the LLM context window. The agent
+ * can search for relevant tools on-demand.
+ *
+ * **Modes:**
+ * - `code_interpreter` (default): Uses external sandbox for regex search. Safer for complex patterns.
+ * - `local`: Uses safe substring matching locally. No network call, faster, completely safe from ReDoS.
+ *
+ * The tool registry can be provided either:
+ * 1. At initialization time via params.toolRegistry
+ * 2. At runtime via config.configurable.toolRegistry when invoking
+ *
+ * @param params - Configuration parameters for the tool (toolRegistry is optional)
+ * @returns A LangChain DynamicStructuredTool for tool searching
+ *
+ * @example
+ * // Option 1: Code interpreter mode (regex via sandbox)
+ * const tool = createToolSearch({ apiKey, toolRegistry });
+ * await tool.invoke({ query: 'expense.*report' });
+ *
+ * @example
+ * // Option 2: Local mode (safe substring search, no API key needed)
+ * const tool = createToolSearch({ mode: 'local', toolRegistry });
+ * await tool.invoke({ query: 'expense' });
+ */
+declare function createToolSearch(initParams?: t.ToolSearchParams): DynamicStructuredTool;
+export { createToolSearch, performLocalSearch, extractMcpServerName, isFromMcpServer, isFromAnyMcpServer, normalizeServerFilter, getAvailableMcpServers, getDeferredToolsListing, getBaseToolName, formatServerListing, sanitizeRegex, escapeRegexSpecialChars, isDangerousPattern, countNestedGroups, hasNestedQuantifiers, };

package/dist/types/tools/handlers.d.ts

@@ -0,0 +1,22 @@
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type { MultiAgentGraph, StandardGraph } from '@/graphs';
+import type { AgentContext } from '@/agents/AgentContext';
+import type * as t from '@/types';
+export declare function handleToolCallChunks({ graph, stepKey, toolCallChunks, metadata, }: {
+    graph: StandardGraph | MultiAgentGraph;
+    stepKey: string;
+    toolCallChunks: ToolCallChunk[];
+    metadata?: Record<string, unknown>;
+}): Promise<void>;
+export declare const handleToolCalls: (toolCalls?: ToolCall[], metadata?: Record<string, unknown>, graph?: StandardGraph | MultiAgentGraph) => Promise<void>;
+export declare const toolResultTypes: Set<string>;
+/**
+ * Handles the result of a server tool call; in other words, a provider's built-in tool.
+ * As of 2025-07-06, only Anthropic handles server tool calls with this pattern.
+ */
+export declare function handleServerToolResult({ graph, content, metadata, agentContext, }: {
+    graph: StandardGraph | MultiAgentGraph;
+    content?: string | t.MessageContentComplex[];
+    metadata?: Record<string, unknown>;
+    agentContext?: AgentContext;
+}): Promise<boolean>;

package/dist/types/tools/schema.d.ts

@@ -0,0 +1,12 @@
+import { type StructuredToolInterface } from '@langchain/core/tools';
+import type { LCTool } from '@/types';
+/**
+ * Creates a schema-only tool for LLM binding in event-driven mode.
+ * These tools have valid schemas for the LLM to understand but should
+ * never be invoked directly - ToolNode handles execution via events.
+ */
+export declare function createSchemaOnlyTool(definition: LCTool): StructuredToolInterface;
+/**
+ * Creates schema-only tools for all definitions in an array.
+ */
+export declare function createSchemaOnlyTools(definitions: LCTool[]): StructuredToolInterface[];

package/dist/types/tools/search/anthropic.d.ts

@@ -0,0 +1,16 @@
+import type { AnthropicTextBlockParam, AnthropicWebSearchResultBlockParam } from '@/llm/anthropic/types';
+import type { SearchResultData } from './types';
+/**
+ * Coerces Anthropic web search results to the SearchResultData format
+ * @param results - Array of Anthropic web search results
+ * @param turn - The turn number to associate with these results
+ * @returns SearchResultData with minimal ProcessedOrganic items
+ */
+export declare function coerceAnthropicSearchResults({ results, turn, }: {
+    results: (AnthropicTextBlockParam | AnthropicWebSearchResultBlockParam)[];
+    turn?: number;
+}): SearchResultData;
+/**
+ * Helper function to check if an object is an Anthropic web search result
+ */
+export declare function isAnthropicWebSearchResult(obj: unknown): obj is AnthropicWebSearchResultBlockParam;

package/dist/types/tools/search/content.d.ts

@@ -0,0 +1,4 @@
+import type { References } from './types';
+export declare function processContent(html: string, markdown: string): {
+    markdown: string;
+} & References;

package/dist/types/tools/search/firecrawl.d.ts

@@ -0,0 +1,54 @@
+import type * as t from './types';
+/**
+ * Firecrawl scraper implementation
+ * Uses the Firecrawl API to scrape web pages
+ */
+export declare class FirecrawlScraper implements t.BaseScraper {
+    private apiKey;
+    private apiUrl;
+    private version;
+    private defaultFormats;
+    private timeout;
+    private logger;
+    private includeTags?;
+    private excludeTags?;
+    private waitFor?;
+    private maxAge?;
+    private mobile?;
+    private skipTlsVerification?;
+    private blockAds?;
+    private removeBase64Images?;
+    private parsePDF?;
+    private storeInCache?;
+    private zeroDataRetention?;
+    private headers?;
+    private location?;
+    private onlyMainContent?;
+    private changeTrackingOptions?;
+    constructor(config?: t.FirecrawlScraperConfig);
+    /**
+     * Scrape a single URL
+     * @param url URL to scrape
+     * @param options Scrape options
+     * @returns Scrape response
+     */
+    scrapeUrl(url: string, options?: t.FirecrawlScrapeOptions): Promise<[string, t.FirecrawlScrapeResponse]>;
+    /**
+     * Extract content from scrape response
+     * @param response Scrape response
+     * @returns Extracted content or empty string if not available
+     */
+    extractContent(response: t.FirecrawlScrapeResponse): [string, undefined | t.References];
+    /**
+     * Extract metadata from scrape response
+     * @param response Scrape response
+     * @returns Metadata object
+     */
+    extractMetadata(response: t.FirecrawlScrapeResponse): t.ScrapeMetadata;
+}
+/**
+ * Create a Firecrawl scraper instance
+ * @param config Scraper configuration
+ * @returns Firecrawl scraper instance
+ */
+export declare const createFirecrawlScraper: (config?: t.FirecrawlScraperConfig) => FirecrawlScraper;

package/dist/types/tools/search/format.d.ts

@@ -0,0 +1,5 @@
+import type * as t from './types';
+export declare function formatResultsForLLM(turn: number, results: t.SearchResultData): {
+    output: string;
+    references: t.ResultReference[];
+};

package/dist/types/tools/search/highlights.d.ts

@@ -0,0 +1,13 @@
+import type * as t from './types';
+/**
+ * Expand highlights in search results using smart boundary detection.
+ *
+ * This implementation finds natural text boundaries like paragraphs, sentences,
+ * and phrases to provide context while maintaining readability.
+ *
+ * @param searchResults - Search results object
+ * @param mainExpandBy - Primary expansion size on each side (default: 300)
+ * @param separatorExpandBy - Additional range to look for separators (default: 150)
+ * @returns Copy of search results with expanded highlights and tracked references
+ */
+export declare function expandHighlights(searchResults: t.SearchResultData, mainExpandBy?: number, separatorExpandBy?: number): t.SearchResultData;

package/dist/types/tools/search/index.d.ts

@@ -0,0 +1,3 @@
+export * from './tool';
+export * from './schema';
+export type * from './types';

package/dist/types/tools/search/rerankers.d.ts

@@ -0,0 +1,38 @@
+import type * as t from './types';
+export declare abstract class BaseReranker {
+    protected apiKey: string | undefined;
+    protected logger: t.Logger;
+    constructor(logger?: t.Logger);
+    abstract rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+    protected getDefaultRanking(documents: string[], topK: number): t.Highlight[];
+}
+export declare class JinaReranker extends BaseReranker {
+    private apiUrl;
+    constructor({ apiKey, apiUrl, logger, }: {
+        apiKey?: string;
+        apiUrl?: string;
+        logger?: t.Logger;
+    });
+    rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+}
+export declare class CohereReranker extends BaseReranker {
+    constructor({ apiKey, logger, }: {
+        apiKey?: string;
+        logger?: t.Logger;
+    });
+    rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+}
+export declare class InfinityReranker extends BaseReranker {
+    constructor(logger?: t.Logger);
+    rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+}
+/**
+ * Creates the appropriate reranker based on type and configuration
+ */
+export declare const createReranker: (config: {
+    rerankerType: t.RerankerType;
+    jinaApiKey?: string;
+    jinaApiUrl?: string;
+    cohereApiKey?: string;
+    logger?: t.Logger;
+}) => BaseReranker | undefined;

package/dist/types/tools/search/schema.d.ts

@@ -0,0 +1,103 @@
+export declare enum DATE_RANGE {
+    PAST_HOUR = "h",
+    PAST_24_HOURS = "d",
+    PAST_WEEK = "w",
+    PAST_MONTH = "m",
+    PAST_YEAR = "y"
+}
+export declare const DEFAULT_QUERY_DESCRIPTION: string;
+export declare const DEFAULT_COUNTRY_DESCRIPTION: string;
+export declare const querySchema: {
+    readonly type: "string";
+    readonly description: string;
+};
+export declare const dateSchema: {
+    readonly type: "string";
+    readonly enum: DATE_RANGE[];
+    readonly description: "Date range for search results.";
+};
+export declare const countrySchema: {
+    readonly type: "string";
+    readonly description: string;
+};
+export declare const imagesSchema: {
+    readonly type: "boolean";
+    readonly description: "Whether to also run an image search.";
+};
+export declare const videosSchema: {
+    readonly type: "boolean";
+    readonly description: "Whether to also run a video search.";
+};
+export declare const newsSchema: {
+    readonly type: "boolean";
+    readonly description: "Whether to also run a news search.";
+};
+/** Combined web search tool schema with all properties */
+export declare const WebSearchToolSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly date: {
+            readonly type: "string";
+            readonly enum: DATE_RANGE[];
+            readonly description: "Date range for search results.";
+        };
+        readonly country: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly images: {
+            readonly type: "boolean";
+            readonly description: "Whether to also run an image search.";
+        };
+        readonly videos: {
+            readonly type: "boolean";
+            readonly description: "Whether to also run a video search.";
+        };
+        readonly news: {
+            readonly type: "boolean";
+            readonly description: "Whether to also run a news search.";
+        };
+    };
+    readonly required: readonly ["query"];
+};
+export declare const WebSearchToolName = "web_search";
+export declare const WebSearchToolDescription = "Real-time search. Results have required citation anchors.\n\nNote: Use ONCE per reply unless instructed otherwise.\n\nAnchors:\n- \\ue202turnXtypeY\n- X = turn idx, type = 'search' | 'news' | 'image' | 'ref', Y = item idx\n\nSpecial Markers:\n- \\ue203...\\ue204 \u2014 highlight start/end of cited text (for Standalone or Group citations)\n- \\ue200...\\ue201 \u2014 group block (e.g. \\ue200\\ue202turn0search1\\ue202turn0news2\\ue201)\n\n**CITE EVERY NON-OBVIOUS FACT/QUOTE:**\nUse anchor marker(s) immediately after the statement:\n- Standalone: \"Pure functions produce same output. \\ue202turn0search0\"\n- Standalone (multiple): \"Today's News \\ue202turn0search0\\ue202turn0news0\"\n- Highlight: \"\\ue203Highlight text.\\ue204\\ue202turn0news1\"\n- Group: \"Sources. \\ue200\\ue202turn0search0\\ue202turn0news1\\ue201\"\n- Group Highlight: \"\\ue203Highlight for group.\\ue204 \\ue200\\ue202turn0search0\\ue202turn0news1\\ue201\"\n- Image: \"See photo \\ue202turn0image0.\"\n\n**NEVER use markdown links, [1], or footnotes. CITE ONLY with anchors provided.**";
+export declare const WebSearchToolDefinition: {
+    readonly name: "web_search";
+    readonly description: "Real-time search. Results have required citation anchors.\n\nNote: Use ONCE per reply unless instructed otherwise.\n\nAnchors:\n- \\ue202turnXtypeY\n- X = turn idx, type = 'search' | 'news' | 'image' | 'ref', Y = item idx\n\nSpecial Markers:\n- \\ue203...\\ue204 — highlight start/end of cited text (for Standalone or Group citations)\n- \\ue200...\\ue201 — group block (e.g. \\ue200\\ue202turn0search1\\ue202turn0news2\\ue201)\n\n**CITE EVERY NON-OBVIOUS FACT/QUOTE:**\nUse anchor marker(s) immediately after the statement:\n- Standalone: \"Pure functions produce same output. \\ue202turn0search0\"\n- Standalone (multiple): \"Today's News \\ue202turn0search0\\ue202turn0news0\"\n- Highlight: \"\\ue203Highlight text.\\ue204\\ue202turn0news1\"\n- Group: \"Sources. \\ue200\\ue202turn0search0\\ue202turn0news1\\ue201\"\n- Group Highlight: \"\\ue203Highlight for group.\\ue204 \\ue200\\ue202turn0search0\\ue202turn0news1\\ue201\"\n- Image: \"See photo \\ue202turn0image0.\"\n\n**NEVER use markdown links, [1], or footnotes. CITE ONLY with anchors provided.**";
+    readonly schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly description: string;
+            };
+            readonly date: {
+                readonly type: "string";
+                readonly enum: DATE_RANGE[];
+                readonly description: "Date range for search results.";
+            };
+            readonly country: {
+                readonly type: "string";
+                readonly description: string;
+            };
+            readonly images: {
+                readonly type: "boolean";
+                readonly description: "Whether to also run an image search.";
+            };
+            readonly videos: {
+                readonly type: "boolean";
+                readonly description: "Whether to also run a video search.";
+            };
+            readonly news: {
+                readonly type: "boolean";
+                readonly description: "Whether to also run a news search.";
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+};

package/dist/types/tools/search/search.d.ts

@@ -0,0 +1,8 @@
+import type * as t from './types';
+export declare const createSearchAPI: (config: t.SearchConfig) => {
+    getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
+};
+export declare const createSourceProcessor: (config?: t.ProcessSourcesConfig, scraperInstance?: t.BaseScraper) => {
+    processSources: (fields: t.ProcessSourcesFields) => Promise<t.SearchResultData>;
+    topResults: number;
+};

package/dist/types/tools/search/serper-scraper.d.ts

@@ -0,0 +1,59 @@
+import type * as t from './types';
+/**
+ * Serper scraper implementation
+ * Uses the Serper Scrape API (https://scrape.serper.dev) to scrape web pages
+ *
+ * Features:
+ * - Simple API with single endpoint
+ * - Returns both text and markdown content
+ * - Includes metadata from scraped pages
+ * - Credits-based pricing model
+ *
+ * @example
+ * ```typescript
+ * const scraper = createSerperScraper({
+ *   apiKey: 'your-serper-api-key',
+ *   includeMarkdown: true,
+ *   timeout: 10000
+ * });
+ *
+ * const [url, response] = await scraper.scrapeUrl('https://example.com');
+ * if (response.success) {
+ *   const [content] = scraper.extractContent(response);
+ *   console.log(content);
+ * }
+ * ```
+ */
+export declare class SerperScraper implements t.BaseScraper {
+    private apiKey;
+    private apiUrl;
+    private timeout;
+    private logger;
+    private includeMarkdown;
+    constructor(config?: t.SerperScraperConfig);
+    /**
+     * Scrape a single URL
+     * @param url URL to scrape
+     * @param options Scrape options
+     * @returns Scrape response
+     */
+    scrapeUrl(url: string, options?: t.SerperScrapeOptions): Promise<[string, t.SerperScrapeResponse]>;
+    /**
+     * Extract content from scrape response
+     * @param response Scrape response
+     * @returns Extracted content or empty string if not available
+     */
+    extractContent(response: t.SerperScrapeResponse): [string, undefined | t.References];
+    /**
+     * Extract metadata from scrape response
+     * @param response Scrape response
+     * @returns Metadata object
+     */
+    extractMetadata(response: t.SerperScrapeResponse): Record<string, string | number | boolean | null | undefined>;
+}
+/**
+ * Create a Serper scraper instance
+ * @param config Scraper configuration
+ * @returns Serper scraper instance
+ */
+export declare const createSerperScraper: (config?: t.SerperScraperConfig) => SerperScraper;

package/dist/types/tools/search/test.d.ts

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

package/dist/types/tools/search/tool.d.ts

@@ -0,0 +1,3 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import type * as t from './types';
+export declare const createSearchTool: (config?: t.SearchToolConfig) => DynamicStructuredTool;