@fevex/core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/http/index.mjs

@@ -0,0 +1,692 @@
+import { o as ArtifactError } from "../artifacts-gUzemET7.mjs";
+import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+import { t as MAX_DEADLINE_MS } from "../run-support-CmZ6Xo6H.mjs";
+//#region src/http/protocol.ts
+const FEVEX_HTTP_PROTOCOL_VERSION = "3";
+const FEVEX_HTTP_PROTOCOL_VERSION_HEADER = "Fevex-Protocol-Version";
+//#endregion
+//#region src/http/transport.ts
+const JSON_TYPE = "application/json";
+const PROBLEM_TYPE = "application/problem+json";
+const SSE_TYPE = "text/event-stream";
+const FEVEX_RUN_ERROR_CODES = /* @__PURE__ */ new Set([
+	"INVALID_CURSOR",
+	"AGENT_NOT_FOUND",
+	"WORKFLOW_NOT_FOUND",
+	"TEAM_NOT_FOUND",
+	"MODEL_NOT_FOUND",
+	"SESSION_NOT_FOUND",
+	"DURABLE_STORE_REQUIRED",
+	"RUN_CONFLICT",
+	"RUN_NOT_RESUMABLE",
+	"RUN_NOT_RECOVERABLE",
+	"CHECKPOINT_UNSUPPORTED",
+	"RUN_DEFINITION_CHANGED",
+	"POLICY_DENIED",
+	"ADMISSION_DENIED",
+	"RUNTIME_CLOSED",
+	"CREDENTIAL_NOT_FOUND",
+	"SANDBOX_REQUIRED",
+	"ELICITATION_INVALID",
+	"APPROVAL_INVALID",
+	"RUN_PAUSED",
+	"TOOL_EXECUTION_UNKNOWN"
+]);
+/** Exposes a Fevex instance through the versioned HTTP protocol. */
+function createFevexHttpHandler(options) {
+	const pollIntervalMs = options.pollIntervalMs ?? 100;
+	const eventPageSize = options.eventPageSize ?? 100;
+	const maxConnections = options.maxConnections;
+	if (!Number.isSafeInteger(eventPageSize) || eventPageSize < 1 || eventPageSize > 1e3) throw new TypeError("eventPageSize must be an integer between 1 and 1000");
+	if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) throw new TypeError("pollIntervalMs must be a positive number");
+	if (maxConnections !== void 0 && (!Number.isSafeInteger(maxConnections) || maxConnections < 1)) throw new TypeError("maxConnections must be a positive safe integer");
+	let activeConnections = 0;
+	const authorize = async (access) => {
+		if (options.authorize && !await options.authorize(access)) throw new HttpProtocolError(403, "FORBIDDEN", "Forbidden");
+	};
+	const authorizeArtifact = async (access) => {
+		if (options.authorizeArtifact && !await options.authorizeArtifact(access)) throw new HttpProtocolError(403, "FORBIDDEN", "Forbidden");
+	};
+	return async (request, handlerContext = {}) => {
+		const url = new URL(request.url);
+		const path = url.pathname;
+		const commitStart = async (run) => {
+			try {
+				await options.onRunStarted?.(run, handlerContext.context);
+			} catch (error) {
+				await options.fevex.cancelRun(run.id).catch(() => {});
+				throw error;
+			}
+		};
+		try {
+			const start = path.match(/^\/v1\/agents\/([^/]+)\/runs$/);
+			if (start && request.method === "POST") {
+				const body = await readJson(request);
+				if (!hasOwn(body, "input")) throw badRequest("input is required");
+				const name = decodeURIComponent(start[1]);
+				const sessionId = optionalId(body.sessionId, "sessionId");
+				const model = optionalId(body.model, "model");
+				const reasoning = optionalReasoning(body.reasoning);
+				const deadlineMs = optionalDeadline(body.deadlineMs, "deadlineMs");
+				await authorize({
+					action: "start",
+					kind: "agent",
+					name,
+					sessionId,
+					context: handlerContext.context
+				});
+				const run = await options.fevex.startAgent(name, {
+					input: body.input,
+					...model ? { model } : {},
+					...reasoning === void 0 ? {} : { reasoning },
+					...deadlineMs === void 0 ? {} : { deadlineMs },
+					...sessionId ? { sessionId } : {},
+					...handlerContext.context ? { context: handlerContext.context } : {}
+				});
+				await commitStart(run);
+				return json(run, 202);
+			}
+			const startWorkflow = path.match(/^\/v1\/workflows\/([^/]+)\/runs$/);
+			if (startWorkflow && request.method === "POST") {
+				const body = await readJson(request);
+				if (!hasOwn(body, "input")) throw badRequest("input is required");
+				const name = decodeURIComponent(startWorkflow[1]);
+				const sessionId = optionalId(body.sessionId, "sessionId");
+				const model = optionalId(body.model, "model");
+				const reasoning = optionalReasoning(body.reasoning);
+				const deadlineMs = optionalDeadline(body.deadlineMs, "deadlineMs");
+				await authorize({
+					action: "start",
+					kind: "workflow",
+					name,
+					sessionId,
+					context: handlerContext.context
+				});
+				const run = await options.fevex.startWorkflow(name, {
+					input: body.input,
+					...model ? { model } : {},
+					...reasoning === void 0 ? {} : { reasoning },
+					...deadlineMs === void 0 ? {} : { deadlineMs },
+					...sessionId ? { sessionId } : {},
+					...handlerContext.context ? { context: handlerContext.context } : {}
+				});
+				await commitStart(run);
+				return json(run, 202);
+			}
+			const startTeam = path.match(/^\/v1\/teams\/([^/]+)\/runs$/);
+			if (startTeam && request.method === "POST") {
+				const body = await readJson(request);
+				if (!hasOwn(body, "input")) throw badRequest("Run input is required");
+				const name = decodeURIComponent(startTeam[1]);
+				const sessionId = optionalId(body.sessionId, "sessionId");
+				const model = optionalId(body.model, "model");
+				const reasoning = optionalReasoning(body.reasoning);
+				const deadlineMs = optionalDeadline(body.deadlineMs, "deadlineMs");
+				await authorize({
+					action: "start",
+					kind: "team",
+					name,
+					sessionId,
+					context: handlerContext.context
+				});
+				const run = await options.fevex.startTeam(name, {
+					input: body.input,
+					...model ? { model } : {},
+					...reasoning === void 0 ? {} : { reasoning },
+					...deadlineMs === void 0 ? {} : { deadlineMs },
+					...sessionId ? { sessionId } : {},
+					...handlerContext.context ? { context: handlerContext.context } : {}
+				});
+				await commitStart(run);
+				return json(run, 202);
+			}
+			const events = path.match(/^\/v1\/runs\/([^/]+)\/events$/);
+			if (events && request.method === "GET") {
+				const runId = decodeURIComponent(events[1]);
+				await authorize({
+					action: "observe",
+					runId,
+					context: handlerContext.context
+				});
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
+				const after = request.headers.get("last-event-id")?.trim() || void 0;
+				const initial = await options.fevex.listEvents(runId, {
+					after,
+					limit: eventPageSize
+				});
+				if (maxConnections !== void 0 && activeConnections >= maxConnections) throw new HttpProtocolError(429, "CONNECTION_LIMIT", "Too many event streams");
+				activeConnections += 1;
+				let released = false;
+				const release = () => {
+					if (released) return;
+					released = true;
+					activeConnections -= 1;
+				};
+				const disconnected = new AbortController();
+				const iterator = observeEvents(options.fevex, runId, initial, after, pollIntervalMs, AbortSignal.any([request.signal, disconnected.signal]), eventPageSize);
+				return versioned(new Response(iteratorStream(iterator, () => disconnected.abort(), release), { headers: {
+					"content-type": `${SSE_TYPE}; charset=utf-8`,
+					"cache-control": "no-cache, no-transform"
+				} }));
+			}
+			const resume = path.match(/^\/v1\/runs\/([^/]+)\/resume$/);
+			if (resume && request.method === "POST") {
+				const runId = decodeURIComponent(resume[1]);
+				const actor = handlerContext.context?.actor;
+				if (!actor?.id?.trim()) throw new HttpProtocolError(401, "ACTOR_REQUIRED", "Authenticated actor is required");
+				await authorize({
+					action: "resume",
+					runId,
+					context: handlerContext.context
+				});
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
+				const resolution = readResolution(await readJson(request), actor);
+				return json(await options.fevex.resumeRun(runId, resolution), 202);
+			}
+			const recover = path.match(/^\/v1\/runs\/([^/]+)\/recover$/);
+			if (recover && request.method === "POST") {
+				const runId = decodeURIComponent(recover[1]);
+				const actor = handlerContext.context?.actor;
+				if (!actor?.id?.trim()) throw new HttpProtocolError(401, "ACTOR_REQUIRED", "Authenticated actor is required");
+				await authorize({
+					action: "recover",
+					runId,
+					context: handlerContext.context
+				});
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
+				return json(await options.fevex.recoverRun(runId, { actor }), 202);
+			}
+			const runArtifacts = path.match(/^\/v1\/runs\/([^/]+)\/artifacts$/);
+			if (runArtifacts && request.method === "GET") {
+				const runId = decodeURIComponent(runArtifacts[1]);
+				await authorizeArtifact({
+					action: "read",
+					kind: "artifacts",
+					runId,
+					context: handlerContext.context
+				});
+				if (!options.artifactCatalog) throw new HttpProtocolError(501, "ARTIFACT_CATALOG_NOT_CONFIGURED", "Artifact catalog is not configured");
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
+				const limit = optionalLimit(url.searchParams.get("limit"));
+				return json((await options.artifactCatalog.list({
+					runId,
+					...limit === void 0 ? {} : { limit }
+				}, artifactContext(handlerContext, request))).map(({ descriptor }) => descriptor));
+			}
+			const artifactRoute = path.match(/^\/v1\/artifacts\/([^/]+)$/);
+			if (artifactRoute && (request.method === "GET" || request.method === "HEAD")) {
+				const artifactId = decodeURIComponent(artifactRoute[1]);
+				await authorizeArtifact({
+					action: "read",
+					kind: "artifact",
+					artifactId,
+					context: handlerContext.context
+				});
+				if (!options.artifacts) throw new HttpProtocolError(501, "ARTIFACTS_NOT_CONFIGURED", "Artifact store is not configured");
+				const context = artifactContext(handlerContext, request);
+				if (request.method === "HEAD" && options.artifacts.head) {
+					const descriptor = await options.artifacts.head(artifactId, context);
+					if (!descriptor) throw notFound("ARTIFACT_NOT_FOUND", "Artifact not found");
+					return artifactResponse(descriptor, null);
+				}
+				const content = await options.artifacts.get(artifactId, context);
+				if (!content) throw notFound("ARTIFACT_NOT_FOUND", "Artifact not found");
+				return artifactResponse(content.descriptor, request.method === "HEAD" ? null : content.bytes);
+			}
+			if (artifactRoute && request.method === "DELETE") {
+				const artifactId = decodeURIComponent(artifactRoute[1]);
+				await authorizeArtifact({
+					action: "delete",
+					kind: "artifact",
+					artifactId,
+					context: handlerContext.context
+				});
+				if (!options.artifacts) throw new HttpProtocolError(501, "ARTIFACTS_NOT_CONFIGURED", "Artifact store is not configured");
+				if (!options.artifacts.delete) throw new HttpProtocolError(501, "ARTIFACT_DELETE_UNSUPPORTED", "Artifact store does not support deletion");
+				if (!await options.artifacts.delete(artifactId, artifactContext(handlerContext, request))) throw notFound("ARTIFACT_NOT_FOUND", "Artifact not found");
+				return versioned(new Response(null, { status: 204 }));
+			}
+			const run = path.match(/^\/v1\/runs\/([^/]+)$/);
+			if (run && request.method === "GET") {
+				const runId = decodeURIComponent(run[1]);
+				await authorize({
+					action: "read",
+					runId,
+					context: handlerContext.context
+				});
+				const value = await options.fevex.getRun(runId);
+				if (!value) throw notFound("RUN_NOT_FOUND", "Run not found");
+				return json(value);
+			}
+			if (run && request.method === "DELETE") {
+				const runId = decodeURIComponent(run[1]);
+				await authorize({
+					action: "cancel",
+					runId,
+					context: handlerContext.context
+				});
+				const value = await options.fevex.getRun(runId);
+				if (!value) throw notFound("RUN_NOT_FOUND", "Run not found");
+				if (value.status === "running" || value.status === "paused") {
+					if (!await options.fevex.cancelRun(runId) && (await options.fevex.getRun(runId))?.status === value.status) throw new HttpProtocolError(409, "RUN_CONFLICT", "Run could not be cancelled");
+				}
+				return versioned(new Response(null, { status: 204 }));
+			}
+			if (start || startWorkflow || startTeam || events || resume || recover || runArtifacts || artifactRoute || run) throw new HttpProtocolError(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+			throw notFound("ROUTE_NOT_FOUND", "Route not found");
+		} catch (error) {
+			return problem(error, url.pathname, options.onError);
+		}
+	};
+}
+var FevexHttpError = class extends Error {
+	problem;
+	name = "FevexHttpError";
+	constructor(problem) {
+		super(problem.detail ?? problem.title);
+		this.problem = problem;
+	}
+	get status() {
+		return this.problem.status;
+	}
+	get code() {
+		return this.problem.code;
+	}
+};
+function createFevexHttpClient(options) {
+	const baseUrl = options.baseUrl.replace(/\/$/, "");
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const request = async (path, init) => {
+		const response = await fetcher(`${baseUrl}${path}`, init);
+		await assertResponse(response, JSON_TYPE);
+		return response.json();
+	};
+	return {
+		startRun(agentName, body) {
+			return request(`/v1/agents/${encodeURIComponent(agentName)}/runs`, jsonInit("POST", body));
+		},
+		startWorkflow(workflowName, body) {
+			return request(`/v1/workflows/${encodeURIComponent(workflowName)}/runs`, jsonInit("POST", body));
+		},
+		startTeam(teamName, body) {
+			return request(`/v1/teams/${encodeURIComponent(teamName)}/runs`, jsonInit("POST", body));
+		},
+		getRun(runId) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}`);
+		},
+		observeRun(runId, observeOptions = {}) {
+			return { async *[Symbol.asyncIterator]() {
+				const response = await fetcher(`${baseUrl}/v1/runs/${encodeURIComponent(runId)}/events`, {
+					headers: observeOptions.after ? { "last-event-id": observeOptions.after } : void 0,
+					signal: observeOptions.signal
+				});
+				await assertResponse(response, SSE_TYPE);
+				if (!response.body) throw new TypeError("Fevex event response has no body");
+				yield* parseEventStream(response.body);
+			} };
+		},
+		resumeRun(runId, body) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}/resume`, jsonInit("POST", body));
+		},
+		recoverRun(runId) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}/recover`, { method: "POST" });
+		},
+		async cancelRun(runId) {
+			await assertResponse(await fetcher(`${baseUrl}/v1/runs/${encodeURIComponent(runId)}`, { method: "DELETE" }));
+		},
+		async getArtifact(artifactId) {
+			const response = await fetcher(`${baseUrl}/v1/artifacts/${encodeURIComponent(artifactId)}`);
+			await assertResponse(response);
+			return response;
+		},
+		listArtifacts(runId) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}/artifacts`);
+		},
+		async deleteArtifact(artifactId) {
+			await assertResponse(await fetcher(`${baseUrl}/v1/artifacts/${encodeURIComponent(artifactId)}`, { method: "DELETE" }));
+		}
+	};
+}
+async function* observeEvents(fevex, runId, initial, after, pollIntervalMs, signal, pageSize) {
+	const encoder = new TextEncoder();
+	let pending = initial;
+	let cursor = after;
+	let closedEmptyReads = 0;
+	while (!signal.aborted) {
+		for (const event of pending) {
+			if (signal.aborted) return;
+			cursor = event.id;
+			yield encoder.encode(formatEvent(event));
+		}
+		const run = await fevex.getRun(runId);
+		if (!run) return;
+		if (run.status !== "running" && pending.length === 0) {
+			closedEmptyReads += 1;
+			if (closedEmptyReads >= 2) return;
+		} else closedEmptyReads = 0;
+		if (pending.length < pageSize) await wait(pollIntervalMs, signal);
+		if (signal.aborted) return;
+		pending = await fevex.listEvents(runId, {
+			after: cursor,
+			limit: pageSize
+		});
+	}
+}
+function iteratorStream(iterator, cancel, done) {
+	let finished = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		done?.();
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const next = await iterator.next();
+				if (next.done) {
+					finish();
+					controller.close();
+				} else controller.enqueue(next.value);
+			} catch (error) {
+				finish();
+				controller.error(error);
+			}
+		},
+		async cancel() {
+			finish();
+			cancel();
+			await iterator.return(void 0);
+		}
+	});
+}
+async function* parseEventStream(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let finished = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			buffer += decoder.decode(value, { stream: !done });
+			let boundary = findBoundary(buffer);
+			while (boundary) {
+				const frame = buffer.slice(0, boundary.index);
+				buffer = buffer.slice(boundary.index + boundary.length);
+				const data = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+				if (data) yield JSON.parse(data);
+				boundary = findBoundary(buffer);
+			}
+			if (done) {
+				if (buffer.trim()) throw new TypeError("Fevex event stream ended with an incomplete frame");
+				finished = true;
+				return;
+			}
+		}
+	} finally {
+		if (!finished) await reader.cancel();
+		reader.releaseLock();
+	}
+}
+function findBoundary(value) {
+	const lf = value.indexOf("\n\n");
+	const crlf = value.indexOf("\r\n\r\n");
+	if (lf < 0 && crlf < 0) return void 0;
+	return crlf >= 0 && (lf < 0 || crlf < lf) ? {
+		index: crlf,
+		length: 4
+	} : {
+		index: lf,
+		length: 2
+	};
+}
+function formatEvent(event) {
+	return `id: ${event.id}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+function artifactContext(handlerContext, request) {
+	const tenantId = handlerContext.context?.attributes?.tenantId;
+	if (tenantId !== void 0 && typeof tenantId !== "string") throw badRequest("tenantId attribute must be a string");
+	const actor = handlerContext.context?.actor;
+	return {
+		...typeof tenantId === "string" ? { tenantId } : {},
+		...actor === void 0 ? {} : { actor },
+		signal: request.signal
+	};
+}
+function optionalLimit(value) {
+	if (value === null) return void 0;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 1) throw badRequest("limit must be a positive integer");
+	return parsed;
+}
+function artifactResponse(descriptor, bytes) {
+	return versioned(new Response(bytes === null ? null : bytes.slice().buffer, { headers: {
+		"content-type": descriptor.mimeType,
+		"content-length": String(descriptor.size),
+		"content-disposition": contentDisposition(descriptor.filename),
+		"cache-control": "private, max-age=0, must-revalidate",
+		etag: `"${descriptor.sha256}"`,
+		"x-content-type-options": "nosniff",
+		"fevex-artifact-id": descriptor.artifactId,
+		"fevex-artifact-sha256": descriptor.sha256
+	} }));
+}
+function contentDisposition(filename) {
+	return `attachment; filename="${filename.replace(/[^\x20-\x7e]/gu, "_").replace(/["\\]/gu, "_")}"; filename*=UTF-8''${encodeURIComponent(filename).replace(/'/gu, "%27")}`;
+}
+function readResolution(body, actor) {
+	if (body.type === "elicitation" && typeof body.requestId === "string" && body.requestId.trim() && hasOwn(body, "value")) return {
+		type: "elicitation",
+		requestId: body.requestId,
+		value: body.value,
+		actor
+	};
+	if (body.type === "approval" && typeof body.approvalId === "string" && (body.decision === "approve" || body.decision === "reject")) return {
+		type: "approval",
+		approvalId: body.approvalId,
+		decision: body.decision,
+		actor
+	};
+	if (body.type === "tool_execution" && typeof body.toolCallId === "string" && body.decision === "retry") return {
+		type: "tool_execution",
+		toolCallId: body.toolCallId,
+		decision: "retry",
+		actor
+	};
+	if (body.type === "tool_execution" && typeof body.toolCallId === "string" && body.decision === "use_output" && hasOwn(body, "output")) return {
+		type: "tool_execution",
+		toolCallId: body.toolCallId,
+		decision: "use_output",
+		output: body.output,
+		actor
+	};
+	if (body.type === "timer") return {
+		type: "timer",
+		actor
+	};
+	if (body.type === "event" && typeof body.eventName === "string" && body.eventName.trim()) return {
+		type: "event",
+		eventName: body.eventName,
+		...hasOwn(body, "payload") ? { payload: body.payload } : {},
+		actor
+	};
+	throw badRequest("Invalid run resolution");
+}
+async function readJson(request) {
+	if (!request.headers.get("content-type")?.toLowerCase().includes(JSON_TYPE)) throw new HttpProtocolError(415, "UNSUPPORTED_MEDIA_TYPE", "Expected application/json");
+	let value;
+	try {
+		value = await request.json();
+	} catch {
+		throw badRequest("Request body must be valid JSON");
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw badRequest("Request body must be a JSON object");
+	return value;
+}
+function optionalId(value, name) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || !value.trim()) throw badRequest(`${name} must be a string`);
+	return value.trim();
+}
+function optionalPositiveInteger(value, name) {
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 1) throw badRequest(`${name} must be a positive integer`);
+	return value;
+}
+function optionalDeadline(value, name) {
+	const deadlineMs = optionalPositiveInteger(value, name);
+	if (deadlineMs !== void 0 && deadlineMs > 2147483647) throw badRequest(`${name} must be at most ${MAX_DEADLINE_MS}`);
+	return deadlineMs;
+}
+function optionalReasoning(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || ![
+		"provider-default",
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	].includes(value)) throw badRequest("reasoning must be a valid effort");
+	return value;
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function jsonInit(method, body) {
+	return {
+		method,
+		headers: { "content-type": JSON_TYPE },
+		body: JSON.stringify(body)
+	};
+}
+function json(value, status = 200) {
+	return versioned(Response.json(value, {
+		status,
+		headers: { "content-type": JSON_TYPE }
+	}));
+}
+function versioned(response) {
+	response.headers.set(FEVEX_HTTP_PROTOCOL_VERSION_HEADER, "3");
+	return response;
+}
+async function assertResponse(response, contentType) {
+	const version = response.headers.get(FEVEX_HTTP_PROTOCOL_VERSION_HEADER);
+	if (version !== "3") throw new TypeError(`Unsupported Fevex HTTP protocol version "${version ?? "missing"}"`);
+	if (!response.ok) {
+		if (!response.headers.get("content-type")?.includes(PROBLEM_TYPE)) throw new TypeError(`Expected ${PROBLEM_TYPE} response`);
+		const value = await response.json().catch(() => void 0);
+		if (!isProblemDetails(value)) throw new TypeError("Invalid Fevex Problem Details response");
+		throw new FevexHttpError(value);
+	}
+	if (contentType && !response.headers.get("content-type")?.includes(contentType)) throw new TypeError(`Expected ${contentType} response`);
+}
+function isProblemDetails(value) {
+	if (!value || typeof value !== "object") return false;
+	const problem = value;
+	return typeof problem.type === "string" && typeof problem.title === "string" && typeof problem.status === "number" && typeof problem.code === "string" && (problem.detail === void 0 || typeof problem.detail === "string") && (problem.instance === void 0 || typeof problem.instance === "string");
+}
+var HttpProtocolError = class extends Error {
+	status;
+	code;
+	constructor(status, code, message) {
+		super(message);
+		this.status = status;
+		this.code = code;
+	}
+};
+function badRequest(message, code = "INVALID_REQUEST") {
+	return new HttpProtocolError(400, code, message);
+}
+function notFound(code, message) {
+	return new HttpProtocolError(404, code, message);
+}
+function problem(error, instance, onError) {
+	let status = 500;
+	let code = "INTERNAL_ERROR";
+	let title = "Internal Server Error";
+	let detail;
+	if (error instanceof HttpProtocolError) {
+		({status, code} = error);
+		title = error.message;
+		detail = error.message;
+	} else if (error instanceof ArtifactError) {
+		code = error.code;
+		status = statusForArtifactErrorCode(error.code);
+		title = titleForStatus(status);
+		detail = error.message;
+	} else {
+		const runError = readFevexRunError(error);
+		if (runError) {
+			code = runError.code;
+			status = statusForRunErrorCode(runError.code);
+			title = titleForStatus(status);
+			detail = runError.message;
+		}
+	}
+	const value = {
+		type: `urn:fevex:problem:${code.toLowerCase()}`,
+		title,
+		status,
+		code,
+		...detail ? { detail } : {},
+		instance
+	};
+	if (status >= 500) try {
+		onError?.(error, value);
+	} catch {}
+	return versioned(new Response(JSON.stringify(value), {
+		status,
+		headers: { "content-type": PROBLEM_TYPE }
+	}));
+}
+function readFevexRunError(error) {
+	if (error instanceof FevexRunError) return error;
+	if (!error || typeof error !== "object") return void 0;
+	const value = error;
+	return typeof value.message === "string" && typeof value.code === "string" && FEVEX_RUN_ERROR_CODES.has(value.code) ? {
+		code: value.code,
+		message: value.message
+	} : void 0;
+}
+function statusForRunErrorCode(code) {
+	if (code === "AGENT_NOT_FOUND" || code === "WORKFLOW_NOT_FOUND" || code === "TEAM_NOT_FOUND" || code === "SESSION_NOT_FOUND") return 404;
+	if (code === "APPROVAL_INVALID" || code === "INVALID_CURSOR") return 400;
+	if (code === "POLICY_DENIED") return 403;
+	if (code === "ADMISSION_DENIED") return 429;
+	if (code === "RUNTIME_CLOSED") return 503;
+	return 409;
+}
+function statusForArtifactErrorCode(code) {
+	if (code === "ARTIFACT_INVALID_ID" || code === "ARTIFACT_INVALID_INPUT" || code === "ARTIFACT_INVALID_CONTEXT") return 400;
+	if (code === "ARTIFACT_TOO_LARGE") return 413;
+	if (code === "ARTIFACT_MIME_UNSUPPORTED") return 415;
+	if (code === "ARTIFACT_CONFLICT") return 409;
+	return 500;
+}
+function titleForStatus(status) {
+	if (status === 400) return "Bad Request";
+	if (status === 403) return "Forbidden";
+	if (status === 404) return "Not Found";
+	if (status === 409) return "Conflict";
+	if (status === 413) return "Payload Too Large";
+	if (status === 415) return "Unsupported Media Type";
+	if (status === 429) return "Too Many Requests";
+	if (status === 501) return "Not Implemented";
+	return "Internal Server Error";
+}
+function wait(ms, signal) {
+	return new Promise((resolve) => {
+		const timeout = setTimeout(finish, ms);
+		function finish() {
+			clearTimeout(timeout);
+			signal.removeEventListener("abort", finish);
+			resolve();
+		}
+		if (signal.aborted) finish();
+		else signal.addEventListener("abort", finish, { once: true });
+	});
+}
+//#endregion
+export { FEVEX_HTTP_PROTOCOL_VERSION, FEVEX_HTTP_PROTOCOL_VERSION_HEADER, FevexHttpError, createFevexHttpClient, createFevexHttpHandler };