@fuserstudio/sdk 0.0.0-stage → 0.0.1

package/index.js

@@ -0,0 +1,1453 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+//#region src/errors.ts
+/** Every error the SDK throws. Subclasses say what went wrong. */
+var FuserError = class extends Error {
+	name = "FuserError";
+	tool;
+	status;
+	code;
+	reason;
+	issues;
+	requestId;
+	retryAfterMs;
+	body;
+	constructor(message, details) {
+		super(message, { cause: details.cause });
+		this.tool = details.tool;
+		this.status = details.status;
+		this.code = details.code;
+		this.reason = details.reason;
+		this.issues = details.issues;
+		this.requestId = details.requestId;
+		this.retryAfterMs = details.retryAfterMs;
+		this.body = details.body;
+	}
+};
+var BadRequestError = class extends FuserError {
+	name = "BadRequestError";
+};
+var AuthenticationError = class extends FuserError {
+	name = "AuthenticationError";
+};
+var PermissionDeniedError = class extends FuserError {
+	name = "PermissionDeniedError";
+};
+var NotFoundError = class extends FuserError {
+	name = "NotFoundError";
+};
+var ConflictError = class extends FuserError {
+	name = "ConflictError";
+};
+var RateLimitError = class extends FuserError {
+	name = "RateLimitError";
+};
+var InternalServerError = class extends FuserError {
+	name = "InternalServerError";
+};
+var ConnectionError = class extends FuserError {
+	name = "ConnectionError";
+};
+var TimeoutError = class extends FuserError {
+	name = "TimeoutError";
+};
+/** `run.start(...).wait()` on a run Fuser refused to start. */
+var RunRefusedError = class extends FuserError {
+	name = "RunRefusedError";
+};
+const BY_STATUS = {
+	400: BadRequestError,
+	401: AuthenticationError,
+	403: PermissionDeniedError,
+	404: NotFoundError,
+	409: ConflictError,
+	429: RateLimitError
+};
+function errorFromResponse(tool, response, body) {
+	const parsed = body && typeof body === "object" ? body : {};
+	const Kind = BY_STATUS[response.status] ?? (response.status >= 500 ? InternalServerError : FuserError);
+	const retryAfter = Number(response.headers.get("retry-after"));
+	const message = parsed.message ?? `${tool} failed with HTTP ${String(response.status)}.`;
+	const issues = parsed.issues?.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message).join("; ");
+	return new Kind(issues ? `${message}: ${issues}` : message, {
+		tool,
+		status: response.status,
+		code: parsed.code,
+		reason: parsed.reason,
+		issues: parsed.issues,
+		requestId: response.headers.get("x-request-id") ?? void 0,
+		retryAfterMs: retryAfter > 0 ? retryAfter * 1e3 : void 0,
+		body
+	});
+}
+//#endregion
+//#region src/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+//#endregion
+//#region src/generated/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+				await sleep(backoff);
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+async function setAuthParams(options) {
+	for (const auth of options.security ?? []) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default: options.headers.set(name, token);
+		}
+	}
+}
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+//#endregion
+//#region src/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams(opts);
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const throwOnError = options.throwOnError ?? _config.throwOnError;
+		const responseStyle = options.responseStyle ?? _config.responseStyle;
+		let request;
+		let response;
+		try {
+			const { opts, url } = await beforeRequest(options);
+			const requestInit = {
+				redirect: "follow",
+				...opts,
+				body: getValidRequestBody(opts)
+			};
+			request = new Request(url, requestInit);
+			for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+			const _fetch = opts.fetch;
+			response = await _fetch(request);
+			for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+			const result = {
+				request,
+				response
+			};
+			if (response.ok) {
+				const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+				if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+					let emptyData;
+					switch (parseAs) {
+						case "arrayBuffer":
+						case "blob":
+						case "text":
+							emptyData = await response[parseAs]();
+							break;
+						case "formData":
+							emptyData = new FormData();
+							break;
+						case "stream":
+							emptyData = response.body;
+							break;
+						default: emptyData = {};
+					}
+					return opts.responseStyle === "data" ? emptyData : {
+						data: emptyData,
+						...result
+					};
+				}
+				let data;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "formData":
+					case "text":
+						data = await response[parseAs]();
+						break;
+					case "json": {
+						const text = await response.text();
+						data = text ? JSON.parse(text) : {};
+						break;
+					}
+					case "stream": return opts.responseStyle === "data" ? response.body : {
+						data: response.body,
+						...result
+					};
+				}
+				if (parseAs === "json") {
+					if (opts.responseValidator) await opts.responseValidator(data);
+					if (opts.responseTransformer) data = await opts.responseTransformer(data);
+				}
+				return opts.responseStyle === "data" ? data : {
+					data,
+					...result
+				};
+			}
+			const textError = await response.text();
+			let jsonError;
+			try {
+				jsonError = JSON.parse(textError);
+			} catch {}
+			throw jsonError ?? textError;
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(finalError, response, request, options);
+			finalError = finalError || {};
+			if (throwOnError) throw finalError;
+			return responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response
+			};
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region src/generated/client.gen.ts
+const client = createClient(createConfig({ baseUrl: "https://api.fuser.studio" }));
+//#endregion
+//#region src/generated/sdk.gen.ts
+var sdk_gen_exports = /* @__PURE__ */ __exportAll({
+	accountGet: () => accountGet,
+	canvasArrange: () => canvasArrange,
+	canvasEdit: () => canvasEdit,
+	canvasGet: () => canvasGet,
+	canvasList: () => canvasList,
+	catalogSearch: () => catalogSearch,
+	mediaExport: () => mediaExport,
+	mediaImport: () => mediaImport,
+	mediaSearch: () => mediaSearch,
+	mediaView: () => mediaView,
+	runCancel: () => runCancel,
+	runGet: () => runGet,
+	runStart: () => runStart,
+	toolBuild: () => toolBuild,
+	toolSearch: () => toolSearch,
+	uploadFinish: () => uploadFinish,
+	uploadStart: () => uploadStart
+});
+/**
+* List canvases
+*
+* Canvases you can open, most recently edited first, with a link to each. Reuse one only when the user points to it; put new work on a new canvas, and never present results that were already there as new.
+*/
+const canvasList = (options) => (options?.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/canvas_list",
+	...options
+});
+/**
+* Read a canvas
+*
+* A compact view of a canvas: a summary, then pages of nodes (id, type, label, socket keys, literal values, result links) and their edges. On a big canvas, find nodes with search or read specific ones with nodeIds instead of paging through everything.
+*/
+const canvasGet = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/canvas_get",
+	...options
+});
+/**
+* Edit a canvas
+*
+* Apply a graph diff to a canvas all at once: add nodes and edges, change inputs, disconnect edges, delete nodes. Every change lands or none does. Keep each edit to about 30 new nodes; build a bigger canvas one section per edit, so a mistake costs one small resend.
+*/
+const canvasEdit = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/canvas_edit",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Arrange nodes on a canvas
+*
+* Lay out existing nodes with Fuser's layout instead of working out positions. Without layout it tidies them along their wiring, inputs to the left of what they feed; with layout it puts them in a row, column or grid in nodeIds order. Without an origin the block stays where the nodes are and slides clear of the nodes around it. Use it when the user asks to rearrange, line up or tidy nodes, or after resizing nodes that now overlap. It changes positions only.
+*/
+const canvasArrange = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/canvas_arrange",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Find node types
+*
+* Node types a canvas_edit diff may use, with what each is good at, its input ids and its output socket. Call it with no query first: it returns the recommended node for each common job. Search only when none of them fits.
+*/
+const catalogSearch = (options) => (options?.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/catalog_search",
+	...options
+});
+/**
+* Run a canvas
+*
+* Run the whole canvas or named nodes. Prices the run first and refuses it when it costs more than maxCredits; dryRun returns only the price. Starts a run once per idempotencyKey; check on it with run_get, not by calling run_start again.
+*/
+const runStart = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/run_start",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Check a run
+*
+* Status of a run you started, per node, with links to each node's results.
+*/
+const runGet = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/run_get",
+	...options
+});
+/**
+* Cancel a run
+*
+* Stop a run you started. Nodes already finished keep their results.
+*/
+const runCancel = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/run_cancel",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Import an image or video
+*
+* Copy an image or video from a public URL into the canvas's assets and get a Fuser link for it. Use it before putting a web link on the canvas: it says straight away when the link can't be fetched, and the copy won't expire. For a file on the user's machine use upload_start.
+*/
+const mediaImport = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/media_import",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Upload files
+*
+* Step 1 of putting files from the user's machine on a canvas, for agents that run commands on that machine (Claude Code, Codex, an IDE). List the files (up to 50): each comes back with a link to PUT it to, or done if Fuser already has it. Then call upload_finish with uploadId. In a chat app use upload_box instead; a cloud code sandbox can't reach these links.
+*/
+const uploadStart = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/upload_start",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Finish uploading files
+*
+* Step 2: returns a link for every file that arrived, to use as an ImageNode or VideoNode input, and says why for any that did not. For files the user is adding on the upload page, call it after they say they are done.
+*/
+const uploadFinish = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/upload_finish",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Look at media
+*
+* See Fuser images and 3D models as small previews, and the first frame of a video, with facts such as size, length and transparency. Look at results before describing or judging them.
+*/
+const mediaView = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/media_view",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Find your media
+*
+* Search the images, videos, audio and 3D files you made or uploaded, by meaning ("the coral reef image", "a dog running on a beach") or by similarity to one you have. Without query or similarTo it lists the newest first. Look at matches with media_view.
+*/
+const mediaSearch = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/media_search",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Download media as a zip
+*
+* A link that downloads a canvas's results as one zip file, for when the user wants their files ('download everything', 'send me the images as a zip'). Give the user the link; it works for an hour. It changes nothing on the canvas.
+*/
+const mediaExport = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/media_export",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Read your account
+*
+* Who you are, your personal credits and plan, and each workspace you belong to with your role, its plan, the team's credits and your monthly spend limit there. Runs on a workspace canvas spend that workspace's credits if you belong to it; runs on a personal canvas, or a workspace canvas shared with you from outside, spend yours.
+*/
+const accountGet = (options) => (options?.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/account_get",
+	...options
+});
+/**
+* Find a saved tool
+*
+* Search the canvas's tool library (tools you or your workspace built) and Fuser's featured tools by title and description. Place a match with tool_build toolId. Only worth it when a tool for the job likely exists; building a new one with tool_build prompt is fine too.
+*/
+const toolSearch = (options) => (options.client ?? client).get({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/tool_search",
+	...options
+});
+/**
+* Build a tool
+*
+* Turn a Tool node (type UtilityNode, added with canvas_edit) into a working tool: describe it in prompt and Fuser writes its code, or place a saved one with toolId. Tools do what generators can't: join, cut, trim or speed up videos, mix audio, crop, grid, filter, measure and convert between images, video, audio, 3D models, text and JSON (not PDF, ZIP or other files). Call it again with a prompt to change a built tool, or with neither to check on a build. Once built, wire its input sockets and set its controls with canvas_edit, then run it like any node; free tools cost nothing to run.
+*/
+const toolBuild = (options) => (options.client ?? client).post({
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v1/tool_build",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+//#endregion
+//#region src/pages.ts
+/**
+* A paged list: await it for the first page, or `for await` it for every
+* item on every page.
+*/
+var PagePromise = class {
+	#first;
+	#load;
+	#items;
+	constructor(load, items) {
+		this.#load = load;
+		this.#items = items;
+	}
+	#firstPage() {
+		this.#first ??= this.#load();
+		return this.#first;
+	}
+	then(onfulfilled, onrejected) {
+		return this.#firstPage().then(onfulfilled, onrejected);
+	}
+	async *pages() {
+		let page = await this.#firstPage();
+		yield page;
+		while (page.nextCursor) {
+			page = await this.#load(page.nextCursor);
+			yield page;
+		}
+	}
+	async *[Symbol.asyncIterator]() {
+		for await (const page of this.pages()) yield* this.#items(page);
+	}
+	/** Every item on every page. */
+	async all() {
+		const items = [];
+		for await (const item of this) items.push(item);
+		return items;
+	}
+};
+//#endregion
+//#region src/fuser.ts
+const OPERATIONS = {
+	accountGet: {
+		in: "query",
+		retry: "transient"
+	},
+	canvasArrange: {
+		in: "body",
+		retry: (args) => args.expectedRevision === void 0 ? "transient" : "rate-limit"
+	},
+	canvasEdit: {
+		in: "body",
+		retry: "transient"
+	},
+	canvasGet: {
+		in: "query",
+		retry: "transient"
+	},
+	canvasList: {
+		in: "query",
+		retry: "transient"
+	},
+	catalogSearch: {
+		in: "query",
+		retry: "transient"
+	},
+	mediaExport: {
+		in: "body",
+		retry: "transient"
+	},
+	mediaImport: {
+		in: "body",
+		retry: "rate-limit"
+	},
+	mediaSearch: {
+		in: "body",
+		retry: "transient"
+	},
+	mediaView: {
+		in: "body",
+		retry: "transient"
+	},
+	runCancel: {
+		in: "body",
+		retry: "transient"
+	},
+	runGet: {
+		in: "query",
+		retry: "transient"
+	},
+	runStart: {
+		in: "body",
+		retry: "transient"
+	},
+	toolBuild: {
+		in: "body",
+		retry: (args) => args.prompt || args.toolId ? "rate-limit" : "transient"
+	},
+	toolSearch: {
+		in: "query",
+		retry: "transient"
+	},
+	uploadFinish: {
+		in: "body",
+		retry: "transient"
+	},
+	uploadStart: {
+		in: "body",
+		retry: "transient"
+	}
+};
+const RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+/** upload_start takes at most this many files. */
+const MAX_UPLOAD_FILES = 50;
+/** The server holds a waiting call open at most this long. */
+const MAX_WAIT_SECONDS = 45;
+/** Runs answer sooner: the server waits at most this long on a run. */
+const RUN_WAIT_SECONDS = 10;
+/** A longer Retry-After is the caller's call, not ours to sleep through. */
+const MAX_RETRY_DELAY_MS = 6e4;
+var StartedCall = class {
+	started;
+	constructor(started) {
+		this.started = started;
+	}
+	then(onfulfilled, onrejected) {
+		return this.started.then(onfulfilled, onrejected);
+	}
+};
+/** `run.start()`: await for the start result, or `.wait()` for the finished run. */
+var RunCall = class extends StartedCall {
+	#wait;
+	constructor(started, wait) {
+		super(started);
+		this.#wait = wait;
+	}
+	/** The run once it stops running. Throws if it was refused or only priced. */
+	async wait(options) {
+		const timeoutMs = options?.timeoutMs ?? 18e5;
+		const startedAt = Date.now();
+		const result = await deadline(timeoutMs, options?.signal, "The run is still starting.", "run_start").guard(this.started);
+		if (result.status === "refused") throw new RunRefusedError(result.error, {
+			tool: "run_start",
+			reason: result.reason,
+			body: result
+		});
+		if (result.status === "quoted") throw new FuserError("A dry run only prices the run; nothing to wait for.", {
+			tool: "run_start",
+			body: result
+		});
+		if (result.run && result.run.status !== "running") return result.run;
+		return this.#wait(result.runId, {
+			signal: options?.signal,
+			timeoutMs: Math.max(timeoutMs - (Date.now() - startedAt), 1)
+		});
+	}
+};
+/** `tool.build()`: await for its state now, or `.wait()` until it's built. */
+var ToolBuildCall = class extends StartedCall {
+	#check;
+	constructor(started, check) {
+		super(started);
+		this.#check = check;
+	}
+	/** The tool once its build stops; check `status` for built or failed. */
+	async wait(options) {
+		const scope = deadline(options?.timeoutMs ?? 6e5, options?.signal, "The tool is still building.", "tool_build");
+		let state = await scope.guard(this.started);
+		while (state.status === "building") {
+			options?.signal?.throwIfAborted();
+			if (scope.expired()) throw scope.timeout();
+			state = await scope.guard(this.#check(scope.signal));
+		}
+		return state;
+	}
+};
+const toCamel = (name) => name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+const toSnake = (key) => key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(signal.reason);
+		return;
+	}
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(signal?.reason);
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+function base64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+const withSignal = (signal, other) => signal ? AbortSignal.any([signal, other]) : other;
+const mergeSignals = (first, second) => first && second ? AbortSignal.any([first, second]) : first ?? second;
+/** One deadline for a whole wait: every poll and retry shares its signal. */
+function deadline(timeoutMs, signal, message, tool) {
+	const timer = AbortSignal.timeout(timeoutMs);
+	const expired = () => timer.aborted && !signal?.aborted;
+	const timeout = (cause) => new TimeoutError(message, {
+		tool,
+		cause
+	});
+	return {
+		signal: withSignal(signal, timer),
+		expired,
+		timeout,
+		/** `work`, or a timeout or abort as soon as either fires, whichever is first. */
+		async guard(work) {
+			const combined = withSignal(signal, timer);
+			let stop = () => {};
+			const stopped = new Promise((_, reject) => {
+				stop = () => reject(expired() ? timeout() : signal?.reason ?? timeout());
+				if (combined.aborted) stop();
+				else combined.addEventListener("abort", stop, { once: true });
+			});
+			stopped.catch(() => void 0);
+			try {
+				return await Promise.race([work, stopped]);
+			} catch (error) {
+				throw expired() && !(error instanceof TimeoutError) ? timeout(error) : error;
+			} finally {
+				combined.removeEventListener("abort", stop);
+			}
+		}
+	};
+}
+/**
+* The Fuser API. Each tool is a method named after it: `canvas_edit` is
+* `fuser.canvas.edit()`, with the same arguments and result as the MCP tool.
+*/
+var Fuser = class {
+	client;
+	#fetch;
+	#timeoutMs;
+	#maxRetries;
+	account = { get: (_args, options) => this.#request("accountGet", void 0, options) };
+	canvas = {
+		/** Await for a page, or `for await` for every canvas. */
+		list: (args, options) => this.#pages("canvasList", args ?? {}, (page) => page.canvases, options),
+		/** Await for a page, or `for await` for every node. */
+		get: (args, options) => this.#pages("canvasGet", args, (page) => page.nodes, options),
+		/** `idempotencyKey` defaults to a new one per call. */
+		edit: (args, options) => this.#request("canvasEdit", args, options),
+		arrange: (args, options) => this.#request("canvasArrange", args, options)
+	};
+	catalog = { search: (args, options) => this.#request("catalogSearch", args ?? {}, options) };
+	run = {
+		/** `idempotencyKey` defaults to a new one per call. Add `.wait()` to wait. */
+		start: (args, options) => new RunCall(this.#request("runStart", args, options), (runId, waitOptions) => this.#waitForRun({
+			canvasId: args.canvasId,
+			runId
+		}, {
+			...waitOptions,
+			signal: mergeSignals(options?.signal, waitOptions?.signal)
+		})),
+		get: (args, options) => this.#request("runGet", args, options),
+		cancel: (args, options) => this.#request("runCancel", args, options),
+		/** Checks a run until it stops running. */
+		wait: (args, options) => this.#waitForRun(args, options)
+	};
+	media = {
+		export: (args, options) => this.#request("mediaExport", args, options),
+		import: (args, options) => this.#request("mediaImport", args, options),
+		/** Await for a page, or `for await` for every match. */
+		search: (args, options) => this.#pages("mediaSearch", args, (page) => page.assets, options),
+		view: (args, options) => this.#request("mediaView", args, options)
+	};
+	upload = {
+		start: (args, options) => this.#request("uploadStart", args, options),
+		finish: (args, options) => this.#request("uploadFinish", args, options),
+		/** Hashes, starts, sends and finishes in one call. */
+		files: (canvasId, files, options) => this.#uploadFiles(canvasId, files, options)
+	};
+	tool = {
+		search: (args, options) => this.#request("toolSearch", args, options),
+		/** Add `.wait()` to wait until it's built. */
+		build: (args, options) => {
+			const { canvasId, nodeId } = args;
+			return new ToolBuildCall(this.#request("toolBuild", args, options), (signal) => this.#request("toolBuild", {
+				canvasId,
+				nodeId,
+				waitSeconds: MAX_WAIT_SECONDS
+			}, {
+				...options,
+				...signal ? { signal: withSignal(options?.signal, signal) } : {}
+			}));
+		}
+	};
+	constructor(options = {}) {
+		const apiKey = options.apiKey ?? globalThis.process?.env?.FUSER_API_KEY;
+		if ("document" in globalThis && "window" in globalThis && !options.dangerouslyAllowBrowser) throw new FuserError("A Fuser API key acts as you, so keep it on a server. Pass dangerouslyAllowBrowser to use it in a browser anyway.", { tool: "client" });
+		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.#timeoutMs = options.timeoutMs ?? 6e4;
+		this.#maxRetries = options.maxRetries ?? 2;
+		this.client = createClient({
+			baseUrl: options.baseUrl ?? "https://api.fuser.studio",
+			fetch: this.#fetch,
+			auth: (scheme) => scheme.scheme === "bearer" ? apiKey : void 0
+		});
+		const { beforeSend, afterSend } = options;
+		if (beforeSend) this.client.interceptors.request.use(async (request) => await beforeSend(request) ?? request);
+		if (afterSend) this.client.interceptors.response.use(async (response, request) => {
+			await afterSend(response, request);
+			return response;
+		});
+	}
+	/** Calls a tool by its MCP name, with the exact arguments an agent sent. */
+	call(name, args, options) {
+		return this.#request(toCamel(name), args, options);
+	}
+	#pages(key, args, items, options) {
+		return new PagePromise(async (cursor) => await this.#request(key, {
+			...args,
+			cursor: cursor ?? args.cursor
+		}, options), items);
+	}
+	async #waitForRun(args, options) {
+		const scope = deadline(options?.timeoutMs ?? 18e5, options?.signal, `Run ${args.runId} is still running.`, "run_get");
+		for (;;) {
+			const summary = await scope.guard(this.run.get({
+				...args,
+				waitSeconds: RUN_WAIT_SECONDS
+			}, { signal: scope.signal }));
+			if (summary.status !== "running") return summary;
+			options?.signal?.throwIfAborted();
+			if (scope.expired()) throw scope.timeout();
+		}
+	}
+	async #uploadFiles(canvasId, inputs, options) {
+		const uploaded = [];
+		for (let start = 0; start < inputs.length; start += MAX_UPLOAD_FILES) uploaded.push(...await this.#uploadBatch(canvasId, inputs.slice(start, start + MAX_UPLOAD_FILES), options));
+		return uploaded;
+	}
+	async #uploadBatch(canvasId, inputs, options) {
+		const prepared = await Promise.all(inputs.map(async (input) => {
+			const bytes = input.data instanceof Blob ? new Uint8Array(await input.data.arrayBuffer()) : new Uint8Array(input.data);
+			const contentType = input.contentType || (input.data instanceof Blob ? input.data.type : "");
+			if (!contentType) throw new FuserError(`${input.fileName} needs a contentType.`, { tool: "upload_start" });
+			const digest = await crypto.subtle.digest("SHA-256", bytes);
+			return {
+				bytes,
+				file: {
+					fileName: input.fileName,
+					contentType,
+					size: bytes.byteLength,
+					sha256: base64(new Uint8Array(digest))
+				}
+			};
+		}));
+		const started = await this.upload.start({
+			canvasId,
+			files: prepared.map((item) => item.file)
+		}, options);
+		const sent = /* @__PURE__ */ new Set();
+		const putErrors = [];
+		await Promise.all(started.files.map(async (file, index) => {
+			if (file.status === "done" || sent.has(file.url)) return;
+			sent.add(file.url);
+			const timeout = AbortSignal.timeout(options?.timeoutMs ?? this.#timeoutMs);
+			try {
+				const response = await this.#fetch(file.url, {
+					method: file.method,
+					headers: file.headers,
+					body: prepared[index].bytes,
+					signal: withSignal(options?.signal, timeout)
+				});
+				if (!response.ok && response.status !== 412) putErrors[index] = `Uploading ${file.fileName} failed (HTTP ${String(response.status)}).`;
+			} catch {
+				options?.signal?.throwIfAborted();
+				putErrors[index] = timeout.aborted ? `Uploading ${file.fileName} timed out.` : `Uploading ${file.fileName} failed: the connection dropped.`;
+			}
+		}));
+		return (await this.upload.finish({ uploadId: started.uploadId }, options)).files.map((file, index) => file.status === "failed" && putErrors[index] ? {
+			...file,
+			error: putErrors[index]
+		} : file);
+	}
+	async #request(key, args, options = {}) {
+		const tool = toSnake(key);
+		const operation = OPERATIONS[key];
+		const policy = typeof operation.retry === "function" ? operation.retry(args) : operation.retry;
+		const body = key === "canvasEdit" || key === "runStart" && !args.dryRun ? {
+			...args,
+			idempotencyKey: args.idempotencyKey ?? crypto.randomUUID()
+		} : args;
+		const send = sdk_gen_exports[key];
+		const waitSeconds = Math.min(args?.waitSeconds ?? (key === "toolBuild" ? MAX_WAIT_SECONDS : 0), MAX_WAIT_SECONDS);
+		const timeoutMs = (options.timeoutMs ?? this.#timeoutMs) + waitSeconds * 1e3;
+		const maxRetries = options.maxRetries ?? this.#maxRetries;
+		for (let attempt = 0;; attempt++) {
+			const timeout = AbortSignal.timeout(timeoutMs);
+			const result = await send({
+				client: this.client,
+				...body === void 0 ? {} : { [operation.in]: body },
+				...options.headers ? { headers: options.headers } : {},
+				signal: withSignal(options.signal, timeout)
+			});
+			if (result.error === void 0 && result.response?.ok) return result.data;
+			options.signal?.throwIfAborted();
+			const error = result.response && !result.response.ok ? errorFromResponse(tool, result.response, result.error) : timeout.aborted ? new TimeoutError(`${tool} timed out.`, {
+				tool,
+				cause: result.error
+			}) : new ConnectionError(`${tool} could not reach Fuser.`, {
+				tool,
+				cause: result.error
+			});
+			const retryable = error.status === void 0 ? policy === "transient" : policy === "transient" ? RETRYABLE_STATUSES.has(error.status) : error.status === 429;
+			const delay = error.retryAfterMs ?? Math.min(8e3, 500 * 2 ** attempt) * (.75 + Math.random() / 2);
+			if (!retryable || attempt >= maxRetries || delay > MAX_RETRY_DELAY_MS) throw error;
+			await sleep(delay, options.signal);
+		}
+	}
+};
+//#endregion
+export { AuthenticationError, BadRequestError, ConflictError, ConnectionError, Fuser, FuserError, InternalServerError, NotFoundError, PagePromise, PermissionDeniedError, RateLimitError, RunCall, RunRefusedError, TimeoutError, ToolBuildCall };
+
+//# sourceMappingURL=index.js.map