@librechat/agents 3.2.61 → 3.2.62

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

@@ -1,5 +1,6 @@
 import { OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER, STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY } from "../../tools/streamedToolCallSeals.mjs";
 import { _convertMessagesToOpenAIParams, isReasoningModel } from "./utils/index.mjs";
+import { dropRepeatedScalarMetadata } from "./streamMetadata.mjs";
 import { AIMessage, AIMessageChunk, isAIMessage } from "@langchain/core/messages";
 import { AzureChatOpenAI, AzureChatOpenAICompletions, AzureChatOpenAIResponses, ChatOpenAI, ChatOpenAICompletions, ChatOpenAIResponses, OpenAIClient, getEndpoint, getHeadersWithUserAgent } from "@langchain/openai";
 import { AzureOpenAI } from "openai";
@@ -35,6 +36,166 @@ function normalizeHeaders(headers) {
 	});
 	return Object.fromEntries(output.entries());
 }
+const CACHE_WRITE_METADATA_KEY = "__librechat_cache_write_tokens";
+function applyManagedRequestParams(params, fields) {
+	return {
+		...params,
+		...fields.promptCacheExplicit === true && { prompt_cache_options: {
+			mode: "explicit",
+			ttl: "30m"
+		} },
+		...fields.safetyIdentifier != null && { safety_identifier: fields.safetyIdentifier }
+	};
+}
+function isCacheableChatPart(part) {
+	if (typeof part !== "object" || part == null || !("type" in part)) return false;
+	return part.type === "text" || part.type === "image_url" || part.type === "input_audio" || part.type === "file" || part.type === "refusal";
+}
+function canAddChatBreakpoint(message) {
+	if (message.role !== "system" && message.role !== "developer" && message.role !== "user" && message.role !== "assistant" && message.role !== "tool") return false;
+	if (typeof message.content === "string") return message.content.length > 0;
+	return Array.isArray(message.content) && message.content.some((part) => isCacheableChatPart(part));
+}
+function addChatBreakpoint(message) {
+	if (!canAddChatBreakpoint(message)) return message;
+	if (typeof message.content === "string") return {
+		...message,
+		content: [{
+			type: "text",
+			text: message.content,
+			prompt_cache_breakpoint: { mode: "explicit" }
+		}]
+	};
+	if (!Array.isArray(message.content) || message.content.length === 0) return message;
+	const content = [...message.content];
+	let index = content.length - 1;
+	while (index >= 0 && !isCacheableChatPart(content[index])) index--;
+	if (index < 0) return message;
+	content[index] = {
+		...content[index],
+		prompt_cache_breakpoint: { mode: "explicit" }
+	};
+	return {
+		...message,
+		content
+	};
+}
+function selectCacheBreakpointIndexes(roles, cacheable) {
+	let instructionIndex = -1;
+	let latestUserIndex = -1;
+	for (let index = 0; index < roles.length; index++) {
+		const role = roles[index];
+		if ((role === "system" || role === "developer") && cacheable[index]) instructionIndex = index;
+		if (role === "user") latestUserIndex = index;
+	}
+	const indexes = /* @__PURE__ */ new Set();
+	if (instructionIndex >= 0) indexes.add(instructionIndex);
+	for (let index = latestUserIndex - 1; index >= 0; index--) if (cacheable[index]) {
+		indexes.add(index);
+		break;
+	}
+	return [...indexes];
+}
+/** @internal */
+function addChatCacheBreakpoints(messages) {
+	const indexes = new Set(selectCacheBreakpointIndexes(messages.map((message) => message.role), messages.map((message) => canAddChatBreakpoint(message))));
+	return messages.map((message, index) => indexes.has(index) ? addChatBreakpoint(message) : message);
+}
+function isResponseMessage(item) {
+	return item.type === "message";
+}
+/** Only `input_text`/`input_image`/`input_file` accept a Responses breakpoint;
+*  `output_text`/`refusal` (replayed assistant blocks) are rejected with a 400. */
+function isCacheableResponsePart(part) {
+	if (typeof part !== "object" || part == null || !("type" in part)) return false;
+	return part.type === "input_text" || part.type === "input_image" || part.type === "input_file";
+}
+function addResponseBreakpoint(item) {
+	if (!isResponseMessage(item)) return item;
+	const rawContent = item.content;
+	if (typeof rawContent === "string") {
+		if (rawContent.length === 0) return item;
+		return {
+			...item,
+			content: [{
+				type: "input_text",
+				text: rawContent,
+				prompt_cache_breakpoint: { mode: "explicit" }
+			}]
+		};
+	}
+	if (!Array.isArray(rawContent) || rawContent.length === 0) return item;
+	const content = [...rawContent];
+	let index = content.length - 1;
+	while (index >= 0 && !isCacheableResponsePart(content[index])) index--;
+	if (index < 0) return item;
+	content[index] = {
+		...content[index],
+		prompt_cache_breakpoint: { mode: "explicit" }
+	};
+	return {
+		...item,
+		content
+	};
+}
+/** @internal */
+function addResponseCacheBreakpoints(input) {
+	if (!Array.isArray(input)) return input;
+	const indexes = new Set(selectCacheBreakpointIndexes(input.map((item) => isResponseMessage(item) ? item.role : void 0), input.map((item) => {
+		if (!isResponseMessage(item)) return false;
+		/** Only input roles take a Responses breakpoint. Assistant/tool turns
+		*  carry output content (string or output_text) that the API rejects
+		*  under an input marker, so they're never eligible. */
+		if (item.role !== "system" && item.role !== "developer" && item.role !== "user") return false;
+		const content = item.content;
+		return typeof content === "string" ? content.length > 0 : Array.isArray(content) && content.some((part) => isCacheableResponsePart(part));
+	})));
+	return input.map((item, index) => indexes.has(index) ? addResponseBreakpoint(item) : item);
+}
+/** @internal */
+function shouldIncludeEncryptedReasoning(model, params) {
+	const reasoningContext = params.reasoning?.context;
+	return /^gpt-5\.6(?:-|$)/i.test(model) && (params.store === false || reasoningContext !== "current_turn");
+}
+function getCacheWriteTokens(message) {
+	const responseMetadata = message.response_metadata;
+	const reported = responseMetadata.usage?.input_tokens_details.cache_write_tokens;
+	if (reported != null) return reported;
+	const serialized = responseMetadata.metadata?.[CACHE_WRITE_METADATA_KEY];
+	if (serialized == null) return;
+	const parsed = Number(serialized);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function attachCacheWriteUsage(message) {
+	const cacheWriteTokens = getCacheWriteTokens(message);
+	if (cacheWriteTokens == null || !isAIMessage(message) || message.usage_metadata == null) return;
+	message.usage_metadata.input_token_details = {
+		...message.usage_metadata.input_token_details,
+		cache_creation: cacheWriteTokens
+	};
+	const responseMetadata = message.response_metadata;
+	if (responseMetadata.metadata?.[CACHE_WRITE_METADATA_KEY] == null) return;
+	const metadata = { ...responseMetadata.metadata };
+	delete metadata[CACHE_WRITE_METADATA_KEY];
+	message.response_metadata = {
+		...message.response_metadata,
+		metadata
+	};
+}
+function attachCacheWriteMetadata(response) {
+	const cacheWriteTokens = response.usage?.input_tokens_details.cache_write_tokens;
+	if (cacheWriteTokens == null) return response;
+	return {
+		...response,
+		metadata: {
+			...response.metadata ?? {},
+			[CACHE_WRITE_METADATA_KEY]: String(cacheWriteTokens)
+		}
+	};
+}
+function isResponsesStream(result) {
+	return Symbol.asyncIterator in result;
+}
 function createUsageMetadata(usage) {
 	const usageMetadata = {
 		input_tokens: usage?.prompt_tokens ?? 0,
@@ -207,7 +368,7 @@ function getStreamChunkTokenIndices(chunk) {
 		completion
 	};
 }
-async function* delayStreamChunks(chunks, delay, signal, runManager) {
+async function* delayStreamChunks(chunks, delay, signal, runManager, seenScalarMetadata) {
 	let lastYieldedAt;
 	for await (const chunk of chunks) {
 		const outputChunks = delay != null && delay > 0 ? splitTextGenerationChunk(chunk) : [chunk];
@@ -220,6 +381,7 @@ async function* delayStreamChunks(chunks, delay, signal, runManager) {
 			}
 			signal?.throwIfAborted();
 			lastYieldedAt = Date.now();
+			if (seenScalarMetadata != null) dropRepeatedScalarMetadata(outputChunk, seenScalarMetadata);
 			await emitStreamChunkCallback(outputChunk, runManager);
 			signal?.throwIfAborted();
 			yield outputChunk;
@@ -342,11 +504,21 @@ var LibreChatOpenAICompletions = class extends ChatOpenAICompletions {
 	includeReasoningContent;
 	includeReasoningDetails;
 	convertReasoningDetailsToContent;
+	promptCacheExplicit;
+	safetyIdentifier;
 	constructor(fields) {
 		super(fields);
 		this.includeReasoningContent = fields?.includeReasoningContent;
 		this.includeReasoningDetails = fields?.includeReasoningDetails;
 		this.convertReasoningDetailsToContent = fields?.convertReasoningDetailsToContent;
+		this.promptCacheExplicit = fields?.promptCacheExplicit;
+		this.safetyIdentifier = fields?.safety_identifier;
+	}
+	invocationParams(options, extra) {
+		return applyManagedRequestParams(super.invocationParams(options, extra), {
+			promptCacheExplicit: this.promptCacheExplicit,
+			safetyIdentifier: this.safetyIdentifier
+		});
 	}
 	_getReasoningParams(options) {
 		return getReasoningParams(this.reasoning, options);
@@ -355,7 +527,10 @@ var LibreChatOpenAICompletions = class extends ChatOpenAICompletions {
 		return getCustomOpenAIClientOptions(this, options);
 	}
 	async completionWithRetry(request, requestOptions) {
-		return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
+		return completionWithFilteredOpenAIStream(this.promptCacheExplicit === true ? {
+			...request,
+			messages: addChatCacheBreakpoints(request.messages)
+		} : request, requestOptions, super.completionWithRetry.bind(this));
 	}
 	_convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
 		const message = attachLibreChatDeltaFields(super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole), delta);
@@ -535,6 +710,40 @@ var LibreChatOpenAICompletions = class extends ChatOpenAICompletions {
 	}
 };
 var LibreChatOpenAIResponses = class extends ChatOpenAIResponses {
+	promptCacheExplicit;
+	safetyIdentifier;
+	constructor(fields) {
+		super(fields);
+		this.promptCacheExplicit = fields?.promptCacheExplicit;
+		this.safetyIdentifier = fields?.safety_identifier;
+	}
+	invocationParams(options) {
+		const params = applyManagedRequestParams(super.invocationParams(options), {
+			promptCacheExplicit: this.promptCacheExplicit,
+			safetyIdentifier: this.safetyIdentifier
+		});
+		if (shouldIncludeEncryptedReasoning(this.model, params)) params.include = [...new Set([...params.include ?? [], "reasoning.encrypted_content"])];
+		return params;
+	}
+	async completionWithRetry(request, requestOptions) {
+		const managedRequest = {
+			...request,
+			input: this.promptCacheExplicit === true ? addResponseCacheBreakpoints(request.input) : request.input
+		};
+		const result = await super.completionWithRetry(managedRequest, requestOptions);
+		return isResponsesStream(result) ? result : attachCacheWriteMetadata(result);
+	}
+	async _generate(messages, options, runManager) {
+		const result = await super._generate(messages, options, runManager);
+		for (const generation of result.generations) attachCacheWriteUsage(generation.message);
+		return result;
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		for await (const chunk of super._streamResponseChunks(messages, options, runManager)) {
+			attachCacheWriteUsage(chunk.message);
+			yield chunk;
+		}
+	}
 	_getReasoningParams(options) {
 		return getReasoningParams(this.reasoning, options);
 	}
@@ -543,6 +752,19 @@ var LibreChatOpenAIResponses = class extends ChatOpenAIResponses {
 	}
 };
 var LibreChatAzureOpenAICompletions = class extends AzureChatOpenAICompletions {
+	promptCacheExplicit;
+	safetyIdentifier;
+	constructor(fields) {
+		super(fields);
+		this.promptCacheExplicit = fields?.promptCacheExplicit;
+		this.safetyIdentifier = fields?.safety_identifier;
+	}
+	invocationParams(options, extra) {
+		return applyManagedRequestParams(super.invocationParams(options, extra), {
+			promptCacheExplicit: this.promptCacheExplicit,
+			safetyIdentifier: this.safetyIdentifier
+		});
+	}
 	_getReasoningParams(options) {
 		return getGatedReasoningParams(this.model, this.reasoning, options);
 	}
@@ -601,10 +823,47 @@ var LibreChatAzureOpenAICompletions = class extends AzureChatOpenAICompletions {
 		return requestOptions;
 	}
 	async completionWithRetry(request, requestOptions) {
-		return completionWithFilteredOpenAIStream(request, requestOptions, super.completionWithRetry.bind(this));
+		return completionWithFilteredOpenAIStream(this.promptCacheExplicit === true ? {
+			...request,
+			messages: addChatCacheBreakpoints(request.messages)
+		} : request, requestOptions, super.completionWithRetry.bind(this));
 	}
 };
 var LibreChatAzureOpenAIResponses = class extends AzureChatOpenAIResponses {
+	promptCacheExplicit;
+	safetyIdentifier;
+	constructor(fields) {
+		super(fields);
+		this.promptCacheExplicit = fields?.promptCacheExplicit;
+		this.safetyIdentifier = fields?.safety_identifier;
+	}
+	invocationParams(options) {
+		const params = applyManagedRequestParams(super.invocationParams(options), {
+			promptCacheExplicit: this.promptCacheExplicit,
+			safetyIdentifier: this.safetyIdentifier
+		});
+		if (shouldIncludeEncryptedReasoning(this.model, params)) params.include = [...new Set([...params.include ?? [], "reasoning.encrypted_content"])];
+		return params;
+	}
+	async completionWithRetry(request, requestOptions) {
+		const managedRequest = {
+			...request,
+			input: this.promptCacheExplicit === true ? addResponseCacheBreakpoints(request.input) : request.input
+		};
+		const result = await super.completionWithRetry(managedRequest, requestOptions);
+		return isResponsesStream(result) ? result : attachCacheWriteMetadata(result);
+	}
+	async _generate(messages, options, runManager) {
+		const result = await super._generate(messages, options, runManager);
+		for (const generation of result.generations) attachCacheWriteUsage(generation.message);
+		return result;
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		for await (const chunk of super._streamResponseChunks(messages, options, runManager)) {
+			attachCacheWriteUsage(chunk.message);
+			yield chunk;
+		}
+	}
 	_getReasoningParams(options) {
 		return getGatedReasoningParams(this.model, this.reasoning, options);
 	}
@@ -703,7 +962,15 @@ var ChatOpenAI$1 = class extends ChatOpenAI {
 		return this.getReasoningParams(options);
 	}
 	async *_streamResponseChunks(messages, options, runManager) {
-		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager, /* @__PURE__ */ new Map());
+	}
+	/**
+	* Raw variant that skips scalar-metadata de-duplication. Used by subclasses
+	* (e.g. `ChatOpenRouter`) that read `finish_reason` as a control signal and
+	* must de-duplicate only after their own finalization.
+	*/
+	_streamRawResponseChunks(messages, options, runManager) {
+		return delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
 	}
 };
 var AzureChatOpenAI$1 = class extends AzureChatOpenAI {
@@ -777,7 +1044,7 @@ var AzureChatOpenAI$1 = class extends AzureChatOpenAI {
 		return requestOptions;
 	}
 	async *_streamResponseChunks(messages, options, runManager) {
-		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager, /* @__PURE__ */ new Map());
 	}
 };
 var ChatDeepSeek$1 = class extends ChatDeepSeek {
@@ -848,7 +1115,7 @@ var ChatDeepSeek$1 = class extends ChatDeepSeek {
 		};
 	}
 	async *_streamResponseChunks(messages, options, runManager) {
-		yield* delayStreamChunks(this._streamResponseChunksWithReasoning(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+		yield* delayStreamChunks(this._streamResponseChunksWithReasoning(messages, options, void 0), this._lc_stream_delay, options.signal, runManager, /* @__PURE__ */ new Map());
 	}
 	/** Parses raw `<think>` fallback tags across chunks and emits sanitized DeepSeek stream chunks. */
 	async *_streamResponseChunksWithReasoning(messages, options, runManager) {
@@ -1081,7 +1348,7 @@ var ChatXAI$1 = class extends ChatXAI {
 		};
 	}
 	async *_streamResponseChunks(messages, options, runManager) {
-		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager);
+		yield* delayStreamChunks(super._streamResponseChunks(messages, options, void 0), this._lc_stream_delay, options.signal, runManager, /* @__PURE__ */ new Map());
 	}
 };
 //#endregion