@librechat/agents 3.2.32 → 3.2.33

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

@@ -1,607 +1,480 @@
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatAnthropicMessages } from '@langchain/anthropic';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { stripUnsupportedAssistantPrefill, _convertMessagesToAnthropicPayload } from './utils/message_inputs.mjs';
-import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs.mjs';
-import { handleToolChoice } from './utils/tools.mjs';
-
+import { _convertMessagesToAnthropicPayload, stripUnsupportedAssistantPrefill } from "./utils/message_inputs.mjs";
+import { _makeMessageChunkFromAnthropicEvent } from "./utils/message_outputs.mjs";
+import { handleToolChoice } from "./utils/tools.mjs";
+import { AIMessageChunk } from "@langchain/core/messages";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { ChatAnthropicMessages } from "@langchain/anthropic";
+//#region src/llm/anthropic/index.ts
 const DEFAULT_STREAM_DELAY = 25;
 const MAX_STREAM_QUEUE_CHUNKS = 256;
 const MAX_STREAM_QUEUE_TEXT_CHARS = 8192;
 const STREAM_CHUNK_MIN_SIZE = 4;
-const STREAM_BOUNDARIES = new Set([' ', '.', ',', '!', '?', ';', ':']);
+const STREAM_BOUNDARIES = new Set([
+	" ",
+	".",
+	",",
+	"!",
+	"?",
+	";",
+	":"
+]);
 const ANTHROPIC_TOOL_BETAS = {
-    tool_search_tool_regex_20251119: 'advanced-tool-use-2025-11-20',
-    tool_search_tool_bm25_20251119: 'advanced-tool-use-2025-11-20',
-    memory_20250818: 'context-management-2025-06-27',
-    web_fetch_20250910: 'web-fetch-2025-09-10',
-    code_execution_20250825: 'code-execution-2025-08-25',
-    computer_20251124: 'computer-use-2025-11-24',
-    computer_20250124: 'computer-use-2025-01-24',
-    mcp_toolset: 'mcp-client-2025-11-20',
+	tool_search_tool_regex_20251119: "advanced-tool-use-2025-11-20",
+	tool_search_tool_bm25_20251119: "advanced-tool-use-2025-11-20",
+	memory_20250818: "context-management-2025-06-27",
+	web_fetch_20250910: "web-fetch-2025-09-10",
+	code_execution_20250825: "code-execution-2025-08-25",
+	computer_20251124: "computer-use-2025-11-24",
+	computer_20250124: "computer-use-2025-01-24",
+	mcp_toolset: "mcp-client-2025-11-20"
 };
 function _toolsInParams(params) {
-    return !!(params.tools && params.tools.length > 0);
+	return !!(params.tools && params.tools.length > 0);
 }
 function _documentsInParams(params) {
-    for (const message of params.messages) {
-        if (typeof message.content === 'string') {
-            continue;
-        }
-        for (const block of message.content) {
-            const maybeBlock = block;
-            if (typeof maybeBlock === 'object' &&
-                maybeBlock !== null &&
-                'type' in maybeBlock &&
-                maybeBlock.type === 'document' &&
-                'citations' in maybeBlock &&
-                maybeBlock.citations != null &&
-                typeof maybeBlock.citations === 'object' &&
-                'enabled' in maybeBlock.citations &&
-                maybeBlock.citations.enabled === true) {
-                return true;
-            }
-        }
-    }
-    return false;
+	for (const message of params.messages) {
+		if (typeof message.content === "string") continue;
+		for (const block of message.content) {
+			const maybeBlock = block;
+			if (typeof maybeBlock === "object" && maybeBlock !== null && "type" in maybeBlock && maybeBlock.type === "document" && "citations" in maybeBlock && maybeBlock.citations != null && typeof maybeBlock.citations === "object" && "enabled" in maybeBlock.citations && maybeBlock.citations.enabled === true) return true;
+		}
+	}
+	return false;
 }
 function _thinkingInParams(params) {
-    return !!(params.thinking &&
-        (params.thinking.type === 'enabled' || params.thinking.type === 'adaptive'));
+	return !!(params.thinking && (params.thinking.type === "enabled" || params.thinking.type === "adaptive"));
 }
 function _compactionInParams(params) {
-    return (params.context_management?.edits?.some((edit) => edit.type === 'compact_20260112') === true);
+	return params.context_management?.edits?.some((edit) => edit.type === "compact_20260112") === true;
 }
 function isThinkingEnabled(thinking) {
-    return thinking.type === 'enabled' || thinking.type === 'adaptive';
+	return thinking.type === "enabled" || thinking.type === "adaptive";
 }
 function isOpus47Model(model) {
-    return /^claude-opus-4-7(?:-|$)/.test(model ?? '');
+	return /^claude-opus-4-7(?:-|$)/.test(model ?? "");
 }
 function combineBetas(...betaGroups) {
-    const betas = new Set();
-    for (const betaGroup of betaGroups) {
-        for (const beta of betaGroup ?? []) {
-            betas.add(beta);
-        }
-    }
-    return [...betas];
+	const betas = /* @__PURE__ */ new Set();
+	for (const betaGroup of betaGroups) for (const beta of betaGroup ?? []) betas.add(beta);
+	return [...betas];
 }
 function getToolBetas(tools) {
-    const betas = new Set();
-    for (const tool of tools ?? []) {
-        if (typeof tool !== 'object' || !('type' in tool)) {
-            continue;
-        }
-        const beta = ANTHROPIC_TOOL_BETAS[String(tool.type)];
-        if (beta != null) {
-            betas.add(beta);
-        }
-    }
-    return [...betas];
+	const betas = /* @__PURE__ */ new Set();
+	for (const tool of tools ?? []) {
+		if (typeof tool !== "object" || !("type" in tool)) continue;
+		const beta = ANTHROPIC_TOOL_BETAS[String(tool.type)];
+		if (beta != null) betas.add(beta);
+	}
+	return [...betas];
 }
 function getCompactionBetas(contextManagement) {
-    return contextManagement?.edits?.some((edit) => edit.type === 'compact_20260112') === true
-        ? ['compact-2026-01-12']
-        : [];
+	return contextManagement?.edits?.some((edit) => edit.type === "compact_20260112") === true ? ["compact-2026-01-12"] : [];
 }
 function getTaskBudgetBetas(model, outputConfig) {
-    return isOpus47Model(model) &&
-        outputConfig != null &&
-        'task_budget' in outputConfig &&
-        outputConfig.task_budget != null
-        ? ['task-budgets-2026-03-13']
-        : [];
+	return isOpus47Model(model) && outputConfig != null && "task_budget" in outputConfig && outputConfig.task_budget != null ? ["task-budgets-2026-03-13"] : [];
 }
 function isSetSamplingValue(value) {
-    return value != null && value !== -1;
+	return value != null && value !== -1;
 }
 function isNonDefaultTemperature(value) {
-    return isSetSamplingValue(value) && value !== 1;
+	return isSetSamplingValue(value) && value !== 1;
 }
-function validateInvocationParamCompatibility({ model, thinking, topK, topP, temperature, }) {
-    const opus47 = isOpus47Model(model);
-    if (opus47 && thinking.type === 'enabled') {
-        throw new Error('thinking.type="enabled" is not supported for claude-opus-4-7; use thinking.type="adaptive" instead');
-    }
-    if (opus47 && 'budget_tokens' in thinking) {
-        throw new Error('thinking.budget_tokens is not supported for claude-opus-4-7; use outputConfig.effort instead');
-    }
-    if (opus47) {
-        if (isSetSamplingValue(topK)) {
-            throw new Error('topK is not supported for claude-opus-4-7; omit topK/topP/temperature or use model prompting instead');
-        }
-        if (isSetSamplingValue(topP) && topP !== 1) {
-            throw new Error('topP is not supported for claude-opus-4-7 when set to non-default values');
-        }
-        if (isNonDefaultTemperature(temperature)) {
-            throw new Error('temperature is not supported for claude-opus-4-7 when set to non-default values');
-        }
-    }
-    if (!isThinkingEnabled(thinking)) {
-        return;
-    }
-    if (isSetSamplingValue(topK)) {
-        throw new Error('topK is not supported when thinking is enabled');
-    }
-    if (isSetSamplingValue(topP)) {
-        throw new Error('topP is not supported when thinking is enabled');
-    }
-    if (isNonDefaultTemperature(temperature)) {
-        throw new Error('temperature is not supported when thinking is enabled');
-    }
+function validateInvocationParamCompatibility({ model, thinking, topK, topP, temperature }) {
+	const opus47 = isOpus47Model(model);
+	if (opus47 && thinking.type === "enabled") throw new Error("thinking.type=\"enabled\" is not supported for claude-opus-4-7; use thinking.type=\"adaptive\" instead");
+	if (opus47 && "budget_tokens" in thinking) throw new Error("thinking.budget_tokens is not supported for claude-opus-4-7; use outputConfig.effort instead");
+	if (opus47) {
+		if (isSetSamplingValue(topK)) throw new Error("topK is not supported for claude-opus-4-7; omit topK/topP/temperature or use model prompting instead");
+		if (isSetSamplingValue(topP) && topP !== 1) throw new Error("topP is not supported for claude-opus-4-7 when set to non-default values");
+		if (isNonDefaultTemperature(temperature)) throw new Error("temperature is not supported for claude-opus-4-7 when set to non-default values");
+	}
+	if (!isThinkingEnabled(thinking)) return;
+	if (isSetSamplingValue(topK)) throw new Error("topK is not supported when thinking is enabled");
+	if (isSetSamplingValue(topP)) throw new Error("topP is not supported when thinking is enabled");
+	if (isNonDefaultTemperature(temperature)) throw new Error("temperature is not supported when thinking is enabled");
 }
-function getSamplingParams({ model, thinking, topK, topP, temperature, }) {
-    if (isThinkingEnabled(thinking) || isOpus47Model(model)) {
-        return {};
-    }
-    return {
-        ...(isSetSamplingValue(temperature) ? { temperature } : {}),
-        ...(isSetSamplingValue(topK) ? { top_k: topK } : {}),
-        ...(isSetSamplingValue(topP) ? { top_p: topP } : {}),
-    };
+function getSamplingParams({ model, thinking, topK, topP, temperature }) {
+	if (isThinkingEnabled(thinking) || isOpus47Model(model)) return {};
+	return {
+		...isSetSamplingValue(temperature) ? { temperature } : {},
+		...isSetSamplingValue(topK) ? { top_k: topK } : {},
+		...isSetSamplingValue(topP) ? { top_p: topP } : {}
+	};
 }
 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 getCadencedStreamDelay({ targetDelay, lastVisibleTextAt, now, }) {
-    if (targetDelay <= 0 || lastVisibleTextAt == null) {
-        return 0;
-    }
-    return Math.max(0, targetDelay - (now - lastVisibleTextAt));
+function getCadencedStreamDelay({ targetDelay, lastVisibleTextAt, now }) {
+	if (targetDelay <= 0 || lastVisibleTextAt == null) return 0;
+	return Math.max(0, targetDelay - (now - lastVisibleTextAt));
 }
 async function waitForStreamDelay(delay, signal) {
-    if (delay <= 0 || isSignalAborted(signal)) {
-        return;
-    }
-    await new Promise((resolve) => {
-        const timeoutRef = {};
-        const onAbort = () => {
-            if (timeoutRef.current) {
-                clearTimeout(timeoutRef.current);
-            }
-            signal?.removeEventListener('abort', onAbort);
-            resolve();
-        };
-        timeoutRef.current = setTimeout(() => {
-            signal?.removeEventListener('abort', onAbort);
-            resolve();
-        }, delay);
-        signal?.addEventListener('abort', onAbort, { once: true });
-        if (isSignalAborted(signal)) {
-            onAbort();
-        }
-    });
+	if (delay <= 0 || isSignalAborted(signal)) return;
+	await new Promise((resolve) => {
+		const timeoutRef = {};
+		const onAbort = () => {
+			if (timeoutRef.current) clearTimeout(timeoutRef.current);
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		};
+		timeoutRef.current = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delay);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (isSignalAborted(signal)) onAbort();
+	});
 }
 function isSignalAborted(signal) {
-    return signal?.aborted === true;
+	return signal?.aborted === true;
 }
 function extractToken(chunk) {
-    if (typeof chunk.content === 'string') {
-        return [chunk.content, 'string'];
-    }
-    else if (Array.isArray(chunk.content) &&
-        chunk.content.length >= 1 &&
-        'input' in chunk.content[0]) {
-        return typeof chunk.content[0].input === 'string'
-            ? [chunk.content[0].input, 'input']
-            : [JSON.stringify(chunk.content[0].input), 'input'];
-    }
-    else if (Array.isArray(chunk.content) &&
-        chunk.content.length >= 1 &&
-        'text' in chunk.content[0]) {
-        const text = chunk.content[0].text;
-        return typeof text === 'string' ? [text, 'content'] : [undefined];
-    }
-    else if (Array.isArray(chunk.content) &&
-        chunk.content.length >= 1 &&
-        'thinking' in chunk.content[0]) {
-        const thinking = chunk.content[0].thinking;
-        return typeof thinking === 'string' ? [thinking, 'content'] : [undefined];
-    }
-    return [undefined];
+	if (typeof chunk.content === "string") return [chunk.content, "string"];
+	else if (Array.isArray(chunk.content) && chunk.content.length >= 1 && "input" in chunk.content[0]) return typeof chunk.content[0].input === "string" ? [chunk.content[0].input, "input"] : [JSON.stringify(chunk.content[0].input), "input"];
+	else if (Array.isArray(chunk.content) && chunk.content.length >= 1 && "text" in chunk.content[0]) {
+		const text = chunk.content[0].text;
+		return typeof text === "string" ? [text, "content"] : [void 0];
+	} else if (Array.isArray(chunk.content) && chunk.content.length >= 1 && "thinking" in chunk.content[0]) {
+		const thinking = chunk.content[0].thinking;
+		return typeof thinking === "string" ? [thinking, "content"] : [void 0];
+	}
+	return [void 0];
 }
 function cloneChunk(text, tokenType, chunk) {
-    if (tokenType === 'string') {
-        return new AIMessageChunk(Object.assign({}, chunk, { content: text }));
-    }
-    else if (tokenType === 'input') {
-        return chunk;
-    }
-    const content = chunk.content[0];
-    if (content.type === 'text') {
-        return new AIMessageChunk(Object.assign({}, chunk, {
-            content: [Object.assign({}, content, { text })],
-        }));
-    }
-    else if (content.type === 'text_delta') {
-        return new AIMessageChunk(Object.assign({}, chunk, {
-            content: [Object.assign({}, content, { text })],
-        }));
-    }
-    else if (typeof content.type === 'string' &&
-        content.type.startsWith('thinking')) {
-        return new AIMessageChunk(Object.assign({}, chunk, {
-            content: [Object.assign({}, content, { thinking: text })],
-        }));
-    }
-    return chunk;
+	if (tokenType === "string") return new AIMessageChunk(Object.assign({}, chunk, { content: text }));
+	else if (tokenType === "input") return chunk;
+	const content = chunk.content[0];
+	if (content.type === "text") return new AIMessageChunk(Object.assign({}, chunk, { content: [Object.assign({}, content, { text })] }));
+	else if (content.type === "text_delta") return new AIMessageChunk(Object.assign({}, chunk, { content: [Object.assign({}, content, { text })] }));
+	else if (typeof content.type === "string" && content.type.startsWith("thinking")) return new AIMessageChunk(Object.assign({}, chunk, { content: [Object.assign({}, content, { thinking: text })] }));
+	return chunk;
 }
 function withIncrementalMessageDeltaUsage(chunk, previousOutputTokens) {
-    const usage = chunk.usage_metadata;
-    if (usage == null) {
-        return { chunk, outputTokens: previousOutputTokens };
-    }
-    const outputTokens = Math.max(0, usage.output_tokens - previousOutputTokens);
-    return {
-        chunk: new AIMessageChunk(Object.assign({}, chunk, {
-            usage_metadata: {
-                ...usage,
-                output_tokens: outputTokens,
-                total_tokens: usage.input_tokens + outputTokens,
-            },
-        })),
-        outputTokens: usage.output_tokens,
-    };
-}
-class CustomAnthropic extends ChatAnthropicMessages {
-    _lc_stream_delay;
-    tools_in_params;
-    top_k;
-    outputConfig;
-    inferenceGeo;
-    contextManagement;
-    constructor(fields) {
-        super(fields);
-        this.resetTokenEvents();
-        this.setDirectFields(fields);
-        this._lc_stream_delay = Math.max(0, fields?._lc_stream_delay ?? DEFAULT_STREAM_DELAY);
-        this.outputConfig = fields?.outputConfig;
-        this.inferenceGeo = fields?.inferenceGeo;
-        this.contextManagement = fields?.contextManagement;
-    }
-    static lc_name() {
-        return 'LibreChatAnthropic';
-    }
-    /**
-     * Get the parameters used to invoke the model
-     */
-    invocationParams(options) {
-        const tool_choice = handleToolChoice(options?.tool_choice);
-        const callOptions = options;
-        const mergedOutputConfig = (() => {
-            const base = {
-                ...this.outputConfig,
-                ...callOptions?.outputConfig,
-            };
-            if (callOptions?.outputFormat && !base.format) {
-                base.format = callOptions.outputFormat;
-            }
-            return Object.keys(base).length > 0 ? base : undefined;
-        })();
-        const inferenceGeo = callOptions?.inferenceGeo ?? this.inferenceGeo;
-        const contextManagement = this.contextManagement;
-        const toolBetas = getToolBetas(options?.tools);
-        const compactionBetas = getCompactionBetas(contextManagement);
-        const taskBudgetBetas = getTaskBudgetBetas(this.model, mergedOutputConfig);
-        const formattedTools = this.formatStructuredToolToAnthropic(options?.tools);
-        const sharedParams = {
-            tools: formattedTools,
-            tool_choice,
-            thinking: this.thinking,
-            context_management: contextManagement,
-            ...this.invocationKwargs,
-            container: callOptions?.container,
-            betas: combineBetas(this.betas, callOptions?.betas, toolBetas, compactionBetas, taskBudgetBetas),
-            output_config: mergedOutputConfig,
-            inference_geo: inferenceGeo,
-            mcp_servers: callOptions?.mcp_servers,
-        };
-        validateInvocationParamCompatibility({
-            model: this.model,
-            thinking: this.thinking,
-            topK: this.top_k,
-            topP: this.topP,
-            temperature: this.temperature,
-        });
-        return {
-            model: this.model,
-            stop_sequences: options?.stop ?? this.stopSequences,
-            stream: this.streaming,
-            max_tokens: this.maxTokens,
-            ...getSamplingParams({
-                model: this.model,
-                thinking: this.thinking,
-                topK: this.top_k,
-                topP: this.topP,
-                temperature: this.temperature,
-            }),
-            ...sharedParams,
-        };
-    }
-    resetTokenEvents() {
-        this.tools_in_params = undefined;
-    }
-    setDirectFields(fields) {
-        this.temperature = fields?.temperature ?? undefined;
-        this.topP = fields?.topP ?? undefined;
-        this.top_k = fields?.topK;
-        if (this.temperature === -1 || this.temperature === 1) {
-            this.temperature = undefined;
-        }
-        if (this.topP === -1) {
-            this.topP = undefined;
-        }
-        if (this.top_k === -1) {
-            this.top_k = undefined;
-        }
-    }
-    createGenerationChunk({ token, chunk, shouldStreamUsage, }) {
-        const usage_metadata = shouldStreamUsage ? chunk.usage_metadata : undefined;
-        return new ChatGenerationChunk({
-            message: new AIMessageChunk({
-                // Just yield chunk as it is and tool_use will be concat by BaseChatModel._generateUncached().
-                content: chunk.content,
-                additional_kwargs: chunk.additional_kwargs,
-                tool_call_chunks: chunk.tool_call_chunks,
-                response_metadata: chunk.response_metadata,
-                usage_metadata,
-                id: chunk.id,
-            }),
-            text: token ?? '',
-        });
-    }
-    async createStreamWithRetry(request, options) {
-        return super.createStreamWithRetry(stripUnsupportedAssistantPrefill(request), options);
-    }
-    async completionWithRetry(request, options) {
-        return super.completionWithRetry(stripUnsupportedAssistantPrefill(request), options);
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        this.resetTokenEvents();
-        const params = this.invocationParams(options);
-        const formattedMessages = _convertMessagesToAnthropicPayload(messages);
-        const payload = stripUnsupportedAssistantPrefill({
-            ...params,
-            ...formattedMessages,
-            stream: true,
-        });
-        const coerceContentToString = !_toolsInParams(payload) &&
-            !_documentsInParams(payload) &&
-            !_thinkingInParams(payload) &&
-            !_compactionInParams(payload);
-        const stream = await this.createStreamWithRetry(payload, {
-            headers: options.headers,
-            signal: options.signal,
-        });
-        const shouldStreamUsage = options.streamUsage ?? this.streamUsage;
-        let messageDeltaOutputTokens = 0;
-        const queuedChunks = [];
-        const producerState = { done: false };
-        let queuedChunkIndex = 0;
-        let bufferedTextLength = 0;
-        let consumerClosed = false;
-        let notifyConsumer;
-        let notifyProducer;
-        const notifyConsumerForChunk = () => {
-            notifyConsumer?.();
-            notifyConsumer = undefined;
-        };
-        const notifyProducerForSpace = () => {
-            notifyProducer?.();
-            notifyProducer = undefined;
-        };
-        const hasQueuedChunks = () => queuedChunkIndex < queuedChunks.length;
-        const getQueuedChunkCount = () => queuedChunks.length - queuedChunkIndex;
-        const isQueueAtCapacity = () => getQueuedChunkCount() >= MAX_STREAM_QUEUE_CHUNKS ||
-            bufferedTextLength >= MAX_STREAM_QUEUE_TEXT_CHARS;
-        const waitForNextChunk = async () => {
-            if (hasQueuedChunks() ||
-                producerState.done ||
-                producerState.error != null) {
-                return;
-            }
-            await new Promise((resolve) => {
-                notifyConsumer = resolve;
-            });
-        };
-        const waitForQueueSpace = async () => {
-            while (isQueueAtCapacity() &&
-                !consumerClosed &&
-                !isSignalAborted(options.signal)) {
-                await new Promise((resolve) => {
-                    const signal = options.signal;
-                    const onAbort = () => {
-                        signal?.removeEventListener('abort', onAbort);
-                        resolve();
-                    };
-                    const onSpace = () => {
-                        signal?.removeEventListener('abort', onAbort);
-                        resolve();
-                    };
-                    notifyProducer = onSpace;
-                    signal?.addEventListener('abort', onAbort, { once: true });
-                    if (isSignalAborted(signal)) {
-                        onAbort();
-                    }
-                });
-            }
-        };
-        const dequeue = () => {
-            if (!hasQueuedChunks()) {
-                return undefined;
-            }
-            const queuedChunk = queuedChunks[queuedChunkIndex];
-            queuedChunkIndex++;
-            if (queuedChunkIndex > 128 &&
-                queuedChunkIndex * 2 >= queuedChunks.length) {
-                queuedChunks.splice(0, queuedChunkIndex);
-                queuedChunkIndex = 0;
-            }
-            return queuedChunk;
-        };
-        const enqueue = async (queuedChunk) => {
-            await waitForQueueSpace();
-            if (consumerClosed || isSignalAborted(options.signal)) {
-                stream.controller.abort();
-                throw new Error('AbortError: User aborted the request.');
-            }
-            queuedChunks.push(queuedChunk);
-            if (queuedChunk.smooth) {
-                bufferedTextLength += queuedChunk.textLength;
-            }
-            notifyConsumerForChunk();
-        };
-        const enqueueChunk = async ({ token, chunk, smooth, }) => {
-            await enqueue({
-                token,
-                smooth,
-                textLength: smooth ? token.length : 0,
-                chunk: this.createGenerationChunk({
-                    token,
-                    chunk,
-                    shouldStreamUsage,
-                }),
-            });
-        };
-        const enqueueTextChunks = (token, tokenType, chunk) => {
-            if (token === '') {
-                return Promise.resolve();
-            }
-            if (this._lc_stream_delay <= 0) {
-                return enqueueChunk({ token, chunk, smooth: false });
-            }
-            const tokenChunks = splitStreamToken(token);
-            if (tokenChunks.length <= 1) {
-                return enqueueChunk({ token, chunk, smooth: true });
-            }
-            let emittedUsage = false;
-            return tokenChunks.reduce(async (previous, currentToken) => {
-                await previous;
-                const newChunk = cloneChunk(currentToken, tokenType, chunk);
-                const chunkForToken = emittedUsage && newChunk.usage_metadata != null
-                    ? new AIMessageChunk(Object.assign({}, newChunk, { usage_metadata: undefined }))
-                    : newChunk;
-                await enqueueChunk({
-                    token: currentToken,
-                    chunk: chunkForToken,
-                    smooth: true,
-                });
-                if (newChunk.usage_metadata != null && !emittedUsage) {
-                    emittedUsage = true;
-                }
-            }, Promise.resolve());
-        };
-        const producer = (async () => {
-            try {
-                for await (const data of stream) {
-                    if (isSignalAborted(options.signal)) {
-                        stream.controller.abort();
-                        throw new Error('AbortError: User aborted the request.');
-                    }
-                    const result = _makeMessageChunkFromAnthropicEvent(data, {
-                        streamUsage: shouldStreamUsage,
-                        coerceContentToString,
-                    });
-                    if (!result) {
-                        continue;
-                    }
-                    let { chunk } = result;
-                    if (data.type === 'message_delta') {
-                        const incremental = withIncrementalMessageDeltaUsage(chunk, messageDeltaOutputTokens);
-                        chunk = incremental.chunk;
-                        messageDeltaOutputTokens = incremental.outputTokens;
-                    }
-                    const [token = '', tokenType] = extractToken(chunk);
-                    if (!tokenType ||
-                        tokenType === 'input' ||
-                        (token === '' && (chunk.usage_metadata != null || chunk.id != null))) {
-                        await enqueueChunk({ token, chunk, smooth: false });
-                        continue;
-                    }
-                    await enqueueTextChunks(token, tokenType, chunk);
-                }
-            }
-            catch (error) {
-                producerState.error = error;
-            }
-            finally {
-                producerState.done = true;
-                notifyConsumerForChunk();
-            }
-        })();
-        let hasEmittedText = false;
-        let lastVisibleTextAt;
-        let keepStreaming = true;
-        try {
-            while (keepStreaming) {
-                if (isSignalAborted(options.signal)) {
-                    stream.controller.abort();
-                    throw new Error('AbortError: User aborted the request.');
-                }
-                await waitForNextChunk();
-                const queuedChunk = dequeue();
-                if (!queuedChunk) {
-                    if (producerState.error != null) {
-                        throw producerState.error;
-                    }
-                    if (producerState.done) {
-                        keepStreaming = false;
-                    }
-                    continue;
-                }
-                if (queuedChunk.smooth) {
-                    bufferedTextLength = Math.max(0, bufferedTextLength - queuedChunk.textLength);
-                    notifyProducerForSpace();
-                    await waitForStreamDelay(getCadencedStreamDelay({
-                        targetDelay: hasEmittedText ? this._lc_stream_delay : 0,
-                        lastVisibleTextAt,
-                        now: Date.now(),
-                    }), options.signal);
-                    if (isSignalAborted(options.signal)) {
-                        stream.controller.abort();
-                        throw new Error('AbortError: User aborted the request.');
-                    }
-                    hasEmittedText = true;
-                    lastVisibleTextAt = Date.now();
-                }
-                else {
-                    notifyProducerForSpace();
-                }
-                yield queuedChunk.chunk;
-                await runManager?.handleLLMNewToken(queuedChunk.token, undefined, undefined, undefined, undefined, { chunk: queuedChunk.chunk });
-            }
-        }
-        finally {
-            consumerClosed = true;
-            if (!producerState.done) {
-                stream.controller.abort();
-                notifyProducerForSpace();
-            }
-            await producer;
-            this.resetTokenEvents();
-        }
-    }
+	const usage = chunk.usage_metadata;
+	if (usage == null) return {
+		chunk,
+		outputTokens: previousOutputTokens
+	};
+	const outputTokens = Math.max(0, usage.output_tokens - previousOutputTokens);
+	return {
+		chunk: new AIMessageChunk(Object.assign({}, chunk, { usage_metadata: {
+			...usage,
+			output_tokens: outputTokens,
+			total_tokens: usage.input_tokens + outputTokens
+		} })),
+		outputTokens: usage.output_tokens
+	};
 }
+var CustomAnthropic = class extends ChatAnthropicMessages {
+	_lc_stream_delay;
+	tools_in_params;
+	top_k;
+	outputConfig;
+	inferenceGeo;
+	contextManagement;
+	constructor(fields) {
+		super(fields);
+		this.resetTokenEvents();
+		this.setDirectFields(fields);
+		this._lc_stream_delay = Math.max(0, fields?._lc_stream_delay ?? DEFAULT_STREAM_DELAY);
+		this.outputConfig = fields?.outputConfig;
+		this.inferenceGeo = fields?.inferenceGeo;
+		this.contextManagement = fields?.contextManagement;
+	}
+	static lc_name() {
+		return "LibreChatAnthropic";
+	}
+	/**
+	* Get the parameters used to invoke the model
+	*/
+	invocationParams(options) {
+		const tool_choice = handleToolChoice(options?.tool_choice);
+		const callOptions = options;
+		const mergedOutputConfig = (() => {
+			const base = {
+				...this.outputConfig,
+				...callOptions?.outputConfig
+			};
+			if (callOptions?.outputFormat && !base.format) base.format = callOptions.outputFormat;
+			return Object.keys(base).length > 0 ? base : void 0;
+		})();
+		const inferenceGeo = callOptions?.inferenceGeo ?? this.inferenceGeo;
+		const contextManagement = this.contextManagement;
+		const toolBetas = getToolBetas(options?.tools);
+		const compactionBetas = getCompactionBetas(contextManagement);
+		const taskBudgetBetas = getTaskBudgetBetas(this.model, mergedOutputConfig);
+		const sharedParams = {
+			tools: this.formatStructuredToolToAnthropic(options?.tools),
+			tool_choice,
+			thinking: this.thinking,
+			context_management: contextManagement,
+			...this.invocationKwargs,
+			container: callOptions?.container,
+			betas: combineBetas(this.betas, callOptions?.betas, toolBetas, compactionBetas, taskBudgetBetas),
+			output_config: mergedOutputConfig,
+			inference_geo: inferenceGeo,
+			mcp_servers: callOptions?.mcp_servers
+		};
+		validateInvocationParamCompatibility({
+			model: this.model,
+			thinking: this.thinking,
+			topK: this.top_k,
+			topP: this.topP,
+			temperature: this.temperature
+		});
+		return {
+			model: this.model,
+			stop_sequences: options?.stop ?? this.stopSequences,
+			stream: this.streaming,
+			max_tokens: this.maxTokens,
+			...getSamplingParams({
+				model: this.model,
+				thinking: this.thinking,
+				topK: this.top_k,
+				topP: this.topP,
+				temperature: this.temperature
+			}),
+			...sharedParams
+		};
+	}
+	resetTokenEvents() {
+		this.tools_in_params = void 0;
+	}
+	setDirectFields(fields) {
+		this.temperature = fields?.temperature ?? void 0;
+		this.topP = fields?.topP ?? void 0;
+		this.top_k = fields?.topK;
+		if (this.temperature === -1 || this.temperature === 1) this.temperature = void 0;
+		if (this.topP === -1) this.topP = void 0;
+		if (this.top_k === -1) this.top_k = void 0;
+	}
+	createGenerationChunk({ token, chunk, shouldStreamUsage }) {
+		const usage_metadata = shouldStreamUsage ? chunk.usage_metadata : void 0;
+		return new ChatGenerationChunk({
+			message: new AIMessageChunk({
+				content: chunk.content,
+				additional_kwargs: chunk.additional_kwargs,
+				tool_call_chunks: chunk.tool_call_chunks,
+				response_metadata: chunk.response_metadata,
+				usage_metadata,
+				id: chunk.id
+			}),
+			text: token ?? ""
+		});
+	}
+	async createStreamWithRetry(request, options) {
+		return super.createStreamWithRetry(stripUnsupportedAssistantPrefill(request), options);
+	}
+	async completionWithRetry(request, options) {
+		return super.completionWithRetry(stripUnsupportedAssistantPrefill(request), options);
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		this.resetTokenEvents();
+		const params = this.invocationParams(options);
+		const formattedMessages = _convertMessagesToAnthropicPayload(messages);
+		const payload = stripUnsupportedAssistantPrefill({
+			...params,
+			...formattedMessages,
+			stream: true
+		});
+		const coerceContentToString = !_toolsInParams(payload) && !_documentsInParams(payload) && !_thinkingInParams(payload) && !_compactionInParams(payload);
+		const stream = await this.createStreamWithRetry(payload, {
+			headers: options.headers,
+			signal: options.signal
+		});
+		const shouldStreamUsage = options.streamUsage ?? this.streamUsage;
+		let messageDeltaOutputTokens = 0;
+		const queuedChunks = [];
+		const producerState = { done: false };
+		let queuedChunkIndex = 0;
+		let bufferedTextLength = 0;
+		let consumerClosed = false;
+		let notifyConsumer;
+		let notifyProducer;
+		const notifyConsumerForChunk = () => {
+			notifyConsumer?.();
+			notifyConsumer = void 0;
+		};
+		const notifyProducerForSpace = () => {
+			notifyProducer?.();
+			notifyProducer = void 0;
+		};
+		const hasQueuedChunks = () => queuedChunkIndex < queuedChunks.length;
+		const getQueuedChunkCount = () => queuedChunks.length - queuedChunkIndex;
+		const isQueueAtCapacity = () => getQueuedChunkCount() >= MAX_STREAM_QUEUE_CHUNKS || bufferedTextLength >= MAX_STREAM_QUEUE_TEXT_CHARS;
+		const waitForNextChunk = async () => {
+			if (hasQueuedChunks() || producerState.done || producerState.error != null) return;
+			await new Promise((resolve) => {
+				notifyConsumer = resolve;
+			});
+		};
+		const waitForQueueSpace = async () => {
+			while (isQueueAtCapacity() && !consumerClosed && !isSignalAborted(options.signal)) await new Promise((resolve) => {
+				const signal = options.signal;
+				const onAbort = () => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve();
+				};
+				const onSpace = () => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve();
+				};
+				notifyProducer = onSpace;
+				signal?.addEventListener("abort", onAbort, { once: true });
+				if (isSignalAborted(signal)) onAbort();
+			});
+		};
+		const dequeue = () => {
+			if (!hasQueuedChunks()) return;
+			const queuedChunk = queuedChunks[queuedChunkIndex];
+			queuedChunkIndex++;
+			if (queuedChunkIndex > 128 && queuedChunkIndex * 2 >= queuedChunks.length) {
+				queuedChunks.splice(0, queuedChunkIndex);
+				queuedChunkIndex = 0;
+			}
+			return queuedChunk;
+		};
+		const enqueue = async (queuedChunk) => {
+			await waitForQueueSpace();
+			if (consumerClosed || isSignalAborted(options.signal)) {
+				stream.controller.abort();
+				throw new Error("AbortError: User aborted the request.");
+			}
+			queuedChunks.push(queuedChunk);
+			if (queuedChunk.smooth) bufferedTextLength += queuedChunk.textLength;
+			notifyConsumerForChunk();
+		};
+		const enqueueChunk = async ({ token, chunk, smooth }) => {
+			await enqueue({
+				token,
+				smooth,
+				textLength: smooth ? token.length : 0,
+				chunk: this.createGenerationChunk({
+					token,
+					chunk,
+					shouldStreamUsage
+				})
+			});
+		};
+		const enqueueTextChunks = (token, tokenType, chunk) => {
+			if (token === "") return Promise.resolve();
+			if (this._lc_stream_delay <= 0) return enqueueChunk({
+				token,
+				chunk,
+				smooth: false
+			});
+			const tokenChunks = splitStreamToken(token);
+			if (tokenChunks.length <= 1) return enqueueChunk({
+				token,
+				chunk,
+				smooth: true
+			});
+			let emittedUsage = false;
+			return tokenChunks.reduce(async (previous, currentToken) => {
+				await previous;
+				const newChunk = cloneChunk(currentToken, tokenType, chunk);
+				await enqueueChunk({
+					token: currentToken,
+					chunk: emittedUsage && newChunk.usage_metadata != null ? new AIMessageChunk(Object.assign({}, newChunk, { usage_metadata: void 0 })) : newChunk,
+					smooth: true
+				});
+				if (newChunk.usage_metadata != null && !emittedUsage) emittedUsage = true;
+			}, Promise.resolve());
+		};
+		const producer = (async () => {
+			try {
+				for await (const data of stream) {
+					if (isSignalAborted(options.signal)) {
+						stream.controller.abort();
+						throw new Error("AbortError: User aborted the request.");
+					}
+					const result = _makeMessageChunkFromAnthropicEvent(data, {
+						streamUsage: shouldStreamUsage,
+						coerceContentToString
+					});
+					if (!result) continue;
+					let { chunk } = result;
+					if (data.type === "message_delta") {
+						const incremental = withIncrementalMessageDeltaUsage(chunk, messageDeltaOutputTokens);
+						chunk = incremental.chunk;
+						messageDeltaOutputTokens = incremental.outputTokens;
+					}
+					const [token = "", tokenType] = extractToken(chunk);
+					if (!tokenType || tokenType === "input" || token === "" && (chunk.usage_metadata != null || chunk.id != null)) {
+						await enqueueChunk({
+							token,
+							chunk,
+							smooth: false
+						});
+						continue;
+					}
+					await enqueueTextChunks(token, tokenType, chunk);
+				}
+			} catch (error) {
+				producerState.error = error;
+			} finally {
+				producerState.done = true;
+				notifyConsumerForChunk();
+			}
+		})();
+		let hasEmittedText = false;
+		let lastVisibleTextAt;
+		let keepStreaming = true;
+		try {
+			while (keepStreaming) {
+				if (isSignalAborted(options.signal)) {
+					stream.controller.abort();
+					throw new Error("AbortError: User aborted the request.");
+				}
+				await waitForNextChunk();
+				const queuedChunk = dequeue();
+				if (!queuedChunk) {
+					if (producerState.error != null) throw producerState.error;
+					if (producerState.done) keepStreaming = false;
+					continue;
+				}
+				if (queuedChunk.smooth) {
+					bufferedTextLength = Math.max(0, bufferedTextLength - queuedChunk.textLength);
+					notifyProducerForSpace();
+					await waitForStreamDelay(getCadencedStreamDelay({
+						targetDelay: hasEmittedText ? this._lc_stream_delay : 0,
+						lastVisibleTextAt,
+						now: Date.now()
+					}), options.signal);
+					if (isSignalAborted(options.signal)) {
+						stream.controller.abort();
+						throw new Error("AbortError: User aborted the request.");
+					}
+					hasEmittedText = true;
+					lastVisibleTextAt = Date.now();
+				} else notifyProducerForSpace();
+				yield queuedChunk.chunk;
+				await runManager?.handleLLMNewToken(queuedChunk.token, void 0, void 0, void 0, void 0, { chunk: queuedChunk.chunk });
+			}
+		} finally {
+			consumerClosed = true;
+			if (!producerState.done) {
+				stream.controller.abort();
+				notifyProducerForSpace();
+			}
+			await producer;
+			this.resetTokenEvents();
+		}
+	}
+};
+//#endregion
+export { CustomAnthropic };
 
-export { CustomAnthropic, _documentsInParams };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map