skydive-cli 0.1.0-beta.96 → 0.2.0-beta.421

package/dist/js/rest-CamHVOce.mjs

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+import { z } from "zod";
+import { createParser } from "eventsource-parser";
+
+//#region src/chat/api/rest.ts
+var HttpError = class extends Error {
+	constructor(status, body) {
+		super(`HTTP ${status}: ${body.slice(0, 200)}`);
+		this.status = status;
+		this.body = body;
+		this.name = "HttpError";
+	}
+};
+const ERROR_DETAIL_MAX_BODY = 2e3;
+/**
+* Fullest renderable text for a thrown value. `HttpError.message` clips the
+* response body to 200 chars (it flows into logs and one-line UIs); the
+* transcript renders errors collapsed to a single line, so it can afford the
+* whole body — capped with an explicit marker, never cut silently.
+*/
+function errorDetail(err) {
+	if (err instanceof HttpError) {
+		const body = err.body.length > ERROR_DETAIL_MAX_BODY ? `${err.body.slice(0, ERROR_DETAIL_MAX_BODY)}… (+${err.body.length - ERROR_DETAIL_MAX_BODY} chars)` : err.body;
+		return body ? `HTTP ${err.status}: ${body}` : `HTTP ${err.status}`;
+	}
+	return err instanceof Error ? err.message : String(err);
+}
+const MAX_STREAM_RECONNECTS = 5;
+function createRestClient({ appUrl, sessionToken }) {
+	const baseHeaders = {
+		authorization: `Bearer ${sessionToken}`,
+		accept: "application/json"
+	};
+	async function get(path, schema) {
+		const res = await fetch(`${appUrl}${path}`, { headers: baseHeaders });
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		return schema.parse(await res.json());
+	}
+	async function post(path, body, schema, method = "POST") {
+		const res = await fetch(`${appUrl}${path}`, {
+			method,
+			headers: {
+				...baseHeaders,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		return schema.parse(await res.json());
+	}
+	async function del(path) {
+		const res = await fetch(`${appUrl}${path}`, {
+			method: "DELETE",
+			headers: baseHeaders
+		});
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+	}
+	const streamEvents = async ({ path, label, signal, onEvent }) => {
+		let lastEventId = null;
+		let finished = false;
+		let reconnects = 0;
+		for (;;) {
+			if (signal.aborted) return;
+			try {
+				const headers = {
+					authorization: `Bearer ${sessionToken}`,
+					accept: "text/event-stream"
+				};
+				if (lastEventId) headers["last-event-id"] = lastEventId;
+				const res = await fetch(`${appUrl}${path}`, {
+					headers,
+					signal
+				});
+				if (!res.ok || !res.body) throw new HttpError(res.status, await res.text().catch(() => ""));
+				reconnects = 0;
+				const parser = createParser({ onEvent: (message) => {
+					if (message.id) lastEventId = message.id;
+					if (message.event === "error") {
+						const { error } = streamErrorSchema.parse(JSON.parse(message.data));
+						throw new Error(error);
+					}
+					const event = runStreamEventSchema.parse(JSON.parse(message.data));
+					if (event.kind === "finished") finished = true;
+					onEvent(event.kind === "finished" ? {
+						...event,
+						error: event.error ?? null
+					} : event);
+				} });
+				const decoder = new TextDecoder();
+				const reader = res.body.getReader();
+				try {
+					for (;;) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						parser.feed(decoder.decode(value, { stream: true }));
+						if (finished) return;
+					}
+				} finally {
+					try {
+						await reader.cancel();
+					} catch (_error) {}
+				}
+			} catch (err) {
+				if (signal.aborted) return;
+				if (err instanceof HttpError && err.status >= 400 && err.status < 500) throw err;
+				reconnects += 1;
+				if (reconnects > MAX_STREAM_RECONNECTS) throw err;
+				await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+				continue;
+			}
+			if (finished) return;
+			reconnects += 1;
+			if (reconnects > MAX_STREAM_RECONNECTS) throw new Error(`${label} stream ended unexpectedly`);
+			await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+		}
+	};
+	return {
+		listAgents: async ({ scope, onPage }) => {
+			const all = [];
+			let cursor;
+			const maxAgents = 2e3;
+			do {
+				const params = new URLSearchParams({
+					limit: "100",
+					scope,
+					sort: "mine_first_usage",
+					includeStats: "false"
+				});
+				if (cursor) params.set("cursor", cursor);
+				const page = await get(`/api/v1/agents?${params.toString()}`, listAgentsResponseSchema);
+				all.push(...page.agents);
+				cursor = page.nextCursor ?? void 0;
+				onPage?.([...all]);
+			} while (cursor && all.length < maxAgents);
+			return all;
+		},
+		createAgent: async ({ name }) => {
+			const { agent } = await post("/api/v1/agents", { name }, createAgentResponseSchema);
+			return agent;
+		},
+		getConversation: async ({ conversationId }) => {
+			const { conversation } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}`, getConversationResponseSchema);
+			return conversation;
+		},
+		listModels: async () => {
+			const { models } = await get("/api/v1/models", listModelsResponseSchema);
+			return models;
+		},
+		updateAgentModel: async ({ agentId, model }) => {
+			const { agent } = await post(`/api/v1/agents/${encodeURIComponent(agentId)}`, { model }, updateAgentResponseSchema, "PATCH");
+			return { model: agent.model ?? null };
+		},
+		listConversations: async ({ agentId, limit, channels, onPage }) => {
+			const all = [];
+			const maxConversations = limit ?? 5e3;
+			let cursor;
+			do {
+				const remaining = maxConversations - all.length;
+				const params = new URLSearchParams({
+					agentId,
+					includeTotal: "false"
+				});
+				params.set("limit", String(Math.min(remaining, 100)));
+				if (cursor) params.set("cursor", cursor);
+				for (const channel of channels ?? []) params.append("channels", channel);
+				const page = await get(`/api/v1/conversations?${params.toString()}`, listConversationsResponseSchema);
+				all.push(...page.conversations);
+				cursor = page.nextCursor ?? void 0;
+				onPage?.(limit ? all.slice(0, limit) : [...all]);
+			} while (cursor && all.length < maxConversations);
+			return limit ? all.slice(0, limit) : all;
+		},
+		listMessages: async ({ conversationId }) => {
+			const { messages } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}/messages`, listMessagesResponseSchema);
+			return messages;
+		},
+		listWorkspaceFiles: async ({ agentId }) => {
+			const { files } = await get(`/api/v1/workspace-files?${new URLSearchParams({ agentId }).toString()}`, listWorkspaceFilesResponseSchema);
+			return files;
+		},
+		readWorkspaceFile: async ({ fileId, maxBytes = 512 * 1024 }) => {
+			const res = await fetch(`${appUrl}/api/v1/workspace-files/${encodeURIComponent(fileId)}/download?disposition=inline`, { headers: {
+				...baseHeaders,
+				Range: `bytes=0-${maxBytes}`
+			} });
+			if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+			const bytes = new Uint8Array(await res.arrayBuffer());
+			const truncated = bytes.byteLength > maxBytes;
+			return {
+				text: new TextDecoder().decode(bytes.subarray(0, maxBytes)),
+				truncated
+			};
+		},
+		getRecap: async ({ conversationId }) => {
+			const { recap } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}/recap`, recapResponseSchema);
+			return recap?.text ?? null;
+		},
+		uploadAttachment: async ({ agentId, fileName, mediaType, data }) => {
+			const size = data.byteLength;
+			const presign = await post("/api/v1/attachments/presign", {
+				agentId,
+				fileName,
+				mediaType,
+				size
+			}, presignResponseSchema);
+			const putRes = await fetch(presign.uploadUrl, {
+				method: "PUT",
+				headers: { "content-type": mediaType },
+				body: new Uint8Array(data)
+			});
+			if (!putRes.ok) throw new HttpError(putRes.status, await putRes.text().catch(() => ""));
+			const finalized = await post(`/api/v1/attachments/${encodeURIComponent(presign.id)}/finalize`, {
+				agentId,
+				fileName: presign.fileName,
+				mediaType: presign.mediaType,
+				size
+			}, finalizeResponseSchema);
+			return {
+				id: presign.id,
+				fileName: finalized.fileName,
+				mediaType: finalized.mediaType,
+				sizeBytes: finalized.sizeBytes ?? size
+			};
+		},
+		deleteConversation: async ({ conversationId }) => {
+			await del(`/api/v1/conversations/${encodeURIComponent(conversationId)}`);
+		},
+		sendMessage: async ({ clientSurface, ...input }) => post("/api/v1/chat/send", {
+			...input,
+			clientSurface
+		}, sendResultSchema),
+		cancelRun: async ({ runId }) => {
+			await post(`/api/v1/chat/runs/${encodeURIComponent(runId)}/cancel`, {}, z.object({ ok: z.boolean() }));
+		},
+		cancelSteer: async ({ directiveId }) => {
+			await post(`/api/v1/chat/steer/${encodeURIComponent(directiveId)}/cancel`, {}, z.object({ ok: z.boolean() }));
+		},
+		oauthConnect: async (input) => {
+			const { connectLink } = await post("/api/v1/oauth/connect", input, oauthConnectResponseSchema);
+			return { connectLink };
+		},
+		externalOauthConnect: async (input) => {
+			const { authorizationUrl } = await post("/api/v1/external-oauth/connect", input, externalOauthConnectResponseSchema);
+			return { authorizationUrl: authorizationUrl ?? null };
+		},
+		fulfillCredential: async ({ url, body }) => {
+			const target = new URL(url, appUrl).toString();
+			const res = await fetch(target, {
+				method: "POST",
+				headers: {
+					...baseHeaders,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(body)
+			});
+			if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		},
+		streamRun: async ({ runId, signal, onEvent }) => streamEvents({
+			path: `/api/v1/chat/runs/${encodeURIComponent(runId)}/stream`,
+			label: "run",
+			signal,
+			onEvent
+		}),
+		streamMessage: async ({ messageId, signal, onEvent }) => streamEvents({
+			path: `/api/v1/chat/messages/${encodeURIComponent(messageId)}/stream`,
+			label: "message",
+			signal,
+			onEvent
+		}),
+		streamConversation: async ({ conversationId, signal, onEvent }) => {
+			let reconnects = 0;
+			for (;;) {
+				if (signal.aborted) return;
+				try {
+					const res = await fetch(`${appUrl}/api/v1/chat/conversations/${encodeURIComponent(conversationId)}/stream`, {
+						headers: {
+							authorization: `Bearer ${sessionToken}`,
+							accept: "text/event-stream"
+						},
+						signal
+					});
+					if (!res.ok || !res.body) throw new HttpError(res.status, await res.text().catch(() => ""));
+					reconnects = 0;
+					const parser = createParser({ onEvent: (message) => {
+						const parsed = conversationStreamEventSchema.safeParse(JSON.parse(message.data));
+						if (parsed.success) onEvent(parsed.data);
+					} });
+					const decoder = new TextDecoder();
+					const reader = res.body.getReader();
+					try {
+						for (;;) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							parser.feed(decoder.decode(value, { stream: true }));
+						}
+					} finally {
+						try {
+							await reader.cancel();
+						} catch (_error) {}
+					}
+				} catch (err) {
+					if (signal.aborted) return;
+					if (err instanceof HttpError && err.status >= 400 && err.status < 500) throw err;
+					reconnects += 1;
+					if (reconnects > MAX_STREAM_RECONNECTS) throw err;
+					await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+					continue;
+				}
+				if (signal.aborted) return;
+				reconnects += 1;
+				if (reconnects > MAX_STREAM_RECONNECTS) throw new Error("conversation stream ended unexpectedly");
+				await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+			}
+		}
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const agentSummarySchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	slug: z.string().nullable().optional(),
+	title: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	createdAt: z.string(),
+	creatorName: z.string().nullable().optional(),
+	model: z.string().nullable().optional(),
+	modelLocked: z.boolean().optional()
+});
+const platformModelSchema = z.object({
+	id: z.string(),
+	displayName: z.string(),
+	providerDisplay: z.string().optional(),
+	reasoning: z.boolean().optional(),
+	compliant: z.boolean().optional()
+}).passthrough();
+const listModelsResponseSchema = z.object({ models: z.array(platformModelSchema) });
+const updateAgentResponseSchema = z.object({ agent: z.object({ model: z.string().nullable().optional() }).passthrough() });
+const listAgentsResponseSchema = z.object({
+	agents: z.array(agentSummarySchema),
+	nextCursor: z.string().nullable().optional(),
+	totalCount: z.number().nullable().optional()
+});
+const createAgentResponseSchema = z.object({ agent: agentSummarySchema });
+const conversationSummarySchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	preview: z.string().nullable(),
+	channel: z.string().nullable(),
+	channelLabel: z.string().nullable(),
+	agent: z.object({
+		id: z.string().uuid(),
+		name: z.string(),
+		slug: z.string().nullable().optional(),
+		title: z.string().nullable().optional()
+	})
+});
+const conversationDetailSchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable(),
+	agentId: z.string().uuid(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const getConversationResponseSchema = z.object({ conversation: conversationDetailSchema });
+const listConversationsResponseSchema = z.object({
+	conversations: z.array(conversationSummarySchema),
+	nextCursor: z.string().nullable().optional(),
+	totalCount: z.number().optional()
+});
+const uiMessagePartSchema = z.union([
+	z.object({
+		type: z.literal("text"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("reasoning"),
+		text: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("dynamic-tool"),
+		toolCallId: z.string(),
+		toolName: z.string(),
+		input: z.unknown().optional(),
+		output: z.unknown().optional(),
+		state: z.string().optional(),
+		errorText: z.string().optional()
+	}),
+	z.object({ type: z.string() }).passthrough()
+]);
+const uiMessageSchema = z.object({
+	id: z.string(),
+	role: z.string(),
+	parts: z.array(uiMessagePartSchema),
+	metadata: z.object({ custom: z.object({
+		agentId: z.string().nullish(),
+		agentName: z.string().nullish()
+	}).passthrough().optional() }).passthrough().optional()
+});
+const recapResponseSchema = z.object({ recap: z.object({ text: z.string() }).nullable() });
+const listMessagesResponseSchema = z.object({ messages: z.array(uiMessageSchema) });
+const workspaceFileSchema = z.object({
+	id: z.string(),
+	path: z.string(),
+	mediaType: z.string(),
+	sizeBytes: z.number(),
+	contentHash: z.string(),
+	updatedAt: z.string(),
+	shareUrl: z.string()
+});
+const listWorkspaceFilesResponseSchema = z.object({ files: z.array(workspaceFileSchema) });
+const sendResultSchema = z.object({
+	runId: z.string(),
+	messageId: z.string().uuid().nullish(),
+	conversationId: z.string().uuid(),
+	isNewConversation: z.boolean(),
+	agentId: z.string().nullish(),
+	agentName: z.string().nullish(),
+	steered: z.boolean().optional(),
+	directive: z.object({ id: z.string() }).passthrough().optional()
+});
+const presignResponseSchema = z.object({
+	id: z.string(),
+	uploadUrl: z.string(),
+	fileName: z.string(),
+	mediaType: z.string()
+});
+const finalizeResponseSchema = z.object({
+	fileName: z.string(),
+	mediaType: z.string(),
+	sizeBytes: z.number().nullable().optional()
+});
+const oauthConnectResponseSchema = z.object({ connectLink: z.string() }).passthrough();
+const externalOauthConnectResponseSchema = z.object({ authorizationUrl: z.string().optional() }).passthrough();
+const runStreamEventSchema = z.union([z.object({
+	kind: z.literal("chunk"),
+	chunk: z.record(z.unknown())
+}), z.object({
+	kind: z.literal("finished"),
+	status: z.string(),
+	error: z.string().nullish()
+})]);
+const streamErrorSchema = z.object({ error: z.string() });
+const conversationStreamEventSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("conversation"),
+	id: z.string(),
+	title: z.string().nullable()
+}), z.object({
+	kind: z.literal("run"),
+	runId: z.string()
+})]);
+
+//#endregion
+export { createRestClient as n, errorDetail as r, HttpError as t };