@neta-art/cohub 1.9.0 → 1.10.0

package/dist/chunks/http.js

@@ -0,0 +1,1919 @@
+import { i as resolveApiBaseUrl } from "./environment.js";
+//#region src/apis/channels.ts
+var ChannelsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	list(customFetch) {
+		return this.transport.request("/api/channels", {
+			method: "GET",
+			fetch: customFetch
+		});
+	}
+	create(data) {
+		return this.transport.request("/api/channels", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(data)
+		});
+	}
+	delete(id) {
+		return this.transport.request(`/api/channels/${id}`, { method: "DELETE" });
+	}
+};
+//#endregion
+//#region src/apis/cron-jobs.ts
+var CronJobsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	list(spaceId) {
+		const query = spaceId ? `?spaceId=${encodeURIComponent(spaceId)}` : "";
+		return this.transport.request(`/api/cron-jobs${query}`);
+	}
+	delete(id) {
+		return this.transport.request(`/api/cron-jobs/${id}`, { method: "DELETE" });
+	}
+	toggle(id, enabled) {
+		return this.transport.request(`/api/cron-jobs/${id}`, {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ enabled })
+		});
+	}
+	runs(cronJobId) {
+		return this.transport.request(`/api/cron-jobs/${cronJobId}/runs`);
+	}
+};
+//#endregion
+//#region src/apis/generations.ts
+var GenerationsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	async create(request) {
+		return this.transport.request("/api/generations", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request)
+		});
+	}
+};
+//#endregion
+//#region src/apis/models.ts
+const MULTIMODAL_MODEL_TYPE = "multimodal";
+var ModelsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	async list() {
+		return this.transport.request("/api/models");
+	}
+	async listMultimodal() {
+		return this.transport.request(`/api/models?modelType=${MULTIMODAL_MODEL_TYPE}`);
+	}
+};
+//#endregion
+//#region src/apis/prompts.ts
+var PromptsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	async list(options, customFetch) {
+		const params = new URLSearchParams();
+		if (options?.spaceId) params.set("spaceId", options.spaceId);
+		const query = params.toString();
+		const path = query ? `/api/prompts?${query}` : "/api/prompts";
+		return this.transport.request(path, { fetch: customFetch });
+	}
+};
+//#endregion
+//#region src/apis/search.ts
+var SearchApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	query(input, customFetch) {
+		const params = new URLSearchParams({ q: input.q });
+		if (input.limit !== void 0) params.set("limit", String(input.limit));
+		for (const type of input.types ?? []) params.append("type", type);
+		if (input.spaceId) params.set("spaceId", input.spaceId);
+		return this.transport.request(`/api/search?${params.toString()}`, { fetch: customFetch });
+	}
+};
+//#endregion
+//#region src/apis/session-access.ts
+var SessionAccessApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	get(sessionId) {
+		return this.transport.request(`/api/sessions/${sessionId}/access`);
+	}
+	set(sessionId, body) {
+		return this.transport.request(`/api/sessions/${sessionId}/access`, {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	remove(sessionId) {
+		return this.transport.request(`/api/sessions/${sessionId}/access`, { method: "DELETE" });
+	}
+};
+//#endregion
+//#region src/realtime.ts
+function ensureRealtimeConnected(websocketClient) {
+	if (websocketClient.state === "open" || websocketClient.state === "connecting" || websocketClient.state === "reconnecting") return;
+	websocketClient.connect().catch((error) => {
+		console.error("[CohubClient] Failed to connect realtime websocket:", error);
+	});
+}
+//#endregion
+//#region src/transport.ts
+const responseBodyForError = async (response) => {
+	return (response.headers.get("content-type") ?? "").includes("application/json") ? await response.json().catch(() => null) : await response.text().catch(() => response.statusText);
+};
+const messageFromErrorBody = (body, fallback) => typeof body === "string" ? body : JSON.stringify(body ?? null) || fallback;
+var HttpError = class extends Error {
+	status;
+	body;
+	constructor(message, status, body) {
+		super(message);
+		this.name = "HttpError";
+		this.status = status;
+		this.body = body;
+	}
+};
+var HttpTransport = class {
+	baseUrl;
+	fetcher;
+	getAccessToken;
+	onUnauthorized;
+	constructor(options = {}) {
+		this.baseUrl = resolveApiBaseUrl(options);
+		this.fetcher = options.fetch ?? fetch;
+		this.getAccessToken = options.getAccessToken;
+		this.onUnauthorized = options.onUnauthorized;
+	}
+	async withAuthorization(init) {
+		const headers = new Headers(init?.headers);
+		const token = this.getAccessToken ? await this.getAccessToken() : null;
+		if (token) headers.set("Authorization", `Bearer ${token}`);
+		else headers.delete("Authorization");
+		return {
+			...init,
+			headers
+		};
+	}
+	async send(path, init) {
+		const response = await (init?.fetch ?? this.fetcher)(this.baseUrl ? `${this.baseUrl}${path}` : path, await this.withAuthorization(init));
+		if (response.status === 401) {
+			await this.onUnauthorized?.();
+			throw new HttpError("unauthorized", 401, null);
+		}
+		if (!response.ok) {
+			const body = await responseBodyForError(response);
+			throw new HttpError(messageFromErrorBody(body, response.statusText), response.status, body);
+		}
+		return response;
+	}
+	async request(path, init) {
+		const response = await this.send(path, init);
+		if (response.status === 204) return null;
+		return response.json();
+	}
+	async raw(path, init) {
+		const response = await this.send(path, init);
+		return {
+			response,
+			blob: () => response.blob(),
+			arrayBuffer: () => response.arrayBuffer(),
+			text: () => response.text(),
+			json: () => response.json()
+		};
+	}
+	async blob(path, init) {
+		return (await this.raw(path, init)).blob();
+	}
+};
+//#endregion
+//#region src/session-patch-reducer.ts
+const blockSubPathPattern = /^\/message\/content\/blocks\/(\d+)\/(.+)$/;
+const blockPathPattern = /^\/message\/content\/blocks\/(\d+)$/;
+const blockMetaPathPattern = /^\/message\/content\/blocks\/(\d+)\/_meta$/;
+const TERMINAL_PATCH_STATUSES = new Set([
+	"completed",
+	"failed",
+	"interrupted"
+]);
+const isTerminalPatchStatus = (status) => TERMINAL_PATCH_STATUSES.has(status);
+const createIdleState = (input) => ({
+	spaceId: input.spaceId ?? null,
+	sessionId: input.sessionId,
+	status: "idle",
+	contentBlocks: [],
+	anchorUserMessageId: null,
+	patchSeq: 0,
+	turnId: null,
+	appendPath: null
+});
+function cloneBlock(block) {
+	return structuredClone(block);
+}
+function getStreamIndex$1(block) {
+	const value = block._meta?.streamIndex;
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function blockIdentityCompatible(prev, next) {
+	if (prev.type !== next.type) return false;
+	if (prev.type === "tool_use" && next.type === "tool_use") return prev.id === next.id && prev.name === next.name;
+	if (prev.type === "tool_result" && next.type === "tool_result") return prev.tool_use_id === next.tool_use_id;
+	return true;
+}
+function findBlockByStreamIndex(blocks, streamIndex) {
+	return blocks.findIndex((block) => getStreamIndex$1(block) === streamIndex);
+}
+function findBlockForReplacement(blocks, streamIndex, nextBlock) {
+	const compatibleIndex = blocks.findIndex((block) => getStreamIndex$1(block) === streamIndex && blockIdentityCompatible(block, nextBlock));
+	if (compatibleIndex >= 0) return compatibleIndex;
+	const sameStreamIndex = blocks.findIndex((block) => getStreamIndex$1(block) === streamIndex);
+	if (sameStreamIndex >= 0 && nextBlock.type !== "tool_use" && nextBlock.type !== "tool_result") return sameStreamIndex;
+	return -1;
+}
+function sortBlocksByStreamIndex(blocks) {
+	return [...blocks].sort((a, b) => {
+		const aIndex = getStreamIndex$1(a);
+		const bIndex = getStreamIndex$1(b);
+		if (aIndex == null && bIndex == null) return 0;
+		if (aIndex == null) return 1;
+		if (bIndex == null) return -1;
+		return aIndex - bIndex;
+	});
+}
+function isContentBlock(value) {
+	return Boolean(value && typeof value === "object" && "type" in value);
+}
+function isPlainObject(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function decodePointerSegments(encoded) {
+	if (!encoded) return [];
+	return encoded.split("/").map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function ensureTextLikeBlock(blocks, streamIndex, field) {
+	const existingIndex = findBlockByStreamIndex(blocks, streamIndex);
+	const existing = existingIndex >= 0 ? blocks[existingIndex] : void 0;
+	if (field === "text") {
+		if (existing?.type === "text") return existing;
+		const block = {
+			type: "text",
+			text: "",
+			_meta: { streamIndex }
+		};
+		blocks.push(block);
+		return block;
+	}
+	if (existing?.type === "thinking") return existing;
+	const block = {
+		type: "thinking",
+		thinking: "",
+		_meta: { streamIndex }
+	};
+	blocks.push(block);
+	return block;
+}
+function getOrCreateBlockForSubpath(blocks, streamIndex, firstSegment) {
+	const idx = findBlockByStreamIndex(blocks, streamIndex);
+	if (idx >= 0) return blocks[idx] ?? null;
+	if (firstSegment === "text") return ensureTextLikeBlock(blocks, streamIndex, "text");
+	if (firstSegment === "thinking") return ensureTextLikeBlock(blocks, streamIndex, "thinking");
+	return null;
+}
+function setDeepOnContentBlock(root, segments, value) {
+	if (segments.length === 0) return false;
+	let cur = root;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const k = segments[i];
+		if (k === void 0) return false;
+		if (!isPlainObject(cur)) return false;
+		const next = cur[k];
+		if (next === void 0) return false;
+		cur = next;
+	}
+	const last = segments[segments.length - 1];
+	if (last === void 0) return false;
+	if (!isPlainObject(cur)) return false;
+	const toAssign = value !== null && typeof value === "object" ? structuredClone(value) : value;
+	cur[last] = toAssign;
+	return true;
+}
+function appendDeepOnContentBlock(root, segments, suffix) {
+	if (segments.length === 0) return false;
+	let cur = root;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const k = segments[i];
+		if (k === void 0) return false;
+		if (!isPlainObject(cur)) return false;
+		const next = cur[k];
+		if (next === void 0) return false;
+		cur = next;
+	}
+	const last = segments[segments.length - 1];
+	if (last === void 0) return false;
+	if (!isPlainObject(cur)) return false;
+	const parent = cur;
+	const leaf = parent[last];
+	if (typeof leaf !== "string") return false;
+	parent[last] = leaf + suffix;
+	return true;
+}
+function resolveBlockForSubpath(blocks, streamIndex, firstSegment) {
+	const idx = findBlockByStreamIndex(blocks, streamIndex);
+	if (idx >= 0) return blocks[idx] ?? null;
+	return getOrCreateBlockForSubpath(blocks, streamIndex, firstSegment);
+}
+function applyReplaceAtBlockSubpath(blocks, streamIndex, encodedTail, value) {
+	const segs = decodePointerSegments(encodedTail);
+	if (segs.length === 0) return false;
+	const block = resolveBlockForSubpath(blocks, streamIndex, segs[0] ?? "");
+	if (!block) return false;
+	return setDeepOnContentBlock(block, segs, value);
+}
+function applyAppendAtBlockSubpath(blocks, streamIndex, encodedTail, suffix) {
+	if (typeof suffix !== "string") return false;
+	const segs = decodePointerSegments(encodedTail);
+	if (segs.length === 0) return false;
+	const block = resolveBlockForSubpath(blocks, streamIndex, segs[0] ?? "");
+	if (!block) return false;
+	return appendDeepOnContentBlock(block, segs, suffix);
+}
+function appendPatchStreamValue(blocks, path, value) {
+	const m = path.match(blockSubPathPattern);
+	if (!m) return false;
+	return applyAppendAtBlockSubpath(blocks, Number(m[1]), m[2] ?? "", value);
+}
+function applyPatchOpsToBlocks(current, ops, initialAppendPath) {
+	const next = current.map(cloneBlock);
+	let anchorUserMessageId;
+	let appendPath = initialAppendPath;
+	let failed = false;
+	for (const op of ops) {
+		if (!op.o && !op.p) {
+			if (!appendPath || !appendPatchStreamValue(next, appendPath, op.v)) {
+				failed = true;
+				break;
+			}
+			continue;
+		}
+		if (op.o === "merge" && op.p === "/message/metadata") {
+			const anchor = op.v.anchorUserMessageId;
+			if (typeof anchor === "string" && anchor.trim()) anchorUserMessageId = anchor;
+			continue;
+		}
+		if (op.o === "append") {
+			if (typeof op.p !== "string" || !appendPatchStreamValue(next, op.p, op.v)) {
+				failed = true;
+				break;
+			}
+			appendPath = op.p;
+			continue;
+		}
+		if (op.o === "merge") {
+			const match = op.p.match(blockMetaPathPattern);
+			if (!match) continue;
+			const blockIndex = findBlockByStreamIndex(next, Number(match[1]));
+			const block = blockIndex >= 0 ? next[blockIndex] : void 0;
+			if (!block) continue;
+			block._meta = {
+				...block._meta ?? {},
+				...op.v
+			};
+			continue;
+		}
+		if (op.o === "replace") {
+			const sub = op.p.match(blockSubPathPattern);
+			if (sub?.[2] && typeof op.p === "string") {
+				const streamIndex = Number(sub[1]);
+				const encodedTail = sub[2];
+				if (applyReplaceAtBlockSubpath(next, streamIndex, encodedTail, op.v)) continue;
+				failed = true;
+				break;
+			}
+		}
+		if (op.o === "replace" || op.o === "add") {
+			const match = op.p.match(blockPathPattern);
+			if (!match || !isContentBlock(op.v)) continue;
+			const streamIndex = Number(match[1]);
+			const block = cloneBlock(op.v);
+			block._meta = {
+				...block._meta ?? {},
+				streamIndex
+			};
+			const blockIndex = findBlockForReplacement(next, streamIndex, block);
+			if (blockIndex >= 0) next[blockIndex] = block;
+			else next.push(block);
+			continue;
+		}
+		if (op.o === "remove") {
+			const match = op.p.match(blockPathPattern);
+			if (!match) continue;
+			const blockIndex = findBlockByStreamIndex(next, Number(match[1]));
+			if (blockIndex >= 0) next.splice(blockIndex, 1);
+		}
+	}
+	return {
+		failed,
+		contentBlocks: sortBlocksByStreamIndex(next),
+		anchorUserMessageId,
+		appendPath
+	};
+}
+var SessionPatchReducer = class {
+	states = /* @__PURE__ */ new Map();
+	key(input) {
+		return `${input.spaceId ?? ""}:${input.sessionId}`;
+	}
+	get(input) {
+		const key = this.key(input);
+		return this.states.get(key) ?? createIdleState(input);
+	}
+	start(input) {
+		const state = {
+			...this.get(input),
+			status: "pending",
+			contentBlocks: [],
+			anchorUserMessageId: null,
+			patchSeq: 0,
+			turnId: input.turnId ?? null,
+			appendPath: null
+		};
+		this.states.set(this.key(input), state);
+		return state;
+	}
+	replaceTurnId(input) {
+		const state = {
+			...this.get(input),
+			turnId: input.nextTurnId
+		};
+		this.states.set(this.key(input), state);
+		return state;
+	}
+	complete(input) {
+		const current = this.get(input);
+		const state = {
+			...current,
+			turnId: input.turnId ?? current.turnId,
+			status: "completed",
+			contentBlocks: [],
+			anchorUserMessageId: null
+		};
+		this.states.set(this.key(input), state);
+		return state;
+	}
+	fail(input) {
+		const current = this.get(input);
+		const state = {
+			...current,
+			turnId: input.turnId ?? current.turnId,
+			status: "failed",
+			contentBlocks: [],
+			anchorUserMessageId: null
+		};
+		this.states.set(this.key(input), state);
+		return state;
+	}
+	interrupt(input) {
+		const current = this.get(input);
+		const state = {
+			...current,
+			turnId: input.turnId ?? current.turnId,
+			status: "interrupted",
+			contentBlocks: [],
+			anchorUserMessageId: null,
+			appendPath: null
+		};
+		this.states.set(this.key(input), state);
+		return state;
+	}
+	reset(input) {
+		this.states.delete(this.key(input));
+	}
+	applySnapshot(input) {
+		const current = this.get(input);
+		const inputTurnId = input.turnId ?? null;
+		const currentTurnId = current.turnId;
+		const isDifferentKnownTurn = Boolean(currentTurnId && inputTurnId && currentTurnId !== inputTurnId);
+		if (isTerminalPatchStatus(current.status) && Boolean(currentTurnId) && currentTurnId === inputTurnId || !isDifferentKnownTurn && input.seq < current.patchSeq) return {
+			applied: false,
+			reason: "duplicate",
+			state: current
+		};
+		const state = {
+			...current,
+			spaceId: input.spaceId ?? current.spaceId ?? null,
+			sessionId: input.sessionId,
+			status: "streaming",
+			contentBlocks: sortBlocksByStreamIndex(input.contentBlocks.map(cloneBlock)),
+			anchorUserMessageId: input.anchorUserMessageId ?? current.anchorUserMessageId ?? null,
+			patchSeq: input.seq,
+			turnId: inputTurnId ?? current.turnId ?? null,
+			appendPath: input.appendPath ?? null
+		};
+		this.states.set(this.key(input), state);
+		return {
+			applied: true,
+			state
+		};
+	}
+	resetAll() {
+		this.states.clear();
+	}
+	applyEvent(event) {
+		return this.applyPatch({
+			spaceId: event.spaceId,
+			sessionId: event.sessionId,
+			turnId: event.payload.turnId,
+			seq: event.payload.seq,
+			baseSeq: event.payload.baseSeq,
+			ops: event.payload.ops,
+			anchorUserMessageId: event.payload.anchorUserMessageId
+		});
+	}
+	applyPatch(input) {
+		const current = this.get(input);
+		const currentTurnId = current.turnId;
+		const inputTurnId = input.turnId ?? null;
+		const isDifferentKnownTurn = Boolean(currentTurnId && inputTurnId && currentTurnId !== inputTurnId);
+		const isFreshKnownTurn = isDifferentKnownTurn && input.baseSeq === 0;
+		const currentSeq = isFreshKnownTurn ? 0 : current.patchSeq;
+		const isSameTurnKeyframe = Boolean(currentTurnId && inputTurnId && currentTurnId === inputTurnId && input.baseSeq === 0 && input.seq >= currentSeq);
+		if (isTerminalPatchStatus(current.status) && Boolean(currentTurnId) && currentTurnId === inputTurnId) return {
+			applied: false,
+			reason: "duplicate",
+			state: current
+		};
+		if (isDifferentKnownTurn && !isFreshKnownTurn) return {
+			applied: false,
+			reason: "version_mismatch",
+			state: current
+		};
+		if (!isSameTurnKeyframe && input.seq <= currentSeq) return {
+			applied: false,
+			reason: "duplicate",
+			state: current
+		};
+		if (!isSameTurnKeyframe && input.baseSeq !== currentSeq) return {
+			applied: false,
+			reason: "version_mismatch",
+			state: current
+		};
+		const startingFresh = input.baseSeq === 0 || isFreshKnownTurn || isSameTurnKeyframe;
+		const patched = applyPatchOpsToBlocks(startingFresh ? [] : current.contentBlocks, input.ops, startingFresh ? null : current.appendPath);
+		if (patched.failed) return {
+			applied: false,
+			reason: "version_mismatch",
+			state: current
+		};
+		const next = {
+			...current,
+			spaceId: input.spaceId ?? current.spaceId ?? null,
+			sessionId: input.sessionId,
+			status: "streaming",
+			contentBlocks: patched.contentBlocks,
+			anchorUserMessageId: patched.anchorUserMessageId ?? input.anchorUserMessageId ?? current.anchorUserMessageId ?? null,
+			patchSeq: input.seq,
+			turnId: input.turnId ?? current.turnId ?? null,
+			appendPath: patched.appendPath
+		};
+		this.states.set(this.key(next), next);
+		return {
+			applied: true,
+			state: next
+		};
+	}
+};
+const createSessionPatchReducer = () => new SessionPatchReducer();
+//#endregion
+//#region src/session-generation-stream.ts
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const isContentBlockArray = (value) => Array.isArray(value) && value.every((item) => isRecord(item) && typeof item.type === "string");
+const stringField = (record, key) => {
+	const value = record[key];
+	return typeof value === "string" ? value : null;
+};
+const numberField = (record, key) => {
+	const value = record[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+};
+const getMessageKind = (message) => {
+	const kind = message.meta?.messageKind;
+	return typeof kind === "string" ? kind : null;
+};
+function parseAssistantMessageCommit(message) {
+	if (message.role !== "assistant") return {
+		kind: "ignored",
+		message,
+		isFinal: false
+	};
+	const kind = getMessageKind(message);
+	if (kind === "assistant_intermediate") return {
+		kind: "intermediate",
+		message,
+		isFinal: false
+	};
+	if (kind === "assistant_final") return {
+		kind: "final",
+		message,
+		isFinal: true
+	};
+	if (kind === "assistant_error") return {
+		kind: "error",
+		message,
+		isFinal: true
+	};
+	return {
+		kind: "ignored",
+		message,
+		isFinal: false
+	};
+}
+function cloneContentBlock(block) {
+	return structuredClone(block);
+}
+function getStreamIndex(block) {
+	const value = block._meta?.streamIndex;
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function findMergeTargetIndex(result, block) {
+	const streamIndex = getStreamIndex(block);
+	if (streamIndex != null) return result.findIndex((existing) => existing.type === block.type && getStreamIndex(existing) === streamIndex);
+	if (block.type === "tool_use") return result.findIndex((existing) => existing.type === "tool_use" && existing.id === block.id);
+	if (block.type === "tool_result") return result.findIndex((existing) => existing.type === "tool_result" && existing.tool_use_id === block.tool_use_id);
+	return -1;
+}
+function mergeStreamingDeltaBlocks(existing, delta) {
+	if (delta.length === 0) return existing;
+	const result = existing.map(cloneContentBlock);
+	for (const block of delta) {
+		const targetIndex = findMergeTargetIndex(result, block);
+		if (targetIndex === -1) {
+			result.push(cloneContentBlock(block));
+			continue;
+		}
+		const target = result[targetIndex];
+		if (block.type === "text" && target?.type === "text") {
+			target.text += block.text;
+			continue;
+		}
+		if (block.type === "thinking" && target?.type === "thinking") {
+			target.thinking += block.thinking;
+			if (block.signature) target.signature = block.signature;
+			if (block._meta) target._meta = {
+				...target._meta ?? {},
+				...block._meta
+			};
+			continue;
+		}
+		result[targetIndex] = Object.assign(target ?? {}, cloneContentBlock(block));
+	}
+	return result;
+}
+function parseSnapshotMessage(value) {
+	if (!isRecord(value) || !isContentBlockArray(value.content)) return null;
+	return {
+		messageId: stringField(value, "messageId"),
+		messageOrdinal: numberField(value, "messageOrdinal"),
+		content: value.content,
+		...typeof value.id === "string" ? { id: value.id } : {},
+		...typeof value.sessionId === "string" ? { sessionId: value.sessionId } : {},
+		...value.role === "user" || value.role === "assistant" || value.role === "system" ? { role: value.role } : {},
+		...typeof value.text === "string" ? { text: value.text } : {},
+		...typeof value.provider === "string" ? { provider: value.provider } : {},
+		...typeof value.model === "string" ? { model: value.model } : {},
+		...typeof value.stopReason === "string" ? { stopReason: value.stopReason } : {},
+		...typeof value.errorMessage === "string" ? { errorMessage: value.errorMessage } : {},
+		...isRecord(value.usage) ? { usage: value.usage } : {},
+		...typeof value.toolCallsObjectKey === "string" ? { toolCallsObjectKey: value.toolCallsObjectKey } : {},
+		...isRecord(value.meta) ? { meta: value.meta } : {},
+		...typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {}
+	};
+}
+function messageRecordToIntermediate(message) {
+	if (!isContentBlockArray(message.content) || message.content.length === 0) return null;
+	const meta = isRecord(message.meta) ? message.meta : {};
+	return {
+		id: message.id,
+		sessionId: message.sessionId,
+		role: message.role,
+		messageId: typeof meta.streamMessageId === "string" ? meta.streamMessageId : message.id ?? null,
+		messageOrdinal: typeof meta.messageOrdinal === "number" ? meta.messageOrdinal : null,
+		content: message.content,
+		text: message.text,
+		provider: message.provider,
+		model: message.model,
+		stopReason: message.stopReason,
+		errorMessage: message.errorMessage,
+		usage: message.usage,
+		meta: message.meta,
+		createdAt: message.createdAt
+	};
+}
+function resolveStreamMessageId(input) {
+	if (input.messageId?.trim()) return input.messageId.trim();
+	if (input.messageOrdinal == null) return null;
+	if (input.turnId?.trim()) return `turn:${input.turnId.trim()}:assistant:${input.messageOrdinal}`;
+	return `session:${input.sessionId}:assistant:${input.messageOrdinal}:${input.anchorUserMessageId ?? "unknown"}`;
+}
+function getTurnIdFromMessage(message) {
+	const turnId = message.meta?.turnId;
+	return typeof turnId === "string" ? turnId : null;
+}
+var SessionGenerationStreamClient = class SessionGenerationStreamClient {
+	websocketClient;
+	spaceId;
+	sessionId;
+	reducer = new SessionPatchReducer();
+	messageId = null;
+	messageOrdinal = null;
+	intermediateMessages = [];
+	progressState = null;
+	constructor(websocketClient, spaceId, sessionId) {
+		this.websocketClient = websocketClient;
+		this.spaceId = spaceId;
+		this.sessionId = sessionId;
+	}
+	subscribe(handlers) {
+		if (!this.websocketClient) throw new Error("realtime transport is not configured for this client");
+		ensureRealtimeConnected(this.websocketClient);
+		const stream = new SessionGenerationStreamClient(this.websocketClient, this.spaceId, this.sessionId);
+		const unsubscribe = this.websocketClient.on("event", (event) => {
+			if (event.spaceId !== this.spaceId || event.sessionId !== this.sessionId) return;
+			stream.handleEvent(event, handlers);
+		});
+		return () => unsubscribe();
+	}
+	emit(handlers, event) {
+		handlers.event?.(event);
+		if (event.type === "state") handlers.state?.(event);
+		if (event.type === "commit") handlers.commit?.(event);
+		if (event.type === "finalized") handlers.finalized?.(event);
+		if (event.type === "turn_updated") handlers.turnUpdated?.(event);
+		if (event.type === "error") handlers.error?.(event);
+		if (event.type === "out_of_sync") handlers.outOfSync?.(event);
+	}
+	resetCurrentMessage() {
+		this.messageId = null;
+		this.messageOrdinal = null;
+		this.progressState = null;
+	}
+	appendCurrentMessage(state) {
+		if (state.contentBlocks.length === 0) return;
+		this.addIntermediateMessage({
+			messageId: this.messageId,
+			messageOrdinal: this.messageOrdinal,
+			content: state.contentBlocks
+		});
+	}
+	addIntermediateMessage(message) {
+		const index = this.intermediateMessages.findIndex((existing) => {
+			if (message.messageId && existing.messageId) return existing.messageId === message.messageId;
+			return message.messageOrdinal !== null && existing.messageOrdinal === message.messageOrdinal;
+		});
+		if (index < 0) {
+			this.intermediateMessages = [...this.intermediateMessages, message];
+			return;
+		}
+		this.intermediateMessages = this.intermediateMessages.map((existing, i) => i === index ? {
+			...existing,
+			...message
+		} : existing);
+	}
+	handleAppliedState(handlers, source, result, rawEvent, messageId, messageOrdinal) {
+		if (!result.applied) {
+			this.emit(handlers, {
+				type: "out_of_sync",
+				source: source === "progress" ? "patch" : source,
+				reason: result.reason,
+				state: result.state,
+				rawEvent
+			});
+			return;
+		}
+		this.progressState = result.state;
+		this.messageId = messageId;
+		this.messageOrdinal = messageOrdinal;
+		this.emit(handlers, {
+			type: "state",
+			source,
+			state: result.state,
+			messageId,
+			messageOrdinal,
+			intermediateMessages: [...this.intermediateMessages],
+			rawEvent
+		});
+	}
+	prepareMessageBoundary(input) {
+		const current = this.progressState ?? this.reducer.get({
+			spaceId: this.spaceId,
+			sessionId: this.sessionId
+		});
+		const nextMessageId = resolveStreamMessageId({
+			sessionId: this.sessionId,
+			turnId: input.turnId,
+			anchorUserMessageId: input.anchorUserMessageId,
+			messageId: input.messageId,
+			messageOrdinal: input.messageOrdinal
+		});
+		const differentTurn = Boolean(current.turnId && input.turnId && current.turnId !== input.turnId);
+		const messageChanged = Boolean(nextMessageId && current.contentBlocks.length > 0 && this.messageId && nextMessageId !== this.messageId);
+		if (differentTurn) {
+			this.intermediateMessages = [];
+			this.resetCurrentMessage();
+			this.reducer.start({
+				spaceId: this.spaceId,
+				sessionId: this.sessionId,
+				turnId: input.turnId
+			});
+		} else if (messageChanged) {
+			this.appendCurrentMessage(current);
+			this.resetCurrentMessage();
+			this.reducer.start({
+				spaceId: this.spaceId,
+				sessionId: this.sessionId,
+				turnId: input.turnId ?? current.turnId
+			});
+		}
+		return nextMessageId;
+	}
+	handleSnapshot(event, handlers) {
+		const payload = event.payload;
+		const current = isRecord(payload.current) ? payload.current : null;
+		const content = current ? current.content : null;
+		const seq = typeof payload.seq === "number" ? payload.seq : null;
+		if (!current || !isContentBlockArray(content) || seq === null) {
+			this.emit(handlers, {
+				type: "out_of_sync",
+				source: "snapshot",
+				reason: "invalid",
+				state: this.reducer.get({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId
+				}),
+				rawEvent: event
+			});
+			return;
+		}
+		const turnId = typeof payload.turnId === "string" ? payload.turnId : null;
+		const anchorUserMessageId = typeof payload.anchorUserMessageId === "string" ? payload.anchorUserMessageId : null;
+		const messageOrdinal = numberField(current, "messageOrdinal");
+		const messageId = this.prepareMessageBoundary({
+			turnId,
+			messageId: stringField(current, "messageId"),
+			messageOrdinal,
+			anchorUserMessageId
+		});
+		this.intermediateMessages = Array.isArray(payload.intermediateMessages) ? payload.intermediateMessages.map(parseSnapshotMessage).filter((message) => message !== null) : [];
+		const result = this.reducer.applySnapshot({
+			spaceId: this.spaceId,
+			sessionId: this.sessionId,
+			turnId,
+			seq,
+			contentBlocks: content,
+			anchorUserMessageId,
+			appendPath: stringField(current, "appendPath")
+		});
+		this.handleAppliedState(handlers, "snapshot", result, event, messageId, messageOrdinal);
+	}
+	handlePatch(event, handlers) {
+		const payload = event.payload;
+		const seq = typeof payload.seq === "number" ? payload.seq : null;
+		const baseSeq = typeof payload.baseSeq === "number" ? payload.baseSeq : null;
+		if (seq === null || baseSeq === null || !Array.isArray(payload.ops)) {
+			this.emit(handlers, {
+				type: "out_of_sync",
+				source: "patch",
+				reason: "invalid",
+				state: this.reducer.get({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId
+				}),
+				rawEvent: event
+			});
+			return;
+		}
+		const turnId = typeof payload.turnId === "string" ? payload.turnId : null;
+		const anchorUserMessageId = typeof payload.anchorUserMessageId === "string" ? payload.anchorUserMessageId : null;
+		const messageOrdinal = typeof payload.messageOrdinal === "number" ? payload.messageOrdinal : null;
+		const messageId = this.prepareMessageBoundary({
+			turnId,
+			messageId: typeof payload.messageId === "string" ? payload.messageId : null,
+			messageOrdinal,
+			anchorUserMessageId
+		});
+		const input = {
+			spaceId: this.spaceId,
+			sessionId: this.sessionId,
+			turnId,
+			seq,
+			baseSeq,
+			ops: payload.ops,
+			anchorUserMessageId
+		};
+		const result = this.reducer.applyPatch(input);
+		this.handleAppliedState(handlers, "patch", result, event, messageId, messageOrdinal);
+	}
+	handleProgress(event, handlers) {
+		const payload = event.payload;
+		if (!isContentBlockArray(payload.content)) return;
+		const current = this.progressState ?? this.reducer.get({
+			spaceId: this.spaceId,
+			sessionId: this.sessionId
+		});
+		const turnId = typeof payload.turnId === "string" ? payload.turnId : current.turnId;
+		const anchorUserMessageId = typeof payload.anchorUserMessageId === "string" ? payload.anchorUserMessageId : current.anchorUserMessageId;
+		const messageOrdinal = typeof payload.messageOrdinal === "number" ? payload.messageOrdinal : this.messageOrdinal;
+		const messageId = this.prepareMessageBoundary({
+			turnId,
+			messageId: typeof payload.messageId === "string" ? payload.messageId : this.messageId,
+			messageOrdinal,
+			anchorUserMessageId
+		});
+		const base = this.progressState?.turnId === turnId ? this.progressState : current;
+		const state = {
+			...base,
+			spaceId: this.spaceId,
+			sessionId: this.sessionId,
+			status: "streaming",
+			contentBlocks: mergeStreamingDeltaBlocks(base.contentBlocks, payload.content),
+			anchorUserMessageId,
+			turnId
+		};
+		this.progressState = state;
+		this.messageId = messageId;
+		this.messageOrdinal = messageOrdinal;
+		this.emit(handlers, {
+			type: "state",
+			source: "progress",
+			state,
+			messageId,
+			messageOrdinal,
+			intermediateMessages: [...this.intermediateMessages],
+			rawEvent: event
+		});
+	}
+	handlePersisted(event, handlers) {
+		const message = event.payload.message;
+		if (!isRecord(message)) return;
+		const commit = parseAssistantMessageCommit(message);
+		if (commit.kind === "intermediate") {
+			const intermediate = messageRecordToIntermediate(commit.message);
+			if (intermediate) this.addIntermediateMessage(intermediate);
+			this.reducer.reset({
+				spaceId: this.spaceId,
+				sessionId: this.sessionId
+			});
+			this.resetCurrentMessage();
+		}
+		if (commit.kind === "final") {
+			this.reducer.complete({
+				spaceId: this.spaceId,
+				sessionId: this.sessionId,
+				turnId: getTurnIdFromMessage(commit.message)
+			});
+			this.resetCurrentMessage();
+		}
+		if (commit.kind === "error") {
+			this.reducer.fail({
+				spaceId: this.spaceId,
+				sessionId: this.sessionId,
+				turnId: getTurnIdFromMessage(commit.message)
+			});
+			this.resetCurrentMessage();
+		}
+		this.emit(handlers, {
+			type: "commit",
+			commit,
+			rawEvent: event
+		});
+	}
+	handleFinalized(event, handlers) {
+		const turn = event.payload.turn;
+		if (!isRecord(turn)) return;
+		const typedTurn = turn;
+		if (typedTurn.status === "interrupted") this.reducer.interrupt({
+			spaceId: this.spaceId,
+			sessionId: this.sessionId,
+			turnId: typedTurn.id
+		});
+		else this.reducer.complete({
+			spaceId: this.spaceId,
+			sessionId: this.sessionId,
+			turnId: typedTurn.id
+		});
+		this.resetCurrentMessage();
+		this.emit(handlers, {
+			type: "finalized",
+			turn: typedTurn,
+			rawEvent: event
+		});
+	}
+	handleEvent(event, handlers) {
+		switch (event.type) {
+			case "session.turn.snapshot":
+				this.handleSnapshot(event, handlers);
+				return;
+			case "session.turn.patch":
+				this.handlePatch(event, handlers);
+				return;
+			case "session.turn.progress":
+				this.handleProgress(event, handlers);
+				return;
+			case "session.message.persisted":
+				this.handlePersisted(event, handlers);
+				return;
+			case "session.turn.finalized":
+				this.handleFinalized(event, handlers);
+				return;
+			case "session.turn.updated": {
+				const turn = event.payload.turn;
+				if (!isRecord(turn)) return;
+				this.emit(handlers, {
+					type: "turn_updated",
+					turn,
+					rawEvent: event
+				});
+				return;
+			}
+			case "session.turn.error": {
+				const message = typeof event.payload.error === "string" && event.payload.error.trim() ? event.payload.error.trim() : "Generation failed";
+				this.reducer.fail({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId
+				});
+				this.resetCurrentMessage();
+				this.emit(handlers, {
+					type: "error",
+					message,
+					rawEvent: event
+				});
+				return;
+			}
+			default: return;
+		}
+	}
+};
+function createSessionGenerationStreamClient(input) {
+	return new SessionGenerationStreamClient(input.websocketClient, input.spaceId, input.sessionId);
+}
+//#endregion
+//#region src/apis/invitations.ts
+var SpaceInvitationsApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	list() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/invitations`);
+	}
+	create(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/invitations`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input ?? {})
+		});
+	}
+	revoke(token) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/invitations/${token}`, { method: "DELETE" });
+	}
+};
+var PublicInviteApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	get(token) {
+		return this.transport.request(`/api/invite/${token}`);
+	}
+	accept(token) {
+		return this.transport.request(`/api/invite/${token}/accept`, { method: "POST" });
+	}
+};
+//#endregion
+//#region src/apis/spaces.ts
+const DEFAULT_DEDUP_WINDOW_MS = 2e3;
+const getFilenameFromContentDisposition = (value) => {
+	if (!value) return null;
+	const encodedMatch = value.match(/filename\*=UTF-8''([^;]+)/i);
+	if (encodedMatch?.[1]) try {
+		return decodeURIComponent(encodedMatch[1]);
+	} catch {
+		return encodedMatch[1];
+	}
+	return value.match(/filename="?([^";]+)"?/i)?.[1] ?? null;
+};
+const toSessionEventName = (type) => {
+	switch (type) {
+		case "session.turn.patch": return "turn.patch";
+		case "session.turn.snapshot": return "turn.snapshot";
+		case "session.turn.progress": return "turn.progress";
+		case "session.turn.error": return "turn.error";
+		case "session.turn.updated": return "turn.updated";
+		case "session.turn.finalized": return "turn.final";
+		case "session.message.persisted": return "message.persisted";
+		default: return null;
+	}
+};
+const isAssistantFinalPersistedEvent = (event) => {
+	if (event.type !== "session.message.persisted") return false;
+	const message = event.payload.message;
+	if (!message || typeof message !== "object") return false;
+	const record = message;
+	return record.role === "assistant" && (record.meta?.messageKind === "assistant_final" || record.meta?.messageKind === "assistant_error");
+};
+const isAssistantIntermediatePersistedEvent = (event) => {
+	if (event.type !== "session.message.persisted") return false;
+	const message = event.payload.message;
+	if (!message || typeof message !== "object") return false;
+	const record = message;
+	return record.role === "assistant" && record.meta?.messageKind === "assistant_intermediate";
+};
+const getPersistedMessageTurnId = (event) => {
+	if (event.type !== "session.message.persisted") return null;
+	const message = event.payload.message;
+	if (!message || typeof message !== "object") return null;
+	const meta = message.meta;
+	return typeof meta?.turnId === "string" ? meta.turnId : null;
+};
+var SpacesApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	list(customFetch) {
+		return this.transport.request("/api/spaces", {
+			method: "GET",
+			fetch: customFetch
+		});
+	}
+	get(spaceId, customFetch) {
+		return this.transport.request(`/api/spaces/${spaceId}`, { fetch: customFetch });
+	}
+	create(input, headers) {
+		return this.transport.request("/api/spaces", {
+			method: "POST",
+			headers: {
+				...headers,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(input ?? {})
+		});
+	}
+};
+var SpaceFilesApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	list(path = "", customFetch) {
+		const params = new URLSearchParams();
+		if (path) params.set("path", path);
+		const query = params.toString();
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/tree${query ? `?${query}` : ""}`, { fetch: customFetch });
+	}
+	read(path, customFetch) {
+		const params = new URLSearchParams({ path });
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, { fetch: customFetch });
+	}
+	readMany(paths, customFetch) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/files`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ paths }),
+			fetch: customFetch
+		});
+	}
+	/**
+	* Build a direct download URL. For private files, prefer `download()` so the
+	* SDK can attach authorization headers.
+	*/
+	getDownloadUrl(path) {
+		const params = new URLSearchParams({ path });
+		return `/api/spaces/${this.spaceId}/fs/download?${params.toString()}`;
+	}
+	async download(path, customFetch) {
+		const params = new URLSearchParams({ path });
+		const raw = await this.transport.raw(`/api/spaces/${this.spaceId}/fs/download?${params.toString()}`, { fetch: customFetch });
+		if (raw.response.status === 202) throw new HttpError("File is being prepared. Please retry shortly.", 202, await raw.json().catch(() => null));
+		const blob = await raw.blob();
+		return {
+			blob,
+			filename: getFilenameFromContentDisposition(raw.response.headers.get("content-disposition")) ?? path.split("/").pop() ?? "download",
+			mimeType: raw.response.headers.get("content-type") ?? blob.type ?? "application/octet-stream"
+		};
+	}
+	write(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/file`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	createDir(path) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/dir`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ path })
+		});
+	}
+	delete(path, recursive = false) {
+		const params = new URLSearchParams({ path });
+		if (recursive) params.set("recursive", "true");
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/node?${params.toString()}`, { method: "DELETE" });
+	}
+	move(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/move`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	upload(files, dir = "") {
+		const params = new URLSearchParams();
+		if (dir) params.set("dir", dir);
+		const query = params.toString();
+		const formData = new FormData();
+		for (const file of files) formData.append("files", file);
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/upload${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: formData
+		});
+	}
+	createUpload(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/uploads`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	completeUpload(uploadId, input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/uploads/${uploadId}/complete`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+};
+var SessionMessagesClient = class {
+	transport;
+	sessionId;
+	lastSentSignature = "";
+	lastSentSessionId = "";
+	lastSentAt = 0;
+	constructor(transport, sessionId) {
+		this.transport = transport;
+		this.sessionId = sessionId;
+	}
+	list(customFetch) {
+		return this.transport.request(`/api/sessions/${this.sessionId}/messages`, { fetch: customFetch });
+	}
+	get(messageId, optionsOrFetch, customFetch) {
+		const options = typeof optionsOrFetch === "function" ? void 0 : optionsOrFetch;
+		const fetch = typeof optionsOrFetch === "function" ? optionsOrFetch : customFetch;
+		const params = new URLSearchParams();
+		if (options?.detail) params.set("detail", options.detail);
+		const query = params.toString();
+		return this.transport.request(`/api/sessions/${this.sessionId}/messages/${messageId}${query ? `?${query}` : ""}`, { fetch });
+	}
+	listPaginated(options, customFetch) {
+		const params = new URLSearchParams();
+		if (options?.cursor !== void 0) params.set("cursor", String(options.cursor));
+		if (options?.limit !== void 0) params.set("limit", String(options.limit));
+		if (options?.direction) params.set("direction", options.direction);
+		const query = params.toString();
+		return this.transport.request(`/api/sessions/${this.sessionId}/messages${query ? `?${query}` : ""}`, { fetch: customFetch });
+	}
+	async send(input) {
+		const signature = JSON.stringify({
+			sessionId: this.sessionId,
+			input
+		});
+		const now = Date.now();
+		if (this.sessionId === this.lastSentSessionId && signature === this.lastSentSignature && now - this.lastSentAt < DEFAULT_DEDUP_WINDOW_MS) throw new Error("Duplicate message ignored");
+		this.lastSentSessionId = this.sessionId;
+		this.lastSentSignature = signature;
+		this.lastSentAt = now;
+		return this.transport.request(`/api/sessions/${this.sessionId}/messages`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				content: input.content,
+				model: input.model,
+				provider: input.provider,
+				clientMessageId: input.clientMessageId
+			})
+		});
+	}
+};
+var SessionTurnsClient = class {
+	transport;
+	sessionId;
+	constructor(transport, sessionId) {
+		this.transport = transport;
+		this.sessionId = sessionId;
+	}
+	listPaginated(options, customFetch) {
+		const params = new URLSearchParams();
+		if (options?.cursor !== void 0) params.set("cursor", String(options.cursor));
+		if (options?.limit !== void 0) params.set("limit", String(options.limit));
+		if (options?.direction) params.set("direction", options.direction);
+		const query = params.toString();
+		return this.transport.request(`/api/sessions/${this.sessionId}/turns${query ? `?${query}` : ""}`, { fetch: customFetch });
+	}
+	index(options, customFetch) {
+		const params = new URLSearchParams();
+		if (options?.cursor !== void 0) params.set("cursor", String(options.cursor));
+		if (options?.limit !== void 0) params.set("limit", String(options.limit));
+		const query = params.toString();
+		return this.transport.request(`/api/sessions/${this.sessionId}/turns/index${query ? `?${query}` : ""}`, { fetch: customFetch });
+	}
+	window(options, customFetch) {
+		const params = new URLSearchParams();
+		if (options.sequence !== void 0) params.set("sequence", String(options.sequence));
+		if (options.turnId) params.set("turnId", options.turnId);
+		if (options.before !== void 0) params.set("before", String(options.before));
+		if (options.after !== void 0) params.set("after", String(options.after));
+		const query = params.toString();
+		return this.transport.request(`/api/sessions/${this.sessionId}/turns/window${query ? `?${query}` : ""}`, { fetch: customFetch });
+	}
+	streamSnapshot(customFetch) {
+		return this.transport.request(`/api/sessions/${this.sessionId}/turns/stream-snapshot`, { fetch: customFetch });
+	}
+	get(turnId, customFetch) {
+		return this.transport.request(`/api/sessions/${this.sessionId}/turns/${turnId}`, { fetch: customFetch });
+	}
+	signedUrls(turnId, objectKeys) {
+		return this.transport.request(`/api/sessions/${this.sessionId}/turns/${turnId}/signed-urls`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ objectKeys })
+		});
+	}
+};
+var SessionRealtimeClient = class {
+	websocketClient;
+	spaceId;
+	sessionId;
+	patchReducer = new SessionPatchReducer();
+	constructor(websocketClient, spaceId, sessionId) {
+		this.websocketClient = websocketClient;
+		this.spaceId = spaceId;
+		this.sessionId = sessionId;
+	}
+	subscribe(handlers) {
+		if (!this.websocketClient) throw new Error("realtime transport is not configured for this client");
+		ensureRealtimeConnected(this.websocketClient);
+		const unsubscribe = this.websocketClient.on("event", (event) => {
+			if (event.spaceId !== this.spaceId || event.sessionId !== this.sessionId) return;
+			handlers.event?.(event);
+			const eventName = toSessionEventName(event.type);
+			if (eventName === "turn.patch") {
+				handlers.patch?.(event);
+				if (event.type === "session.turn.patch") {
+					const payload = event.payload;
+					if (typeof payload.seq === "number" && typeof payload.baseSeq === "number" && Array.isArray(payload.ops)) handlers.patchState?.(this.patchReducer.applyPatch({
+						spaceId: this.spaceId,
+						sessionId: this.sessionId,
+						turnId: typeof payload.turnId === "string" ? payload.turnId : null,
+						seq: payload.seq,
+						baseSeq: payload.baseSeq,
+						ops: payload.ops,
+						anchorUserMessageId: typeof payload.anchorUserMessageId === "string" ? payload.anchorUserMessageId : null
+					}));
+				}
+			}
+			if (eventName === "turn.snapshot") handlers.snapshot?.(event);
+			if (eventName === "turn.progress") handlers.progress?.(event);
+			if (eventName === "turn.error") {
+				this.patchReducer.fail({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId
+				});
+				handlers.error?.(event);
+			}
+			if (eventName === "message.persisted") {
+				handlers.persisted?.(event);
+				if (isAssistantIntermediatePersistedEvent(event)) this.patchReducer.reset({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId
+				});
+			}
+			if (eventName === "turn.updated") handlers.turnUpdated?.(event);
+			if (eventName === "turn.final") {
+				this.patchReducer.complete({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId,
+					turnId: typeof event.payload.turn === "object" && event.payload.turn && "id" in event.payload.turn ? String(event.payload.turn.id) : null
+				});
+				handlers.turnFinalized?.(event);
+				handlers.final?.(event);
+			}
+			if (isAssistantFinalPersistedEvent(event)) {
+				this.patchReducer.complete({
+					spaceId: this.spaceId,
+					sessionId: this.sessionId,
+					turnId: getPersistedMessageTurnId(event)
+				});
+				handlers.final?.(event);
+			}
+		});
+		return () => unsubscribe();
+	}
+	on(type, handler) {
+		return this.subscribe({ event: (event) => {
+			if (type === "turn.final" && isAssistantFinalPersistedEvent(event)) {
+				handler(event);
+				return;
+			}
+			if (toSessionEventName(event.type) === type) handler(event);
+		} });
+	}
+};
+var SessionClient = class {
+	spaceId;
+	id;
+	transport;
+	messages;
+	turns;
+	realtime;
+	generation;
+	constructor(spaceId, id, transport, websocketClient) {
+		this.spaceId = spaceId;
+		this.id = id;
+		this.transport = transport;
+		this.messages = new SessionMessagesClient(transport, id);
+		this.turns = new SessionTurnsClient(transport, id);
+		this.realtime = new SessionRealtimeClient(websocketClient, spaceId, id);
+		this.generation = new SessionGenerationStreamClient(websocketClient, spaceId, id);
+	}
+	get(customFetch) {
+		return this.transport.request(`/api/sessions/${this.id}`, { fetch: customFetch });
+	}
+	rename(title, customFetch) {
+		return this.transport.request(`/api/sessions/${this.id}`, {
+			method: "PATCH",
+			body: JSON.stringify({ title }),
+			fetch: customFetch
+		});
+	}
+	abort(optionsOrFetch, customFetch) {
+		const options = typeof optionsOrFetch === "function" ? void 0 : optionsOrFetch;
+		const fetch = typeof optionsOrFetch === "function" ? optionsOrFetch : customFetch;
+		return this.transport.request(`/api/sessions/${this.id}/abort`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ turnId: options?.turnId ?? null }),
+			fetch
+		});
+	}
+	turn(turnId) {
+		return { fork: (input = {}) => this.transport.request(`/api/sessions/${this.id}/turns/${turnId}/fork`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		}) };
+	}
+	subscribe(handlers) {
+		return this.realtime.subscribe(handlers);
+	}
+	subscribeGeneration(handlers) {
+		return this.generation.subscribe(handlers);
+	}
+	on(type, handler) {
+		return this.realtime.on(type, handler);
+	}
+};
+var SpaceSessionsApi = class {
+	transport;
+	spaceId;
+	websocketClient;
+	constructor(transport, spaceId, websocketClient) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+		this.websocketClient = websocketClient;
+	}
+	create(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/sessions`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input ?? {})
+		});
+	}
+	list(optionsOrFetch, customFetch) {
+		const options = typeof optionsOrFetch === "function" ? void 0 : optionsOrFetch;
+		const fetch = typeof optionsOrFetch === "function" ? optionsOrFetch : customFetch;
+		const params = new URLSearchParams();
+		if (options?.limit !== void 0) params.set("limit", String(options.limit));
+		if (options?.cursor) params.set("cursor", options.cursor);
+		if (options?.includeForks) params.set("includeForks", "1");
+		const query = params.toString();
+		return this.transport.request(`/api/spaces/${this.spaceId}/sessions${query ? `?${query}` : ""}`, { fetch });
+	}
+	byId(sessionId) {
+		return new SessionClient(this.spaceId, sessionId, this.transport, this.websocketClient);
+	}
+};
+var SpaceEventsApi = class {
+	websocketClient;
+	spaceId;
+	constructor(websocketClient, spaceId) {
+		this.websocketClient = websocketClient;
+		this.spaceId = spaceId;
+	}
+	subscribe(handler) {
+		if (!this.websocketClient) throw new Error("realtime transport is not configured for this client");
+		ensureRealtimeConnected(this.websocketClient);
+		return this.websocketClient.on("event", (event) => {
+			if (event.spaceId !== this.spaceId) return;
+			handler(event);
+		});
+	}
+	on(type, handler) {
+		return this.subscribe((event) => {
+			if (type === "event") {
+				handler(event);
+				return;
+			}
+			if (type === "ports.changed" && event.type === "space.ports.changed") {
+				handler(event);
+				return;
+			}
+			if (type === "turn.final" && isAssistantFinalPersistedEvent(event)) {
+				handler(event);
+				return;
+			}
+			if (toSessionEventName(event.type) === type) handler(event);
+		});
+	}
+};
+var SpaceMembersApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	list() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/members`);
+	}
+	update(userId, role) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/members`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				userId,
+				role
+			})
+		});
+	}
+	remove(userId) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/members`, {
+			method: "DELETE",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ userId })
+		});
+	}
+};
+var SpaceAccessApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	get() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/access`);
+	}
+	set(body) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/access`, {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+};
+var SpaceUsageApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	get(days = 30, customFetch) {
+		const params = new URLSearchParams({ days: String(days) });
+		return this.transport.request(`/api/spaces/${this.spaceId}/usage?${params.toString()}`, { fetch: customFetch });
+	}
+};
+var SpaceChannelsApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	list() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/channels`);
+	}
+	bind(channelId, config) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/channels/${channelId}`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ config: config ?? null })
+		});
+	}
+	unbind(channelId) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/channels/${channelId}`, { method: "DELETE" });
+	}
+};
+var SpaceEnvApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	list() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/env`);
+	}
+	create(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/env`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	update(name, value) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/env/${encodeURIComponent(name)}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ value })
+		});
+	}
+	remove(name) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/env/${encodeURIComponent(name)}`, { method: "DELETE" });
+	}
+};
+var SpaceSandboxApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	get() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/sandbox`);
+	}
+	ports() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/sandbox/ports`);
+	}
+	recreate() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/sandbox/recreate`, { method: "POST" });
+	}
+};
+var SpaceMarksApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	list(kind = "pin") {
+		const params = new URLSearchParams({ kind });
+		return this.transport.request(`/api/spaces/${this.spaceId}/marks?${params.toString()}`);
+	}
+	create(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/marks`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				kind: "pin",
+				...input
+			})
+		});
+	}
+	delete(markId) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/marks/${markId}`, { method: "DELETE" });
+	}
+};
+var SpaceCheckpointsApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	create(description) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/checkpoints`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ description: description ?? null })
+		});
+	}
+	list() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/checkpoints`);
+	}
+	get(checkpointId, customFetch) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/checkpoints/${checkpointId}`, { fetch: customFetch });
+	}
+};
+var SpaceClient = class {
+	id;
+	transport;
+	websocketClient;
+	files;
+	sessions;
+	members;
+	access;
+	checkpoints;
+	usage;
+	channels;
+	env;
+	sandbox;
+	invitations;
+	marks;
+	constructor(id, transport, websocketClient) {
+		this.id = id;
+		this.transport = transport;
+		this.websocketClient = websocketClient;
+		this.files = new SpaceFilesApi(transport, id);
+		this.sessions = new SpaceSessionsApi(transport, id, websocketClient);
+		this.members = new SpaceMembersApi(transport, id);
+		this.access = new SpaceAccessApi(transport, id);
+		this.checkpoints = new SpaceCheckpointsApi(transport, id);
+		this.usage = new SpaceUsageApi(transport, id);
+		this.channels = new SpaceChannelsApi(transport, id);
+		this.env = new SpaceEnvApi(transport, id);
+		this.sandbox = new SpaceSandboxApi(transport, id);
+		this.invitations = new SpaceInvitationsApi(transport, id);
+		this.marks = new SpaceMarksApi(transport, id);
+	}
+	get(customFetch) {
+		return this.transport.request(`/api/spaces/${this.id}`, { fetch: customFetch });
+	}
+	prompt(input) {
+		return this.transport.request(`/api/spaces/${this.id}/prompt`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	rename(name) {
+		return this.transport.request(`/api/spaces/${this.id}`, {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ name })
+		});
+	}
+	profile(body) {
+		return this.transport.request(`/api/spaces/${this.id}/profile`, {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	session(sessionId) {
+		return new SessionClient(this.id, sessionId, this.transport, this.websocketClient);
+	}
+	subscribe(handler) {
+		return new SpaceEventsApi(this.websocketClient, this.id).subscribe(handler);
+	}
+	on(type, handler) {
+		return new SpaceEventsApi(this.websocketClient, this.id).on(type, handler);
+	}
+};
+//#endregion
+//#region src/apis/tasks.ts
+var TasksApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	get(taskRunId) {
+		return this.transport.request(`/api/tasks/${taskRunId}`);
+	}
+	list(filters) {
+		const params = new URLSearchParams();
+		if (filters?.cronJobId) params.set("cronJobId", filters.cronJobId);
+		if (filters?.spaceId) params.set("spaceId", filters.spaceId);
+		const query = params.toString();
+		return this.transport.request(`/api/tasks${query ? `?${query}` : ""}`);
+	}
+};
+//#endregion
+//#region src/apis/user.ts
+var UserApi = class {
+	transport;
+	transportBaseUrl;
+	setStoredAuthToken;
+	clearStoredAuthToken;
+	constructor(transport, transportBaseUrl, setStoredAuthToken, clearStoredAuthToken) {
+		this.transport = transport;
+		this.transportBaseUrl = transportBaseUrl;
+		this.setStoredAuthToken = setStoredAuthToken;
+		this.clearStoredAuthToken = clearStoredAuthToken;
+	}
+	getMe(customFetch) {
+		return this.transport.request("/api/me", { fetch: customFetch });
+	}
+	updateProfile(input) {
+		return this.transport.request("/api/me/profile", {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	getRules(customFetch) {
+		return this.transport.request("/api/me/rules", {
+			method: "GET",
+			fetch: customFetch
+		});
+	}
+	async setAuthToken(token) {
+		const trimmedToken = token.trim();
+		const response = await fetch(this.transportBaseUrl ? `${this.transportBaseUrl}/api/me` : "/api/me", { headers: { Authorization: `Bearer ${trimmedToken}` } });
+		if (!response.ok) {
+			const body = (response.headers.get("content-type") ?? "").includes("application/json") ? await response.json().catch(() => null) : await response.text().catch(() => response.statusText);
+			throw new HttpError((typeof body === "string" ? body : JSON.stringify(body ?? null)) || response.statusText, response.status, body);
+		}
+		this.setStoredAuthToken?.(trimmedToken);
+		return response.json();
+	}
+	async clearAuthToken() {
+		this.clearStoredAuthToken?.();
+		return null;
+	}
+	getSshKeys(customFetch) {
+		return this.transport.request("/api/user/ssh-keys", {
+			method: "GET",
+			fetch: customFetch
+		});
+	}
+	createSshKey(data) {
+		return this.transport.request("/api/user/ssh-keys", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(data)
+		});
+	}
+	deleteSshKey(id) {
+		return this.transport.request(`/api/user/ssh-keys/${id}`, { method: "DELETE" });
+	}
+};
+//#endregion
+//#region src/http.ts
+var CohubHttpClient = class {
+	spaces;
+	channels;
+	user;
+	generations;
+	models;
+	prompts;
+	sessionAccess;
+	search;
+	tasks;
+	cronJobs;
+	invite;
+	transport;
+	constructor(options = {}) {
+		const apiBaseUrl = resolveApiBaseUrl(options);
+		this.transport = new HttpTransport(options);
+		this.spaces = new SpacesApi(this.transport);
+		this.channels = new ChannelsApi(this.transport);
+		this.user = new UserApi(this.transport, apiBaseUrl, options.setStoredAuthToken, options.clearStoredAuthToken);
+		this.generations = new GenerationsApi(this.transport);
+		this.models = new ModelsApi(this.transport);
+		this.prompts = new PromptsApi(this.transport);
+		this.sessionAccess = new SessionAccessApi(this.transport);
+		this.search = new SearchApi(this.transport);
+		this.tasks = new TasksApi(this.transport);
+		this.cronJobs = new CronJobsApi(this.transport);
+		this.invite = new PublicInviteApi(this.transport);
+	}
+	space(spaceId) {
+		return new SpaceClient(spaceId, this.transport, null);
+	}
+};
+const createHttpClient = (options) => new CohubHttpClient(options);
+//#endregion
+export { PromptsApi as _, SpaceClient as a, CronJobsApi as b, SessionGenerationStreamClient as c, SessionPatchReducer as d, createSessionPatchReducer as f, SearchApi as g, SessionAccessApi as h, TasksApi as i, createSessionGenerationStreamClient as l, HttpTransport as m, createHttpClient as n, SpacesApi as o, HttpError as p, UserApi as r, PublicInviteApi as s, CohubHttpClient as t, parseAssistantMessageCommit as u, ModelsApi as v, ChannelsApi as x, GenerationsApi as y };