@librechat/agents 3.3.10 → 3.3.11

package/dist/cjs/messages/core.cjs

@@ -310,38 +310,593 @@ function cloneAIMessageWithContent(message, content) {
 		...lcKwargs,
 		value: {
 			...lcKwargs.value,
-			content
+			...message.response_metadata.output_version === "v1" ? {
+				content: void 0,
+				contentBlocks: content
+			} : { content }
 		}
 	};
 	return Object.create(Object.getPrototypeOf(message), descriptors);
 }
+function cloneAIMessageWithResponsesReplayState(message, content, id, additionalKwargs, responseMetadata) {
+	const descriptors = Object.getOwnPropertyDescriptors(message);
+	const replacements = {
+		content,
+		id,
+		additional_kwargs: additionalKwargs,
+		response_metadata: responseMetadata
+	};
+	for (const [key, value] of Object.entries(replacements)) {
+		const descriptor = descriptors[key];
+		descriptors[key] = {
+			configurable: descriptor?.configurable ?? true,
+			enumerable: descriptor?.enumerable ?? true,
+			value,
+			writable: descriptor?.writable ?? true
+		};
+	}
+	const lcKwargs = descriptors.lc_kwargs;
+	if (lcKwargs != null && "value" in lcKwargs && typeof lcKwargs.value === "object" && lcKwargs.value != null) descriptors.lc_kwargs = {
+		...lcKwargs,
+		value: {
+			...lcKwargs.value,
+			...replacements,
+			...responseMetadata.output_version === "v1" ? {
+				content: void 0,
+				contentBlocks: content
+			} : {}
+		}
+	};
+	return Object.create(Object.getPrototypeOf(message), descriptors);
+}
+function hasReplayableEncryptedReasoning(reasoning) {
+	if (reasoning == null || typeof reasoning !== "object") return false;
+	const item = reasoning;
+	return item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0 && Array.isArray(item.summary) && typeof item.encrypted_content === "string" && item.encrypted_content.length > 0 && (item.status === void 0 || item.status === "completed" || item.status === "incomplete");
+}
+const OPENAI_RESPONSES_REPLAY_POSITIONS_KEY = "__openai_responses_replay_positions__";
+function isProviderGeneratedImageBlock(block, generatedImages, allowDataFallback = true) {
+	if (typeof block.id === "string" && block.id.length > 0) return generatedImages.ids.has(block.id);
+	return allowDataFallback && typeof block.data === "string" && generatedImages.data.has(block.data) && block.metadata != null && typeof block.metadata === "object" && block.metadata.status === "completed";
+}
+function hasMeaningfulServerToolOutput(output) {
+	if (output == null || output === "") return false;
+	if (Array.isArray(output)) return output.length > 0;
+	if (typeof output !== "object") return true;
+	try {
+		return Object.keys(output).length > 0;
+	} catch {
+		return false;
+	}
+}
+function createServerToolResultExtras(toolName) {
+	return { librechatServerToolResult: { ...toolName != null ? { toolName } : {} } };
+}
+function createNeutralServerToolResult(output, status, maxChars, toolName) {
+	if (!hasMeaningfulServerToolOutput(output)) return;
+	return {
+		type: "text",
+		text: require_toolContent.serializeToolContentBounded({ serverToolResult: {
+			librechatResponsesReplay: true,
+			...toolName != null ? { toolName } : {},
+			status,
+			output
+		} }, maxChars),
+		extras: createServerToolResultExtras(toolName)
+	};
+}
+function isCompleteToolStreamContentBlock(block) {
+	if (block == null || typeof block !== "object") return true;
+	try {
+		if ((0, node_util_types.isProxy)(block)) return false;
+		const type = Object.getOwnPropertyDescriptor(block, "type");
+		if (type == null) return true;
+		if (type.enumerable !== true || !("value" in type)) return false;
+		if (type.value !== "text") return true;
+		const text = Object.getOwnPropertyDescriptor(block, "text");
+		return text?.enumerable === true && "value" in text && typeof text.value === "string" && text.value !== "";
+	} catch {
+		return false;
+	}
+}
+function projectPreemptedResponsesV1Content(content, reasoning, maxChars, replayProjection, generatedImages, originalImages, serverToolResults, positionedServerToolResultIds, reasoningPosition, textPositions, messagePositions) {
+	if (!Array.isArray(content)) return {
+		content,
+		preservedServerToolResult: false
+	};
+	const contentBlocks = content;
+	const encryptedReasoning = replayProjection === "native" && hasReplayableEncryptedReasoning(reasoning) ? reasoning : void 0;
+	const positionedReasoning = encryptedReasoning != null && reasoningPosition != null ? {
+		block: {
+			type: "non_standard",
+			value: encryptedReasoning
+		},
+		...reasoningPosition,
+		subIndex: 0
+	} : void 0;
+	const projected = [];
+	let changed = false;
+	let hasEncryptedReasoning = false;
+	let preservedServerToolResult = false;
+	let reasoningInsertionIndex;
+	let generatedImageIndex = 0;
+	let originalImageIndex = 0;
+	let reasoningPending = positionedReasoning;
+	let serverToolResultIndex = 0;
+	let sourceTextIndex = 0;
+	const serverToolNamesByCallId = /* @__PURE__ */ new Map();
+	const appendOriginalImages = (throughTextIndex) => {
+		if (replayProjection !== "native" || originalImages == null) return;
+		while (originalImageIndex < originalImages.blocks.length) {
+			const positionedImage = originalImages.blocks[originalImageIndex];
+			if (throughTextIndex != null && positionedImage.textIndex > throughTextIndex) return;
+			originalImageIndex++;
+			if (generatedImages != null && isProviderGeneratedImageBlock(positionedImage.block, generatedImages, false)) continue;
+			projected.push(positionedImage.block);
+			changed = true;
+		}
+	};
+	const appendReplayBlocks = (throughTextIndex, beforeOutputIndex) => {
+		for (;;) {
+			const generatedImage = generatedImages?.blocks[generatedImageIndex];
+			const serverToolResult = serverToolResults?.[serverToolResultIndex];
+			const candidates = [];
+			if (generatedImage != null) candidates.push({
+				kind: "generatedImage",
+				value: generatedImage
+			});
+			if (serverToolResult != null) candidates.push({
+				kind: "serverToolResult",
+				value: serverToolResult
+			});
+			if (reasoningPending != null) candidates.push({
+				kind: "reasoning",
+				value: reasoningPending
+			});
+			if (candidates.length === 0) return;
+			candidates.sort((a, b) => comparePositionedResponsesReplayBlocks(a.value, b.value));
+			const selected = candidates[0];
+			const positionedResult = selected.value;
+			if (throughTextIndex != null && (positionedResult.textIndex == null || positionedResult.textIndex > throughTextIndex)) return;
+			if (beforeOutputIndex != null && positionedResult.outputIndex >= beforeOutputIndex) return;
+			if (selected.kind === "generatedImage") generatedImageIndex++;
+			else if (selected.kind === "serverToolResult") serverToolResultIndex++;
+			else reasoningPending = void 0;
+			if (replayProjection === "fallback" && positionedResult.block.type === "text") projected.push({
+				type: "text",
+				text: positionedResult.block.text
+			});
+			else projected.push(positionedResult.block);
+			changed = true;
+			preservedServerToolResult ||= selected.kind === "serverToolResult";
+		}
+	};
+	const appendPositionedOriginalImages = (throughTextIndex) => {
+		const nextOriginalImage = originalImages?.blocks[originalImageIndex];
+		if (nextOriginalImage == null || throughTextIndex != null && nextOriginalImage.textIndex > throughTextIndex) return;
+		const followingTextPosition = textPositions?.[nextOriginalImage.textIndex];
+		const imageOnlyMessagePosition = originalImages?.textCount === 0 ? messagePositions?.[0] : void 0;
+		const outputBoundary = followingTextPosition ?? imageOnlyMessagePosition;
+		if (outputBoundary != null) appendReplayBlocks(nextOriginalImage.textIndex, outputBoundary.outputIndex);
+		appendOriginalImages(throughTextIndex);
+	};
+	for (let i = 0; i < contentBlocks.length; i++) {
+		const block = contentBlocks[i];
+		if (!isCompleteToolStreamContentBlock(block)) {
+			changed = true;
+			continue;
+		}
+		if (block.type === "reasoning") {
+			reasoningInsertionIndex ??= projected.length;
+			changed = true;
+			continue;
+		}
+		if (block.type === "non_standard") {
+			if (replayProjection === "native" && !hasEncryptedReasoning && hasReplayableEncryptedReasoning(block.value)) {
+				hasEncryptedReasoning = true;
+				if (positionedReasoning == null) projected.push(block);
+				else changed = true;
+			} else changed = true;
+			continue;
+		}
+		if (block.type === "text") {
+			appendPositionedOriginalImages(sourceTextIndex);
+			appendReplayBlocks(sourceTextIndex);
+			if (replayProjection === "fallback") {
+				projected.push({
+					type: "text",
+					text: block.text
+				});
+				changed = true;
+			} else projected.push(block);
+			sourceTextIndex++;
+			continue;
+		}
+		if (originalImages != null && sourceTextIndex >= originalImages.textCount) appendPositionedOriginalImages();
+		if (block.type === "server_tool_call" || block.type === "server_tool_call_chunk") {
+			if (typeof block.id === "string" && block.id.length > 0 && typeof block.name === "string" && block.name.length > 0) serverToolNamesByCallId.set(block.id, block.name);
+			changed = true;
+			continue;
+		}
+		if (block.type === "server_tool_call_result") {
+			if (positionedServerToolResultIds?.has(block.toolCallId) === true) {
+				changed = true;
+				continue;
+			}
+			const result = createNeutralServerToolResult(block.output, block.status, maxChars, serverToolNamesByCallId.get(block.toolCallId));
+			changed = true;
+			if (result != null) {
+				projected.push(replayProjection === "fallback" ? {
+					type: "text",
+					text: result.text
+				} : result);
+				preservedServerToolResult = true;
+			}
+			continue;
+		}
+		if (block.type === "image") {
+			if (replayProjection === "fallback" || generatedImages != null && isProviderGeneratedImageBlock(block, generatedImages)) {
+				changed = true;
+				continue;
+			}
+		}
+		projected.push(block);
+	}
+	if (encryptedReasoning != null && !hasEncryptedReasoning && positionedReasoning == null) {
+		const reasoningBlock = {
+			type: "non_standard",
+			value: encryptedReasoning
+		};
+		projected.splice(reasoningInsertionIndex ?? 0, 0, reasoningBlock);
+		changed = true;
+	}
+	appendPositionedOriginalImages();
+	appendReplayBlocks();
+	return {
+		content: changed ? require_langchain.toLangChainContent(projected) : content,
+		preservedServerToolResult
+	};
+}
+function getAuthoritativeResponsesOutput(message) {
+	const responseOutput = message.response_metadata.output;
+	const toolOutputs = message.additional_kwargs.tool_outputs;
+	if (Array.isArray(responseOutput) && responseOutput.length > 0) return responseOutput;
+	return Array.isArray(toolOutputs) ? toolOutputs : [];
+}
+function isResponsesReplayPosition(value) {
+	if (value == null || typeof value !== "object") return false;
+	const position = value;
+	return (position.kind === "message" || position.kind === "output" || position.kind === "reasoning" || position.kind === "text") && typeof position.itemId === "string" && position.itemId.length > 0 && typeof position.outputIndex === "number" && Number.isSafeInteger(position.outputIndex) && position.outputIndex >= 0 && (position.contentIndex == null || typeof position.contentIndex === "number" && Number.isSafeInteger(position.contentIndex) && position.contentIndex >= 0);
+}
+function getGeneratedImageMimeType(data) {
+	const bytes = Buffer.from(data.slice(0, 16), "base64");
+	if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+	if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
+	return "image/png";
+}
+function getResponsesReplayItemKey(item) {
+	if (typeof item.id === "string" && item.id.length > 0) return item.id;
+	return typeof item.call_id === "string" && item.call_id.length > 0 ? item.call_id : void 0;
+}
+function comparePositionedResponsesReplayBlocks(a, b) {
+	return (a.textIndex ?? Number.MAX_SAFE_INTEGER) - (b.textIndex ?? Number.MAX_SAFE_INTEGER) || a.outputIndex - b.outputIndex || a.subIndex - b.subIndex;
+}
+const RESPONSES_REPLAY_OUTPUT_TOOL_NAMES = {
+	apply_patch_call_output: "apply_patch",
+	local_shell_call_output: "local_shell",
+	shell_call_output: "shell"
+};
+function getResponsesReplayArtifacts(output, maxChars, replayProjection, replayPositionValue) {
+	const blocks = [];
+	const data = /* @__PURE__ */ new Set();
+	const ids = /* @__PURE__ */ new Set();
+	const emittedData = /* @__PURE__ */ new Set();
+	const emittedIds = /* @__PURE__ */ new Set();
+	const positionedServerToolResultIds = /* @__PURE__ */ new Set();
+	const rawOutputIndices = /* @__PURE__ */ new Map();
+	const serverToolResults = [];
+	const replayPositions = Array.isArray(replayPositionValue) ? replayPositionValue.filter(isResponsesReplayPosition) : [];
+	const authoritativeOutputIndicesByItemId = /* @__PURE__ */ new Map();
+	const messagePositionsByKey = /* @__PURE__ */ new Map();
+	const outputPositionsByItemId = /* @__PURE__ */ new Map();
+	const textPositionsByKey = /* @__PURE__ */ new Map();
+	for (const position of replayPositions) {
+		if (position.kind === "output" || position.kind === "reasoning") {
+			outputPositionsByItemId.set(position.itemId, position);
+			continue;
+		}
+		if (position.kind === "message") {
+			messagePositionsByKey.set(`${position.itemId}:${position.outputIndex}`, position);
+			continue;
+		}
+		textPositionsByKey.set(`${position.itemId}:${position.outputIndex}:${position.contentIndex ?? 0}`, position);
+	}
+	let hasAuthoritativeMessage = false;
+	for (let outputIndex = 0; outputIndex < output.length; outputIndex++) {
+		const item = output[outputIndex];
+		if (item == null || typeof item !== "object") continue;
+		const itemRecord = item;
+		rawOutputIndices.set(itemRecord, outputIndex);
+		const itemKey = getResponsesReplayItemKey(itemRecord);
+		if (itemKey != null) authoritativeOutputIndicesByItemId.set(itemKey, outputIndex);
+		if (!("type" in item) || item.type !== "message") continue;
+		hasAuthoritativeMessage = true;
+		const messageItemId = "id" in item && typeof item.id === "string" ? item.id : `message-${outputIndex}`;
+		messagePositionsByKey.set(`${messageItemId}:${outputIndex}`, {
+			itemId: messageItemId,
+			kind: "message",
+			outputIndex
+		});
+		if (!("content" in item) || !Array.isArray(item.content)) continue;
+		for (let contentIndex = 0; contentIndex < item.content.length; contentIndex++) {
+			const content = item.content[contentIndex];
+			if (content == null || typeof content !== "object" || !("type" in content) || content.type !== "output_text" || !("text" in content) || typeof content.text !== "string" || content.text.length === 0) continue;
+			const itemId = "id" in item && typeof item.id === "string" ? item.id : `message-${outputIndex}`;
+			textPositionsByKey.set(`${itemId}:${outputIndex}:${contentIndex}`, {
+				contentIndex,
+				itemId,
+				kind: "text",
+				outputIndex
+			});
+		}
+	}
+	if (hasAuthoritativeMessage) for (const [itemId, outputIndex] of authoritativeOutputIndicesByItemId) outputPositionsByItemId.set(itemId, {
+		itemId,
+		kind: "output",
+		outputIndex
+	});
+	const textPositions = [...textPositionsByKey.values()].sort((a, b) => a.outputIndex - b.outputIndex || (a.contentIndex ?? 0) - (b.contentIndex ?? 0));
+	const messagePositions = [...messagePositionsByKey.values()].sort((a, b) => a.outputIndex - b.outputIndex);
+	const textCountBeforeOutputIndex = /* @__PURE__ */ new Map();
+	const positionedOutputIndexSet = /* @__PURE__ */ new Set();
+	for (const position of outputPositionsByItemId.values()) positionedOutputIndexSet.add(position.outputIndex);
+	if (hasAuthoritativeMessage) for (const outputIndex of rawOutputIndices.values()) positionedOutputIndexSet.add(outputIndex);
+	const positionedOutputIndices = [...positionedOutputIndexSet].sort((a, b) => a - b);
+	let textPositionIndex = 0;
+	for (const outputIndex of positionedOutputIndices) {
+		while (textPositionIndex < textPositions.length && textPositions[textPositionIndex].outputIndex < outputIndex) textPositionIndex++;
+		textCountBeforeOutputIndex.set(outputIndex, textPositionIndex);
+	}
+	const positionsByItemId = /* @__PURE__ */ new Map();
+	for (const [itemId, position] of outputPositionsByItemId) positionsByItemId.set(itemId, {
+		outputIndex: position.outputIndex,
+		textIndex: textCountBeforeOutputIndex.get(position.outputIndex) ?? 0
+	});
+	const getPosition = (item) => {
+		const itemId = getResponsesReplayItemKey(item);
+		const position = itemId != null ? positionsByItemId.get(itemId) : void 0;
+		if (position == null) {
+			const rawOutputIndex = rawOutputIndices.get(item);
+			return {
+				outputIndex: rawOutputIndex ?? Number.MAX_SAFE_INTEGER,
+				...hasAuthoritativeMessage && rawOutputIndex != null ? { textIndex: textCountBeforeOutputIndex.get(rawOutputIndex) ?? 0 } : {}
+			};
+		}
+		return position;
+	};
+	const pushServerToolResult = (block, item, subIndex = 0) => {
+		if (block == null) return;
+		const itemId = getResponsesReplayItemKey(item);
+		if (itemId != null) positionedServerToolResultIds.add(itemId);
+		serverToolResults.push({
+			block,
+			...getPosition(item),
+			subIndex
+		});
+	};
+	for (const item of output) {
+		if (item == null || typeof item !== "object" || !("type" in item)) continue;
+		if (item.type === "code_interpreter_call") {
+			if (!("outputs" in item) || !Array.isArray(item.outputs) || !("status" in item)) continue;
+			const resultStatus = item.status === "completed" ? "success" : "error";
+			const returnCode = item.status === "completed" ? 0 : 1;
+			for (let resultIndex = 0; resultIndex < item.outputs.length; resultIndex++) {
+				const result = item.outputs[resultIndex];
+				if (result == null || typeof result !== "object" || !("type" in result)) continue;
+				if (result.type === "logs" && "logs" in result && typeof result.logs === "string") {
+					pushServerToolResult(createNeutralServerToolResult({
+						type: "code_interpreter_output",
+						returnCode,
+						stdout: result.logs
+					}, resultStatus, maxChars, "code_interpreter"), item, resultIndex);
+					continue;
+				}
+				if (result.type !== "image" || !("url" in result) || typeof result.url !== "string" || result.url.length === 0) continue;
+				const resultUrl = result.url;
+				if (replayProjection === "native" && resultUrl.startsWith("data:image/")) {
+					pushServerToolResult({
+						type: "image",
+						url: resultUrl,
+						extras: createServerToolResultExtras("code_interpreter")
+					}, item, resultIndex);
+					continue;
+				}
+				pushServerToolResult(createNeutralServerToolResult({
+					type: "code_interpreter_image",
+					url: resultUrl
+				}, resultStatus, maxChars, "code_interpreter"), item, resultIndex);
+			}
+			continue;
+		}
+		if (item.type === "file_search_call") {
+			pushServerToolResult(createNeutralServerToolResult("results" in item && Array.isArray(item.results) ? { results: item.results } : void 0, "status" in item && item.status === "completed" ? "success" : "error", maxChars, "file_search"), item);
+			continue;
+		}
+		if (item.type === "web_search_call") {
+			pushServerToolResult(createNeutralServerToolResult({
+				..."action" in item ? { action: item.action } : {},
+				..."results" in item && Array.isArray(item.results) ? { results: item.results } : {}
+			}, "status" in item && item.status === "completed" ? "success" : "error", maxChars, "web_search"), item);
+			continue;
+		}
+		if (item.type === "tool_search_output") {
+			pushServerToolResult(createNeutralServerToolResult("tools" in item && Array.isArray(item.tools) ? { tools: item.tools } : void 0, "status" in item && item.status === "completed" ? "success" : "error", maxChars, "tool_search"), item);
+			continue;
+		}
+		if (item.type === "mcp_list_tools") {
+			const hasError = "error" in item && typeof item.error === "string" && item.error.length > 0;
+			pushServerToolResult(createNeutralServerToolResult({
+				..."server_label" in item && typeof item.server_label === "string" ? { serverLabel: item.server_label } : {},
+				..."tools" in item && Array.isArray(item.tools) ? { tools: item.tools } : {},
+				...hasError ? { error: item.error } : {}
+			}, hasError ? "error" : "success", maxChars, "mcp_list_tools"), item);
+			continue;
+		}
+		if (item.type === "mcp_call") {
+			const hasOutput = "output" in item && typeof item.output === "string" && item.output.length > 0;
+			const hasError = "error" in item && typeof item.error === "string" && item.error.length > 0;
+			if (!hasOutput && !hasError) continue;
+			pushServerToolResult(createNeutralServerToolResult({
+				..."name" in item && typeof item.name === "string" ? { name: item.name } : {},
+				..."server_label" in item && typeof item.server_label === "string" ? { serverLabel: item.server_label } : {},
+				..."output" in item && typeof item.output === "string" ? { output: item.output } : {},
+				..."error" in item && typeof item.error === "string" ? { error: item.error } : {}
+			}, hasError || "status" in item && (item.status === "failed" || item.status === "incomplete") ? "error" : "success", maxChars, "name" in item && typeof item.name === "string" && item.name.length > 0 ? item.name : "mcp"), item);
+			continue;
+		}
+		if (item.type === "local_shell_call_output" || item.type === "shell_call_output" || item.type === "apply_patch_call_output") {
+			if (!("output" in item)) continue;
+			pushServerToolResult(createNeutralServerToolResult(item.output, "status" in item && (item.status === "failed" || item.status === "incomplete") ? "error" : "success", maxChars, RESPONSES_REPLAY_OUTPUT_TOOL_NAMES[item.type]), item);
+			continue;
+		}
+		if (item.type === "program_output") {
+			if (!("result" in item)) continue;
+			pushServerToolResult(createNeutralServerToolResult(item.result, "status" in item && item.status === "incomplete" ? "error" : "success", maxChars, "program"), item);
+			continue;
+		}
+		if (item.type !== "image_generation_call") continue;
+		if ("id" in item && typeof item.id === "string" && item.id.length > 0) ids.add(item.id);
+		if (!("result" in item) || typeof item.result !== "string" || item.result.length === 0) continue;
+		data.add(item.result);
+		if ("status" in item && item.status === "completed") {
+			const itemId = "id" in item && typeof item.id === "string" && item.id.length > 0 ? item.id : void 0;
+			if (itemId != null && emittedIds.has(itemId) || itemId == null && emittedData.has(item.result)) continue;
+			if (itemId != null) emittedIds.add(itemId);
+			else emittedData.add(item.result);
+			blocks.push({
+				block: {
+					type: "image",
+					mimeType: getGeneratedImageMimeType(item.result),
+					data: item.result,
+					extras: createServerToolResultExtras("image_generation")
+				},
+				...getPosition(item),
+				subIndex: 0
+			});
+		}
+	}
+	return {
+		generatedImages: {
+			blocks: blocks.sort(comparePositionedResponsesReplayBlocks),
+			data,
+			ids
+		},
+		messagePositions,
+		positionedServerToolResultIds,
+		positionsByItemId,
+		serverToolResults: serverToolResults.sort(comparePositionedResponsesReplayBlocks),
+		textPositions
+	};
+}
+function getSelfContainedResponsesV0Images(message) {
+	if (!Array.isArray(message.content)) return {
+		blocks: [],
+		textCount: 0
+	};
+	const images = [];
+	let textCount = 0;
+	for (const block of message.content) {
+		if (block.type === "text") {
+			if (isCompleteToolStreamContentBlock(block)) textCount++;
+			continue;
+		}
+		if (block.type === "image" && ("fileId" in block && typeof block.fileId === "string" && block.fileId.length > 0 || "url" in block && typeof block.url === "string" && block.url.length > 0 || "data" in block && (typeof block.data === "string" && block.data.length > 0 || block.data instanceof Uint8Array && block.data.length > 0))) images.push({
+			block,
+			textIndex: textCount
+		});
+	}
+	return {
+		blocks: images,
+		textCount
+	};
+}
+function getResponsesV0ContentBlocks(message, authoritativeOutput) {
+	let content = message.content;
+	if (typeof content === "string") content = require_langchain.toLangChainContent(content.length > 0 ? [{
+		type: "text",
+		text: content
+	}] : []);
+	return require_langchain.toLangChainContent(cloneAIMessageWithResponsesReplayState(message, content, message.id, {
+		...message.additional_kwargs,
+		tool_outputs: authoritativeOutput
+	}, {
+		...message.response_metadata,
+		model_provider: "openai"
+	}).contentBlocks);
+}
+function isPreemptedOpenAIResponsesMessage(message) {
+	const metadata = message.response_metadata;
+	if (metadata.preempted !== true || metadata.model_provider !== "openai") return false;
+	if (message.id?.startsWith("msg_") === true || message.id?.startsWith("resp_") === true || typeof metadata.id === "string" && metadata.id.startsWith("resp_") || Array.isArray(metadata.output) || metadata.tool_outputs != null || Array.isArray(message.additional_kwargs.tool_outputs) || message.additional_kwargs["__openai_responses_replay_positions__"] != null || message.additional_kwargs.__openai_function_call_ids__ != null || message.additional_kwargs.__openai_custom_tool_call_ids__ != null || message.additional_kwargs.reasoning != null && typeof message.additional_kwargs.reasoning === "object") return true;
+	return false;
+}
 /**
-* Drops incomplete streamed text-input fragments that some providers retain
-* beside the assembled parsed tool call. They are neither user-visible text
-* nor valid content blocks for a subsequent provider.
+* A sealed Responses turn cannot prove that provider-side item ids were
+* retained: the response object does not echo the request's `store` flag.
+* Project a provider-neutral clone while preserving self-contained encrypted
+* reasoning and the original graph/checkpoint message.
 */
-function projectToolStreamContentForProvider(messages) {
+function projectPreemptedOpenAIResponsesMessage(message, maxChars, replayProjection) {
+	if (!isPreemptedOpenAIResponsesMessage(message)) return message;
+	const metadata = message.response_metadata;
+	const additionalKwargs = { ...message.additional_kwargs };
+	const retainsEncryptedReasoning = replayProjection === "native" && hasReplayableEncryptedReasoning(additionalKwargs.reasoning);
+	const authoritativeOutput = getAuthoritativeResponsesOutput(message);
+	const { generatedImages, messagePositions, positionedServerToolResultIds, positionsByItemId, serverToolResults, textPositions } = getResponsesReplayArtifacts(authoritativeOutput, maxChars, replayProjection, additionalKwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY]);
+	const reasoningItemId = retainsEncryptedReasoning && additionalKwargs.reasoning != null && typeof additionalKwargs.reasoning === "object" && "id" in additionalKwargs.reasoning && typeof additionalKwargs.reasoning.id === "string" ? additionalKwargs.reasoning.id : void 0;
+	const reasoningPosition = reasoningItemId != null ? positionsByItemId.get(reasoningItemId) : void 0;
+	const isV1 = metadata.output_version === "v1";
+	const translatesV0 = !isV1 && (replayProjection === "fallback" || authoritativeOutput.length > 0);
+	const originalImages = replayProjection === "native" && translatesV0 ? getSelfContainedResponsesV0Images(message) : void 0;
+	let contentForProjection = message.content;
+	if (!isV1 && translatesV0) contentForProjection = getResponsesV0ContentBlocks(message, authoritativeOutput);
+	const projectedContent = projectPreemptedResponsesV1Content(contentForProjection, isV1 || translatesV0 ? additionalKwargs.reasoning : void 0, maxChars, replayProjection, replayProjection === "native" ? generatedImages : void 0, originalImages, serverToolResults, positionedServerToolResultIds, reasoningPosition, textPositions, messagePositions);
+	const promotesV0 = !isV1 && (replayProjection === "fallback" || generatedImages.blocks.length > 0 || projectedContent.preservedServerToolResult);
+	const unpromotedV0Content = contentForProjection === message.content ? projectedContent.content : projectPreemptedResponsesV1Content(message.content, void 0, maxChars, replayProjection).content;
+	const content = isV1 || promotesV0 ? projectedContent.content : unpromotedV0Content;
+	if (!(content !== message.content || message.id?.startsWith("msg_") === true || !retainsEncryptedReasoning && additionalKwargs.reasoning != null || additionalKwargs.tool_outputs != null || additionalKwargs["__openai_responses_replay_positions__"] != null || additionalKwargs.__openai_function_call_ids__ != null || additionalKwargs.__openai_custom_tool_call_ids__ != null || metadata.id != null || metadata.output != null || metadata.tool_outputs != null)) return message;
+	if (!retainsEncryptedReasoning) delete additionalKwargs.reasoning;
+	delete additionalKwargs.tool_outputs;
+	delete additionalKwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY];
+	delete additionalKwargs.__openai_function_call_ids__;
+	delete additionalKwargs.__openai_custom_tool_call_ids__;
+	const responseMetadata = { ...metadata };
+	delete responseMetadata.id;
+	delete responseMetadata.output;
+	delete responseMetadata.tool_outputs;
+	if (promotesV0) responseMetadata.output_version = "v1";
+	return cloneAIMessageWithResponsesReplayState(message, content, message.id?.startsWith("msg_") === true ? void 0 : message.id, additionalKwargs, responseMetadata);
+}
+/** Applies sealed-Responses safety and drops incomplete streamed text input. */
+function projectToolStreamContentForProvider(messages, responsesReplayProjection, maxChars = require_truncation.HARD_MAX_TOOL_RESULT_CHARS) {
 	let projected;
 	for (let i = 0; i < messages.length; i++) {
 		const message = messages[i];
-		if (message.getType() !== "ai" || !Array.isArray(message.content)) continue;
-		const content = message.content.filter((block) => {
-			if (block == null || typeof block !== "object") return true;
-			try {
-				if ((0, node_util_types.isProxy)(block)) return false;
-				const type = Object.getOwnPropertyDescriptor(block, "type");
-				if (type == null) return true;
-				if (type.enumerable !== true || !("value" in type)) return false;
-				if (type.value !== "text") return true;
-				const text = Object.getOwnPropertyDescriptor(block, "text");
-				return text?.enumerable === true && "value" in text && typeof text.value === "string" && text.value !== "";
-			} catch {
-				return false;
+		if (message.getType() !== "ai") continue;
+		const assistantMessage = message;
+		if (responsesReplayProjection != null && isPreemptedOpenAIResponsesMessage(assistantMessage)) {
+			const replaySafeMessage = projectPreemptedOpenAIResponsesMessage(assistantMessage, maxChars, responsesReplayProjection);
+			if (replaySafeMessage !== assistantMessage) {
+				projected ??= [...messages];
+				projected[i] = replaySafeMessage;
 			}
-		});
-		if (content.length === message.content.length) continue;
+			continue;
+		}
+		if (!Array.isArray(assistantMessage.content)) continue;
+		const content = assistantMessage.content.filter(isCompleteToolStreamContentBlock);
+		if (content.length === assistantMessage.content.length) continue;
 		projected ??= [...messages];
-		projected[i] = cloneAIMessageWithContent(message, require_langchain.toLangChainContent(content));
+		projected[i] = cloneAIMessageWithContent(assistantMessage, require_langchain.toLangChainContent(content));
 	}
 	return projected ?? messages;
 }
@@ -362,7 +917,7 @@ function projectStructuredOpenAIToolContent(content, maxChars, cacheControlledTe
 * the budget guard counted. Native Responses computer screenshots stay
 * structured because their dedicated converter sends the media block directly.
 */
-function projectOpenAIToolMessageContentInternal(messages, maxChars, deduplicateResponsesComputerCalls, cacheControlledTextProjection) {
+function projectOpenAIToolMessageContentInternal(messages, maxChars, nativeResponsesProjection, cacheControlledTextProjection) {
 	const pendingComputerCallIds = [];
 	const seenComputerCallIds = /* @__PURE__ */ new Set();
 	let projected;
@@ -370,8 +925,17 @@ function projectOpenAIToolMessageContentInternal(messages, maxChars, deduplicate
 		const message = messages[i];
 		const messageRole = message.role;
 		if (message.getType() === "ai" || messageRole === "assistant") {
+			let assistantMessage = message;
+			if (nativeResponsesProjection) {
+				const replaySafeMessage = projectPreemptedOpenAIResponsesMessage(assistantMessage, maxChars, "native");
+				if (replaySafeMessage !== assistantMessage) {
+					projected ??= [...messages];
+					projected[i] = replaySafeMessage;
+					assistantMessage = replaySafeMessage;
+				}
+			}
 			const parsedComputerCallIds = /* @__PURE__ */ new Set();
-			const toolCalls = message.tool_calls;
+			const toolCalls = assistantMessage.tool_calls;
 			if (Array.isArray(toolCalls)) for (const toolCall of toolCalls) {
 				const record = toolCall;
 				if (record.type !== "tool_call" || record.isComputerTool !== true || typeof record.id !== "string" || record.id === "") continue;
@@ -381,8 +945,8 @@ function projectOpenAIToolMessageContentInternal(messages, maxChars, deduplicate
 				seenComputerCallIds.add(record.id);
 				pendingComputerCallIds.push(record.id);
 			}
-			const rawOutput = message.response_metadata.output;
-			const fallbackOutput = message.additional_kwargs.tool_outputs;
+			const rawOutput = assistantMessage.response_metadata.output;
+			const fallbackOutput = assistantMessage.additional_kwargs.tool_outputs;
 			let actualToolOutputs = [];
 			if (Array.isArray(rawOutput) && rawOutput.length > 0) actualToolOutputs = rawOutput;
 			else if (Array.isArray(fallbackOutput)) actualToolOutputs = fallbackOutput;
@@ -398,7 +962,7 @@ function projectOpenAIToolMessageContentInternal(messages, maxChars, deduplicate
 				seenComputerCallIds.add(record.call_id);
 				pendingComputerCallIds.push(record.call_id);
 			}
-			if (deduplicateResponsesComputerCalls && Array.isArray(toolCalls) && rawComputerCallIds.size > 0) {
+			if (nativeResponsesProjection && Array.isArray(toolCalls) && rawComputerCallIds.size > 0) {
 				/**
 				* The non-streaming Responses converter marks parsed computer calls,
 				* but the streaming converter currently emits the same call as an
@@ -409,7 +973,7 @@ function projectOpenAIToolMessageContentInternal(messages, maxChars, deduplicate
 				const projectedToolCalls = toolCalls.filter((toolCall) => typeof toolCall.id !== "string" || !rawComputerCallIds.has(toolCall.id));
 				if (projectedToolCalls.length !== toolCalls.length) {
 					projected ??= [...messages];
-					projected[i] = cloneAIMessageWithToolCalls(message, projectedToolCalls, rawComputerCallIds);
+					projected[i] = cloneAIMessageWithToolCalls(assistantMessage, projectedToolCalls, rawComputerCallIds);
 				}
 			}
 		}
@@ -571,6 +1135,7 @@ function findLastIndex(array, predicate) {
 	return -1;
 }
 //#endregion
+exports.OPENAI_RESPONSES_REPLAY_POSITIONS_KEY = OPENAI_RESPONSES_REPLAY_POSITIONS_KEY;
 exports.convertMessagesToContent = convertMessagesToContent;
 exports.findLastIndex = findLastIndex;
 exports.formatAnthropicArtifactContent = formatAnthropicArtifactContent;