@librechat/agents 3.2.32 → 3.2.34

package/dist/esm/llm/openai/index.mjs

@@ -1,1323 +1,1090 @@
-import { AzureOpenAI } from 'openai';
-import { ChatXAI as ChatXAI$1 } from '@langchain/xai';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { ChatDeepSeek as ChatDeepSeek$1 } from '@langchain/deepseek';
-import { isAIMessage, AIMessage, AIMessageChunk } from '@langchain/core/messages';
-import { isLangChainTool, convertToOpenAITool } from '@langchain/core/utils/function_calling';
-import { getEndpoint, AzureChatOpenAI as AzureChatOpenAI$1, ChatOpenAI as ChatOpenAI$1, OpenAIClient, AzureChatOpenAICompletions, AzureChatOpenAIResponses, ChatOpenAIResponses, ChatOpenAICompletions, getHeadersWithUserAgent } from '@langchain/openai';
-import { _convertMessagesToOpenAIParams, isReasoningModel } from './utils/index.mjs';
-
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+import { OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER, STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY } from "../../tools/streamedToolCallSeals.mjs";
+import { _convertMessagesToOpenAIParams, isReasoningModel } from "./utils/index.mjs";
+import { AIMessage, AIMessageChunk, isAIMessage } from "@langchain/core/messages";
+import { AzureChatOpenAI, AzureChatOpenAICompletions, AzureChatOpenAIResponses, ChatOpenAI, ChatOpenAICompletions, ChatOpenAIResponses, OpenAIClient, getEndpoint, getHeadersWithUserAgent } from "@langchain/openai";
+import { AzureOpenAI } from "openai";
+import { ChatXAI } from "@langchain/xai";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { ChatDeepSeek } from "@langchain/deepseek";
+import { convertToOpenAITool, isLangChainTool } from "@langchain/core/utils/function_calling";
+//#region src/llm/openai/index.ts
 const iife = (fn) => fn();
 const STREAM_CHUNK_MIN_SIZE = 4;
-const STREAM_BOUNDARIES = new Set([' ', '.', ',', '!', '?', ';', ':']);
+const STREAM_BOUNDARIES = new Set([
+	" ",
+	".",
+	",",
+	"!",
+	"?",
+	";",
+	":"
+]);
 function isHeaders(headers) {
-    return (typeof Headers !== 'undefined' &&
-        headers !== null &&
-        typeof headers === 'object' &&
-        Object.prototype.toString.call(headers) === '[object Headers]');
+	return typeof Headers !== "undefined" && headers !== null && typeof headers === "object" && Object.prototype.toString.call(headers) === "[object Headers]";
 }
 function normalizeHeaders(headers) {
-    const output = iife(() => {
-        // If headers is a Headers instance
-        if (isHeaders(headers)) {
-            return headers;
-        }
-        // If headers is an array of [key, value] pairs
-        else if (Array.isArray(headers)) {
-            return new Headers(headers);
-        }
-        // If headers is a NullableHeaders-like object (has 'values' property that is a Headers)
-        else if (typeof headers === 'object' &&
-            headers !== null &&
-            'values' in headers &&
-            isHeaders(headers.values)) {
-            return headers.values;
-        }
-        // If headers is a plain object
-        else if (typeof headers === 'object' && headers !== null) {
-            const entries = Object.entries(headers)
-                .filter(([, v]) => typeof v === 'string')
-                .map(([k, v]) => [k, v]);
-            return new Headers(entries);
-        }
-        return new Headers();
-    });
-    return Object.fromEntries(output.entries());
+	const output = iife(() => {
+		if (isHeaders(headers)) return headers;
+		else if (Array.isArray(headers)) return new Headers(headers);
+		else if (typeof headers === "object" && headers !== null && "values" in headers && isHeaders(headers.values)) return headers.values;
+		else if (typeof headers === "object" && headers !== null) {
+			const entries = Object.entries(headers).filter(([, v]) => typeof v === "string").map(([k, v]) => [k, v]);
+			return new Headers(entries);
+		}
+		return new Headers();
+	});
+	return Object.fromEntries(output.entries());
 }
 function createUsageMetadata(usage) {
-    const usageMetadata = {
-        input_tokens: usage?.prompt_tokens ?? 0,
-        output_tokens: usage?.completion_tokens ?? 0,
-        total_tokens: usage?.total_tokens ?? 0,
-    };
-    if (usage == null) {
-        return usageMetadata;
-    }
-    const inputTokenDetails = {};
-    const outputTokenDetails = {};
-    let hasInputTokenDetails = false;
-    let hasOutputTokenDetails = false;
-    const promptTokenDetails = usage.prompt_tokens_details;
-    const audioInputTokens = promptTokenDetails?.audio_tokens;
-    const cachedInputTokens = promptTokenDetails?.cached_tokens;
-    const cacheWriteInputTokens = promptTokenDetails?.cache_write_tokens;
-    const audioOutputTokens = usage.completion_tokens_details?.audio_tokens;
-    const reasoningOutputTokens = usage.completion_tokens_details?.reasoning_tokens;
-    if (audioInputTokens != null) {
-        inputTokenDetails.audio = audioInputTokens;
-        hasInputTokenDetails = true;
-    }
-    if (cachedInputTokens != null) {
-        inputTokenDetails.cache_read = cachedInputTokens;
-        hasInputTokenDetails = true;
-    }
-    if (cacheWriteInputTokens != null) {
-        inputTokenDetails.cache_creation = cacheWriteInputTokens;
-        hasInputTokenDetails = true;
-    }
-    if (audioOutputTokens != null) {
-        outputTokenDetails.audio = audioOutputTokens;
-        hasOutputTokenDetails = true;
-    }
-    if (reasoningOutputTokens != null) {
-        outputTokenDetails.reasoning = reasoningOutputTokens;
-        hasOutputTokenDetails = true;
-    }
-    if (hasInputTokenDetails) {
-        usageMetadata.input_token_details = inputTokenDetails;
-    }
-    if (hasOutputTokenDetails) {
-        usageMetadata.output_token_details = outputTokenDetails;
-    }
-    return usageMetadata;
+	const usageMetadata = {
+		input_tokens: usage?.prompt_tokens ?? 0,
+		output_tokens: usage?.completion_tokens ?? 0,
+		total_tokens: usage?.total_tokens ?? 0
+	};
+	if (usage == null) return usageMetadata;
+	const inputTokenDetails = {};
+	const outputTokenDetails = {};
+	let hasInputTokenDetails = false;
+	let hasOutputTokenDetails = false;
+	const promptTokenDetails = usage.prompt_tokens_details;
+	const audioInputTokens = promptTokenDetails?.audio_tokens;
+	const cachedInputTokens = promptTokenDetails?.cached_tokens;
+	const cacheWriteInputTokens = promptTokenDetails?.cache_write_tokens;
+	const audioOutputTokens = usage.completion_tokens_details?.audio_tokens;
+	const reasoningOutputTokens = usage.completion_tokens_details?.reasoning_tokens;
+	if (audioInputTokens != null) {
+		inputTokenDetails.audio = audioInputTokens;
+		hasInputTokenDetails = true;
+	}
+	if (cachedInputTokens != null) {
+		inputTokenDetails.cache_read = cachedInputTokens;
+		hasInputTokenDetails = true;
+	}
+	if (cacheWriteInputTokens != null) {
+		inputTokenDetails.cache_creation = cacheWriteInputTokens;
+		hasInputTokenDetails = true;
+	}
+	if (audioOutputTokens != null) {
+		outputTokenDetails.audio = audioOutputTokens;
+		hasOutputTokenDetails = true;
+	}
+	if (reasoningOutputTokens != null) {
+		outputTokenDetails.reasoning = reasoningOutputTokens;
+		hasOutputTokenDetails = true;
+	}
+	if (hasInputTokenDetails) usageMetadata.input_token_details = inputTokenDetails;
+	if (hasOutputTokenDetails) usageMetadata.output_token_details = outputTokenDetails;
+	return usageMetadata;
 }
 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;
+	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(void 0);
+	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;
+	let reasoning;
+	if (baseReasoning !== void 0) reasoning = {
+		...reasoning,
+		...baseReasoning
+	};
+	if (options?.reasoning !== void 0) reasoning = {
+		...reasoning,
+		...options.reasoning
+	};
+	if (options?.reasoningEffort !== void 0 && reasoning?.effort === void 0) reasoning = {
+		...reasoning,
+		effort: options.reasoningEffort
+	};
+	return reasoning;
 }
 function getGatedReasoningParams(model, baseReasoning, options) {
-    if (!isReasoningModel(model)) {
-        return;
-    }
-    return getReasoningParams(baseReasoning, options);
+	if (!isReasoningModel(model)) return;
+	return getReasoningParams(baseReasoning, options);
 }
 function isObject(value) {
-    return typeof value === 'object' && value !== null;
+	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);
+	if (!isObject(value)) return false;
+	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;
+	if (isOpenAIChatCompletionChunk(value)) return value;
+	const { data } = value;
+	if (isOpenAIChatCompletionChunk(data)) return data;
 }
 async function* filterOpenAIChatCompletionStream(stream) {
-    for await (const item of stream) {
-        const chunk = getOpenAIChatCompletionChunk(item);
-        if (chunk == null) {
-            continue;
-        }
-        yield chunk;
-    }
+	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);
+	if (request.stream !== true) return await completionWithRetry(request, requestOptions);
+	return filterOpenAIChatCompletionStream(await completionWithRetry(request, requestOptions));
 }
 function attachLibreChatDeltaFields(chunk, delta) {
-    if (!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;
+	if (!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 (!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;
+	if (!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 = getEndpoint(openAIEndpointConfig);
-        const params = {
-            ...owner.clientConfig,
-            baseURL: endpoint,
-            timeout: owner.timeout,
-            maxRetries: 0,
-        };
-        if (params.baseURL == null) {
-            delete params.baseURL;
-        }
-        params.defaultHeaders = getHeadersWithUserAgent(params.defaultHeaders);
-        owner.client = new CustomOpenAIClient(params);
-    }
-    const requestOptions = {
-        ...owner.clientConfig,
-        ...options,
-    };
-    return requestOptions;
+	if (!owner.client) {
+		const endpoint = getEndpoint({ baseURL: owner.clientConfig.baseURL });
+		const params = {
+			...owner.clientConfig,
+			baseURL: endpoint,
+			timeout: owner.timeout,
+			maxRetries: 0
+		};
+		if (params.baseURL == null) delete params.baseURL;
+		params.defaultHeaders = getHeadersWithUserAgent(params.defaultHeaders);
+		owner.client = new CustomOpenAIClient(params);
+	}
+	return {
+		...owner.clientConfig,
+		...options
+	};
 }
 function findStreamChunkBoundary(text, minSize) {
-    if (minSize >= text.length) {
-        return text.length;
-    }
-    for (let position = minSize; position < text.length; position++) {
-        if (STREAM_BOUNDARIES.has(text[position])) {
-            return position + 1;
-        }
-    }
-    return text.length;
+	if (minSize >= text.length) return text.length;
+	for (let position = minSize; position < text.length; position++) if (STREAM_BOUNDARIES.has(text[position])) return position + 1;
+	return text.length;
 }
 function splitStreamToken(text) {
-    const chunks = [];
-    let currentIndex = 0;
-    while (currentIndex < text.length) {
-        const remainingText = text.slice(currentIndex);
-        const chunkSize = findStreamChunkBoundary(remainingText, STREAM_CHUNK_MIN_SIZE);
-        chunks.push(text.slice(currentIndex, currentIndex + chunkSize));
-        currentIndex += chunkSize;
-    }
-    return chunks;
+	const chunks = [];
+	let currentIndex = 0;
+	while (currentIndex < text.length) {
+		const chunkSize = findStreamChunkBoundary(text.slice(currentIndex), STREAM_CHUNK_MIN_SIZE);
+		chunks.push(text.slice(currentIndex, currentIndex + chunkSize));
+		currentIndex += chunkSize;
+	}
+	return chunks;
 }
 function splitTextGenerationChunk(chunk) {
-    const { message } = chunk;
-    if (!chunk.text ||
-        !(message instanceof AIMessageChunk) ||
-        typeof message.content !== 'string' ||
-        message.content !== chunk.text ||
-        chunk.generationInfo?.logprobs != null ||
-        chunk.generationInfo?.finish_reason != null) {
-        return [chunk];
-    }
-    const tokenChunks = splitStreamToken(chunk.text);
-    if (tokenChunks.length <= 1) {
-        return [chunk];
-    }
-    let emittedUsage = false;
-    return tokenChunks.map((token) => {
-        const usageMetadata = emittedUsage && message.usage_metadata != null
-            ? undefined
-            : message.usage_metadata;
-        if (message.usage_metadata != null && !emittedUsage) {
-            emittedUsage = true;
-        }
-        return new ChatGenerationChunk({
-            text: token,
-            generationInfo: chunk.generationInfo,
-            message: new AIMessageChunk(Object.assign({}, message, {
-                content: token,
-                usage_metadata: usageMetadata,
-            })),
-        });
-    });
+	const { message } = chunk;
+	if (!chunk.text || !(message instanceof AIMessageChunk) || typeof message.content !== "string" || message.content !== chunk.text || chunk.generationInfo?.logprobs != null || chunk.generationInfo?.finish_reason != null) return [chunk];
+	const tokenChunks = splitStreamToken(chunk.text);
+	if (tokenChunks.length <= 1) return [chunk];
+	let emittedUsage = false;
+	return tokenChunks.map((token) => {
+		const usageMetadata = emittedUsage && message.usage_metadata != null ? void 0 : message.usage_metadata;
+		if (message.usage_metadata != null && !emittedUsage) emittedUsage = true;
+		return new ChatGenerationChunk({
+			text: token,
+			generationInfo: chunk.generationInfo,
+			message: new AIMessageChunk(Object.assign({}, message, {
+				content: token,
+				usage_metadata: usageMetadata
+			}))
+		});
+	});
 }
 async function emitStreamChunkCallback(chunk, runManager) {
-    await runManager?.handleLLMNewToken(chunk.text, getStreamChunkTokenIndices(chunk), undefined, undefined, undefined, { chunk });
+	await runManager?.handleLLMNewToken(chunk.text, getStreamChunkTokenIndices(chunk), void 0, void 0, void 0, { chunk });
 }
 function getStreamChunkTokenIndices(chunk) {
-    const prompt = chunk.generationInfo?.prompt;
-    const completion = chunk.generationInfo?.completion;
-    if (typeof prompt === 'number' && typeof completion === 'number') {
-        return { prompt, completion };
-    }
-    return undefined;
+	const prompt = chunk.generationInfo?.prompt;
+	const completion = chunk.generationInfo?.completion;
+	if (typeof prompt === "number" && typeof completion === "number") return {
+		prompt,
+		completion
+	};
 }
 async function* delayStreamChunks(chunks, delay, signal, runManager) {
-    let lastYieldedAt;
-    for await (const chunk of chunks) {
-        const outputChunks = delay != null && delay > 0 ? splitTextGenerationChunk(chunk) : [chunk];
-        for (const outputChunk of outputChunks) {
-            signal?.throwIfAborted();
-            if (delay != null && delay > 0 && lastYieldedAt != null) {
-                const timeSinceLastYield = Date.now() - lastYieldedAt;
-                const timeToWait = Math.max(0, delay - timeSinceLastYield);
-                if (timeToWait > 0) {
-                    await sleepWithAbort(timeToWait, signal);
-                }
-            }
-            signal?.throwIfAborted();
-            lastYieldedAt = Date.now();
-            await emitStreamChunkCallback(outputChunk, runManager);
-            signal?.throwIfAborted();
-            yield outputChunk;
-        }
-    }
+	let lastYieldedAt;
+	for await (const chunk of chunks) {
+		const outputChunks = delay != null && delay > 0 ? splitTextGenerationChunk(chunk) : [chunk];
+		for (const outputChunk of outputChunks) {
+			signal?.throwIfAborted();
+			if (delay != null && delay > 0 && lastYieldedAt != null) {
+				const timeSinceLastYield = Date.now() - lastYieldedAt;
+				const timeToWait = Math.max(0, delay - timeSinceLastYield);
+				if (timeToWait > 0) await sleepWithAbort(timeToWait, signal);
+			}
+			signal?.throwIfAborted();
+			lastYieldedAt = Date.now();
+			await emitStreamChunkCallback(outputChunk, runManager);
+			signal?.throwIfAborted();
+			yield outputChunk;
+		}
+	}
 }
 async function sleepWithAbort(delay, signal) {
-    if (delay <= 0) {
-        return;
-    }
-    signal?.throwIfAborted();
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener('abort', onAbort);
-            resolve();
-        }, delay);
-        const onAbort = () => {
-            clearTimeout(timeout);
-            signal?.removeEventListener('abort', onAbort);
-            reject(signal?.reason ?? new Error('AbortError: User aborted request.'));
-        };
-        signal?.addEventListener('abort', onAbort, { once: true });
-        if (signal?.aborted === true) {
-            onAbort();
-        }
-    });
+	if (delay <= 0) return;
+	signal?.throwIfAborted();
+	await new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delay);
+		const onAbort = () => {
+			clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+			reject(signal?.reason ?? /* @__PURE__ */ new Error("AbortError: User aborted request."));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted === true) onAbort();
+	});
 }
 function createAbortHandler(controller) {
-    return function () {
-        controller.abort();
-    };
+	return function() {
+		controller.abort();
+	};
 }
 /**
- * Formats a tool in either OpenAI format, or LangChain structured tool format
- * into an OpenAI tool format. If the tool is already in OpenAI format, return without
- * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
- * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
- * returned from the `zodFunction` util are not defined.
- *
- * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
- * @param {Object} [fields] Additional fields to add to the OpenAI tool.
- * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
- */
+* Formats a tool in either OpenAI format, or LangChain structured tool format
+* into an OpenAI tool format. If the tool is already in OpenAI format, return without
+* any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
+* using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
+* returned from the `zodFunction` util are not defined.
+*
+* @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
+* @param {Object} [fields] Additional fields to add to the OpenAI tool.
+* @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+*/
 function _convertToOpenAITool(tool, fields) {
-    let toolDef;
-    if (isLangChainTool(tool)) {
-        toolDef = convertToOpenAITool(tool);
-    }
-    else {
-        toolDef = tool;
-    }
-    return toolDef;
-}
-class CustomOpenAIClient extends OpenAIClient {
-    abortHandler;
-    async fetchWithTimeout(url, init, ms, controller) {
-        const { signal, ...options } = init || {};
-        const handler = createAbortHandler(controller);
-        this.abortHandler = handler;
-        if (signal)
-            signal.addEventListener('abort', handler, { once: true });
-        const timeout = setTimeout(handler, ms);
-        const fetchOptions = {
-            signal: controller.signal,
-            ...options,
-        };
-        if (fetchOptions.method != null) {
-            // Custom methods like 'patch' need to be uppercased
-            // See https://github.com/nodejs/undici/issues/2294
-            fetchOptions.method = fetchOptions.method.toUpperCase();
-        }
-        return (
-        // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        /** @ts-ignore */
-        this.fetch.call(undefined, url, fetchOptions).finally(() => {
-            clearTimeout(timeout);
-        }));
-    }
-}
-class CustomAzureOpenAIClient extends AzureOpenAI {
-    abortHandler;
-    async fetchWithTimeout(url, init, ms, controller) {
-        const { signal, ...options } = init || {};
-        const handler = createAbortHandler(controller);
-        this.abortHandler = handler;
-        if (signal)
-            signal.addEventListener('abort', handler, { once: true });
-        const timeout = setTimeout(handler, ms);
-        const fetchOptions = {
-            signal: controller.signal,
-            ...options,
-        };
-        if (fetchOptions.method != null) {
-            // Custom methods like 'patch' need to be uppercased
-            // See https://github.com/nodejs/undici/issues/2294
-            fetchOptions.method = fetchOptions.method.toUpperCase();
-        }
-        return (
-        // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        /** @ts-ignore */
-        this.fetch.call(undefined, url, fetchOptions).finally(() => {
-            clearTimeout(timeout);
-        }));
-    }
+	let toolDef;
+	if (isLangChainTool(tool)) toolDef = convertToOpenAITool(tool);
+	else toolDef = tool;
+	if (fields?.strict !== void 0) toolDef.function.strict = fields.strict;
+	return toolDef;
 }
-class LibreChatOpenAICompletions extends ChatOpenAICompletions {
-    includeReasoningContent;
-    includeReasoningDetails;
-    convertReasoningDetailsToContent;
-    constructor(fields) {
-        super(fields);
-        this.includeReasoningContent = fields?.includeReasoningContent;
-        this.includeReasoningDetails = fields?.includeReasoningDetails;
-        this.convertReasoningDetailsToContent =
-            fields?.convertReasoningDetailsToContent;
-    }
-    _getReasoningParams(options) {
-        return getReasoningParams(this.reasoning, options);
-    }
-    _getClientOptions(options) {
-        return getCustomOpenAIClientOptions(this, options);
-    }
-    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, options, runManager) {
-        if (this.includeReasoningContent !== true &&
-            this.includeReasoningDetails !== true) {
-            return super._generate(messages, options, runManager);
-        }
-        options.signal?.throwIfAborted();
-        const usageMetadata = {};
-        const params = this.invocationParams(options);
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: this.includeReasoningContent,
-            includeReasoningDetails: this.includeReasoningDetails,
-            convertReasoningDetailsToContent: this.convertReasoningDetailsToContent,
-        });
-        if (params.stream === true) {
-            const stream = this._streamResponseChunks(messages, 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, 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,
-                    },
-                },
-            };
-        }
-        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;
-        }
-        const promptTokensDetailsWithCacheWrite = promptTokensDetails;
-        if (promptTokensDetailsWithCacheWrite?.audio_tokens != null ||
-            promptTokensDetailsWithCacheWrite?.cached_tokens != null ||
-            promptTokensDetailsWithCacheWrite?.cache_write_tokens != null) {
-            usageMetadata.input_token_details = {
-                ...(promptTokensDetailsWithCacheWrite.audio_tokens != null && {
-                    audio: promptTokensDetailsWithCacheWrite.audio_tokens,
-                }),
-                ...(promptTokensDetailsWithCacheWrite.cached_tokens != null && {
-                    cache_read: promptTokensDetailsWithCacheWrite.cached_tokens,
-                }),
-                ...(promptTokensDetailsWithCacheWrite.cache_write_tokens != null && {
-                    cache_creation: promptTokensDetailsWithCacheWrite.cache_write_tokens,
-                }),
-            };
-        }
-        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 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 (isAIMessage(generation.message)) {
-                generation.message.usage_metadata = usageMetadata;
-            }
-            generation.message = new AIMessage(Object.fromEntries(Object.entries(generation.message).filter(([key]) => !key.startsWith('lc_'))));
-            generations.push(generation);
-        }
-        return {
-            generations,
-            llmOutput: {
-                tokenUsage: {
-                    promptTokens: usageMetadata.input_tokens,
-                    completionTokens: usageMetadata.output_tokens,
-                    totalTokens: usageMetadata.total_tokens,
-                },
-            },
-        };
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        if (this.includeReasoningContent !== true &&
-            this.includeReasoningDetails !== true) {
-            yield* super._streamResponseChunks(messages, options, runManager);
-            return;
-        }
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: this.includeReasoningContent,
-            includeReasoningDetails: this.includeReasoningDetails,
-            convertReasoningDetailsToContent: this.convertReasoningDetailsToContent,
-        });
-        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) {
-            if (options.signal?.aborted === true) {
-                return;
-            }
-            const choices = data.choices;
-            const choice = choices?.[0];
-            if (data.usage != null) {
-                usage = data.usage;
-            }
-            if (choice == null) {
-                continue;
-            }
-            const { delta } = choice;
-            if (delta == null) {
-                continue;
-            }
-            const chunk = this._convertCompletionsDeltaToBaseMessageChunk(delta, data, defaultRole);
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 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;
-            }
-            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 ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            await runManager?.handleLLMNewToken(generationChunk.text, newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            const promptTokenDetails = usage.prompt_tokens_details;
-            const inputTokenDetails = {
-                ...(promptTokenDetails?.audio_tokens != null && {
-                    audio: promptTokenDetails.audio_tokens,
-                }),
-                ...(promptTokenDetails?.cached_tokens != null && {
-                    cache_read: promptTokenDetails.cached_tokens,
-                }),
-                ...(promptTokenDetails?.cache_write_tokens != null && {
-                    cache_creation: promptTokenDetails.cache_write_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 ChatGenerationChunk({
-                message: new 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;
-            await runManager?.handleLLMNewToken(generationChunk.text, {
-                prompt: 0,
-                completion: 0,
-            }, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-}
-class LibreChatOpenAIResponses extends ChatOpenAIResponses {
-    _getReasoningParams(options) {
-        return getReasoningParams(this.reasoning, options);
-    }
-    _getClientOptions(options) {
-        return getCustomOpenAIClientOptions(this, options);
-    }
+var CustomOpenAIClient = class extends OpenAIClient {
+	abortHandler;
+	async fetchWithTimeout(url, init, ms, controller) {
+		const { signal, ...options } = init || {};
+		const handler = createAbortHandler(controller);
+		this.abortHandler = handler;
+		if (signal) signal.addEventListener("abort", handler, { once: true });
+		const timeout = setTimeout(handler, ms);
+		const fetchOptions = {
+			signal: controller.signal,
+			...options
+		};
+		if (fetchOptions.method != null) fetchOptions.method = fetchOptions.method.toUpperCase();
+		return this.fetch.call(void 0, url, fetchOptions).finally(() => {
+			clearTimeout(timeout);
+		});
+	}
+};
+var CustomAzureOpenAIClient = class extends AzureOpenAI {
+	abortHandler;
+	async fetchWithTimeout(url, init, ms, controller) {
+		const { signal, ...options } = init || {};
+		const handler = createAbortHandler(controller);
+		this.abortHandler = handler;
+		if (signal) signal.addEventListener("abort", handler, { once: true });
+		const timeout = setTimeout(handler, ms);
+		const fetchOptions = {
+			signal: controller.signal,
+			...options
+		};
+		if (fetchOptions.method != null) fetchOptions.method = fetchOptions.method.toUpperCase();
+		return this.fetch.call(void 0, url, fetchOptions).finally(() => {
+			clearTimeout(timeout);
+		});
+	}
+};
+const OFFICIAL_OPENAI_BASE_URL_PATTERN = /^https:\/\/api\.openai\.com(\/|$)/;
+/**
+* Official OpenAI (api.openai.com) and Azure OpenAI Chat Completions streams
+* emit tool-call deltas strictly sequentially by index: once a delta for a
+* later index appears, a prior index's arguments never change. Stamping this
+* adapter lets the stream handler seal a prior call for eager execution the
+* moment the next call begins. OpenAI-compatible endpoints (custom baseURL)
+* must NOT be stamped — e.g. live Kimi/Moonshot streams revise prior-index
+* args after advancing — so callers gate on the wire endpoint, not the class.
+*/
+function stampSequentialStreamedToolCallAdapter(message) {
+	if (message instanceof AIMessageChunk && (message.tool_call_chunks?.length ?? 0) > 0) message.response_metadata = {
+		...message.response_metadata,
+		[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]: OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
+	};
+	return message;
 }
-class LibreChatAzureOpenAICompletions extends AzureChatOpenAICompletions {
-    _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 = getEndpoint(openAIEndpointConfig);
-            const params = {
-                ...this.clientConfig,
-                baseURL: endpoint,
-                timeout: this.timeout,
-                maxRetries: 0,
-            };
-            if (!this.azureADTokenProvider) {
-                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
-            }
-            if (params.baseURL == null) {
-                delete params.baseURL;
-            }
-            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 completionWithRetry(request, requestOptions) {
-        return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
-    }
+function isOfficialOpenAIBaseURL(baseURL) {
+	const effectiveBaseURL = baseURL != null && baseURL !== "" ? baseURL : process.env.OPENAI_BASE_URL;
+	if (effectiveBaseURL == null || effectiveBaseURL === "") return true;
+	return OFFICIAL_OPENAI_BASE_URL_PATTERN.test(effectiveBaseURL);
 }
-class LibreChatAzureOpenAIResponses extends 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 = getEndpoint(openAIEndpointConfig);
-            const params = {
-                ...this.clientConfig,
-                baseURL: endpoint,
-                timeout: this.timeout,
-                maxRetries: 0,
-            };
-            if (!this.azureADTokenProvider) {
-                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
-            }
-            if (params.baseURL == null) {
-                delete params.baseURL;
-            }
-            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;
-    }
+const AZURE_FIRST_PARTY_BASE_PATH_PATTERN = /^https:\/\/[^/]+\.(openai\.azure\.com|cognitiveservices\.azure\.com|api\.cognitive\.microsoft\.com)(:\d+)?(\/|$)/;
+/**
+* Azure OpenAI is first-party when requests resolve to an instance-name
+* endpoint or an *.openai.azure.com / *.cognitiveservices.azure.com /
+* regional *.api.cognitive.microsoft.com base path. A custom
+* `clientConfig.baseURL` or a non-Azure `azureOpenAIBasePath` routes through
+* a proxy or Azure-compatible endpoint whose stream contract is unknown, so
+* those are not stamped.
+*/
+function isFirstPartyAzureEndpoint(args) {
+	if (args.baseURL != null && args.baseURL !== "") return false;
+	if (args.azureOpenAIBasePath == null || args.azureOpenAIBasePath === "") return true;
+	return AZURE_FIRST_PARTY_BASE_PATH_PATTERN.test(args.azureOpenAIBasePath);
 }
+var LibreChatOpenAICompletions = class extends ChatOpenAICompletions {
+	includeReasoningContent;
+	includeReasoningDetails;
+	convertReasoningDetailsToContent;
+	constructor(fields) {
+		super(fields);
+		this.includeReasoningContent = fields?.includeReasoningContent;
+		this.includeReasoningDetails = fields?.includeReasoningDetails;
+		this.convertReasoningDetailsToContent = fields?.convertReasoningDetailsToContent;
+	}
+	_getReasoningParams(options) {
+		return getReasoningParams(this.reasoning, options);
+	}
+	_getClientOptions(options) {
+		return getCustomOpenAIClientOptions(this, options);
+	}
+	async completionWithRetry(request, requestOptions) {
+		return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
+	}
+	_convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
+		const message = attachLibreChatDeltaFields(super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole), delta);
+		if (isOfficialOpenAIBaseURL(this.clientConfig.baseURL)) return stampSequentialStreamedToolCallAdapter(message);
+		return message;
+	}
+	_convertCompletionsMessageToBaseMessage(message, rawResponse) {
+		return attachLibreChatMessageFields(super._convertCompletionsMessageToBaseMessage(message, rawResponse), message);
+	}
+	async _generate(messages, options, runManager) {
+		if (this.includeReasoningContent !== true && this.includeReasoningDetails !== true) return super._generate(messages, options, runManager);
+		options.signal?.throwIfAborted();
+		const usageMetadata = {};
+		const params = this.invocationParams(options);
+		const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
+			includeReasoningContent: this.includeReasoningContent,
+			includeReasoningDetails: this.includeReasoningDetails,
+			convertReasoningDetailsToContent: this.convertReasoningDetailsToContent
+		});
+		if (params.stream === true) {
+			const stream = this._streamResponseChunks(messages, options, runManager);
+			const finalChunks = /* @__PURE__ */ 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, 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
+				} }
+			};
+		}
+		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;
+		const promptTokensDetailsWithCacheWrite = promptTokensDetails;
+		if (promptTokensDetailsWithCacheWrite?.audio_tokens != null || promptTokensDetailsWithCacheWrite?.cached_tokens != null || promptTokensDetailsWithCacheWrite?.cache_write_tokens != null) usageMetadata.input_token_details = {
+			...promptTokensDetailsWithCacheWrite.audio_tokens != null && { audio: promptTokensDetailsWithCacheWrite.audio_tokens },
+			...promptTokensDetailsWithCacheWrite.cached_tokens != null && { cache_read: promptTokensDetailsWithCacheWrite.cached_tokens },
+			...promptTokensDetailsWithCacheWrite.cache_write_tokens != null && { cache_creation: promptTokensDetailsWithCacheWrite.cache_write_tokens }
+		};
+		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 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 (isAIMessage(generation.message)) generation.message.usage_metadata = usageMetadata;
+			generation.message = new AIMessage(Object.fromEntries(Object.entries(generation.message).filter(([key]) => !key.startsWith("lc_"))));
+			generations.push(generation);
+		}
+		return {
+			generations,
+			llmOutput: { tokenUsage: {
+				promptTokens: usageMetadata.input_tokens,
+				completionTokens: usageMetadata.output_tokens,
+				totalTokens: usageMetadata.total_tokens
+			} }
+		};
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		if (this.includeReasoningContent !== true && this.includeReasoningDetails !== true) {
+			yield* super._streamResponseChunks(messages, options, runManager);
+			return;
+		}
+		const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
+			includeReasoningContent: this.includeReasoningContent,
+			includeReasoningDetails: this.includeReasoningDetails,
+			convertReasoningDetailsToContent: this.convertReasoningDetailsToContent
+		});
+		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) {
+			if (options.signal?.aborted === true) return;
+			const choice = data.choices?.[0];
+			if (data.usage != null) usage = data.usage;
+			if (choice == null) continue;
+			const { delta } = choice;
+			if (delta == null) continue;
+			const chunk = this._convertCompletionsDeltaToBaseMessageChunk(delta, data, defaultRole);
+			defaultRole = delta.role ?? defaultRole;
+			const newTokenIndices = {
+				prompt: options.promptIndex ?? 0,
+				completion: choice.index
+			};
+			if (typeof chunk.content !== "string") {
+				console.log("[WARNING]: Received non-string content from OpenAI. This is currently not supported.");
+				continue;
+			}
+			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 ChatGenerationChunk({
+				message: chunk,
+				text: chunk.content,
+				generationInfo
+			});
+			yield generationChunk;
+			await runManager?.handleLLMNewToken(generationChunk.text, newTokenIndices, void 0, void 0, void 0, { chunk: generationChunk });
+		}
+		if (usage) {
+			const promptTokenDetails = usage.prompt_tokens_details;
+			const inputTokenDetails = {
+				...promptTokenDetails?.audio_tokens != null && { audio: promptTokenDetails.audio_tokens },
+				...promptTokenDetails?.cached_tokens != null && { cache_read: promptTokenDetails.cached_tokens },
+				...promptTokenDetails?.cache_write_tokens != null && { cache_creation: promptTokenDetails.cache_write_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 ChatGenerationChunk({
+				message: new 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;
+			await runManager?.handleLLMNewToken(generationChunk.text, {
+				prompt: 0,
+				completion: 0
+			}, void 0, void 0, void 0, { chunk: generationChunk });
+		}
+		if (options.signal?.aborted === true) throw new Error("AbortError");
+	}
+};
+var LibreChatOpenAIResponses = class extends ChatOpenAIResponses {
+	_getReasoningParams(options) {
+		return getReasoningParams(this.reasoning, options);
+	}
+	_getClientOptions(options) {
+		return getCustomOpenAIClientOptions(this, options);
+	}
+};
+var LibreChatAzureOpenAICompletions = class extends AzureChatOpenAICompletions {
+	_getReasoningParams(options) {
+		return getGatedReasoningParams(this.model, this.reasoning, options);
+	}
+	_convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
+		const message = super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole);
+		if (isFirstPartyAzureEndpoint({
+			baseURL: this.clientConfig.baseURL,
+			azureOpenAIBasePath: this.azureOpenAIBasePath
+		})) return stampSequentialStreamedToolCallAdapter(message);
+		return message;
+	}
+	_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 = getEndpoint(openAIEndpointConfig);
+			const params = {
+				...this.clientConfig,
+				baseURL: endpoint,
+				timeout: this.timeout,
+				maxRetries: 0
+			};
+			if (!this.azureADTokenProvider) params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+			if (params.baseURL == null) delete params.baseURL;
+			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 completionWithRetry(request, requestOptions) {
+		return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
+	}
+};
+var LibreChatAzureOpenAIResponses = class extends 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 = getEndpoint(openAIEndpointConfig);
+			const params = {
+				...this.clientConfig,
+				baseURL: endpoint,
+				timeout: this.timeout,
+				maxRetries: 0
+			};
+			if (!this.azureADTokenProvider) params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+			if (params.baseURL == null) delete params.baseURL;
+			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;
+	}
+};
 function withLibreChatOpenAIFields(fields) {
-    const nextFields = fields ?? {};
-    return {
-        ...nextFields,
-        completions: nextFields.completions ?? new LibreChatOpenAICompletions(nextFields),
-        responses: nextFields.responses ?? new LibreChatOpenAIResponses(nextFields),
-    };
-}
-class ChatOpenAI extends ChatOpenAI$1 {
-    _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,
-            };
-            const endpoint = 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;
-    }
-    /**
-     * 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, undefined), this._lc_stream_delay, options.signal, runManager);
-    }
-}
-class AzureChatOpenAI extends AzureChatOpenAI$1 {
-    _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 = getEndpoint(openAIEndpointConfig);
-            const params = {
-                ...this.clientConfig,
-                baseURL: endpoint,
-                timeout: this.timeout,
-                maxRetries: 0,
-            };
-            if (!this.azureADTokenProvider) {
-                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
-            }
-            if (params.baseURL == null) {
-                delete params.baseURL;
-            }
-            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, options, runManager) {
-        yield* delayStreamChunks(super._streamResponseChunks(messages, options, undefined), this._lc_stream_delay, options.signal, runManager);
-    }
-}
-class ChatDeepSeek extends ChatDeepSeek$1 {
-    _lc_stream_delay;
-    constructor(fields) {
-        super(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay;
-    }
-    get exposedClient() {
-        return this.client;
-    }
-    static lc_name() {
-        return 'LibreChatDeepSeek';
-    }
-    _convertDeepSeekMessages(messages) {
-        return _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
-    }
-    async _generate(messages, options, runManager) {
-        options.signal?.throwIfAborted();
-        const params = this.invocationParams(options);
-        if (params.stream === true) {
-            return super._generate(messages, options, runManager);
-        }
-        const messagesMapped = this._convertDeepSeekMessages(messages);
-        const response = await this.completionWithRetry({
-            ...params,
-            stream: false,
-            messages: messagesMapped,
-        }, {
-            signal: options.signal,
-            ...options.options,
-        });
-        const usageMetadata = createUsageMetadata(response.usage);
-        const generations = response.choices.map((part) => {
-            const text = part.message.content ?? '';
-            const generation = {
-                text,
-                message: this._convertCompletionsMessageToBaseMessage(part.message, response),
-            };
-            generation.generationInfo = {
-                finish_reason: part.finish_reason,
-                ...(part.logprobs != null ? { logprobs: part.logprobs } : {}),
-            };
-            if (isAIMessage(generation.message)) {
-                generation.message.usage_metadata = usageMetadata;
-            }
-            generation.message = new AIMessage(Object.fromEntries(Object.entries(generation.message).filter(([key]) => !key.startsWith('lc_'))));
-            return generation;
-        });
-        return {
-            generations,
-            llmOutput: {
-                tokenUsage: {
-                    promptTokens: usageMetadata.input_tokens,
-                    completionTokens: usageMetadata.output_tokens,
-                    totalTokens: usageMetadata.total_tokens,
-                },
-            },
-        };
-    }
-    _getClientOptions(options) {
-        if (!this.client) {
-            const openAIEndpointConfig = {
-                baseURL: this.clientConfig.baseURL,
-            };
-            const endpoint = 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;
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        yield* delayStreamChunks(this._streamResponseChunksWithReasoning(messages, options, undefined), this._lc_stream_delay, options.signal, runManager);
-    }
-    /** Parses raw `<think>` fallback tags across chunks and emits sanitized DeepSeek stream chunks. */
-    async *_streamResponseChunksWithReasoning(messages, options, runManager) {
-        const stream = this._streamResponseChunksFromReasoningMessages(messages, options);
-        const thinkStartTag = '<think>';
-        const thinkEndTag = '</think>';
-        let tokensBuffer = '';
-        let isThinking = false;
-        for await (const chunk of stream) {
-            if (options.signal?.aborted === true) {
-                throw new Error('AbortError');
-            }
-            const reasoningContent = chunk.message.additional_kwargs.reasoning_content;
-            if (reasoningContent != null && reasoningContent !== '') {
-                yield* this._yieldDeepSeekStreamChunk(chunk, runManager);
-                continue;
-            }
-            const text = chunk.text;
-            if (text === '') {
-                yield* this._yieldDeepSeekStreamChunk(chunk, runManager);
-                continue;
-            }
-            tokensBuffer += text;
-            while (tokensBuffer !== '') {
-                if (isThinking) {
-                    const thinkEndIndex = tokensBuffer.indexOf(thinkEndTag);
-                    if (thinkEndIndex !== -1) {
-                        const thoughtContent = tokensBuffer.substring(0, thinkEndIndex);
-                        if (thoughtContent !== '') {
-                            yield* this._yieldDeepSeekReasoningText(chunk, thoughtContent, runManager);
-                        }
-                        tokensBuffer = tokensBuffer.substring(thinkEndIndex + thinkEndTag.length);
-                        isThinking = false;
-                        continue;
-                    }
-                    const splitIndex = this._getDeepSeekPartialTagSplitIndex(tokensBuffer, thinkEndTag);
-                    if (splitIndex !== -1) {
-                        const safeToYield = tokensBuffer.substring(0, splitIndex);
-                        if (safeToYield !== '') {
-                            yield* this._yieldDeepSeekReasoningText(chunk, safeToYield, runManager);
-                        }
-                        tokensBuffer = tokensBuffer.substring(splitIndex);
-                        break;
-                    }
-                    yield* this._yieldDeepSeekReasoningText(chunk, tokensBuffer, runManager);
-                    tokensBuffer = '';
-                    break;
-                }
-                const thinkStartIndex = tokensBuffer.indexOf(thinkStartTag);
-                if (thinkStartIndex !== -1) {
-                    const beforeThink = tokensBuffer.substring(0, thinkStartIndex);
-                    if (beforeThink !== '') {
-                        yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekStreamChunk(chunk, beforeThink), runManager);
-                    }
-                    tokensBuffer = tokensBuffer.substring(thinkStartIndex + thinkStartTag.length);
-                    isThinking = true;
-                    continue;
-                }
-                const splitIndex = this._getDeepSeekPartialTagSplitIndex(tokensBuffer, thinkStartTag);
-                if (splitIndex !== -1) {
-                    const safeToYield = tokensBuffer.substring(0, splitIndex);
-                    if (safeToYield !== '') {
-                        yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekStreamChunk(chunk, safeToYield), runManager);
-                    }
-                    tokensBuffer = tokensBuffer.substring(splitIndex);
-                    break;
-                }
-                yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekStreamChunk(chunk, tokensBuffer), runManager);
-                tokensBuffer = '';
-                break;
-            }
-        }
-        if (tokensBuffer === '') {
-            return;
-        }
-        if (isThinking) {
-            yield* this._yieldDeepSeekStreamChunk(new ChatGenerationChunk({
-                message: new AIMessageChunk({
-                    content: '',
-                    additional_kwargs: {
-                        reasoning_content: tokensBuffer,
-                    },
-                }),
-                text: '',
-            }), runManager);
-            return;
-        }
-        yield* this._yieldDeepSeekStreamChunk(new ChatGenerationChunk({
-            message: new AIMessageChunk({
-                content: tokensBuffer,
-            }),
-            text: tokensBuffer,
-        }), runManager);
-    }
-    async *_streamResponseChunksFromReasoningMessages(messages, options) {
-        const params = {
-            ...this.invocationParams(options, { streaming: true }),
-            stream: true,
-        };
-        const messagesMapped = this._convertDeepSeekMessages(messages);
-        const streamIterable = await this.completionWithRetry({
-            ...params,
-            messages: messagesMapped,
-        }, {
-            signal: options.signal,
-            ...options.options,
-        });
-        let defaultRole;
-        let usage;
-        for await (const data of streamIterable) {
-            if (options.signal?.aborted === true) {
-                throw new Error('AbortError');
-            }
-            if (data.usage != null) {
-                usage = data.usage;
-            }
-            if (data.choices.length === 0) {
-                continue;
-            }
-            const choice = data.choices[0];
-            const { delta } = choice;
-            const messageChunk = this._convertCompletionsDeltaToBaseMessageChunk(delta, data, defaultRole);
-            defaultRole = delta.role ?? defaultRole;
-            if (typeof messageChunk.content !== 'string') {
-                continue;
-            }
-            const messageText = messageChunk.content;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index,
-            };
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                Object.assign(generationInfo, {
-                    finish_reason: choice.finish_reason,
-                    system_fingerprint: data.system_fingerprint,
-                    model_name: data.model,
-                    service_tier: data.service_tier,
-                });
-            }
-            if (this.logprobs === true) {
-                Object.assign(generationInfo, { logprobs: choice.logprobs });
-            }
-            const generationChunk = new ChatGenerationChunk({
-                message: messageChunk,
-                text: messageText,
-                generationInfo,
-            });
-            yield generationChunk;
-        }
-        if (usage != null) {
-            const usageMetadata = createUsageMetadata(usage);
-            const generationChunk = new ChatGenerationChunk({
-                message: new AIMessageChunk({
-                    content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                    },
-                    usage_metadata: usageMetadata,
-                }),
-                text: '',
-                generationInfo: {
-                    prompt: 0,
-                    completion: 0,
-                },
-            });
-            yield generationChunk;
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-    _createDeepSeekStreamChunk(chunk, content, additionalKwargs, text = content) {
-        if (!(chunk.message instanceof AIMessageChunk)) {
-            return new ChatGenerationChunk({
-                message: new AIMessageChunk({
-                    content,
-                    additional_kwargs: additionalKwargs ?? chunk.message.additional_kwargs,
-                    response_metadata: chunk.message.response_metadata,
-                    id: chunk.message.id,
-                }),
-                text,
-                generationInfo: chunk.generationInfo,
-            });
-        }
-        const message = chunk.message;
-        return new ChatGenerationChunk({
-            message: new AIMessageChunk({
-                content,
-                additional_kwargs: additionalKwargs ?? message.additional_kwargs,
-                response_metadata: message.response_metadata,
-                tool_calls: message.tool_calls,
-                tool_call_chunks: message.tool_call_chunks,
-                id: message.id,
-            }),
-            text,
-            generationInfo: chunk.generationInfo,
-        });
-    }
-    _createDeepSeekReasoningStreamChunk(chunk, reasoningContent) {
-        return this._createDeepSeekStreamChunk(chunk, '', {
-            ...chunk.message.additional_kwargs,
-            reasoning_content: reasoningContent,
-        }, '');
-    }
-    async *_yieldDeepSeekReasoningText(chunk, reasoningContent, runManager) {
-        yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekReasoningStreamChunk(chunk, reasoningContent), runManager);
-    }
-    async *_yieldDeepSeekStreamChunk(chunk, runManager) {
-        yield chunk;
-        await runManager?.handleLLMNewToken(chunk.text, this._getDeepSeekTokenIndices(chunk), undefined, undefined, undefined, { chunk });
-    }
-    _getDeepSeekTokenIndices(chunk) {
-        return getStreamChunkTokenIndices(chunk);
-    }
-    _getDeepSeekPartialTagSplitIndex(text, tag) {
-        for (let i = tag.length - 1; i >= 1; i--) {
-            if (text.endsWith(tag.substring(0, i))) {
-                return text.length - i;
-            }
-        }
-        return -1;
-    }
-}
-class ChatMoonshot extends ChatOpenAI {
-    constructor(fields) {
-        super({
-            ...fields,
-            includeReasoningContent: true,
-        });
-    }
-    static lc_name() {
-        return 'LibreChatMoonshot';
-    }
-}
-class ChatXAI extends ChatXAI$1 {
-    _lc_stream_delay;
-    constructor(fields) {
-        super(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay;
-        const customBaseURL = fields?.configuration?.baseURL ?? fields?.clientConfig?.baseURL;
-        if (customBaseURL != null && customBaseURL) {
-            this.clientConfig = {
-                ...this.clientConfig,
-                baseURL: customBaseURL,
-            };
-            // Reset the client to force recreation with new config
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.client = undefined;
-        }
-    }
-    static lc_name() {
-        return 'LibreChatXAI';
-    }
-    get exposedClient() {
-        return this.client;
-    }
-    _getClientOptions(options) {
-        if (!this.client) {
-            const openAIEndpointConfig = {
-                baseURL: this.clientConfig.baseURL,
-            };
-            const endpoint = 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;
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        yield* delayStreamChunks(super._streamResponseChunks(messages, options, undefined), this._lc_stream_delay, options.signal, runManager);
-    }
+	const nextFields = fields ?? {};
+	return {
+		...nextFields,
+		completions: nextFields.completions ?? new LibreChatOpenAICompletions(nextFields),
+		responses: nextFields.responses ?? new LibreChatOpenAIResponses(nextFields)
+	};
 }
+var ChatOpenAI$1 = class extends 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(void 0));
+	}
+	static lc_name() {
+		return "LibreChatOpenAI";
+	}
+	_getClientOptions(options) {
+		if (!this.client) {
+			const endpoint = getEndpoint({ baseURL: this.clientConfig.baseURL });
+			const params = {
+				...this.clientConfig,
+				baseURL: endpoint,
+				timeout: this.timeout,
+				maxRetries: 0
+			};
+			if (params.baseURL == null) delete params.baseURL;
+			this.client = new CustomOpenAIClient(params);
+		}
+		return {
+			...this.clientConfig,
+			...options
+		};
+	}
+	/**
+	* 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, void 0), this._lc_stream_delay, options.signal, runManager);
+	}
+};
+var AzureChatOpenAI$1 = class extends 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(void 0));
+	}
+	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 = getEndpoint(openAIEndpointConfig);
+			const params = {
+				...this.clientConfig,
+				baseURL: endpoint,
+				timeout: this.timeout,
+				maxRetries: 0
+			};
+			if (!this.azureADTokenProvider) params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+			if (params.baseURL == null) delete params.baseURL;
+			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, options, runManager) {
+		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+	}
+};
+var ChatDeepSeek$1 = class extends ChatDeepSeek {
+	_lc_stream_delay;
+	constructor(fields) {
+		super(fields);
+		this._lc_stream_delay = fields?._lc_stream_delay;
+	}
+	get exposedClient() {
+		return this.client;
+	}
+	static lc_name() {
+		return "LibreChatDeepSeek";
+	}
+	_convertDeepSeekMessages(messages) {
+		return _convertMessagesToOpenAIParams(messages, this.model, { includeReasoningContent: true });
+	}
+	async _generate(messages, options, runManager) {
+		options.signal?.throwIfAborted();
+		const params = this.invocationParams(options);
+		if (params.stream === true) return super._generate(messages, options, runManager);
+		const messagesMapped = this._convertDeepSeekMessages(messages);
+		const response = await this.completionWithRetry({
+			...params,
+			stream: false,
+			messages: messagesMapped
+		}, {
+			signal: options.signal,
+			...options.options
+		});
+		const usageMetadata = createUsageMetadata(response.usage);
+		return {
+			generations: response.choices.map((part) => {
+				const generation = {
+					text: part.message.content ?? "",
+					message: this._convertCompletionsMessageToBaseMessage(part.message, response)
+				};
+				generation.generationInfo = {
+					finish_reason: part.finish_reason,
+					...part.logprobs != null ? { logprobs: part.logprobs } : {}
+				};
+				if (isAIMessage(generation.message)) generation.message.usage_metadata = usageMetadata;
+				generation.message = new AIMessage(Object.fromEntries(Object.entries(generation.message).filter(([key]) => !key.startsWith("lc_"))));
+				return generation;
+			}),
+			llmOutput: { tokenUsage: {
+				promptTokens: usageMetadata.input_tokens,
+				completionTokens: usageMetadata.output_tokens,
+				totalTokens: usageMetadata.total_tokens
+			} }
+		};
+	}
+	_getClientOptions(options) {
+		if (!this.client) {
+			const endpoint = getEndpoint({ baseURL: this.clientConfig.baseURL });
+			const params = {
+				...this.clientConfig,
+				baseURL: endpoint,
+				timeout: this.timeout,
+				maxRetries: 0
+			};
+			if (params.baseURL == null) delete params.baseURL;
+			this.client = new CustomOpenAIClient(params);
+		}
+		return {
+			...this.clientConfig,
+			...options
+		};
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		yield* delayStreamChunks(this._streamResponseChunksWithReasoning(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+	}
+	/** Parses raw `<think>` fallback tags across chunks and emits sanitized DeepSeek stream chunks. */
+	async *_streamResponseChunksWithReasoning(messages, options, runManager) {
+		const stream = this._streamResponseChunksFromReasoningMessages(messages, options);
+		const thinkStartTag = "<think>";
+		const thinkEndTag = "</think>";
+		let tokensBuffer = "";
+		let isThinking = false;
+		for await (const chunk of stream) {
+			if (options.signal?.aborted === true) throw new Error("AbortError");
+			const reasoningContent = chunk.message.additional_kwargs.reasoning_content;
+			if (reasoningContent != null && reasoningContent !== "") {
+				yield* this._yieldDeepSeekStreamChunk(chunk, runManager);
+				continue;
+			}
+			const text = chunk.text;
+			if (text === "") {
+				yield* this._yieldDeepSeekStreamChunk(chunk, runManager);
+				continue;
+			}
+			tokensBuffer += text;
+			while (tokensBuffer !== "") {
+				if (isThinking) {
+					const thinkEndIndex = tokensBuffer.indexOf(thinkEndTag);
+					if (thinkEndIndex !== -1) {
+						const thoughtContent = tokensBuffer.substring(0, thinkEndIndex);
+						if (thoughtContent !== "") yield* this._yieldDeepSeekReasoningText(chunk, thoughtContent, runManager);
+						tokensBuffer = tokensBuffer.substring(thinkEndIndex + 8);
+						isThinking = false;
+						continue;
+					}
+					const splitIndex = this._getDeepSeekPartialTagSplitIndex(tokensBuffer, thinkEndTag);
+					if (splitIndex !== -1) {
+						const safeToYield = tokensBuffer.substring(0, splitIndex);
+						if (safeToYield !== "") yield* this._yieldDeepSeekReasoningText(chunk, safeToYield, runManager);
+						tokensBuffer = tokensBuffer.substring(splitIndex);
+						break;
+					}
+					yield* this._yieldDeepSeekReasoningText(chunk, tokensBuffer, runManager);
+					tokensBuffer = "";
+					break;
+				}
+				const thinkStartIndex = tokensBuffer.indexOf(thinkStartTag);
+				if (thinkStartIndex !== -1) {
+					const beforeThink = tokensBuffer.substring(0, thinkStartIndex);
+					if (beforeThink !== "") yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekStreamChunk(chunk, beforeThink), runManager);
+					tokensBuffer = tokensBuffer.substring(thinkStartIndex + 7);
+					isThinking = true;
+					continue;
+				}
+				const splitIndex = this._getDeepSeekPartialTagSplitIndex(tokensBuffer, thinkStartTag);
+				if (splitIndex !== -1) {
+					const safeToYield = tokensBuffer.substring(0, splitIndex);
+					if (safeToYield !== "") yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekStreamChunk(chunk, safeToYield), runManager);
+					tokensBuffer = tokensBuffer.substring(splitIndex);
+					break;
+				}
+				yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekStreamChunk(chunk, tokensBuffer), runManager);
+				tokensBuffer = "";
+				break;
+			}
+		}
+		if (tokensBuffer === "") return;
+		if (isThinking) {
+			yield* this._yieldDeepSeekStreamChunk(new ChatGenerationChunk({
+				message: new AIMessageChunk({
+					content: "",
+					additional_kwargs: { reasoning_content: tokensBuffer }
+				}),
+				text: ""
+			}), runManager);
+			return;
+		}
+		yield* this._yieldDeepSeekStreamChunk(new ChatGenerationChunk({
+			message: new AIMessageChunk({ content: tokensBuffer }),
+			text: tokensBuffer
+		}), runManager);
+	}
+	async *_streamResponseChunksFromReasoningMessages(messages, options) {
+		const params = {
+			...this.invocationParams(options, { streaming: true }),
+			stream: true
+		};
+		const messagesMapped = this._convertDeepSeekMessages(messages);
+		const streamIterable = await this.completionWithRetry({
+			...params,
+			messages: messagesMapped
+		}, {
+			signal: options.signal,
+			...options.options
+		});
+		let defaultRole;
+		let usage;
+		for await (const data of streamIterable) {
+			if (options.signal?.aborted === true) throw new Error("AbortError");
+			if (data.usage != null) usage = data.usage;
+			if (data.choices.length === 0) continue;
+			const choice = data.choices[0];
+			const { delta } = choice;
+			const messageChunk = this._convertCompletionsDeltaToBaseMessageChunk(delta, data, defaultRole);
+			defaultRole = delta.role ?? defaultRole;
+			if (typeof messageChunk.content !== "string") continue;
+			const messageText = messageChunk.content;
+			const generationInfo = {
+				prompt: options.promptIndex ?? 0,
+				completion: choice.index
+			};
+			if (choice.finish_reason != null) Object.assign(generationInfo, {
+				finish_reason: choice.finish_reason,
+				system_fingerprint: data.system_fingerprint,
+				model_name: data.model,
+				service_tier: data.service_tier
+			});
+			if (this.logprobs === true) Object.assign(generationInfo, { logprobs: choice.logprobs });
+			yield new ChatGenerationChunk({
+				message: messageChunk,
+				text: messageText,
+				generationInfo
+			});
+		}
+		if (usage != null) {
+			const usageMetadata = createUsageMetadata(usage);
+			yield new ChatGenerationChunk({
+				message: new AIMessageChunk({
+					content: "",
+					response_metadata: { usage: { ...usage } },
+					usage_metadata: usageMetadata
+				}),
+				text: "",
+				generationInfo: {
+					prompt: 0,
+					completion: 0
+				}
+			});
+		}
+		if (options.signal?.aborted === true) throw new Error("AbortError");
+	}
+	_createDeepSeekStreamChunk(chunk, content, additionalKwargs, text = content) {
+		if (!(chunk.message instanceof AIMessageChunk)) return new ChatGenerationChunk({
+			message: new AIMessageChunk({
+				content,
+				additional_kwargs: additionalKwargs ?? chunk.message.additional_kwargs,
+				response_metadata: chunk.message.response_metadata,
+				id: chunk.message.id
+			}),
+			text,
+			generationInfo: chunk.generationInfo
+		});
+		const message = chunk.message;
+		return new ChatGenerationChunk({
+			message: new AIMessageChunk({
+				content,
+				additional_kwargs: additionalKwargs ?? message.additional_kwargs,
+				response_metadata: message.response_metadata,
+				tool_calls: message.tool_calls,
+				tool_call_chunks: message.tool_call_chunks,
+				id: message.id
+			}),
+			text,
+			generationInfo: chunk.generationInfo
+		});
+	}
+	_createDeepSeekReasoningStreamChunk(chunk, reasoningContent) {
+		return this._createDeepSeekStreamChunk(chunk, "", {
+			...chunk.message.additional_kwargs,
+			reasoning_content: reasoningContent
+		}, "");
+	}
+	async *_yieldDeepSeekReasoningText(chunk, reasoningContent, runManager) {
+		yield* this._yieldDeepSeekStreamChunk(this._createDeepSeekReasoningStreamChunk(chunk, reasoningContent), runManager);
+	}
+	async *_yieldDeepSeekStreamChunk(chunk, runManager) {
+		yield chunk;
+		await runManager?.handleLLMNewToken(chunk.text, this._getDeepSeekTokenIndices(chunk), void 0, void 0, void 0, { chunk });
+	}
+	_getDeepSeekTokenIndices(chunk) {
+		return getStreamChunkTokenIndices(chunk);
+	}
+	_getDeepSeekPartialTagSplitIndex(text, tag) {
+		for (let i = tag.length - 1; i >= 1; i--) if (text.endsWith(tag.substring(0, i))) return text.length - i;
+		return -1;
+	}
+};
+var ChatMoonshot = class extends ChatOpenAI$1 {
+	constructor(fields) {
+		super({
+			...fields,
+			includeReasoningContent: true
+		});
+	}
+	static lc_name() {
+		return "LibreChatMoonshot";
+	}
+};
+var ChatXAI$1 = class extends ChatXAI {
+	_lc_stream_delay;
+	constructor(fields) {
+		super(fields);
+		this._lc_stream_delay = fields?._lc_stream_delay;
+		const customBaseURL = fields?.configuration?.baseURL ?? fields?.clientConfig?.baseURL;
+		if (customBaseURL != null && customBaseURL) {
+			this.clientConfig = {
+				...this.clientConfig,
+				baseURL: customBaseURL
+			};
+			this.client = void 0;
+		}
+	}
+	static lc_name() {
+		return "LibreChatXAI";
+	}
+	get exposedClient() {
+		return this.client;
+	}
+	_getClientOptions(options) {
+		if (!this.client) {
+			const endpoint = getEndpoint({ baseURL: this.clientConfig.baseURL });
+			const params = {
+				...this.clientConfig,
+				baseURL: endpoint,
+				timeout: this.timeout,
+				maxRetries: 0
+			};
+			if (params.baseURL == null) delete params.baseURL;
+			this.client = new CustomOpenAIClient(params);
+		}
+		return {
+			...this.clientConfig,
+			...options
+		};
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+	}
+};
+//#endregion
+export { AzureChatOpenAI$1 as AzureChatOpenAI, ChatDeepSeek$1 as ChatDeepSeek, ChatMoonshot, ChatOpenAI$1 as ChatOpenAI, ChatXAI$1 as ChatXAI, CustomOpenAIClient, _convertToOpenAITool, emitStreamChunkCallback };
 
-export { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI, CustomAzureOpenAIClient, CustomOpenAIClient, _convertToOpenAITool, emitStreamChunkCallback, isHeaders, normalizeHeaders };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map