@copilotkit/aimock 1.23.1 → 1.24.0

package/dist/fal.cjs

@@ -1,6 +1,7 @@
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_helpers = require('./helpers.cjs');
 const require_router = require('./router.cjs');
+const require_url = require('./url.cjs');
 const require_recorder = require('./recorder.cjs');
 const require_fal_audio = require('./fal-audio.cjs');
 let node_crypto = require("node:crypto");
@@ -50,6 +51,109 @@ var FalQueueStateMap = class {
 	}
 };
 const falQueueStates = new FalQueueStateMap();
+function extractExtension(url, fallback) {
+	const segment = url.split("?")[0].split("#")[0].split("/").pop() ?? "";
+	const fileName = segment.length > 0 ? segment : "";
+	const dotIdx = fileName.lastIndexOf(".");
+	return {
+		fileName,
+		ext: dotIdx >= 0 ? fileName.slice(dotIdx + 1).toLowerCase() : fallback
+	};
+}
+function imageItemToFalImage(item, index) {
+	const url = item.url ?? `https://mock.fal.media/files/generated_image_${index}.png`;
+	const { ext } = extractExtension(url, "png");
+	return {
+		url,
+		width: 1024,
+		height: 1024,
+		content_type: ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext}`
+	};
+}
+/**
+* Translate an `ImageResponse` fixture into fal's image envelope shape:
+* `{ images: [...], timings, seed, has_nsfw_concepts, prompt }`.
+* Used by `LLMock.onFalImage` to keep callers from re-deriving the wire shape.
+*/
+function imageResponseToFalJson(response) {
+	const images = (response.images ?? (response.image ? [response.image] : [])).map((item, i) => imageItemToFalImage(item, i));
+	return {
+		images,
+		timings: { inference: 0 },
+		seed: 0,
+		has_nsfw_concepts: images.map(() => false),
+		prompt: ""
+	};
+}
+/**
+* Translate a `VideoResponse` fixture into fal's video envelope shape:
+* `{ video: { url, content_type, file_name, file_size }, seed }`.
+*/
+function videoResponseToFalJson(response) {
+	const url = response.video.url ?? "https://mock.fal.media/files/generated_video.mp4";
+	const { fileName, ext } = extractExtension(url, "mp4");
+	return {
+		video: {
+			url,
+			content_type: `video/${ext}`,
+			file_name: fileName || "generated_video.mp4",
+			file_size: 0
+		},
+		seed: 0
+	};
+}
+function resolveProgression(config) {
+	const pollsBeforeInProgress = config?.pollsBeforeInProgress ?? 0;
+	const explicitCompleted = config?.pollsBeforeCompleted;
+	let pollsBeforeCompleted;
+	if (explicitCompleted != null) pollsBeforeCompleted = Math.max(pollsBeforeInProgress, explicitCompleted);
+	else if (config?.pollsBeforeInProgress != null) pollsBeforeCompleted = pollsBeforeInProgress + 1;
+	else pollsBeforeCompleted = 0;
+	return {
+		pollsBeforeInProgress,
+		pollsBeforeCompleted
+	};
+}
+/**
+* Mutates a job in place to advance its state on a status/result poll.
+* IN_QUEUE → IN_PROGRESS → COMPLETED based on poll-count thresholds. No-op
+* once COMPLETED or CANCELLED.
+*/
+function advanceJob(job) {
+	if (job.status === "COMPLETED" || job.status === "CANCELLED") return;
+	job.pollCount += 1;
+	if (job.status === "IN_QUEUE" && job.pollCount >= job.pollsBeforeInProgress) {
+		job.status = "IN_PROGRESS";
+		job.logs.push({
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level: "INFO",
+			message: "Job started processing."
+		});
+	} else if (job.pollCount >= job.pollsBeforeCompleted) {
+		job.status = "COMPLETED";
+		job.completedAt = Date.now();
+		job.logs.push({
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level: "INFO",
+			message: "Job completed."
+		});
+	}
+}
+function queuePosition(job) {
+	if (job.status !== "IN_QUEUE") return 0;
+	return Math.max(0, job.pollsBeforeInProgress - job.pollCount);
+}
+function statusResponseBody(job) {
+	const body = {
+		status: job.status,
+		request_id: job.requestId,
+		response_url: `https://${FAL_HOSTS.queue}/${job.modelId}/requests/${job.requestId}`,
+		logs: job.logs
+	};
+	if (job.status === "IN_QUEUE" || job.status === "IN_PROGRESS") body.queue_position = queuePosition(job);
+	if (job.status === "COMPLETED" && job.completedAt != null) body.metrics = { inference_time: (job.completedAt - job.submittedAt) / 1e3 };
+	return body;
+}
 const FAL_HOSTS = {
 	queue: "queue.fal.run",
 	sync: "fal.run",
@@ -166,11 +270,8 @@ async function handleFal(req, res, body, pathname, fixtures, defaults, journal)
 				respondNotFound(req, res, pathname, journal, route.requestId);
 				return "handled";
 			}
-			writeJson(req, res, 200, {
-				status: job.status,
-				request_id: job.requestId,
-				response_url: `https://${FAL_HOSTS.queue}/${job.modelId}/requests/${job.requestId}`
-			}, pathname, journal);
+			advanceJob(job);
+			writeJson(req, res, 200, statusResponseBody(job), pathname, journal);
 			return "handled";
 		}
 		case "queue-result": {
@@ -179,11 +280,17 @@ async function handleFal(req, res, body, pathname, fixtures, defaults, journal)
 				respondNotFound(req, res, pathname, journal, route.requestId);
 				return "handled";
 			}
+			advanceJob(job);
+			if (job.status !== "COMPLETED") {
+				writeJson(req, res, 202, statusResponseBody(job), pathname, journal);
+				return "handled";
+			}
 			writeJson(req, res, 200, job.result, pathname, journal);
 			return "handled";
 		}
-		case "queue-cancel":
-			if (!falQueueStates.get(stateKey(route.requestId))) {
+		case "queue-cancel": {
+			const job = falQueueStates.get(stateKey(route.requestId));
+			if (!job) {
 				journal.add({
 					method: req.method ?? "PUT",
 					path: pathname,
@@ -198,19 +305,56 @@ async function handleFal(req, res, body, pathname, fixtures, defaults, journal)
 				res.end(JSON.stringify({ status: "NOT_FOUND" }));
 				return "handled";
 			}
+			if (job.status === "COMPLETED") {
+				journal.add({
+					method: req.method ?? "PUT",
+					path: pathname,
+					headers: require_helpers.flattenHeaders(req.headers),
+					body: null,
+					response: {
+						status: 400,
+						fixture: null
+					}
+				});
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ status: "ALREADY_COMPLETED" }));
+				return "handled";
+			}
+			if (job.status === "CANCELLED") {
+				journal.add({
+					method: req.method ?? "PUT",
+					path: pathname,
+					headers: require_helpers.flattenHeaders(req.headers),
+					body: null,
+					response: {
+						status: 200,
+						fixture: null
+					}
+				});
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ status: "CANCELLED" }));
+				return "handled";
+			}
+			job.status = "CANCELLED";
+			job.logs.push({
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				level: "INFO",
+				message: "Job cancelled."
+			});
 			journal.add({
 				method: req.method ?? "PUT",
 				path: pathname,
 				headers: require_helpers.flattenHeaders(req.headers),
 				body: null,
 				response: {
-					status: 400,
+					status: 200,
 					fixture: null
 				}
 			});
-			res.writeHead(400, { "Content-Type": "application/json" });
-			res.end(JSON.stringify({ status: "ALREADY_COMPLETED" }));
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ status: "CANCELLED" }));
 			return "handled";
+		}
 		case "storage": {
 			let filename = "upload.bin";
 			try {
@@ -228,7 +372,29 @@ async function handleFal(req, res, body, pathname, fixtures, defaults, journal)
 		case "queue-submit":
 		case "sync-run": {
 			const modelId = route.modelId;
-			const parsedBody = parseBody(body);
+			let parsedBody;
+			try {
+				parsedBody = parseBody(body);
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : "Invalid JSON body";
+				journal.add({
+					method: req.method ?? "POST",
+					path: pathname,
+					headers: require_helpers.flattenHeaders(req.headers),
+					body: null,
+					response: {
+						status: 400,
+						fixture: null
+					}
+				});
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: {
+					message: detail,
+					type: "invalid_request_error",
+					code: "invalid_json"
+				} }));
+				return "handled";
+			}
 			const syntheticReq = {
 				model: modelId,
 				messages: [{
@@ -261,21 +427,37 @@ async function handleFal(req, res, body, pathname, fixtures, defaults, journal)
 				}
 				if (defaults.record) {
 					const effectiveDefaults = withFalUpstream(defaults, route.targetHost);
-					const outcome = await require_recorder.proxyAndRecord(req, res, syntheticReq, "fal", stripFalPrefix(pathname), fixtures, effectiveDefaults, body);
-					if (outcome === "handled_by_hook") return "handled";
-					if (outcome !== "not_configured") {
-						journal.add({
-							method: req.method ?? "POST",
-							path: pathname,
-							headers: require_helpers.flattenHeaders(req.headers),
-							body: syntheticReq,
-							response: {
-								status: res.statusCode ?? 200,
-								fixture: null,
-								source: "proxy"
-							}
-						});
-						return "handled";
+					if (route.kind === "queue-submit") {
+						if (await proxyAndRecordFalQueueSubmit({
+							req,
+							res,
+							syntheticReq,
+							modelId,
+							pathname,
+							strippedPath: stripFalPrefix(pathname),
+							body,
+							fixtures,
+							defaults: effectiveDefaults,
+							stateKey,
+							journal
+						}) === "handled") return "handled";
+					} else {
+						const outcome = await require_recorder.proxyAndRecord(req, res, syntheticReq, "fal", stripFalPrefix(pathname), fixtures, effectiveDefaults, body);
+						if (outcome === "handled_by_hook") return "handled";
+						if (outcome !== "not_configured") {
+							journal.add({
+								method: req.method ?? "POST",
+								path: pathname,
+								headers: require_helpers.flattenHeaders(req.headers),
+								body: syntheticReq,
+								response: {
+									status: res.statusCode ?? 200,
+									fixture: null,
+									source: "proxy"
+								}
+							});
+							return "handled";
+						}
 					}
 				}
 				journal.add({
@@ -352,19 +534,33 @@ async function handleFal(req, res, body, pathname, fixtures, defaults, journal)
 				return "handled";
 			}
 			const requestId = node_crypto.default.randomUUID();
-			falQueueStates.set(stateKey(requestId), {
+			const progression = resolveProgression(defaults.falQueue);
+			const now = Date.now();
+			const initialStatus = progression.pollsBeforeCompleted === 0 ? "COMPLETED" : "IN_QUEUE";
+			const job = {
 				requestId,
 				modelId,
-				status: "COMPLETED",
+				status: initialStatus,
 				result: payload,
-				createdAt: Date.now()
-			});
+				pollCount: 0,
+				pollsBeforeInProgress: progression.pollsBeforeInProgress,
+				pollsBeforeCompleted: progression.pollsBeforeCompleted,
+				submittedAt: now,
+				completedAt: initialStatus === "COMPLETED" ? now : null,
+				logs: [{
+					timestamp: new Date(now).toISOString(),
+					level: "INFO",
+					message: "Job enqueued."
+				}],
+				createdAt: now
+			};
+			falQueueStates.set(stateKey(requestId), job);
 			const envelope = {
 				request_id: requestId,
 				response_url: `https://${FAL_HOSTS.queue}/${modelId}/requests/${requestId}`,
 				status_url: `https://${FAL_HOSTS.queue}/${modelId}/requests/${requestId}/status`,
 				cancel_url: `https://${FAL_HOSTS.queue}/${modelId}/requests/${requestId}/cancel`,
-				queue_position: 0
+				queue_position: queuePosition(job)
 			};
 			journal.add({
 				method: req.method ?? "POST",
@@ -386,8 +582,188 @@ function parseBody(raw) {
 	if (!raw.trim()) return null;
 	try {
 		return JSON.parse(raw);
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : "unknown";
+		throw new Error(`Malformed JSON: ${detail}`);
+	}
+}
+const DEFAULT_FAL_POLL_INTERVAL_MS = 1e3;
+const DEFAULT_FAL_TIMEOUT_MS = 9e5;
+const FAL_STRIP_FORWARD_HEADERS = new Set([
+	"connection",
+	"keep-alive",
+	"transfer-encoding",
+	"te",
+	"trailer",
+	"upgrade",
+	"proxy-authorization",
+	"proxy-authenticate",
+	"host",
+	"content-length",
+	"cookie",
+	"accept-encoding"
+]);
+function buildFalForwardHeaders(req) {
+	const out = {};
+	for (const [name, val] of Object.entries(req.headers)) {
+		if (val === void 0) continue;
+		if (FAL_STRIP_FORWARD_HEADERS.has(name.toLowerCase())) continue;
+		out[name] = Array.isArray(val) ? val.join(", ") : val;
+	}
+	return out;
+}
+/**
+* Walk a fal-shaped queue protocol upstream: POST submit, poll status until
+* COMPLETED, GET final result body. Returns the parsed final body so the caller
+* can persist it as the fixture and seed local queue state.
+*
+* Decoupled from the route layer so the legacy `/fal/queue/submit/{model}`
+* audio path (`fal-audio.ts`) can reuse the same logic.
+*/
+async function walkFalQueue(args) {
+	const { upstreamBase, submitPath, body, headers, pollIntervalMs = DEFAULT_FAL_POLL_INTERVAL_MS, timeoutMs = DEFAULT_FAL_TIMEOUT_MS, fallbackStatusPath, fallbackResultPath } = args;
+	const deadline = Date.now() + timeoutMs;
+	const submitUrl = require_url.resolveUpstreamUrl(upstreamBase, submitPath);
+	const submitRes = await fetch(submitUrl, {
+		method: "POST",
+		headers,
+		body
+	});
+	const submitText = await submitRes.text();
+	if (!submitRes.ok) throw new Error(`Submit ${submitRes.status}: ${submitText.slice(0, 200)}`);
+	const env = parseJsonOrThrow(submitText, "Submit");
+	const upstreamRequestId = String(env.request_id ?? "").trim();
+	if (!upstreamRequestId) throw new Error("Submit response missing request_id");
+	const envStatusUrl = env.status_url;
+	const envResponseUrl = env.response_url;
+	const statusUrl = typeof envStatusUrl === "string" && envStatusUrl ? new URL(envStatusUrl) : require_url.resolveUpstreamUrl(upstreamBase, fallbackStatusPath(upstreamRequestId));
+	const resultUrl = typeof envResponseUrl === "string" && envResponseUrl ? new URL(envResponseUrl) : require_url.resolveUpstreamUrl(upstreamBase, fallbackResultPath(upstreamRequestId));
+	while (true) {
+		if (Date.now() > deadline) throw new Error(`Queue walk timed out after ${timeoutMs}ms`);
+		const statusRes = await fetch(statusUrl, { headers });
+		const statusText = await statusRes.text();
+		if (!statusRes.ok) throw new Error(`Status ${statusRes.status}: ${statusText.slice(0, 200)}`);
+		const statusJson = parseJsonOrThrow(statusText, "Status");
+		const s = String(statusJson.status ?? "");
+		if (s === "COMPLETED") break;
+		if (s === "FAILED" || s === "ERROR" || s === "CANCELLED") throw new Error(`Upstream job terminated with status ${s}`);
+		const remaining = deadline - Date.now();
+		const sleep = Math.min(pollIntervalMs, Math.max(0, remaining));
+		if (sleep <= 0) throw new Error(`Queue walk timed out after ${timeoutMs}ms`);
+		await new Promise((r) => setTimeout(r, sleep));
+	}
+	const resultRes = await fetch(resultUrl, { headers });
+	const resultText = await resultRes.text();
+	if (!resultRes.ok) throw new Error(`Result ${resultRes.status}: ${resultText.slice(0, 200)}`);
+	return parseJsonOrThrow(resultText, "Result");
+}
+async function proxyAndRecordFalQueueSubmit(args) {
+	const { req, res, syntheticReq, modelId, pathname, strippedPath, body, fixtures, defaults, stateKey, journal } = args;
+	const record = defaults.record;
+	if (!record) return "no_upstream";
+	const upstreamBase = record.providers.fal;
+	if (!upstreamBase) {
+		defaults.logger.warn(`No upstream URL configured for provider "fal" — cannot proxy`);
+		return "no_upstream";
+	}
+	defaults.logger.warn(`NO FIXTURE MATCH — walking fal queue at ${upstreamBase}${strippedPath}`);
+	let finalBody;
+	try {
+		finalBody = await walkFalQueue({
+			upstreamBase,
+			submitPath: strippedPath,
+			body,
+			headers: buildFalForwardHeaders(req),
+			pollIntervalMs: record.fal?.pollIntervalMs,
+			timeoutMs: record.fal?.timeoutMs,
+			fallbackStatusPath: (id) => `${modelId}/requests/${id}/status`,
+			fallbackResultPath: (id) => `${modelId}/requests/${id}`
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : "Unknown queue-walk error";
+		defaults.logger.error(`fal queue-walk proxy failed: ${msg}`);
+		journal.add({
+			method: req.method ?? "POST",
+			path: pathname,
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status: 502,
+				fixture: null,
+				source: "proxy"
+			}
+		});
+		res.writeHead(502, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: {
+			message: `Proxy to upstream failed: ${msg}`,
+			type: "proxy_error"
+		} }));
+		return "handled";
+	}
+	const fixture = {
+		match: require_recorder.buildFixtureMatch(defaults.requestTransform ? defaults.requestTransform(syntheticReq) : syntheticReq, record),
+		response: {
+			json: finalBody,
+			status: 200
+		}
+	};
+	require_recorder.persistFixture({
+		record,
+		providerKey: "fal",
+		testId: require_helpers.getTestId(req),
+		fixture,
+		fixtures,
+		logger: defaults.logger
+	});
+	const newRequestId = node_crypto.default.randomUUID();
+	const progression = resolveProgression(defaults.falQueue);
+	const now = Date.now();
+	const initialStatus = progression.pollsBeforeCompleted === 0 ? "COMPLETED" : "IN_QUEUE";
+	const job = {
+		requestId: newRequestId,
+		modelId,
+		status: initialStatus,
+		result: finalBody,
+		pollCount: 0,
+		pollsBeforeInProgress: progression.pollsBeforeInProgress,
+		pollsBeforeCompleted: progression.pollsBeforeCompleted,
+		submittedAt: now,
+		completedAt: initialStatus === "COMPLETED" ? now : null,
+		logs: [{
+			timestamp: new Date(now).toISOString(),
+			level: "INFO",
+			message: "Job enqueued."
+		}],
+		createdAt: now
+	};
+	falQueueStates.set(stateKey(newRequestId), job);
+	const envelope = {
+		request_id: newRequestId,
+		response_url: `https://${FAL_HOSTS.queue}/${modelId}/requests/${newRequestId}`,
+		status_url: `https://${FAL_HOSTS.queue}/${modelId}/requests/${newRequestId}/status`,
+		cancel_url: `https://${FAL_HOSTS.queue}/${modelId}/requests/${newRequestId}/cancel`,
+		queue_position: queuePosition(job)
+	};
+	journal.add({
+		method: req.method ?? "POST",
+		path: pathname,
+		headers: require_helpers.flattenHeaders(req.headers),
+		body: syntheticReq,
+		response: {
+			status: 200,
+			fixture: null,
+			source: "proxy"
+		}
+	});
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(envelope));
+	return "handled";
+}
+function parseJsonOrThrow(text, label) {
+	try {
+		return JSON.parse(text);
 	} catch {
-		return null;
+		throw new Error(`${label} returned non-JSON: ${text.slice(0, 200)}`);
 	}
 }
 function withFalUpstream(defaults, targetHost) {
@@ -438,6 +814,10 @@ function respondNotFound(req, res, pathname, journal, requestId) {
 
 //#endregion
 exports.FalQueueStateMap = FalQueueStateMap;
+exports.buildFalForwardHeaders = buildFalForwardHeaders;
 exports.falQueueStates = falQueueStates;
 exports.handleFal = handleFal;
+exports.imageResponseToFalJson = imageResponseToFalJson;
+exports.videoResponseToFalJson = videoResponseToFalJson;
+exports.walkFalQueue = walkFalQueue;
 //# sourceMappingURL=fal.cjs.map