@librechat/agents 2.4.322 → 3.0.0-rc1

package/dist/cjs/llm/ollama/utils.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+var messages = require('@langchain/core/messages');
+var uuid = require('uuid');
+
+function convertOllamaMessagesToLangChain(messages$1, extra) {
+    const additional_kwargs = {};
+    if ('thinking' in messages$1) {
+        additional_kwargs.reasoning_content = messages$1.thinking;
+    }
+    return new messages.AIMessageChunk({
+        content: messages$1.content || '',
+        tool_call_chunks: messages$1.tool_calls?.map((tc) => ({
+            name: tc.function.name,
+            args: JSON.stringify(tc.function.arguments),
+            type: 'tool_call_chunk',
+            index: 0,
+            id: uuid.v4(),
+        })),
+        response_metadata: extra?.responseMetadata,
+        usage_metadata: extra?.usageMetadata,
+        additional_kwargs,
+    });
+}
+function extractBase64FromDataUrl(dataUrl) {
+    const match = dataUrl.match(/^data:.*?;base64,(.*)$/);
+    return match ? match[1] : '';
+}
+function convertAMessagesToOllama(messages) {
+    if (typeof messages.content === 'string') {
+        return [
+            {
+                role: 'assistant',
+                content: messages.content,
+            },
+        ];
+    }
+    const textFields = messages.content.filter((c) => c.type === 'text' && typeof c.text === 'string');
+    const textMessages = textFields.map((c) => ({
+        role: 'assistant',
+        content: c.text,
+    }));
+    let toolCallMsgs;
+    if (messages.content.find((c) => c.type === 'tool_use') &&
+        messages.tool_calls?.length) {
+        // `tool_use` content types are accepted if the message has tool calls
+        const toolCalls = messages.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: {
+                name: tc.name,
+                arguments: tc.args,
+            },
+        }));
+        if (toolCalls) {
+            toolCallMsgs = {
+                role: 'assistant',
+                tool_calls: toolCalls,
+                content: '',
+            };
+        }
+    }
+    else if (messages.content.find((c) => c.type === 'tool_use') &&
+        !messages.tool_calls?.length) {
+        throw new Error('\'tool_use\' content type is not supported without tool calls.');
+    }
+    return [...textMessages, ...(toolCallMsgs ? [toolCallMsgs] : [])];
+}
+function convertHumanGenericMessagesToOllama(message) {
+    if (typeof message.content === 'string') {
+        return [
+            {
+                role: 'user',
+                content: message.content,
+            },
+        ];
+    }
+    return message.content.map((c) => {
+        if (c.type === 'text') {
+            return {
+                role: 'user',
+                content: c.text,
+            };
+        }
+        else if (c.type === 'image_url') {
+            if (typeof c.image_url === 'string') {
+                return {
+                    role: 'user',
+                    content: '',
+                    images: [extractBase64FromDataUrl(c.image_url)],
+                };
+            }
+            else if (c.image_url.url && typeof c.image_url.url === 'string') {
+                return {
+                    role: 'user',
+                    content: '',
+                    images: [extractBase64FromDataUrl(c.image_url.url)],
+                };
+            }
+        }
+        throw new Error(`Unsupported content type: ${c.type}`);
+    });
+}
+function convertSystemMessageToOllama(message) {
+    if (typeof message.content === 'string') {
+        return [
+            {
+                role: 'system',
+                content: message.content,
+            },
+        ];
+    }
+    else if (message.content.every((c) => c.type === 'text' && typeof c.text === 'string')) {
+        return message.content.map((c) => ({
+            role: 'system',
+            content: c.text,
+        }));
+    }
+    else {
+        throw new Error(`Unsupported content type(s): ${message.content
+            .map((c) => c.type)
+            .join(', ')}`);
+    }
+}
+function convertToolMessageToOllama(message) {
+    if (typeof message.content !== 'string') {
+        throw new Error('Non string tool message content is not supported');
+    }
+    return [
+        {
+            role: 'tool',
+            content: message.content,
+        },
+    ];
+}
+function convertToOllamaMessages(messages) {
+    return messages.flatMap((msg) => {
+        if (['human', 'generic'].includes(msg._getType())) {
+            return convertHumanGenericMessagesToOllama(msg);
+        }
+        else if (msg._getType() === 'ai') {
+            return convertAMessagesToOllama(msg);
+        }
+        else if (msg._getType() === 'system') {
+            return convertSystemMessageToOllama(msg);
+        }
+        else if (msg._getType() === 'tool') {
+            return convertToolMessageToOllama(msg);
+        }
+        else {
+            throw new Error(`Unsupported message type: ${msg._getType()}`);
+        }
+    });
+}
+
+exports.convertOllamaMessagesToLangChain = convertOllamaMessagesToLangChain;
+exports.convertToOllamaMessages = convertToOllamaMessages;
+//# sourceMappingURL=utils.cjs.map

package/dist/cjs/llm/ollama/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":["../../../../src/llm/ollama/utils.ts"],"sourcesContent":["import {\n  AIMessage,\n  AIMessageChunk,\n  BaseMessage,\n  HumanMessage,\n  MessageContentText,\n  SystemMessage,\n  ToolMessage,\n  UsageMetadata,\n} from '@langchain/core/messages';\nimport type {\n  Message as OllamaMessage,\n  ToolCall as OllamaToolCall,\n} from 'ollama';\nimport { v4 as uuidv4 } from 'uuid';\n\nexport function convertOllamaMessagesToLangChain(\n  messages: OllamaMessage,\n  extra?: {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    responseMetadata?: Record<string, any>;\n    usageMetadata?: UsageMetadata;\n  }\n): AIMessageChunk {\n  const additional_kwargs: BaseMessage['additional_kwargs'] = {};\n  if ('thinking' in messages) {\n    additional_kwargs.reasoning_content = messages.thinking as string;\n  }\n  return new AIMessageChunk({\n    content: messages.content || '',\n    tool_call_chunks: messages.tool_calls?.map((tc) => ({\n      name: tc.function.name,\n      args: JSON.stringify(tc.function.arguments),\n      type: 'tool_call_chunk',\n      index: 0,\n      id: uuidv4(),\n    })),\n    response_metadata: extra?.responseMetadata,\n    usage_metadata: extra?.usageMetadata,\n    additional_kwargs,\n  });\n}\n\nfunction extractBase64FromDataUrl(dataUrl: string): string {\n  const match = dataUrl.match(/^data:.*?;base64,(.*)$/);\n  return match ? match[1] : '';\n}\n\nfunction convertAMessagesToOllama(messages: AIMessage): OllamaMessage[] {\n  if (typeof messages.content === 'string') {\n    return [\n      {\n        role: 'assistant',\n        content: messages.content,\n      },\n    ];\n  }\n\n  const textFields = messages.content.filter(\n    (c) => c.type === 'text' && typeof c.text === 'string'\n  );\n  const textMessages = (textFields as MessageContentText[]).map((c) => ({\n    role: 'assistant',\n    content: c.text,\n  }));\n  let toolCallMsgs: OllamaMessage | undefined;\n\n  if (\n    messages.content.find((c) => c.type === 'tool_use') &&\n    messages.tool_calls?.length\n  ) {\n    // `tool_use` content types are accepted if the message has tool calls\n    const toolCalls: OllamaToolCall[] | undefined = messages.tool_calls.map(\n      (tc) => ({\n        id: tc.id,\n        type: 'function',\n        function: {\n          name: tc.name,\n          arguments: tc.args,\n        },\n      })\n    );\n\n    if (toolCalls) {\n      toolCallMsgs = {\n        role: 'assistant',\n        tool_calls: toolCalls,\n        content: '',\n      };\n    }\n  } else if (\n    messages.content.find((c) => c.type === 'tool_use') &&\n    !messages.tool_calls?.length\n  ) {\n    throw new Error(\n      '\\'tool_use\\' content type is not supported without tool calls.'\n    );\n  }\n\n  return [...textMessages, ...(toolCallMsgs ? [toolCallMsgs] : [])];\n}\n\nfunction convertHumanGenericMessagesToOllama(\n  message: HumanMessage\n): OllamaMessage[] {\n  if (typeof message.content === 'string') {\n    return [\n      {\n        role: 'user',\n        content: message.content,\n      },\n    ];\n  }\n  return message.content.map((c) => {\n    if (c.type === 'text') {\n      return {\n        role: 'user',\n        content: c.text,\n      };\n    } else if (c.type === 'image_url') {\n      if (typeof c.image_url === 'string') {\n        return {\n          role: 'user',\n          content: '',\n          images: [extractBase64FromDataUrl(c.image_url)],\n        };\n      } else if (c.image_url.url && typeof c.image_url.url === 'string') {\n        return {\n          role: 'user',\n          content: '',\n          images: [extractBase64FromDataUrl(c.image_url.url)],\n        };\n      }\n    }\n    throw new Error(`Unsupported content type: ${c.type}`);\n  });\n}\n\nfunction convertSystemMessageToOllama(message: SystemMessage): OllamaMessage[] {\n  if (typeof message.content === 'string') {\n    return [\n      {\n        role: 'system',\n        content: message.content,\n      },\n    ];\n  } else if (\n    message.content.every(\n      (c) => c.type === 'text' && typeof c.text === 'string'\n    )\n  ) {\n    return (message.content as MessageContentText[]).map((c) => ({\n      role: 'system',\n      content: c.text,\n    }));\n  } else {\n    throw new Error(\n      `Unsupported content type(s): ${message.content\n        .map((c) => c.type)\n        .join(', ')}`\n    );\n  }\n}\n\nfunction convertToolMessageToOllama(message: ToolMessage): OllamaMessage[] {\n  if (typeof message.content !== 'string') {\n    throw new Error('Non string tool message content is not supported');\n  }\n  return [\n    {\n      role: 'tool',\n      content: message.content,\n    },\n  ];\n}\n\nexport function convertToOllamaMessages(\n  messages: BaseMessage[]\n): OllamaMessage[] {\n  return messages.flatMap((msg) => {\n    if (['human', 'generic'].includes(msg._getType())) {\n      return convertHumanGenericMessagesToOllama(msg);\n    } else if (msg._getType() === 'ai') {\n      return convertAMessagesToOllama(msg);\n    } else if (msg._getType() === 'system') {\n      return convertSystemMessageToOllama(msg);\n    } else if (msg._getType() === 'tool') {\n      return convertToolMessageToOllama(msg as ToolMessage);\n    } else {\n      throw new Error(`Unsupported message type: ${msg._getType()}`);\n    }\n  });\n}\n"],"names":["messages","AIMessageChunk","uuidv4"],"mappings":"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"}

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

@@ -1,10 +1,50 @@
 'use strict';
 
 var openai$1 = require('openai');
+var messages = require('@langchain/core/messages');
 var xai = require('@langchain/xai');
+var outputs = require('@langchain/core/outputs');
+require('@langchain/core/utils/function_calling');
 var deepseek = require('@langchain/deepseek');
 var openai = require('@langchain/openai');
+var index = require('./utils/index.cjs');
 
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const iife = (fn) => fn();
+function isHeaders(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());
+}
 function createAbortHandler(controller) {
     return function () {
         controller.abort();
@@ -64,6 +104,7 @@ class CustomAzureOpenAIClient extends openai$1.AzureOpenAI {
         }));
     }
 }
+/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
 class ChatOpenAI extends openai.ChatOpenAI {
     get exposedClient() {
         return this.client;
@@ -91,11 +132,189 @@ class ChatOpenAI extends openai.ChatOpenAI {
         };
         return requestOptions;
     }
+    /**
+     * Returns backwards compatible reasoning parameters from constructor params and call options
+     * @internal
+     */
+    getReasoningParams(options) {
+        if (!index.isReasoningModel(this.model)) {
+            return;
+        }
+        // apply options in reverse order of importance -- newer options supersede older options
+        let reasoning;
+        if (this.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...this.reasoning,
+            };
+        }
+        if (options?.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...options.reasoning,
+            };
+        }
+        return reasoning;
+    }
+    _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: index._convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
+            stream: true,
+        }, options);
+        for await (const data of streamIterable) {
+            const chunk = index._convertOpenAIResponsesDeltaToBaseMessageChunk(data);
+            if (chunk == null)
+                continue;
+            yield chunk;
+            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
+        }
+        return;
+    }
+    async *_streamResponseChunks2(messages$1, options, runManager) {
+        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model);
+        const params = {
+            ...this.invocationParams(options, {
+                streaming: true,
+            }),
+            messages: messagesMapped,
+            stream: true,
+        };
+        let defaultRole;
+        const streamIterable = await this.completionWithRetry(params, options);
+        let usage;
+        for await (const data of streamIterable) {
+            const choice = data.choices[0];
+            if (data.usage) {
+                usage = data.usage;
+            }
+            if (!choice) {
+                continue;
+            }
+            const { delta } = choice;
+            if (!delta) {
+                continue;
+            }
+            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
+            if ('reasoning_content' in delta) {
+                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+            }
+            else if ('reasoning' in delta) {
+                chunk.additional_kwargs.reasoning_content = delta.reasoning;
+            }
+            defaultRole = delta.role ?? defaultRole;
+            const newTokenIndices = {
+                prompt: options.promptIndex ?? 0,
+                completion: choice.index ?? 0,
+            };
+            if (typeof chunk.content !== 'string') {
+                // eslint-disable-next-line no-console
+                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
+                continue;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const generationInfo = { ...newTokenIndices };
+            if (choice.finish_reason != null) {
+                generationInfo.finish_reason = choice.finish_reason;
+                // Only include system fingerprint in the last chunk for now
+                // to avoid concatenation issues
+                generationInfo.system_fingerprint = data.system_fingerprint;
+                generationInfo.model_name = data.model;
+                generationInfo.service_tier = data.service_tier;
+            }
+            if (this.logprobs == true) {
+                generationInfo.logprobs = choice.logprobs;
+            }
+            const generationChunk = new outputs.ChatGenerationChunk({
+                message: chunk,
+                text: chunk.content,
+                generationInfo,
+            });
+            yield generationChunk;
+            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
+        }
+        if (usage) {
+            const inputTokenDetails = {
+                ...(usage.prompt_tokens_details?.audio_tokens != null && {
+                    audio: usage.prompt_tokens_details.audio_tokens,
+                }),
+                ...(usage.prompt_tokens_details?.cached_tokens != null && {
+                    cache_read: usage.prompt_tokens_details.cached_tokens,
+                }),
+            };
+            const outputTokenDetails = {
+                ...(usage.completion_tokens_details?.audio_tokens != null && {
+                    audio: usage.completion_tokens_details.audio_tokens,
+                }),
+                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+                    reasoning: usage.completion_tokens_details.reasoning_tokens,
+                }),
+            };
+            const generationChunk = new outputs.ChatGenerationChunk({
+                message: new messages.AIMessageChunk({
+                    content: '',
+                    response_metadata: {
+                        usage: { ...usage },
+                    },
+                    usage_metadata: {
+                        input_tokens: usage.prompt_tokens,
+                        output_tokens: usage.completion_tokens,
+                        total_tokens: usage.total_tokens,
+                        ...(Object.keys(inputTokenDetails).length > 0 && {
+                            input_token_details: inputTokenDetails,
+                        }),
+                        ...(Object.keys(outputTokenDetails).length > 0 && {
+                            output_token_details: outputTokenDetails,
+                        }),
+                    },
+                }),
+                text: '',
+            });
+            yield generationChunk;
+        }
+        if (options.signal?.aborted === true) {
+            throw new Error('AbortError');
+        }
+    }
 }
+/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
 class AzureChatOpenAI extends openai.AzureChatOpenAI {
     get exposedClient() {
         return this.client;
     }
+    /**
+     * Returns backwards compatible reasoning parameters from constructor params and call options
+     * @internal
+     */
+    getReasoningParams(options) {
+        if (!index.isReasoningModel(this.model)) {
+            return;
+        }
+        // apply options in reverse order of importance -- newer options supersede older options
+        let reasoning;
+        if (this.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...this.reasoning,
+            };
+        }
+        if (options?.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...options.reasoning,
+            };
+        }
+        return reasoning;
+    }
+    _getReasoningParams(options) {
+        return this.getReasoningParams(options);
+    }
     _getClientOptions(options) {
         if (!this.client) {
             const openAIEndpointConfig = {
@@ -119,11 +338,12 @@ class AzureChatOpenAI extends openai.AzureChatOpenAI {
             if (params.baseURL == null) {
                 delete params.baseURL;
             }
+            const defaultHeaders = normalizeHeaders(params.defaultHeaders);
             params.defaultHeaders = {
                 ...params.defaultHeaders,
-                'User-Agent': params.defaultHeaders?.['User-Agent'] != null
-                    ? `${params.defaultHeaders['User-Agent']}: langchainjs-azure-openai-v2`
-                    : 'langchainjs-azure-openai-v2',
+                'User-Agent': defaultHeaders['User-Agent'] != null
+                    ? `${defaultHeaders['User-Agent']}: librechat-azure-openai-v2`
+                    : 'librechat-azure-openai-v2',
             };
             this.client = new CustomAzureOpenAIClient({
                 apiVersion: this.azureOpenAIApiVersion,
@@ -147,6 +367,24 @@ class AzureChatOpenAI extends openai.AzureChatOpenAI {
         }
         return requestOptions;
     }
+    async *_streamResponseChunks(messages, options, runManager) {
+        if (!this._useResponseApi(options)) {
+            return yield* super._streamResponseChunks(messages, options, runManager);
+        }
+        const streamIterable = await this.responseApiWithRetry({
+            ...this.invocationParams(options, { streaming: true }),
+            input: index._convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
+            stream: true,
+        }, options);
+        for await (const data of streamIterable) {
+            const chunk = index._convertOpenAIResponsesDeltaToBaseMessageChunk(data);
+            if (chunk == null)
+                continue;
+            yield chunk;
+            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
+        }
+        return;
+    }
 }
 class ChatDeepSeek extends deepseek.ChatDeepSeek {
     get exposedClient() {
@@ -177,6 +415,19 @@ class ChatDeepSeek extends deepseek.ChatDeepSeek {
     }
 }
 class ChatXAI extends xai.ChatXAI {
+    constructor(fields) {
+        super(fields);
+        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;
+        }
+    }
     get exposedClient() {
         return this.client;
     }
@@ -203,6 +454,139 @@ class ChatXAI extends xai.ChatXAI {
         };
         return requestOptions;
     }
+    async *_streamResponseChunks(messages$1, options, runManager) {
+        const messagesMapped = index._convertMessagesToOpenAIParams(messages$1, this.model);
+        const params = {
+            ...this.invocationParams(options, {
+                streaming: true,
+            }),
+            messages: messagesMapped,
+            stream: true,
+        };
+        let defaultRole;
+        const streamIterable = await this.completionWithRetry(params, options);
+        let usage;
+        for await (const data of streamIterable) {
+            const choice = data.choices[0];
+            if (data.usage) {
+                usage = data.usage;
+            }
+            if (!choice) {
+                continue;
+            }
+            const { delta } = choice;
+            if (!delta) {
+                continue;
+            }
+            const chunk = this._convertOpenAIDeltaToBaseMessageChunk(delta, data, defaultRole);
+            if (chunk.usage_metadata != null) {
+                chunk.usage_metadata = {
+                    input_tokens: chunk.usage_metadata.input_tokens ?? 0,
+                    output_tokens: chunk.usage_metadata.output_tokens ?? 0,
+                    total_tokens: chunk.usage_metadata.total_tokens ?? 0,
+                };
+            }
+            if ('reasoning_content' in delta) {
+                chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+            }
+            defaultRole = delta.role ?? defaultRole;
+            const newTokenIndices = {
+                prompt: options.promptIndex ?? 0,
+                completion: choice.index ?? 0,
+            };
+            if (typeof chunk.content !== 'string') {
+                // eslint-disable-next-line no-console
+                console.log('[WARNING]: Received non-string content from OpenAI. This is currently not supported.');
+                continue;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const generationInfo = { ...newTokenIndices };
+            if (choice.finish_reason != null) {
+                generationInfo.finish_reason = choice.finish_reason;
+                // Only include system fingerprint in the last chunk for now
+                // to avoid concatenation issues
+                generationInfo.system_fingerprint = data.system_fingerprint;
+                generationInfo.model_name = data.model;
+                generationInfo.service_tier = data.service_tier;
+            }
+            if (this.logprobs == true) {
+                generationInfo.logprobs = choice.logprobs;
+            }
+            const generationChunk = new outputs.ChatGenerationChunk({
+                message: chunk,
+                text: chunk.content,
+                generationInfo,
+            });
+            yield generationChunk;
+            await runManager?.handleLLMNewToken(generationChunk.text || '', newTokenIndices, undefined, undefined, undefined, { chunk: generationChunk });
+        }
+        if (usage) {
+            // Type assertion for xAI-specific usage structure
+            const xaiUsage = usage;
+            const inputTokenDetails = {
+                // Standard OpenAI fields
+                ...(usage.prompt_tokens_details?.audio_tokens != null && {
+                    audio: usage.prompt_tokens_details.audio_tokens,
+                }),
+                ...(usage.prompt_tokens_details?.cached_tokens != null && {
+                    cache_read: usage.prompt_tokens_details.cached_tokens,
+                }),
+                // Add xAI-specific prompt token details if they exist
+                ...(xaiUsage.prompt_tokens_details?.text_tokens != null && {
+                    text: xaiUsage.prompt_tokens_details.text_tokens,
+                }),
+                ...(xaiUsage.prompt_tokens_details?.image_tokens != null && {
+                    image: xaiUsage.prompt_tokens_details.image_tokens,
+                }),
+            };
+            const outputTokenDetails = {
+                // Standard OpenAI fields
+                ...(usage.completion_tokens_details?.audio_tokens != null && {
+                    audio: usage.completion_tokens_details.audio_tokens,
+                }),
+                ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+                    reasoning: usage.completion_tokens_details.reasoning_tokens,
+                }),
+                // Add xAI-specific completion token details if they exist
+                ...(xaiUsage.completion_tokens_details?.accepted_prediction_tokens !=
+                    null && {
+                    accepted_prediction: xaiUsage.completion_tokens_details.accepted_prediction_tokens,
+                }),
+                ...(xaiUsage.completion_tokens_details?.rejected_prediction_tokens !=
+                    null && {
+                    rejected_prediction: xaiUsage.completion_tokens_details.rejected_prediction_tokens,
+                }),
+            };
+            const generationChunk = new outputs.ChatGenerationChunk({
+                message: new messages.AIMessageChunk({
+                    content: '',
+                    response_metadata: {
+                        usage: { ...usage },
+                        // Include xAI-specific metadata if it exists
+                        ...(xaiUsage.num_sources_used != null && {
+                            num_sources_used: xaiUsage.num_sources_used,
+                        }),
+                    },
+                    usage_metadata: {
+                        input_tokens: usage.prompt_tokens,
+                        output_tokens: usage.completion_tokens,
+                        total_tokens: usage.total_tokens,
+                        ...(Object.keys(inputTokenDetails).length > 0 && {
+                            input_token_details: inputTokenDetails,
+                        }),
+                        ...(Object.keys(outputTokenDetails).length > 0 && {
+                            output_token_details: outputTokenDetails,
+                        }),
+                    },
+                }),
+                text: '',
+            });
+            yield generationChunk;
+        }
+        if (options.signal?.aborted === true) {
+            throw new Error('AbortError');
+        }
+    }
 }
 
 exports.AzureChatOpenAI = AzureChatOpenAI;
@@ -211,4 +595,6 @@ exports.ChatOpenAI = ChatOpenAI;
 exports.ChatXAI = ChatXAI;
 exports.CustomAzureOpenAIClient = CustomAzureOpenAIClient;
 exports.CustomOpenAIClient = CustomOpenAIClient;
+exports.isHeaders = isHeaders;
+exports.normalizeHeaders = normalizeHeaders;
 //# sourceMappingURL=index.cjs.map