@copilotkit/aimock 1.37.3 → 1.38.0

package/dist/recorder.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.cts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UA0IiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA6MU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}
+{"version":3,"file":"recorder.d.cts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAkMiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA6MU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}

package/dist/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UA0IiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA6MU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}
+{"version":3,"file":"recorder.d.ts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAkMiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA6MU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}

package/dist/recorder.js

@@ -1,11 +1,12 @@
 import { DEFAULT_TEST_ID } from "./constants.js";
 import { normalizeModelName } from "./model-utils.js";
+import { isAuthenticatedRequest, isRecognizedApiKeyHeader } from "./api-key-auth.js";
 import { getTestId, slugifyContext, slugifyTestId } from "./helpers.js";
-import { getLastMessageByRole, getTextContent } from "./router.js";
+import { currentTurnHasToolResult, getLastMessageByRole, getTextContent } from "./router.js";
 import { writeErrorResponse } from "./sse-writer.js";
 import { capturedRedactedData, collapseStreamingResponse } from "./stream-collapse.js";
 import { resolveUpstreamUrl } from "./url.js";
-import { applyProviderAuth } from "./provider-auth.js";
+import { applyConfiguredProviderAuth, applyProviderAuth } from "./provider-auth.js";
 import * as http$1 from "node:http";
 import * as crypto$1 from "node:crypto";
 import * as https from "node:https";
@@ -14,6 +15,16 @@ import * as path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
 //#region src/recorder.ts
+/** True when an SSE frame completes an OpenAI stream. */
+function isTerminalSSEFrame(frame) {
+	const data = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+	if (data === "[DONE]") return true;
+	try {
+		return JSON.parse(data).type === "transcript.text.done";
+	} catch {
+		return false;
+	}
+}
 /** Headers to strip when proxying — hop-by-hop (RFC 2616 §13.5.1) + client-set. */
 /**
 * Default ceiling (bytes) for the in-memory proxy-path buffer. Chosen well
@@ -97,11 +108,30 @@ function buildForwardHeaders(req) {
 	const out = {};
 	for (const [name, val] of Object.entries(req.headers)) {
 		const lower = name.toLowerCase();
-		if (val === void 0 || STRIP_HEADERS.has(lower) || lower.startsWith("x-aimock-chaos-")) continue;
+		if (val === void 0 || STRIP_HEADERS.has(lower) || lower.startsWith("x-aimock-chaos-") || isAuthenticatedRequest(req) && isRecognizedApiKeyHeader(lower)) continue;
 		out[name] = Array.isArray(val) ? val.join(", ") : val;
 	}
 	return out;
 }
+/** Remove every casing of a header from an egress map. */
+function removeForwardHeader(headers, name) {
+	const lowerName = name.toLowerCase();
+	for (const key of Object.keys(headers)) if (key.toLowerCase() === lowerName) delete headers[key];
+}
+/**
+* Construct the only safe egress map when inbound access control is enabled.
+* Test credentials are always removed; a static configured provider credential
+* is mandatory so an accepted test credential can never become an upstream one.
+*/
+function prepareEgressHeaders(req, target, providerKey, configuredKey) {
+	const headers = buildForwardHeaders(req);
+	if (!isAuthenticatedRequest(req)) {
+		applyProviderAuth(headers, target, providerKey, configuredKey);
+		return headers;
+	}
+	for (const name of Object.keys(headers)) if (isRecognizedApiKeyHeader(name)) delete headers[name];
+	return configuredKey && applyConfiguredProviderAuth(headers, target, providerKey, configuredKey) ? headers : void 0;
+}
 /**
 * Make an arbitrary string safe to set as an HTTP header value. Node's
 * `res.setHeader` throws ERR_INVALID_CHAR on anything outside Latin-1 (plus
@@ -230,8 +260,14 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		return "relayed";
 	}
 	defaults.logger.warn(`NO FIXTURE MATCH — proxying to ${upstreamUrl}${pathname}`);
-	const forwardHeaders = buildForwardHeaders(req);
-	applyProviderAuth(forwardHeaders, target, providerKey, record.providerKeys?.[lookupKey]);
+	const forwardHeaders = prepareEgressHeaders(req, target, providerKey, record.providerKeys?.[lookupKey]);
+	if (!forwardHeaders) {
+		writeErrorResponse(res, 502, JSON.stringify({ error: {
+			message: "No configured provider credential",
+			type: "proxy_error"
+		} }));
+		return "relayed";
+	}
 	const requestBody = rawBody ?? JSON.stringify(request);
 	let upstreamStatus;
 	let upstreamHeaders;
@@ -318,7 +354,8 @@ 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${collapsed.firstDroppedSample ? ` — first: ${collapsed.firstDroppedSample}` : ""}`);
 		if (collapsed.harmonyUnparsed) defaults.logger.warn(`Harmony tokens present but unparseable — content preserved verbatim${collapsed.harmonyNote ? ` (${collapsed.harmonyNote})` : ""}`);
-		if (collapsed.audioB64) {
+		if (collapsed.transcription) fixtureResponse = { transcription: collapsed.transcription };
+		else if (collapsed.audioB64) {
 			const audioToolCallsSpread = collapsed.toolCalls && collapsed.toolCalls.length > 0 ? { toolCalls: collapsed.toolCalls.map((tc) => ({
 				...tc,
 				name: tc.name ?? "",
@@ -411,7 +448,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 				json: parsedResponse,
 				status: upstreamStatus
 			};
-		} else fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, defaults.logger);
+		} else fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, defaults.logger, request);
 	}
 	if (clientDisconnected) {
 		if (!sawDone) {
@@ -644,7 +681,7 @@ function makeUpstreamRequest(target, headers, body, clientRes, method = "POST",
 						const frame = parts[fi].trim();
 						if (frame.length > 0) {
 							frameTimestamps.push(Date.now());
-							if (frame === "data: [DONE]") sawDone = true;
+							if (isTerminalSSEFrame(frame)) sawDone = true;
 						}
 					}
 					if (!bufferTruncated) frameBuffer = parts[parts.length - 1];
@@ -737,7 +774,7 @@ function toToolCallArguments(raw) {
 * Detect the response format from the parsed upstream JSON and convert
 * it into an aimock FixtureResponse.
 */
-function buildFixtureResponse(parsed, status, logger) {
+function buildFixtureResponse(parsed, status, logger, request) {
 	if (parsed === null || parsed === void 0) return {
 		error: {
 			message: "Upstream returned non-JSON response",
@@ -790,10 +827,13 @@ function buildFixtureResponse(parsed, status, logger) {
 		if (images.length === 1) return { image: images[0] };
 		return { images };
 	}
-	if (typeof obj.text === "string" && (obj.task === "transcribe" || obj.language !== void 0 && obj.duration !== void 0) && !("choices" in obj) && !("candidates" in obj) && !("object" in obj) && !("message" in obj) && !("outputs" in obj)) return { transcription: {
+	const isTranscriptionRequest = request?._endpointType === "transcription" || request?._endpointType === "translation";
+	if (typeof obj.text === "string" && (isTranscriptionRequest || obj.task === "transcribe" || obj.language !== void 0 && obj.duration !== void 0) && !("choices" in obj) && !("candidates" in obj) && !("object" in obj) && !("message" in obj) && !("outputs" in obj)) return { transcription: {
 		text: obj.text,
 		...obj.language ? { language: String(obj.language) } : {},
+		...Array.isArray(obj.languages) ? { languages: obj.languages.filter((language) => typeof language === "object" && language !== null && typeof language.code === "string").map((language) => ({ code: language.code })) } : {},
 		...obj.duration !== void 0 ? { duration: Number(obj.duration) } : {},
+		...obj.usage && typeof obj.usage === "object" ? { usage: obj.usage } : {},
 		...Array.isArray(obj.words) ? { words: obj.words } : {},
 		...Array.isArray(obj.segments) ? { segments: obj.segments } : {}
 	} };
@@ -1101,7 +1141,7 @@ function buildFixtureMatch(request, recordConfig) {
 	const messages = request.messages ?? [];
 	if (messages.length > 0 && (request._endpointType === "chat" || request._endpointType === void 0)) {
 		match.turnIndex = messages.filter((m) => m.role === "assistant").length;
-		match.hasToolResult = messages.some((m) => m.role === "tool");
+		match.hasToolResult = currentTurnHasToolResult(messages);
 	}
 	if (request._context) match.context = request._context;
 	return match;
@@ -1120,5 +1160,5 @@ function buildFixtureMetadata(request) {
 }
 
 //#endregion
-export { buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, proxyAndRecord, sanitizeHeaderValue };
+export { buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, prepareEgressHeaders, proxyAndRecord, removeForwardHeader, sanitizeHeaderValue };
 //# sourceMappingURL=recorder.js.map