@librechat/agents 3.1.75 → 3.1.77-dev.1

package/dist/cjs/llm/openai/index.cjs

@@ -53,6 +53,153 @@ function normalizeHeaders(headers) {
     });
     return Object.fromEntries(output.entries());
 }
+function getExposedOpenAIClient(completions, responses, preferResponses) {
+    const responsesClient = responses.client;
+    if (responsesClient?.abortHandler != null) {
+        return responsesClient;
+    }
+    const completionsClient = completions.client;
+    if (completionsClient?.abortHandler != null) {
+        return completionsClient;
+    }
+    const delegate = preferResponses ? responses : completions;
+    delegate._getClientOptions(undefined);
+    return delegate.client;
+}
+function getReasoningParams(baseReasoning, options) {
+    let reasoning;
+    if (baseReasoning !== undefined) {
+        reasoning = {
+            ...reasoning,
+            ...baseReasoning,
+        };
+    }
+    if (options?.reasoning !== undefined) {
+        reasoning = {
+            ...reasoning,
+            ...options.reasoning,
+        };
+    }
+    if (options?.reasoningEffort !== undefined &&
+        reasoning?.effort === undefined) {
+        reasoning = {
+            ...reasoning,
+            effort: options.reasoningEffort,
+        };
+    }
+    return reasoning;
+}
+function getGatedReasoningParams(model, baseReasoning, options) {
+    if (!index.isReasoningModel(model)) {
+        return;
+    }
+    return getReasoningParams(baseReasoning, options);
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isOpenAIChatCompletionChunk(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    // Intentionally loose: downstream handlers already tolerate empty choices.
+    const { choices } = value;
+    return Array.isArray(choices);
+}
+function getOpenAIChatCompletionChunk(value) {
+    if (isOpenAIChatCompletionChunk(value)) {
+        return value;
+    }
+    const { data } = value;
+    if (isOpenAIChatCompletionChunk(data)) {
+        return data;
+    }
+    return undefined;
+}
+async function* filterOpenAIChatCompletionStream(stream) {
+    for await (const item of stream) {
+        const chunk = getOpenAIChatCompletionChunk(item);
+        if (chunk == null) {
+            continue;
+        }
+        yield chunk;
+    }
+}
+async function completionWithFilteredOpenAIStream(request, requestOptions, completionWithRetry) {
+    if (request.stream !== true) {
+        return (await completionWithRetry(request, requestOptions));
+    }
+    const stream = await completionWithRetry(request, requestOptions);
+    return filterOpenAIChatCompletionStream(stream);
+}
+function attachLibreChatDeltaFields(chunk, delta) {
+    if (!messages.AIMessageChunk.isInstance(chunk)) {
+        return chunk;
+    }
+    const libreChatDelta = delta;
+    if (libreChatDelta.reasoning != null &&
+        chunk.additional_kwargs.reasoning_content == null) {
+        chunk.additional_kwargs.reasoning_content = libreChatDelta.reasoning;
+    }
+    if (libreChatDelta.reasoning_details != null) {
+        chunk.additional_kwargs.reasoning_details =
+            libreChatDelta.reasoning_details;
+    }
+    if (libreChatDelta.provider_specific_fields != null) {
+        chunk.additional_kwargs.provider_specific_fields =
+            libreChatDelta.provider_specific_fields;
+    }
+    return chunk;
+}
+function attachLibreChatMessageFields(message, rawMessage) {
+    if (!messages.isAIMessage(message)) {
+        return message;
+    }
+    if (rawMessage.reasoning != null &&
+        message.additional_kwargs.reasoning_content == null) {
+        message.additional_kwargs.reasoning_content = rawMessage.reasoning;
+    }
+    if (rawMessage.reasoning_details != null) {
+        message.additional_kwargs.reasoning_details = rawMessage.reasoning_details;
+    }
+    if (rawMessage.provider_specific_fields != null) {
+        message.additional_kwargs.provider_specific_fields =
+            rawMessage.provider_specific_fields;
+    }
+    return message;
+}
+function getCustomOpenAIClientOptions(owner, options) {
+    if (!owner.client) {
+        const openAIEndpointConfig = {
+            baseURL: owner.clientConfig.baseURL,
+        };
+        const endpoint = openai.getEndpoint(openAIEndpointConfig);
+        const params = {
+            ...owner.clientConfig,
+            baseURL: endpoint,
+            timeout: owner.timeout,
+            maxRetries: 0,
+        };
+        if (params.baseURL == null) {
+            delete params.baseURL;
+        }
+        params.defaultHeaders = openai.getHeadersWithUserAgent(params.defaultHeaders);
+        owner.client = new CustomOpenAIClient(params);
+    }
+    const requestOptions = {
+        ...owner.clientConfig,
+        ...options,
+    };
+    return requestOptions;
+}
+async function* delayStreamChunks(chunks, delay) {
+    for await (const chunk of chunks) {
+        yield chunk;
+        if (delay != null) {
+            await run.sleep(delay);
+        }
+    }
+}
 function createAbortHandler(controller) {
     return function () {
         controller.abort();
@@ -112,89 +259,165 @@ class CustomAzureOpenAIClient extends openai$1.AzureOpenAI {
         }));
     }
 }
-/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
-class ChatOpenAI extends openai.ChatOpenAI {
-    _lc_stream_delay;
+class LibreChatOpenAICompletions extends openai.ChatOpenAICompletions {
+    includeReasoningContent;
+    includeReasoningDetails;
+    convertReasoningDetailsToContent;
     constructor(fields) {
         super(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay;
-    }
-    get exposedClient() {
-        return this.client;
+        this.includeReasoningContent = fields?.includeReasoningContent;
+        this.includeReasoningDetails = fields?.includeReasoningDetails;
+        this.convertReasoningDetailsToContent =
+            fields?.convertReasoningDetailsToContent;
     }
-    static lc_name() {
-        return 'LibreChatOpenAI';
+    _getReasoningParams(options) {
+        return getReasoningParams(this.reasoning, options);
     }
     _getClientOptions(options) {
-        if (!this.client) {
-            const openAIEndpointConfig = {
-                baseURL: this.clientConfig.baseURL,
-            };
-            const endpoint = openai.getEndpoint(openAIEndpointConfig);
-            const params = {
-                ...this.clientConfig,
-                baseURL: endpoint,
-                timeout: this.timeout,
-                maxRetries: 0,
-            };
-            if (params.baseURL == null) {
-                delete params.baseURL;
-            }
-            this.client = new CustomOpenAIClient(params);
-        }
-        const requestOptions = {
-            ...this.clientConfig,
-            ...options,
-        };
-        return requestOptions;
+        return getCustomOpenAIClientOptions(this, options);
     }
-    /**
-     * Returns backwards compatible reasoning parameters from constructor params and call options
-     * @internal
-     */
-    getReasoningParams(options) {
-        // apply options in reverse order of importance -- newer options supersede older options
-        let reasoning;
-        if (this.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...this.reasoning,
+    async completionWithRetry(request, requestOptions) {
+        return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
+    }
+    _convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
+        return attachLibreChatDeltaFields(super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole), delta);
+    }
+    _convertCompletionsMessageToBaseMessage(message, rawResponse) {
+        return attachLibreChatMessageFields(super._convertCompletionsMessageToBaseMessage(message, rawResponse), message);
+    }
+    async _generate(messages$1, options, runManager) {
+        if (this.includeReasoningContent !== true &&
+            this.includeReasoningDetails !== true) {
+            return super._generate(messages$1, options, runManager);
+        }
+        options.signal?.throwIfAborted();
+        const usageMetadata = {};
+        const params = this.invocationParams(options);
+        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model, {
+            includeReasoningContent: this.includeReasoningContent,
+            includeReasoningDetails: this.includeReasoningDetails,
+            convertReasoningDetailsToContent: this.convertReasoningDetailsToContent,
+        });
+        if (params.stream === true) {
+            const stream = this._streamResponseChunks(messages$1, options, runManager);
+            const finalChunks = new Map();
+            for await (const chunk of stream) {
+                chunk.message.response_metadata = {
+                    ...chunk.generationInfo,
+                    ...chunk.message.response_metadata,
+                };
+                const index = typeof chunk.generationInfo?.completion === 'number'
+                    ? chunk.generationInfo.completion
+                    : 0;
+                const existingChunk = finalChunks.get(index);
+                if (existingChunk == null) {
+                    finalChunks.set(index, chunk);
+                }
+                else {
+                    finalChunks.set(index, existingChunk.concat(chunk));
+                }
+            }
+            const generations = Array.from(finalChunks.entries())
+                .sort(([aKey], [bKey]) => aKey - bKey)
+                .map(([, value]) => value);
+            const { functions, function_call } = this.invocationParams(options);
+            const promptTokenUsage = await this._getEstimatedTokenCountFromPrompt(messages$1, functions, function_call);
+            const completionTokenUsage = await this._getNumTokensFromGenerations(generations);
+            usageMetadata.input_tokens = promptTokenUsage;
+            usageMetadata.output_tokens = completionTokenUsage;
+            usageMetadata.total_tokens = promptTokenUsage + completionTokenUsage;
+            return {
+                generations,
+                llmOutput: {
+                    estimatedTokenUsage: {
+                        promptTokens: usageMetadata.input_tokens,
+                        completionTokens: usageMetadata.output_tokens,
+                        totalTokens: usageMetadata.total_tokens,
+                    },
+                },
             };
         }
-        if (options?.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...options.reasoning,
+        const data = await this.completionWithRetry({
+            ...params,
+            stream: false,
+            messages: messagesMapped,
+        }, {
+            signal: options.signal,
+            ...options.options,
+        });
+        const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, prompt_tokens_details: promptTokensDetails, completion_tokens_details: completionTokensDetails, } = data.usage ?? {};
+        if (completionTokens != null) {
+            usageMetadata.output_tokens =
+                (usageMetadata.output_tokens ?? 0) + completionTokens;
+        }
+        if (promptTokens != null) {
+            usageMetadata.input_tokens =
+                (usageMetadata.input_tokens ?? 0) + promptTokens;
+        }
+        if (totalTokens != null) {
+            usageMetadata.total_tokens =
+                (usageMetadata.total_tokens ?? 0) + totalTokens;
+        }
+        if (promptTokensDetails?.audio_tokens != null ||
+            promptTokensDetails?.cached_tokens != null) {
+            usageMetadata.input_token_details = {
+                ...(promptTokensDetails.audio_tokens != null && {
+                    audio: promptTokensDetails.audio_tokens,
+                }),
+                ...(promptTokensDetails.cached_tokens != null && {
+                    cache_read: promptTokensDetails.cached_tokens,
+                }),
             };
         }
-        return reasoning;
-    }
-    _getReasoningParams(options) {
-        return this.getReasoningParams(options);
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        if (!this._useResponseApi(options)) {
-            return yield* this._streamResponseChunks2(messages, options, runManager);
+        if (completionTokensDetails?.audio_tokens != null ||
+            completionTokensDetails?.reasoning_tokens != null) {
+            usageMetadata.output_token_details = {
+                ...(completionTokensDetails.audio_tokens != null && {
+                    audio: completionTokensDetails.audio_tokens,
+                }),
+                ...(completionTokensDetails.reasoning_tokens != null && {
+                    reasoning: completionTokensDetails.reasoning_tokens,
+                }),
+            };
         }
-        const streamIterable = await this.responseApiWithRetry({
-            ...this.invocationParams(options, { streaming: true }),
-            input: index._convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
-            stream: true,
-        }, options);
-        for await (const data of streamIterable) {
-            const chunk = index._convertOpenAIResponsesDeltaToBaseMessageChunk(data);
-            if (chunk == null)
-                continue;
-            yield chunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
+        const generations = [];
+        for (const part of data.choices) {
+            const generation = {
+                text: part.message.content ?? '',
+                message: this._convertCompletionsMessageToBaseMessage(part.message, data),
+            };
+            generation.generationInfo = {
+                finish_reason: part.finish_reason,
+                ...(part.logprobs ? { logprobs: part.logprobs } : {}),
+            };
+            if (messages.isAIMessage(generation.message)) {
+                generation.message.usage_metadata = usageMetadata;
             }
-            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
+            generation.message = new messages.AIMessage(Object.fromEntries(Object.entries(generation.message).filter(([key]) => !key.startsWith('lc_'))));
+            generations.push(generation);
         }
-        return;
+        return {
+            generations,
+            llmOutput: {
+                tokenUsage: {
+                    promptTokens: usageMetadata.input_tokens,
+                    completionTokens: usageMetadata.output_tokens,
+                    totalTokens: usageMetadata.total_tokens,
+                },
+            },
+        };
     }
-    async *_streamResponseChunks2(messages$1, options, runManager) {
-        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model);
+    async *_streamResponseChunks(messages$1, options, runManager) {
+        if (this.includeReasoningContent !== true &&
+            this.includeReasoningDetails !== true) {
+            yield* super._streamResponseChunks(messages$1, options, runManager);
+            return;
+        }
+        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model, {
+            includeReasoningContent: this.includeReasoningContent,
+            includeReasoningDetails: this.includeReasoningDetails,
+            convertReasoningDetailsToContent: this.convertReasoningDetailsToContent,
+        });
         const params = {
             ...this.invocationParams(options, {
                 streaming: true,
@@ -206,49 +429,40 @@ class ChatOpenAI extends openai.ChatOpenAI {
         const streamIterable = await this.completionWithRetry(params, options);
         let usage;
         for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
+            if (options.signal?.aborted === true) {
+                return;
+            }
+            const choices = data.choices;
+            const choice = choices?.[0];
+            if (data.usage != null) {
                 usage = data.usage;
             }
-            if (!choice) {
+            if (choice == null) {
                 continue;
             }
             const { delta } = choice;
-            if (!delta) {
+            if (delta == null) {
                 continue;
             }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            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;
-            }
+            const chunk = this._convertCompletionsDeltaToBaseMessageChunk(delta, data, defaultRole);
             defaultRole = delta.role ?? defaultRole;
             const newTokenIndices = {
                 prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
+                completion: choice.index,
             };
             if (typeof chunk.content !== 'string') {
                 // eslint-disable-next-line no-console
                 console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
                 continue;
             }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const generationInfo = { ...newTokenIndices };
             if (choice.finish_reason != null) {
                 generationInfo.finish_reason = choice.finish_reason;
-                // Only include system fingerprint in the last chunk for now
-                // to avoid concatenation issues
                 generationInfo.system_fingerprint = data.system_fingerprint;
                 generationInfo.model_name = data.model;
                 generationInfo.service_tier = data.service_tier;
             }
-            if (this.logprobs == true) {
+            if (this.logprobs === true) {
                 generationInfo.logprobs = choice.logprobs;
             }
             const generationChunk = new outputs.ChatGenerationChunk({
@@ -257,10 +471,7 @@ class ChatOpenAI extends openai.ChatOpenAI {
                 generationInfo,
             });
             yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
+            await runManager?.handleLLMNewToken(generationChunk.text, newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
         }
         if (usage) {
             const inputTokenDetails = {
@@ -282,9 +493,7 @@ class ChatOpenAI extends openai.ChatOpenAI {
             const generationChunk = new outputs.ChatGenerationChunk({
                 message: new messages.AIMessageChunk({
                     content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                    },
+                    response_metadata: { usage: { ...usage } },
                     usage_metadata: {
                         input_tokens: usage.prompt_tokens,
                         output_tokens: usage.completion_tokens,
@@ -300,54 +509,27 @@ class ChatOpenAI extends openai.ChatOpenAI {
                 text: '',
             });
             yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
+            await runManager?.handleLLMNewToken(generationChunk.text, {
+                prompt: 0,
+                completion: 0,
+            }, undefined, undefined, undefined, { chunk: generationChunk });
         }
         if (options.signal?.aborted === true) {
             throw new Error('AbortError');
         }
     }
 }
-/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
-class AzureChatOpenAI extends openai.AzureChatOpenAI {
-    _lc_stream_delay;
-    constructor(fields) {
-        super(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay;
-    }
-    get exposedClient() {
-        return this.client;
-    }
-    static lc_name() {
-        return 'LibreChatAzureOpenAI';
+class LibreChatOpenAIResponses extends openai.ChatOpenAIResponses {
+    _getReasoningParams(options) {
+        return getReasoningParams(this.reasoning, options);
     }
-    /**
-     * Returns backwards compatible reasoning parameters from constructor params and call options
-     * @internal
-     */
-    getReasoningParams(options) {
-        if (!index.isReasoningModel(this.model)) {
-            return;
-        }
-        // apply options in reverse order of importance -- newer options supersede older options
-        let reasoning;
-        if (this.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...this.reasoning,
-            };
-        }
-        if (options?.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...options.reasoning,
-            };
-        }
-        return reasoning;
+    _getClientOptions(options) {
+        return getCustomOpenAIClientOptions(this, options);
     }
+}
+class LibreChatAzureOpenAICompletions extends openai.AzureChatOpenAICompletions {
     _getReasoningParams(options) {
-        return this.getReasoningParams(options);
+        return getGatedReasoningParams(this.model, this.reasoning, options);
     }
     _getClientOptions(options) {
         if (!this.client) {
@@ -401,120 +583,22 @@ class AzureChatOpenAI extends openai.AzureChatOpenAI {
         }
         return requestOptions;
     }
-    async *_streamResponseChunks(messages, options, runManager) {
-        if (!this._useResponseApi(options)) {
-            return yield* super._streamResponseChunks(messages, options, runManager);
-        }
-        const streamIterable = await this.responseApiWithRetry({
-            ...this.invocationParams(options, { streaming: true }),
-            input: index._convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
-            stream: true,
-        }, options);
-        for await (const data of streamIterable) {
-            const chunk = index._convertOpenAIResponsesDeltaToBaseMessageChunk(data);
-            if (chunk == null)
-                continue;
-            yield chunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
-        }
-        return;
+    async completionWithRetry(request, requestOptions) {
+        return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
     }
 }
-class ChatDeepSeek extends deepseek.ChatDeepSeek {
-    get exposedClient() {
-        return this.client;
-    }
-    static lc_name() {
-        return 'LibreChatDeepSeek';
-    }
-    _convertMessages(messages) {
-        return index._convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
-    }
-    async _generate(messages, options, runManager) {
-        const params = this.invocationParams(options);
-        if (params.stream === true) {
-            return super._generate(messages, options ?? {}, runManager);
-        }
-        const messagesMapped = this._convertMessages(messages);
-        const data = await this.completionWithRetry({
-            ...params,
-            stream: false,
-            messages: messagesMapped,
-        }, {
-            signal: options?.signal,
-            ...options?.options,
-        });
-        const { completion_tokens, prompt_tokens, total_tokens } = data.usage ?? {};
-        const generations = [];
-        for (const part of data.choices ?? []) {
-            const text = part.message.content ?? '';
-            const generation = {
-                text: typeof text === 'string' ? text : '',
-                message: this._convertResponseToMessage(part, data),
-            };
-            generation.generationInfo = {
-                ...(part.finish_reason != null
-                    ? { finish_reason: part.finish_reason }
-                    : {}),
-                ...(part.logprobs ? { logprobs: part.logprobs } : {}),
-            };
-            generations.push(generation);
-        }
-        return {
-            generations,
-            llmOutput: {
-                tokenUsage: {
-                    completionTokens: completion_tokens,
-                    promptTokens: prompt_tokens,
-                    totalTokens: total_tokens,
-                },
-            },
-        };
-    }
-    _convertResponseToMessage(choice, data) {
-        const { message } = choice;
-        const rawToolCalls = message.tool_calls;
-        const toolCalls = rawToolCalls?.map((tc) => ({
-            id: tc.id,
-            name: tc.function.name,
-            args: JSON.parse(tc.function.arguments || '{}'),
-            type: 'tool_call',
-        }));
-        const additional_kwargs = {};
-        if (rawToolCalls) {
-            additional_kwargs.tool_calls = rawToolCalls;
-        }
-        if ('reasoning_content' in message &&
-            message.reasoning_content != null &&
-            message.reasoning_content !== '') {
-            additional_kwargs.reasoning_content = message.reasoning_content;
-        }
-        return new messages.AIMessage({
-            content: message.content ?? '',
-            tool_calls: toolCalls,
-            additional_kwargs,
-            usage_metadata: data.usage
-                ? {
-                    input_tokens: data.usage.prompt_tokens,
-                    output_tokens: data.usage.completion_tokens,
-                    total_tokens: data.usage.total_tokens,
-                }
-                : undefined,
-            response_metadata: {
-                model_name: data.model,
-                system_fingerprint: data.system_fingerprint,
-                finish_reason: choice.finish_reason,
-            },
-        });
+class LibreChatAzureOpenAIResponses extends openai.AzureChatOpenAIResponses {
+    _getReasoningParams(options) {
+        return getGatedReasoningParams(this.model, this.reasoning, options);
     }
     _getClientOptions(options) {
         if (!this.client) {
             const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                azureADTokenProvider: this.azureADTokenProvider,
                 baseURL: this.clientConfig.baseURL,
             };
             const endpoint = openai.getEndpoint(openAIEndpointConfig);
@@ -524,311 +608,227 @@ class ChatDeepSeek extends deepseek.ChatDeepSeek {
                 timeout: this.timeout,
                 maxRetries: 0,
             };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
             if (params.baseURL == null) {
                 delete params.baseURL;
             }
-            this.client = new CustomOpenAIClient(params);
+            const defaultHeaders = normalizeHeaders(params.defaultHeaders);
+            params.defaultHeaders = {
+                ...params.defaultHeaders,
+                'User-Agent': defaultHeaders['User-Agent'] != null
+                    ? `${defaultHeaders['User-Agent']}: librechat-azure-openai-v2`
+                    : 'librechat-azure-openai-v2',
+            };
+            this.client = new CustomAzureOpenAIClient({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                ...params,
+            });
         }
         const requestOptions = {
             ...this.clientConfig,
             ...options,
         };
+        if (this.azureOpenAIApiKey != null) {
+            requestOptions.headers = {
+                'api-key': this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                'api-version': this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
         return requestOptions;
     }
-    async *_streamResponseChunks(messages$1, options, runManager) {
-        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model, {
-            includeReasoningContent: true,
-        });
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
+}
+function withLibreChatOpenAIFields(fields) {
+    const nextFields = fields ?? {};
+    return {
+        ...nextFields,
+        completions: nextFields.completions ?? new LibreChatOpenAICompletions(nextFields),
+        responses: nextFields.responses ?? new LibreChatOpenAIResponses(nextFields),
+    };
+}
+class ChatOpenAI extends openai.ChatOpenAI {
+    _lc_stream_delay;
+    constructor(fields) {
+        super(withLibreChatOpenAIFields(fields));
+        this._lc_stream_delay = fields?._lc_stream_delay;
+    }
+    get exposedClient() {
+        return getExposedOpenAIClient(this.completions, this.responses, this._useResponsesApi(undefined));
+    }
+    static lc_name() {
+        return 'LibreChatOpenAI';
+    }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                baseURL: this.clientConfig.baseURL,
             };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
+            const endpoint = openai.getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (params.baseURL == null) {
+                delete params.baseURL;
             }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
+            this.client = new CustomOpenAIClient(params);
+        }
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        return requestOptions;
+    }
+    /**
+     * Returns backwards compatible reasoning parameters from constructor params and call options
+     * @internal
+     */
+    getReasoningParams(options) {
+        return getReasoningParams(this.reasoning, options);
+    }
+    _getReasoningParams(options) {
+        return this.getReasoningParams(options);
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
+    }
+}
+class AzureChatOpenAI extends openai.AzureChatOpenAI {
+    _lc_stream_delay;
+    constructor(fields) {
+        super(fields);
+        this.completions = new LibreChatAzureOpenAICompletions(fields);
+        this.responses = new LibreChatAzureOpenAIResponses(fields);
+        this._lc_stream_delay = fields?._lc_stream_delay;
+    }
+    get exposedClient() {
+        return getExposedOpenAIClient(this.completions, this.responses, this._useResponsesApi(undefined));
+    }
+    static lc_name() {
+        return 'LibreChatAzureOpenAI';
+    }
+    /**
+     * Returns backwards compatible reasoning parameters from constructor params and call options
+     * @internal
+     */
+    getReasoningParams(options) {
+        return getGatedReasoningParams(this.model, this.reasoning, options);
+    }
+    _getReasoningParams(options) {
+        return this.getReasoningParams(options);
+    }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                azureADTokenProvider: this.azureADTokenProvider,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = openai.getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
             }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
+            if (params.baseURL == null) {
+                delete params.baseURL;
             }
-            const generationChunk = new outputs.ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
+            const defaultHeaders = normalizeHeaders(params.defaultHeaders);
+            params.defaultHeaders = {
+                ...params.defaultHeaders,
+                'User-Agent': defaultHeaders['User-Agent'] != null
+                    ? `${defaultHeaders['User-Agent']}: librechat-azure-openai-v2`
+                    : 'librechat-azure-openai-v2',
+            };
+            this.client = new CustomAzureOpenAIClient({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                ...params,
             });
-            yield generationChunk;
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
         }
-        if (usage) {
-            const inputTokenDetails = {
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        if (this.azureOpenAIApiKey != null) {
+            requestOptions.headers = {
+                'api-key': this.azureOpenAIApiKey,
+                ...requestOptions.headers,
             };
-            const outputTokenDetails = {
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
+            requestOptions.query = {
+                'api-version': this.azureOpenAIApiVersion,
+                ...requestOptions.query,
             };
-            const generationChunk = new outputs.ChatGenerationChunk({
-                message: new messages.AIMessageChunk({
-                    content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                    },
-                    usage_metadata: {
-                        input_tokens: usage.prompt_tokens,
-                        output_tokens: usage.completion_tokens,
-                        total_tokens: usage.total_tokens,
-                        ...(Object.keys(inputTokenDetails).length > 0 && {
-                            input_token_details: inputTokenDetails,
-                        }),
-                        ...(Object.keys(outputTokenDetails).length > 0 && {
-                            output_token_details: outputTokenDetails,
-                        }),
-                    },
-                }),
-                text: '',
-            });
-            yield generationChunk;
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
         }
+        return requestOptions;
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
     }
 }
-class ChatMoonshot extends ChatOpenAI {
-    static lc_name() {
-        return 'LibreChatMoonshot';
+class ChatDeepSeek extends deepseek.ChatDeepSeek {
+    _lc_stream_delay;
+    constructor(fields) {
+        super(fields);
+        this._lc_stream_delay = fields?._lc_stream_delay;
     }
-    _convertMessages(messages) {
-        return index._convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
+    get exposedClient() {
+        return this.client;
     }
-    async _generate(messages, options, runManager) {
-        const params = this.invocationParams(options);
-        if (params.stream === true) {
-            return super._generate(messages, options, runManager);
-        }
-        const messagesMapped = this._convertMessages(messages);
-        const data = await this.completionWithRetry({
-            ...params,
-            stream: false,
-            messages: messagesMapped,
-        }, {
-            signal: options.signal,
-            ...options.options,
-        });
-        const { completion_tokens, prompt_tokens, total_tokens } = data.usage ?? {};
-        const generations = [];
-        for (const part of data.choices ?? []) {
-            const text = part.message.content ?? '';
-            const generation = {
-                text: typeof text === 'string' ? text : '',
-                message: this._convertResponseToMessage(part, data),
+    static lc_name() {
+        return 'LibreChatDeepSeek';
+    }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                baseURL: this.clientConfig.baseURL,
             };
-            generation.generationInfo = {
-                ...(part.finish_reason ? { finish_reason: part.finish_reason } : {}),
-                ...(part.logprobs ? { logprobs: part.logprobs } : {}),
+            const endpoint = openai.getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
             };
-            generations.push(generation);
+            if (params.baseURL == null) {
+                delete params.baseURL;
+            }
+            this.client = new CustomOpenAIClient(params);
         }
-        return {
-            generations,
-            llmOutput: {
-                tokenUsage: {
-                    completionTokens: completion_tokens,
-                    promptTokens: prompt_tokens,
-                    totalTokens: total_tokens,
-                },
-            },
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
         };
+        return requestOptions;
     }
-    _convertResponseToMessage(choice, data) {
-        const { message } = choice;
-        const rawToolCalls = message.tool_calls;
-        const toolCalls = rawToolCalls?.map((tc) => ({
-            id: tc.id,
-            name: tc.function.name,
-            args: JSON.parse(tc.function.arguments || '{}'),
-            type: 'tool_call',
-        }));
-        const additional_kwargs = {};
-        if (rawToolCalls) {
-            additional_kwargs.tool_calls = rawToolCalls;
-        }
-        if ('reasoning_content' in message &&
-            message.reasoning_content != null &&
-            message.reasoning_content !== '') {
-            additional_kwargs.reasoning_content = message.reasoning_content;
-        }
-        return new messages.AIMessage({
-            content: message.content ?? '',
-            tool_calls: toolCalls,
-            additional_kwargs,
-            usage_metadata: data.usage
-                ? {
-                    input_tokens: data.usage.prompt_tokens,
-                    output_tokens: data.usage.completion_tokens,
-                    total_tokens: data.usage.total_tokens,
-                }
-                : undefined,
-            response_metadata: {
-                model_name: data.model,
-                system_fingerprint: data.system_fingerprint,
-                finish_reason: choice.finish_reason,
-            },
-        });
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
     }
-    async *_streamResponseChunks(messages$1, options, runManager) {
-        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model, {
+}
+class ChatMoonshot extends ChatOpenAI {
+    constructor(fields) {
+        super({
+            ...fields,
             includeReasoningContent: true,
         });
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new outputs.ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            const inputTokenDetails = {
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-            };
-            const outputTokenDetails = {
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
-            };
-            const generationChunk = new outputs.ChatGenerationChunk({
-                message: new messages.AIMessageChunk({
-                    content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                    },
-                    usage_metadata: {
-                        input_tokens: usage.prompt_tokens,
-                        output_tokens: usage.completion_tokens,
-                        total_tokens: usage.total_tokens,
-                        ...(Object.keys(inputTokenDetails).length > 0 && {
-                            input_token_details: inputTokenDetails,
-                        }),
-                        ...(Object.keys(outputTokenDetails).length > 0 && {
-                            output_token_details: outputTokenDetails,
-                        }),
-                    },
-                }),
-                text: '',
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
+    }
+    static lc_name() {
+        return 'LibreChatMoonshot';
     }
 }
 class ChatXAI extends xai.ChatXAI {
@@ -876,144 +876,8 @@ class ChatXAI extends xai.ChatXAI {
         };
         return requestOptions;
     }
-    async *_streamResponseChunks(messages$1, options, runManager) {
-        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model);
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if (chunk.usage_metadata != null) {
-                chunk.usage_metadata = {
-                    input_tokens: chunk.usage_metadata.input_tokens ?? 0,
-                    output_tokens: chunk.usage_metadata.output_tokens ?? 0,
-                    total_tokens: chunk.usage_metadata.total_tokens ?? 0,
-                };
-            }
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                // Only include system fingerprint in the last chunk for now
-                // to avoid concatenation issues
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new outputs.ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            // Type assertion for xAI-specific usage structure
-            const xaiUsage = usage;
-            const inputTokenDetails = {
-                // Standard OpenAI fields
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-                // Add xAI-specific prompt token details if they exist
-                ...(xaiUsage.prompt_tokens_details?.text_tokens != null && {
-                    text: xaiUsage.prompt_tokens_details.text_tokens,
-                }),
-                ...(xaiUsage.prompt_tokens_details?.image_tokens != null && {
-                    image: xaiUsage.prompt_tokens_details.image_tokens,
-                }),
-            };
-            const outputTokenDetails = {
-                // Standard OpenAI fields
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
-                // Add xAI-specific completion token details if they exist
-                ...(xaiUsage.completion_tokens_details?.accepted_prediction_tokens !=
-                    null && {
-                    accepted_prediction: xaiUsage.completion_tokens_details.accepted_prediction_tokens,
-                }),
-                ...(xaiUsage.completion_tokens_details?.rejected_prediction_tokens !=
-                    null && {
-                    rejected_prediction: xaiUsage.completion_tokens_details.rejected_prediction_tokens,
-                }),
-            };
-            const generationChunk = new outputs.ChatGenerationChunk({
-                message: new messages.AIMessageChunk({
-                    content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                        // Include xAI-specific metadata if it exists
-                        ...(xaiUsage.num_sources_used != null && {
-                            num_sources_used: xaiUsage.num_sources_used,
-                        }),
-                    },
-                    usage_metadata: {
-                        input_tokens: usage.prompt_tokens,
-                        output_tokens: usage.completion_tokens,
-                        total_tokens: usage.total_tokens,
-                        ...(Object.keys(inputTokenDetails).length > 0 && {
-                            input_token_details: inputTokenDetails,
-                        }),
-                        ...(Object.keys(outputTokenDetails).length > 0 && {
-                            output_token_details: outputTokenDetails,
-                        }),
-                    },
-                }),
-                text: '',
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await run.sleep(this._lc_stream_delay);
-            }
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
     }
 }