@dianshuv/copilot-api 0.8.1 → 0.9.0

package/dist/main.mjs

@@ -1348,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.8.1";
+var version = "0.9.0";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -3042,6 +3042,158 @@ const awaitApproval = async () => {
 	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", 403, JSON.stringify({ message: "Request rejected" }));
 };
 
+//#endregion
+//#region src/lib/echo-model.ts
+/**
+* Capture the requested model id from a raw request `model` value, classifying
+* it into the three-state contract. `undefined`/missing → `absent`; `""` →
+* `empty`; any other string → `present`.
+*/
+function captureRequestedModel(rawModel) {
+	if (rawModel === void 0 || rawModel === null) return { kind: "absent" };
+	if (typeof rawModel !== "string") return { kind: "absent" };
+	if (rawModel === "") return { kind: "empty" };
+	return {
+		kind: "present",
+		value: rawModel
+	};
+}
+/**
+* Resolve a {@link RequestedModel} into the action to take on a model field:
+*  - `{ write: true, value }` → set the field to `value`.
+*  - `{ write: false, omit: true }` → remove the field (absent case).
+*  - `null` → leave the field untouched (context-missing case).
+*/
+function resolveFieldAction(requested) {
+	if (requested.kind === "present") return { value: requested.value };
+	if (requested.kind === "empty") return { value: "" };
+	if (requested.kind === "absent") return { omit: true };
+	return null;
+}
+/**
+* Apply the requested-model action to a single `model`-like key on a shallow
+* clone of `obj`. Returns a new object; never mutates `obj`. If `obj` does not
+* own `key`, it is returned (cloned) unchanged regardless of the action — we
+* only ever rewrite a field the upstream payload actually carries (supports
+* AC-MALFORMED-SSE: no model field → original passthrough).
+*/
+function rewriteKey(obj, key, requested) {
+	if (!Object.hasOwn(obj, key)) return obj;
+	const action = resolveFieldAction(requested);
+	if (action === null) return obj;
+	if ("omit" in action) {
+		const { [key]: _omitted, ...rest } = obj;
+		return rest;
+	}
+	return {
+		...obj,
+		[key]: action.value
+	};
+}
+/**
+* Core rewrite over a plain record. Rewrites the documented model fields:
+*  - top-level `model`, top-level `modelVersion` (Gemini),
+*  - nested `message.model` (Anthropic message_start),
+*  - nested `response.model` (OpenAI Responses event).
+* Returns a shallow clone; never mutates the input.
+*/
+function echoRecord(body, requested) {
+	let out = rewriteKey(body, "model", requested);
+	out = rewriteKey(out, "modelVersion", requested);
+	if (isRecord$1(out.message) && Object.hasOwn(out.message, "model")) {
+		const newMessage = rewriteKey(out.message, "model", requested);
+		if (newMessage !== out.message) out = {
+			...out,
+			message: newMessage
+		};
+	}
+	if (isRecord$1(out.response) && Object.hasOwn(out.response, "model")) {
+		const newResponse = rewriteKey(out.response, "model", requested);
+		if (newResponse !== out.response) out = {
+			...out,
+			response: newResponse
+		};
+	}
+	return out;
+}
+/**
+* Rewrite the documented client-facing model field(s) of a JSON response body
+* to the requested model id. Handles every supported non-stream/body shape:
+*  - top-level `model` (OpenAI chat/completions & Responses bodies, Anthropic
+*    messages body, embeddings),
+*  - nested `message.model` (Anthropic `message_start` event object),
+*  - nested `response.model` (OpenAI Responses streaming event object),
+*  - top-level `modelVersion` (Gemini body & chunk).
+*
+* Returns a shallow-cloned object; the input is never mutated. Fields that are
+* not present are left as-is (a payload with no model field round-trips
+* unchanged), supporting AC-MALFORMED-SSE.
+*
+* The generic is constrained to `object` (not an index-signature shape) so it
+* accepts the project's domain interfaces (`AnthropicResponse`,
+* `ChatCompletionChunk`, …) directly without forcing callers to widen them.
+*/
+function echoModelInResponseBody(body, requested) {
+	return echoRecord(body, requested);
+}
+/**
+* Ensure a response body's top-level `model` field equals the requested model
+* id — **setting it even when the body omits it**. This differs from
+* {@link echoModelInResponseBody}, which only rewrites a `model` field the
+* payload already carries (the passthrough rule that protects malformed-SSE /
+* model-less events). Some upstreams omit `model` from an otherwise-valid
+* response body (notably the Copilot embeddings endpoint, whose 200 body carries
+* only `data` + `usage`); for those, the documented client-facing contract is
+* still "`response.model` == R", so the field must be added, not skipped.
+*
+* Three-state per AC-MISSING-MODEL, keyed on the REQUESTER's model (not the
+* upstream's):
+*  - `present` → set `model` to R (added if absent, overwritten if present).
+*  - `empty`   → set `model` to "" (the client sent an empty string).
+*  - `absent`  → omit `model` (client sent no model → never invent one); if the
+*               body happened to carry an upstream `model`, drop it.
+*  - `context-missing` → leave the body untouched (defensive passthrough).
+*
+* Only the documented client's own string R is ever written — never the upstream
+* id — so this introduces no side channel (AC-NO-SIDECHANNEL). Returns a shallow
+* clone; the input is never mutated (protects the AC-OBS data source).
+*/
+function echoTopLevelModel(body, requested) {
+	if (requested.kind === "context-missing") return body;
+	const rec = body;
+	if (requested.kind === "absent") {
+		if (!Object.hasOwn(rec, "model")) return body;
+		const { model: _dropped, ...rest } = rec;
+		return rest;
+	}
+	const value = requested.kind === "present" ? requested.value : "";
+	return {
+		...rec,
+		model: value
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Rewrite the model field of an already-parsed SSE event payload to the
+* requested model id, dispatched by protocol shape:
+*  - Anthropic `message_start` → `message.model`,
+*  - OpenAI chunk → top-level `model`,
+*  - OpenAI Responses event → nested `response.model`,
+*  - Gemini chunk → `modelVersion`.
+*
+* The field dispatch is identical to {@link echoModelInResponseBody} (both
+* operate on the same documented model fields), so this delegates to the same
+* core rather than duplicating the shape logic — the two exports exist to name
+* the two responsibilities (body vs parsed-event) at call sites, per the PRD's
+* single-policy-point design. Events with no model field round-trip unchanged
+* (AC-MALFORMED-SSE); the input is never mutated.
+*/
+function echoModelInParsedEvent(event, requested) {
+	return echoRecord(event, requested);
+}
+
 //#endregion
 //#region src/lib/message-sanitizer.ts
 const startPattern = /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\n*/;
@@ -3913,6 +4065,32 @@ function extractErrorMetrics(error) {
 * Shared utilities for request handlers.
 * Contains common functions used by both OpenAI and Anthropic message handlers.
 */
+/**
+* Resolve the requested model id (R) carried on the response context into a
+* {@link RequestedModel}. A context that never captured R (`undefined`) is
+* treated as `context-missing` so the echo passes the upstream value through
+* unchanged — it must never invent an id or throw.
+*/
+function requestedModelOf(ctx) {
+	return ctx.requestedModel ?? { kind: "context-missing" };
+}
+/**
+* Echo the requested model id into a JSON response body at the client write-out
+* boundary. Thin context-aware wrapper over {@link echoModelInResponseBody};
+* MUST be called AFTER history/posthog/TUI have read the upstream value.
+*/
+function echoResponseBody(body, ctx) {
+	return echoModelInResponseBody(body, requestedModelOf(ctx));
+}
+/**
+* Echo the requested model id into an already-parsed SSE event payload at the
+* client write-out boundary. Thin context-aware wrapper over
+* {@link echoModelInParsedEvent}; MUST be called AFTER the stream accumulator
+* (the observability data source) has read the upstream value.
+*/
+function echoParsedEvent(event, ctx) {
+	return echoModelInParsedEvent(event, requestedModelOf(ctx));
+}
 /** Helper to update tracker model */
 function updateTrackerModel(trackingId, model, resolvedModel) {
 	if (!trackingId) return;
@@ -4141,6 +4319,7 @@ function getReasoningTokensFromOpenAIUsage(usage) {
 async function handleCompletion$1(c) {
 	const originalPayload = await c.req.json();
 	consola.debug("Request payload:", JSON.stringify(originalPayload).slice(-400));
+	const requestedModel = captureRequestedModel(originalPayload.model);
 	const trackingId = c.get("trackingId");
 	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
 	updateTrackerModel(trackingId, originalPayload.model);
@@ -4157,7 +4336,8 @@ async function handleCompletion$1(c) {
 			temperature: originalPayload.temperature ?? void 0
 		}),
 		trackingId,
-		startTime
+		startTime,
+		requestedModel
 	};
 	const selectedModel = findModelById(originalPayload.model);
 	await logTokenCount(originalPayload, selectedModel);
@@ -4262,7 +4442,7 @@ function handleNonStreamingResponse$1(c, originalResponse, ctx, payload) {
 		reasoningTokens,
 		stopReason: choice.finish_reason
 	});
-	return c.json(response);
+	return c.json(echoResponseBody(response, ctx));
 }
 function buildResponseContent(choice) {
 	return {
@@ -4317,15 +4497,14 @@ async function handleStreamingResponse$1(opts) {
 				}]
 			};
 			await stream.writeSSE({
-				data: JSON.stringify(markerChunk),
+				data: JSON.stringify(echoParsedEvent(markerChunk, ctx)),
 				event: "message"
 			});
 			acc.content += marker;
 		}
 		for await (const chunk of response) {
 			consola.debug("Streaming chunk:", JSON.stringify(chunk));
-			parseStreamChunk(chunk, acc, checkRepetition);
-			await stream.writeSSE(chunk);
+			await accumulateAndEchoChunk(chunk, acc, checkRepetition, ctx, stream);
 		}
 		recordStreamSuccess(acc, payload.model, ctx);
 		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs, acc.reasoningTokens, {
@@ -4358,45 +4537,70 @@ async function handleStreamingResponse$1(opts) {
 				}]
 			};
 			await stream.writeSSE({
-				data: JSON.stringify(markerChunk),
+				data: JSON.stringify(echoParsedEvent(markerChunk, ctx)),
 				event: "message"
 			});
 		} catch {}
 	}
 }
-function parseStreamChunk(chunk, acc, checkRepetition) {
-	if (!chunk.data || chunk.data === "[DONE]") return;
+async function accumulateAndEchoChunk(chunk, acc, checkRepetition, ctx, stream) {
+	if (!chunk.data || chunk.data === "[DONE]") {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	let parsed;
 	try {
-		const parsed = JSON.parse(chunk.data);
-		if (parsed.model && !acc.model) acc.model = parsed.model;
-		if (parsed.usage) {
-			acc.inputTokens = parsed.usage.prompt_tokens;
-			acc.outputTokens = parsed.usage.completion_tokens;
-			acc.reasoningTokens = getReasoningTokensFromOpenAIUsage(parsed.usage) ?? 0;
-		}
-		const choice = parsed.choices[0];
-		if (choice) {
-			if (choice.delta.content) {
-				acc.content += choice.delta.content;
-				checkRepetition(choice.delta.content);
-			}
-			if (choice.delta.tool_calls) for (const tc of choice.delta.tool_calls) {
-				const idx = tc.index;
-				if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
-					id: tc.id ?? "",
-					name: tc.function?.name ?? "",
-					arguments: ""
-				});
-				const item = acc.toolCallMap.get(idx);
-				if (item) {
-					if (tc.id) item.id = tc.id;
-					if (tc.function?.name) item.name = tc.function.name;
-					if (tc.function?.arguments) item.arguments += tc.function.arguments;
-				}
+		parsed = JSON.parse(chunk.data);
+	} catch {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	try {
+		accumulateParsedChunk(parsed, acc, checkRepetition);
+	} catch {}
+	if (!Object.hasOwn(parsed, "model")) {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	const echoed = echoParsedEvent(parsed, ctx);
+	await stream.writeSSE({
+		...chunk,
+		data: JSON.stringify(echoed)
+	});
+}
+function accumulateParsedChunk(parsed, acc, checkRepetition) {
+	if (parsed.model && !acc.model) acc.model = parsed.model;
+	if (parsed.usage) {
+		acc.inputTokens = parsed.usage.prompt_tokens;
+		acc.outputTokens = parsed.usage.completion_tokens;
+		acc.reasoningTokens = getReasoningTokensFromOpenAIUsage(parsed.usage) ?? 0;
+	}
+	const choice = parsed.choices?.[0];
+	if (choice) {
+		if (choice.delta?.content) {
+			acc.content += choice.delta.content;
+			checkRepetition(choice.delta.content);
+		}
+		if (choice.delta?.tool_calls) for (const tc of choice.delta.tool_calls) {
+			const idx = tc.index;
+			if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
+				id: tc.id ?? "",
+				name: tc.function?.name ?? "",
+				arguments: ""
+			});
+			const item = acc.toolCallMap.get(idx);
+			if (item) {
+				if (tc.id) item.id = tc.id;
+				if (tc.function?.name) item.name = tc.function.name;
+				if (tc.function?.arguments) item.arguments += tc.function.arguments;
 			}
-			if (choice.finish_reason) acc.finishReason = choice.finish_reason;
 		}
-	} catch {}
+		if (choice.finish_reason) acc.finishReason = choice.finish_reason;
+	}
 }
 function recordStreamSuccess(acc, fallbackModel, ctx) {
 	for (const tc of acc.toolCallMap.values()) if (tc.id && tc.name) acc.toolCalls.push(tc);
@@ -4476,10 +4680,30 @@ const createEmbeddings = async (payload) => {
 //#endregion
 //#region src/routes/embeddings/route.ts
 const embeddingRoutes = new Hono();
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 embeddingRoutes.post("/", async (c) => {
+	const startTime = Date.now();
 	try {
-		const response = await createEmbeddings(await c.req.json());
-		return c.json(response);
+		const rawBody = await c.req.json();
+		const payload = rawBody;
+		const requestedModel = captureRequestedModel(isRecord(rawBody) ? rawBody.model : void 0);
+		const response = await createEmbeddings(payload);
+		if (!isRecord(response)) return c.json(response);
+		const upstreamModel = typeof response.model === "string" ? response.model : "";
+		const usage = response.usage;
+		captureRequest({
+			model: upstreamModel,
+			inputTokens: isRecord(usage) && typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+			outputTokens: 0,
+			durationMs: Date.now() - startTime,
+			success: true,
+			stream: false,
+			toolCount: 0,
+			endpoint: "embeddings"
+		});
+		return c.json(echoTopLevelModel(response, requestedModel));
 	} catch (error) {
 		return forwardError(c, error);
 	}
@@ -4831,7 +5055,7 @@ function buildUsageMetadata(usage) {
 
 //#endregion
 //#region src/routes/gemini/handler.ts
-async function handleGeminiGenerate(c, model, isStream) {
+async function handleGeminiGenerate(c, model, isStream, requestedModel) {
 	try {
 		const geminiRequest = await c.req.json();
 		consola.debug("Gemini request for model:", model, "stream:", isStream);
@@ -4856,7 +5080,8 @@ async function handleGeminiGenerate(c, model, isStream) {
 				temperature: payload.temperature ?? void 0
 			}),
 			trackingId,
-			startTime
+			startTime,
+			requestedModel
 		};
 		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, { resolvedModel: selectedModel }));
 		ctx.queueWaitMs = queueWaitMs;
@@ -4879,7 +5104,7 @@ async function handleGeminiGenerate(c, model, isStream) {
 						continue;
 					}
 					const geminiChunks = translateOpenAIChunkToGemini(chunk, streamState);
-					for (const gc of geminiChunks) await s.write(`data: ${JSON.stringify(gc)}\n\n`);
+					for (const gc of geminiChunks) await s.write(`data: ${JSON.stringify(echoParsedEvent(gc, ctx))}\n\n`);
 				}
 				recordResponse(ctx.historyId, {
 					success: true,
@@ -4947,7 +5172,7 @@ function handleNonStreamResponse(c, response, model, ctx, payload) {
 		stopReason: response.choices[0]?.finish_reason,
 		toolCount: payload.tools?.length ?? 0
 	});
-	return c.json(geminiResponse);
+	return c.json(echoResponseBody(geminiResponse, ctx));
 }
 
 //#endregion
@@ -4983,11 +5208,13 @@ geminiRoutes.post("/:modelAction", async (c) => {
 	const modelAction = c.req.param("modelAction");
 	const colonIndex = modelAction.lastIndexOf(":");
 	if (colonIndex === -1) return geminiError(c, 400, "INVALID_ARGUMENT", "Missing action in URL");
-	const model = resolveGeminiModelAlias(modelAction.slice(0, Math.max(0, colonIndex)));
+	const rawModel = modelAction.slice(0, Math.max(0, colonIndex));
+	const requestedModel = captureRequestedModel(rawModel);
+	const model = resolveGeminiModelAlias(rawModel);
 	const action = modelAction.slice(Math.max(0, colonIndex + 1));
 	switch (action) {
-		case "generateContent": return handleGeminiGenerate(c, model, false);
-		case "streamGenerateContent": return handleGeminiGenerate(c, model, true);
+		case "generateContent": return handleGeminiGenerate(c, model, false, requestedModel);
+		case "streamGenerateContent": return handleGeminiGenerate(c, model, true, requestedModel);
 		case "countTokens": return handleGeminiCountTokens(c, model);
 		default: return geminiError(c, 400, "INVALID_ARGUMENT", `Unknown action: ${action}`);
 	}
@@ -8067,7 +8294,40 @@ function handleDirectAnthropicNonStreamingResponse(c, response, ctx, truncateRes
 	if (state.verbose && truncateResult?.wasCompacted) finalResponse = prependMarkerToResponse(response, createTruncationMarker$1(truncateResult));
 	logServerToolBlocks(finalResponse.content);
 	finalResponse = filterServerToolBlocksFromResponse(finalResponse);
-	return c.json(finalResponse);
+	return c.json(echoResponseBody(finalResponse, ctx));
+}
+/**
+* Echo the requester's original model id into a single already-serialized
+* native-Anthropic SSE `data:` payload at the write-out boundary.
+*
+* In the native Anthropic stream only `message_start` carries a model field
+* (`message.model`), so every other event type is forwarded byte-for-byte —
+* this both avoids a needless re-parse per text delta and guarantees events
+* with no model field round-trip unchanged. For `message_start`, the payload
+* is parsed and run through the shared echo policy point; the re-serialized
+* form is returned ONLY when the echo actually rewrote the object (identity
+* change). When nothing was rewritten — a model-less `message_start`, or
+* `context-missing` R — the original `forwardData` bytes are returned verbatim
+* so a passthrough never re-minifies / re-orders the upstream frame. If the
+* payload fails to parse (malformed upstream frame), the original string is
+* likewise returned untouched so the stream is never corrupted or interrupted
+* (AC-MALFORMED-SSE).
+*
+* Operates on the serialized output of the server-tool rewrite (not the raw
+* upstream frame), so the echo composes with any index remap that step made.
+*/
+function echoForwardData(forwardData, eventType, ctx) {
+	if (eventType !== "message_start") return forwardData;
+	let parsed;
+	try {
+		parsed = JSON.parse(forwardData);
+	} catch {
+		return forwardData;
+	}
+	if (typeof parsed !== "object" || parsed === null) return forwardData;
+	const echoed = echoParsedEvent(parsed, ctx);
+	if (echoed === parsed) return forwardData;
+	return JSON.stringify(echoed);
 }
 /**
 * Handle streaming direct Anthropic response (passthrough SSE events)
@@ -8094,9 +8354,10 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
 			const forwardData = serverToolFilter.rewriteEvent(event, rawEvent.data);
 			if (forwardData === null) continue;
+			const echoedData = echoForwardData(forwardData, event.type, ctx);
 			await stream.writeSSE({
 				event: rawEvent.event || event.type,
-				data: forwardData
+				data: echoedData
 			});
 		}
 		recordAnthropicStreamingResponse(acc, anthropicPayload.model, ctx);
@@ -8276,7 +8537,7 @@ function handleNonStreamingResponse(opts) {
 		toolCount: anthropicPayload.tools?.length ?? 0,
 		stopReason: anthropicResponse.stop_reason ?? void 0
 	});
-	return c.json(anthropicResponse);
+	return c.json(echoResponseBody(anthropicResponse, ctx));
 }
 async function handleStreamingResponse(opts) {
 	const { stream, response, toolNameMapping, anthropicPayload, ctx } = opts;
@@ -8300,7 +8561,8 @@ async function handleStreamingResponse(opts) {
 			toolNameMapping,
 			streamState,
 			acc,
-			checkRepetition
+			checkRepetition,
+			ctx
 		});
 		recordAnthropicStreamingResponse(acc, anthropicPayload.model, ctx);
 		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs, void 0, {
@@ -8363,7 +8625,7 @@ async function sendTruncationMarkerEvent(stream, streamState, marker) {
 	streamState.contentBlockIndex++;
 }
 async function processStreamChunks(opts) {
-	const { stream, response, toolNameMapping, streamState, acc, checkRepetition } = opts;
+	const { stream, response, toolNameMapping, streamState, acc, checkRepetition, ctx } = opts;
 	for await (const rawEvent of response) {
 		consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 		if (rawEvent.data === "[DONE]") break;
@@ -8381,9 +8643,10 @@ async function processStreamChunks(opts) {
 			consola.debug("Translated Anthropic event:", JSON.stringify(event));
 			processAnthropicEvent(event, acc);
 			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
+			const echoed = echoParsedEvent(event, ctx);
 			await stream.writeSSE({
-				event: event.type,
-				data: JSON.stringify(event)
+				event: echoed.type,
+				data: JSON.stringify(echoed)
 			});
 		}
 	}
@@ -8402,6 +8665,7 @@ function resolveModelFromBetaHeader(model, betaHeader) {
 async function handleCompletion(c) {
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const requestedModel = captureRequestedModel(anthropicPayload.model);
 	const betaHeader = c.req.header("anthropic-beta");
 	anthropicPayload.model = resolveModelFromBetaHeader(anthropicPayload.model, betaHeader);
 	logToolInfo(anthropicPayload);
@@ -8426,7 +8690,8 @@ async function handleCompletion(c) {
 			system: extractSystemPrompt(anthropicPayload.system)
 		}),
 		trackingId,
-		startTime
+		startTime,
+		requestedModel
 	};
 	if (useDirectAnthropicApi) return handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiatorOverride);
 	return handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOverride);
@@ -8590,13 +8855,23 @@ const createResponses = async (payload, { vision, initiator, resolvedModel }) =>
 //#endregion
 //#region src/routes/responses/stream-id-sync.ts
 const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
-const fixStreamIds = (data, event, tracker) => {
+/**
+* Rewrite a single Responses SSE event's `data`: synchronize item ids AND echo
+* the requester's model id into any nested `response.model` the event carries,
+* from one parse/serialize. Events whose payload has no `response.model` (text
+* deltas, the `error` event, …) round-trip with their model untouched
+* (AC-MALFORMED-SSE); unparseable/empty `data` is forwarded byte-for-byte.
+*
+* The echo is applied AFTER the handler's history/tracking has read the upstream
+* values from the same chunks, preserving the observability split (AC-OBS).
+*/
+const fixStreamIds = (data, event, tracker, requestedModel) => {
 	if (!data) return data;
-	const parsed = JSON.parse(data);
+	const echoed = echoModelInParsedEvent(JSON.parse(data), requestedModel);
 	switch (event) {
-		case "response.output_item.added": return handleOutputItemAdded(parsed, tracker);
-		case "response.output_item.done": return handleOutputItemDone(parsed, tracker);
-		default: return handleItemId(parsed, tracker);
+		case "response.output_item.added": return handleOutputItemAdded(echoed, tracker);
+		case "response.output_item.done": return handleOutputItemDone(echoed, tracker);
+		default: return handleItemId(echoed, tracker);
 	}
 };
 const handleOutputItemAdded = (parsed, tracker) => {
@@ -8809,6 +9084,7 @@ const TERMINAL_EVENTS = new Set([
 ]);
 const handleResponses = async (c) => {
 	let payload = await c.req.json();
+	const requestedModel = captureRequestedModel(payload.model);
 	if (state.normalizeResponsesCallIds) payload = normalizeCallIds(payload);
 	consola.debug("Responses request payload:", JSON.stringify(payload));
 	const trackingId = c.get("trackingId");
@@ -8831,7 +9107,8 @@ const handleResponses = async (c) => {
 	const ctx = {
 		historyId,
 		trackingId,
-		startTime
+		startTime,
+		requestedModel
 	};
 	const selectedModel = findModelById(payload.model);
 	if (!(selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) {
@@ -8872,7 +9149,7 @@ const handleResponses = async (c) => {
 							const parsed = JSON.parse(rawData);
 							if (typeof parsed.sequence_number === "number") lastSequenceNumber = parsed.sequence_number;
 						} catch {}
-						const processedData = fixStreamIds(rawData, eventType, idTracker);
+						const processedData = fixStreamIds(rawData, eventType, idTracker, requestedModel);
 						await stream.writeSSE({
 							id: chunk.id,
 							event: eventType,
@@ -8935,7 +9212,7 @@ const handleResponses = async (c) => {
 			toolCount: tools.length
 		});
 		consola.debug("Forwarding native Responses result:", JSON.stringify(result).slice(-400));
-		return c.json(result);
+		return c.json(echoResponseBody(result, ctx));
 	} catch (error) {
 		recordErrorResponse(ctx, model, error, "responses", stream);
 		failTracking(trackingId, error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",