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

package/src/patch/render.ts

@@ -0,0 +1,201 @@
+import { Box, Container, Spacer, Text, type Component } from "@earendil-works/pi-tui";
+import { previewApplyPatch, type ApplyPatchPreviewFile } from "./apply.js";
+
+const PREVIEW_INTERVAL_MS = 500;
+
+type RenderPreview = { complete: boolean; files: ApplyPatchPreviewFile[] } | { error: string };
+
+interface PreviewRequest {
+	input: string;
+	cwd: string;
+	complete: boolean;
+	invalidate: () => void;
+}
+
+interface ApplyPatchRenderBox extends Box {
+	preview?: RenderPreview;
+	request?: PreviewRequest;
+	requestKey?: string;
+	previewPending: boolean;
+	previewTimer?: ReturnType<typeof setTimeout>;
+	lastPreviewStartedAt: number;
+	executionStarted: boolean;
+	settledFiles?: Array<{ kind: ApplyPatchPreviewFile["kind"]; path: string; moveTo?: string }>;
+	settledError: boolean;
+	settledSuccess: boolean;
+}
+
+async function computePreview(request: PreviewRequest): Promise<RenderPreview> {
+	try {
+		const preview = await previewApplyPatch(request.input, {
+			cwd: request.cwd,
+		}, request.complete);
+		return {
+			complete: preview.complete,
+			files: preview.files,
+		};
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+function createRenderBox(): ApplyPatchRenderBox {
+	return Object.assign(new Box(1, 1, (text: string) => text), {
+		previewPending: false,
+		lastPreviewStartedAt: 0,
+		executionStarted: false,
+		settledError: false,
+		settledSuccess: false,
+	});
+}
+
+function getRenderBox(state: Record<string, unknown>, lastComponent: Component | undefined): ApplyPatchRenderBox {
+	if (lastComponent instanceof Box) {
+		state.callComponent = lastComponent;
+		return lastComponent as ApplyPatchRenderBox;
+	}
+	if (state.callComponent instanceof Box) return state.callComponent as ApplyPatchRenderBox;
+	const component = createRenderBox();
+	state.callComponent = component;
+	return component;
+}
+
+function requestKey(request: Omit<PreviewRequest, "invalidate">): string {
+	return `${request.complete ? "complete" : "partial"}\u0000${request.cwd}\u0000${request.input}`;
+}
+
+function schedulePreview(component: ApplyPatchRenderBox, immediate = false): void {
+	if (!component.request || component.previewPending) return;
+	if (component.previewTimer) {
+		if (!immediate) return;
+		clearTimeout(component.previewTimer);
+		component.previewTimer = undefined;
+	}
+	const delay = immediate ? 0 : Math.max(0, PREVIEW_INTERVAL_MS - (Date.now() - component.lastPreviewStartedAt));
+	component.previewTimer = setTimeout(() => {
+		component.previewTimer = undefined;
+		const request = component.request;
+		if (!request) return;
+		const key = component.requestKey;
+		component.previewPending = true;
+		component.lastPreviewStartedAt = Date.now();
+		void computePreview(request).then((preview) => {
+			if (!component.executionStarted && component.requestKey === key) {
+				component.preview = preview;
+			}
+		}).finally(() => {
+			component.previewPending = false;
+			request.invalidate();
+			if (!component.executionStarted && component.requestKey !== key) schedulePreview(component, Boolean(component.request?.complete));
+		});
+	}, delay);
+	component.previewTimer.unref?.();
+}
+
+function updatePreviewRequest(component: ApplyPatchRenderBox, request: PreviewRequest): void {
+	const key = requestKey(request);
+	if (component.requestKey === key) return;
+	component.request = request;
+	component.requestKey = key;
+	schedulePreview(component, request.complete);
+}
+
+function contentLineCount(content: string): number {
+	if (!content) return 0;
+	const lines = content.replace(/\r\n/g, "\n").split("\n");
+	if (lines[lines.length - 1] === "") lines.pop();
+	return lines.length;
+}
+
+function operationLine(file: ApplyPatchPreviewFile, theme: any, expanded: boolean): string {
+	const marker = file.kind === "add" ? "A" : file.kind === "delete" ? "D" : "M";
+	const markerColor = file.kind === "delete" ? "error" : file.kind === "add" ? "success" : "accent";
+	const path = file.moveTo ? `${file.path} → ${file.moveTo}` : file.path;
+	const before = contentLineCount(file.previousContent);
+	const after = contentLineCount(file.content);
+	const size = file.kind === "add" ? `+${after} lines` : file.kind === "delete" ? `-${before} lines` : `${before}→${after} lines`;
+	const detail = expanded && file.moveTo ? ` (${file.path} moved)` : "";
+	return `${theme.fg(markerColor, marker)} ${theme.fg("accent", path)} ${theme.fg("dim", `${size}${detail}`)}`;
+}
+
+function settledOperationLine(file: { kind: ApplyPatchPreviewFile["kind"]; path: string; moveTo?: string }, theme: any): string {
+	const marker = file.kind === "add" ? "A" : file.kind === "delete" ? "D" : "M";
+	const markerColor = file.kind === "delete" ? "error" : file.kind === "add" ? "success" : "accent";
+	const path = file.moveTo ? `${file.path} → ${file.moveTo}` : file.path;
+	return `${theme.fg(markerColor, marker)} ${theme.fg("accent", path)}`;
+}
+
+function rebuildCall(component: ApplyPatchRenderBox, theme: any, expanded: boolean): ApplyPatchRenderBox {
+	component.setBgFn(component.settledError
+		? (text: string) => theme.bg("toolErrorBg", text)
+		: component.settledSuccess
+			? (text: string) => theme.bg("toolSuccessBg", text)
+			: (text: string) => theme.bg("toolPendingBg", text));
+	component.clear();
+	const status = component.settledError
+		? "failed"
+		: component.settledSuccess
+			? "applied"
+			: component.executionStarted
+				? "applying"
+				: component.previewPending
+					? "previewing"
+					: component.preview && "complete" in component.preview && component.preview.complete ? "ready" : "streaming";
+	component.addChild(new Text(`${theme.fg("toolTitle", theme.bold("apply_patch"))} ${theme.fg("dim", status)}`, 0, 0));
+	if (component.settledFiles) {
+		for (const file of component.settledFiles) component.addChild(new Text(settledOperationLine(file, theme), 0, 0));
+		return component;
+	}
+	if (!component.preview) return component;
+	if ("error" in component.preview) {
+		component.addChild(new Spacer(1));
+		component.addChild(new Text(theme.fg("error", component.preview.error), 0, 0));
+		return component;
+	}
+	for (const file of component.preview.files) component.addChild(new Text(operationLine(file, theme, expanded), 0, 0));
+	return component;
+}
+
+export function createApplyPatchRenderers() {
+	return {
+		renderCall(args: { input?: string } | undefined, theme: any, context: any) {
+			const component = getRenderBox(context.state, context.lastComponent);
+			if (context.executionStarted && !component.executionStarted) {
+				component.executionStarted = true;
+				if (component.previewTimer) clearTimeout(component.previewTimer);
+				component.previewTimer = undefined;
+				component.request = undefined;
+				component.requestKey = undefined;
+			}
+			const input = typeof args?.input === "string" ? args.input : "";
+			if (input && !component.executionStarted) {
+				updatePreviewRequest(component, {
+					input,
+					cwd: context.cwd,
+					complete: Boolean(context.argsComplete),
+					invalidate: context.invalidate,
+				});
+			}
+			return rebuildCall(component, theme, Boolean(context.expanded));
+		},
+		renderResult(result: {
+			content?: Array<{ type?: string; text?: string }>;
+			details?: { files?: Array<{ kind?: string; path?: string; moveTo?: string }> };
+		}, _options: unknown, theme: any, context: any) {
+			const component = getRenderBox(context.state, context.state.callComponent);
+			component.settledError = Boolean(context.isError);
+			component.settledSuccess = !context.isError;
+			if (!context.isError && Array.isArray(result.details?.files)) {
+				component.settledFiles = result.details.files.flatMap((file) =>
+					(file.kind === "add" || file.kind === "update" || file.kind === "delete") && typeof file.path === "string"
+						? [{ kind: file.kind, path: file.path, ...(typeof file.moveTo === "string" ? { moveTo: file.moveTo } : {}) }]
+						: []);
+				component.preview = undefined;
+			}
+			rebuildCall(component, theme, Boolean(context.expanded));
+			const message = result.content?.filter((item) => item.type === "text").map((item) => item.text ?? "").join("\n") ?? "";
+			if (context.isError) return message ? new Text(theme.fg("error", message), 0, 0) : new Container();
+			return new Text(theme.fg("success", context.expanded && message ? message : "Applied"), 0, 0);
+		},
+	};
+}

package/src/provider-native-tools.ts

@@ -0,0 +1,75 @@
+import { createCodexReservedNamespaceTool } from "@oai404iao/pi-codex-runtime/internal/codex-reserved-tools";
+import type { NativeToolOwnership } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export interface NativeToolRewriteResult<T = unknown> {
+	payload: T;
+	rewritten: string[];
+}
+
+export interface NativeToolRewriteOptions {
+	ownsNativeTool?: NativeToolOwnership;
+	imageModel?: string;
+	imageGeneration?: boolean | "hosted" | "standalone";
+	webSearch?: boolean | {
+		implementation?: "hosted" | "standalone";
+		contentTypes?: readonly ("text" | "image")[];
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function toolName(tool: Record<string, unknown>): string | undefined {
+	if (typeof tool.name === "string") return tool.name;
+	const nested = isRecord(tool.function) ? tool.function : undefined;
+	return typeof nested?.name === "string" ? nested.name : undefined;
+}
+
+function imageToolConfig(tool: Record<string, unknown>, options: NativeToolRewriteOptions): Record<string, unknown> {
+	const parameters = isRecord(tool.parameters) ? tool.parameters : isRecord(isRecord(tool.function) ? tool.function.parameters : undefined) ? (tool.function as Record<string, unknown>).parameters as Record<string, unknown> : {};
+	const config: Record<string, unknown> = { type: "image_generation" };
+	if (typeof options.imageModel === "string" && options.imageModel.trim()) config.model = options.imageModel.trim();
+	for (const key of ["size", "quality", "background", "output_format"]) {
+		const value = parameters[key];
+		if (typeof value === "string") config[key] = value;
+	}
+	if (!config.output_format) config.output_format = "png";
+	if (!config.action) config.action = "auto";
+	return config;
+}
+
+export function rewriteNativeOpenAiTools<T>(payload: T, options: NativeToolRewriteOptions = {}): NativeToolRewriteResult<T> {
+	if (!isRecord(payload) || !Array.isArray(payload.tools)) return { payload, rewritten: [] };
+	const rewritten: string[] = [];
+	const tools = payload.tools.map((candidate) => {
+		if (!isRecord(candidate)) return candidate;
+		const name = toolName(candidate);
+		if ((name === "web_search" || name === "image_generation")
+			&& options.ownsNativeTool?.(name) === false) return candidate;
+		if (name === "image_generation" && options.imageGeneration !== false) {
+			rewritten.push(name);
+			if (options.imageGeneration === "standalone") {
+				return createCodexReservedNamespaceTool("image_generation");
+			}
+			return imageToolConfig(candidate, options);
+		}
+		if (name === "web_search" && options.webSearch) {
+			rewritten.push(name);
+			if (typeof options.webSearch === "object" && options.webSearch.implementation === "standalone") {
+				return createCodexReservedNamespaceTool("web_search");
+			}
+			const contentTypes = typeof options.webSearch === "object"
+				? options.webSearch.contentTypes
+				: undefined;
+			return {
+				type: "web_search",
+				...(contentTypes && contentTypes.length > 0
+					? { search_content_types: [...contentTypes] }
+					: {}),
+			};
+		}
+		return candidate;
+	});
+	return { payload: { ...payload, tools } as T, rewritten };
+}

package/src/providers/codex-apply-patch-tool.ts

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs";
+
+export const CODEX_APPLY_PATCH_DESCRIPTION = "Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.";
+
+let grammar: string | undefined;
+
+export function codexApplyPatchGrammar(): string {
+	grammar ??= readFileSync(new URL("./codex-apply-patch.lark", import.meta.url), "utf8");
+	return grammar;
+}
+
+export function createCodexApplyPatchCustomTool(): Record<string, unknown> {
+	return {
+		type: "custom",
+		name: "apply_patch",
+		description: CODEX_APPLY_PATCH_DESCRIPTION,
+		format: {
+			type: "grammar",
+			syntax: "lark",
+			definition: codexApplyPatchGrammar(),
+		},
+	};
+}

package/src/providers/codex-apply-patch.lark

@@ -0,0 +1,19 @@
+start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+
+%import common.LF

package/src/providers/openai-codex/cache-key.ts

@@ -0,0 +1,52 @@
+import { type Api, type Model } from "@earendil-works/pi-ai/compat";
+
+function shortHash(str: string): string {
+	let h1 = 0xdeadbeef;
+	let h2 = 0x41c6ce57;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+	h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+	return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+
+function webSocketHeaderIdentity(headers: Headers): string {
+	const requestScoped = new Set([
+		"x-codex-turn-metadata",
+		"x-codex-turn-state",
+		"x-codex-window-id",
+	]);
+	return shortHash(
+		[...headers.entries()]
+			.filter(([name]) => !requestScoped.has(name.toLowerCase()))
+			.sort(([left], [right]) => left.localeCompare(right))
+			.map(([name, value]) => `${name}:${value}`)
+			.join("\n"),
+	);
+}
+
+export function webSocketCacheKey(
+	sessionId: string | undefined,
+	model: Model<Api>,
+	url: string,
+	headers: Headers,
+	profileHash?: string,
+): string | undefined {
+	return sessionId
+		? `${sessionId}\n${model.provider}\n${model.api}\n${model.id}\n${url}\n${profileHash ?? "no-profile"}\n${webSocketHeaderIdentity(headers)}`
+		: undefined;
+}
+
+export function webSocketFallbackKey(
+	sessionId: string | undefined,
+	model: Model<Api>,
+	url: string,
+	profileHash?: string,
+): string | undefined {
+	return sessionId
+		? `${sessionId}\n${model.provider}\n${model.api}\n${model.id}\n${url}\n${profileHash ?? "no-profile"}`
+		: undefined;
+}

package/src/providers/openai-codex/captured-stream.ts

@@ -0,0 +1,50 @@
+import type { Api, AssistantMessage, AssistantMessageEventStream, Model, SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { processResponsesStream } from "@oai404iao/pi-codex-runtime/internal/providers/responses/stream";
+import type { CitationSource, WebSearchCitationSource } from "@oai404iao/pi-codex-runtime/internal/providers/responses/types";
+import { mapCodexEvents } from "./events.js";
+import type { ProviderStreamEffects } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/stream-effects";
+import type { ServiceTier, StreamEventShape } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { applyServiceTierPricing, resolveCodexServiceTier } from "./usage.js";
+
+export async function processCapturedResponsesStream<TApi extends Api>(
+	events: AsyncIterable<StreamEventShape>,
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	model: Model<TApi>,
+	options: SimpleStreamOptions | undefined,
+	sessionKey: string | undefined,
+	effects: ProviderStreamEffects,
+	cwd: string,
+	requestPrompt: string | undefined,
+	webSearchCitationSources: ReadonlyArray<WebSearchCitationSource>,
+	historicalCitationSources: ReadonlyArray<CitationSource>,
+): Promise<{ responseId?: string; responseItems: unknown[] }> {
+	const responseItems: unknown[] = [];
+	let responseId: string | undefined;
+	const observe = effects.createEventObserver?.({
+		cwd, requestPrompt, signal: options?.signal, output, stream,
+	});
+	const captureContinuation = async function* (): AsyncIterable<StreamEventShape> {
+		for await (const event of mapCodexEvents(events, sessionKey)) {
+			if (event.type === "response.created" && event.response?.id) responseId = event.response.id;
+			if (event.type === "response.output_item.done" && event.item) responseItems.push(event.item);
+			if (
+				(event.type === "response.completed" || event.type === "response.incomplete")
+				&& event.response?.id
+			) {
+				responseId = event.response.id;
+			}
+			await observe?.(event);
+			yield event;
+		}
+	};
+	await processResponsesStream(captureContinuation() as AsyncIterable<never>, output, stream, model, {
+		serviceTier: (options as { serviceTier?: ServiceTier } | undefined)?.serviceTier,
+		resolveServiceTier: resolveCodexServiceTier,
+		applyServiceTierPricing: (usage, serviceTier) =>
+			applyServiceTierPricing(usage, serviceTier, model as Model<Api>, cwd),
+		webSearchCitationSources,
+		historicalCitationSources,
+	});
+	return { responseId: responseId ?? output.responseId, responseItems };
+}

package/src/providers/openai-codex/constants.ts

@@ -0,0 +1,61 @@
+export const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+
+export const MAX_RETRIES = 3;
+
+export const BASE_DELAY_MS = 1000;
+
+export const SSE_RESPONSE_HEADER_TIMEOUT_MS = 20_000;
+
+export const WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
+
+export const WEBSOCKET_PREWARM_TIMEOUT_MS = 15_000;
+
+export const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
+
+export const WEBSOCKET_SEND_TIMEOUT_MS = 300_000;
+
+export const WEBSOCKET_EVENT_QUEUE_CAPACITY = 1600;
+
+export const DEFAULT_WEBSOCKET_STREAM_MAX_RETRIES = 5;
+
+export const MAX_WEBSOCKET_STREAM_MAX_RETRIES = 100;
+
+export const WEBSOCKET_RETRY_BASE_DELAY_MS = 200;
+
+export const WEBSOCKET_RETRY_MAX_DELAY_MS = 60_000;
+
+export const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+
+export const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
+
+export const PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
+
+export const CODEX_RESPONSE_STATUSES = new Set(["completed", "incomplete", "failed", "cancelled", "queued", "in_progress"]);
+
+export const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
+
+export const X_OPENAI_INTERNAL_CODEX_RESPONSES_LITE = "x-openai-internal-codex-responses-lite";
+
+export const WS_RESPONSES_LITE_CLIENT_METADATA_KEY = "ws_request_header_x_openai_internal_codex_responses_lite";
+
+export const WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY = "x-codex-ws-stream-request-start-ms";
+
+export const WEB_SEARCH_SOURCES_INCLUDE = "web_search_call.action.sources";
+
+export const WEB_SEARCH_RESULTS_INCLUDE = "web_search_call.results";
+
+export const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
+
+export const CODEX_COMPACTION_TRIGGER_TYPE = "compaction_trigger";
+
+export const CODEX_RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
+
+export const CODEX_MAX_RETAINED_AGENT_MESSAGE_TOKENS = 10_000;
+
+export const CODEX_REMOTE_COMPACTION_STREAM_RETRIES = 2;
+
+export const X_CODEX_BETA_FEATURES = "x-codex-beta-features";
+
+export const CODEX_REMOTE_COMPACTION_V2_FEATURE = "remote_compaction_v2";
+
+export const APPROX_BYTES_PER_TOKEN = 4;

package/src/providers/openai-codex/continuation.ts

@@ -0,0 +1,110 @@
+import { type CachedWebSocketContinuationState, type ResponsesBody, type SessionWebSocketCacheEntry } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+function requestBodyWithoutInput(body: ResponsesBody): ResponsesBody {
+	const {
+		input: _input,
+		previous_response_id: _previousResponseId,
+		client_metadata: _clientMetadata,
+		stream_options: _streamOptions,
+		generate: _generate,
+		...rest
+	} = body;
+	return rest as ResponsesBody;
+}
+
+function normalizeResponseItemForComparison(value: unknown): unknown {
+	if (Array.isArray(value)) return value.map(normalizeResponseItemForComparison);
+	if (!value || typeof value !== "object") return value;
+	const result: Record<string, unknown> = {};
+	for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+		if (key === "internal_chat_message_metadata_passthrough") continue;
+		result[key] = normalizeResponseItemForComparison(entry);
+	}
+	return result;
+}
+
+function stableJson(value: unknown): string {
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+	if (value && typeof value === "object") {
+		return `{${Object.entries(value as Record<string, unknown>)
+			.sort(([left], [right]) => left.localeCompare(right))
+			.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+			.join(",")}}`;
+	}
+	return JSON.stringify(value) ?? "undefined";
+}
+
+function responseInputsEqual(a: unknown[] | undefined, b: unknown[] | undefined): boolean {
+	const left = a ?? [];
+	const right = b ?? [];
+	if (left.length !== right.length) return false;
+	return left.every((item, index) =>
+		stableJson(normalizeResponseItemForComparison(item))
+		=== stableJson(normalizeResponseItemForComparison(right[index])));
+}
+
+function requestBodiesMatchExceptInput(a: ResponsesBody, b: ResponsesBody): boolean {
+	return stableJson(requestBodyWithoutInput(a)) === stableJson(requestBodyWithoutInput(b));
+}
+
+function getCachedWebSocketInputDelta(body: ResponsesBody, continuation: CachedWebSocketContinuationState): unknown[] | undefined {
+	if (!requestBodiesMatchExceptInput(body, continuation.lastRequestBody)) {
+		return undefined;
+	}
+
+	const currentInput = body.input ?? [];
+	const baseline = [...(continuation.lastRequestBody.input ?? []), ...continuation.lastResponseItems];
+	if (currentInput.length < baseline.length) {
+		return undefined;
+	}
+
+	const prefix = currentInput.slice(0, baseline.length);
+	if (!responseInputsEqual(prefix, baseline)) {
+		return undefined;
+	}
+
+	return currentInput.slice(baseline.length);
+}
+
+export function buildCachedWebSocketRequestBody(
+	entry: SessionWebSocketCacheEntry,
+	body: ResponsesBody,
+): ResponsesBody {
+	const continuation = entry.continuation;
+	if (!continuation) {
+		return body;
+	}
+
+	const delta = getCachedWebSocketInputDelta(body, continuation);
+	if (delta === undefined || !continuation.lastResponseId) {
+		entry.continuation = undefined;
+		return body;
+	}
+	return {
+		...body,
+		previous_response_id: continuation.lastResponseId,
+		input: delta,
+	};
+}
+
+function isPrefixedResponseItemId(value: string): boolean {
+	const separator = value.indexOf("_");
+	return separator > 0 && separator < value.length - 1;
+}
+
+function prepareResponseItemsForWire(items: unknown[]): unknown[] {
+	return items.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+		const record = item as Record<string, unknown>;
+		if (typeof record.id !== "string" || isPrefixedResponseItemId(record.id)) return item;
+		const { id: _id, ...rest } = record;
+		return rest;
+	});
+}
+
+export function prepareWebSocketRequestBodyForWire(body: ResponsesBody): ResponsesBody {
+	return {
+		...body,
+		input: prepareResponseItemsForWire(body.input ?? []),
+	};
+}