@oai404iao/pi-codex-runtime 0.1.0-alpha.1

package/src/providers/responses/citations.ts

@@ -0,0 +1,105 @@
+import { type Api, type Context, type Model } from "@earendil-works/pi-ai";
+import { cloneJsonRecord, sanitizeWebSearchCallItem } from "./items.js";
+import { decodeWebSearchActivityTextSignature, isWebSearchActivityTextSignature, parseTextSignature } from "./signatures.js";
+import { type CitationSource, type InternalAssistantContent, type WebSearchCitationSource } from "./types.js";
+
+export const INTERNAL_CITATION_MARKER = /cite([^]+)/;
+
+const INTERNAL_CITATION_REF = /^turn\d+[a-z][a-z0-9_-]*\d+$/i;
+
+function citationRefsFromResult(result: Record<string, unknown>): string[] {
+	const refs = new Set<string>();
+	for (const key of ["ref_id", "reference_id", "id"]) {
+		const value = result[key];
+		if (typeof value === "string" && INTERNAL_CITATION_REF.test(value)) refs.add(value);
+	}
+	if (typeof result.snippet === "string") {
+		const marker = INTERNAL_CITATION_MARKER.exec(result.snippet.slice(0, 2048));
+		for (const ref of marker?.[1]?.split("") ?? []) {
+			const trimmed = ref.trim();
+			if (INTERNAL_CITATION_REF.test(trimmed)) refs.add(trimmed);
+		}
+	}
+	return [...refs];
+}
+
+export function extractWebSearchCitationSources(item: unknown): WebSearchCitationSource[] {
+	const replayItem = sanitizeWebSearchCallItem(item);
+	if (!replayItem) return [];
+	const actionResults = Array.isArray(replayItem.action.results)
+		? replayItem.action.results.map(cloneJsonRecord).filter((result): result is Record<string, unknown> => !!result)
+		: [];
+	const results = [...(replayItem.results ?? []), ...actionResults];
+	const sources: WebSearchCitationSource[] = [];
+	const seen = new Set<string>();
+	for (const result of results) {
+		const url = typeof result.url === "string" && result.url.trim() ? result.url.trim() : undefined;
+		if (!url) continue;
+		const title = typeof result.title === "string" && result.title.trim() ? result.title.trim() : undefined;
+		for (const refId of citationRefsFromResult(result)) {
+			const key = `${refId}\n${url}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			sources.push({ refId, url, ...(title ? { title } : {}) });
+		}
+	}
+	return sources;
+}
+
+export function collectWebSearchCitationSources<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+): WebSearchCitationSource[] {
+	const byRef = new Map<string, WebSearchCitationSource>();
+	for (const message of context.messages) {
+		if (message.role !== "assistant") continue;
+		if (message.provider !== model.provider || message.api !== model.api || message.model !== model.id) continue;
+		for (const block of message.content as InternalAssistantContent[]) {
+			if (block.type !== "text") continue;
+			const item = decodeWebSearchActivityTextSignature(block.textSignature);
+			if (!item) continue;
+			for (const source of extractWebSearchCitationSources(item)) byRef.set(source.refId, source);
+		}
+	}
+	return [...byRef.values()];
+}
+
+export function collectHistoricalCitationSources<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+): CitationSource[] {
+	let latestSources: CitationSource[] = [];
+	for (const message of context.messages) {
+		if (message.role !== "assistant") continue;
+		if (message.provider !== model.provider || message.api !== model.api || message.model !== model.id) continue;
+		const messageSources: CitationSource[] = [];
+		const seenUrls = new Set<string>();
+		const pushSource = (source: CitationSource): void => {
+			if (!source.url || seenUrls.has(source.url)) return;
+			seenUrls.add(source.url);
+			messageSources.push(source);
+		};
+		for (const block of message.content as InternalAssistantContent[]) {
+			if (block.type !== "text" || isWebSearchActivityTextSignature(block.textSignature)) continue;
+			const markdownLinkPattern = /\[([^\]\n]+)\]\((https?:\/\/[^)\s]+)\)/g;
+			for (const match of block.text.matchAll(markdownLinkPattern)) {
+				pushSource({ title: match[1], url: match[2] });
+			}
+			const replayItem = parseTextSignature(block.textSignature)?.item;
+			for (const part of replayItem?.content ?? []) {
+				if (part.type !== "output_text") continue;
+				for (const annotation of part.annotations) {
+					const url = annotation.type === "url_citation" && typeof annotation.url === "string"
+						? annotation.url.trim()
+						: "";
+					const title = typeof annotation.title === "string" && annotation.title.trim()
+						? annotation.title.trim()
+						: undefined;
+					if (url) pushSource({ url, ...(title ? { title } : {}) });
+				}
+			}
+		}
+		if (messageSources.length > 0) latestSources = messageSources;
+	}
+	return latestSources;
+}

package/src/providers/responses/history.ts

@@ -0,0 +1,144 @@
+import { type Api, type Context, type Model } from "@earendil-works/pi-ai";
+import { isImageGenerationCallBlock } from "./items.js";
+import { isWebSearchActivityTextSignature } from "./signatures.js";
+import { type InternalAssistantContent, type Message } from "./types.js";
+
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+
+const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+
+function replaceImagesWithPlaceholder(
+	content: Extract<Message, { role: "user" }> extends { content: infer T } ? Exclude<T, string> : never,
+	placeholder: string,
+) {
+	const result: Array<{ type: "text"; text: string } | { type: "image"; data: string; mimeType: string }> = [];
+	let previousWasPlaceholder = false;
+	for (const block of content) {
+		if (block.type === "image") {
+			if (!previousWasPlaceholder) {
+				result.push({ type: "text", text: placeholder });
+			}
+			previousWasPlaceholder = true;
+			continue;
+		}
+		result.push(block);
+		previousWasPlaceholder = block.text === placeholder;
+	}
+	return result;
+}
+
+function downgradeUnsupportedImages(messages: Context["messages"], model: Model<Api>): Context["messages"] {
+	if (model.input.includes("image")) return messages;
+	return messages.map((msg) => {
+		if (msg.role === "user" && Array.isArray(msg.content)) {
+			return { ...msg, content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER) };
+		}
+		if (msg.role === "toolResult") {
+			return { ...msg, content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER) };
+		}
+		return msg;
+	});
+}
+
+export function transformMessages(
+	messages: Context["messages"],
+	model: Model<Api>,
+	normalizeToolCallId?: (id: string, targetModel: Model<Api>, source: Extract<Message, { role: "assistant" }>) => string,
+): Context["messages"] {
+	const toolCallIdMap = new Map<string, string>();
+	const imageAwareMessages = downgradeUnsupportedImages(messages, model);
+	const transformed = imageAwareMessages.map((msg) => {
+		if (msg.role === "user") return msg;
+		if (msg.role === "toolResult") {
+			const normalizedId = toolCallIdMap.get(msg.toolCallId);
+			return normalizedId && normalizedId !== msg.toolCallId ? { ...msg, toolCallId: normalizedId } : msg;
+		}
+		if (msg.role === "assistant") {
+			const assistantMsg = msg;
+			const isSameModel =
+				assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+			const transformedContent = (assistantMsg.content as InternalAssistantContent[]).flatMap((block) => {
+				if (isImageGenerationCallBlock(block)) return block;
+				if (block.type === "thinking") {
+					if (block.redacted) return isSameModel ? block : [];
+					if (isSameModel && block.thinkingSignature) return block;
+					if (!block.thinking || block.thinking.trim() === "") return [];
+					return isSameModel ? block : { type: "text" as const, text: block.thinking };
+				}
+				if (block.type === "text") {
+					if (isWebSearchActivityTextSignature(block.textSignature)) return block;
+					return isSameModel ? block : { type: "text" as const, text: block.text };
+				}
+				if (block.type === "toolCall") {
+					let normalizedToolCall = block;
+					if (!isSameModel && block.thoughtSignature) {
+						normalizedToolCall = { ...block };
+						delete normalizedToolCall.thoughtSignature;
+					}
+					if (!isSameModel && normalizeToolCallId) {
+						const normalizedId = normalizeToolCallId(block.id, model, assistantMsg);
+						if (normalizedId !== block.id) {
+							toolCallIdMap.set(block.id, normalizedId);
+							normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+						}
+					}
+					return normalizedToolCall;
+				}
+				return block;
+			});
+			return { ...assistantMsg, content: transformedContent as Extract<Message, { role: "assistant" }>["content"] };
+		}
+		return msg;
+	});
+
+	const result: Context["messages"] = [];
+	let pendingToolCalls: Array<Extract<Extract<Message, { role: "assistant" }>["content"][number], { type: "toolCall" }>> = [];
+	let existingToolResultIds = new Set<string>();
+
+	const insertSyntheticToolResults = () => {
+		if (pendingToolCalls.length === 0) return;
+		for (const toolCall of pendingToolCalls) {
+			if (!existingToolResultIds.has(toolCall.id)) {
+				result.push({
+					role: "toolResult",
+					toolCallId: toolCall.id,
+					toolName: toolCall.name,
+					content: [{ type: "text", text: "No result provided" }],
+					isError: true,
+					timestamp: Date.now(),
+				});
+			}
+		}
+		pendingToolCalls = [];
+		existingToolResultIds = new Set();
+	};
+
+	for (const msg of transformed) {
+		if (msg.role === "assistant") {
+			insertSyntheticToolResults();
+			if (msg.stopReason === "error" || msg.stopReason === "aborted") continue;
+			const toolCalls = msg.content.filter((block) => block.type === "toolCall");
+			if (toolCalls.length > 0) {
+				pendingToolCalls = toolCalls;
+				existingToolResultIds = new Set();
+			}
+			result.push(msg);
+			continue;
+		}
+		if (msg.role === "toolResult") {
+			existingToolResultIds.add(msg.toolCallId);
+			result.push(msg);
+			continue;
+		}
+		if (msg.role === "user") {
+			insertSyntheticToolResults();
+			result.push(msg);
+			continue;
+		}
+		result.push(msg);
+	}
+
+	insertSyntheticToolResults();
+
+	return result;
+}

package/src/providers/responses/items.ts

@@ -0,0 +1,87 @@
+import { type ImageGenerationCallBlock, type ImageGenerationCallItem, type InternalAssistantContent, type ReplayableResponseMessageContent, type ReplayableResponseMessageItem, type ReplayableWebSearchCallItem } from "./types.js";
+
+export function cloneJsonRecord(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	try {
+		const cloned = JSON.parse(JSON.stringify(value)) as unknown;
+		return cloned && typeof cloned === "object" && !Array.isArray(cloned)
+			? cloned as Record<string, unknown>
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function sanitizeWebSearchCallItem(item: unknown): ReplayableWebSearchCallItem | undefined {
+	if (!item || typeof item !== "object") return undefined;
+	const candidate = item as Record<string, unknown>;
+	if (candidate.type !== "web_search_call") return undefined;
+	if (typeof candidate.id !== "string" || candidate.id === "") return undefined;
+	if (candidate.status !== "completed") return undefined;
+	const action = cloneJsonRecord(candidate.action);
+	if (!action) return undefined;
+	const results = Array.isArray(candidate.results)
+		? candidate.results.map(cloneJsonRecord).filter((result): result is Record<string, unknown> => !!result)
+		: undefined;
+
+	return {
+		type: "web_search_call",
+		id: candidate.id,
+		status: "completed",
+		action,
+		...(results ? { results } : {}),
+	};
+}
+
+export function sanitizeResponseMessageItem(item: unknown): ReplayableResponseMessageItem | undefined {
+	if (!item || typeof item !== "object") return undefined;
+	const candidate = item as Record<string, unknown>;
+	if (candidate.type !== "message") return undefined;
+	if (typeof candidate.id !== "string" || candidate.id === "") return undefined;
+	const rawContent = Array.isArray(candidate.content) ? candidate.content : [];
+	const content: ReplayableResponseMessageContent[] = [];
+	for (const rawPart of rawContent) {
+		if (!rawPart || typeof rawPart !== "object") continue;
+		const part = rawPart as Record<string, unknown>;
+		if (part.type === "output_text" && typeof part.text === "string") {
+			const annotations = Array.isArray(part.annotations)
+				? part.annotations.map(cloneJsonRecord).filter((annotation): annotation is Record<string, unknown> => !!annotation)
+				: [];
+			content.push({ type: "output_text", text: part.text, annotations });
+		} else if (part.type === "refusal" && typeof part.refusal === "string") {
+			content.push({ type: "refusal", refusal: part.refusal });
+		}
+	}
+	const phase = candidate.phase === "commentary" || candidate.phase === "final_answer"
+		? candidate.phase
+		: undefined;
+	return {
+		type: "message",
+		id: candidate.id,
+		role: "assistant",
+		status: "completed",
+		content,
+		...(phase ? { phase } : {}),
+	};
+}
+
+export function isImageGenerationCallBlock(block: InternalAssistantContent): block is ImageGenerationCallBlock {
+	return block.type === "image_generation_call" && block.item?.type === "image_generation_call";
+}
+
+export function sanitizeImageGenerationCallItem(item: unknown): ImageGenerationCallItem | undefined {
+	if (!item || typeof item !== "object") return undefined;
+	const candidate = item as Record<string, unknown>;
+	if (candidate.type !== "image_generation_call") return undefined;
+	if (typeof candidate.id !== "string" || candidate.id === "") return undefined;
+	if (typeof candidate.status !== "string" || candidate.status === "") return undefined;
+	if (!(typeof candidate.result === "string" || candidate.result === null)) return undefined;
+
+	return {
+		type: "image_generation_call",
+		id: candidate.id,
+		status: candidate.status,
+		result: candidate.result,
+		...(typeof candidate.revised_prompt === "string" ? { revised_prompt: candidate.revised_prompt } : {}),
+	};
+}

package/src/providers/responses/markdown.ts

@@ -0,0 +1,92 @@
+interface MarkdownCodeRange {
+	start: number;
+	end: number;
+}
+
+function characterRunLength(text: string, index: number, character: string): number {
+	let end = index;
+	while (end < text.length && text[end] === character) end++;
+	return end - index;
+}
+
+function isFencePosition(text: string, index: number): boolean {
+	const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+	return /^ {0,3}$/.test(text.slice(lineStart, index));
+}
+
+export function markdownCodeRanges(text: string): MarkdownCodeRange[] {
+	const ranges: MarkdownCodeRange[] = [];
+	let fence: { character: "`" | "~"; length: number; start: number } | undefined;
+	let index = 0;
+	while (index < text.length) {
+		const character = text[index];
+		if (fence) {
+			if (character === fence.character && isFencePosition(text, index)) {
+				const runLength = characterRunLength(text, index, character);
+				if (runLength >= fence.length) {
+					ranges.push({ start: fence.start, end: index + runLength });
+					fence = undefined;
+					index += runLength;
+					continue;
+				}
+			}
+			index++;
+			continue;
+		}
+
+		if ((character === "`" || character === "~") && isFencePosition(text, index)) {
+			const runLength = characterRunLength(text, index, character);
+			if (runLength >= 3) {
+				fence = { character, length: runLength, start: index };
+				index += runLength;
+				continue;
+			}
+		}
+
+		if (character === "`") {
+			const runLength = characterRunLength(text, index, character);
+			const delimiter = character.repeat(runLength);
+			const close = text.indexOf(delimiter, index + runLength);
+			if (close < 0) {
+				ranges.push({ start: index, end: text.length });
+				break;
+			}
+			ranges.push({ start: index, end: close + runLength });
+			index = close + runLength;
+			continue;
+		}
+		index++;
+	}
+	if (fence) ranges.push({ start: fence.start, end: text.length });
+	return ranges;
+}
+
+export function isInsideMarkdownCode(index: number, ranges: MarkdownCodeRange[]): boolean {
+	return ranges.some((range) => index >= range.start && index < range.end);
+}
+
+export function trailingCitationFragmentStart(text: string, ranges: MarkdownCodeRange[]): number | undefined {
+	const opener = "cite";
+	const openIndex = text.lastIndexOf("cite");
+	if (openIndex >= 0 && text.indexOf("", openIndex) < 0 && !isInsideMarkdownCode(openIndex, ranges)) {
+		return openIndex;
+	}
+	for (let length = Math.min(opener.length - 1, text.length); length > 0; length--) {
+		if (!text.endsWith(opener.slice(0, length))) continue;
+		const start = text.length - length;
+		if (!isInsideMarkdownCode(start, ranges)) return start;
+	}
+	return undefined;
+}
+
+export function trailingIndexedSourceFragmentStart(text: string, ranges: MarkdownCodeRange[]): number | undefined {
+	const openIndex = text.lastIndexOf("【");
+	if (openIndex < 0 || text.indexOf("】", openIndex) >= 0 || isInsideMarkdownCode(openIndex, ranges)) {
+		return undefined;
+	}
+	const fragment = text.slice(openIndex);
+	const match = /^【\d*(?:†([a-z]*))?$/i.exec(fragment);
+	if (!match) return undefined;
+	const sourceFragment = match[1]?.toLowerCase() ?? "";
+	return "source".startsWith(sourceFragment) ? openIndex : undefined;
+}

package/src/providers/responses/messages.ts

@@ -0,0 +1,169 @@
+import { type Api, type Context, type Model } from "@earendil-works/pi-ai";
+import { type ResponseInput } from "openai/resources/responses/responses.js";
+import { transformMessages } from "./history.js";
+import { isImageGenerationCallBlock, sanitizeImageGenerationCallItem } from "./items.js";
+import { decodeWebSearchActivityTextSignature, isWebSearchActivityTextSignature, parseTextSignature } from "./signatures.js";
+import { sanitizeSurrogates, shortHash } from "./text.js";
+import { wireToolIdentity } from "./tool-identity.js";
+import { type ConvertResponsesMessagesOptions, type InternalAssistantContent, type Message } from "./types.js";
+
+export function convertResponsesMessages<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	allowedToolCallProviders: ReadonlySet<string>,
+	options?: ConvertResponsesMessagesOptions,
+): ResponseInput {
+	const messages: ResponseInput = [];
+	const normalizeIdPart = (part: string) => {
+		const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+		const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+		return normalized.replace(/_+$/, "");
+	};
+	const buildForeignResponsesItemId = (itemId: string, prefix: "fc_" | "ctc_") => {
+		const normalized = `${prefix}${shortHash(itemId)}`;
+		return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+	};
+	const normalizeToolCallId = (id: string, _targetModel: Model<TApi>, source: Extract<Message, { role: "assistant" }>) => {
+		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
+		if (!id.includes("|")) return normalizeIdPart(id);
+		const [callId, itemId] = id.split("|");
+		const normalizedCallId = normalizeIdPart(callId);
+		const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+		const itemPrefix = itemId?.startsWith("ctc_") ? "ctc_" : "fc_";
+		let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId ?? "", itemPrefix) : normalizeIdPart(itemId ?? "");
+		if (!normalizedItemId.startsWith(itemPrefix)) normalizedItemId = normalizeIdPart(`${itemPrefix}${normalizedItemId}`);
+		return `${normalizedCallId}|${normalizedItemId}`;
+	};
+
+	const transformedMessages = transformMessages(context.messages, model as Model<Api>, normalizeToolCallId as never);
+	const includeSystemPrompt = options?.includeSystemPrompt ?? true;
+	if (includeSystemPrompt && context.systemPrompt) {
+		messages.push({ role: model.reasoning ? "developer" : "system", content: sanitizeSurrogates(context.systemPrompt) });
+	}
+
+	let msgIndex = 0;
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				messages.push({ role: "user", content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }] });
+			} else {
+				const content = msg.content.map((item) =>
+					item.type === "text"
+						? { type: "input_text" as const, text: sanitizeSurrogates(item.text) }
+						: { type: "input_image" as const, detail: "auto" as const, image_url: `data:${item.mimeType};base64,${item.data}` },
+				);
+				if (content.length > 0) messages.push({ role: "user", content });
+			}
+		} else if (msg.role === "assistant") {
+			const output: ResponseInput = [];
+			const isSameModel = msg.model === model.id && msg.provider === model.provider && msg.api === model.api;
+			const isDifferentModel = msg.model !== model.id && msg.provider === model.provider && msg.api === model.api;
+			let assistantBlockIndex = 0;
+			for (const block of msg.content as InternalAssistantContent[]) {
+				if (isImageGenerationCallBlock(block)) {
+					const imageGenerationCall = sanitizeImageGenerationCallItem(block.item);
+					if (imageGenerationCall) output.push(imageGenerationCall as ResponseInput[number]);
+				} else if (block.type === "thinking") {
+					if (block.thinkingSignature) output.push(JSON.parse(block.thinkingSignature));
+				} else if (block.type === "text") {
+					if (isWebSearchActivityTextSignature(block.textSignature)) {
+						const webSearchItem = isSameModel
+							? decodeWebSearchActivityTextSignature(block.textSignature)
+							: undefined;
+						if (webSearchItem) output.push(webSearchItem as unknown as ResponseInput[number]);
+						continue;
+					}
+					const parsedSignature = parseTextSignature(block.textSignature);
+					if (isSameModel && parsedSignature?.item) {
+						output.push(parsedSignature.item as ResponseInput[number]);
+						assistantBlockIndex++;
+						continue;
+					}
+					let msgId = parsedSignature?.id ?? `msg_${msgIndex}_${assistantBlockIndex}`;
+					if (msgId.length > 64) msgId = `msg_${shortHash(msgId)}`;
+					output.push({
+						type: "message",
+						role: "assistant",
+						content: [{ type: "output_text", text: sanitizeSurrogates(block.text), annotations: [] }],
+						status: "completed",
+						id: msgId,
+						...(parsedSignature?.phase ? { phase: parsedSignature.phase } : {}),
+					});
+					assistantBlockIndex++;
+				} else if (block.type === "toolCall") {
+					const [callId, itemIdRaw] = block.id.split("|");
+					const custom = itemIdRaw?.startsWith("ctc_") === true;
+					let itemId: string | undefined = itemIdRaw;
+					if (isDifferentModel && (itemId?.startsWith("fc_") || itemId?.startsWith("ctc_"))) itemId = undefined;
+					const wireIdentity = wireToolIdentity(block.name, block.thoughtSignature);
+					if (custom) {
+						output.push({
+							type: "custom_tool_call",
+							...(itemId ? { id: itemId } : {}),
+							call_id: callId,
+							name: wireIdentity.name,
+							...(wireIdentity.namespace ? { namespace: wireIdentity.namespace } : {}),
+							input: typeof block.arguments.input === "string" ? block.arguments.input : "",
+						} as ResponseInput[number]);
+					} else {
+						output.push({
+							type: "function_call",
+							...(itemId ? { id: itemId } : {}),
+							call_id: callId,
+							name: wireIdentity.name,
+							...(wireIdentity.namespace ? { namespace: wireIdentity.namespace } : {}),
+							arguments: JSON.stringify(block.arguments),
+						} as ResponseInput[number]);
+					}
+				}
+			}
+			if (output.length > 0) messages.push(...output);
+		} else if (msg.role === "toolResult") {
+			const textResult = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+			const hasImages = msg.content.some((c) => c.type === "image");
+			const hasText = textResult.length > 0;
+			const [callId, itemId] = msg.toolCallId.split("|");
+			const supportsToolResultImages = hasImages && model.input.includes("image");
+			let originalCallUsesContentItems = false;
+			for (let index = msgIndex - 1; index >= 0; index--) {
+				const previous = context.messages[index];
+				if (previous?.role !== "assistant") continue;
+				const originalCall = previous.content.find((block) =>
+					block.type === "toolCall" && block.id.split("|")[0] === callId);
+				if (originalCall?.type === "toolCall") {
+					originalCallUsesContentItems = wireToolIdentity(
+						originalCall.name,
+						originalCall.thoughtSignature,
+					).namespace === "web";
+					break;
+				}
+			}
+			const usesContentItems = supportsToolResultImages || originalCallUsesContentItems;
+			const output = usesContentItems
+				? [
+						...(hasText ? [{ type: "input_text" as const, text: sanitizeSurrogates(textResult) }] : []),
+						...(supportsToolResultImages
+							? msg.content
+									.filter((block) => block.type === "image")
+									.map((block) => ({
+										type: "input_image" as const,
+										detail: "auto" as const,
+										image_url: `data:${block.mimeType};base64,${block.data}`,
+									}))
+							: []),
+						...(!hasText && !supportsToolResultImages
+							? [{ type: "input_text" as const, text: "(see attached image)" }]
+							: []),
+					]
+				: sanitizeSurrogates(hasText ? textResult : "(see attached image)");
+			messages.push({
+				type: itemId?.startsWith("ctc_") ? "custom_tool_call_output" : "function_call_output",
+				call_id: callId,
+				output,
+			} as ResponseInput[number]);
+		}
+		msgIndex++;
+	}
+
+	return messages;
+}