@librechat/agents 2.4.322 → 3.0.0-rc10

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

@@ -0,0 +1,293 @@
+import { ChatGoogle } from '@langchain/google-gauth';
+import type { GoogleAIModelRequestParams, GoogleAbstractedClient } from '@langchain/google-common';
+import type { VertexAIClientOptions } from '@/types';
+/**
+ * Integration with Google Vertex AI chat models.
+ *
+ * Setup:
+ * Install `@langchain/google-vertexai` and set your stringified
+ * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.
+ *
+ * ```bash
+ * npm install @langchain/google-vertexai
+ * export GOOGLE_APPLICATION_CREDENTIALS="path/to/credentials"
+ * ```
+ *
+ * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)
+ *
+ * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)
+ *
+ * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+ * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+ *
+ * ```typescript
+ * // When calling `.withConfig`, call options should be passed via the first argument
+ * const llmWithArgsBound = llm.withConfig({
+ *   stop: ["\n"],
+ *   tools: [...],
+ * });
+ *
+ * // When calling `.bindTools`, call options should be passed via the second argument
+ * const llmWithTools = llm.bindTools(
+ *   [...],
+ *   {
+ *     tool_choice: "auto",
+ *   }
+ * );
+ * ```
+ *
+ * ## Examples
+ *
+ * <details open>
+ * <summary><strong>Instantiate</strong></summary>
+ *
+ * ```typescript
+ * import { ChatVertexAI } from '@langchain/google-vertexai';
+ *
+ * const llm = new ChatVertexAI({
+ *   model: "gemini-1.5-pro",
+ *   temperature: 0,
+ *   // other params...
+ * });
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Invoking</strong></summary>
+ *
+ * ```typescript
+ * const input = `Translate "I love programming" into French.`;
+ *
+ * // Models also accept a list of chat messages or a formatted prompt
+ * const result = await llm.invoke(input);
+ * console.log(result);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n\nHere's why this is the best translation:\n\n* **J'adore** means \"I love\" and conveys a strong passion.\n* **Programmer** is the French verb for \"to program.\"\n\nThis translation is natural and idiomatic in French. \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 63,
+ *     "total_tokens": 72
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Streaming Chunks</strong></summary>
+ *
+ * ```typescript
+ * for await (const chunk of await llm.stream(input)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Aggregate Streamed Chunks</strong></summary>
+ *
+ * ```typescript
+ * import { AIMessageChunk } from '@langchain/core/messages';
+ * import { concat } from '@langchain/core/utils/stream';
+ *
+ * const stream = await llm.stream(input);
+ * let full: AIMessageChunk | undefined;
+ * for await (const chunk of stream) {
+ *   full = !full ? chunk : concat(full, chunk);
+ * }
+ * console.log(full);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Bind tools</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const GetWeather = {
+ *   name: "GetWeather",
+ *   description: "Get the current weather in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const GetPopulation = {
+ *   name: "GetPopulation",
+ *   description: "Get the current population in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
+ * const aiMsg = await llmWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?"
+ * );
+ * console.log(aiMsg.tool_calls);
+ * ```
+ *
+ * ```txt
+ * [
+ *   {
+ *     name: 'GetPopulation',
+ *     args: { location: 'New York City, NY' },
+ *     id: '33c1c1f47e2f492799c77d2800a43912',
+ *     type: 'tool_call'
+ *   }
+ * ]
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Structured Output</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const Joke = z.object({
+ *   setup: z.string().describe("The setup of the joke"),
+ *   punchline: z.string().describe("The punchline to the joke"),
+ *   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+ * }).describe('Joke to tell user.');
+ *
+ * const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
+ * const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+ * console.log(jokeResult);
+ * ```
+ *
+ * ```txt
+ * {
+ *   setup: 'What do you call a cat that loves to bowl?',
+ *   punchline: 'An alley cat!'
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const aiMsgForMetadata = await llm.invoke(input);
+ * console.log(aiMsgForMetadata.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Stream Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const streamForMetadata = await llm.stream(
+ *   input,
+ *   {
+ *     streamUsage: true
+ *   }
+ * );
+ * let fullForMetadata: AIMessageChunk | undefined;
+ * for await (const chunk of streamForMetadata) {
+ *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
+ * }
+ * console.log(fullForMetadata?.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ */
+export declare class ChatVertexAI extends ChatGoogle {
+    lc_namespace: string[];
+    dynamicThinkingBudget: boolean;
+    static lc_name(): 'ChatVertexAI';
+    constructor(fields?: VertexAIClientOptions);
+    invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
+    buildConnection(fields: VertexAIClientOptions, client: GoogleAbstractedClient): void;
+}

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

@@ -0,0 +1,9 @@
+import { BaseMessage, BaseMessageLike } from '@langchain/core/messages';
+export declare const REMOVE_ALL_MESSAGES = "__remove_all__";
+export type Messages = Array<BaseMessage | BaseMessageLike> | BaseMessage | BaseMessageLike;
+/**
+ * Prebuilt reducer that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
+export declare function messagesStateReducer(left: Messages, right: Messages): BaseMessage[];

package/dist/types/run.d.ts

@@ -1,28 +1,35 @@
 import type { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
-import type { ClientCallbacks, SystemCallbacks } from '@/graphs/Graph';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
-import { Providers } from '@/common';
+import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
 import { StandardGraph } from '@/graphs/Graph';
-export declare class Run<T extends t.BaseGraphState> {
-    graphRunnable?: t.CompiledWorkflow<T, Partial<T>, string>;
-    private handlerRegistry;
+export declare const defaultOmitOptions: Set<string>;
+export declare class Run<_T extends t.BaseGraphState> {
     id: string;
-    Graph: StandardGraph | undefined;
-    provider: Providers | undefined;
+    private tokenCounter?;
+    private handlerRegistry?;
+    private indexTokenCountMap?;
+    graphRunnable?: t.CompiledStateWorkflow;
+    Graph: StandardGraph | MultiAgentGraph | undefined;
     returnContent: boolean;
     private constructor();
-    private createStandardGraph;
+    private createLegacyGraph;
+    private createMultiAgentGraph;
     static create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>>;
     getRunMessages(): BaseMessage[] | undefined;
+    /**
+     * Creates a custom event callback handler that intercepts custom events
+     * and processes them through our handler registry instead of EventStreamCallbackHandler
+     */
+    private createCustomEventCallback;
     processStream(inputs: t.IState, config: Partial<RunnableConfig> & {
         version: 'v1' | 'v2';
         run_id?: string;
     }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
     private createSystemCallback;
-    getCallbacks(clientCallbacks: ClientCallbacks): SystemCallbacks;
-    generateTitle({ inputText, contentParts, titlePrompt, clientOptions, chainOptions, skipLanguage, }: t.RunTitleOptions): Promise<{
-        language: string;
-        title: string;
+    getCallbacks(clientCallbacks: t.ClientCallbacks): t.SystemCallbacks;
+    generateTitle({ provider, inputText, contentParts, titlePrompt, clientOptions, chainOptions, skipLanguage, titleMethod, titlePromptTemplate, }: t.RunTitleOptions): Promise<{
+        language?: string;
+        title?: string;
     }>;
 }

package/dist/types/stream.d.ts

@@ -1,8 +1,15 @@
 import type { AIMessageChunk } from '@langchain/core/messages';
-import type { Graph } from '@/graphs';
+import type { AgentContext } from '@/agents/AgentContext';
+import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
+import { Providers } from '@/common';
+export declare function getChunkContent({ chunk, provider, reasoningKey, }: {
+    chunk?: Partial<AIMessageChunk>;
+    provider?: Providers;
+    reasoningKey: 'reasoning_content' | 'reasoning';
+}): string | t.MessageContentComplex[] | undefined;
 export declare class ChatModelStreamHandler implements t.EventHandler {
-    handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: Graph): void;
-    handleReasoning(chunk: Partial<AIMessageChunk>, graph: Graph): void;
+    handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: StandardGraph): Promise<void>;
+    handleReasoning(chunk: Partial<AIMessageChunk>, agentContext: AgentContext): void;
 }
 export declare function createContentAggregator(): t.ContentAggregatorResult;

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

@@ -10,12 +10,12 @@ declare const CodeExecutionToolSchema: z.ZodObject<{
     args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     code: string;
-    lang: "r" | "py" | "js" | "ts" | "c" | "cpp" | "java" | "php" | "rs" | "go" | "d" | "f90";
+    lang: "r" | "d" | "py" | "js" | "ts" | "c" | "cpp" | "java" | "php" | "rs" | "go" | "f90";
     args?: string[] | undefined;
     session_id?: string | undefined;
 }, {
     code: string;
-    lang: "r" | "py" | "js" | "ts" | "c" | "cpp" | "java" | "php" | "rs" | "go" | "d" | "f90";
+    lang: "r" | "d" | "py" | "js" | "ts" | "c" | "cpp" | "java" | "php" | "rs" | "go" | "f90";
     args?: string[] | undefined;
     session_id?: string | undefined;
 }>;

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

@@ -19,4 +19,4 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     getToolUsageCounts(): ReadonlyMap<string, number>;
     protected run(input: any, config: RunnableConfig): Promise<T>;
 }
-export declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): 'tools' | typeof END;
+export declare function toolsCondition<T extends string>(state: BaseMessage[] | typeof MessagesAnnotation.State, toolNode: T, invokedToolIds?: Set<string>): T | typeof END;

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

@@ -1,8 +1,21 @@
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
-import type { Graph } from '@/graphs';
+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, }: {
-    graph: Graph;
+    graph: StandardGraph | MultiAgentGraph;
     stepKey: string;
     toolCallChunks: ToolCallChunk[];
-}): void;
-export declare const handleToolCalls: (toolCalls?: ToolCall[], metadata?: Record<string, unknown>, graph?: Graph) => void;
+}): 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/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/firecrawl.d.ts

@@ -9,6 +9,21 @@ export declare class FirecrawlScraper {
     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

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

@@ -5,7 +5,6 @@ export declare abstract class BaseReranker {
     constructor(logger?: t.Logger);
     abstract rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
     protected getDefaultRanking(documents: string[], topK: number): t.Highlight[];
-    protected logDocumentSamples(documents: string[]): void;
 }
 export declare class JinaReranker extends BaseReranker {
     constructor({ apiKey, logger, }: {

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

@@ -85,7 +85,7 @@ export interface ProcessSourcesConfig {
 export interface FirecrawlConfig {
     firecrawlApiKey?: string;
     firecrawlApiUrl?: string;
-    firecrawlFormats?: string[];
+    firecrawlOptions?: FirecrawlScraperConfig;
 }
 export interface ScraperContentResult {
     content: string;
@@ -132,6 +132,7 @@ export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, Fi
     jinaApiKey?: string;
     cohereApiKey?: string;
     rerankerType?: RerankerType;
+    scraperTimeout?: number;
     onSearchResults?: (results: SearchResult, runnableConfig?: RunnableConfig) => void;
     onGetHighlights?: (link: string) => void;
 }
@@ -146,14 +147,7 @@ export type UsedReferences = {
     reference: MediaReference;
 }[];
 /** Firecrawl */
-export interface FirecrawlScrapeOptions {
-    formats?: string[];
-    includeTags?: string[];
-    excludeTags?: string[];
-    headers?: Record<string, string>;
-    waitFor?: number;
-    timeout?: number;
-}
+export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export interface ScrapeMetadata {
     sourceURL?: string;
     url?: string;
@@ -225,6 +219,24 @@ export interface FirecrawlScraperConfig {
     formats?: string[];
     timeout?: number;
     logger?: Logger;
+    includeTags?: string[];
+    excludeTags?: string[];
+    waitFor?: number;
+    maxAge?: number;
+    mobile?: boolean;
+    skipTlsVerification?: boolean;
+    blockAds?: boolean;
+    removeBase64Images?: boolean;
+    parsePDF?: boolean;
+    storeInCache?: boolean;
+    zeroDataRetention?: boolean;
+    headers?: Record<string, string>;
+    location?: {
+        country?: string;
+        languages?: string[];
+    };
+    onlyMainContent?: boolean;
+    changeTrackingOptions?: object;
 }
 export type GetSourcesParams = {
     query: string;
@@ -507,6 +519,15 @@ export interface SearXNGResult {
     content?: string;
     publishedDate?: string;
     img_src?: string;
+    score?: number;
+    engine?: string;
+    category?: string;
+    thumbnail?: string;
+    priority?: string;
+    engines?: string[];
+    positions?: number[];
+    template?: string;
+    parsed_url?: string[];
 }
 export type ProcessSourcesFields = {
     result: SearchResult;