@bike4mind/cli 2.1.0 → 3.0.0

package/dist/dist-BsG2Hlp-.mjs

@@ -0,0 +1,739 @@
+#!/usr/bin/env node
+import { _ as logger, f as AuthenticatedApiClient, p as DeviceFlowClient, t as ConfigStore } from "./ConfigStore-51UaP9pJ.mjs";
+import { t as version } from "./package-DEsNSP54.mjs";
+import { isAxiosError } from "axios";
+import { Readable } from "node:stream";
+import { createParser } from "eventsource-parser";
+//#region src/auth/OAuthClient.ts
+/**
+* The CLI's RFC 8628 `client_id`; the desktop app registers under its own. Typed against the
+* server allowlist so dropping this id there fails this build rather than this client's logins
+* (see OAUTH_DEVICE_CLIENT_IDS).
+*/
+const CLI_OAUTH_CLIENT_ID = "b4m-cli";
+/**
+* The shared device-flow client, pinned to the CLI's registration.
+*/
+var OAuthClient = class extends DeviceFlowClient {
+	constructor(baseURL = "http://localhost:3000") {
+		super({
+			baseUrl: baseURL,
+			clientId: CLI_OAUTH_CLIENT_ID
+		});
+	}
+};
+//#endregion
+//#region src/auth/providerKeyFailure.ts
+const PROVIDER_KEY_ERROR_CODES = /* @__PURE__ */ new Set(["provider_not_configured", "provider_rejected"]);
+/**
+* A 401 whose body names a missing or rejected AI-provider key (e.g. /api/ai/tts). The
+* Bike4Mind credential was accepted, so refreshing or re-authenticating cannot fix it.
+* Shared by the ApiClient refresh interceptor and mapApiError in mcp/b4mApiClient.ts.
+*/
+function isProviderKeyFailure(data) {
+	const body = decodeBinaryBody(data);
+	if (!body || typeof body !== "object") return false;
+	const { errorCode } = body;
+	return typeof errorCode === "string" && PROVIDER_KEY_ERROR_CODES.has(errorCode);
+}
+/**
+* An arraybuffer-typed request (every @bike4mind/sdk call, through ApiClient.fetch) gets its
+* error body as raw bytes, and the refresh interceptor sees it before any caller can decode it.
+*/
+function decodeBinaryBody(data) {
+	const bytes = data instanceof ArrayBuffer ? Buffer.from(data) : ArrayBuffer.isView(data) ? Buffer.from(data.buffer, data.byteOffset, data.byteLength) : void 0;
+	if (!bytes) return data;
+	try {
+		return JSON.parse(bytes.toString("utf8"));
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/auth/ApiClient.ts
+const USER_AGENT = `b4m-cli/${version}`;
+/**
+* Per-request timeout. Generous by design: a waited chat (POST /api/chat with wait:true)
+* runs a full server-side quest, so the bound only exists to stop a hung backend from
+* wedging a caller forever, not to cap a normal long quest. Override with B4M_API_TIMEOUT_MS
+* (0 disables the timeout entirely).
+*/
+const DEFAULT_API_TIMEOUT_MS = 6e5;
+function resolveTimeoutMs() {
+	const raw = process.env.B4M_API_TIMEOUT_MS;
+	if (raw === void 0 || raw.trim() === "") return DEFAULT_API_TIMEOUT_MS;
+	const parsed = Number(raw);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_API_TIMEOUT_MS;
+}
+/**
+* The shared authenticated client, wired to the CLI's storage, logger and branding.
+*/
+var ApiClient = class extends AuthenticatedApiClient {
+	/**
+	* @param apiKey - When set, requests authenticate with this instance API key via
+	*   the `x-api-key` header and the OAuth-JWT path (Bearer injection + refresh-on-401)
+	*   is bypassed entirely. Omit to keep the default stored-JWT behavior unchanged.
+	*/
+	constructor(baseURL = "http://localhost:3000", configStore, apiKey) {
+		super({
+			baseUrl: baseURL,
+			tokenStore: configStore || new ConfigStore(),
+			oauthClient: new OAuthClient(baseURL),
+			logger,
+			apiKey,
+			timeoutMs: resolveTimeoutMs(),
+			headers: {
+				"User-Agent": USER_AGENT,
+				"X-B4M-Client": USER_AGENT
+			},
+			reauthMessages: {
+				refreshFailed: "Authentication expired. Please run `b4m login` again.",
+				stillUnauthorized: "Authentication failed. Please run /login to authenticate.",
+				notLoggedIn: "Authentication failed: not logged in. Please run `b4m login` to authenticate."
+			},
+			isPassThrough401: isProviderKeyFailure
+		});
+		this.fetch = async (input, init = {}) => {
+			const headers = Object.fromEntries(new Headers(init.headers));
+			try {
+				return toFetchResponse(await this.getAxiosInstance().request({
+					url: input instanceof Request ? input.url : String(input),
+					method: init.method ?? "GET",
+					headers,
+					data: init.body ?? void 0,
+					signal: init.signal ?? void 0,
+					responseType: /text\/event-stream/i.test(headers.accept ?? "") ? "stream" : "arraybuffer",
+					...init.redirect && init.redirect !== "follow" ? { maxRedirects: 0 } : {}
+				}));
+			} catch (error) {
+				if (isAxiosError(error) && error.response) return toFetchResponse(error.response);
+				throw error;
+			}
+		};
+	}
+	get baseURL() {
+		return this.getAxiosInstance().defaults.baseURL ?? "";
+	}
+};
+function toFetchResponse(response) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(response.headers)) if (value !== void 0 && value !== null) headers.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+	const body = [
+		101,
+		204,
+		205,
+		304
+	].includes(response.status) ? null : response.data instanceof Readable ? Readable.toWeb(response.data) : response.data;
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+//#region ../sdk/dist/index.mjs
+/**
+* A non-2xx response. `message` is the envelope's `error` (`ErrorResponse` in the spec); branch on `status` and
+* `errorCode`, never on the prose. The deprecated `name` field is deliberately not surfaced.
+*/
+var B4mApiError = class B4mApiError extends Error {
+	status;
+	errorCode;
+	requestId;
+	retryAfterSeconds;
+	body;
+	headers;
+	constructor(status, body, headers) {
+		const record = body && typeof body === "object" ? body : {};
+		super(typeof record.error === "string" ? record.error : `HTTP ${status}`);
+		this.name = "B4mApiError";
+		this.status = status;
+		this.body = body;
+		this.headers = headers;
+		if (typeof record.errorCode === "string") this.errorCode = record.errorCode;
+		const requestId = typeof record.request_id === "string" ? record.request_id : headers.get("x-request-id");
+		if (requestId) this.requestId = requestId;
+		const retryAfterSeconds = parseRetryAfterSeconds(headers.get("retry-after"));
+		if (retryAfterSeconds !== void 0) this.retryAfterSeconds = retryAfterSeconds;
+	}
+	static async fromResponse(response) {
+		const text = await response.text().catch(() => "");
+		let body = text;
+		try {
+			body = JSON.parse(text);
+		} catch {}
+		return new B4mApiError(response.status, body, response.headers);
+	}
+};
+/**
+* A completions stream that closed without `[DONE]` and without an `error` event: the connection was cut
+* mid-response, so nothing about the request itself failed. Safe to retry when no output was used yet.
+*/
+var B4mStreamEndedError = class extends Error {
+	constructor() {
+		super("completion stream ended before [DONE]");
+		this.name = "B4mStreamEndedError";
+	}
+};
+/**
+* A polled quest (chat turn, image generation or edit) that did not succeed: it carries `type: "error"`
+* (`reason: 'error'`), ended `stopped` (`'stopped'`), or was still running when the poll's `timeoutMs` ran out
+* (`'timeout'`). `quest` is the last state seen; its `reply` carries the server's explanation.
+*/
+var B4mQuestError = class extends Error {
+	reason;
+	quest;
+	constructor(reason, quest) {
+		super(reason === "timeout" ? `quest ${quest.id} still ${quest.status ?? "pending"} when the poll timed out` : quest.reply ?? `quest ${quest.id} ${reason === "error" ? "failed" : "was stopped"}`);
+		this.name = "B4mQuestError";
+		this.reason = reason;
+		this.quest = quest;
+	}
+};
+/**
+* Normalize a Retry-After header (RFC 7231: delta-seconds or an HTTP-date) to whole, non-negative seconds;
+* undefined when absent or unparseable.
+*/
+function parseRetryAfterSeconds(value) {
+	if (value === void 0 || value === null) return void 0;
+	const raw = String(value).trim();
+	if (/^\d+$/.test(raw)) return Number(raw);
+	const dateMs = Date.parse(raw);
+	if (Number.isNaN(dateMs)) return void 0;
+	return Math.max(0, Math.ceil((dateMs - Date.now()) / 1e3));
+}
+const operations = {
+	addDataLakeFile: {
+		method: "POST",
+		path: "/api/v1/data-lakes/{id}/files/{file_id}"
+	},
+	cancelMusicGeneration: {
+		method: "POST",
+		path: "/api/v1/music-generations/{id}/cancel"
+	},
+	cancelVideoGeneration: {
+		method: "POST",
+		path: "/api/v1/video-generations/{id}/cancel"
+	},
+	cloneSession: {
+		method: "POST",
+		path: "/api/v1/sessions/{id}/clone"
+	},
+	createAgent: {
+		method: "POST",
+		path: "/api/v1/agents"
+	},
+	createArtifact: {
+		method: "POST",
+		path: "/api/v1/artifacts"
+	},
+	createCompletion: {
+		method: "POST",
+		path: "/api/ai/v1/completions"
+	},
+	createDecision: {
+		method: "POST",
+		path: "/api/v1/decisions"
+	},
+	createEmbeddings: {
+		method: "POST",
+		path: "/api/v1/embeddings"
+	},
+	createFileUpload: {
+		method: "POST",
+		path: "/api/v1/files"
+	},
+	createMusicGeneration: {
+		method: "POST",
+		path: "/api/v1/music-generations"
+	},
+	createProject: {
+		method: "POST",
+		path: "/api/v1/projects"
+	},
+	createSession: {
+		method: "POST",
+		path: "/api/v1/sessions"
+	},
+	createTranscription: {
+		method: "POST",
+		path: "/api/v1/transcriptions"
+	},
+	createTranscriptionUpload: {
+		method: "POST",
+		path: "/api/v1/transcriptions/uploads"
+	},
+	createVideoGeneration: {
+		method: "POST",
+		path: "/api/v1/video-generations"
+	},
+	createVoiceSession: {
+		method: "POST",
+		path: "/api/v1/voice/sessions"
+	},
+	deleteAgent: {
+		method: "DELETE",
+		path: "/api/v1/agents/{id}"
+	},
+	deleteArtifact: {
+		method: "DELETE",
+		path: "/api/v1/artifacts/{id}"
+	},
+	deleteFile: {
+		method: "DELETE",
+		path: "/api/v1/files/{id}"
+	},
+	deleteProject: {
+		method: "DELETE",
+		path: "/api/v1/projects/{id}"
+	},
+	deleteSession: {
+		method: "DELETE",
+		path: "/api/sessions/{id}"
+	},
+	editImage: {
+		method: "POST",
+		path: "/api/v1/image-edits"
+	},
+	endVoiceSession: {
+		method: "POST",
+		path: "/api/v1/voice/sessions/{id}/end"
+	},
+	executeTool: {
+		method: "POST",
+		path: "/api/ai/v1/tools"
+	},
+	generateImage: {
+		method: "POST",
+		path: "/api/v1/image-generations"
+	},
+	generateMusic: {
+		method: "POST",
+		path: "/api/ai/music"
+	},
+	generateSoundEffect: {
+		method: "POST",
+		path: "/api/ai/sound-effects"
+	},
+	getAgent: {
+		method: "GET",
+		path: "/api/v1/agents/{id}"
+	},
+	getAgentExecution: {
+		method: "GET",
+		path: "/api/v1/agent-executions/{id}"
+	},
+	getArtifact: {
+		method: "GET",
+		path: "/api/v1/artifacts/{id}"
+	},
+	getArtifactVersion: {
+		method: "GET",
+		path: "/api/v1/artifacts/{id}/versions/{version}"
+	},
+	getCreditBalance: {
+		method: "GET",
+		path: "/api/v1/credits"
+	},
+	getDataLake: {
+		method: "GET",
+		path: "/api/v1/data-lakes/{id}"
+	},
+	getDataLakeFile: {
+		method: "GET",
+		path: "/api/v1/data-lakes/{id}/files/{file_id}"
+	},
+	getFile: {
+		method: "GET",
+		path: "/api/v1/files/{id}"
+	},
+	getMe: {
+		method: "GET",
+		path: "/api/v1/me"
+	},
+	getMusicGeneration: {
+		method: "GET",
+		path: "/api/v1/music-generations/{id}"
+	},
+	getProject: {
+		method: "GET",
+		path: "/api/v1/projects/{id}"
+	},
+	getQuest: {
+		method: "GET",
+		path: "/api/v1/quests/{id}"
+	},
+	getSession: {
+		method: "GET",
+		path: "/api/sessions/{id}"
+	},
+	getVideoGeneration: {
+		method: "GET",
+		path: "/api/v1/video-generations/{id}"
+	},
+	listAgents: {
+		method: "GET",
+		path: "/api/v1/agents"
+	},
+	listArtifactVersions: {
+		method: "GET",
+		path: "/api/v1/artifacts/{id}/versions"
+	},
+	listArtifacts: {
+		method: "GET",
+		path: "/api/v1/artifacts"
+	},
+	listDataLakes: {
+		method: "GET",
+		path: "/api/v1/data-lakes"
+	},
+	listDecisionModels: {
+		method: "GET",
+		path: "/api/v1/decision-models"
+	},
+	listFiles: {
+		method: "GET",
+		path: "/api/v1/files"
+	},
+	listModels: {
+		method: "GET",
+		path: "/api/v1/models"
+	},
+	listMusicGenerations: {
+		method: "GET",
+		path: "/api/v1/music-generations"
+	},
+	listMusicModels: {
+		method: "GET",
+		path: "/api/v1/music-models"
+	},
+	listProjects: {
+		method: "GET",
+		path: "/api/v1/projects"
+	},
+	listQuestFiles: {
+		method: "GET",
+		path: "/api/v1/quests/{id}/files"
+	},
+	listSessions: {
+		method: "GET",
+		path: "/api/v1/sessions"
+	},
+	listVideoGenerations: {
+		method: "GET",
+		path: "/api/v1/video-generations"
+	},
+	listVideoModels: {
+		method: "GET",
+		path: "/api/v1/video-models"
+	},
+	listVoices: {
+		method: "GET",
+		path: "/api/v1/voice/voices"
+	},
+	listWhatsNew: {
+		method: "GET",
+		path: "/api/v1/whats-new"
+	},
+	removeDataLakeFile: {
+		method: "DELETE",
+		path: "/api/v1/data-lakes/{id}/files/{file_id}"
+	},
+	searchDataLake: {
+		method: "POST",
+		path: "/api/v1/data-lakes/{id}/search"
+	},
+	sendChatMessage: {
+		method: "POST",
+		path: "/api/chat"
+	},
+	startAgentExecution: {
+		method: "POST",
+		path: "/api/v1/agent-executions"
+	},
+	synthesizeSpeech: {
+		method: "POST",
+		path: "/api/ai/tts"
+	},
+	updateAgent: {
+		method: "PATCH",
+		path: "/api/v1/agents/{id}"
+	},
+	updateArtifact: {
+		method: "PATCH",
+		path: "/api/v1/artifacts/{id}"
+	},
+	updateFile: {
+		method: "PATCH",
+		path: "/api/v1/files/{id}"
+	},
+	updateProject: {
+		method: "PATCH",
+		path: "/api/v1/projects/{id}"
+	},
+	updateSession: {
+		method: "PUT",
+		path: "/api/sessions/{id}"
+	}
+};
+/**
+* Yield each server-sent event's `data` from a fetch body, until `[DONE]`, the end of the stream, or `signal`
+* aborts (which throws the signal's reason). `onDone` is called when `[DONE]` is seen, so a caller can tell it
+* from a truncated stream. Breaking out of the loop early cancels the body.
+*/
+async function* parseSse(body, signal, onDone) {
+	const queue = [];
+	const parser = createParser({ onEvent: (event) => queue.push(event.data) });
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const onAbort = () => void reader.cancel().catch(() => {});
+	signal?.addEventListener("abort", onAbort, { once: true });
+	let finished = false;
+	try {
+		for (;;) {
+			signal?.throwIfAborted();
+			const { done, value } = await reader.read();
+			signal?.throwIfAborted();
+			parser.feed(done ? decoder.decode() : decoder.decode(value, { stream: true }));
+			while (queue.length > 0) {
+				const data = queue.shift();
+				if (data === "[DONE]") {
+					onDone?.();
+					return;
+				}
+				yield data;
+			}
+			if (done) {
+				finished = true;
+				return;
+			}
+		}
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+		if (!finished) await reader.cancel().catch(() => {});
+	}
+}
+const ABSOLUTE_URL = /^https?:\/\//i;
+function buildUrl(baseUrl, path, params, query) {
+	const values = params ?? {};
+	const resolved = path.replace(/\{([^}]+)\}/g, (_, name) => {
+		const value = values[name];
+		if (value === void 0 || value === null || value === "" || value === "." || value === "..") throw new Error(`Invalid path parameter ${name}: ${JSON.stringify(value)}`);
+		return encodeURIComponent(String(value));
+	});
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(query ?? {})) for (const item of Array.isArray(value) ? value : [value]) if (item !== void 0 && item !== null) search.append(key, String(item));
+	const qs = search.toString();
+	const relative = resolved.startsWith("/") ? resolved : `/${resolved}`;
+	const url = ABSOLUTE_URL.test(resolved) ? resolved : `${baseUrl.replace(/\/+$/, "")}${relative}`;
+	return qs ? `${url}${url.includes("?") ? "&" : "?"}${qs}` : url;
+}
+function assertBaseUrl(baseUrl) {
+	let parsed;
+	try {
+		parsed = new URL(baseUrl);
+	} catch {
+		throw new Error(`createClient: baseUrl must be an absolute http(s) URL, got ${JSON.stringify(baseUrl)}`);
+	}
+	if (!/^https?:$/.test(parsed.protocol) || parsed.search || parsed.hash) throw new Error(`createClient: baseUrl must be an http(s) URL with no query or fragment, got ${JSON.stringify(baseUrl)}`);
+}
+function createClient(options) {
+	if (!options.baseUrl) throw new Error("createClient: baseUrl is required");
+	assertBaseUrl(options.baseUrl);
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	async function send(method, path, args = {}) {
+		const headers = new Headers(options.headers);
+		for (const [name, value] of Object.entries(args.headers ?? {})) headers.set(name, value);
+		const token = await options.getAuthToken?.() || options.apiKey;
+		if (token) headers.set("authorization", `Bearer ${token}`);
+		let body;
+		if (args.body !== void 0) {
+			headers.set("content-type", "application/json");
+			body = JSON.stringify(args.body);
+		}
+		const response = await fetchImpl(buildUrl(options.baseUrl, path, args.params, args.query), {
+			method,
+			headers,
+			body,
+			signal: args.signal,
+			...args.redirect ? { redirect: args.redirect } : {}
+		});
+		if (!response.ok) throw await B4mApiError.fromResponse(response);
+		return response;
+	}
+	/** Any spec operation, returning the raw 2xx `Response` (for binary or streamed bodies). Non-2xx throws. */
+	function raw(operationId, ...[args]) {
+		const { method, path } = operations[operationId];
+		return send(method, path, args);
+	}
+	/** Any spec operation, typed from the spec; returns the parsed JSON body (`undefined` for an empty one). A non-JSON 2xx body throws. */
+	async function call(operationId, ...rest) {
+		const response = await raw(operationId, ...rest);
+		const text = await response.text();
+		const contentType = response.headers.get("content-type") ?? "";
+		if (text && !/json/i.test(contentType)) throw new Error(`${operationId} returned ${contentType || "a non-JSON body"}; use raw(), completions() or the tts/music/soundEffects helpers`);
+		return text ? JSON.parse(text) : void 0;
+	}
+	async function pollQuest(questId, poll = {}) {
+		const { intervalMs = 1e3, maxIntervalMs = 5e3, timeoutMs, signal } = poll;
+		const deadline = timeoutMs === void 0 ? void 0 : Date.now() + timeoutMs;
+		let delay = intervalMs;
+		for (;;) {
+			const quest = await call("getQuest", {
+				params: { id: questId },
+				signal
+			});
+			if (quest.status === "stopped") throw new B4mQuestError("stopped", quest);
+			if (quest.type === "error") throw new B4mQuestError("error", quest);
+			if (quest.status === "done") return quest;
+			if (deadline !== void 0 && Date.now() + delay > deadline) throw new B4mQuestError("timeout", quest);
+			await sleep(delay, signal);
+			delay = Math.min(delay * 1.5, maxIntervalMs);
+		}
+	}
+	const questHandle = (questId, ack) => ({
+		questId,
+		ack,
+		poll: (poll) => pollQuest(questId, poll)
+	});
+	async function audio(operationId, body, signal) {
+		const { method, path } = operations[operationId];
+		const response = await send(method, path, {
+			body: {
+				...body,
+				encoding: "base64"
+			},
+			signal
+		});
+		const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+		if (/json/i.test(contentType)) return await response.json();
+		const saved = response.headers.get("x-b4m-audio-saved") === "true";
+		const header = (name) => saved ? response.headers.get(name) ?? void 0 : void 0;
+		const result = {
+			delivery: "inline",
+			audio: toBase64(new Uint8Array(await response.arrayBuffer())),
+			contentType,
+			saved
+		};
+		const fabFileId = header("x-b4m-audio-fab-file-id");
+		const fileName = header("x-b4m-audio-file-name");
+		const fileUrl = header("x-b4m-audio-file-url");
+		if (fabFileId) result.fabFileId = fabFileId;
+		if (fileName) result.fileName = fileName;
+		if (fileUrl) result.fileUrl = fileUrl;
+		return result;
+	}
+	return {
+		call,
+		raw,
+		/**
+		* Stream `POST /api/ai/v1/completions` as parsed events. A non-2xx before the stream throws `B4mApiError`; a
+		* server `{ type: 'error' }` event is yielded, not thrown. A stream that ends without `[DONE]` and without an
+		* error event throws. `url` overrides the path: an absolute http(s) URL is used as-is, anything else is joined
+		* under `baseUrl`. An absolute `url` receives the same `Authorization` header, so pass only an origin you trust.
+		*/
+		async *completions(body, opts = {}) {
+			const response = await send("POST", opts.url ?? operations.createCompletion.path, {
+				body,
+				signal: opts.signal,
+				headers: {
+					accept: "text/event-stream",
+					...opts.headers
+				}
+			});
+			if (!response.body) return;
+			let sawDone = false;
+			let sawError = false;
+			for await (const data of parseSse(response.body, opts.signal, () => {
+				sawDone = true;
+			})) {
+				let event;
+				try {
+					event = JSON.parse(data);
+				} catch {
+					continue;
+				}
+				if (event.type === "error") sawError = true;
+				yield event;
+			}
+			if (!sawDone && !sawError) throw new B4mStreamEndedError();
+		},
+		/** `POST /api/chat`, queued (the default): the turn's outcome is on the returned handle's `poll()`. */
+		async chat(body, opts = {}) {
+			const ack = await call("sendChatMessage", {
+				body,
+				signal: opts.signal
+			});
+			return questHandle(ack.id, ack);
+		},
+		async generateImage(body, opts = {}) {
+			const ack = await call("generateImage", {
+				body,
+				signal: opts.signal
+			});
+			return questHandle(ack.quest.id, ack);
+		},
+		/** Edited images arrive on the finished quest's `files[].url`. */
+		async editImage(body, opts = {}) {
+			const ack = await call("editImage", {
+				body,
+				signal: opts.signal
+			});
+			return questHandle(ack.id, ack);
+		},
+		pollQuest,
+		async tts(body, opts = {}) {
+			try {
+				return {
+					kind: "audio",
+					data: await audio("synthesizeSpeech", body, opts.signal)
+				};
+			} catch (error) {
+				const tooLarge = error instanceof B4mApiError && error.status === 413 ? error : void 0;
+				const data = tooLarge?.body;
+				if (!tooLarge || !data?.saved || typeof data.fabFileId !== "string" || typeof data.provider !== "string") throw error;
+				const fallbackFrom = tooLarge.headers.get("x-b4m-tts-provider-fallback-from");
+				const result = {
+					kind: "saved-too-large",
+					data: {
+						...data,
+						fabFileId: data.fabFileId
+					}
+				};
+				if (fallbackFrom) result.fallbackFrom = fallbackFrom;
+				return result;
+			}
+		},
+		/**
+		* @deprecated `POST /api/ai/music` sunsets 2027-01-15. Queue a job with
+		* `call('createMusicGeneration', ...)` and poll `getMusicGeneration` instead.
+		*/
+		music(body, opts = {}) {
+			return audio("generateMusic", body, opts.signal);
+		},
+		soundEffects(body, opts = {}) {
+			return audio("generateSoundEffect", body, opts.signal);
+		}
+	};
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(signal.reason);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function toBase64(bytes) {
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(binary);
+}
+//#endregion
+export { ApiClient as a, parseRetryAfterSeconds as i, B4mStreamEndedError as n, isProviderKeyFailure as o, createClient as r, OAuthClient as s, B4mApiError as t };