@librechat/agents 3.1.75 → 3.1.76

package/dist/types/index.d.ts

@@ -24,6 +24,7 @@ export * from './common';
 export * from './utils';
 export * from './hooks';
 export type * from './types';
+export * from './langchain';
 export { CustomOpenAIClient } from './llm/openai';
 export { ChatOpenRouter } from './llm/openrouter';
 export type { OpenRouterReasoning, OpenRouterReasoningEffort, ChatOpenRouterCallOptions, } from './llm/openrouter';

package/dist/types/langchain/google-common.d.ts

@@ -0,0 +1 @@
+export type { GoogleAIToolType } from '@langchain/google-common';

package/dist/types/langchain/index.d.ts

@@ -0,0 +1,8 @@
+export * from './messages';
+export * from './prompts';
+export * from './runnables';
+export * from './tools';
+export * from './google-common';
+export * from './language_models/chat_models';
+export * from './messages/tool';
+export * from './openai';

package/dist/types/langchain/language_models/chat_models.d.ts

@@ -0,0 +1 @@
+export type { BindToolsInput } from '@langchain/core/language_models/chat_models';

package/dist/types/langchain/messages/tool.d.ts

@@ -0,0 +1 @@
+export type { InvalidToolCall, ToolCall, ToolCallChunk, } from '@langchain/core/messages/tool';

package/dist/types/langchain/messages.d.ts

@@ -0,0 +1,2 @@
+export { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, HumanMessage, SystemMessage, ToolMessage, getBufferString, isAIMessage, isBaseMessage, isToolMessage, } from '@langchain/core/messages';
+export type { BaseMessageFields, MessageContent, MessageContentText, MessageContentImageUrl, UsageMetadata, } from '@langchain/core/messages';

package/dist/types/langchain/openai.d.ts

@@ -0,0 +1 @@
+export type { AzureOpenAIInput } from '@langchain/openai';

package/dist/types/langchain/prompts.d.ts

@@ -0,0 +1 @@
+export { PromptTemplate } from '@langchain/core/prompts';

package/dist/types/langchain/runnables.d.ts

@@ -0,0 +1,2 @@
+export { Runnable, RunnableLambda, RunnableSequence, } from '@langchain/core/runnables';
+export type { RunnableConfig } from '@langchain/core/runnables';

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

@@ -0,0 +1,2 @@
+export { DynamicStructuredTool, StructuredTool, Tool, tool, } from '@langchain/core/tools';
+export type { StructuredToolInterface } from '@langchain/core/tools';

package/dist/types/langchain/utils/env.d.ts

@@ -0,0 +1 @@
+export { getEnvironmentVariable } from '@langchain/core/utils/env';

package/dist/types/llm/anthropic/index.d.ts

@@ -4,18 +4,31 @@ import type { BaseChatModelParams } from '@langchain/core/language_models/chat_m
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { AnthropicInput } from '@langchain/anthropic';
-import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams, AnthropicOutputConfig } from '@/llm/anthropic/types';
+import type { Anthropic } from '@anthropic-ai/sdk';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams, AnthropicOutputConfig, AnthropicBeta, AnthropicMCPServerURLDefinition, AnthropicContextManagementConfigParam } from '@/llm/anthropic/types';
+export declare function _documentsInParams(params: AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams): boolean;
 export type CustomAnthropicInput = AnthropicInput & {
     _lc_stream_delay?: number;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
-    contextManagement?: any;
+    contextManagement?: AnthropicContextManagementConfigParam;
 } & BaseChatModelParams;
-/**
- * A type representing additional parameters that can be passed to the
- * Anthropic API.
- */
-type Kwargs = Record<string, any>;
+export type CustomAnthropicCallOptions = {
+    outputConfig?: AnthropicOutputConfig;
+    outputFormat?: Anthropic.Messages.JSONOutputFormat;
+    inferenceGeo?: string;
+    betas?: AnthropicBeta[];
+    container?: string;
+    mcp_servers?: AnthropicMCPServerURLDefinition[];
+};
+type CustomAnthropicInvocationParams = {
+    betas?: AnthropicBeta[];
+    container?: string;
+    context_management?: AnthropicContextManagementConfigParam;
+    inference_geo?: string;
+    mcp_servers?: AnthropicMCPServerURLDefinition[];
+    output_config?: AnthropicOutputConfig;
+};
 export declare class CustomAnthropic extends ChatAnthropicMessages {
     _lc_stream_delay: number;
     private message_start;
@@ -25,13 +38,13 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     top_k: number | undefined;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
-    contextManagement?: any;
+    contextManagement?: AnthropicContextManagementConfigParam;
     constructor(fields?: CustomAnthropicInput);
     static lc_name(): 'LibreChatAnthropic';
     /**
      * Get the parameters used to invoke the model
      */
-    invocationParams(options?: this['ParsedCallOptions']): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & Kwargs;
+    invocationParams(options?: this['ParsedCallOptions'] & CustomAnthropicCallOptions): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & CustomAnthropicInvocationParams;
     /**
      * Get stream usage as returned by this client's API response.
      * @returns The stream usage object.

package/dist/types/llm/anthropic/types.d.ts

@@ -1,5 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { AnthropicBeta } from '@anthropic-ai/sdk/resources';
+export type { AnthropicBeta };
 export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
 export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
@@ -14,8 +16,10 @@ export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolRes
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
 export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
+export type AnthropicContextManagementConfigParam = Anthropic.Beta.BetaContextManagementConfig;
 export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 export type AnthropicRequestOptions = Anthropic.RequestOptions;
+export type AnthropicMCPServerURLDefinition = Anthropic.Beta.Messages.BetaRequestMCPServerURLDefinition;
 export type AnthropicToolChoice = {
     type: 'tool';
     name: string;

package/dist/types/llm/anthropic/utils/message_outputs.d.ts

@@ -1,10 +1,16 @@
-/**
- * This util file contains functions for converting Anthropic messages to LangChain messages.
- */
-import Anthropic from '@anthropic-ai/sdk';
+/** This util file contains functions for converting Anthropic messages to LangChain messages. */
 import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGeneration } from '@langchain/core/outputs';
-import { AnthropicMessageResponse } from '../types';
+import type Anthropic from '@anthropic-ai/sdk';
+import type { UsageMetadata } from '@langchain/core/messages';
+import type { ChatGeneration } from '@langchain/core/outputs';
+import type { AnthropicMessageResponse } from '../types';
+interface AnthropicUsageData {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+}
+export declare function getAnthropicUsageMetadata(usage: AnthropicUsageData | null | undefined): UsageMetadata | undefined;
 export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta.Messages.BetaRawMessageStreamEvent, fields: {
     streamUsage: boolean;
     coerceContentToString: boolean;
@@ -12,3 +18,4 @@ export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta
     chunk: AIMessageChunk;
 } | null;
 export declare function anthropicResponseToChatMessages(messages: AnthropicMessageResponse[], additionalKwargs: Record<string, unknown>): ChatGeneration[];
+export {};

package/dist/types/llm/anthropic/utils/output_parsers.d.ts

@@ -18,5 +18,5 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;
 }
-export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall<string, Record<string, any>>[];
 export {};

package/dist/types/llm/openai/index.d.ts

@@ -1,20 +1,26 @@
 import { AzureOpenAI as AzureOpenAIClient } from 'openai';
 import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { AIMessage } from '@langchain/core/messages';
 import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import { OpenAIClient, ChatOpenAI as OriginalChatOpenAI, AzureChatOpenAI as OriginalAzureChatOpenAI } from '@langchain/openai';
 import type { HeaderValue, HeadersLike } from './types';
-import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { ChatResult } from '@langchain/core/outputs';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { ChatXAIInput } from '@langchain/xai';
 import type * as t from '@langchain/openai';
 export declare function isHeaders(headers: unknown): headers is Headers;
 export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
-type OpenAICompletionParam = OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
 type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
+type LibreChatOpenAIFields = t.ChatOpenAIFields & {
+    _lc_stream_delay?: number;
+    includeReasoningContent?: boolean;
+    includeReasoningDetails?: boolean;
+    convertReasoningDetailsToContent?: boolean;
+};
+type LibreChatAzureOpenAIFields = t.AzureOpenAIInput & {
+    _lc_stream_delay?: number;
+};
 /**
  * Formats a tool in either OpenAI format, or LangChain structured tool format
  * into an OpenAI tool format. If the tool is already in OpenAI format, return without
@@ -41,15 +47,12 @@ export declare class CustomAzureOpenAIClient extends AzureOpenAIClient {
     abortHandler?: () => void;
     fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
 }
-/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
 export declare class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
     _lc_stream_delay?: number;
-    constructor(fields?: t.ChatOpenAICallOptions & {
-        _lc_stream_delay?: number;
-    } & t.OpenAIChatInput['modelKwargs']);
+    constructor(fields?: LibreChatOpenAIFields & t.OpenAIChatInput['modelKwargs']);
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): string;
-    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     /**
      * Returns backwards compatible reasoning parameters from constructor params and call options
      * @internal
@@ -57,14 +60,10 @@ export declare class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptio
     getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
     protected _getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    _streamResponseChunks2(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
-/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
 export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
     _lc_stream_delay?: number;
-    constructor(fields?: t.AzureOpenAIInput & {
-        _lc_stream_delay?: number;
-    });
+    constructor(fields?: LibreChatAzureOpenAIFields);
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): 'LibreChatAzureOpenAI';
     /**
@@ -73,16 +72,17 @@ export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
      */
     getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
     protected _getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
-    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
+    _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export declare class ChatDeepSeek extends OriginalChatDeepSeek {
+    _lc_stream_delay?: number;
+    constructor(fields?: ConstructorParameters<typeof OriginalChatDeepSeek>[0] & {
+        _lc_stream_delay?: number;
+    });
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): 'LibreChatDeepSeek';
-    protected _convertMessages(messages: BaseMessage[]): OpenAICompletionParam[];
-    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'] | undefined, runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    protected _convertResponseToMessage(choice: OpenAIClient.Chat.Completions.ChatCompletion.Choice, data: OpenAIClient.Chat.Completions.ChatCompletion): AIMessage;
-    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 /** xAI-specific usage metadata type */
@@ -102,11 +102,8 @@ export interface XAIUsageMetadata extends OpenAIClient.Completions.CompletionUsa
     num_sources_used?: number;
 }
 export declare class ChatMoonshot extends ChatOpenAI {
+    constructor(fields?: LibreChatOpenAIFields & t.OpenAIChatInput['modelKwargs']);
     static lc_name(): 'LibreChatMoonshot';
-    protected _convertMessages(messages: BaseMessage[]): OpenAICompletionParam[];
-    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    protected _convertResponseToMessage(choice: OpenAIClient.Chat.Completions.ChatCompletion.Choice, data: OpenAIClient.Chat.Completions.ChatCompletion): AIMessage;
-    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export declare class ChatXAI extends OriginalChatXAI {
     _lc_stream_delay?: number;
@@ -121,7 +118,7 @@ export declare class ChatXAI extends OriginalChatXAI {
     });
     static lc_name(): 'LibreChatXAI';
     get exposedClient(): CustomOpenAIClient;
-    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export {};

package/dist/types/llm/openrouter/index.d.ts

@@ -1,7 +1,7 @@
 import { ChatOpenAI } from '@/llm/openai';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { FunctionMessageChunk, SystemMessageChunk, HumanMessageChunk, ToolMessageChunk, ChatMessageChunk, AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatOpenAICallOptions, OpenAIChatInput, OpenAIClient } from '@langchain/openai';
 export type OpenRouterReasoningEffort = 'xhigh' | 'high' | 'medium' | 'low' | 'minimal' | 'none';
 export interface OpenRouterReasoning {
@@ -16,20 +16,22 @@ export interface ChatOpenRouterCallOptions extends Omit<ChatOpenAICallOptions, '
     reasoning?: OpenRouterReasoning;
     modelKwargs?: OpenAIChatInput['modelKwargs'];
 }
+export type ChatOpenRouterInput = Partial<ChatOpenRouterCallOptions & OpenAIChatInput>;
 /** invocationParams return type extended with OpenRouter reasoning */
 export type OpenRouterInvocationParams = Omit<OpenAIClient.Chat.ChatCompletionCreateParams, 'messages'> & {
     reasoning?: OpenRouterReasoning;
 };
+type InvocationParamsExtra = {
+    streaming?: boolean;
+};
 export declare class ChatOpenRouter extends ChatOpenAI {
     private openRouterReasoning?;
     /** @deprecated Use `reasoning` object instead */
     private includeReasoning?;
-    constructor(_fields: Partial<ChatOpenRouterCallOptions>);
+    constructor(_fields: ChatOpenRouterInput);
     static lc_name(): 'LibreChatOpenRouter';
-    invocationParams(options?: this['ParsedCallOptions'], extra?: {
-        streaming?: boolean;
-    }): OpenRouterInvocationParams;
+    invocationParams(options?: this['ParsedCallOptions'], extra?: InvocationParamsExtra): OpenRouterInvocationParams;
     private buildOpenRouterReasoning;
-    protected _convertOpenAIDeltaToBaseMessageChunk(delta: Record<string, any>, rawResponse: OpenAIClient.ChatCompletionChunk, defaultRole?: 'function' | 'user' | 'system' | 'developer' | 'assistant' | 'tool'): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
-    _streamResponseChunks2(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
+export {};

package/dist/types/llm/vertexai/index.d.ts

@@ -288,6 +288,7 @@ export declare class ChatVertexAI extends ChatGoogle {
     dynamicThinkingBudget: boolean;
     thinkingConfig?: GoogleThinkingConfig;
     static lc_name(): 'LibreChatVertexAI';
+    constructor(model: string, fields?: Omit<VertexAIClientOptions, 'model'>);
     constructor(fields?: VertexAIClientOptions);
     invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
     buildConnection(fields: VertexAIClientOptions | undefined, client: GoogleAbstractedClient): void;

package/dist/types/messages/cache.d.ts

@@ -36,5 +36,8 @@ export declare function stripBedrockCacheControl<T extends MessageWithContent>(m
  * @param messages - The array of message objects.
  * @returns - A new array of message objects with cache points added.
  */
-export declare function addBedrockCacheControl<T extends Partial<BaseMessage> & MessageWithContent>(messages: T[]): T[];
+export declare function addBedrockCacheControl<T extends MessageWithContent & {
+    getType?: () => string;
+    role?: string;
+}>(messages: T[]): T[];
 export {};

package/dist/types/messages/format.d.ts

@@ -84,6 +84,9 @@ interface LangChainMessage {
  * @returns - The formatted LangChain message.
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
+interface FormatAgentMessagesOptions {
+    provider?: Providers;
+}
 /**
  * Groups content parts by agent and formats them with agent labels
  * This preprocesses multi-agent content to prevent identity confusion
@@ -107,7 +110,7 @@ export declare const labelContentByAgent: (contentParts: MessageContentComplex[]
  * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
-export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>, skills?: Map<string, string>) => {
+export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number | undefined>, tools?: Set<string>, skills?: Map<string, string>, options?: FormatAgentMessagesOptions) => {
     messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
     indexTokenCountMap?: Record<number, number>;
     /** Cross-run summary extracted from the payload. Should be forwarded to the

package/dist/types/messages/langchain.d.ts

@@ -0,0 +1,27 @@
+import type { MessageContent } from '@langchain/core/messages';
+import type * as t from '@/types';
+type LibreChatMessageContent = MessageContent | string | t.MessageContentComplex[] | t.ExtendedMessageContent[];
+type WithLangChainContent<T extends {
+    content: LibreChatMessageContent;
+}> = Omit<T, 'content'> & {
+    content: MessageContent;
+};
+/**
+ * Bridges LibreChat's extended content blocks to LangChain 1.x MessageContent.
+ *
+ * LangChain 1.x narrowed message constructor types around ContentBlock, while
+ * LibreChat still carries provider-specific blocks through the same content
+ * field. This helper keeps the runtime shape unchanged during the dependency
+ * upgrade; tracking issue: https://github.com/danny-avila/agents/issues/130.
+ */
+export declare function toLangChainContent(content: LibreChatMessageContent): MessageContent;
+/**
+ * Applies the same LangChain 1.x content bridge to message constructor fields.
+ *
+ * Keep this cast-only helper local to constructor boundaries so follow-up work
+ * can replace it with aligned content types or explicit conversion logic.
+ */
+export declare function toLangChainMessageFields<T extends {
+    content: LibreChatMessageContent;
+}>(message: T): WithLangChainContent<T>;
+export {};

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

@@ -0,0 +1,19 @@
+import type * as t from './types';
+export declare class TavilyScraper implements t.BaseScraper {
+    private apiKey;
+    private apiUrl;
+    private timeout;
+    private payloadTimeout;
+    private logger;
+    private extractDepth;
+    private includeImages;
+    private includeFavicon;
+    private format;
+    constructor(config?: t.TavilyScraperConfig);
+    scrapeUrl(url: string, options?: t.TavilyScrapeOptions): Promise<[string, t.TavilyScrapeResponse]>;
+    scrapeUrls(urls: string[], options?: t.TavilyScrapeOptions): Promise<Array<[string, t.TavilyScrapeResponse]>>;
+    private extractBatch;
+    extractContent(response: t.TavilyScrapeResponse): [string, undefined | t.References];
+    extractMetadata(response: t.TavilyScrapeResponse): t.GenericScrapeMetadata;
+}
+export declare const createTavilyScraper: (config?: t.TavilyScraperConfig) => TavilyScraper;

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

@@ -0,0 +1,4 @@
+import type * as t from './types';
+export declare const createTavilyAPI: (apiKey?: string, apiUrl?: string, options?: t.TavilySearchOptions) => {
+    getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
+};

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

@@ -2,8 +2,8 @@ import type { Logger as WinstonLogger } from 'winston';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
-export type SearchProvider = 'serper' | 'searxng';
-export type ScraperProvider = 'firecrawl' | 'serper';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -56,11 +56,50 @@ export interface Source {
     snippet?: string;
     date?: string;
 }
+export type TavilyTimeRange = 'day' | 'week' | 'month' | 'year';
+export type TavilyTimeRangeInput = TavilyTimeRange | 'h' | 'd' | 'w' | 'm' | 'y';
+export interface TavilySearchOptions {
+    searchDepth?: 'basic' | 'advanced' | 'fast' | 'ultra-fast';
+    maxResults?: number;
+    includeImages?: boolean;
+    includeAnswer?: boolean | 'basic' | 'advanced';
+    includeRawContent?: boolean | 'markdown' | 'text';
+    includeDomains?: string[];
+    excludeDomains?: string[];
+    topic?: 'general' | 'news' | 'finance';
+    timeRange?: TavilyTimeRangeInput;
+    includeImageDescriptions?: boolean;
+    includeFavicon?: boolean;
+    chunksPerSource?: number;
+    safeSearch?: boolean;
+    timeout?: number;
+}
+export interface TavilySearchPayload {
+    query: string;
+    search_depth: NonNullable<TavilySearchOptions['searchDepth']>;
+    topic: NonNullable<TavilySearchOptions['topic']>;
+    max_results: number;
+    safe_search?: boolean;
+    time_range?: TavilyTimeRange;
+    country?: string;
+    include_images?: boolean;
+    include_answer?: NonNullable<TavilySearchOptions['includeAnswer']>;
+    include_raw_content?: NonNullable<TavilySearchOptions['includeRawContent']>;
+    include_domains?: string[];
+    exclude_domains?: string[];
+    include_image_descriptions?: boolean;
+    include_favicon?: boolean;
+    chunks_per_source?: number;
+}
 export interface SearchConfig {
     searchProvider?: SearchProvider;
     serperApiKey?: string;
     searxngInstanceUrl?: string;
     searxngApiKey?: string;
+    tavilyApiKey?: string;
+    tavilySearchUrl?: string;
+    tavilyExtractUrl?: string;
+    tavilySearchOptions?: TavilySearchOptions;
 }
 export type References = {
     links: MediaReference[];
@@ -95,6 +134,16 @@ export interface SerperScraperConfig {
     logger?: Logger;
     includeMarkdown?: boolean;
 }
+export interface TavilyScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    timeout?: number;
+    logger?: Logger;
+    extractDepth?: 'basic' | 'advanced';
+    includeImages?: boolean;
+    includeFavicon?: boolean;
+    format?: 'markdown' | 'text';
+}
 export interface ScraperContentResult {
     content: string;
 }
@@ -135,6 +184,7 @@ export interface CohereRerankerResponse {
 export type SafeSearchLevel = 0 | 1 | 2;
 export type Logger = WinstonLogger;
 export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
+    tavilyScraperOptions?: TavilyScraperConfig;
     logger?: Logger;
     safeSearch?: SafeSearchLevel;
     jinaApiKey?: string;
@@ -157,15 +207,27 @@ export type UsedReferences = {
     originalIndex: number;
     reference: MediaReference;
 }[];
+export type AnyScraperResponse = FirecrawlScrapeResponse | SerperScrapeResponse | TavilyScrapeResponse;
 /** Base Scraper Interface */
 export interface BaseScraper {
-    scrapeUrl(url: string, options?: unknown): Promise<[string, FirecrawlScrapeResponse | SerperScrapeResponse]>;
-    extractContent(response: FirecrawlScrapeResponse | SerperScrapeResponse): [string, undefined | References];
-    extractMetadata(response: FirecrawlScrapeResponse | SerperScrapeResponse): ScrapeMetadata | Record<string, string | number | boolean | null | undefined>;
+    scrapeUrl(url: string, options?: unknown): Promise<[string, AnyScraperResponse]>;
+    scrapeUrls?(urls: string[], options?: unknown): Promise<Array<[string, AnyScraperResponse]>>;
+    extractContent(response: AnyScraperResponse): [string, undefined | References];
+    extractMetadata(response: AnyScraperResponse): ScrapeMetadata | GenericScrapeMetadata;
 }
 /** Firecrawl */
 export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'version' | 'logger'>;
 export type SerperScrapeOptions = Omit<SerperScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+export type TavilyScrapeOptions = Omit<TavilyScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+export interface TavilyExtractPayload {
+    urls: string[];
+    extract_depth: NonNullable<TavilyScraperConfig['extractDepth']>;
+    include_images: boolean;
+    include_favicon?: boolean;
+    format?: NonNullable<TavilyScraperConfig['format']>;
+    timeout?: number;
+}
+export type GenericScrapeMetadata = Record<string, string | number | boolean | null | undefined>;
 export interface ScrapeMetadata {
     sourceURL?: string;
     url?: string;
@@ -241,6 +303,38 @@ export interface SerperScrapeResponse {
     };
     error?: string;
 }
+export interface TavilyScrapeResponse {
+    success: boolean;
+    data?: {
+        rawContent?: string;
+        images?: string[];
+        favicon?: string;
+    };
+    error?: string;
+}
+export interface TavilySearchResult {
+    title?: string;
+    url?: string;
+    content?: string;
+    score?: number;
+    published_date?: string;
+}
+export type TavilyImageResult = string | {
+    url?: string;
+    description?: string;
+};
+export interface TavilySearchResponse {
+    answer?: string;
+    images?: TavilyImageResult[];
+    results?: TavilySearchResult[];
+}
+export interface TavilyExtractResult {
+    url: string;
+    raw_content?: string;
+    images?: string[];
+    favicon?: string;
+    error?: string;
+}
 export interface FirecrawlScraperConfig {
     apiKey?: string;
     apiUrl?: string;

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

@@ -6,5 +6,5 @@ import type * as t from './types';
  */
 export declare const createDefaultLogger: () => t.Logger;
 export declare const fileExtRegex: RegExp;
-export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata, logger?: t.Logger) => string | undefined;
-export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata, logger?: t.Logger): string | undefined;
+export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata | t.GenericScrapeMetadata, logger?: t.Logger) => string | undefined;
+export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata | t.GenericScrapeMetadata, logger?: t.Logger): string | undefined;