@librechat/agents 3.1.86 → 3.1.88

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

@@ -6,17 +6,11 @@ import { isLangChainTool, convertToOpenAITool } from '@langchain/core/utils/func
 import { ChatDeepSeek as ChatDeepSeek$1 } from '@langchain/deepseek';
 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';
-import '../../common/enum.mjs';
-import 'nanoid';
-import '../../messages/core.mjs';
-import '@langchain/core/callbacks/dispatch';
-import 'uuid';
-import { sleep } from '../../utils/run.mjs';
-import 'ai-tokenizer';
-import 'zod-to-json-schema';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 const iife = (fn) => fn();
+const STREAM_CHUNK_MIN_SIZE = 4;
+const STREAM_BOUNDARIES = new Set([' ', '.', ',', '!', '?', ';', ':']);
 function isHeaders(headers) {
     return (typeof Headers !== 'undefined' &&
         headers !== null &&
@@ -237,14 +231,113 @@ function getCustomOpenAIClientOptions(owner, options) {
     };
     return requestOptions;
 }
-async function* delayStreamChunks(chunks, delay) {
+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;
+}
+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;
+}
+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,
+            })),
+        });
+    });
+}
+async function emitStreamChunkCallback(chunk, runManager) {
+    await runManager?.handleLLMNewToken(chunk.text, getStreamChunkTokenIndices(chunk), undefined, undefined, undefined, { 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;
+}
+async function* delayStreamChunks(chunks, delay, signal, runManager) {
+    let lastYieldedAt;
     for await (const chunk of chunks) {
-        yield chunk;
-        if (delay != null) {
-            await sleep(delay);
+        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();
+        }
+    });
+}
 function createAbortHandler(controller) {
     return function () {
         controller.abort();
@@ -279,7 +372,7 @@ class CustomOpenAIClient extends OpenAIClient {
         this.abortHandler = handler;
         if (signal)
             signal.addEventListener('abort', handler, { once: true });
-        const timeout = setTimeout(() => handler, ms);
+        const timeout = setTimeout(handler, ms);
         const fetchOptions = {
             signal: controller.signal,
             ...options,
@@ -306,7 +399,7 @@ class CustomAzureOpenAIClient extends AzureOpenAI {
         this.abortHandler = handler;
         if (signal)
             signal.addEventListener('abort', handler, { once: true });
-        const timeout = setTimeout(() => handler, ms);
+        const timeout = setTimeout(handler, ms);
         const fetchOptions = {
             signal: controller.signal,
             ...options,
@@ -773,7 +866,7 @@ class ChatOpenAI extends ChatOpenAI$1 {
         return this.getReasoningParams(options);
     }
     async *_streamResponseChunks(messages, options, runManager) {
-        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, undefined), this._lc_stream_delay, options.signal, runManager);
     }
 }
 class AzureChatOpenAI extends AzureChatOpenAI$1 {
@@ -853,7 +946,7 @@ class AzureChatOpenAI extends AzureChatOpenAI$1 {
         return requestOptions;
     }
     async *_streamResponseChunks(messages, options, runManager) {
-        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, undefined), this._lc_stream_delay, options.signal, runManager);
     }
 }
 class ChatDeepSeek extends ChatDeepSeek$1 {
@@ -940,7 +1033,7 @@ class ChatDeepSeek extends ChatDeepSeek$1 {
         return requestOptions;
     }
     async *_streamResponseChunks(messages, options, runManager) {
-        yield* delayStreamChunks(this._streamResponseChunksWithReasoning(messages, options, runManager), this._lc_stream_delay);
+        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) {
@@ -1154,12 +1247,7 @@ class ChatDeepSeek extends ChatDeepSeek$1 {
         await runManager?.handleLLMNewToken(chunk.text, this._getDeepSeekTokenIndices(chunk), undefined, undefined, undefined, { chunk });
     }
     _getDeepSeekTokenIndices(chunk) {
-        const prompt = chunk.generationInfo?.prompt;
-        const completion = chunk.generationInfo?.completion;
-        if (typeof prompt === 'number' && typeof completion === 'number') {
-            return { prompt, completion };
-        }
-        return undefined;
+        return getStreamChunkTokenIndices(chunk);
     }
     _getDeepSeekPartialTagSplitIndex(text, tag) {
         for (let i = tag.length - 1; i >= 1; i--) {
@@ -1227,9 +1315,9 @@ class ChatXAI extends ChatXAI$1 {
         return requestOptions;
     }
     async *_streamResponseChunks(messages, options, runManager) {
-        yield* delayStreamChunks(super._streamResponseChunks(messages, options, runManager), this._lc_stream_delay);
+        yield* delayStreamChunks(super._streamResponseChunks(messages, options, undefined), this._lc_stream_delay, options.signal, runManager);
     }
 }
 
-export { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI, CustomAzureOpenAIClient, CustomOpenAIClient, _convertToOpenAITool, isHeaders, normalizeHeaders };
+export { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI, CustomAzureOpenAIClient, CustomOpenAIClient, _convertToOpenAITool, emitStreamChunkCallback, isHeaders, normalizeHeaders };
 //# sourceMappingURL=index.mjs.map