ghc-proxy 0.5.1 → 0.5.3

package/dist/main.mjs

@@ -5378,7 +5378,11 @@ const configFileSchema = object({
 	smallModel: string().optional(),
 	compactUseSmallModel: boolean().optional(),
 	useFunctionApplyPatch: boolean().optional(),
+	responsesApiAutoCompactInput: boolean().optional(),
+	responsesApiAutoContextManagement: boolean().optional(),
 	responsesApiContextManagementModels: array(string()).optional(),
+	responsesOfficialEmulator: boolean().optional(),
+	responsesOfficialEmulatorTtlSeconds: number().int().positive().optional(),
 	modelReasoningEfforts: record(string(), reasoningEffortSchema).optional(),
 	modelRewrites: array(object({
 		from: string(),
@@ -5392,6 +5396,10 @@ let cachedConfig = {};
 const DEFAULT_REASONING_EFFORT = "high";
 const DEFAULT_USE_FUNCTION_APPLY_PATCH = true;
 const DEFAULT_COMPACT_USE_SMALL_MODEL = false;
+const DEFAULT_RESPONSES_API_AUTO_COMPACT_INPUT = false;
+const DEFAULT_RESPONSES_API_AUTO_CONTEXT_MANAGEMENT = false;
+const DEFAULT_RESPONSES_OFFICIAL_EMULATOR = false;
+const DEFAULT_RESPONSES_OFFICIAL_EMULATOR_TTL_SECONDS = 14400;
 const DEFAULT_CONTEXT_UPGRADE = true;
 const DEFAULT_CONTEXT_UPGRADE_TOKEN_THRESHOLD = 16e4;
 async function readConfig() {
@@ -5439,9 +5447,19 @@ function shouldCompactUseSmallModel() {
 function shouldUseFunctionApplyPatch() {
 	return cachedConfig.useFunctionApplyPatch ?? DEFAULT_USE_FUNCTION_APPLY_PATCH;
 }
+function shouldAutoCompactResponsesInput() {
+	return cachedConfig.responsesApiAutoCompactInput ?? DEFAULT_RESPONSES_API_AUTO_COMPACT_INPUT;
+}
 function isResponsesApiContextManagementModel(model) {
+	if (!(cachedConfig.responsesApiAutoContextManagement ?? DEFAULT_RESPONSES_API_AUTO_CONTEXT_MANAGEMENT)) return false;
 	return cachedConfig.responsesApiContextManagementModels?.includes(model) ?? false;
 }
+function shouldUseResponsesOfficialEmulator() {
+	return cachedConfig.responsesOfficialEmulator ?? DEFAULT_RESPONSES_OFFICIAL_EMULATOR;
+}
+function getResponsesOfficialEmulatorTtlSeconds() {
+	return cachedConfig.responsesOfficialEmulatorTtlSeconds ?? DEFAULT_RESPONSES_OFFICIAL_EMULATOR_TTL_SECONDS;
+}
 function shouldContextUpgrade() {
 	return cachedConfig.contextUpgrade ?? DEFAULT_CONTEXT_UPGRADE;
 }
@@ -5698,6 +5716,9 @@ function fromTranslationFailure(failure) {
 		type: "translation_error"
 	} });
 }
+function previewBody(text, maxLength = 500) {
+	return text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
+}
 function isStructuredErrorPayload(value) {
 	return typeof value === "object" && value !== null && "error" in value && typeof value.error === "object" && value.error !== null;
 }
@@ -5706,12 +5727,13 @@ function isStructuredErrorPayload(value) {
 * Used by CopilotClient when upstream returns a non-OK response.
 */
 async function throwUpstreamError(message, response) {
+	let rawText = "";
 	let body;
 	try {
-		const text = await response.text();
-		const json = JSON.parse(text);
+		rawText = await response.text();
+		const json = JSON.parse(rawText);
 		body = isStructuredErrorPayload(json) ? json : { error: {
-			message: text,
+			message: rawText,
 			type: "upstream_error"
 		} };
 	} catch {
@@ -5720,7 +5742,13 @@ async function throwUpstreamError(message, response) {
 			type: "upstream_error"
 		} };
 	}
-	consola.error("Upstream error:", body);
+	consola.error("Upstream error:", {
+		status: response.status,
+		statusText: response.statusText,
+		url: response.url,
+		body,
+		rawBody: rawText ? previewBody(rawText) : "<empty>"
+	});
 	throw new HTTPError(response.status, body);
 }
 
@@ -5751,10 +5779,7 @@ var CopilotClient = class {
 			body: options.body,
 			signal: options.signal
 		});
-		if (!response.ok) {
-			consola.error(errorMessage, response);
-			await throwUpstreamError(errorMessage, response);
-		}
+		if (!response.ok) await throwUpstreamError(errorMessage, response);
 		return response;
 	}
 	/** Fetch and parse JSON response */
@@ -6022,6 +6047,221 @@ async function getVSCodeVersion() {
 	return remoteVersion ?? localVersion ?? FALLBACK;
 }
 
+//#endregion
+//#region src/lib/responses-emulator-state.ts
+function cloneValue$1(value) {
+	if (typeof globalThis.structuredClone === "function") return globalThis.structuredClone(value);
+	return JSON.parse(JSON.stringify(value));
+}
+function currentTime() {
+	return Date.now();
+}
+function resolveTtlSeconds(ttlSeconds) {
+	const resolved = ttlSeconds ?? getResponsesOfficialEmulatorTtlSeconds();
+	if (!Number.isFinite(resolved) || resolved <= 0) return getResponsesOfficialEmulatorTtlSeconds();
+	return Math.floor(resolved);
+}
+function toExpiresAt(ttlSeconds, at = currentTime()) {
+	return at + resolveTtlSeconds(ttlSeconds) * 1e3;
+}
+function responseKeyFromConversation(conversation) {
+	return typeof conversation === "string" ? conversation : conversation.id;
+}
+function createResponsesEmulatorState() {
+	const responseRecords = /* @__PURE__ */ new Map();
+	const conversationRecords = /* @__PURE__ */ new Map();
+	const conversationHeadRecords = /* @__PURE__ */ new Map();
+	const inputItemRecords = /* @__PURE__ */ new Map();
+	const responseDeletionFlags = /* @__PURE__ */ new Map();
+	const conversationDeletionFlags = /* @__PURE__ */ new Map();
+	const inputItemDeletionFlags = /* @__PURE__ */ new Map();
+	function pruneMap(map, at = currentTime()) {
+		for (const [key, entry] of map) if (entry.expiresAt <= at) map.delete(key);
+	}
+	function readMap(map, key, at = currentTime()) {
+		const entry = map.get(key);
+		if (!entry) return;
+		if (entry.expiresAt <= at) {
+			map.delete(key);
+			return;
+		}
+		return cloneValue$1(entry.value);
+	}
+	function writeMap(map, key, value, ttlSeconds, at = currentTime()) {
+		const cloned = cloneValue$1(value);
+		map.set(key, {
+			expiresAt: toExpiresAt(ttlSeconds, at),
+			value: cloned
+		});
+		return cloneValue$1(cloned);
+	}
+	function deleteMapEntry(map, key) {
+		return map.delete(key);
+	}
+	function putDeletionFlag(map, id, ttlSeconds, at = currentTime()) {
+		const flag = {
+			deleted: true,
+			deletedAt: at,
+			expiresAt: toExpiresAt(ttlSeconds, at)
+		};
+		map.set(id, {
+			expiresAt: flag.expiresAt,
+			value: flag
+		});
+		return cloneValue$1(flag);
+	}
+	function readDeletionFlag(map, id, at = currentTime()) {
+		return readMap(map, id, at);
+	}
+	function removeDeletionFlag(map, id) {
+		map.delete(id);
+	}
+	function deletionMap(kind) {
+		switch (kind) {
+			case "response": return responseDeletionFlags;
+			case "conversation": return conversationDeletionFlags;
+			case "input_items": return inputItemDeletionFlags;
+		}
+	}
+	function pruneExpiredRecords(at = currentTime()) {
+		pruneMap(responseRecords, at);
+		pruneMap(conversationRecords, at);
+		pruneMap(conversationHeadRecords, at);
+		pruneMap(inputItemRecords, at);
+		pruneMap(responseDeletionFlags, at);
+		pruneMap(conversationDeletionFlags, at);
+		pruneMap(inputItemDeletionFlags, at);
+	}
+	return {
+		isEnabled() {
+			return shouldUseResponsesOfficialEmulator();
+		},
+		getDefaultTtlSeconds() {
+			return getResponsesOfficialEmulatorTtlSeconds();
+		},
+		clear() {
+			responseRecords.clear();
+			conversationRecords.clear();
+			conversationHeadRecords.clear();
+			inputItemRecords.clear();
+			responseDeletionFlags.clear();
+			conversationDeletionFlags.clear();
+			inputItemDeletionFlags.clear();
+		},
+		pruneExpired(nowValue) {
+			pruneExpiredRecords(nowValue ?? currentTime());
+		},
+		snapshot(nowValue) {
+			pruneExpiredRecords(nowValue ?? currentTime());
+			return {
+				responses: responseRecords.size,
+				conversations: conversationRecords.size,
+				conversationHeads: conversationHeadRecords.size,
+				inputItems: inputItemRecords.size,
+				deletions: responseDeletionFlags.size + conversationDeletionFlags.size + inputItemDeletionFlags.size
+			};
+		},
+		setResponse(response, options) {
+			pruneExpiredRecords();
+			removeDeletionFlag(responseDeletionFlags, response.id);
+			if (response.conversation !== void 0 && response.conversation !== null) {
+				const conversationId = responseKeyFromConversation(response.conversation);
+				writeMap(conversationRecords, conversationId, response.conversation, options?.ttlSeconds);
+				writeMap(conversationHeadRecords, conversationId, response.id, options?.ttlSeconds);
+				removeDeletionFlag(conversationDeletionFlags, conversationId);
+			}
+			return writeMap(responseRecords, response.id, response, options?.ttlSeconds);
+		},
+		getResponse(responseId) {
+			pruneExpiredRecords();
+			if (readDeletionFlag(responseDeletionFlags, responseId)) return;
+			return readMap(responseRecords, responseId);
+		},
+		deleteResponse(responseId, options) {
+			pruneExpiredRecords();
+			const existing = readMap(responseRecords, responseId);
+			deleteMapEntry(responseRecords, responseId);
+			deleteMapEntry(inputItemRecords, responseId);
+			putDeletionFlag(responseDeletionFlags, responseId, options?.ttlSeconds);
+			putDeletionFlag(inputItemDeletionFlags, responseId, options?.ttlSeconds);
+			if (existing?.conversation) {
+				const conversationId = responseKeyFromConversation(existing.conversation);
+				if (readMap(conversationHeadRecords, conversationId) === responseId) deleteMapEntry(conversationHeadRecords, conversationId);
+			}
+			return {
+				id: responseId,
+				object: "response.deleted",
+				deleted: true
+			};
+		},
+		setConversation(conversation, options) {
+			pruneExpiredRecords();
+			const conversationId = responseKeyFromConversation(conversation);
+			removeDeletionFlag(conversationDeletionFlags, conversationId);
+			return writeMap(conversationRecords, conversationId, conversation, options?.ttlSeconds);
+		},
+		getConversation(conversationId) {
+			pruneExpiredRecords();
+			if (readDeletionFlag(conversationDeletionFlags, conversationId)) return;
+			return readMap(conversationRecords, conversationId);
+		},
+		deleteConversation(conversationId, options) {
+			pruneExpiredRecords();
+			deleteMapEntry(conversationRecords, conversationId);
+			deleteMapEntry(conversationHeadRecords, conversationId);
+			putDeletionFlag(conversationDeletionFlags, conversationId, options?.ttlSeconds);
+			return {
+				id: conversationId,
+				object: "conversation.deleted",
+				deleted: true
+			};
+		},
+		setConversationHead(conversationId, responseId, options) {
+			pruneExpiredRecords();
+			return writeMap(conversationHeadRecords, conversationId, responseId, options?.ttlSeconds);
+		},
+		getConversationHead(conversationId) {
+			pruneExpiredRecords();
+			return readMap(conversationHeadRecords, conversationId);
+		},
+		clearConversationHead(conversationId) {
+			deleteMapEntry(conversationHeadRecords, conversationId);
+		},
+		setInputItems(responseId, inputItems, options) {
+			pruneExpiredRecords();
+			removeDeletionFlag(inputItemDeletionFlags, responseId);
+			return writeMap(inputItemRecords, responseId, inputItems, options?.ttlSeconds);
+		},
+		getInputItems(responseId) {
+			pruneExpiredRecords();
+			if (readDeletionFlag(inputItemDeletionFlags, responseId)) return;
+			return readMap(inputItemRecords, responseId);
+		},
+		deleteInputItems(responseId, options) {
+			pruneExpiredRecords();
+			deleteMapEntry(inputItemRecords, responseId);
+			putDeletionFlag(inputItemDeletionFlags, responseId, options?.ttlSeconds);
+			return {
+				id: responseId,
+				object: "response.input_items.deleted",
+				deleted: true
+			};
+		},
+		setDeletionFlag(kind, id, options) {
+			pruneExpiredRecords();
+			return putDeletionFlag(deletionMap(kind), id, options?.ttlSeconds);
+		},
+		getDeletionFlag(kind, id) {
+			pruneExpiredRecords();
+			return readDeletionFlag(deletionMap(kind), id);
+		},
+		clearDeletionFlag(kind, id) {
+			removeDeletionFlag(deletionMap(kind), id);
+		}
+	};
+}
+const responsesEmulatorState = createResponsesEmulatorState();
+
 //#endregion
 //#region src/lib/state.ts
 const state = {
@@ -6033,7 +6273,8 @@ const state = {
 		showToken: false
 	},
 	cache: {},
-	rateLimit: {}
+	rateLimit: {},
+	responsesEmulator: responsesEmulatorState
 };
 function getClientConfig() {
 	return {
@@ -6225,7 +6466,7 @@ const checkUsage = defineCommand({
 
 //#endregion
 //#region src/lib/version.ts
-const VERSION = "0.5.1";
+const VERSION = "0.5.3";
 
 //#endregion
 //#region src/debug.ts
@@ -46711,8 +46952,8 @@ function inferModelFamily(model) {
 const baseProfile = {
 	id: "base",
 	family: "other",
-	enableCacheControl: false,
-	includeUsageOnStream: false,
+	enableCacheControl: true,
+	includeUsageOnStream: true,
 	applyThinking(request) {
 		const thinking = request.thinking;
 		if (!thinking || thinking.type === "disabled") return {};
@@ -46740,6 +46981,9 @@ function selectCapiProfile(model) {
 
 //#endregion
 //#region src/core/capi/request-context.ts
+const SUBAGENT_MARKER_PREFIX = "__SUBAGENT_MARKER__";
+const SYSTEM_REMINDER_OPEN_TAG = "<system-reminder>";
+const SYSTEM_REMINDER_CLOSE_TAG = "</system-reminder>";
 function readHeader(headers, name) {
 	return headers.get(name) ?? void 0;
 }
@@ -46751,11 +46995,20 @@ function readCapiRequestContext(headers) {
 		interactionType: readHeader(headers, "x-interaction-type"),
 		agentTaskId: readHeader(headers, "x-agent-task-id"),
 		parentAgentTaskId: readHeader(headers, "x-parent-agent-id"),
-		clientSessionId: readHeader(headers, "x-client-session-id"),
+		clientSessionId: readHeader(headers, "x-client-session-id") ?? readHeader(headers, "x-session-id"),
 		interactionId: readHeader(headers, "x-interaction-id"),
 		clientMachineId: readHeader(headers, "x-client-machine-id")
 	};
 }
+function resolveInitiator(defaultInitiator, requestContext) {
+	switch (requestContext?.interactionType) {
+		case "conversation-agent":
+		case "conversation-subagent":
+		case "conversation-background": return "agent";
+		case "conversation-user": return "user";
+		default: return defaultInitiator;
+	}
+}
 function buildCapiRequestContext(initiator, overrides = {}) {
 	return {
 		interactionType: overrides.interactionType ?? (initiator === "agent" ? "conversation-agent" : "conversation-user"),
@@ -46766,6 +47019,269 @@ function buildCapiRequestContext(initiator, overrides = {}) {
 		clientMachineId: overrides.clientMachineId
 	};
 }
+function normalizeAnthropicRequestContext(payload, headers) {
+	return withSubagentMarker(readCapiRequestContext(headers), headers, stripSubagentMarkerFromAnthropicPayload(payload));
+}
+function normalizeChatRequestContext(payload, headers) {
+	return withSubagentMarker(readCapiRequestContext(headers), headers, stripSubagentMarkerFromChatPayload(payload));
+}
+function normalizeResponsesRequestContext(payload, headers) {
+	return withSubagentMarker(readCapiRequestContext(headers), headers, stripSubagentMarkerFromResponsesPayload(payload));
+}
+function withSubagentMarker(baseContext, headers, marker) {
+	if (!marker) return baseContext;
+	const rootSessionId = readHeader(headers, "x-session-id") ?? baseContext.clientSessionId;
+	return {
+		...baseContext,
+		interactionType: baseContext.interactionType && baseContext.interactionType !== "conversation-user" ? baseContext.interactionType : "conversation-subagent",
+		agentTaskId: baseContext.agentTaskId ?? marker.agent_id ?? marker.session_id,
+		clientSessionId: baseContext.clientSessionId ?? rootSessionId ?? marker.session_id
+	};
+}
+function stripSubagentMarkerFromAnthropicPayload(payload) {
+	let marker;
+	if (typeof payload.system === "string") {
+		const result = stripSubagentMarkerFromText(payload.system);
+		payload.system = result.text || void 0;
+		marker ??= result.marker;
+	} else if (Array.isArray(payload.system)) {
+		payload.system = payload.system.map((block) => {
+			const result = stripSubagentMarkerFromText(block.text);
+			marker ??= result.marker;
+			return result.text ? {
+				...block,
+				text: result.text
+			} : void 0;
+		}).filter((block) => block !== void 0);
+		if (payload.system.length === 0) payload.system = void 0;
+	}
+	payload.messages = payload.messages.map((message) => {
+		const sanitized = sanitizeAnthropicMessage(message);
+		marker ??= sanitized.marker;
+		return sanitized.message;
+	}).filter((message) => message !== void 0);
+	return marker;
+}
+function sanitizeAnthropicMessage(message) {
+	if (typeof message.content === "string") {
+		const result = stripSubagentMarkerFromText(message.content);
+		return {
+			marker: result.marker,
+			message: result.text ? {
+				...message,
+				content: result.text
+			} : void 0
+		};
+	}
+	if (message.role === "user") {
+		let marker;
+		const content = message.content.map((block) => {
+			if (block.type !== "text") return block;
+			const result = stripSubagentMarkerFromText(block.text);
+			marker ??= result.marker;
+			return result.text ? {
+				...block,
+				text: result.text
+			} : void 0;
+		}).filter((block) => block !== void 0);
+		return {
+			marker,
+			message: content.length > 0 ? {
+				...message,
+				content
+			} : void 0
+		};
+	}
+	let marker;
+	const content = message.content.map((block) => {
+		if (block.type !== "text") return block;
+		const result = stripSubagentMarkerFromText(block.text);
+		marker ??= result.marker;
+		return result.text ? {
+			...block,
+			text: result.text
+		} : void 0;
+	}).filter((block) => block !== void 0);
+	return {
+		marker,
+		message: content.length > 0 ? {
+			...message,
+			content
+		} : void 0
+	};
+}
+function stripSubagentMarkerFromChatPayload(payload) {
+	let marker;
+	payload.messages = payload.messages.map((message) => {
+		const sanitized = sanitizeChatMessage(message);
+		marker ??= sanitized.marker;
+		return sanitized.message;
+	}).filter((message) => message !== void 0);
+	return marker;
+}
+function sanitizeChatMessage(message) {
+	if (typeof message.content === "string") {
+		const result = stripSubagentMarkerFromText(message.content);
+		return {
+			marker: result.marker,
+			message: result.text || message.tool_calls?.length ? {
+				...message,
+				content: result.text
+			} : void 0
+		};
+	}
+	if (message.content === null) return { message };
+	let marker;
+	const content = message.content.map((part) => {
+		if (part.type !== "text") return part;
+		const result = stripSubagentMarkerFromText(part.text);
+		marker ??= result.marker;
+		return result.text ? {
+			...part,
+			text: result.text
+		} : void 0;
+	}).filter((part) => part !== void 0);
+	return {
+		marker,
+		message: content.length > 0 || message.tool_calls?.length ? {
+			...message,
+			content
+		} : void 0
+	};
+}
+function stripSubagentMarkerFromResponsesPayload(payload) {
+	let marker;
+	if (typeof payload.instructions === "string") {
+		const result = stripSubagentMarkerFromText(payload.instructions);
+		payload.instructions = result.text || void 0;
+		marker ??= result.marker;
+	}
+	if (typeof payload.input === "string") {
+		const result = stripSubagentMarkerFromText(payload.input);
+		payload.input = result.text || null;
+		marker ??= result.marker;
+		return marker;
+	}
+	if (!Array.isArray(payload.input)) return marker;
+	payload.input = payload.input.map((item) => {
+		const sanitized = sanitizeResponsesInputItem(item);
+		marker ??= sanitized.marker;
+		return sanitized.item;
+	}).filter((item) => item !== void 0);
+	return marker;
+}
+function sanitizeResponsesInputItem(item) {
+	if (!("type" in item) || item.type !== "message") return { item };
+	if (typeof item.content === "string") {
+		const result = stripSubagentMarkerFromText(item.content);
+		return {
+			marker: result.marker,
+			item: result.text ? {
+				...item,
+				content: result.text
+			} : void 0
+		};
+	}
+	if (!Array.isArray(item.content)) return { item };
+	let marker;
+	const content = item.content.map((part) => {
+		const sanitized = sanitizeResponsesInputContent(part);
+		marker ??= sanitized.marker;
+		return sanitized.content;
+	}).filter((part) => part !== void 0);
+	return {
+		marker,
+		item: content.length > 0 ? {
+			...item,
+			content
+		} : void 0
+	};
+}
+function sanitizeResponsesInputContent(content) {
+	if (!("type" in content)) return { content };
+	if (content.type !== "input_text" && content.type !== "output_text") return { content };
+	if (typeof content.text !== "string") return { content };
+	const result = stripSubagentMarkerFromText(content.text);
+	return {
+		marker: result.marker,
+		content: result.text ? {
+			...content,
+			text: result.text
+		} : void 0
+	};
+}
+function stripSubagentMarkerFromText(text) {
+	const markerMatch = findSubagentMarker(text);
+	if (!markerMatch) return { text };
+	const removalRange = findReminderRange(text, markerMatch.start, markerMatch.end);
+	const before = text.slice(0, removalRange.start).trimEnd();
+	const after = text.slice(removalRange.end).trimStart();
+	return {
+		marker: markerMatch.marker,
+		text: before && after ? `${before}\n${after}` : `${before}${after}`
+	};
+}
+function findSubagentMarker(text) {
+	const markerIndex = text.indexOf(SUBAGENT_MARKER_PREFIX);
+	if (markerIndex < 0) return;
+	const jsonStart = text.indexOf("{", markerIndex + 19);
+	if (jsonStart < 0) return;
+	const jsonEnd = findJsonObjectEnd(text, jsonStart);
+	if (jsonEnd < 0) return;
+	try {
+		const parsed = JSON.parse(text.slice(jsonStart, jsonEnd));
+		if (!parsed || typeof parsed !== "object") return;
+		return {
+			marker: parsed,
+			start: markerIndex,
+			end: jsonEnd
+		};
+	} catch {
+		return;
+	}
+}
+function findReminderRange(text, markerStart, markerEnd) {
+	const reminderStart = text.lastIndexOf(SYSTEM_REMINDER_OPEN_TAG, markerStart);
+	const reminderEnd = text.indexOf(SYSTEM_REMINDER_CLOSE_TAG, markerEnd);
+	if (reminderStart >= 0 && reminderEnd >= 0) return {
+		start: reminderStart,
+		end: reminderEnd + 18
+	};
+	return {
+		start: markerStart,
+		end: markerEnd
+	};
+}
+function findJsonObjectEnd(text, start) {
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let index = start; index < text.length; index++) {
+		const char = text[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === "\"") {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (char === "{") {
+			depth++;
+			continue;
+		}
+		if (char === "}") {
+			depth--;
+			if (depth === 0) return index + 1;
+		}
+	}
+	return -1;
+}
 
 //#endregion
 //#region src/core/capi/plan-builder.ts
@@ -46944,7 +47460,7 @@ function stripTransportFields(payload) {
 function buildCapiExecutionPlan(request, options = {}) {
 	const resolvedModel = options.resolveModel?.(request.model) ?? request.model;
 	const profile = selectCapiProfile(resolvedModel);
-	const initiator = inferInitiator(request.turns);
+	const initiator = resolveInitiator(inferInitiator(request.turns), options.requestContext);
 	const payload = {
 		model: resolvedModel,
 		messages: serializeTurns(request.turns),
@@ -48262,6 +48778,9 @@ async function getTokenCount(payload, model) {
 		output: outputTokens
 	};
 }
+async function estimateResponsesInputTokens(inputItems, model) {
+	return (await getEncoder(getTokenizerFromModel(model))).encode(JSON.stringify(inputItems)).length;
+}
 /**
 * Fast character-based token estimate for Anthropic payloads.
 * Uses ~3.5 chars/token ratio (conservative for Claude's tokenizer).
@@ -48467,7 +48986,10 @@ function parseAnthropicCountTokensPayload(payload) {
 //#region src/lib/validation/embeddings.ts
 const embeddingRequestSchema = object({
 	input: union([string(), array(string())]),
-	model: string().min(1)
+	model: string().min(1),
+	dimensions: nonNegativeIntegerSchema.optional(),
+	encoding_format: _enum(["float", "base64"]).optional(),
+	user: string().min(1).optional()
 }).loose();
 function parseEmbeddingRequest(payload) {
 	return parsePayload(embeddingRequestSchema, "openai.embeddings", payload);
@@ -48725,7 +49247,7 @@ const responsesFunctionToolSchema = object({
 	type: literal("function"),
 	name: string().min(1),
 	parameters: jsonObjectSchema.nullable().optional(),
-	strict: boolean().nullable().optional(),
+	strict: boolean().optional(),
 	description: string().nullable().optional()
 }).loose();
 const responsesUnknownToolSchema = object({ type: string().min(1) }).catchall(unknown()).superRefine((tool, ctx) => {
@@ -48739,9 +49261,33 @@ const responsesToolChoiceSchema = union([
 	literal("none"),
 	literal("auto"),
 	literal("required"),
+	object({
+		type: literal("allowed_tools"),
+		mode: _enum(["auto", "required"]),
+		tools: array(jsonObjectSchema)
+	}).loose(),
+	object({ type: _enum([
+		"file_search",
+		"web_search_preview",
+		"web_search_preview_2025_03_11",
+		"computer_use_preview",
+		"code_interpreter",
+		"image_generation",
+		"apply_patch",
+		"shell"
+	]) }).loose(),
 	object({
 		type: literal("function"),
 		name: string().min(1)
+	}).loose(),
+	object({
+		type: literal("mcp"),
+		server_label: string().min(1),
+		name: string().min(1).optional()
+	}).loose(),
+	object({
+		type: literal("custom"),
+		name: string().min(1)
 	}).loose()
 ]);
 const responsesReasoningConfigSchema = object({
@@ -48753,6 +49299,11 @@ const responsesReasoningConfigSchema = object({
 		"high",
 		"xhigh"
 	]).nullable().optional(),
+	generate_summary: _enum([
+		"auto",
+		"concise",
+		"detailed"
+	]).nullable().optional(),
 	summary: _enum([
 		"auto",
 		"concise",
@@ -48766,7 +49317,7 @@ const responsesTextFormatJsonSchemaSchema = object({
 	name: string().min(1),
 	schema: jsonObjectSchema,
 	description: string().nullable().optional(),
-	strict: boolean().nullable().optional()
+	strict: boolean().optional()
 }).loose();
 const responsesTextConfigSchema = object({
 	format: union([
@@ -48784,9 +49335,10 @@ const responsesContextManagementSchema = object({
 	type: literal("compaction"),
 	compact_threshold: nonNegativeIntegerSchema
 }).loose();
-const responsesConversationSchema = union([string().min(1), object({ id: string().nullable().optional() }).loose()]);
+const responsesConversationSchema = union([string().min(1), object({ id: string().min(1) }).loose()]);
 function createResponsesPayloadSchema(options) {
 	return object({
+		background: boolean().nullable().optional(),
 		model: options.requireModel ? string().min(1) : string().min(1).nullable().optional(),
 		instructions: string().nullable().optional(),
 		input: union([
@@ -48804,19 +49356,36 @@ function createResponsesPayloadSchema(options) {
 		max_tool_calls: nonNegativeIntegerSchema.nullable().optional(),
 		metadata: record(string(), string()).nullable().optional(),
 		stream: boolean().nullable().optional(),
+		stream_options: object({ include_obfuscation: boolean().nullable().optional() }).loose().nullable().optional(),
 		safety_identifier: string().nullable().optional(),
 		prompt_cache_key: string().nullable().optional(),
+		prompt_cache_retention: _enum(["in-memory", "24h"]).nullable().optional(),
 		truncation: _enum(["auto", "disabled"]).nullable().optional(),
 		parallel_tool_calls: boolean().nullable().optional(),
 		store: boolean().nullable().optional(),
 		user: string().nullable().optional(),
-		prompt: union([string().min(1), jsonObjectSchema]).nullable().optional(),
+		prompt: object({
+			id: string().min(1),
+			variables: record(string(), unknown()).optional(),
+			version: string().min(1).optional()
+		}).loose().nullable().optional(),
 		text: responsesTextConfigSchema.nullable().optional(),
 		reasoning: responsesReasoningConfigSchema.nullable().optional(),
 		context_management: array(responsesContextManagementSchema).nullable().optional(),
 		include: array(string().min(1)).nullable().optional(),
-		service_tier: string().nullable().optional()
+		service_tier: _enum([
+			"auto",
+			"default",
+			"flex",
+			"scale",
+			"priority"
+		]).nullable().optional()
 	}).loose().superRefine((payload, ctx) => {
+		if (payload.previous_response_id && payload.conversation) ctx.addIssue({
+			code: "custom",
+			message: "previous_response_id cannot be used together with conversation",
+			path: ["previous_response_id"]
+		});
 		const toolChoice = payload.tool_choice;
 		if (toolChoice && typeof toolChoice === "object" && "name" in toolChoice && typeof toolChoice.name === "string" && Array.isArray(payload.tools)) {
 			if (!payload.tools.filter((tool) => {
@@ -48871,6 +49440,7 @@ function createChatCompletionsStrategy(transport, adapter, plan, signal) {
 async function handleCompletionCore({ body, signal, headers }) {
 	const adapter = new OpenAIChatAdapter();
 	let payload = parseOpenAIChatPayload(body);
+	const requestContext = normalizeChatRequestContext(payload, headers);
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	const rewrite = applyModelRewrite(payload);
 	const originalModel = rewrite.originalModel;
@@ -48891,7 +49461,7 @@ async function handleCompletionCore({ body, signal, headers }) {
 		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
 	const upstreamSignal = createUpstreamSignalFromConfig(signal);
-	const plan = adapter.toCapiPlan(payload, { requestContext: readCapiRequestContext(headers) });
+	const plan = adapter.toCapiPlan(payload, { requestContext });
 	const modelMapping = {
 		originalModel,
 		rewrittenModel: rewrite.model,
@@ -48923,12 +49493,18 @@ function createCompletionRoutes() {
 
 //#endregion
 //#region src/routes/embeddings/handler.ts
+function normalizeEmbeddingRequest(payload) {
+	return {
+		...payload,
+		input: typeof payload.input === "string" ? [payload.input] : payload.input
+	};
+}
 /**
 * Core handler for creating embeddings.
 */
 async function handleEmbeddingsCore(body) {
 	const payload = parseEmbeddingRequest(body);
-	return await createCopilotClient().createEmbeddings(payload);
+	return await createCopilotClient().createEmbeddings(normalizeEmbeddingRequest(payload));
 }
 
 //#endregion
@@ -48956,16 +49532,23 @@ function createAnthropicAdapter() {
 
 //#endregion
 //#region src/routes/messages/count-tokens-handler.ts
-const CLAUDE_TOOL_OVERHEAD_TOKENS = 346;
-const GROK_TOOL_OVERHEAD_TOKENS = 480;
-const CLAUDE_ESTIMATION_FACTOR = 1.15;
-const GROK_ESTIMATION_FACTOR = 1.03;
+const TOOL_OVERHEAD_TOKENS = {
+	claude: 346,
+	grok: 480,
+	gpt: 346
+};
+const ESTIMATION_FACTOR = {
+	claude: 1.15,
+	grok: 1.03,
+	gpt: 1.1
+};
 /**
 * Core handler for counting tokens.
 */
 async function handleCountTokensCore({ body, headers }) {
 	const anthropicBeta = headers.get("anthropic-beta") ?? void 0;
 	const anthropicPayload = parseAnthropicCountTokensPayload(body);
+	normalizeAnthropicRequestContext(anthropicPayload, headers);
 	const adapter = createAnthropicAdapter();
 	let openAIPayload;
 	try {
@@ -48984,13 +49567,13 @@ async function handleCountTokensCore({ body, headers }) {
 		let mcpToolExist = false;
 		if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
 		if (!mcpToolExist) {
-			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + CLAUDE_TOOL_OVERHEAD_TOKENS;
-			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + GROK_TOOL_OVERHEAD_TOKENS;
+			const overhead = TOOL_OVERHEAD_TOKENS[inferModelFamily(anthropicPayload.model)];
+			if (overhead) tokenCount.input = tokenCount.input + overhead;
 		}
 	}
 	let finalTokenCount = tokenCount.input + tokenCount.output;
-	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * CLAUDE_ESTIMATION_FACTOR);
-	else if (anthropicPayload.model.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * GROK_ESTIMATION_FACTOR);
+	const factor = ESTIMATION_FACTOR[inferModelFamily(anthropicPayload.model)];
+	if (factor) finalTokenCount = Math.round(finalTokenCount * factor);
 	consola.info("Token count:", finalTokenCount);
 	return { input_tokens: finalTokenCount };
 }
@@ -49056,6 +49639,49 @@ function containsVisionContent$1(content) {
 	return content.some((block) => block.type === "image");
 }
 
+//#endregion
+//#region src/lib/function-schema.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const COPILOT_UNSUPPORTED_SCHEMA_ANNOTATIONS = new Set([
+	"$schema",
+	"$id",
+	"id",
+	"title",
+	"format",
+	"default",
+	"example",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"contentEncoding",
+	"contentMediaType"
+]);
+function normalizeSchemaNode(node) {
+	if (Array.isArray(node)) return node.map(normalizeSchemaNode);
+	if (!isRecord$2(node)) return node;
+	const normalized = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (COPILOT_UNSUPPORTED_SCHEMA_ANNOTATIONS.has(key)) continue;
+		if (key === "properties" && isRecord$2(value)) {
+			normalized[key] = Object.fromEntries(Object.entries(value).map(([propertyName, propertySchema]) => [propertyName, normalizeSchemaNode(propertySchema)]));
+			continue;
+		}
+		normalized[key] = normalizeSchemaNode(value);
+	}
+	if (node.type === "object" || isRecord$2(normalized.properties)) {
+		normalized.required = isRecord$2(normalized.properties) ? Object.keys(normalized.properties) : [];
+		normalized.additionalProperties = false;
+	}
+	return normalized;
+}
+function normalizeFunctionParametersSchemaForCopilot(schema) {
+	if (!schema) return schema;
+	return normalizeSchemaNode(schema);
+}
+
 //#endregion
 //#region src/translator/responses/signature-codec.ts
 const COMPACTION_PREFIX = "cm1#";
@@ -49188,12 +49814,15 @@ function translateAssistantMessage(message) {
 				continue;
 			}
 			if (SignatureCodec.isReasoningSignature(block.signature)) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
-				});
-				items.push(createReasoningContent(block));
-				continue;
+				const { id } = SignatureCodec.decodeReasoning(block.signature);
+				if (id) {
+					flushPendingContent(pendingContent, items, {
+						role: "assistant",
+						phase: assistantPhase
+					});
+					items.push(createReasoningContent(block));
+					continue;
+				}
 			}
 		}
 		const converted = translateAssistantContentBlock(block);
@@ -49313,7 +49942,7 @@ function convertAnthropicTools(tools) {
 	return tools.map((tool) => ({
 		type: "function",
 		name: tool.name,
-		parameters: tool.input_schema,
+		parameters: normalizeFunctionParametersSchemaForCopilot(tool.input_schema),
 		strict: false,
 		...tool.description ? { description: tool.description } : {}
 	}));
@@ -49426,6 +50055,7 @@ function applyContextManagement(payload, maxPromptTokens) {
 	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
 }
 function compactInputByLatestCompaction(payload) {
+	if (!shouldAutoCompactResponsesInput()) return;
 	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
 	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
 	if (latestCompactionMessageIndex === void 0) return;
@@ -49661,14 +50291,14 @@ function mapResponsesUsage(response) {
 		...cachedTokens !== void 0 ? { cache_read_input_tokens: cachedTokens } : {}
 	};
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
 function isResponseOutputText(block) {
-	return isRecord(block) && block.type === "output_text";
+	return isRecord$1(block) && block.type === "output_text";
 }
 function isResponseOutputRefusal(block) {
-	return isRecord(block) && block.type === "refusal";
+	return isRecord$1(block) && block.type === "refusal";
 }
 
 //#endregion
@@ -49831,6 +50461,7 @@ var ResponsesStreamTranslator = class {
 			this.closeScalarBlock(`thinking:${rawEvent.output_index}`, events);
 		}
 		if (rawEvent.item.type === "function_call") {
+			if (this.state.functionCallStateByOutputIndex.get(rawEvent.output_index)?.closed) return events;
 			const blockIndex = this.openFunctionCallBlock({
 				outputIndex: rawEvent.output_index,
 				toolCallId: rawEvent.item.call_id,
@@ -50272,6 +50903,7 @@ function processAnthropicBetaHeader(rawHeader, model) {
 */
 async function handleMessagesCore({ body, signal, headers }) {
 	const anthropicPayload = parseAnthropicMessagesPayload(body);
+	const requestContext = normalizeAnthropicRequestContext(anthropicPayload, headers);
 	if (consola.level >= 4) consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const rewrite = applyModelRewrite(anthropicPayload);
 	const betaResult = processAnthropicBetaHeader(headers.get("anthropic-beta"), anthropicPayload.model);
@@ -50298,7 +50930,7 @@ async function handleMessagesCore({ body, signal, headers }) {
 		selectedModel,
 		upstreamSignal,
 		headers,
-		requestContext: readCapiRequestContext(headers),
+		requestContext,
 		modelMapping
 	};
 	let strategyResult;
@@ -50380,8 +51012,246 @@ function createModelRoutes() {
 	});
 }
 
+//#endregion
+//#region src/routes/responses/emulator.ts
+function cloneValue(value) {
+	if (typeof globalThis.structuredClone === "function") return globalThis.structuredClone(value);
+	return JSON.parse(JSON.stringify(value));
+}
+function rejectUnsupportedBackground(payload) {
+	if (payload.background) throwInvalidRequestError("background mode is not supported by the responses official emulator.", "background", "unsupported_background_mode");
+}
+function prepareEmulatorRequest(payload) {
+	rejectUnsupportedBackground(payload);
+	const normalizedCurrentInput = normalizeResponsesInput(payload.input);
+	const { continuationSourceResponseId, conversation: resolvedConversation, previousResponse } = resolveContinuation(payload);
+	const conversation = resolvedConversation ?? createConversationRef();
+	const effectiveInputItems = [...continuationSourceResponseId ? buildContinuationHistory(continuationSourceResponseId) : [], ...normalizedCurrentInput];
+	const shouldStore = payload.store ?? true;
+	return {
+		upstreamPayload: {
+			...payload,
+			background: void 0,
+			conversation: void 0,
+			previous_response_id: void 0,
+			store: void 0,
+			input: effectiveInputItems
+		},
+		effectiveInputItems,
+		previousResponseId: previousResponse?.id,
+		conversation,
+		shouldStore
+	};
+}
+function decorateStoredResponse(upstreamResponse, requestPayload, prepared) {
+	return {
+		...cloneValue(upstreamResponse),
+		previous_response_id: prepared.previousResponseId ?? null,
+		conversation: prepared.conversation,
+		truncation: requestPayload.truncation ?? null,
+		store: prepared.shouldStore,
+		user: normalizeNullableString(requestPayload.user),
+		service_tier: normalizeServiceTier(requestPayload.service_tier)
+	};
+}
+function persistEmulatorResponse(response, effectiveInputItems) {
+	state.responsesEmulator.setResponse(response);
+	if (response.conversation) {
+		state.responsesEmulator.setConversation(response.conversation);
+		state.responsesEmulator.setConversationHead(getConversationId(response.conversation), response.id);
+	}
+	state.responsesEmulator.setInputItems(response.id, effectiveInputItems);
+}
+function getStoredResponseOrThrow(responseId) {
+	const response = state.responsesEmulator.getResponse(responseId);
+	if (!response) throw new HTTPError(404, { error: {
+		message: `No response found with id '${responseId}'.`,
+		type: "invalid_request_error"
+	} });
+	return response;
+}
+function listStoredInputItemsOrThrow(responseId, params) {
+	const items = state.responsesEmulator.getInputItems(responseId);
+	if (!items) throw new HTTPError(404, { error: {
+		message: `No response input items found for id '${responseId}'.`,
+		type: "invalid_request_error"
+	} });
+	let orderedItems = cloneValue(items);
+	if (params?.order === "desc") orderedItems.reverse();
+	if (params?.after) {
+		const afterIndex = orderedItems.findIndex((item) => getInputItemId(item) === params.after);
+		if (afterIndex >= 0) orderedItems = orderedItems.slice(afterIndex + 1);
+	}
+	const limitedItems = orderedItems.slice(0, params?.limit ?? orderedItems.length);
+	return {
+		object: "list",
+		data: limitedItems,
+		first_id: getInputItemId(limitedItems[0]) ?? null,
+		last_id: getInputItemId(limitedItems.at(-1)) ?? null,
+		has_more: limitedItems.length < orderedItems.length
+	};
+}
+function deleteStoredResponseOrThrow(responseId) {
+	getStoredResponseOrThrow(responseId);
+	return state.responsesEmulator.deleteResponse(responseId);
+}
+async function estimateEmulatorInputTokens(payload, selectedModel) {
+	return {
+		object: "response.input_tokens",
+		input_tokens: await estimateResponsesInputTokens(resolveEffectiveInputForInputTokens(payload), selectedModel)
+	};
+}
+function resolveEffectiveInputForInputTokens(payload) {
+	const normalizedInput = normalizeResponsesInput(payload.input);
+	const background = payload.background === null || typeof payload.background === "boolean" ? payload.background : void 0;
+	const conversation = isConversationReference(payload.conversation) ? payload.conversation : void 0;
+	const previousResponseId = typeof payload.previous_response_id === "string" ? payload.previous_response_id : void 0;
+	rejectUnsupportedBackground({ background });
+	const { continuationSourceResponseId } = resolveContinuation({
+		conversation,
+		previous_response_id: previousResponseId
+	});
+	if (continuationSourceResponseId) return [...buildContinuationHistory(continuationSourceResponseId), ...normalizedInput];
+	return normalizedInput;
+}
+function resolveContinuation(payload) {
+	const previousResponse = resolvePreviousResponse(payload.previous_response_id);
+	const conversation = resolveConversation(payload.conversation, previousResponse);
+	return {
+		previousResponse,
+		conversation,
+		continuationSourceResponseId: resolveContinuationSourceResponseId(previousResponse, conversation)
+	};
+}
+function resolvePreviousResponse(previousResponseId) {
+	if (typeof previousResponseId !== "string" || previousResponseId.length === 0) return;
+	const previousResponse = state.responsesEmulator.getResponse(previousResponseId);
+	if (!previousResponse) throwInvalidRequestError("The selected previous_response_id could not be resolved.", "previous_response_id");
+	return previousResponse;
+}
+function resolveConversation(conversation, previousResponse) {
+	if (isConversationReference(conversation)) {
+		const conversationId = getConversationId(conversation);
+		const existingConversation = state.responsesEmulator.getConversation(conversationId);
+		if (!existingConversation) throwInvalidRequestError("The selected conversation could not be resolved.", "conversation");
+		if (previousResponse?.conversation && getConversationId(previousResponse.conversation) !== conversationId) throwInvalidRequestError("The selected previous_response_id does not belong to the selected conversation.", "previous_response_id");
+		return existingConversation;
+	}
+	return previousResponse?.conversation ?? void 0;
+}
+function resolveContinuationSourceResponseId(previousResponse, conversation) {
+	if (previousResponse) return previousResponse.id;
+	if (!conversation) return;
+	const head = state.responsesEmulator.getConversationHead(getConversationId(conversation));
+	if (!head) throwInvalidRequestError("The selected conversation could not be resolved.", "conversation");
+	return head;
+}
+function buildContinuationHistory(responseId) {
+	const previousResponse = getStoredResponseOrThrow(responseId);
+	const previousInput = state.responsesEmulator.getInputItems(responseId);
+	if (!previousInput) throwInvalidRequestError("The selected previous_response_id is missing stored input items.", "previous_response_id");
+	return [...cloneValue(previousInput), ...convertOutputItemsToInputItems(previousResponse.output)];
+}
+function normalizeResponsesInput(input) {
+	if (!input) return [];
+	if (typeof input === "string") return [{
+		type: "message",
+		role: "user",
+		content: input
+	}];
+	if (Array.isArray(input)) return cloneValue(input);
+	return [];
+}
+function convertOutputItemsToInputItems(output) {
+	const items = [];
+	for (const item of output) switch (item.type) {
+		case "message":
+			items.push(convertMessageOutputToInput(item));
+			break;
+		case "function_call":
+			items.push(convertFunctionCallOutputToInput(item));
+			break;
+		case "reasoning": {
+			const reasoningInput = convertReasoningOutputToInput(item);
+			if (reasoningInput) items.push(reasoningInput);
+			break;
+		}
+		case "compaction":
+			items.push(convertCompactionOutputToInput(item));
+			break;
+	}
+	return items;
+}
+function convertMessageOutputToInput(item) {
+	return {
+		type: "message",
+		role: item.role,
+		status: item.status,
+		content: item.content?.map((content) => {
+			if (content.type === "output_text" && typeof content.text === "string") return {
+				type: "output_text",
+				text: content.text
+			};
+			return cloneValue(content);
+		}) ?? []
+	};
+}
+function convertFunctionCallOutputToInput(item) {
+	return {
+		type: "function_call",
+		call_id: item.call_id,
+		name: item.name,
+		arguments: item.arguments,
+		status: item.status
+	};
+}
+function convertReasoningOutputToInput(item) {
+	if (!item.encrypted_content) return;
+	return {
+		id: item.id,
+		type: "reasoning",
+		summary: (item.summary ?? []).filter((summary) => typeof summary.text === "string").map((summary) => ({
+			type: "summary_text",
+			text: summary.text
+		})),
+		encrypted_content: item.encrypted_content
+	};
+}
+function convertCompactionOutputToInput(item) {
+	return {
+		id: item.id,
+		type: "compaction",
+		encrypted_content: item.encrypted_content
+	};
+}
+function normalizeNullableString(value) {
+	return typeof value === "string" ? value : null;
+}
+function normalizeServiceTier(value) {
+	if (value === "auto" || value === "default" || value === "flex" || value === "scale" || value === "priority") return value;
+	return null;
+}
+function createConversationRef() {
+	return { id: `conv_${randomUUID().replaceAll("-", "")}` };
+}
+function isConversationReference(value) {
+	if (typeof value === "string") return value.length > 0;
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && value.id.length > 0;
+}
+function getConversationId(conversation) {
+	return typeof conversation === "string" ? conversation : conversation.id;
+}
+function getInputItemId(item) {
+	if (!item || typeof item !== "object") return;
+	if ("id" in item && typeof item.id === "string") return item.id;
+	if ("call_id" in item && typeof item.call_id === "string") return item.call_id;
+}
+
 //#endregion
 //#region src/routes/responses/strategy.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
 function createStreamIdTracker() {
 	return { itemIdsByOutputIndex: /* @__PURE__ */ new Map() };
 }
@@ -50393,23 +51263,24 @@ function fixStreamIds(rawData, eventName, state) {
 	} catch {
 		return rawData;
 	}
-	if (eventName === "response.created" || eventName === "response.completed" || eventName === "response.incomplete") {
-		const response = parsed.response;
-		if (response?.id && typeof response.id === "string") state.responseId = response.id;
+	const response = isRecord(parsed.response) ? parsed.response : void 0;
+	if (typeof response?.id === "string") {
+		if (!state.responseId) state.responseId = response.id;
+		else if (response.id !== state.responseId) response.id = state.responseId;
 	}
 	if (eventName === "response.output_item.added" || eventName === "response.output_item.done") {
 		const outputIndex = typeof parsed.output_index === "number" ? parsed.output_index : void 0;
-		const item = parsed.item;
-		if (outputIndex !== void 0 && typeof item?.id === "string") state.itemIdsByOutputIndex.set(outputIndex, item.id);
+		const item = isRecord(parsed.item) ? parsed.item : void 0;
+		if (outputIndex !== void 0 && typeof item?.id === "string") {
+			const stableId = state.itemIdsByOutputIndex.get(outputIndex);
+			if (!stableId) state.itemIdsByOutputIndex.set(outputIndex, item.id);
+			else if (item.id !== stableId) item.id = stableId;
+		}
 	}
-	if ((eventName === "response.function_call_arguments.delta" || eventName === "response.function_call_arguments.done" || eventName === "response.output_text.delta" || eventName === "response.output_text.done" || eventName === "response.reasoning_summary_text.delta" || eventName === "response.reasoning_summary_text.done") && typeof parsed.output_index === "number") {
+	if (typeof parsed.output_index === "number" && typeof parsed.item_id === "string") {
 		const stableId = state.itemIdsByOutputIndex.get(parsed.output_index);
 		if (stableId && parsed.item_id !== stableId) parsed.item_id = stableId;
 	}
-	if (state.responseId && parsed.response && typeof parsed.response === "object") {
-		const response = parsed.response;
-		if (response.id !== state.responseId) response.id = state.responseId;
-	}
 	return JSON.stringify(parsed);
 }
 function createResponsesPassthroughStrategy(copilotClient, payload, options) {
@@ -50425,10 +51296,34 @@ function createResponsesPassthroughStrategy(copilotClient, payload, options) {
 			return result;
 		},
 		translateStreamChunk(chunk) {
-			return passthroughSSEChunk(chunk, fixStreamIds(chunk.data ?? "", chunk.event, tracker));
+			const fixedData = fixStreamIds(chunk.data ?? "", chunk.event, tracker);
+			const mappedData = options.mapResponse ? mapChunkResponse(fixedData, options.mapResponse) : fixedData;
+			const parsedResponse = tryExtractTerminalResponse(mappedData);
+			if (parsedResponse) options.onTerminalResponse?.(parsedResponse);
+			return passthroughSSEChunk(chunk, mappedData);
 		}
 	};
 }
+function mapChunkResponse(rawData, mapResponse) {
+	if (!rawData) return rawData;
+	try {
+		const parsed = JSON.parse(rawData);
+		if (isRecord(parsed.response)) {
+			parsed.response = mapResponse(parsed.response);
+			return JSON.stringify(parsed);
+		}
+	} catch {}
+	return rawData;
+}
+function tryExtractTerminalResponse(rawData) {
+	if (!rawData) return;
+	try {
+		const parsed = JSON.parse(rawData);
+		if (parsed.type !== "response.completed" && parsed.type !== "response.incomplete" && parsed.type !== "response.failed") return;
+		const response = parsed.response;
+		if (response && typeof response === "object") return response;
+	} catch {}
+}
 
 //#endregion
 //#region src/routes/responses/handler.ts
@@ -50438,34 +51333,65 @@ const HTTP_URL_RE = /^https?:\/\//i;
 */
 async function handleResponsesCore({ body, signal, headers }) {
 	const payload = parseResponsesPayload(body);
-	const rewrite = applyModelRewrite(payload);
-	applyResponsesToolTransforms(payload);
-	applyResponsesInputPolicies(payload);
-	compactInputByLatestCompaction(payload);
-	const selectedModel = findModelById(payload.model);
+	const requestContext = normalizeResponsesRequestContext(payload, headers);
+	const emulatorPrepared = shouldUseResponsesOfficialEmulator() ? prepareEmulatorRequest(payload) : void 0;
+	const rewrite = applyModelRewrite(emulatorPrepared?.upstreamPayload ?? payload);
+	const effectivePayload = emulatorPrepared?.upstreamPayload ?? payload;
+	applyResponsesToolTransforms(effectivePayload);
+	applyResponsesInputPolicies(effectivePayload);
+	compactInputByLatestCompaction(effectivePayload);
+	const selectedModel = findModelById(effectivePayload.model);
 	if (!selectedModel) throwInvalidRequestError("The selected model could not be resolved.", "model");
 	if (!modelSupportsEndpoint(selectedModel, RESPONSES_ENDPOINT)) throwInvalidRequestError("The selected model does not support the responses endpoint.", "model");
-	applyContextManagement(payload, selectedModel.capabilities.limits.max_prompt_tokens);
-	const { vision, initiator } = getResponsesRequestOptions(payload);
+	applyContextManagement(effectivePayload, selectedModel.capabilities.limits.max_prompt_tokens);
+	const { vision, initiator } = getResponsesRequestOptions(effectivePayload);
 	const upstreamSignal = createUpstreamSignalFromConfig(signal);
+	const copilotClient = createCopilotClient();
+	const decorateResponse = emulatorPrepared ? (response) => decorateStoredResponse(response, payload, emulatorPrepared) : void 0;
+	const result = await runStrategy(createResponsesPassthroughStrategy(copilotClient, effectivePayload, {
+		vision,
+		initiator: resolveInitiator(initiator, requestContext),
+		requestContext,
+		signal: upstreamSignal.signal,
+		mapResponse: decorateResponse,
+		onTerminalResponse: emulatorPrepared ? (terminalResponse) => {
+			if (!emulatorPrepared?.shouldStore) return;
+			persistEmulatorResponse(terminalResponse, emulatorPrepared.effectiveInputItems);
+		} : void 0
+	}), upstreamSignal);
+	if (emulatorPrepared && result.kind === "json") {
+		const emulatedResponse = decorateStoredResponse(result.data, payload, emulatorPrepared);
+		if (emulatorPrepared.shouldStore) persistEmulatorResponse(emulatedResponse, emulatorPrepared.effectiveInputItems);
+		result.data = emulatedResponse;
+	}
 	return {
-		result: await runStrategy(createResponsesPassthroughStrategy(createCopilotClient(), payload, {
-			vision,
-			initiator,
-			requestContext: readCapiRequestContext(headers),
-			signal: upstreamSignal.signal
-		}), upstreamSignal),
+		result,
 		modelMapping: {
 			originalModel: rewrite.originalModel,
 			rewrittenModel: rewrite.model,
-			mappedModel: payload.model
+			mappedModel: effectivePayload.model
 		}
 	};
 }
 function applyResponsesToolTransforms(payload) {
 	applyFunctionApplyPatch(payload);
+	applyFunctionToolCompatibilityDefaults(payload);
 	rejectUnsupportedBuiltinTools(payload);
 }
+function applyFunctionToolCompatibilityDefaults(payload) {
+	if (!Array.isArray(payload.tools)) return;
+	payload.tools = payload.tools.map((tool) => {
+		if (!isResponseFunctionTool(tool)) return tool;
+		return {
+			...tool,
+			parameters: normalizeFunctionParametersSchemaForCopilot(tool.parameters),
+			strict: tool.strict ?? true
+		};
+	});
+}
+function isResponseFunctionTool(tool) {
+	return tool.type === "function";
+}
 function applyFunctionApplyPatch(payload) {
 	if (!shouldUseFunctionApplyPatch() || !Array.isArray(payload.tools)) return;
 	payload.tools = payload.tools.map((tool) => {
@@ -50487,6 +51413,7 @@ function applyFunctionApplyPatch(payload) {
 	});
 }
 function rejectUnsupportedBuiltinTools(payload) {
+	if (payload.tool_choice && typeof payload.tool_choice === "object" && "type" in payload.tool_choice && (payload.tool_choice.type === "web_search_preview" || payload.tool_choice.type === "web_search_preview_2025_03_11")) throwInvalidRequestError("The selected Copilot endpoint does not support the Responses web_search tool.", "tool_choice", "unsupported_tool_web_search");
 	if (!Array.isArray(payload.tools)) return;
 	for (const tool of payload.tools) if (tool.type === "web_search") throwInvalidRequestError("The selected Copilot endpoint does not support the Responses web_search tool.", "tools", "unsupported_tool_web_search");
 }
@@ -50510,6 +51437,7 @@ function containsRemoteImageUrl(value) {
 //#region src/routes/responses/resource-handler.ts
 async function handleRetrieveResponseCore({ params, url, headers, signal }) {
 	const responseId = requireResponseId(params.responseId);
+	if (shouldUseResponsesOfficialEmulator()) return getStoredResponseOrThrow(responseId);
 	return await createCopilotClient().getResponse(responseId, {
 		params: getRetrieveParamsFromUrl(url),
 		requestContext: readCapiRequestContext(headers),
@@ -50518,6 +51446,7 @@ async function handleRetrieveResponseCore({ params, url, headers, signal }) {
 }
 async function handleListResponseInputItemsCore({ params, url, headers, signal }) {
 	const responseId = requireResponseId(params.responseId);
+	if (shouldUseResponsesOfficialEmulator()) return listStoredInputItemsOrThrow(responseId, getInputItemsParamsFromUrl(url));
 	return await createCopilotClient().getResponseInputItems(responseId, getInputItemsParamsFromUrl(url), {
 		requestContext: readCapiRequestContext(headers),
 		signal
@@ -50525,13 +51454,22 @@ async function handleListResponseInputItemsCore({ params, url, headers, signal }
 }
 async function handleCreateResponseInputTokensCore({ body, headers, signal }) {
 	const payload = parseResponsesInputTokensPayload(body);
+	const requestContext = normalizeResponsesRequestContext(payload, headers);
+	if (shouldUseResponsesOfficialEmulator()) {
+		const model = payload.model;
+		if (!model) throwInvalidRequestError("The selected model could not be resolved.", "model");
+		const selectedModel = findModelById(model);
+		if (!selectedModel) throwInvalidRequestError("The selected model could not be resolved.", "model");
+		return await estimateEmulatorInputTokens(payload, selectedModel);
+	}
 	return await createCopilotClient().createResponseInputTokens(payload, {
-		requestContext: readCapiRequestContext(headers),
+		requestContext,
 		signal
 	});
 }
 async function handleDeleteResponseCore({ params, headers, signal }) {
 	const responseId = requireResponseId(params.responseId);
+	if (shouldUseResponsesOfficialEmulator()) return deleteStoredResponseOrThrow(responseId);
 	return await createCopilotClient().deleteResponse(responseId, {
 		requestContext: readCapiRequestContext(headers),
 		signal