@copilotkit/aimock 1.46.0 → 1.47.0

package/dist/gemini.cjs

@@ -6,7 +6,11 @@ const require_chaos = require('./chaos.cjs');
 const require_misbehavior = require('./misbehavior.cjs');
 const require_router = require('./router.cjs');
 const require_recorder = require('./recorder.cjs');
-const require_interruption = require('./interruption.cjs');
+const require_logger = require('./logger.cjs');
+const require_timing = require('./response/timing.cjs');
+const require_deliver = require('./response/deliver.cjs');
+const require_proxy = require('./response/proxy.cjs');
+const require_raw = require('./response/raw.cjs');
 const require_finish = require('./response/finish.cjs');
 const require_gemini = require('./response/usage/codecs/gemini.cjs');
 
@@ -149,6 +153,110 @@ function geminiFinishReason(finishReason, defaultReason) {
 function geminiUsageMetadata(overrides) {
 	return require_gemini.render(overrides);
 }
+function geminiWholeTextPart(text, partIndex) {
+	return [{
+		partIndex,
+		start: 0,
+		end: text.length
+	}];
+}
+function geminiGroundingSupports(text, citations, textParts) {
+	const segment = (part, from, to) => {
+		const partText = text.slice(part.start, part.end);
+		const start = Math.min(Math.max(from - part.start, 0), partText.length);
+		const end = Math.min(Math.max(to - part.start, start), partText.length);
+		const byteOffset = (charIndex) => Buffer.byteLength(partText.slice(0, charIndex), "utf8");
+		return {
+			partIndex: part.partIndex,
+			startIndex: byteOffset(start),
+			endIndex: byteOffset(end),
+			text: partText.slice(start, end)
+		};
+	};
+	return citations.flatMap((c, i) => {
+		const spanned = textParts.filter((p) => Math.max(c.startIndex, p.start) < Math.min(c.endIndex, p.end));
+		return (spanned.length > 0 ? spanned : [textParts.find((p) => c.startIndex < p.end) ?? textParts[textParts.length - 1]]).map((p) => ({
+			segment: segment(p, c.startIndex, c.endIndex),
+			groundingChunkIndices: [i]
+		}));
+	});
+}
+function geminiGroundingMetadata(text, overrides, textParts) {
+	const citations = require_helpers.resolveCitations(text, overrides?.citations);
+	if (citations.length === 0 || textParts.length === 0) return void 0;
+	return {
+		groundingChunks: geminiGroundingChunks(citations),
+		groundingSupports: geminiGroundingSupports(text, citations, textParts)
+	};
+}
+function geminiGroundingChunks(citations) {
+	return citations.map((c) => ({ web: {
+		uri: c.url,
+		title: c.title
+	} }));
+}
+function geminiGroundingField(text, overrides, textParts) {
+	const groundingMetadata = geminiGroundingMetadata(text, overrides, textParts);
+	return groundingMetadata ? { groundingMetadata } : {};
+}
+function geminiStreamGroundingFields(text, overrides, spans) {
+	const fields = spans.map(() => ({}));
+	const citations = require_helpers.resolveCitations(text, overrides?.citations);
+	if (citations.length === 0 || spans.length === 0) return fields;
+	const textParts = spans.map((s, k) => ({
+		partIndex: k,
+		start: s.start,
+		end: s.end
+	}));
+	const groundingChunks = geminiGroundingChunks(citations);
+	for (const support of geminiGroundingSupports(text, citations, textParts)) {
+		const k = support.segment.partIndex;
+		(fields[k].groundingMetadata ??= {
+			groundingChunks,
+			groundingSupports: []
+		}).groundingSupports.push({
+			...support,
+			segment: {
+				...support.segment,
+				partIndex: 0
+			}
+		});
+	}
+	return fields;
+}
+function geminiTextChunkSpans(text, chunkSize, offset = 0) {
+	if (text.length === 0) return [{
+		start: offset,
+		end: offset
+	}];
+	const spans = [];
+	let start = offset;
+	for (const slice of require_helpers.surrogateSafeChunks(text, chunkSize)) {
+		spans.push({
+			start,
+			end: start + slice.length
+		});
+		start += slice.length;
+	}
+	return spans;
+}
+function geminiFileParts(overrides) {
+	return require_helpers.fixtureFiles(overrides?.files).map((f) => ({ inlineData: {
+		mimeType: f.mimeType,
+		data: f.data
+	} }));
+}
+function geminiFileChunks(overrides) {
+	const parts = geminiFileParts(overrides);
+	if (parts.length === 0) return [];
+	return [{ candidates: [{
+		content: {
+			role: "model",
+			parts
+		},
+		index: 0
+	}] }];
+}
 function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 	const chunks = [];
 	const effectiveFinish = geminiFinishReason(overrides?.finishReason, "STOP");
@@ -166,9 +274,11 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 			index: 0
 		}] });
 	}
-	for (let i = 0; i < content.length; i += chunkSize) {
-		const slice = content.slice(i, i + chunkSize);
-		const isLast = i + chunkSize >= content.length;
+	chunks.push(...geminiFileChunks(overrides));
+	const grounding = geminiStreamGroundingFields(content, overrides, geminiTextChunkSpans(content, chunkSize));
+	const contentSlices = require_helpers.surrogateSafeChunks(content, chunkSize);
+	contentSlices.forEach((slice, k) => {
+		const isLast = k === contentSlices.length - 1;
 		const chunk = {
 			candidates: [{
 				content: {
@@ -176,12 +286,13 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 					parts: [{ text: slice }]
 				},
 				index: 0,
-				...isLast ? { finishReason: effectiveFinish } : {}
+				...isLast ? { finishReason: effectiveFinish } : {},
+				...grounding[k]
 			}],
 			...isLast ? { usageMetadata: usage } : {}
 		};
 		chunks.push(chunk);
-	}
+	});
 	if (content.length === 0) chunks.push({
 		candidates: [{
 			content: {
@@ -189,6 +300,7 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 				parts: [{ text: "" }]
 			},
 			finishReason: effectiveFinish,
+			...grounding[0],
 			index: 0
 		}],
 		usageMetadata: usage
@@ -219,6 +331,8 @@ function buildGeminiToolCallStreamChunks(toolCalls, chunkSize, logger, reasoning
 			index: 0
 		}] });
 	}
+	chunks.push(...geminiFileChunks(overrides));
+	require_helpers.resolveCitations("", overrides?.citations);
 	const parts = toolCalls.map((tc) => parseToolCallPart(tc, logger));
 	chunks.push({
 		candidates: [{
@@ -239,6 +353,8 @@ function buildGeminiTextResponse(content, reasoning, overrides) {
 		text: reasoning,
 		thought: true
 	});
+	parts.push(...geminiFileParts(overrides));
+	const textParts = geminiWholeTextPart(content, parts.length);
 	parts.push({ text: content });
 	return {
 		candidates: [{
@@ -247,17 +363,20 @@ function buildGeminiTextResponse(content, reasoning, overrides) {
 				parts
 			},
 			finishReason: geminiFinishReason(overrides?.finishReason, "STOP"),
+			...geminiGroundingField(content, overrides, textParts),
 			index: 0
 		}],
 		usageMetadata: geminiUsageMetadata(overrides)
 	};
 }
 function buildGeminiToolCallResponse(toolCalls, logger, reasoning, overrides) {
+	require_helpers.resolveCitations("", overrides?.citations);
 	const parts = [];
 	if (reasoning) parts.push({
 		text: reasoning,
 		thought: true
 	});
+	parts.push(...geminiFileParts(overrides));
 	parts.push(...toolCalls.map((tc) => parseToolCallPart(tc, logger)));
 	return {
 		candidates: [{
@@ -286,9 +405,19 @@ function buildGeminiContentWithToolCallsStreamChunks(content, toolCalls, chunkSi
 			index: 0
 		}] });
 	}
+	chunks.push(...geminiFileChunks(overrides));
 	if (blocks && blocks.length > 0) {
 		const outcome = require_helpers.resolveFixtureBlockOutcome(blocks);
 		const resolved = outcome.ordered;
+		const spans = [];
+		let offset = 0;
+		for (const block of resolved) {
+			if (block.type !== "text") continue;
+			spans.push(...geminiTextChunkSpans(block.text, chunkSize, offset));
+			offset += block.text.length;
+		}
+		const grounding = geminiStreamGroundingFields(outcome.content, overrides, spans);
+		let textChunk = 0;
 		resolved.forEach((block, i) => {
 			const isLast = i === resolved.length - 1;
 			const finishReason = isLast ? geminiFinishReason(overrides?.finishReason, outcome.hasToolCalls ? "FUNCTION_CALL" : "STOP") : void 0;
@@ -318,47 +447,53 @@ function buildGeminiContentWithToolCallsStreamChunks(content, toolCalls, chunkSi
 							parts: [{ text: "" }]
 						},
 						...finishReason ? { finishReason } : {},
+						...grounding[textChunk++],
 						index: 0
 					}],
 					...isLast ? { usageMetadata: geminiUsageMetadata(overrides) } : {}
 				});
-				else for (let j = 0; j < text.length; j += chunkSize) {
-					const slice = text.slice(j, j + chunkSize);
-					const lastSlice = j + chunkSize >= text.length;
-					const sliceFinish = isLast && lastSlice ? finishReason : void 0;
-					chunks.push({
-						candidates: [{
-							content: {
-								role: "model",
-								parts: [{ text: slice }]
-							},
-							...sliceFinish ? { finishReason: sliceFinish } : {},
-							index: 0
-						}],
-						...isLast && lastSlice ? { usageMetadata: geminiUsageMetadata(overrides) } : {}
+				else {
+					const slices = require_helpers.surrogateSafeChunks(text, chunkSize);
+					slices.forEach((slice, j) => {
+						const lastSlice = j === slices.length - 1;
+						const sliceFinish = isLast && lastSlice ? finishReason : void 0;
+						chunks.push({
+							candidates: [{
+								content: {
+									role: "model",
+									parts: [{ text: slice }]
+								},
+								...sliceFinish ? { finishReason: sliceFinish } : {},
+								...grounding[textChunk++],
+								index: 0
+							}],
+							...isLast && lastSlice ? { usageMetadata: geminiUsageMetadata(overrides) } : {}
+						});
 					});
 				}
 			}
 		});
 		return chunks;
 	}
+	const grounding = geminiStreamGroundingFields(content, overrides, geminiTextChunkSpans(content, chunkSize));
 	if (content.length === 0) chunks.push({ candidates: [{
 		content: {
 			role: "model",
 			parts: [{ text: "" }]
 		},
+		...grounding[0],
 		index: 0
 	}] });
-	else for (let i = 0; i < content.length; i += chunkSize) {
-		const slice = content.slice(i, i + chunkSize);
+	else require_helpers.surrogateSafeChunks(content, chunkSize).forEach((slice, k) => {
 		chunks.push({ candidates: [{
 			content: {
 				role: "model",
 				parts: [{ text: slice }]
 			},
+			...grounding[k],
 			index: 0
 		}] });
-	}
+	});
 	const parts = toolCalls.map((tc) => parseToolCallPart(tc, logger));
 	chunks.push({
 		candidates: [{
@@ -379,18 +514,31 @@ function buildGeminiContentWithToolCallsResponse(content, toolCalls, logger, rea
 		text: reasoning,
 		thought: true
 	});
+	parts.push(...geminiFileParts(overrides));
 	let blockHasTools;
+	let groundingText = content;
+	const textParts = [];
 	if (blocks && blocks.length > 0) {
 		const outcome = require_helpers.resolveFixtureBlockOutcome(blocks);
 		const resolved = outcome.ordered;
 		blockHasTools = outcome.hasToolCalls;
+		groundingText = outcome.content;
 		for (const block of resolved) if (block.type === "toolCall") parts.push(parseToolCallPart({
 			name: block.name,
 			arguments: block.arguments,
 			id: block.id
 		}, logger));
-		else parts.push({ text: block.text });
+		else {
+			const start = textParts.length > 0 ? textParts[textParts.length - 1].end : 0;
+			textParts.push({
+				partIndex: parts.length,
+				start,
+				end: start + block.text.length
+			});
+			parts.push({ text: block.text });
+		}
 	} else {
+		textParts.push(...geminiWholeTextPart(content, parts.length));
 		parts.push({ text: content });
 		parts.push(...toolCalls.map((tc) => parseToolCallPart(tc, logger)));
 	}
@@ -401,6 +549,7 @@ function buildGeminiContentWithToolCallsResponse(content, toolCalls, logger, rea
 				parts
 			},
 			finishReason: geminiFinishReason(overrides?.finishReason, blockHasTools === false ? "STOP" : "FUNCTION_CALL"),
+			...geminiGroundingField(groundingText, overrides, textParts),
 			index: 0
 		}],
 		usageMetadata: geminiUsageMetadata(overrides)
@@ -452,30 +601,19 @@ function buildGeminiAudioStreamChunks(audio, toolCalls, logger, effReasoning) {
 		usageMetadata: require_gemini.render()
 	}];
 }
-async function writeGeminiSSEStream(res, chunks, optionsOrLatency) {
-	const opts = typeof optionsOrLatency === "number" ? { latency: optionsOrLatency } : optionsOrLatency ?? {};
-	const latency = opts.latency ?? 0;
-	const profile = opts.streamingProfile;
-	const { recordedTimings, replaySpeed } = opts;
-	const signal = opts.signal;
-	const onChunkSent = opts.onChunkSent;
-	if (res.writableEnded) return true;
-	res.setHeader("Content-Type", "text/event-stream");
-	res.setHeader("Cache-Control", "no-cache");
-	res.setHeader("Connection", "keep-alive");
-	let chunkIndex = 0;
-	for (const chunk of chunks) {
-		const chunkDelay = require_sse_writer.calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);
-		if (chunkDelay > 0) await require_sse_writer.delay(chunkDelay, signal);
-		if (signal?.aborted) return false;
-		if (res.writableEnded) return true;
-		res.write(`data: ${JSON.stringify(chunk)}\n\n`);
-		onChunkSent?.();
-		if (signal?.aborted) return false;
-		chunkIndex++;
-	}
-	if (!res.writableEnded) res.end();
-	return true;
+const GEMINI_SSE = require_sse_writer.sseCodec({ done: false });
+const SILENT_LOGGER = new require_logger.Logger("silent");
+/**
+* The reasoning a misbehavior reply's non-streaming wait is sized with: the
+* plan response's reasoning through the same model and strict gate the
+* builders apply. The gate runs with a silent logger, so the builder's own
+* warning stays the only one. A reasoning-only plan carries its reasoning on
+* the plan, and `misbehaviorPayloadLength` reads it there.
+*/
+function misbehaviorPayloadReasoning(plan, model, strict) {
+	const response = plan.response;
+	if (plan.reasoning !== void 0 || !(require_helpers.isCombinedFixtureResponse(response) || require_helpers.isTextResponse(response) || require_helpers.isToolCallResponse(response))) return;
+	return require_helpers.resolveReasoningForModel(response.reasoning, model, strict, SILENT_LOGGER);
 }
 /** Prepare native fault output once; the journal describes these exact parts. */
 function prepareGeminiMisbehavior(plan, request, streaming, chunkSize, logger, strict) {
@@ -508,7 +646,11 @@ function prepareGeminiMisbehavior(plan, request, streaming, chunkSize, logger, s
 		candidate.finishReason = "UNEXPECTED_TOOL_CALL";
 		chunks = [{ candidates: [candidate] }];
 	} else if (fault === "stop-length-mid-tool") {
-		candidate.content.parts = content ? [{ text: content }] : [];
+		const parts = geminiFileParts(overrides);
+		const textPartIndex = parts.length;
+		if (content) parts.push({ text: content });
+		candidate.content.parts = parts;
+		if (content) Object.assign(candidate, geminiGroundingField(content, overrides, geminiWholeTextPart(content, textPartIndex)));
 		candidate.finishReason = "MAX_TOKENS";
 		chunks = [{ candidates: [candidate] }];
 	} else if (fault === "empty-response") {
@@ -626,7 +768,10 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 	completionReq._endpointType = "chat";
 	completionReq._context = require_helpers.getContext(req);
 	const testId = require_helpers.getTestId(req);
-	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, require_router.recordMatchOptions(!!defaults.record, defaults.logger));
+	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, {
+		...require_router.recordMatchOptions(!!defaults.record, defaults.logger),
+		wire: "gemini"
+	});
 	const path = req.url ?? `/v1beta/models/${model}:generateContent`;
 	if (fixture) logger.debug(`Fixture matched: ${JSON.stringify(fixture.match).slice(0, 120)}`);
 	else logger.debug(`No fixture matched for request`);
@@ -661,7 +806,7 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			return;
 		}
 		if (decisions.upstream && defaults.record) {
-			const outcome = await require_recorder.proxyAndRecord(req, res, completionReq, providerKey, path, fixtures, defaults, raw);
+			const { outcome, clientHungUp } = await require_proxy.withHangUpDetection(req, res, () => require_recorder.proxyAndRecord(req, res, completionReq, providerKey, path, fixtures, defaults, raw));
 			if (outcome === "handled_by_hook") return;
 			if (outcome !== "not_configured") {
 				journal.add({
@@ -672,7 +817,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 					response: {
 						status: res.statusCode ?? 200,
 						fixture: null,
-						source: "proxy"
+						source: "proxy",
+						...require_proxy.proxyInterruption(res, clientHungUp)
 					}
 				});
 				return;
@@ -736,8 +882,21 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
+	const streamTiming = {
+		latency,
+		streamingProfile: fixture.streamingProfile,
+		recordedTimings: fixture.recordedTimings,
+		replaySpeed
+	};
+	const jsonOpts = (payloadLength, duplicateId = false) => ({
+		surface: "other",
+		payloadLength,
+		chunkSize,
+		recordedTimings: fixture.recordedTimings,
+		duplicateId,
+		replaySpeed
+	});
 	if (misbehavior.kind === "applied") {
-		const prepared = prepareGeminiMisbehavior(misbehavior, completionReq, streaming, chunkSize, logger, require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression);
 		const entry = journal.add({
 			method: req.method ?? "POST",
 			path,
@@ -748,6 +907,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture
 			}
 		});
+		const strictReasoning = require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
+		const prepared = prepareGeminiMisbehavior(misbehavior, completionReq, streaming, chunkSize, logger, strictReasoning);
 		require_misbehavior.recordMisbehaviorOutcome({
 			entry,
 			summary: prepared.summary,
@@ -755,24 +916,26 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		if (!streaming) {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(prepared.chunks[0]));
-		} else {
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, prepared.chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				entry.response.interrupted = true;
-				entry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+			const preparedBody = prepared.chunks[0];
+			await require_deliver.deliverJson(res, entry, fixture, () => preparedBody, jsonOpts(require_timing.misbehaviorPayloadLength(misbehavior, misbehaviorPayloadReasoning(misbehavior, completionReq.model, strictReasoning)), !!misbehavior.duplicateId));
+		} else await require_deliver.deliverStream(res, entry, fixture, GEMINI_SSE, prepared.chunks, streamTiming);
+		return;
+	}
+	if (require_helpers.isRawResponse(response)) {
+		await require_raw.serveRawResponse({
+			wire: "gemini",
+			stream: streaming,
+			req,
+			res,
+			fixture,
+			response,
+			body: completionReq,
+			journal,
+			defaults,
+			testId,
+			misbehaviorSummary: misbehavior.summary,
+			errorWire: "gemini"
+		});
 		return;
 	}
 	if (require_helpers.isErrorResponse(response)) {
@@ -819,27 +982,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		const audioToolCalls = Array.isArray(response.toolCalls) ? require_helpers.requireServedFunctionToolCalls(response, wire) : [];
-		if (!streaming) {
-			const body = buildGeminiAudioResponse(response, audioToolCalls, logger, effReasoning);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiAudioStreamChunks(response, audioToolCalls, logger, effReasoning);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiAudioResponse(response, audioToolCalls, logger, effReasoning), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiAudioStreamChunks(response, audioToolCalls, logger, effReasoning), streamTiming);
 		return;
 	}
 	if (require_helpers.isCombinedFixtureResponse(response)) {
@@ -864,27 +1008,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, wire);
-		if (!streaming) {
-			const body = buildGeminiContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiContentWithToolCallsStreamChunks(response.content ?? "", functionToolCalls, chunkSize, logger, effReasoning, overrides, response.blocks);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiContentWithToolCallsStreamChunks(response.content ?? "", functionToolCalls, chunkSize, logger, effReasoning, overrides, response.blocks), streamTiming);
 		return;
 	}
 	if (require_helpers.isTextResponse(response)) {
@@ -908,27 +1033,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			defaults,
 			testId
 		});
-		if (!streaming) {
-			const body = buildGeminiTextResponse(response.content, effReasoning, overrides);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiTextStreamChunks(response.content, chunkSize, effReasoning, overrides);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiTextResponse(response.content, effReasoning, overrides), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiTextStreamChunks(response.content, chunkSize, effReasoning, overrides), streamTiming);
 		return;
 	}
 	if (require_helpers.isToolCallResponse(response)) {
@@ -953,27 +1059,8 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 			testId
 		});
 		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, wire);
-		if (!streaming) {
-			const body = buildGeminiToolCallResponse(functionToolCalls, logger, effReasoning, overrides);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
-			const chunks = buildGeminiToolCallStreamChunks(functionToolCalls, chunkSize, logger, effReasoning, overrides);
-			const interruption = require_interruption.createInterruptionSignal(fixture);
-			if (!await writeGeminiSSEStream(res, chunks, {
-				latency,
-				streamingProfile: fixture.streamingProfile,
-				recordedTimings: fixture.recordedTimings,
-				replaySpeed,
-				signal: interruption?.signal,
-				onChunkSent: interruption?.tick
-			})) {
-				if (!res.writableEnded) res.destroy();
-				journalEntry.response.interrupted = true;
-				journalEntry.response.interruptReason = interruption?.reason();
-			}
-			interruption?.cleanup();
-		}
+		if (!streaming) await require_deliver.deliverJson(res, journalEntry, fixture, () => buildGeminiToolCallResponse(functionToolCalls, logger, effReasoning, overrides), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
+		else await require_deliver.deliverStream(res, journalEntry, fixture, GEMINI_SSE, buildGeminiToolCallStreamChunks(functionToolCalls, chunkSize, logger, effReasoning, overrides), streamTiming);
 		return;
 	}
 	require_misbehavior.recordMisbehaviorOutcome({