@copilotkit/aimock 1.15.0 → 1.16.0

package/dist/recorder.js

@@ -28,14 +28,17 @@ const STRIP_HEADERS = new Set([
 * Proxy an unmatched request to the real upstream provider, record the
 * response as a fixture on disk and in memory, then relay the response
 * back to the original client.
+*
+* Returns `true` if the request was proxied (provider configured),
+* `false` if no upstream URL is configured for the given provider key.
 */
-async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures, defaults, rawBody, options) {
+async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures, defaults, rawBody) {
 	const record = defaults.record;
-	if (!record) return "not_configured";
+	if (!record) return false;
 	const upstreamUrl = record.providers[providerKey];
 	if (!upstreamUrl) {
 		defaults.logger.warn(`No upstream URL configured for provider "${providerKey}" — cannot proxy`);
-		return "not_configured";
+		return false;
 	}
 	const fixturePath = record.fixturePath ?? "./fixtures/recorded";
 	let target;
@@ -47,7 +50,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 			message: `Invalid upstream URL: ${upstreamUrl}`,
 			type: "proxy_error"
 		} }));
-		return "relayed";
+		return true;
 	}
 	defaults.logger.warn(`NO FIXTURE MATCH — proxying to ${upstreamUrl}${pathname}`);
 	const forwardHeaders = {};
@@ -58,6 +61,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 	let upstreamBody;
 	let rawBuffer;
 	let streamedToClient = false;
+	let clientDisconnected = false;
 	try {
 		const result = await makeUpstreamRequest(target, forwardHeaders, requestBody, res);
 		upstreamStatus = result.status;
@@ -65,15 +69,18 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		upstreamBody = result.body;
 		rawBuffer = result.rawBuffer;
 		streamedToClient = result.streamedToClient;
+		clientDisconnected = result.clientDisconnected;
 	} catch (err) {
 		const msg = err instanceof Error ? err.message : "Unknown proxy error";
 		defaults.logger.error(`Proxy request failed: ${msg}`);
-		res.writeHead(502, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ error: {
-			message: `Proxy to upstream failed: ${msg}`,
-			type: "proxy_error"
-		} }));
-		return "relayed";
+		if (!res.headersSent) {
+			res.writeHead(502, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: {
+				message: `Proxy to upstream failed: ${msg}`,
+				type: "proxy_error"
+			} }));
+		} else res.end();
+		return true;
 	}
 	const contentType = upstreamHeaders["content-type"];
 	const ctString = Array.isArray(contentType) ? contentType.join(", ") : contentType ?? "";
@@ -91,10 +98,20 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		if (collapsed.truncated) defaults.logger.warn("Bedrock EventStream: CRC mismatch — response may be truncated");
 		if (collapsed.droppedChunks && collapsed.droppedChunks > 0) defaults.logger.warn(`${collapsed.droppedChunks} chunk(s) dropped during stream collapse`);
 		if (collapsed.content === "" && (!collapsed.toolCalls || collapsed.toolCalls.length === 0)) defaults.logger.warn("Stream collapse produced empty content — fixture may be incomplete");
-		if (collapsed.toolCalls && collapsed.toolCalls.length > 0) {
-			if (collapsed.content) defaults.logger.warn("Collapsed response has both content and toolCalls — preferring toolCalls");
-			fixtureResponse = { toolCalls: collapsed.toolCalls };
-		} else fixtureResponse = { content: collapsed.content ?? "" };
+		const reasoningSpread = collapsed.reasoning ? { reasoning: collapsed.reasoning } : {};
+		if (collapsed.toolCalls && collapsed.toolCalls.length > 0) if (collapsed.content) fixtureResponse = {
+			content: collapsed.content,
+			toolCalls: collapsed.toolCalls,
+			...reasoningSpread
+		};
+		else fixtureResponse = {
+			toolCalls: collapsed.toolCalls,
+			...reasoningSpread
+		};
+		else fixtureResponse = {
+			content: collapsed.content ?? "",
+			...reasoningSpread
+		};
 	} else {
 		let parsedResponse = null;
 		try {
@@ -105,9 +122,15 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		let encodingFormat;
 		try {
 			encodingFormat = rawBody ? JSON.parse(rawBody).encoding_format : void 0;
-		} catch {}
+		} catch (err) {
+			defaults.logger.debug(`Could not parse encoding_format from raw body: ${err instanceof Error ? err.message : "unknown error"}`);
+		}
 		fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, encodingFormat);
 	}
+	if (clientDisconnected) {
+		defaults.logger.warn("Client disconnected mid-stream — skipping fixture save to avoid truncated data");
+		return true;
+	}
 	const fixtureMatch = buildFixtureMatch(defaults.requestTransform ? defaults.requestTransform(request) : request);
 	const fixture = {
 		match: fixtureMatch,
@@ -132,29 +155,22 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : "Unknown filesystem error";
 			defaults.logger.error(`Failed to save fixture to disk: ${msg}`);
-			res.setHeader("X-LLMock-Record-Error", msg);
+			if (!res.headersSent) res.setHeader("X-LLMock-Record-Error", msg);
+			else defaults.logger.warn(`Cannot set X-LLMock-Record-Error header — headers already sent`);
 		}
 		if (writtenToDisk) {
 			if (!isEmptyMatch) fixtures.push(fixture);
 			defaults.logger.warn(`Response recorded → ${filepath}`);
 		} else defaults.logger.warn(`Response relayed but NOT saved to disk — see error above`);
 	} else defaults.logger.info(`Proxied ${providerKey} request (proxy-only mode)`);
-	if (streamedToClient) {
-		if (options?.beforeWriteResponse && options.onHookBypassed) options.onHookBypassed("sse_streamed");
-	} else {
-		if (options?.beforeWriteResponse) {
-			if (await options.beforeWriteResponse({
-				status: upstreamStatus,
-				contentType: ctString,
-				body: rawBuffer
-			})) return "handled_by_hook";
-		}
+	if (!streamedToClient) {
 		const relayHeaders = {};
 		if (ctString) relayHeaders["Content-Type"] = ctString;
 		res.writeHead(upstreamStatus, relayHeaders);
-		res.end(isBinaryStream ? rawBuffer : upstreamBody);
+		const isAudioRelay = ctString.toLowerCase().startsWith("audio/");
+		res.end(isBinaryStream || isAudioRelay ? rawBuffer : upstreamBody);
 	}
-	return "relayed";
+	return true;
 }
 function makeUpstreamRequest(target, headers, body, clientRes) {
 	return new Promise((resolve, reject) => {
@@ -176,28 +192,34 @@ function makeUpstreamRequest(target, headers, body, clientRes) {
 			const ctStr = Array.isArray(ct) ? ct.join(", ") : ct ?? "";
 			const isSSE = ctStr.toLowerCase().includes("text/event-stream");
 			let streamedToClient = false;
+			let clientDisconnected = false;
 			if (isSSE && clientRes && !clientRes.headersSent) {
 				const relayHeaders = {};
 				if (ctStr) relayHeaders["Content-Type"] = ctStr;
 				clientRes.writeHead(res.statusCode ?? 200, relayHeaders);
 				if (typeof clientRes.flushHeaders === "function") clientRes.flushHeaders();
 				streamedToClient = true;
+				clientRes.on("close", () => {
+					clientDisconnected = true;
+					req.destroy();
+				});
 			}
 			const chunks = [];
 			res.on("data", (chunk) => {
 				chunks.push(chunk);
-				if (streamedToClient) clientRes.write(chunk);
+				if (streamedToClient && clientRes && !clientDisconnected && !clientRes.destroyed && !clientRes.writableEnded) clientRes.write(chunk);
 			});
 			res.on("error", reject);
 			res.on("end", () => {
 				const rawBuffer = Buffer.concat(chunks);
-				if (streamedToClient) clientRes.end();
+				if (streamedToClient && clientRes && !clientDisconnected && !clientRes.destroyed && !clientRes.writableEnded) clientRes.end();
 				resolve({
 					status: res.statusCode ?? 500,
 					headers: res.headers,
 					body: rawBuffer.toString(),
 					rawBuffer,
-					streamedToClient
+					streamedToClient,
+					clientDisconnected
 				});
 			});
 		});
@@ -222,7 +244,7 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 		status
 	};
 	const obj = parsed;
-	if (obj.error) {
+	if (typeof obj.error === "object" && obj.error !== null && typeof obj.error.message === "string") {
 		const err = obj.error;
 		return {
 			error: {
@@ -236,11 +258,12 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 	if (Array.isArray(obj.data) && obj.data.length > 0) {
 		const first = obj.data[0];
 		if (Array.isArray(first.embedding)) return { embedding: first.embedding };
-		if (typeof first.embedding === "string" && encodingFormat === "base64") try {
+		if (typeof first.embedding === "string" && encodingFormat === "base64") {
 			const buf = Buffer.from(first.embedding, "base64");
-			const floats = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+			const aligned = new Uint8Array(buf).buffer;
+			const floats = new Float32Array(aligned, 0, buf.byteLength / 4);
 			return { embedding: Array.from(floats) };
-		} catch {}
+		}
 		if (first.url || first.b64_json) {
 			const images = obj.data.map((item) => ({
 				...item.url ? { url: String(item.url) } : {},
@@ -266,7 +289,7 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 		...Array.isArray(obj.words) ? { words: obj.words } : {},
 		...Array.isArray(obj.segments) ? { segments: obj.segments } : {}
 	} };
-	if (typeof obj.id === "string" && typeof obj.status === "string" && (obj.status === "completed" || obj.status === "in_progress" || obj.status === "failed")) {
+	if (typeof obj.id === "string" && typeof obj.status === "string" && (obj.status === "completed" || obj.status === "in_progress" || obj.status === "failed") && !("choices" in obj) && !("content" in obj) && !("candidates" in obj) && !("message" in obj) && !("data" in obj) && !("object" in obj)) {
 		if (obj.status === "completed" && obj.url) return { video: {
 			id: String(obj.id),
 			status: "completed",
@@ -281,40 +304,109 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 	if (Array.isArray(obj.choices) && obj.choices.length > 0) {
 		const message = obj.choices[0].message;
 		if (message) {
-			if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) return { toolCalls: message.tool_calls.map((tc) => {
-				const fn = tc.function;
+			const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+			const hasContent = typeof message.content === "string" && message.content.length > 0;
+			const openaiReasoning = typeof message.reasoning_content === "string" && message.reasoning_content.length > 0 ? message.reasoning_content : void 0;
+			if (hasToolCalls) {
+				const toolCalls = message.tool_calls.map((tc) => {
+					const fn = tc.function;
+					return {
+						name: String(fn.name),
+						arguments: String(fn.arguments),
+						...tc.id ? { id: String(tc.id) } : {}
+					};
+				});
+				if (hasContent) return {
+					content: message.content,
+					toolCalls,
+					...openaiReasoning ? { reasoning: openaiReasoning } : {}
+				};
 				return {
-					name: String(fn.name),
-					arguments: String(fn.arguments)
+					toolCalls,
+					...openaiReasoning ? { reasoning: openaiReasoning } : {}
 				};
-			}) };
-			if (typeof message.content === "string") return { content: message.content };
+			}
+			if (hasContent) return {
+				content: message.content,
+				...openaiReasoning ? { reasoning: openaiReasoning } : {}
+			};
+			return {
+				content: "",
+				...openaiReasoning ? { reasoning: openaiReasoning } : {}
+			};
 		}
 	}
 	if (Array.isArray(obj.content) && obj.content.length > 0) {
 		const blocks = obj.content;
 		const toolUseBlocks = blocks.filter((b) => b.type === "tool_use");
-		if (toolUseBlocks.length > 0) return { toolCalls: toolUseBlocks.map((b) => ({
-			name: String(b.name),
-			arguments: typeof b.input === "string" ? b.input : JSON.stringify(b.input)
-		})) };
-		const textBlock = blocks.find((b) => b.type === "text");
-		if (textBlock && typeof textBlock.text === "string") return { content: textBlock.text };
+		const textBlocks = blocks.filter((b) => b.type === "text" && typeof b.text === "string");
+		const thinkingBlocks = blocks.filter((b) => b.type === "thinking");
+		const hasToolCalls = toolUseBlocks.length > 0;
+		const joinedText = textBlocks.map((b) => String(b.text ?? "")).join("");
+		const hasContent = joinedText.length > 0;
+		const anthropicReasoning = thinkingBlocks.length > 0 ? thinkingBlocks.map((b) => String(b.thinking ?? "")).join("") : void 0;
+		if (hasToolCalls) {
+			const toolCalls = toolUseBlocks.map((b) => ({
+				name: String(b.name),
+				arguments: typeof b.input === "string" ? b.input : JSON.stringify(b.input),
+				...b.id ? { id: String(b.id) } : {}
+			}));
+			if (hasContent) return {
+				content: joinedText,
+				toolCalls,
+				...anthropicReasoning ? { reasoning: anthropicReasoning } : {}
+			};
+			return {
+				toolCalls,
+				...anthropicReasoning ? { reasoning: anthropicReasoning } : {}
+			};
+		}
+		if (hasContent) return {
+			content: joinedText,
+			...anthropicReasoning ? { reasoning: anthropicReasoning } : {}
+		};
+		if (anthropicReasoning) return {
+			content: "",
+			reasoning: anthropicReasoning
+		};
 	}
 	if (Array.isArray(obj.candidates) && obj.candidates.length > 0) {
 		const content = obj.candidates[0].content;
 		if (content && Array.isArray(content.parts)) {
 			const parts = content.parts;
 			const fnCallParts = parts.filter((p) => p.functionCall);
-			if (fnCallParts.length > 0) return { toolCalls: fnCallParts.map((p) => {
-				const fc = p.functionCall;
+			const textParts = parts.filter((p) => typeof p.text === "string" && !p.thought);
+			const thoughtParts = parts.filter((p) => p.thought === true && typeof p.text === "string");
+			const hasToolCalls = fnCallParts.length > 0;
+			const joinedText = textParts.map((p) => String(p.text ?? "")).join("");
+			const hasContent = joinedText.length > 0;
+			const geminiReasoning = thoughtParts.length > 0 ? thoughtParts.map((p) => String(p.text ?? "")).join("") : void 0;
+			if (hasToolCalls) {
+				const toolCalls = fnCallParts.map((p) => {
+					const fc = p.functionCall;
+					return {
+						name: String(fc.name),
+						arguments: typeof fc.args === "string" ? fc.args : JSON.stringify(fc.args)
+					};
+				});
+				if (hasContent) return {
+					content: joinedText,
+					toolCalls,
+					...geminiReasoning ? { reasoning: geminiReasoning } : {}
+				};
 				return {
-					name: String(fc.name),
-					arguments: typeof fc.args === "string" ? fc.args : JSON.stringify(fc.args)
+					toolCalls,
+					...geminiReasoning ? { reasoning: geminiReasoning } : {}
 				};
-			}) };
-			const textPart = parts.find((p) => typeof p.text === "string");
-			if (textPart && typeof textPart.text === "string") return { content: textPart.text };
+			}
+			if (hasContent) return {
+				content: joinedText,
+				...geminiReasoning ? { reasoning: geminiReasoning } : {}
+			};
+			return {
+				content: "",
+				...geminiReasoning ? { reasoning: geminiReasoning } : {}
+			};
 		}
 	}
 	if (obj.output && typeof obj.output === "object") {
@@ -322,32 +414,105 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 		if (msg && Array.isArray(msg.content)) {
 			const blocks = msg.content;
 			const toolUseBlocks = blocks.filter((b) => b.toolUse);
-			if (toolUseBlocks.length > 0) return { toolCalls: toolUseBlocks.map((b) => {
-				const tu = b.toolUse;
+			const textBlocks = blocks.filter((b) => typeof b.text === "string");
+			const reasoningBlocks = blocks.filter((b) => b.reasoningContent);
+			const hasToolCalls = toolUseBlocks.length > 0;
+			const joinedText = textBlocks.map((b) => String(b.text ?? "")).join("");
+			const hasContent = joinedText.length > 0;
+			const bedrockReasoning = reasoningBlocks.length > 0 ? reasoningBlocks.map((b) => {
+				const rt = b.reasoningContent?.reasoningText;
+				return String(rt?.text ?? "");
+			}).join("") : void 0;
+			if (hasToolCalls) {
+				const toolCalls = toolUseBlocks.map((b) => {
+					const tu = b.toolUse;
+					return {
+						name: String(tu.name ?? ""),
+						arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input),
+						...tu.toolUseId ? { id: String(tu.toolUseId) } : {}
+					};
+				});
+				if (hasContent) return {
+					content: joinedText,
+					toolCalls,
+					...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
+				};
 				return {
-					name: String(tu.name ?? ""),
-					arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input)
+					toolCalls,
+					...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
 				};
-			}) };
-			const textBlock = blocks.find((b) => typeof b.text === "string");
-			if (textBlock && typeof textBlock.text === "string") return { content: textBlock.text };
+			}
+			if (hasContent) return {
+				content: joinedText,
+				...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
+			};
+			return {
+				content: "",
+				...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
+			};
 		}
 	}
+	if (typeof obj.finish_reason === "string" && obj.message && typeof obj.message === "object" && Array.isArray(obj.message.content)) {
+		const msg = obj.message;
+		const contentBlocks = msg.content;
+		const textBlock = contentBlocks.find((b) => b.type === "text" && typeof b.text === "string");
+		const hasContent = textBlock && typeof textBlock.text === "string" && textBlock.text.length > 0;
+		const toolCallBlocks = contentBlocks.filter((b) => b.type === "tool_call");
+		const msgToolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+		if (toolCallBlocks.length > 0) {
+			const toolCalls = toolCallBlocks.map((b) => ({
+				name: String(b.name ?? b.function?.name ?? ""),
+				arguments: typeof b.parameters === "string" ? b.parameters : typeof b.parameters === "object" ? JSON.stringify(b.parameters) : typeof b.function?.arguments === "string" ? String(b.function.arguments) : JSON.stringify(b.function?.arguments),
+				...b.id ? { id: String(b.id) } : {}
+			}));
+			if (hasContent) return {
+				content: textBlock.text,
+				toolCalls
+			};
+			return { toolCalls };
+		}
+		if (msgToolCalls.length > 0) {
+			const toolCalls = msgToolCalls.map((tc) => {
+				const fn = tc.function;
+				return {
+					name: String(tc.name ?? fn?.name ?? ""),
+					arguments: typeof tc.parameters === "string" ? tc.parameters : typeof tc.parameters === "object" ? JSON.stringify(tc.parameters) : typeof fn?.arguments === "string" ? String(fn.arguments) : JSON.stringify(fn?.arguments),
+					...tc.id ? { id: String(tc.id) } : {}
+				};
+			});
+			if (hasContent) return {
+				content: textBlock.text,
+				toolCalls
+			};
+			return { toolCalls };
+		}
+		if (hasContent) return { content: textBlock.text };
+	}
 	if (obj.message && typeof obj.message === "object") {
 		const msg = obj.message;
-		if (Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) return { toolCalls: msg.tool_calls.filter((tc) => tc.function != null).map((tc) => {
-			const fn = tc.function;
-			return {
-				name: String(fn.name ?? ""),
-				arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments)
+		const hasOllamaToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+		const hasOllamaContent = typeof msg.content === "string" && msg.content.length > 0;
+		if (hasOllamaToolCalls) {
+			const toolCalls = msg.tool_calls.filter((tc) => tc.function != null).map((tc) => {
+				const fn = tc.function;
+				return {
+					name: String(fn.name ?? ""),
+					arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments)
+				};
+			});
+			if (hasOllamaContent) return {
+				content: msg.content,
+				toolCalls
 			};
-		}) };
-		if (typeof msg.content === "string" && msg.content.length > 0) return { content: msg.content };
+			return { toolCalls };
+		}
+		if (hasOllamaContent) return { content: msg.content };
 		if (Array.isArray(msg.content) && msg.content.length > 0) {
 			const first = msg.content[0];
 			if (typeof first.text === "string") return { content: first.text };
 		}
 	}
+	if (typeof obj.response === "string" && "done" in obj) return { content: obj.response };
 	return {
 		error: {
 			message: "Could not detect response format from upstream",