@copilotkit/aimock 1.34.0 → 1.35.0

package/dist/ws-realtime.cjs

@@ -546,6 +546,10 @@ async function handleResponseCreate(ws, fixtures, journal, defaults, session, co
 				fixture
 			}
 		});
+		if (response.blocks && response.blocks.length > 0) {
+			await streamRealtimeBlocks(ws, require_helpers.resolveFixtureBlocks(response.blocks), responseId, fixture, defaults, latency, chunkSize, isBeta, conversationItems, journalEntry);
+			return;
+		}
 		sendEvent(ws, {
 			type: "response.created",
 			response: {
@@ -598,7 +602,7 @@ async function handleResponseCreate(ws, fixtures, journal, defaults, session, co
 				text: ""
 			}
 		}, isBeta);
-		const content = response.content;
+		const content = response.content ?? "";
 		const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
 		const { recordedTimings } = fixture;
 		let eventIndex = 0;
@@ -695,8 +699,9 @@ async function handleResponseCreate(ws, fixtures, journal, defaults, session, co
 			return;
 		}
 		allOutputItems.push(textOutputItem);
-		for (let tcIdx = 0; tcIdx < response.toolCalls.length; tcIdx++) {
-			const tc = response.toolCalls[tcIdx];
+		const toolCalls = response.toolCalls ?? [];
+		for (let tcIdx = 0; tcIdx < toolCalls.length; tcIdx++) {
+			const tc = toolCalls[tcIdx];
 			const callId = tc.id ?? require_helpers.generateToolCallId();
 			const itemId = realtimeId("item");
 			const outputIndex = tcIdx + 1;
@@ -882,7 +887,7 @@ async function handleResponseCreate(ws, fixtures, journal, defaults, session, co
 				text: ""
 			}
 		}, isBeta);
-		const content = response.content;
+		const content = response.content ?? "";
 		const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
 		const { recordedTimings } = fixture;
 		const interruption = require_interruption.createInterruptionSignal(fixture);
@@ -1147,6 +1152,278 @@ async function handleResponseCreate(ws, fixtures, journal, defaults, session, co
 	});
 	buildErrorRealtimeEvent(ws, "Fixture response did not match any known type", isBeta, "server_error");
 }
+/**
+* Stream a content+toolCalls fixture's ordered `blocks` over the Realtime WS
+* surface (#274). Each block becomes its own output item, sequenced on the wire
+* with an incrementing `output_index` so a client observes the blocks in array
+* order (text and tool-call items can interleave in any order, unlike the
+* separate channels of chat-completions). Emits the same per-item event shapes
+* as the legacy text/tool branches; a blocks-only fixture therefore never
+* produces an empty payload.
+*/
+async function streamRealtimeBlocks(ws, blocks, responseId, fixture, defaults, latency, chunkSize, isBeta, conversationItems, journalEntry) {
+	sendEvent(ws, {
+		type: "response.created",
+		response: {
+			id: responseId,
+			object: "realtime.response",
+			status: "in_progress",
+			status_details: null,
+			output: [],
+			usage: null
+		}
+	}, isBeta);
+	const interruption = require_interruption.createInterruptionSignal(fixture);
+	let interrupted = false;
+	const allOutputItems = [];
+	const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
+	const { recordedTimings } = fixture;
+	let eventIndex = 0;
+	const hasToolCalls = blocks.some((b) => b.type === "toolCall");
+	for (let outputIndex = 0; outputIndex < blocks.length; outputIndex++) {
+		if (ws.isClosed || interrupted) break;
+		const block = blocks[outputIndex];
+		if (block.type === "text") {
+			const textItemId = realtimeId("item");
+			const contentIndex = 0;
+			const textPhase = hasToolCalls ? "commentary" : "final_answer";
+			const text = block.text;
+			const textOutputItem = {
+				id: textItemId,
+				type: "message",
+				role: "assistant",
+				status: "completed",
+				content: [{
+					type: "output_text",
+					text
+				}]
+			};
+			sendEvent(ws, {
+				type: "response.output_item.added",
+				response_id: responseId,
+				output_index: outputIndex,
+				item: {
+					id: textItemId,
+					type: "message",
+					role: "assistant",
+					status: "in_progress",
+					content: [],
+					phase: textPhase
+				}
+			}, isBeta);
+			sendEvent(ws, {
+				type: "response.content_part.added",
+				response_id: responseId,
+				item_id: textItemId,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				part: {
+					type: "output_text",
+					text: ""
+				}
+			}, isBeta);
+			for (let i = 0; i < text.length; i += chunkSize) {
+				if (ws.isClosed) break;
+				const chunkDelay = require_sse_writer.calculateDelay(eventIndex, void 0, latency, recordedTimings, replaySpeed);
+				if (chunkDelay > 0) await require_sse_writer.delay(chunkDelay, interruption?.signal);
+				if (interruption?.signal.aborted) {
+					interrupted = true;
+					break;
+				}
+				if (ws.isClosed) break;
+				const chunk = text.slice(i, i + chunkSize);
+				try {
+					sendEvent(ws, {
+						type: "response.output_text.delta",
+						response_id: responseId,
+						item_id: textItemId,
+						output_index: outputIndex,
+						content_index: contentIndex,
+						delta: chunk
+					}, isBeta);
+				} catch (err) {
+					defaults.logger.debug("[ws-realtime] send failed during block text streaming, closing", err);
+					break;
+				}
+				eventIndex++;
+				interruption?.tick();
+				if (interruption?.signal.aborted) {
+					interrupted = true;
+					break;
+				}
+			}
+			if (interrupted || ws.isClosed) break;
+			sendEvent(ws, {
+				type: "response.output_text.done",
+				response_id: responseId,
+				item_id: textItemId,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				text
+			}, isBeta);
+			if (ws.isClosed) break;
+			sendEvent(ws, {
+				type: "response.content_part.done",
+				response_id: responseId,
+				item_id: textItemId,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				part: {
+					type: "output_text",
+					text
+				}
+			}, isBeta);
+			if (ws.isClosed) break;
+			sendEvent(ws, {
+				type: "response.output_item.done",
+				response_id: responseId,
+				output_index: outputIndex,
+				item: {
+					...textOutputItem,
+					phase: textPhase
+				}
+			}, isBeta);
+			sendEvent(ws, {
+				type: "conversation.item.done",
+				item: {
+					id: textItemId,
+					object: "realtime.item",
+					type: "message",
+					role: "assistant",
+					status: "completed",
+					content: textOutputItem.content
+				}
+			}, isBeta);
+			if (ws.isClosed) break;
+			allOutputItems.push(textOutputItem);
+		} else {
+			const callId = block.id ?? require_helpers.generateToolCallId();
+			const itemId = realtimeId("item");
+			const args = block.arguments;
+			const toolOutputItem = {
+				id: itemId,
+				type: "function_call",
+				status: "completed",
+				call_id: callId,
+				name: block.name,
+				arguments: args
+			};
+			sendEvent(ws, {
+				type: "response.output_item.added",
+				response_id: responseId,
+				output_index: outputIndex,
+				item: {
+					id: itemId,
+					type: "function_call",
+					status: "in_progress",
+					call_id: callId,
+					name: block.name,
+					arguments: "",
+					phase: "final_answer"
+				}
+			}, isBeta);
+			for (let i = 0; i < args.length; i += chunkSize) {
+				if (ws.isClosed) break;
+				const chunkDelay = require_sse_writer.calculateDelay(eventIndex, void 0, latency, recordedTimings, replaySpeed);
+				if (chunkDelay > 0) await require_sse_writer.delay(chunkDelay, interruption?.signal);
+				if (interruption?.signal.aborted) {
+					interrupted = true;
+					break;
+				}
+				if (ws.isClosed) break;
+				const chunk = args.slice(i, i + chunkSize);
+				try {
+					sendEvent(ws, {
+						type: "response.function_call_arguments.delta",
+						response_id: responseId,
+						item_id: itemId,
+						output_index: outputIndex,
+						call_id: callId,
+						delta: chunk
+					}, isBeta);
+				} catch (err) {
+					defaults.logger.debug("[ws-realtime] send failed during block tool call streaming, closing", err);
+					break;
+				}
+				eventIndex++;
+				interruption?.tick();
+				if (interruption?.signal.aborted) {
+					interrupted = true;
+					break;
+				}
+			}
+			if (interrupted || ws.isClosed) break;
+			sendEvent(ws, {
+				type: "response.function_call_arguments.done",
+				response_id: responseId,
+				item_id: itemId,
+				output_index: outputIndex,
+				call_id: callId,
+				arguments: args
+			}, isBeta);
+			if (ws.isClosed) break;
+			sendEvent(ws, {
+				type: "response.output_item.done",
+				response_id: responseId,
+				output_index: outputIndex,
+				item: {
+					...toolOutputItem,
+					phase: "final_answer"
+				}
+			}, isBeta);
+			sendEvent(ws, {
+				type: "conversation.item.done",
+				item: {
+					id: itemId,
+					object: "realtime.item",
+					type: "function_call",
+					status: "completed",
+					call_id: callId,
+					name: block.name,
+					arguments: args
+				}
+			}, isBeta);
+			if (ws.isClosed) break;
+			allOutputItems.push(toolOutputItem);
+		}
+	}
+	if (interrupted) {
+		ws.destroy();
+		journalEntry.response.interrupted = true;
+		journalEntry.response.interruptReason = interruption?.reason();
+		interruption?.cleanup();
+		return;
+	}
+	interruption?.cleanup();
+	if (ws.isClosed) return;
+	sendEvent(ws, {
+		type: "response.done",
+		response: {
+			id: responseId,
+			object: "realtime.response",
+			status: "completed",
+			output: allOutputItems,
+			usage: {
+				total_tokens: 0,
+				input_tokens: 0,
+				output_tokens: 0
+			}
+		}
+	}, isBeta);
+	for (const item of allOutputItems) {
+		const it = item;
+		if (it.type === "message") conversationItems.push({
+			type: "message",
+			id: it.id,
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: it.content?.[0]?.text ?? ""
+			}]
+		});
+		else conversationItems.push(item);
+	}
+}
 
 //#endregion
 exports.handleWebSocketRealtime = handleWebSocketRealtime;