@bike4mind/sdk 0.0.0-stage → 1.1.1

package/dist/index.mjs

@@ -0,0 +1,613 @@
+import { createParser } from "eventsource-parser";
+//#region src/errors.ts
+/**
+* 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));
+}
+//#endregion
+//#region src/generated/operations.ts
+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}"
+	}
+};
+//#endregion
+//#region src/sse.ts
+/**
+* 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(() => {});
+	}
+}
+//#endregion
+//#region src/client.ts
+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 { B4mApiError, B4mQuestError, B4mStreamEndedError, createClient, operations, parseRetryAfterSeconds };

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@bike4mind/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.1",
+  "description": "Typed client for the Bike4Mind HTTP API, generated from its OpenAPI spec",
+  "license": "BUSL-1.1",
+  "author": "Bike4Mind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bike4Mind/bike4mind.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://github.com/bike4mind/bike4mind/tree/main/packages/sdk#readme",
+  "bugs": "https://github.com/bike4mind/bike4mind/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "bike4mind",
+    "api",
+    "sdk",
+    "openapi"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "generate": "node scripts/generate.mjs",
+    "typecheck": "tsc --noEmit",
+    "typecheck:fast": "tsgo --noEmit --types node || tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "eventsource-parser": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "openapi-typescript": "^7.13.0",
+    "prettier": "^3.9.6",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11"
+  }
+}