@werft-ai/sdk 0.0.0-stage → 0.1.2

package/index.js

@@ -0,0 +1,1241 @@
+import createClient from "openapi-fetch";
+// ../client/src/errors.ts
+/**
+* What every failed call becomes. Callers branch on `code` (the server's
+* `error.code`), never on the HTTP status alone, and show `message` as the
+* server wrote it — a 403 says which scope was missing.
+*/
+var ApiError = class extends Error {
+	status;
+	code;
+	requestId;
+	retryable;
+	details;
+	retryAfterSeconds;
+	mismatch;
+	constructor(status, code, message, detail = {}) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "ApiError";
+		this.requestId = detail.requestId ?? null;
+		this.retryable = detail.retryable ?? null;
+		this.details = detail.details ?? null;
+		this.retryAfterSeconds = detail.retryAfterSeconds ?? null;
+		this.mismatch = detail.mismatch ?? null;
+	}
+};
+const text$1 = (value) => typeof value === "string" ? value : void 0;
+/** Seconds from a `Retry-After` header; an HTTP date or junk reads as none. */
+function retryAfterSeconds(response) {
+	const seconds = Number(response.headers.get("retry-after") ?? NaN);
+	return Number.isFinite(seconds) && seconds >= 0 ? seconds : null;
+}
+/** A non-2xx response and its parsed body, as one error shape. */
+function errorFromResponse$1(response, body) {
+	const error = body?.error;
+	return new ApiError(response.status, text$1(error?.code) ?? "UNKNOWN", text$1(error?.message) ?? response.statusText, {
+		requestId: text$1(error?.request_id) ?? response.headers.get("x-request-id"),
+		retryable: typeof error?.retryable === "boolean" ? error.retryable : null,
+		details: error?.details ?? null,
+		retryAfterSeconds: retryAfterSeconds(response)
+	});
+}
+// ../client/src/contract.ts
+function contractPolicy(options) {
+	const mode = options.validate ?? "off";
+	const warn = options.onContractMismatch ?? ((mismatch) => console.warn("API contract mismatch", mismatch));
+	const policy = {
+		mode,
+		validators: options.validators ?? {},
+		report(mismatch, status, requestId) {
+			if (mode === "off" || mismatch.issues.length === 0) return;
+			if (mode === "warn") return warn(mismatch);
+			throw new ApiError(status, "CLIENT_CONTRACT_MISMATCH", `${mismatch.operation} answered outside the API contract`, {
+				requestId,
+				mismatch
+			});
+		},
+		check(operation, validator, value, status, requestId) {
+			if (mode === "off" || !validator) return;
+			const issues = validator(value).map(({ path, message }) => ({
+				path: String(path),
+				message: String(message)
+			}));
+			policy.report({
+				operation,
+				issues
+			}, status, requestId);
+		}
+	};
+	return policy;
+}
+// ../client/src/client.ts
+const CSRF_HEADER_NAME = "x-requested-with";
+const CSRF_HEADER_VALUE = "agent-platform-web";
+const csrfHeader = { onRequest({ request }) {
+	request.headers.set(CSRF_HEADER_NAME, CSRF_HEADER_VALUE);
+	return request;
+} };
+const noCsrfHeader = { onRequest({ request }) {
+	request.headers.delete(CSRF_HEADER_NAME);
+	return request;
+} };
+const METHODS = [
+	"GET",
+	"PUT",
+	"POST",
+	"DELETE",
+	"OPTIONS",
+	"HEAD",
+	"PATCH",
+	"TRACE"
+];
+/**
+* A call may override the client's credentials, and middleware never sees
+* the call's options (Request.credentials is not reliable either: Bun reports
+* "include" for all), so the header is decided per call here.
+*/
+function csrfPerCall(client, fallback) {
+	const withCsrf = (init) => ({
+		...init,
+		middleware: [...init?.middleware ?? [], (init?.credentials ?? fallback) === "omit" ? noCsrfHeader : csrfHeader]
+	});
+	const wrapped = { ...client };
+	for (const method of METHODS) {
+		const call = client[method];
+		wrapped[method] = (url, init) => call(url, withCsrf(init));
+	}
+	const request = client.request;
+	wrapped.request = (method, url, init) => request(method, url, withCsrf(init));
+	return wrapped;
+}
+const policies = /* @__PURE__ */ new WeakMap();
+/** The contract policy a client was made with; streams apply it too. */
+function policyOf(client) {
+	let policy;
+	for (let c = client; c && !policy; c = Object.getPrototypeOf(c)) policy = policies.get(c);
+	if (!policy) throw new TypeError("client was not made by createApiClient");
+	return policy;
+}
+function createApiClient(options = {}) {
+	const credentials = options.credentials ?? "same-origin";
+	const client = csrfPerCall(createClient({
+		baseUrl: options.baseUrl ?? "",
+		credentials,
+		...options.headers ? { headers: { ...options.headers } } : {},
+		...options.fetch ? { fetch: options.fetch } : {}
+	}), credentials);
+	const policy = contractPolicy(options);
+	policies.set(client, policy);
+	if (policy.mode !== "off") client.use(contractCheck(policy));
+	return client;
+}
+function contractCheck(policy) {
+	return { async onResponse({ request, response, schemaPath }) {
+		const operation = `${request.method} ${schemaPath}`;
+		const validator = policy.validators.responses?.[operation];
+		if (!validator || !response.ok || response.status === 204) return;
+		const requestId = response.headers.get("x-request-id");
+		let body;
+		try {
+			body = JSON.parse(await response.clone().text());
+		} catch {
+			policy.report({
+				operation,
+				issues: [{
+					path: "",
+					message: "body is not JSON"
+				}]
+			}, response.status, requestId);
+			return;
+		}
+		policy.check(operation, validator, body, response.status, requestId);
+	} };
+}
+// ../client/src/sse.ts
+/**
+* Turns decoded text, split anywhere, into frames: the subset of the
+* WHATWG event-stream format the server writes (id, event, data, comments).
+*/
+function createFrameParser() {
+	let buffer = "";
+	let id;
+	let event = "";
+	let data = [];
+	return { push(text) {
+		buffer += text;
+		const frames = [];
+		for (;;) {
+			const end = buffer.search(/\r\n|\r|\n/);
+			if (end < 0 || end === buffer.length - 1 && buffer[end] === "\r") break;
+			const line = buffer.slice(0, end);
+			buffer = buffer.slice(end + (buffer.startsWith("\r\n", end) ? 2 : 1));
+			if (line === "") {
+				if (data.length > 0) frames.push({
+					id,
+					event: event || "message",
+					data: data.join("\n")
+				});
+				id = void 0;
+				event = "";
+				data = [];
+				continue;
+			}
+			if (line.startsWith(":")) continue;
+			const colon = line.indexOf(":");
+			const field = colon < 0 ? line : line.slice(0, colon);
+			let value = colon < 0 ? "" : line.slice(colon + 1);
+			if (value.startsWith(" ")) value = value.slice(1);
+			if (field === "id" && !value.includes("\0")) id = value;
+			else if (field === "event") event = value;
+			else if (field === "data") data.push(value);
+		}
+		return frames;
+	} };
+}
+const EVENT_NAMES = {
+	system: true,
+	assistant: true,
+	tool_use: true,
+	tool_result: true,
+	question: true,
+	result: true,
+	status: true,
+	error: true
+};
+Object.keys(EVENT_NAMES);
+/**
+* The envelope check every frame gets, in every mode and without a schema
+* library: what a frame must hold to be shown at all.
+*/
+function readFrame(raw, sessionId) {
+	const issue = (path, message) => ({
+		kind: "mismatch",
+		issues: [{
+			path,
+			message
+		}]
+	});
+	if (!raw.id) return issue("id", "missing");
+	if (!Object.hasOwn(EVENT_NAMES, raw.event)) return {
+		kind: "unknown",
+		issues: [{
+			path: "event",
+			message: "unknown kind"
+		}]
+	};
+	let envelope;
+	try {
+		envelope = JSON.parse(raw.data);
+	} catch {
+		return issue("data", "not JSON");
+	}
+	if (typeof envelope !== "object" || envelope === null) return issue("data", "not an object");
+	const fields = envelope;
+	if (fields.schema_version !== 1) return issue("data.schema_version", `not 1`);
+	if (typeof fields.session_id !== "string" || fields.session_id.toLowerCase() !== sessionId.toLowerCase()) return issue("data.session_id", "not the subscribed session");
+	if (typeof fields.occurred_at !== "string") return issue("data.occurred_at", "not a string");
+	for (const key of ["turn_id", "attempt_id"]) {
+		const value = fields[key];
+		if (value !== null && typeof value !== "string") return issue(`data.${key}`, "not a string or null");
+	}
+	if (!("data" in fields)) return issue("data.data", "missing");
+	return {
+		kind: "event",
+		frame: {
+			id: raw.id,
+			occurredAt: fields.occurred_at,
+			turnId: fields.turn_id,
+			attemptId: fields.attempt_id,
+			payload: {
+				event: raw.event,
+				data: fields.data
+			}
+		},
+		wire: {
+			id: raw.id,
+			event: raw.event,
+			data: envelope
+		}
+	};
+}
+// ../client/src/events.ts
+const OPERATION = "SSE /v1/sessions/{id}/events";
+const DEDUPE_WINDOW = 1e3;
+/**
+* Session events over fetch: unlike EventSource it carries the client's
+* headers, sees HTTP statuses, and resumes with Last-Event-ID after any drop.
+* Frames of a kind or envelope version this client does not know are dropped,
+* but the cursor still moves past them, or a reconnect would stall on them.
+*/
+async function subscribeSessionEvents(client, sessionId, options) {
+	const { signal } = options;
+	const policy = policyOf(client);
+	const initialMs = options.retry?.initialMs ?? 1e3;
+	const maxMs = options.retry?.maxMs ?? 3e4;
+	const idleMs = options.retry?.idleMs ?? 45e3;
+	const delivered = /* @__PURE__ */ new Set();
+	let cursor = options.lastEventId || void 0;
+	let backoff = initialMs;
+	/** Returns false once the subscription must end. */
+	const receive = (raw) => {
+		const reading = readFrame(raw, sessionId);
+		if (reading.kind === "event" && delivered.has(reading.frame.id)) return true;
+		if (raw.id) cursor = raw.id;
+		try {
+			if (reading.kind !== "event") {
+				if (reading.kind === "mismatch" || policy.mode === "strict") policy.report({
+					operation: OPERATION,
+					issues: reading.issues
+				}, 200, null);
+				return true;
+			}
+			policy.check(OPERATION, policy.validators.sessionEvent, reading.wire, 200, null);
+		} catch (error) {
+			if (!(error instanceof ApiError)) throw error;
+			options.onError?.(error);
+			return false;
+		}
+		delivered.add(reading.frame.id);
+		if (delivered.size > DEDUPE_WINDOW) delivered.delete(delivered.values().next().value);
+		backoff = initialMs;
+		options.onEvent(reading.frame);
+		return true;
+	};
+	/** One connection; resolves to the wait before the next, or null to end. */
+	const connect = async () => {
+		if (signal.aborted) return null;
+		const attempt = new AbortController();
+		const stop = () => attempt.abort();
+		signal.addEventListener("abort", stop, { once: true });
+		let idle;
+		const touch = () => {
+			clearTimeout(idle);
+			idle = setTimeout(stop, idleMs);
+		};
+		touch();
+		try {
+			const open = () => client.GET("/v1/sessions/{id}/events", {
+				params: {
+					path: { id: sessionId },
+					header: cursor ? { "Last-Event-ID": cursor } : {}
+				},
+				headers: { accept: "text/event-stream" },
+				parseAs: "stream",
+				signal: attempt.signal
+			});
+			let result;
+			try {
+				result = await open();
+			} catch {
+				return signal.aborted ? null : backoff;
+			}
+			const { data: body, error, response } = result;
+			if (!response.ok) {
+				const retryAfter = retryAfterSeconds(response);
+				if (response.status === 429 || response.status === 503) return retryAfter ? retryAfter * 1e3 : backoff;
+				if (response.status >= 500 || response.status === 408) return backoff;
+				options.onError?.(errorFromResponse$1(response, error));
+				return null;
+			}
+			if (!body) return backoff;
+			options.onState?.("open");
+			const reader = body.getReader();
+			const decoder = new TextDecoder();
+			const parser = createFrameParser();
+			for (;;) {
+				let chunk;
+				try {
+					chunk = await reader.read();
+				} catch {
+					break;
+				}
+				if (chunk.done) break;
+				touch();
+				for (const raw of parser.push(decoder.decode(chunk.value, { stream: true }))) if (signal.aborted || !receive(raw)) {
+					await reader.cancel().catch(() => {});
+					return null;
+				}
+			}
+			await reader.cancel().catch(() => {});
+			return signal.aborted ? null : backoff;
+		} finally {
+			clearTimeout(idle);
+			signal.removeEventListener("abort", stop);
+		}
+	};
+	try {
+		while (!signal.aborted) {
+			options.onState?.("connecting");
+			const wait = await connect();
+			if (wait === null) return;
+			backoff = Math.min(backoff * 2, maxMs);
+			await sleep(wait, signal);
+		}
+	} finally {
+		options.onState?.("closed");
+	}
+}
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) return resolve();
+		const done = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+// src/core/errors.ts
+/** One class per failure mechanism, never per code: branch on `code`. */
+var WerftError = class extends Error {
+	code;
+	attempts;
+	/** Set on every error from a keyed command, aborts included. Retry with this key, not a new one. */
+	idempotencyKey;
+	constructor(code, message, init = {}) {
+		super(message, init.cause === void 0 ? void 0 : { cause: init.cause });
+		this.name = new.target.name;
+		this.code = code;
+		this.attempts = init.attempts ?? 1;
+		this.idempotencyKey = init.idempotencyKey;
+	}
+};
+/** The server answered with an error. `code` is its `error.code` as sent. */
+var APIError = class extends WerftError {
+	status;
+	retryable;
+	requestId;
+	details;
+	/** Retry-After in milliseconds, when the response had one. */
+	retryAfterMs;
+	constructor(status, code, message, init = {}) {
+		super(code, message, init);
+		this.status = status;
+		this.retryable = init.retryable ?? false;
+		this.requestId = init.requestId ?? null;
+		this.details = init.details ?? null;
+		this.retryAfterMs = init.retryAfterMs;
+	}
+};
+/** No response was read: the command may or may not have run. */
+var ConnectionError = class extends WerftError {
+	constructor(message, init = {}) {
+		super("NETWORK_ERROR", message, init);
+	}
+};
+var TimeoutError = class extends WerftError {
+	constructor(message, init = {}) {
+		super("TIMEOUT", message, init);
+	}
+};
+/** The caller's signal aborted. `name` is "AbortError" and `cause` the signal's reason. */
+var AbortedError = class extends WerftError {
+	constructor(reason, init = {}) {
+		super("ABORTED", "The request was aborted", {
+			...init,
+			cause: reason
+		});
+		this.name = "AbortError";
+	}
+};
+/** waitForTurn only: the session left `active` and the turn cannot end until someone acts. */
+var TurnBlockedError = class extends WerftError {
+	details;
+	constructor(admissionState) {
+		super("TURN_BLOCKED", `The session is ${admissionState}; the turn cannot finish until it is acted on`);
+		this.details = { admission_state: admissionState };
+	}
+};
+function isApiError(error, code) {
+	return error instanceof APIError && (code === void 0 || error.code === code);
+}
+// src/core/request.ts
+const RESERVED_HEADERS = /* @__PURE__ */ new Set(["authorization", "idempotency-key"]);
+function checkHeaders(headers) {
+	for (const name of Object.keys(headers ?? {})) if (RESERVED_HEADERS.has(name.toLowerCase())) throw new TypeError(`headers cannot set ${name}`);
+	return { ...headers };
+}
+/** The one place for deadlines, retries, the Idempotency-Key and error mapping. */
+async function call(policy, kind, attempt, options = {}, defaultKey) {
+	const headers = checkHeaders(options.headers);
+	const key = kind === "keyed" ? options.idempotencyKey ?? defaultKey ?? crypto.randomUUID() : void 0;
+	const { signal } = options;
+	const maxRetries = options.maxRetries ?? policy.maxRetries;
+	const timeoutMs = options.timeoutMs ?? policy.timeoutMs;
+	const sleep = policy.sleep ?? abortableSleep;
+	const random = policy.random ?? Math.random;
+	for (let retry = 0;; retry++) {
+		const tags = {
+			attempts: retry + 1,
+			idempotencyKey: key
+		};
+		if (signal?.aborted) throw new AbortedError(signal.reason, {
+			...tags,
+			attempts: retry
+		});
+		const deadline = new AbortController();
+		const timer = setTimeout(() => deadline.abort(), timeoutMs);
+		let failure;
+		let retryable;
+		try {
+			const { data, error, response } = await attempt({
+				signal: signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal,
+				headers,
+				idempotencyKey: key ?? ""
+			});
+			if (response.ok) return data;
+			failure = errorFromResponse(response, error, tags);
+			retryable = isRetryable(response.status, error, kind);
+		} catch (cause) {
+			if (signal?.aborted) throw new AbortedError(signal.reason, tags);
+			failure = deadline.signal.aborted ? new TimeoutError(`No response within ${timeoutMs} ms`, tags) : new ConnectionError(cause instanceof Error ? cause.message : String(cause), {
+				...tags,
+				cause
+			});
+			retryable = kind !== "unkeyed";
+		} finally {
+			clearTimeout(timer);
+		}
+		if (!retryable || retry >= maxRetries) throw failure;
+		let wait = random() * Math.min(500 * 2 ** retry, 8e3, policy.maxRetryDelayMs);
+		if (failure instanceof APIError && failure.retryAfterMs !== void 0) {
+			if (failure.retryAfterMs > policy.maxRetryDelayMs) throw failure;
+			wait = failure.retryAfterMs;
+		}
+		await sleep(wait, signal);
+		if (signal?.aborted) throw new AbortedError(signal.reason, tags);
+	}
+}
+function apiErrorBody(body) {
+	const error = body?.error;
+	return typeof error?.code === "string" ? error : void 0;
+}
+/**
+* 409 is always a state conflict and 500 a server bug: neither is retried
+* whatever the body says. A 502 or 504 without the API's error body came
+* from a proxy in front of it, so the API may have run the call: like a
+* lost response, it is retried only for reads and keyed commands.
+*/
+function isRetryable(status, body, kind) {
+	if (status === 409 || status === 500) return false;
+	const error = apiErrorBody(body);
+	if (error) return error.retryable === true;
+	return kind !== "unkeyed" && (status === 502 || status === 504);
+}
+/** A failure `call` would have retried: worth another try on the next poll. */
+function isTransient(error) {
+	if (error instanceof ConnectionError || error instanceof TimeoutError) return true;
+	if (!(error instanceof APIError)) return false;
+	if (error.status === 409 || error.status === 500) return false;
+	return error.retryable || (error.status === 502 || error.status === 504) && error.code === "UNKNOWN";
+}
+function retryAfterMs(response) {
+	const header = response.headers.get("retry-after");
+	if (header === null || header.trim() === "") return void 0;
+	const seconds = Number(header);
+	return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+}
+const text = (value) => typeof value === "string" ? value : void 0;
+function errorFromResponse(response, body, tags) {
+	const error = apiErrorBody(body);
+	return new APIError(response.status, text(error?.code) ?? "UNKNOWN", text(error?.message) ?? (response.statusText || `HTTP ${response.status}`), {
+		...tags,
+		retryable: error?.retryable === true,
+		requestId: text(error?.request_id) ?? response.headers.get("x-request-id"),
+		details: error?.details ?? null,
+		retryAfterMs: retryAfterMs(response)
+	});
+}
+function abortableSleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) return resolve();
+		const done = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		signal?.addEventListener("abort", done, { once: true });
+	});
+}
+// src/core/page.ts
+function page(fetch, body, options) {
+	return {
+		items: body.items,
+		next_cursor: body.next_cursor,
+		async nextPage(overrides) {
+			if (body.next_cursor === null) return null;
+			const merged = {
+				...options,
+				...overrides
+			};
+			return page(fetch, await fetch(body.next_cursor, merged), merged);
+		}
+	};
+}
+function paginate(fetch, options) {
+	const first = fetch(void 0, options).then((body) => page(fetch, body, options));
+	return Object.assign(first, { async *[Symbol.asyncIterator]() {
+		let current = await first;
+		while (current) {
+			yield* current.items;
+			current = await current.nextPage();
+		}
+	} });
+}
+// src/core/stream.ts
+const MAX_BUFFERED_EVENTS = 1e4;
+function toEvent(frame) {
+	return {
+		id: frame.id,
+		turn_id: frame.turnId,
+		attempt_id: frame.attemptId,
+		occurred_at: frame.occurredAt,
+		kind: frame.payload.event,
+		payload: frame.payload.data
+	};
+}
+function fromClientError(error) {
+	return new APIError(error.status, error.code, error.message, {
+		retryable: error.retryable === true,
+		requestId: error.requestId,
+		details: error.details,
+		retryAfterMs: error.retryAfterSeconds === null ? void 0 : error.retryAfterSeconds * 1e3
+	});
+}
+function openEventStream(api, sessionId, options = {}) {
+	const stop = new AbortController();
+	const signal = options.signal ? AbortSignal.any([options.signal, stop.signal]) : stop.signal;
+	let lastEventId = options.lastEventId || void 0;
+	let started = false;
+	const queue = [];
+	let failure;
+	let ended = false;
+	let closed = false;
+	let wake;
+	const notify = () => {
+		wake?.();
+		wake = void 0;
+	};
+	const start = () => {
+		started = true;
+		signal.addEventListener("abort", () => {
+			ended = true;
+			notify();
+		}, { once: true });
+		subscribeSessionEvents(api, sessionId, {
+			signal,
+			...lastEventId ? { lastEventId } : {},
+			onEvent(frame) {
+				if (failure !== void 0) return;
+				if (queue.length >= 1e4) {
+					failure = new WerftError("STREAM_OVERFLOW", `More than ${MAX_BUFFERED_EVENTS} events waited to be read; reopen the stream from lastEventId`);
+					stop.abort();
+					return;
+				}
+				queue.push(toEvent(frame));
+				notify();
+			},
+			onError(error) {
+				failure = fromClientError(error);
+			}
+		}).catch((error) => {
+			failure = error;
+		}).finally(() => {
+			ended = true;
+			notify();
+		});
+	};
+	return {
+		get lastEventId() {
+			return lastEventId;
+		},
+		close() {
+			closed = true;
+			stop.abort();
+		},
+		async *[Symbol.asyncIterator]() {
+			if (started) throw new TypeError("an event stream is read once");
+			start();
+			try {
+				for (;;) {
+					if (closed || options.signal?.aborted) return;
+					const event = queue.shift();
+					if (event) {
+						lastEventId = event.id;
+						yield event;
+						continue;
+					}
+					if (ended) {
+						if (failure !== void 0) throw failure;
+						return;
+					}
+					await new Promise((resolve) => {
+						wake = resolve;
+					});
+				}
+			} finally {
+				stop.abort();
+			}
+		}
+	};
+}
+// src/resources/close.ts
+/** Admission while the worker drains for a close; `closed` follows. */
+const SESSION_ADMISSION_CLOSING = "closing";
+/** A message or control sent while the session is `closing`. */
+const SESSION_CLOSING = "SESSION_CLOSING";
+/** Attention on a close whose drain has run over 60 seconds. Nothing is killed for it. */
+const CLOSE_BLOCKED = "CLOSE_BLOCKED";
+function isClosing(session) {
+	return session.admission_state === SESSION_ADMISSION_CLOSING;
+}
+function closeBlocked(session) {
+	const attention = session.attention;
+	return attention?.code === "CLOSE_BLOCKED" ? attention : null;
+}
+/** The typed result of a succeeded close receipt; null for any other receipt. */
+function closeResult(receipt) {
+	if (receipt.operation !== "close" || receipt.status !== "succeeded") return null;
+	const result = receipt.result;
+	if (typeof result?.resulting_admission_state !== "string" || typeof result.cancelled_turn_count !== "number" || result.checkpoint_revision !== null && typeof result.checkpoint_revision !== "number") return null;
+	return result;
+}
+/**
+* Ends a session whose work is done; the running turn finishes first. A
+* caller closing its own session from inside a turn must not wait on the
+* receipt: the drain waits for that turn to end.
+*/
+function closeSession(context, id, params, options) {
+	return call(context.policy, "keyed", ({ signal, headers, idempotencyKey }) => context.api.POST("/v1/sessions/{id}/close", {
+		params: {
+			path: { id },
+			header: { "Idempotency-Key": idempotencyKey }
+		},
+		body: params,
+		signal,
+		headers
+	}), options);
+}
+// src/resources/sessions.ts
+function sessions(context) {
+	const { api, policy } = context;
+	const header = (idempotencyKey) => ({ "Idempotency-Key": idempotencyKey });
+	const approve = (id, pushRequestId, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/push-requests/{push_request_id}/approve", {
+		params: {
+			path: {
+				id,
+				push_request_id: pushRequestId
+			},
+			header: header(idempotencyKey)
+		},
+		body: params,
+		signal,
+		headers
+	}), options);
+	const reject = (id, pushRequestId, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/push-requests/{push_request_id}/reject", {
+		params: {
+			path: {
+				id,
+				push_request_id: pushRequestId
+			},
+			header: header(idempotencyKey)
+		},
+		body: params,
+		signal,
+		headers
+	}), options);
+	return {
+		create: (params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions", {
+			params: { header: header(idempotencyKey) },
+			body: params,
+			signal,
+			headers
+		}), options),
+		get: (id, options) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}", {
+			params: { path: { id } },
+			signal,
+			headers
+		}), options),
+		list: (params, options) => paginate((cursor, pageOptions) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions", {
+			params: { query: {
+				...params,
+				...cursor ? { cursor } : {}
+			} },
+			signal,
+			headers
+		}), pageOptions), options),
+		usage: (id, options) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/usage", {
+			params: { path: { id } },
+			signal,
+			headers
+		}), options),
+		share: (id, options) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/share", {
+			params: { path: { id } },
+			signal,
+			headers
+		}), options),
+		interrupt: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/interrupt", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: params,
+			signal,
+			headers
+		}), options),
+		pause: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/pause", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: params,
+			signal,
+			headers
+		}), options),
+		resume: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/resume", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: params,
+			signal,
+			headers
+		}), options),
+		terminate: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/terminate", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: params,
+			signal,
+			headers
+		}), options),
+		close: (id, params, options) => closeSession(context, id, params, options),
+		changeProfile: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/profile", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: params,
+			signal,
+			headers
+		}), options),
+		recoveryDecisions: { create: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/recovery-decisions", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: params,
+			signal,
+			headers
+		}), options) },
+		messages: { send: (id, params, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/messages", {
+			params: {
+				path: { id },
+				header: header(idempotencyKey)
+			},
+			body: {
+				mode: "enqueue",
+				...params
+			},
+			signal,
+			headers
+		}), options) },
+		turns: {
+			get: (id, turnId, options) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/turns/{turn_id}", {
+				params: { path: {
+					id,
+					turn_id: turnId
+				} },
+				signal,
+				headers
+			}), options),
+			list: (id, params, options) => paginate((cursor, pageOptions) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/turns", {
+				params: {
+					path: { id },
+					query: {
+						...params,
+						...cursor ? { cursor } : {}
+					}
+				},
+				signal,
+				headers
+			}), pageOptions), options)
+		},
+		events: { stream: (id, options) => openEventStream(api, id, options) },
+		requests: {
+			list: async (id, options) => (await call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/pending-requests", {
+				params: { path: { id } },
+				signal,
+				headers
+			}), options)).items,
+			answer: (id, body, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/answers", {
+				params: {
+					path: { id },
+					header: header(idempotencyKey)
+				},
+				body,
+				signal,
+				headers
+			}), options, `answer:${body.request_id}`)
+		},
+		pushRequests: {
+			create: (id, options) => call(policy, "keyed", ({ signal, headers, idempotencyKey }) => api.POST("/v1/sessions/{id}/push-requests", {
+				params: {
+					path: { id },
+					header: header(idempotencyKey)
+				},
+				body: {},
+				signal,
+				headers
+			}), options),
+			list: async (id, options) => (await call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/push-requests", {
+				params: { path: { id } },
+				signal,
+				headers
+			}), options)).items,
+			get: (id, pushRequestId, options) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/sessions/{id}/push-requests/{push_request_id}", {
+				params: { path: {
+					id,
+					push_request_id: pushRequestId
+				} },
+				signal,
+				headers
+			}), options),
+			approve,
+			reject,
+			openPullRequest: (id, pushRequestId, params, options) => call(policy, "unkeyed", ({ signal, headers }) => api.POST("/v1/sessions/{id}/push-requests/{push_request_id}/pull-request", {
+				params: { path: {
+					id,
+					push_request_id: pushRequestId
+				} },
+				body: params ?? {},
+				signal,
+				headers
+			}), options),
+			commentPullRequest: (id, pushRequestId, params, options) => call(policy, "unkeyed", ({ signal, headers }) => api.POST("/v1/sessions/{id}/push-requests/{push_request_id}/pull-request/comments", {
+				params: { path: {
+					id,
+					push_request_id: pushRequestId
+				} },
+				body: params,
+				signal,
+				headers
+			}), options)
+		}
+	};
+}
+// src/client.ts
+const settings = /* @__PURE__ */ new WeakMap();
+function environment() {
+	return globalThis.process?.env ?? {};
+}
+function isLoopback(hostname) {
+	return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "[::1]" || /^127(\.\d{1,3}){3}$/.test(hostname);
+}
+function count(name, value, fallback) {
+	if (value === void 0) return fallback;
+	if (!Number.isInteger(value) || value < 0) throw new TypeError(`${name} must be a non-negative integer`);
+	return value;
+}
+var Werft = class Werft {
+	sessions;
+	receipts;
+	/** This key's owner and scopes. */
+	auth;
+	limits;
+	profiles;
+	root;
+	constructor(options = {}) {
+		const env = environment();
+		const apiKey = options.apiKey ?? env.WERFT_API_KEY;
+		const baseUrl = options.baseUrl ?? env.WERFT_BASE_URL;
+		if (!apiKey) throw new TypeError("No API key: pass apiKey or set WERFT_API_KEY");
+		if (!baseUrl) throw new TypeError("No base URL: pass baseUrl or set WERFT_BASE_URL");
+		if (typeof globalThis.window !== "undefined" && !options.dangerouslyAllowBrowser) throw new Error("Werft runs on servers and scripts: an API key in a browser page leaks. Set dangerouslyAllowBrowser to override.");
+		let url;
+		try {
+			url = new URL(baseUrl);
+		} catch {
+			throw new TypeError("baseUrl is not a URL");
+		}
+		if (url.protocol !== "https:" && url.protocol !== "http:") throw new TypeError("baseUrl must be http or https");
+		if (url.protocol === "http:" && !isLoopback(url.hostname) && !options.allowInsecureHttp) throw new Error("baseUrl is plain http to a remote host: the API key would cross the wire in clear text. Use https or set allowInsecureHttp.");
+		const policy = {
+			maxRetries: count("maxRetries", options.maxRetries, 2),
+			maxRetryDelayMs: count("maxRetryDelayMs", options.maxRetryDelayMs, 6e4),
+			timeoutMs: count("timeoutMs", options.timeoutMs, 6e4)
+		};
+		const api = createApiClient({
+			baseUrl: url.href.replace(/\/+$/, ""),
+			credentials: "omit",
+			headers: {
+				...checkHeaders(options.defaultHeaders),
+				authorization: `Bearer ${apiKey}`
+			},
+			...options.fetch ? { fetch: options.fetch } : {}
+		});
+		const context = {
+			api,
+			policy
+		};
+		settings.set(this, {
+			...options,
+			apiKey,
+			baseUrl
+		});
+		this.sessions = sessions(context);
+		this.receipts = { get: (id, o) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/receipts/{id}", {
+			params: { path: { id } },
+			signal,
+			headers
+		}), o) };
+		this.auth = { me: (o) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/auth/me", {
+			signal,
+			headers
+		}), o) };
+		this.limits = { get: async (o) => {
+			const limits = await call(policy, "read", ({ signal, headers }) => api.GET("/v1/limits", {
+				params: { query: { scope: "installation" } },
+				signal,
+				headers
+			}), o);
+			if (limits.scope !== "installation") throw new TypeError(`unexpected limits scope ${limits.scope}`);
+			return limits;
+		} };
+		this.profiles = { list: (o) => call(policy, "read", ({ signal, headers }) => api.GET("/v1/profiles", {
+			signal,
+			headers
+		}), o) };
+		this.root = { get: (o) => call(policy, "read", ({ signal, headers }) => api.GET("/v1", {
+			signal,
+			headers
+		}), o) };
+	}
+	/** A second client with some options changed, e.g. an approve-scoped key. */
+	withOptions(overrides) {
+		return new Werft({
+			...settings.get(this),
+			...overrides
+		});
+	}
+};
+// src/helpers.ts
+const TERMINAL_TURN = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"interrupted",
+	"cancelled",
+	"outcome_unknown"
+]);
+const BLOCKED_ADMISSION = /* @__PURE__ */ new Set([
+	"paused",
+	"stopped",
+	"recovery_required",
+	"closed"
+]);
+const OPEN_PUSH = /* @__PURE__ */ new Set([
+	"requested",
+	"approved",
+	"pushing"
+]);
+const ended = (turn) => TERMINAL_TURN.has(turn.status) || turn.ended_at !== null;
+const never = new AbortController().signal;
+function aborted(signal) {
+	if (signal?.aborted) throw new AbortedError(signal.reason);
+}
+const optionsOf = (signal) => signal ? { signal } : {};
+async function decide(request, handlers, signal) {
+	if (request.kind === "permission" && handlers.permission) {
+		const answer = await handlers.permission(request, { signal });
+		if (!answer) return void 0;
+		const { action } = answer;
+		if (action === "deny" && !answer.reason?.trim()) throw new TypeError("a denial needs a reason the model can act on");
+		return {
+			request_id: request.request_id,
+			kind: "permission",
+			action,
+			...answer.reason ? { reason: answer.reason } : {}
+		};
+	}
+	if (request.kind === "question" && handlers.question) {
+		const answer = await handlers.question(request, { signal });
+		if (!answer) return void 0;
+		return {
+			request_id: request.request_id,
+			kind: "question",
+			answers: answer.answers
+		};
+	}
+}
+async function answerOne(client, sessionId, request, handlers, signal) {
+	const { request_id } = request;
+	const body = await decide(request, handlers, signal ?? never);
+	if (!body) return {
+		request_id,
+		outcome: "left_open"
+	};
+	try {
+		return {
+			request_id,
+			outcome: "accepted",
+			receipt: await client.sessions.requests.answer(sessionId, body, optionsOf(signal))
+		};
+	} catch (error) {
+		if (isApiError(error, "REQUEST_EXPIRED")) return {
+			request_id,
+			outcome: "too_late",
+			code: "REQUEST_EXPIRED"
+		};
+		if (isApiError(error, "REQUEST_STALE")) return {
+			request_id,
+			outcome: "too_late",
+			code: "REQUEST_STALE"
+		};
+		if (isApiError(error, "IDEMPOTENCY_CONFLICT")) return {
+			request_id,
+			outcome: "conflict"
+		};
+		throw error;
+	}
+}
+const oldestFirst = (a, b) => a.created_at.localeCompare(b.created_at);
+/** Hands every open request of the session, oldest first, to its handler once. */
+async function answerPending(client, sessionId, handlers, options = {}) {
+	const requests = await client.sessions.requests.list(sessionId, optionsOf(options.signal));
+	const outcomes = [];
+	for (const request of [...requests].sort(oldestFirst)) outcomes.push(await answerOne(client, sessionId, request, handlers, options.signal));
+	return outcomes;
+}
+/** A wait that the timer, an event or the signal ends, whichever comes first. */
+function waker(signal) {
+	let pending = false;
+	let holdMs = 0;
+	let wakeNow;
+	return {
+		wake() {
+			if (wakeNow) wakeNow();
+			else pending = true;
+		},
+		/** The server's Retry-After: the next nap lasts at least this, and no event cuts it short. */
+		holdOff(ms) {
+			holdMs = Math.max(holdMs, ms);
+		},
+		nap(ms) {
+			const hold = holdMs;
+			holdMs = 0;
+			if (signal?.aborted || pending && hold === 0) {
+				pending = false;
+				return Promise.resolve();
+			}
+			pending = false;
+			return new Promise((resolve) => {
+				const done = () => {
+					clearTimeout(timer);
+					signal?.removeEventListener("abort", done);
+					wakeNow = void 0;
+					resolve();
+				};
+				const timer = setTimeout(done, Math.max(ms, hold));
+				signal?.addEventListener("abort", done, { once: true });
+				if (hold === 0) wakeNow = done;
+			});
+		}
+	};
+}
+/** Retryable failures wait for the next poll; any other ends the wait. */
+async function orNull(read, timer) {
+	try {
+		return await read;
+	} catch (error) {
+		if (!isTransient(error)) throw error;
+		if (error instanceof APIError && error.retryAfterMs !== void 0) timer.holdOff(error.retryAfterMs);
+		return null;
+	}
+}
+/**
+* Resolves with the turn once GET turn shows it ended; a `failed` turn is
+* data, not an error. One loop reads the turn, answers new pending requests
+* of the session (not only this turn's: a queued turn waits on the one
+* ahead) and checks the session is not stuck, then sleeps.
+*/
+async function waitForTurn(client, sessionId, turnId, options = {}) {
+	const { signal } = options;
+	const interval = options.pollIntervalMs ?? 2e3;
+	const handed = /* @__PURE__ */ new Set();
+	const timer = waker(signal);
+	const streamStop = new AbortController();
+	if (options.events) {
+		const stream = client.sessions.events.stream(sessionId, {
+			signal: signal ? AbortSignal.any([signal, streamStop.signal]) : streamStop.signal,
+			...options.events.lastEventId ? { lastEventId: options.events.lastEventId } : {}
+		});
+		const onEvent = options.events.onEvent;
+		(async () => {
+			try {
+				for await (const event of stream) {
+					onEvent?.(event);
+					timer.wake();
+				}
+			} catch {}
+		})();
+	}
+	try {
+		for (;;) {
+			aborted(signal);
+			const turn = await orNull(client.sessions.turns.get(sessionId, turnId, optionsOf(signal)), timer);
+			if (turn && ended(turn)) return turn;
+			if (options.onRequest) {
+				const requests = await orNull(client.sessions.requests.list(sessionId, optionsOf(signal)), timer);
+				for (const request of [...requests ?? []].sort(oldestFirst)) {
+					if (handed.has(request.request_id)) continue;
+					handed.add(request.request_id);
+					const outcome = await answerOne(client, sessionId, request, options.onRequest, signal);
+					options.onAnswer?.(outcome);
+				}
+			}
+			const session = await orNull(client.sessions.get(sessionId, optionsOf(signal)), timer);
+			if (turn && session && BLOCKED_ADMISSION.has(session.admission_state)) {
+				const again = await orNull(client.sessions.turns.get(sessionId, turnId, optionsOf(signal)), timer);
+				if (again && ended(again)) return again;
+				if (again) throw new TurnBlockedError(session.admission_state);
+			}
+			await timer.nap(interval);
+		}
+	} finally {
+		streamStop.abort();
+	}
+}
+/** Polls the receipt until it leaves `accepted`. */
+async function waitForReceipt(client, receiptId, options = {}) {
+	const { signal } = options;
+	const timer = waker(signal);
+	for (;;) {
+		aborted(signal);
+		const receipt = await orNull(client.receipts.get(receiptId, optionsOf(signal)), timer);
+		if (receipt && receipt.status !== "accepted") return receipt;
+		await timer.nap(options.pollIntervalMs ?? 1e3);
+	}
+}
+/** Polls until the push request is pushed, failed or rejected. */
+async function waitForPushRequest(client, sessionId, pushRequestId, options = {}) {
+	const { signal } = options;
+	const timer = waker(signal);
+	for (;;) {
+		aborted(signal);
+		const push = await orNull(client.sessions.pushRequests.get(sessionId, pushRequestId, optionsOf(signal)), timer);
+		if (push && !OPEN_PUSH.has(push.state)) return push;
+		await timer.nap(options.pollIntervalMs ?? 2e3);
+	}
+}
+// src/version.ts
+const SDK_VERSION = "0.1.2";
+/** info.version of the spec the types were generated from. Not checked at runtime: the API does not report one. */
+const API_SPEC_VERSION = "0.1.0-alpha";
+const SUPPORTED_SSE_SCHEMA_VERSIONS = [1];
+export { APIError, API_SPEC_VERSION, AbortedError, CLOSE_BLOCKED, ConnectionError, SDK_VERSION, SESSION_ADMISSION_CLOSING, SESSION_CLOSING, SUPPORTED_SSE_SCHEMA_VERSIONS, TimeoutError, TurnBlockedError, Werft, WerftError, answerPending, closeBlocked, closeResult, isApiError, isClosing, waitForPushRequest, waitForReceipt, waitForTurn };