@illuma-ai/agents 1.1.21 → 1.1.23

package/src/llm/openai/index.js

@@ -1,1033 +0,0 @@
-import { AzureOpenAI as AzureOpenAIClient } from 'openai';
-import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
-import { isLangChainTool } from '@langchain/core/utils/function_calling';
-import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
-import { getEndpoint, OpenAIClient, formatToOpenAITool, ChatOpenAI as OriginalChatOpenAI, AzureChatOpenAI as OriginalAzureChatOpenAI, } from '@langchain/openai';
-import { isReasoningModel, _convertMessagesToOpenAIParams, _convertMessagesToOpenAIResponsesParams, _convertOpenAIResponsesDeltaToBaseMessageChunk, } from './utils';
-import { sleep } from '@/utils';
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-const iife = (fn) => fn();
-export function isHeaders(headers) {
-    return (typeof Headers !== 'undefined' &&
-        headers !== null &&
-        typeof headers === 'object' &&
-        Object.prototype.toString.call(headers) === '[object Headers]');
-}
-export 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());
-}
-function createAbortHandler(controller) {
-    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.
- */
-export function _convertToOpenAITool(tool, fields) {
-    let toolDef;
-    if (isLangChainTool(tool)) {
-        toolDef = formatToOpenAITool(tool);
-    }
-    else {
-        toolDef = tool;
-    }
-    if (fields?.strict !== undefined) {
-        toolDef.function.strict = fields.strict;
-    }
-    return toolDef;
-}
-export 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);
-        }));
-    }
-}
-export class CustomAzureOpenAIClient extends AzureOpenAIClient {
-    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);
-        }));
-    }
-}
-/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
-export class ChatOpenAI extends OriginalChatOpenAI {
-    _lc_stream_delay;
-    constructor(fields) {
-        super(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay;
-    }
-    get exposedClient() {
-        return this.client;
-    }
-    static lc_name() {
-        return 'IllumaOpenAI';
-    }
-    _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) {
-        // apply options in reverse order of importance -- newer options supersede older options
-        let reasoning;
-        if (this.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...this.reasoning,
-            };
-        }
-        if (options?.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...options.reasoning,
-            };
-        }
-        return reasoning;
-    }
-    _getReasoningParams(options) {
-        return this.getReasoningParams(options);
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        if (!this._useResponseApi(options)) {
-            return yield* this._streamResponseChunks2(messages, options, runManager);
-        }
-        const streamIterable = await this.responseApiWithRetry({
-            ...this.invocationParams(options, { streaming: true }),
-            input: _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
-            stream: true,
-        }, options);
-        for await (const data of streamIterable) {
-            const chunk = _convertOpenAIResponsesDeltaToBaseMessageChunk(data);
-            if (chunk == null)
-                continue;
-            yield chunk;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
-        }
-        return;
-    }
-    async *_streamResponseChunks2(messages, options, runManager) {
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model);
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            else if ('reasoning' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning;
-            }
-            if ('provider_specific_fields' in delta) {
-                chunk.additional_kwargs.provider_specific_fields =
-                    delta.provider_specific_fields;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                // Only include system fingerprint in the last chunk for now
-                // to avoid concatenation issues
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            const inputTokenDetails = {
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-            };
-            const outputTokenDetails = {
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
-            };
-            const generationChunk = new 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;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-}
-/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
-export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
-    _lc_stream_delay;
-    constructor(fields) {
-        super(fields);
-        this._lc_stream_delay = fields?._lc_stream_delay;
-    }
-    get exposedClient() {
-        return this.client;
-    }
-    static lc_name() {
-        return 'IllumaAzureOpenAI';
-    }
-    /**
-     * Returns backwards compatible reasoning parameters from constructor params and call options
-     * @internal
-     */
-    getReasoningParams(options) {
-        if (!isReasoningModel(this.model)) {
-            return;
-        }
-        // apply options in reverse order of importance -- newer options supersede older options
-        let reasoning;
-        if (this.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...this.reasoning,
-            };
-        }
-        if (options?.reasoning !== undefined) {
-            reasoning = {
-                ...reasoning,
-                ...options.reasoning,
-            };
-        }
-        return reasoning;
-    }
-    _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']}: illuma-azure-openai-v2`
-                    : 'illuma-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) {
-        if (!this._useResponseApi(options)) {
-            return yield* super._streamResponseChunks(messages, options, runManager);
-        }
-        const streamIterable = await this.responseApiWithRetry({
-            ...this.invocationParams(options, { streaming: true }),
-            input: _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
-            stream: true,
-        }, options);
-        for await (const data of streamIterable) {
-            const chunk = _convertOpenAIResponsesDeltaToBaseMessageChunk(data);
-            if (chunk == null)
-                continue;
-            yield chunk;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
-        }
-        return;
-    }
-}
-export class ChatDeepSeek extends OriginalChatDeepSeek {
-    get exposedClient() {
-        return this.client;
-    }
-    static lc_name() {
-        return 'IllumaDeepSeek';
-    }
-    _convertMessages(messages) {
-        return _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
-    }
-    async _generate(messages, options, runManager) {
-        const params = this.invocationParams(options);
-        if (params.stream === true) {
-            return super._generate(messages, options ?? {}, runManager);
-        }
-        const messagesMapped = this._convertMessages(messages);
-        const data = await this.completionWithRetry({
-            ...params,
-            stream: false,
-            messages: messagesMapped,
-        }, {
-            signal: options?.signal,
-            ...options?.options,
-        });
-        const { completion_tokens, prompt_tokens, total_tokens } = data.usage ?? {};
-        const generations = [];
-        for (const part of data.choices ?? []) {
-            const text = part.message.content ?? '';
-            const generation = {
-                text: typeof text === 'string' ? text : '',
-                message: this._convertResponseToMessage(part, data),
-            };
-            generation.generationInfo = {
-                ...(part.finish_reason != null
-                    ? { finish_reason: part.finish_reason }
-                    : {}),
-                ...(part.logprobs ? { logprobs: part.logprobs } : {}),
-            };
-            generations.push(generation);
-        }
-        return {
-            generations,
-            llmOutput: {
-                tokenUsage: {
-                    completionTokens: completion_tokens,
-                    promptTokens: prompt_tokens,
-                    totalTokens: total_tokens,
-                },
-            },
-        };
-    }
-    _convertResponseToMessage(choice, data) {
-        const { message } = choice;
-        const rawToolCalls = message.tool_calls;
-        const toolCalls = rawToolCalls?.map((tc) => ({
-            id: tc.id,
-            name: tc.function.name,
-            args: JSON.parse(tc.function.arguments || '{}'),
-            type: 'tool_call',
-        }));
-        const additional_kwargs = {};
-        if (rawToolCalls) {
-            additional_kwargs.tool_calls = rawToolCalls;
-        }
-        if ('reasoning_content' in message &&
-            message.reasoning_content != null &&
-            message.reasoning_content !== '') {
-            additional_kwargs.reasoning_content = message.reasoning_content;
-        }
-        return new AIMessage({
-            content: message.content ?? '',
-            tool_calls: toolCalls,
-            additional_kwargs,
-            usage_metadata: data.usage
-                ? {
-                    input_tokens: data.usage.prompt_tokens,
-                    output_tokens: data.usage.completion_tokens,
-                    total_tokens: data.usage.total_tokens,
-                }
-                : undefined,
-            response_metadata: {
-                model_name: data.model,
-                system_fingerprint: data.system_fingerprint,
-                finish_reason: choice.finish_reason,
-            },
-        });
-    }
-    _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) {
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            const inputTokenDetails = {
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-            };
-            const 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;
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-}
-export class ChatMoonshot extends ChatOpenAI {
-    static lc_name() {
-        return 'LibreChatMoonshot';
-    }
-    _convertMessages(messages) {
-        return _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
-    }
-    async _generate(messages, options, runManager) {
-        const params = this.invocationParams(options);
-        if (params.stream === true) {
-            return super._generate(messages, options, runManager);
-        }
-        const messagesMapped = this._convertMessages(messages);
-        const data = await this.completionWithRetry({
-            ...params,
-            stream: false,
-            messages: messagesMapped,
-        }, {
-            signal: options.signal,
-            ...options.options,
-        });
-        const { completion_tokens, prompt_tokens, total_tokens } = data.usage ?? {};
-        const generations = [];
-        for (const part of data.choices ?? []) {
-            const text = part.message.content ?? '';
-            const generation = {
-                text: typeof text === 'string' ? text : '',
-                message: this._convertResponseToMessage(part, data),
-            };
-            generation.generationInfo = {
-                ...(part.finish_reason ? { finish_reason: part.finish_reason } : {}),
-                ...(part.logprobs ? { logprobs: part.logprobs } : {}),
-            };
-            generations.push(generation);
-        }
-        return {
-            generations,
-            llmOutput: {
-                tokenUsage: {
-                    completionTokens: completion_tokens,
-                    promptTokens: prompt_tokens,
-                    totalTokens: total_tokens,
-                },
-            },
-        };
-    }
-    _convertResponseToMessage(choice, data) {
-        const { message } = choice;
-        const rawToolCalls = message.tool_calls;
-        const toolCalls = rawToolCalls?.map((tc) => ({
-            id: tc.id,
-            name: tc.function.name,
-            args: JSON.parse(tc.function.arguments || '{}'),
-            type: 'tool_call',
-        }));
-        const additional_kwargs = {};
-        if (rawToolCalls) {
-            additional_kwargs.tool_calls = rawToolCalls;
-        }
-        if ('reasoning_content' in message &&
-            message.reasoning_content != null &&
-            message.reasoning_content !== '') {
-            additional_kwargs.reasoning_content = message.reasoning_content;
-        }
-        return new AIMessage({
-            content: message.content ?? '',
-            tool_calls: toolCalls,
-            additional_kwargs,
-            usage_metadata: data.usage
-                ? {
-                    input_tokens: data.usage.prompt_tokens,
-                    output_tokens: data.usage.completion_tokens,
-                    total_tokens: data.usage.total_tokens,
-                }
-                : undefined,
-            response_metadata: {
-                model_name: data.model,
-                system_fingerprint: data.system_fingerprint,
-                finish_reason: choice.finish_reason,
-            },
-        });
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model, {
-            includeReasoningContent: true,
-        });
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            const inputTokenDetails = {
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-            };
-            const outputTokenDetails = {
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
-            };
-            const generationChunk = new 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;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-}
-export class ChatXAI extends OriginalChatXAI {
-    _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 'IllumaXAI';
-    }
-    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) {
-        const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model);
-        const params = {
-            ...this.invocationParams(options, {
-                streaming: true,
-            }),
-            messages: messagesMapped,
-            stream: true,
-        };
-        let defaultRole;
-        const streamIterable = await this.completionWithRetry(params, options);
-        let usage;
-        for await (const data of streamIterable) {
-            const choice = data.choices[0];
-            if (data.usage) {
-                usage = data.usage;
-            }
-            if (!choice) {
-                continue;
-            }
-            const { delta } = choice;
-            if (!delta) {
-                continue;
-            }
-            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
-            if (chunk.usage_metadata != null) {
-                chunk.usage_metadata = {
-                    input_tokens: chunk.usage_metadata.input_tokens ?? 0,
-                    output_tokens: chunk.usage_metadata.output_tokens ?? 0,
-                    total_tokens: chunk.usage_metadata.total_tokens ?? 0,
-                };
-            }
-            if ('reasoning_content' in delta) {
-                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
-            }
-            defaultRole = delta.role ?? defaultRole;
-            const newTokenIndices = {
-                prompt: options.promptIndex ?? 0,
-                completion: choice.index ?? 0,
-            };
-            if (typeof chunk.content !== 'string') {
-                // eslint-disable-next-line no-console
-                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
-                continue;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const generationInfo = { ...newTokenIndices };
-            if (choice.finish_reason != null) {
-                generationInfo.finish_reason = choice.finish_reason;
-                // Only include system fingerprint in the last chunk for now
-                // to avoid concatenation issues
-                generationInfo.system_fingerprint = data.system_fingerprint;
-                generationInfo.model_name = data.model;
-                generationInfo.service_tier = data.service_tier;
-            }
-            if (this.logprobs == true) {
-                generationInfo.logprobs = choice.logprobs;
-            }
-            const generationChunk = new ChatGenerationChunk({
-                message: chunk,
-                text: chunk.content,
-                generationInfo,
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
-        }
-        if (usage) {
-            // Type assertion for xAI-specific usage structure
-            const xaiUsage = usage;
-            const inputTokenDetails = {
-                // Standard OpenAI fields
-                ...(usage.prompt_tokens_details?.audio_tokens != null && {
-                    audio: usage.prompt_tokens_details.audio_tokens,
-                }),
-                ...(usage.prompt_tokens_details?.cached_tokens != null && {
-                    cache_read: usage.prompt_tokens_details.cached_tokens,
-                }),
-                // Add xAI-specific prompt token details if they exist
-                ...(xaiUsage.prompt_tokens_details?.text_tokens != null && {
-                    text: xaiUsage.prompt_tokens_details.text_tokens,
-                }),
-                ...(xaiUsage.prompt_tokens_details?.image_tokens != null && {
-                    image: xaiUsage.prompt_tokens_details.image_tokens,
-                }),
-            };
-            const outputTokenDetails = {
-                // Standard OpenAI fields
-                ...(usage.completion_tokens_details?.audio_tokens != null && {
-                    audio: usage.completion_tokens_details.audio_tokens,
-                }),
-                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
-                    reasoning: usage.completion_tokens_details.reasoning_tokens,
-                }),
-                // Add xAI-specific completion token details if they exist
-                ...(xaiUsage.completion_tokens_details?.accepted_prediction_tokens !=
-                    null && {
-                    accepted_prediction: xaiUsage.completion_tokens_details.accepted_prediction_tokens,
-                }),
-                ...(xaiUsage.completion_tokens_details?.rejected_prediction_tokens !=
-                    null && {
-                    rejected_prediction: xaiUsage.completion_tokens_details.rejected_prediction_tokens,
-                }),
-            };
-            const generationChunk = new ChatGenerationChunk({
-                message: new AIMessageChunk({
-                    content: '',
-                    response_metadata: {
-                        usage: { ...usage },
-                        // Include xAI-specific metadata if it exists
-                        ...(xaiUsage.num_sources_used != null && {
-                            num_sources_used: xaiUsage.num_sources_used,
-                        }),
-                    },
-                    usage_metadata: {
-                        input_tokens: usage.prompt_tokens,
-                        output_tokens: usage.completion_tokens,
-                        total_tokens: usage.total_tokens,
-                        ...(Object.keys(inputTokenDetails).length > 0 && {
-                            input_token_details: inputTokenDetails,
-                        }),
-                        ...(Object.keys(outputTokenDetails).length > 0 && {
-                            output_token_details: outputTokenDetails,
-                        }),
-                    },
-                }),
-                text: '',
-            });
-            yield generationChunk;
-            if (this._lc_stream_delay != null) {
-                await sleep(this._lc_stream_delay);
-            }
-        }
-        if (options.signal?.aborted === true) {
-            throw new Error('AbortError');
-        }
-    }
-}
-//# sourceMappingURL=index.js.map