@copilotkit/aimock 1.37.4 → 1.38.0

package/dist/responses.cjs

@@ -1,3 +1,4 @@
+const require_model_utils = require('./model-utils.cjs');
 const require_helpers = require('./helpers.cjs');
 const require_router = require('./router.cjs');
 const require_sse_writer = require('./sse-writer.cjs');
@@ -161,8 +162,8 @@ function responseId() {
 function itemId() {
 	return require_helpers.generateId("msg");
 }
-function buildTextStreamEvents(content, model, chunkSize, reasoning, webSearches, overrides) {
-	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides);
+function buildTextStreamEvents(content, model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 	const { events: msgEvents, msgItem } = buildMessageOutputEvents(content, chunkSize, nextOutputIndex);
 	events.push(...msgEvents);
 	events.push({
@@ -179,8 +180,8 @@ function buildTextStreamEvents(content, model, chunkSize, reasoning, webSearches
 	});
 	return events;
 }
-function buildToolCallStreamEvents(toolCalls, model, chunkSize, reasoning, webSearches, overrides) {
-	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides);
+function buildToolCallStreamEvents(toolCalls, model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 	const fcOutputItems = [];
 	for (let idx = 0; idx < toolCalls.length; idx++) {
 		const tc = toolCalls[idx];
@@ -244,66 +245,184 @@ function buildToolCallStreamEvents(toolCalls, model, chunkSize, reasoning, webSe
 	});
 	return events;
 }
-function buildReasoningStreamEvents(reasoning, model, chunkSize) {
+/**
+* Whether the incoming Responses request should receive encrypted reasoning.
+*
+* Two observed triggers, gated on EITHER:
+*  - `include: ["reasoning.encrypted_content"]` — the explicit opt-in, and what
+*    `agent-framework-openai` >= 1.11.0 auto-appends on its stateless-replay path
+*    (it never sends `store`), so this is the branch that fires for real clients.
+*  - `store: false` — captured responses carry the blob when not server-side
+*    stored (ZDR) and omit it when stored; kept as a secondary trigger for
+*    clients that go stateless without opting in via `include`.
+*
+* Stored / opted-out replays stay byte-identical. Exported so the WebSocket
+* Responses transport can share one gate.
+*/
+function requestWantsEncryptedReasoning(req) {
+	if (requestIncludesEncryptedReasoning(req)) return true;
+	return req.store === false;
+}
+/**
+* Whether the request carries the EXPLICIT `include` opt-in — a strictly
+* narrower gate than `requestWantsEncryptedReasoning`, which also fires on
+* `store: false`.
+*
+* This is the gate for SYNTHESIZING a reasoning item that the fixture does not
+* declare (see `shouldSynthesizeBlobOnlyReasoning`), and it is deliberately the
+* narrow one. Attaching a field to an item aimock was already emitting is a much
+* smaller step than conjuring a whole output item that did not previously exist,
+* so the larger behavior change gets the gate that is directly observable in the
+* request rather than the inferred `store: false` one. `agent-framework-openai`
+* >= 1.11.0 auto-appends `include` on its stateless-replay path and never sends
+* `store` at all, so the motivating client is fully served by this branch — the
+* narrowing costs the feature nothing.
+*
+* Exported so the WebSocket Responses transport shares one gate.
+*/
+function requestIncludesEncryptedReasoning(req) {
+	const include = req.include;
+	return Array.isArray(include) && include.includes("reasoning.encrypted_content");
+}
+/**
+* Synthetic stand-in for OpenAI's opaque `reasoning.encrypted_content`. aimock
+* has no real ciphertext; it emits a base64 placeholder derived from the
+* reasoning id (stable for a given item, opaque like the real field). Consumers
+* store it (e.g. as agent-framework `protected_data`) and replay it verbatim;
+* aimock matches on content and ignores the echoed blob. Without it,
+* agent-framework-openai >= 1.11.0 hard-fails a reasoning + multi-tool chain on
+* the follow-up request. See microsoft/agent-framework#7233.
+*
+* aimock skips inbound reasoning items entirely, so it cannot reproduce
+* OpenAI's `invalid_encrypted_content` rejection of a mismatched blob/id — a
+* known replay-only limitation.
+*/
+function syntheticEncryptedReasoning(reasoningId) {
+	return Buffer.from(`aimock-encrypted-reasoning:${reasoningId}`).toString("base64");
+}
+/**
+* Build a Responses `reasoning` output item. `summaryText` controls the summary
+* (present for the terminal `done` / non-streaming item, omitted for the
+* in-progress `added` item); `emitEncrypted` controls the blob INDEPENDENTLY of
+* the summary, so a blob with an empty summary is expressible. aimock emits the
+* blob only on the terminal item and omits it on `added`: real OpenAI populates
+* `added` opportunistically, but the field is `anyOf: [string, null]` and
+* non-required, so consumers should read it at `done` and treat `added` as
+* best-effort — omitting there is legal and harmless.
+*/
+function buildReasoningOutputItem(reasoningId, opts = {}) {
+	const item = {
+		type: "reasoning",
+		id: reasoningId,
+		summary: opts.summaryText === void 0 ? [] : [{
+			type: "summary_text",
+			text: opts.summaryText
+		}]
+	};
+	if (opts.emitEncrypted) item.encrypted_content = syntheticEncryptedReasoning(reasoningId);
+	return item;
+}
+/**
+* Whether to synthesize a summary-LESS reasoning item that exists purely to
+* carry the encrypted blob.
+*
+* Every reasoning item aimock emits otherwise originates in a fixture's declared
+* `reasoning` summary text. But a fixture RECORDED from the real stateless
+* agent-framework flow typically has NO summary — OpenAI returns `summary: []`
+* unless summaries are explicitly requested — so keying the item on a declared
+* summary starves the exact flow this feature exists to serve: fully opted in,
+* yet no reasoning item and therefore no blob. Real OpenAI, for a
+* reasoning-capable model, still returns a reasoning item (`summary: []`) with
+* the blob populated. So synthesize one, gated on:
+*
+*  - the EXPLICIT `include` opt-in ONLY (`requestIncludesEncryptedReasoning`),
+*    which is NARROWER than the `requestWantsEncryptedReasoning` gate that
+*    controls the blob itself. A `store: false` request whose fixture declares no
+*    summary therefore gets NO reasoning item, exactly as before this change.
+*    Two reasons: (1) creating an output item that did not previously exist is a
+*    bigger behavior change than adding a field to an item already being
+*    emitted, so it earns the gate that is directly observable in the request
+*    rather than the inferred one; (2) the `store: false` trigger's supporting
+*    capture evidence is not verifiable from this repo, and a larger change must
+*    not be stacked on an unverifiable premise. `agent-framework-openai` >=
+*    1.11.0 sends `include` and never `store`, so nothing is lost.
+*  - the REQUESTED model's reasoning capability (aimock#254) — emitting a
+*    reasoning item for gpt-4o would be LESS faithful, not more, since that
+*    model has no reasoning channel at all. Unlike `resolveReasoningForModel`,
+*    which fails open for a declared summary (a recorded summary is evidence the
+*    model did reason), there is nothing to preserve here: a synthesized item on
+*    a non-reasoning model would be pure fabrication, so this gate is hard.
+*
+* Note this is INDEPENDENT of `emitEncryptedReasoning`: when a fixture DOES
+* declare a summary, the blob still rides on it under either trigger (including
+* `store: false`), unchanged.
+*/
+function shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning) {
+	if (reasoning) return false;
+	if (!synthesizeSummarylessReasoning) return false;
+	return require_model_utils.isReasoningModel(model);
+}
+/**
+* `reasoning` is `undefined` for a synthesized blob-only item (see
+* `shouldSynthesizeBlobOnlyReasoning`). In that case the item's `summary` is
+* `[]`, so the summary-part / summary-text events are SKIPPED entirely — they
+* would describe a part that does not exist on the item — leaving a coherent
+* `output_item.added` → `output_item.done` pair with nothing between.
+*/
+function buildReasoningStreamEvents(reasoning, chunkSize, emitEncryptedReasoning = false) {
 	const reasoningId = require_helpers.generateId("rs");
 	const events = [];
 	events.push({
 		type: "response.output_item.added",
 		output_index: 0,
-		item: {
-			type: "reasoning",
-			id: reasoningId,
-			summary: []
-		}
+		item: buildReasoningOutputItem(reasoningId)
 	});
-	events.push({
-		type: "response.reasoning_summary_part.added",
-		item_id: reasoningId,
-		output_index: 0,
-		summary_index: 0,
-		part: {
-			type: "summary_text",
-			text: ""
+	if (reasoning !== void 0) {
+		events.push({
+			type: "response.reasoning_summary_part.added",
+			item_id: reasoningId,
+			output_index: 0,
+			summary_index: 0,
+			part: {
+				type: "summary_text",
+				text: ""
+			}
+		});
+		for (let i = 0; i < reasoning.length; i += chunkSize) {
+			const slice = reasoning.slice(i, i + chunkSize);
+			events.push({
+				type: "response.reasoning_summary_text.delta",
+				item_id: reasoningId,
+				output_index: 0,
+				summary_index: 0,
+				delta: slice
+			});
 		}
-	});
-	for (let i = 0; i < reasoning.length; i += chunkSize) {
-		const slice = reasoning.slice(i, i + chunkSize);
 		events.push({
-			type: "response.reasoning_summary_text.delta",
+			type: "response.reasoning_summary_text.done",
 			item_id: reasoningId,
 			output_index: 0,
 			summary_index: 0,
-			delta: slice
+			text: reasoning
+		});
+		events.push({
+			type: "response.reasoning_summary_part.done",
+			item_id: reasoningId,
+			output_index: 0,
+			summary_index: 0,
+			part: {
+				type: "summary_text",
+				text: reasoning
+			}
 		});
 	}
-	events.push({
-		type: "response.reasoning_summary_text.done",
-		item_id: reasoningId,
-		output_index: 0,
-		summary_index: 0,
-		text: reasoning
-	});
-	events.push({
-		type: "response.reasoning_summary_part.done",
-		item_id: reasoningId,
-		output_index: 0,
-		summary_index: 0,
-		part: {
-			type: "summary_text",
-			text: reasoning
-		}
-	});
 	events.push({
 		type: "response.output_item.done",
 		output_index: 0,
-		item: {
-			type: "reasoning",
-			id: reasoningId,
-			summary: [{
-				type: "summary_text",
-				text: reasoning
-			}]
-		}
+		item: buildReasoningOutputItem(reasoningId, {
+			summaryText: reasoning,
+			emitEncrypted: emitEncryptedReasoning
+		})
 	});
 	return events;
 }
@@ -341,7 +460,7 @@ function buildWebSearchStreamEvents(queries, startOutputIndex) {
 	}
 	return events;
 }
-function buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides) {
+function buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
 	const respId = overrides?.id ?? responseId();
 	const created = overrides?.created ?? Math.floor(Date.now() / 1e3);
 	const effectiveModel = overrides?.model ?? model;
@@ -370,8 +489,8 @@ function buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrid
 			output: []
 		}
 	});
-	if (reasoning) {
-		const reasoningEvents = buildReasoningStreamEvents(reasoning, model, chunkSize);
+	if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) {
+		const reasoningEvents = buildReasoningStreamEvents(reasoning, chunkSize, emitEncryptedReasoning);
 		events.push(...reasoningEvents);
 		const doneEvent = reasoningEvents.find((e) => e.type === "response.output_item.done" && e.item?.type === "reasoning");
 		if (doneEvent) prefixOutputItems.push(doneEvent.item);
@@ -518,16 +637,12 @@ function buildFunctionCallOutputEvents(toolCall, chunkSize, outputIndex) {
 		fcItem
 	};
 }
-function buildOutputPrefix(content, reasoning, webSearches) {
+function buildOutputPrefix(content, model, reasoning, webSearches, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
 	const output = [];
-	if (reasoning) output.push({
-		type: "reasoning",
-		id: require_helpers.generateId("rs"),
-		summary: [{
-			type: "summary_text",
-			text: reasoning
-		}]
-	});
+	if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) output.push(buildReasoningOutputItem(require_helpers.generateId("rs"), {
+		summaryText: reasoning,
+		emitEncrypted: emitEncryptedReasoning
+	}));
 	if (webSearches && webSearches.length > 0) for (const query of webSearches) output.push({
 		type: "web_search_call",
 		id: require_helpers.generateId("ws"),
@@ -561,19 +676,15 @@ function buildResponseEnvelope(model, output, overrides) {
 		usage: responsesUsage(overrides)
 	};
 }
-function buildTextResponse(content, model, reasoning, webSearches, overrides) {
-	return buildResponseEnvelope(model, buildOutputPrefix(content, reasoning, webSearches), overrides);
+function buildTextResponse(content, model, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	return buildResponseEnvelope(model, buildOutputPrefix(content, model, reasoning, webSearches, emitEncryptedReasoning, synthesizeSummarylessReasoning), overrides);
 }
-function buildToolCallResponse(toolCalls, model, reasoning, webSearches, overrides) {
+function buildToolCallResponse(toolCalls, model, reasoning, webSearches, overrides, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
 	const output = [];
-	if (reasoning) output.push({
-		type: "reasoning",
-		id: require_helpers.generateId("rs"),
-		summary: [{
-			type: "summary_text",
-			text: reasoning
-		}]
-	});
+	if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) output.push(buildReasoningOutputItem(require_helpers.generateId("rs"), {
+		summaryText: reasoning,
+		emitEncrypted: emitEncryptedReasoning
+	}));
 	if (webSearches && webSearches.length > 0) for (const query of webSearches) output.push({
 		type: "web_search_call",
 		id: require_helpers.generateId("ws"),
@@ -593,8 +704,8 @@ function buildToolCallResponse(toolCalls, model, reasoning, webSearches, overrid
 	});
 	return buildResponseEnvelope(model, output, overrides);
 }
-function buildContentWithToolCallsStreamEvents(content, toolCalls, model, chunkSize, reasoning, webSearches, overrides, blocks) {
-	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides);
+function buildContentWithToolCallsStreamEvents(content, toolCalls, model, chunkSize, reasoning, webSearches, overrides, blocks, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
+	const { respId, created, events, prefixOutputItems, nextOutputIndex } = buildResponsePreamble(model, chunkSize, reasoning, webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 	const orderedOutputItems = [];
 	if (blocks && blocks.length > 0) {
 		const ordered = require_helpers.resolveFixtureBlocks(blocks);
@@ -663,18 +774,14 @@ function buildMessageOutputItem(content) {
 		}]
 	};
 }
-function buildContentWithToolCallsResponse(content, toolCalls, model, reasoning, webSearches, overrides, blocks) {
+function buildContentWithToolCallsResponse(content, toolCalls, model, reasoning, webSearches, overrides, blocks, emitEncryptedReasoning = false, synthesizeSummarylessReasoning = false) {
 	if (blocks && blocks.length > 0) {
 		const ordered = require_helpers.resolveFixtureBlocks(blocks);
 		const output = [];
-		if (reasoning) output.push({
-			type: "reasoning",
-			id: require_helpers.generateId("rs"),
-			summary: [{
-				type: "summary_text",
-				text: reasoning
-			}]
-		});
+		if (reasoning || shouldSynthesizeBlobOnlyReasoning(reasoning, model, synthesizeSummarylessReasoning)) output.push(buildReasoningOutputItem(require_helpers.generateId("rs"), {
+			summaryText: reasoning,
+			emitEncrypted: emitEncryptedReasoning
+		}));
 		if (webSearches && webSearches.length > 0) for (const query of webSearches) output.push({
 			type: "web_search_call",
 			id: require_helpers.generateId("ws"),
@@ -692,7 +799,7 @@ function buildContentWithToolCallsResponse(content, toolCalls, model, reasoning,
 		}));
 		return buildResponseEnvelope(model, output, overrides);
 	}
-	const output = buildOutputPrefix(content, reasoning, webSearches);
+	const output = buildOutputPrefix(content, model, reasoning, webSearches, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 	for (const tc of toolCalls) output.push(buildFunctionCallOutputItem(tc));
 	return buildResponseEnvelope(model, output, overrides);
 }
@@ -748,6 +855,8 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 	const completionReq = responsesToCompletionRequest(responsesReq);
 	completionReq._endpointType = "chat";
 	completionReq._context = require_helpers.getContext(req);
+	const emitEncryptedReasoning = requestWantsEncryptedReasoning(responsesReq);
+	const synthesizeSummarylessReasoning = requestIncludesEncryptedReasoning(responsesReq);
 	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));
 	if (fixture) {
@@ -854,11 +963,11 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 			}
 		});
 		if (responsesReq.stream !== true) {
-			const body = buildContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], completionReq.model, effReasoning, response.webSearches, overrides, response.blocks);
+			const body = buildContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], completionReq.model, effReasoning, response.webSearches, overrides, response.blocks, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildContentWithToolCallsStreamEvents(response.content ?? "", response.toolCalls ?? [], completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, response.blocks);
+			const events = buildContentWithToolCallsStreamEvents(response.content ?? "", response.toolCalls ?? [], completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, response.blocks, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeResponsesSSEStream(res, events, {
 				latency,
@@ -891,11 +1000,11 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 			}
 		});
 		if (responsesReq.stream !== true) {
-			const body = buildTextResponse(response.content, completionReq.model, effReasoning, response.webSearches, overrides);
+			const body = buildTextResponse(response.content, completionReq.model, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildTextStreamEvents(response.content, completionReq.model, chunkSize, effReasoning, response.webSearches, overrides);
+			const events = buildTextStreamEvents(response.content, completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeResponsesSSEStream(res, events, {
 				latency,
@@ -928,11 +1037,11 @@ async function handleResponses(req, res, raw, fixtures, journal, defaults, setCo
 			}
 		});
 		if (responsesReq.stream !== true) {
-			const body = buildToolCallResponse(response.toolCalls, completionReq.model, effReasoning, response.webSearches, overrides);
+			const body = buildToolCallResponse(response.toolCalls, completionReq.model, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildToolCallStreamEvents(response.toolCalls, completionReq.model, chunkSize, effReasoning, response.webSearches, overrides);
+			const events = buildToolCallStreamEvents(response.toolCalls, completionReq.model, chunkSize, effReasoning, response.webSearches, overrides, emitEncryptedReasoning, synthesizeSummarylessReasoning);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeResponsesSSEStream(res, events, {
 				latency,
@@ -971,5 +1080,7 @@ exports.buildContentWithToolCallsStreamEvents = buildContentWithToolCallsStreamE
 exports.buildTextStreamEvents = buildTextStreamEvents;
 exports.buildToolCallStreamEvents = buildToolCallStreamEvents;
 exports.handleResponses = handleResponses;
+exports.requestIncludesEncryptedReasoning = requestIncludesEncryptedReasoning;
+exports.requestWantsEncryptedReasoning = requestWantsEncryptedReasoning;
 exports.responsesToCompletionRequest = responsesToCompletionRequest;
 //# sourceMappingURL=responses.cjs.map