@librechat/agents 3.0.0-rc10 → 3.0.0-rc11

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

@@ -3,5 +3,6 @@ import { ChatOllama as BaseChatOllama } from '@langchain/ollama';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { BaseMessage } from '@langchain/core/messages';
 export declare class ChatOllama extends BaseChatOllama {
+    static lc_name(): 'LibreChatOllama';
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }

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

@@ -45,6 +45,7 @@ export declare class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptio
         _lc_stream_delay?: number;
     } & t.OpenAIChatInput['modelKwargs']);
     get exposedClient(): CustomOpenAIClient;
+    static lc_name(): string;
     protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     /**
      * Returns backwards compatible reasoning parameters from constructor params and call options
@@ -62,6 +63,7 @@ export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
         _lc_stream_delay?: number;
     });
     get exposedClient(): CustomOpenAIClient;
+    static lc_name(): 'LibreChatAzureOpenAI';
     /**
      * Returns backwards compatible reasoning parameters from constructor params and call options
      * @internal
@@ -73,6 +75,7 @@ export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
 }
 export declare class ChatDeepSeek extends OriginalChatDeepSeek {
     get exposedClient(): CustomOpenAIClient;
+    static lc_name(): 'LibreChatDeepSeek';
     protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
 }
 /** xAI-specific usage metadata type */
@@ -102,6 +105,7 @@ export declare class ChatXAI extends OriginalChatXAI {
         };
         _lc_stream_delay?: number;
     });
+    static lc_name(): 'LibreChatXAI';
     get exposedClient(): CustomOpenAIClient;
     protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;

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

@@ -1,10 +1,12 @@
-import type { ChatOpenAICallOptions, OpenAIClient } from '@langchain/openai';
-import type { AIMessageChunk, HumanMessageChunk, SystemMessageChunk, FunctionMessageChunk, ToolMessageChunk, ChatMessageChunk } from '@langchain/core/messages';
 import { ChatOpenAI } from '@/llm/openai';
+import type { FunctionMessageChunk, SystemMessageChunk, HumanMessageChunk, ToolMessageChunk, ChatMessageChunk, AIMessageChunk } from '@langchain/core/messages';
+import type { ChatOpenAICallOptions, OpenAIChatInput, OpenAIClient } from '@langchain/openai';
 export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
     include_reasoning?: boolean;
+    modelKwargs?: OpenAIChatInput['modelKwargs'];
 }
 export declare class ChatOpenRouter extends ChatOpenAI {
     constructor(_fields: Partial<ChatOpenRouterCallOptions>);
+    static lc_name(): 'LibreChatOpenRouter';
     protected _convertOpenAIDeltaToBaseMessageChunk(delta: Record<string, any>, rawResponse: OpenAIClient.ChatCompletionChunk, defaultRole?: 'function' | 'user' | 'system' | 'developer' | 'assistant' | 'tool'): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
 }

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

@@ -286,7 +286,7 @@ import type { VertexAIClientOptions } from '@/types';
 export declare class ChatVertexAI extends ChatGoogle {
     lc_namespace: string[];
     dynamicThinkingBudget: boolean;
-    static lc_name(): 'ChatVertexAI';
+    static lc_name(): 'LibreChatVertexAI';
     constructor(fields?: VertexAIClientOptions);
     invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
     buildConnection(fields: VertexAIClientOptions, client: GoogleAbstractedClient): void;

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

@@ -2,23 +2,23 @@ import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import { Providers } from '@/common';
-interface VisionMessageParams {
+interface MediaMessageParams {
     message: {
         role: string;
         content: string;
         name?: string;
         [key: string]: any;
     };
-    image_urls: MessageContentImageUrl[];
+    mediaParts: MessageContentComplex[];
     endpoint?: Providers;
 }
 /**
- * Formats a message to OpenAI Vision API payload format.
+ * Formats a message with media content (images, documents, videos, audios) to API payload format.
  *
- * @param {VisionMessageParams} params - The parameters for formatting.
- * @returns {Object} - The formatted message.
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
  */
-export declare const formatVisionMessage: ({ message, image_urls, endpoint, }: VisionMessageParams) => {
+export declare const formatMediaMessage: ({ message, endpoint, mediaParts, }: MediaMessageParams) => {
     role: string;
     content: MessageContentComplex[];
     name?: string;
@@ -31,6 +31,9 @@ interface MessageInput {
     text?: string;
     content?: string | MessageContentComplex[];
     image_urls?: MessageContentImageUrl[];
+    documents?: MessageContentComplex[];
+    videos?: MessageContentComplex[];
+    audios?: MessageContentComplex[];
     lc_id?: string[];
     [key: string]: any;
 }
@@ -50,16 +53,16 @@ interface FormattedMessage {
 /**
  * Formats a message to OpenAI payload format based on the provided options.
  *
- * @param {FormatMessageParams} params - The parameters for formatting.
- * @returns {FormattedMessage | HumanMessage | AIMessage | SystemMessage} - The formatted message.
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
  */
-export declare const formatMessage: ({ message, userName, assistantName, endpoint, langChain, }: FormatMessageParams) => FormattedMessage | HumanMessage | AIMessage | SystemMessage;
+export declare const formatMessage: ({ message, userName, endpoint, assistantName, langChain, }: FormatMessageParams) => FormattedMessage | HumanMessage | AIMessage | SystemMessage;
 /**
  * Formats an array of messages for LangChain.
  *
- * @param {Array<MessageInput>} messages - The array of messages to format.
- * @param {Omit<FormatMessageParams, 'message' | 'langChain'>} formatOptions - The options for formatting each message.
- * @returns {Array<HumanMessage | AIMessage | SystemMessage>} - The array of formatted LangChain messages.
+ * @param messages - The array of messages to format.
+ * @param formatOptions - The options for formatting each message.
+ * @returns - The array of formatted LangChain messages.
  */
 export declare const formatLangChainMessages: (messages: Array<MessageInput>, formatOptions: Omit<FormatMessageParams, "message" | "langChain">) => Array<HumanMessage | AIMessage | SystemMessage>;
 interface LangChainMessage {
@@ -76,17 +79,17 @@ interface LangChainMessage {
 /**
  * Formats a LangChain message object by merging properties from `lc_kwargs` or `kwargs` and `additional_kwargs`.
  *
- * @param {LangChainMessage} message - The message object to format.
- * @returns {Record<string, any>} The formatted LangChain message.
+ * @param message - The message object to format.
+ * @returns - The formatted LangChain message.
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
- * @param {TPayload} payload - The array of messages to format.
- * @param {Record<number, number>} [indexTokenCountMap] - Optional map of message indices to token counts.
- * @param {Set<string>} [tools] - Optional set of tool names that are allowed in the request.
- * @returns {Object} - Object containing formatted messages and updated indexTokenCountMap if provided.
+ * @param payload - The array of messages to format.
+ * @param indexTokenCountMap - Optional map of message indices to token counts.
+ * @param tools - Optional set of tool names that are allowed in the request.
+ * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
 export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number>, tools?: Set<string>) => {
     messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
@@ -94,8 +97,8 @@ export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap
 };
 /**
  * Formats an array of messages for LangChain, making sure all content fields are strings
- * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.
- * @returns {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} - The array of formatted LangChain messages, including ToolMessages for tool calls.
+ * @param payload - The array of messages to format.
+ * @returns - The array of formatted LangChain messages, including ToolMessages for tool calls.
  */
 export declare const formatContentStrings: (payload: Array<BaseMessage>) => Array<BaseMessage>;
 /**

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

@@ -3,9 +3,10 @@ import type * as t from './types';
  * Firecrawl scraper implementation
  * Uses the Firecrawl API to scrape web pages
  */
-export declare class FirecrawlScraper {
+export declare class FirecrawlScraper implements t.BaseScraper {
     private apiKey;
     private apiUrl;
+    private version;
     private defaultFormats;
     private timeout;
     private logger;

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

@@ -7,8 +7,10 @@ export declare abstract class BaseReranker {
     protected getDefaultRanking(documents: string[], topK: number): t.Highlight[];
 }
 export declare class JinaReranker extends BaseReranker {
-    constructor({ apiKey, logger, }: {
+    private apiUrl;
+    constructor({ apiKey, apiUrl, logger, }: {
         apiKey?: string;
+        apiUrl?: string;
         logger?: t.Logger;
     });
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
@@ -30,6 +32,7 @@ export declare class InfinityReranker extends BaseReranker {
 export declare const createReranker: (config: {
     rerankerType: t.RerankerType;
     jinaApiKey?: string;
+    jinaApiUrl?: string;
     cohereApiKey?: string;
     logger?: t.Logger;
 }) => BaseReranker | undefined;

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

@@ -1,9 +1,8 @@
 import type * as t from './types';
-import { FirecrawlScraper } from './firecrawl';
 export declare const createSearchAPI: (config: t.SearchConfig) => {
     getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
 };
-export declare const createSourceProcessor: (config?: t.ProcessSourcesConfig, scraperInstance?: FirecrawlScraper) => {
+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/tool.d.ts

@@ -6,6 +6,27 @@ import { DATE_RANGE } from './schema';
  * Creates a search tool with a schema that dynamically includes the country field
  * only when the searchProvider is 'serper'.
  *
+ * Supports multiple scraper providers:
+ * - Firecrawl (default): Full-featured web scraping with multiple formats
+ * - Serper: Lightweight scraping using Serper's scrape API
+ *
+ * @example
+ * ```typescript
+ * // Using Firecrawl scraper (default)
+ * const searchTool = createSearchTool({
+ *   searchProvider: 'serper',
+ *   scraperProvider: 'firecrawl',
+ *   firecrawlApiKey: 'your-firecrawl-key'
+ * });
+ *
+ * // Using Serper scraper
+ * const searchTool = createSearchTool({
+ *   searchProvider: 'serper',
+ *   scraperProvider: 'serper',
+ *   serperApiKey: 'your-serper-key'
+ * });
+ * ```
+ *
  * @param config - The search tool configuration
  * @returns A DynamicStructuredTool with a schema that depends on the searchProvider
  */
@@ -18,16 +39,16 @@ export declare const createSearchTool: (config?: t.SearchToolConfig) => DynamicS
     news: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     query: string;
-    date?: DATE_RANGE | undefined;
-    images?: boolean | undefined;
     videos?: boolean | undefined;
+    images?: boolean | undefined;
     news?: boolean | undefined;
+    date?: DATE_RANGE | undefined;
     country?: unknown;
 }, {
     query: string;
-    date?: DATE_RANGE | undefined;
-    images?: boolean | undefined;
     videos?: boolean | undefined;
+    images?: boolean | undefined;
     news?: boolean | undefined;
+    date?: DATE_RANGE | undefined;
     country?: unknown;
 }>>;

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

@@ -4,6 +4,7 @@ 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 RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -85,8 +86,16 @@ export interface ProcessSourcesConfig {
 export interface FirecrawlConfig {
     firecrawlApiKey?: string;
     firecrawlApiUrl?: string;
+    firecrawlVersion?: string;
     firecrawlOptions?: FirecrawlScraperConfig;
 }
+export interface SerperScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    timeout?: number;
+    logger?: Logger;
+    includeMarkdown?: boolean;
+}
 export interface ScraperContentResult {
     content: string;
 }
@@ -130,9 +139,12 @@ export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, Fi
     logger?: Logger;
     safeSearch?: SafeSearchLevel;
     jinaApiKey?: string;
+    jinaApiUrl?: string;
     cohereApiKey?: string;
     rerankerType?: RerankerType;
+    scraperProvider?: ScraperProvider;
     scraperTimeout?: number;
+    serperScraperOptions?: SerperScraperConfig;
     onSearchResults?: (results: SearchResult, runnableConfig?: RunnableConfig) => void;
     onGetHighlights?: (link: string) => void;
 }
@@ -146,8 +158,15 @@ export type UsedReferences = {
     originalIndex: number;
     reference: MediaReference;
 }[];
+/** 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>;
+}
 /** Firecrawl */
-export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'version' | 'logger'>;
+export type SerperScrapeOptions = Omit<SerperScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export interface ScrapeMetadata {
     sourceURL?: string;
     url?: string;
@@ -213,9 +232,20 @@ export interface FirecrawlScrapeResponse {
     };
     error?: string;
 }
+export interface SerperScrapeResponse {
+    success: boolean;
+    data?: {
+        text?: string;
+        markdown?: string;
+        metadata?: Record<string, string | number | boolean | null | undefined>;
+        credits?: number;
+    };
+    error?: string;
+}
 export interface FirecrawlScraperConfig {
     apiKey?: string;
     apiUrl?: string;
+    version?: string;
     formats?: string[];
     timeout?: number;
     logger?: Logger;

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

@@ -0,0 +1,34 @@
+/**
+ * Multi-Agent Handler Utilities
+ *
+ * Provides a simple helper to create handlers with content aggregation for multi-agent scripts.
+ *
+ * Usage:
+ * ```typescript
+ * const { contentParts, aggregateContent, handlers } = createHandlers();
+ *
+ * // With callbacks
+ * const { contentParts, aggregateContent, handlers } = createHandlers({
+ *   onRunStep: (event, data) => console.log('Step:', data),
+ *   onRunStepCompleted: (event, data) => console.log('Completed:', data)
+ * });
+ * ```
+ */
+import { GraphEvents } from '@/common';
+import { createContentAggregator } from '@/stream';
+import type * as t from '@/types';
+interface HandlerCallbacks {
+    onRunStep?: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData) => void;
+    onRunStepCompleted?: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData) => void;
+    onRunStepDelta?: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData) => void;
+    onMessageDelta?: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData) => void;
+}
+/**
+ * Creates handlers with content aggregation for multi-agent scripts
+ */
+export declare function createHandlers(callbacks?: HandlerCallbacks): {
+    contentParts: Array<t.MessageContentComplex | undefined>;
+    aggregateContent: ReturnType<typeof createContentAggregator>['aggregateContent'];
+    handlers: Record<string, t.EventHandler>;
+};
+export {};

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

@@ -1,5 +1,6 @@
 export * from './graph';
 export * from './llm';
 export * from './misc';
+export * from './handlers';
 export * from './run';
 export * from './tokens';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.0.00-rc10",
+  "version": "3.0.00-rc11",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -51,7 +51,7 @@
     "caching": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/caching.ts --name 'Jo' --location 'New York, NY'",
     "thinking": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/thinking.ts --name 'Jo' --location 'New York, NY'",
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
-    "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
+    "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'openrouter' --name 'Jo' --location 'New York, NY'",
     "search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/search.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "ant_web_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search.ts --name 'Jo' --location 'New York, NY'",
     "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",

package/src/graphs/Graph.ts

@@ -299,6 +299,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       agentContext.currentTokenType === 'think_and_text'
     ) {
       keyList.push('reasoning');
+    } else if (agentContext.tokenTypeSwitch === 'content') {
+      keyList.push('post-reasoning');
     }
 
     if (this.invokedToolIds != null && this.invokedToolIds.size > 0) {
@@ -580,7 +582,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               null) ||
           (agentContext.provider === Providers.BEDROCK &&
             (agentContext.clientOptions as t.BedrockAnthropicInput)
-              .additionalModelRequestFields?.['thinking'] != null);
+              .additionalModelRequestFields?.['thinking'] != null) ||
+          (agentContext.provider === Providers.OPENAI &&
+            (
+              (agentContext.clientOptions as t.OpenAIClientOptions).modelKwargs
+                ?.thinking as t.AnthropicClientOptions['thinking']
+            )?.type === 'enabled');
 
         agentContext.pruneMessages = createPruneMessages({
           startIndex: this.startIndex,

package/src/llm/anthropic/index.ts

@@ -135,12 +135,18 @@ export class CustomAnthropic extends ChatAnthropicMessages {
   private message_delta: AnthropicMessageDeltaEvent | undefined;
   private tools_in_params?: boolean;
   private emitted_usage?: boolean;
+  top_k: number | undefined;
   constructor(fields?: CustomAnthropicInput) {
     super(fields);
     this.resetTokenEvents();
+    this.setDirectFields(fields);
     this._lc_stream_delay = fields?._lc_stream_delay ?? 25;
   }
 
+  static lc_name(): 'LibreChatAnthropic' {
+    return 'LibreChatAnthropic';
+  }
+
   /**
    * Get the parameters used to invoke the model
    */
@@ -158,7 +164,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       | undefined = handleToolChoice(options?.tool_choice);
 
     if (this.thinking.type === 'enabled') {
-      if (this.topK !== -1 && (this.topK as number | undefined) != null) {
+      if (this.top_k !== -1 && (this.top_k as number | undefined) != null) {
         throw new Error('topK is not supported when thinking is enabled');
       }
       if (this.topP !== -1 && (this.topP as number | undefined) != null) {
@@ -187,7 +193,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     return {
       model: this.model,
       temperature: this.temperature,
-      top_k: this.topK,
+      top_k: this.top_k,
       top_p: this.topP,
       stop_sequences: options?.stop ?? this.stopSequences,
       stream: this.streaming,
@@ -244,6 +250,21 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     this.tools_in_params = undefined;
   }
 
+  setDirectFields(fields?: CustomAnthropicInput): void {
+    this.temperature = fields?.temperature ?? undefined;
+    this.topP = fields?.topP ?? undefined;
+    this.top_k = fields?.topK;
+    if (this.temperature === -1 || this.temperature === 1) {
+      this.temperature = undefined;
+    }
+    if (this.topP === -1) {
+      this.topP = undefined;
+    }
+    if (this.top_k === -1) {
+      this.top_k = undefined;
+    }
+  }
+
   private createGenerationChunk({
     token,
     chunk,

package/src/llm/google/index.ts

@@ -107,6 +107,10 @@ export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
     this.streamUsage = fields.streamUsage ?? this.streamUsage;
   }
 
+  static lc_name(): 'LibreChatGoogleGenerativeAI' {
+    return 'LibreChatGoogleGenerativeAI';
+  }
+
   invocationParams(
     options?: this['ParsedCallOptions']
   ): Omit<GenerateContentRequest, 'contents'> {

package/src/llm/google/utils/common.ts

@@ -301,6 +301,20 @@ function _convertLangChainContentToPart(
         mimeType,
       },
     };
+  } else if (
+    content.type === 'document' ||
+    content.type === 'audio' ||
+    content.type === 'video'
+  ) {
+    if (!isMultimodalModel) {
+      throw new Error(`This model does not support ${content.type}s`);
+    }
+    return {
+      inlineData: {
+        data: content.data,
+        mimeType: content.mimeType,
+      },
+    };
   } else if (content.type === 'media') {
     return messageContentMedia(content);
   } else if (content.type === 'tool_use') {

package/src/llm/ollama/index.ts

@@ -13,6 +13,9 @@ import {
 } from './utils';
 
 export class ChatOllama extends BaseChatOllama {
+  static lc_name(): 'LibreChatOllama' {
+    return 'LibreChatOllama';
+  }
   async *_streamResponseChunks(
     messages: BaseMessage[],
     options: this['ParsedCallOptions'],

package/src/llm/openai/index.ts

@@ -210,6 +210,9 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  static lc_name(): string {
+    return 'LibreChatOpenAI';
+  }
   protected _getClientOptions(
     options?: OpenAICoreRequestOptions
   ): OpenAICoreRequestOptions {
@@ -245,7 +248,8 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    if (!isReasoningModel(this.model)) {
+    const lc_name = (this.constructor as typeof ChatOpenAI).lc_name();
+    if (lc_name === 'LibreChatOpenAI' && !isReasoningModel(this.model)) {
       return;
     }
 
@@ -360,6 +364,10 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
       } else if ('reasoning' in delta) {
         chunk.additional_kwargs.reasoning_content = delta.reasoning;
       }
+      if ('provider_specific_fields' in delta) {
+        chunk.additional_kwargs.provider_specific_fields =
+          delta.provider_specific_fields;
+      }
       defaultRole = delta.role ?? defaultRole;
       const newTokenIndices = {
         prompt: options.promptIndex ?? 0,
@@ -463,6 +471,9 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  static lc_name(): 'LibreChatAzureOpenAI' {
+    return 'LibreChatAzureOpenAI';
+  }
   /**
    * Returns backwards compatible reasoning parameters from constructor params and call options
    * @internal
@@ -607,6 +618,9 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  static lc_name(): 'LibreChatDeepSeek' {
+    return 'LibreChatDeepSeek';
+  }
   protected _getClientOptions(
     options?: OpenAICoreRequestOptions
   ): OpenAICoreRequestOptions {
@@ -679,6 +693,10 @@ export class ChatXAI extends OriginalChatXAI {
     }
   }
 
+  static lc_name(): 'LibreChatXAI' {
+    return 'LibreChatXAI';
+  }
+
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }