@perstack/api-client 0.0.48 → 0.0.50

package/dist/{bundle.mjs → index.mjs}

@@ -2,6 +2,414 @@ import { r as __toESM, t as __commonJSMin } from "./chunk-Bdv87wj9.mjs";
 import { z } from "zod";
 import { activityOrGroupSchema, checkpointSchema as perstackCheckpointSchema, instructionMessageSchema, messageSchema, stepSchema, toolCallSchema, toolMessageSchema, toolResultSchema, usageSchema, userMessageSchema } from "@perstack/core";
 
+//#region src/lib/api-key.ts
+function matchWildcard(value, pattern) {
+	if (pattern === "*") return true;
+	if (pattern.endsWith("*")) return value.startsWith(pattern.slice(0, -1));
+	if (pattern.startsWith("*")) return value.endsWith(pattern.slice(1));
+	return value === pattern;
+}
+function matchOperations(operations, requiredOperation) {
+	return operations.some((pattern) => matchWildcard(requiredOperation, pattern));
+}
+function matchExperts(experts, expertId) {
+	if (experts === void 0 || experts === "*") return true;
+	return experts.some((pattern) => matchWildcard(expertId, pattern));
+}
+function isApiKeyPermissions(parsed) {
+	return typeof parsed === "object" && parsed !== null && "operations" in parsed && Array.isArray(parsed.operations);
+}
+function parseApiKeyPermissions(permissionsJson) {
+	if (!permissionsJson) return null;
+	try {
+		const parsed = JSON.parse(permissionsJson);
+		if (!isApiKeyPermissions(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function stringifyApiKeyPermissions(permissions) {
+	return JSON.stringify(permissions);
+}
+
+//#endregion
+//#region src/lib/auth.ts
+function buildAuthHeaders(auth) {
+	if (auth.type === "apiKey") return { Authorization: `Bearer ${auth.apiKey}` };
+	return { Cookie: auth.cookie };
+}
+
+//#endregion
+//#region src/lib/errors.ts
+function createValidationError(error) {
+	return {
+		errorType: "validation",
+		code: 400,
+		message: `Validation failed: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
+		reason: error.issues
+	};
+}
+function createAbortError() {
+	return {
+		errorType: "abort",
+		code: 0,
+		message: "Request aborted",
+		aborted: true
+	};
+}
+function createTimeoutError() {
+	return {
+		errorType: "timeout",
+		code: 0,
+		message: "Request timed out"
+	};
+}
+function createNetworkError(error) {
+	return {
+		errorType: "network",
+		code: 0,
+		message: error instanceof Error ? error.message : "Network error",
+		reason: error,
+		cause: error instanceof Error ? error : void 0
+	};
+}
+async function handleHttpError(response$23) {
+	let errorBody;
+	try {
+		errorBody = await response$23.json();
+	} catch {
+		errorBody = void 0;
+	}
+	return {
+		ok: false,
+		error: createHttpError(response$23.status, response$23.statusText, errorBody)
+	};
+}
+function createHttpError(status, statusText, body) {
+	if (typeof body === "object" && body !== null) {
+		const hasReason = "reason" in body;
+		if ("error" in body && typeof body.error === "string") return {
+			errorType: "http",
+			code: status,
+			message: body.error,
+			reason: hasReason ? body.reason : void 0
+		};
+		if (hasReason) return {
+			errorType: "http",
+			code: status,
+			message: statusText,
+			reason: body.reason
+		};
+	}
+	return {
+		errorType: "http",
+		code: status,
+		message: statusText
+	};
+}
+function isHttpError(error) {
+	return error.errorType === "http";
+}
+function isNetworkError(error) {
+	return error.errorType === "network";
+}
+function isTimeoutError(error) {
+	return error.errorType === "timeout";
+}
+function isValidationError(error) {
+	return error.errorType === "validation";
+}
+function isAbortError(error) {
+	return error.errorType === "abort";
+}
+function isClientError(error) {
+	return error.errorType !== "http";
+}
+
+//#endregion
+//#region src/lib/fetcher.ts
+const DEFAULT_BASE_URL = "https://api.perstack.ai";
+const DEFAULT_TIMEOUT = 3e4;
+function createFetcher(config) {
+	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+	const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+	const useCredentials = "credentials" in config && config.credentials === "include";
+	const apiKey = "apiKey" in config ? config.apiKey : void 0;
+	function buildUrl(path) {
+		return `${baseUrl}${path}`;
+	}
+	function buildHeaders(options) {
+		const headers = {};
+		if (options?.hasBody) headers["Content-Type"] = "application/json";
+		if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+		return headers;
+	}
+	function getCredentials() {
+		return useCredentials ? "include" : void 0;
+	}
+	function createTimeoutSignal(externalSignal) {
+		const controller = new AbortController();
+		let timedOut = false;
+		const timeoutId = setTimeout(() => {
+			timedOut = true;
+			controller.abort();
+		}, timeout);
+		let abortHandler;
+		if (externalSignal) if (externalSignal.aborted) controller.abort();
+		else {
+			abortHandler = () => controller.abort();
+			externalSignal.addEventListener("abort", abortHandler);
+		}
+		return {
+			signal: controller.signal,
+			cleanup: () => {
+				clearTimeout(timeoutId);
+				if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
+			},
+			isTimeout: () => timedOut
+		};
+	}
+	function wrapStreamWithIdleTimeout(stream, idleTimeoutMs, externalSignal) {
+		const reader = stream.getReader();
+		const controller = new AbortController();
+		let timeoutId;
+		let abortHandler;
+		if (externalSignal) if (externalSignal.aborted) controller.abort();
+		else {
+			abortHandler = () => controller.abort();
+			externalSignal.addEventListener("abort", abortHandler);
+		}
+		function resetTimeout() {
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = setTimeout(() => controller.abort(), idleTimeoutMs);
+		}
+		function cleanup() {
+			if (timeoutId) clearTimeout(timeoutId);
+			if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
+		}
+		return new ReadableStream({
+			start() {
+				resetTimeout();
+			},
+			async pull(streamController) {
+				try {
+					const result = await Promise.race([reader.read(), new Promise((_, reject) => {
+						if (controller.signal.aborted) reject(new DOMException("Stream idle timeout", "AbortError"));
+						controller.signal.addEventListener("abort", () => {
+							reject(new DOMException("Stream idle timeout", "AbortError"));
+						});
+					})]);
+					if (result.done) {
+						cleanup();
+						streamController.close();
+						return;
+					}
+					resetTimeout();
+					streamController.enqueue(result.value);
+				} catch (error) {
+					cleanup();
+					reader.cancel().catch(() => {});
+					if (error instanceof DOMException && error.name === "AbortError") streamController.error(new DOMException("Stream idle timeout", "AbortError"));
+					else streamController.error(error);
+				}
+			},
+			cancel(reason) {
+				cleanup();
+				reader.cancel(reason).catch(() => {});
+			}
+		});
+	}
+	async function request$23(method, path, body, options) {
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+		try {
+			const response$23 = await fetch(buildUrl(path), {
+				method,
+				headers: buildHeaders(body ? { hasBody: true } : void 0),
+				body: body ? JSON.stringify(body) : void 0,
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$23.ok) return handleHttpError(response$23);
+			return {
+				ok: true,
+				data: await response$23.json()
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		} finally {
+			cleanup();
+		}
+	}
+	async function requestBlob(path, options) {
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+		try {
+			const response$23 = await fetch(buildUrl(path), {
+				method: "GET",
+				headers: buildHeaders(),
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$23.ok) return handleHttpError(response$23);
+			return {
+				ok: true,
+				data: await response$23.blob()
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		} finally {
+			cleanup();
+		}
+	}
+	async function requestStream(path, options) {
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+		try {
+			const response$23 = await fetch(buildUrl(path), {
+				method: "GET",
+				headers: buildHeaders(),
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$23.ok) {
+				cleanup();
+				return handleHttpError(response$23);
+			}
+			if (!response$23.body) {
+				cleanup();
+				return {
+					ok: false,
+					error: createNetworkError(/* @__PURE__ */ new Error("Response body is null"))
+				};
+			}
+			cleanup();
+			const idleTimeout = options?.streamIdleTimeout ?? timeout;
+			return {
+				ok: true,
+				data: wrapStreamWithIdleTimeout(response$23.body, idleTimeout, options?.signal)
+			};
+		} catch (error) {
+			cleanup();
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		}
+	}
+	async function requestNoContent(method, path, options) {
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+		try {
+			const response$23 = await fetch(buildUrl(path), {
+				method,
+				headers: buildHeaders(),
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$23.ok) return handleHttpError(response$23);
+			return {
+				ok: true,
+				data: void 0
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		} finally {
+			cleanup();
+		}
+	}
+	return {
+		get: (path, options) => request$23("GET", path, void 0, options),
+		post: (path, body, options) => request$23("POST", path, body, options),
+		put: (path, body, options) => request$23("PUT", path, body, options),
+		delete: (path, options) => request$23("DELETE", path, void 0, options),
+		deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
+		getBlob: (path, options) => requestBlob(path, options),
+		getStream: (path, options) => requestStream(path, options)
+	};
+}
+
+//#endregion
+//#region src/lib/query-string.ts
+function buildQueryString(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) searchParams.set(key, String(value));
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+
+//#endregion
+//#region src/lib/sse.ts
+async function* parseSSE(reader) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const events = buffer.split("\n\n");
+		buffer = events.pop() || "";
+		for (const event of events) {
+			if (event.trim() === "") continue;
+			const lines = event.split("\n");
+			const eventType = lines.find((line) => line.startsWith("event:"))?.slice(6).trim();
+			const data = lines.find((line) => line.startsWith("data:"))?.slice(5).trim();
+			if (eventType !== "message" || !data) continue;
+			try {
+				yield JSON.parse(data);
+			} catch {}
+		}
+	}
+}
+
+//#endregion
 //#region ../constants/index.ts
 const organizationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
 const maxOrganizationNameLength = 128;
@@ -44,13 +452,13 @@ const maxProviderHeadersCount = 50;
 
 //#endregion
 //#region ../models/src/domain/common.ts
-const cuidSchema = z.cuid2();
+const cuidSchema = z.string().cuid2();
+const cuidRequestSchema = z.string().min(24).cuid2();
 const runtimeVersionSchema = z.enum(["v1.0"]);
 const providerSchema = z.enum([
 	"anthropic",
 	"google",
 	"openai",
-	"ollama",
 	"deepseek",
 	"azure-openai",
 	"amazon-bedrock",
@@ -154,7 +562,7 @@ const createApiKeyResponseSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/api-keys/create.ts
-const request$49 = { body: z.object({
+const request$22 = { body: z.object({
 	name: z.string().min(1).max(255).optional(),
 	operations: z.array(z.string()).optional(),
 	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
@@ -162,7 +570,7 @@ const request$49 = { body: z.object({
 	applicationIds: z.array(cuidSchema).optional(),
 	expiresIn: z.number().min(60).optional()
 }) };
-const response$51 = z.object({ data: z.object({
+const response$22 = z.object({ data: z.object({
 	apiKey: apiKeySchema.extend({
 		permissions: apiKeyPermissionsSchema.optional(),
 		wildcardApplicationAccess: z.boolean(),
@@ -173,8 +581,8 @@ const response$51 = z.object({ data: z.object({
 
 //#endregion
 //#region ../models/src/api/api-keys/get.ts
-const request$48 = { params: z.object({ apiKeyId: cuidSchema }) };
-const response$50 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
+const request$21 = { params: z.object({ apiKeyId: cuidSchema }) };
+const response$21 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
 	permissions: apiKeyPermissionsSchema.optional(),
 	wildcardApplicationAccess: z.boolean(),
 	applicationIds: z.array(cuidSchema)
@@ -266,25 +674,24 @@ const errorUnauthorizedFlexible = z.object({
 }).describe("Unauthorized");
 
 //#endregion
-//#region ../models/src/api/api-keys/getAll.ts
-const request$47 = { query: z.object({
-	take: z.coerce.number().min(1).max(100).default(20),
-	skip: z.coerce.number().min(0).default(0)
-}) };
-const apiKeyWithApplicationsSchema = apiKeySchema.extend({
+//#region ../models/src/api/api-keys/revoke.ts
+const request$20 = { params: z.object({ apiKeyId: cuidSchema }) };
+const response$20 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
 	permissions: apiKeyPermissionsSchema.optional(),
 	wildcardApplicationAccess: z.boolean(),
 	applicationIds: z.array(cuidSchema)
-});
-const response$49 = z.object({
-	data: z.object({ apiKeys: z.array(apiKeyWithApplicationsSchema) }),
-	meta: paginationMeta
-});
+}) }) });
 
 //#endregion
-//#region ../models/src/api/api-keys/revoke.ts
-const request$46 = { params: z.object({ apiKeyId: cuidSchema }) };
-const response$48 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
+//#region ../models/src/api/api-keys/update.ts
+const request$19 = {
+	params: z.object({ apiKeyId: cuidSchema }),
+	body: z.object({
+		applicationIds: z.array(cuidSchema).optional(),
+		wildcardApplicationAccess: z.boolean().optional()
+	})
+};
+const response$19 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
 	permissions: apiKeyPermissionsSchema.optional(),
 	wildcardApplicationAccess: z.boolean(),
 	applicationIds: z.array(cuidSchema)
@@ -313,25 +720,15 @@ const applicationSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/applications/create.ts
-const request$45 = { body: z.object({
+const request$18 = { body: z.object({
 	name: applicationNameSchema,
 	applicationGroupId: cuidSchema.optional()
 }) };
-const response$47 = z.object({ data: z.object({ application: applicationSchema }) });
-
-//#endregion
-//#region ../models/src/api/applications/delete.ts
-const request$44 = { params: z.object({ applicationId: cuidSchema }) };
-const response$46 = z.object({ data: z.object({ application: applicationSchema }) });
-
-//#endregion
-//#region ../models/src/api/applications/get.ts
-const request$43 = { params: z.object({ applicationId: cuidSchema }) };
-const response$45 = z.object({ data: z.object({ application: applicationSchema }) });
+const response$18 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/api/applications/getAll.ts
-const request$42 = { query: z.object({
+const request$17 = { query: z.object({
 	name: z.union([z.string(), z.array(z.string())]).optional().transform((v) => Array.isArray(v) ? v.join(",") : v),
 	sort: z.enum([
 		"name",
@@ -342,21 +739,21 @@ const request$42 = { query: z.object({
 	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$44 = z.object({
+const response$17 = z.object({
 	data: z.object({ applications: z.array(applicationSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
 //#region ../models/src/api/applications/update.ts
-const request$41 = {
+const request$16 = {
 	params: z.object({ applicationId: cuidSchema }),
 	body: z.object({
 		name: applicationNameSchema.optional(),
 		status: applicationStatusSchema.exclude(["deleted"]).optional()
 	}).refine((data) => data.name !== void 0 || data.status !== void 0, { message: "At least one field must be provided" })
 };
-const response$43 = z.object({ data: z.object({ application: applicationSchema }) });
+const response$16 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/domain/secret.ts
@@ -378,44 +775,28 @@ const secretSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/secrets/create.ts
-const request$40 = { body: z.object({
+const request$15 = { body: z.object({
 	applicationId: cuidSchema,
 	name: secretNameSchema,
 	value: secretValueSchema
 }) };
-const response$42 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
-
-//#endregion
-//#region ../models/src/api/env/secrets/delete.ts
-const request$39 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$41 = z.null();
-
-//#endregion
-//#region ../models/src/api/env/secrets/get.ts
-const request$38 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$40 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$15 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/getAll.ts
-const request$37 = { query: z.object({ applicationId: cuidSchema.optional() }) };
-const response$39 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
+const request$14 = { query: z.object({ applicationId: cuidSchema.optional() }) };
+const response$14 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/update.ts
-const request$36 = {
+const request$13 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: secretValueSchema
 	})
 };
-const response$38 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$13 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/domain/variable.ts
@@ -439,44 +820,28 @@ const variableResponseSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/variables/create.ts
-const request$35 = { body: z.object({
+const request$12 = { body: z.object({
 	applicationId: cuidSchema,
 	name: variableNameSchema,
 	value: variableValueSchema
 }) };
-const response$37 = z.object({ data: z.object({ variable: variableResponseSchema }) });
-
-//#endregion
-//#region ../models/src/api/env/variables/delete.ts
-const request$34 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$36 = z.null();
-
-//#endregion
-//#region ../models/src/api/env/variables/get.ts
-const request$33 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$35 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$12 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/getAll.ts
-const request$32 = { query: z.object({ applicationId: cuidSchema }) };
-const response$34 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
+const request$11 = { query: z.object({ applicationId: cuidSchema }) };
+const response$11 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/update.ts
-const request$31 = {
+const request$10 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: variableValueSchema
 	})
 };
-const response$33 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$10 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/domain/expertScope.ts
@@ -484,6 +849,7 @@ const expertScopeSchema = z.object({
 	id: cuidSchema,
 	name: scopeNameSchema,
 	organizationId: cuidSchema,
+	expertDraftScopeId: cuidSchema,
 	published: z.boolean(),
 	publishedAt: datetimeSchema.optional(),
 	category: expertCategoryFieldSchema,
@@ -602,171 +968,9 @@ const expertWithMetadataSchema = expertSchema.extend({
 	version: expertVersionSchema
 });
 
-//#endregion
-//#region ../models/src/api/experts/definition.ts
-const expertDefinitionSchema = z.object({
-	name: expertNameFieldSchema,
-	version: expertVersionFieldSchema,
-	organizationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	createdBy: cuidSchema,
-	updatedBy: cuidSchema,
-	experts: z.record(expertKeyFieldSchema, expertSchema.omit({ key: true }))
-});
-
-//#endregion
-//#region ../models/src/api/experts/delete.ts
-const request$30 = { params: z.object({ scopeName: scopeNameRefSchema }) };
-const response$32 = z.object({ data: expertMetadataSchema.extend({
-	yanked: z.literal(true),
-	latestTagUpdated: z.boolean()
-}) });
-
-//#endregion
-//#region ../models/src/domain/expertDraftScope.ts
-const expertDraftScopeSchema = z.object({
-	id: cuidSchema,
-	name: scopeNameSchema,
-	organizationId: cuidSchema,
-	applicationId: cuidSchema,
-	totalRuns: z.number().int().min(0),
-	totalJobs: z.number().int().min(0),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	createdBy: cuidSchema,
-	updatedBy: cuidSchema
-});
-const expertDraftRefSchema = z.object({
-	id: cuidSchema,
-	expertDraftScopeId: cuidSchema,
-	totalRuns: z.number().int().min(0),
-	totalJobs: z.number().int().min(0),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	createdBy: cuidSchema,
-	updatedBy: cuidSchema
-});
-const expertDraftScopeWithRefsSchema = expertDraftScopeSchema.extend({ draftRefs: z.array(expertDraftRefSchema) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/definition.ts
-const expertDefinitionContentSchema = z.object({
-	name: expertNameFieldSchema,
-	version: z.literal("0.0.0-draft"),
-	applicationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	createdBy: cuidSchema,
-	updatedBy: cuidSchema,
-	experts: z.record(expertKeyFieldSchema, expertSchema.omit({ key: true }))
-});
-
-//#endregion
-//#region ../models/src/api/experts/drafts/create.ts
-const request$29 = {
-	params: z.object({ scopeName: scopeNameSchema }),
-	body: z.object({
-		applicationId: cuidSchema,
-		experts: z.array(expertSchema)
-	})
-};
-const response$31 = z.object({ data: z.object({
-	scope: expertDraftScopeSchema,
-	draftRef: expertDraftRefSchema,
-	definition: expertDefinitionContentSchema
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/delete.ts
-const request$28 = { params: z.object({
-	scopeName: scopeNameSchema,
-	draftRef: expertDraftRefSchema.shape.id
-}) };
-const response$30 = z.object({ data: z.object({
-	deleted: z.boolean(),
-	draftRef: z.string()
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/get.ts
-const request$27 = { params: z.object({
-	scopeName: scopeNameSchema,
-	draftRef: expertDraftRefSchema.shape.id
-}) };
-const response$29 = z.object({ data: z.object({
-	scope: expertDraftScopeSchema,
-	draftRef: expertDraftRefSchema,
-	definition: expertDefinitionContentSchema
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/getAll.ts
-const request$26 = {
-	params: z.object({ scopeName: expertDraftScopeSchema.shape.name }),
-	query: z.object({
-		take: z.coerce.number().int().min(1).max(100).default(20),
-		skip: z.coerce.number().int().min(0).default(0)
-	})
-};
-const response$28 = z.object({
-	data: z.object({ draftRefs: z.array(expertDraftRefSchema) }),
-	meta: paginationMeta
-});
-
-//#endregion
-//#region ../models/src/api/experts/drafts/update.ts
-const request$25 = {
-	params: z.object({
-		scopeName: scopeNameSchema,
-		draftRef: expertDraftRefSchema.shape.id
-	}),
-	body: z.object({ experts: z.array(expertSchema) })
-};
-const response$27 = z.object({ data: z.object({
-	scope: expertDraftScopeSchema,
-	draftRef: expertDraftRefSchema,
-	definition: expertDefinitionContentSchema
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/version.ts
-const request$24 = {
-	params: z.object({
-		scopeName: scopeNameSchema,
-		draftRef: z.string().min(1)
-	}),
-	body: z.object({
-		version: z.string().min(1, "Version is required.").max(maxExpertVersionTagLength, "Version is too long.").regex(expertVersionRegex, "Invalid version format. (e.g. 1.0.0)"),
-		tag: z.string().max(maxExpertVersionTagLength, "Tag is too long.").regex(tagNameRegex, "Invalid tag format. (e.g. latest)").optional()
-	})
-};
-const response$26 = z.object({ data: z.object({
-	scope: expertScopeSchema,
-	version: expertVersionSchema,
-	definitionUrl: z.string()
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/featured.ts
-const response$25 = z.object({ data: z.object({ featuredExperts: z.array(z.object({
-	scope: expertScopeSchema,
-	currentVersion: expertVersionSchema,
-	displayOrder: z.number().int().min(0).max(2),
-	featuredAt: z.string().datetime()
-})) }) });
-
-//#endregion
-//#region ../models/src/api/experts/get.ts
-const request$23 = { params: z.object({ scopeName: scopeNameRefSchema }) };
-const response$24 = z.object({ data: z.object({
-	definition: expertDefinitionSchema,
-	yanked: z.boolean().optional()
-}) });
-
 //#endregion
 //#region ../models/src/api/experts/getAll.ts
-const request$22 = { query: z.object({
+const request$9 = { query: z.object({
 	filter: z.string().describe("Filter by scope name (partial match)").optional(),
 	category: z.enum([
 		"general",
@@ -775,38 +979,15 @@ const request$22 = { query: z.object({
 		"writing",
 		"data",
 		"automation"
-	]).describe("Filter by category").optional(),
-	includeDrafts: z.coerce.boolean().default(false).describe("Include unpublished scopes (owner only)").optional(),
-	take: z.coerce.number().min(1).max(100).default(20),
-	skip: z.coerce.number().min(0).default(0)
-}) };
-const response$23 = z.object({
-	data: z.object({ experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema })) }),
-	meta: paginationMeta
-});
-
-//#endregion
-//#region ../models/src/api/experts/meta.ts
-const request$21 = {
-	params: z.object({ scopeName: scopeNameRefSchema }),
-	query: z.object({ public: z.enum(["true", "false"]).transform((val) => val === "true").optional().default(false).describe("Public access check (no auth)") })
-};
-const response$22 = z.object({ data: expertMetadataSchema.extend({ definitionUrl: z.string() }) });
-
-//#endregion
-//#region ../models/src/api/experts/publish.ts
-const request$20 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$21 = z.object({ data: z.object({ scope: expertScopeSchema }) });
-
-//#endregion
-//#region ../models/src/api/experts/unpublish.ts
-const request$19 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$20 = z.object({ data: z.object({ scope: expertScopeSchema }) });
-
-//#endregion
-//#region ../models/src/api/experts/versions.ts
-const request$18 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$19 = z.object({ data: z.object({ versions: z.array(expertVersionSchema) }) });
+	]).describe("Filter by category").optional(),
+	includeDrafts: z.coerce.boolean().default(false).describe("Include unpublished scopes (owner only)").optional(),
+	take: z.coerce.number().min(1).max(100).default(20),
+	skip: z.coerce.number().min(0).default(0)
+}) };
+const response$9 = z.object({
+	data: z.object({ experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema.nullable() })) }),
+	meta: paginationMeta
+});
 
 //#endregion
 //#region ../models/src/domain/checkpoint.ts
@@ -885,26 +1066,18 @@ const requestCheckpointSchema = perstackCheckpointSchema.omit({
 	id: true,
 	runId: true
 }).extend({ runId: z.string().optional() });
-const request$17 = {
+const request$8 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({
 		checkpoint: requestCheckpointSchema,
 		step: stepSchema
 	})
 };
-const response$18 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/checkpoints/get.ts
-const request$16 = { params: z.object({
-	jobId: cuidSchema,
-	checkpointId: cuidSchema
-}) };
-const response$17 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
+const response$8 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/checkpoints/getAll.ts
-const request$15 = {
+const request$7 = {
 	params: z.object({ jobId: cuidSchema }),
 	query: z.object({
 		filter: z.string().min(1).max(256).optional(),
@@ -914,16 +1087,11 @@ const request$15 = {
 		skip: z.coerce.number().min(0).default(0)
 	})
 };
-const response$16 = z.object({
+const response$7 = z.object({
 	data: z.object({ checkpoints: z.array(apiCheckpointSchema) }),
 	meta: paginationMeta
 });
 
-//#endregion
-//#region ../models/src/api/jobs/checkpoints/stream.ts
-const request$14 = { params: z.object({ jobId: cuidSchema }) };
-const response$15 = z.object({ data: apiCheckpointSchema });
-
 //#endregion
 //#region ../support-models/src/index.ts
 const anthropicSupportModels = [
@@ -1124,7 +1292,7 @@ const jobSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/jobs/continue.ts
-const request$13 = {
+const request$6 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({
 		query: jobSchema.shape.query.optional(),
@@ -1137,11 +1305,11 @@ const request$13 = {
 		maxRetries: z.coerce.number().optional()
 	})
 };
-const response$14 = z.object({ data: z.object({ job: jobSchema }) });
+const response$6 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/create.ts
-const request$12 = { body: z.object({
+const request$5 = { body: z.object({
 	applicationId: cuidSchema.describe("Application ID to create the job in"),
 	expertKey: expertKeyFieldSchema,
 	query: jobSchema.shape.query.optional(),
@@ -1152,33 +1320,28 @@ const request$12 = { body: z.object({
 	maxSteps: z.coerce.number().optional(),
 	maxRetries: z.coerce.number().optional()
 }) };
-const response$13 = z.object({ data: z.object({ job: jobSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/get.ts
-const request$11 = { params: z.object({ jobId: cuidSchema }) };
-const response$12 = z.object({ data: z.object({ job: jobSchema }) });
+const response$5 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/getAll.ts
-const request$10 = { query: z.object({
+const request$4 = { query: z.object({
 	sort: z.enum(["createdAt", "updatedAt"]).optional(),
 	order: z.enum(["asc", "desc"]).optional(),
 	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$11 = z.object({
+const response$4 = z.object({
 	data: z.object({ jobs: z.array(jobSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
 //#region ../models/src/api/jobs/update.ts
-const request$9 = {
+const request$3 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({ status: jobStatusSchema })
 };
-const response$10 = z.object({ data: z.object({ job: jobSchema }) });
+const response$3 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/domain/providerSetting.ts
@@ -1255,7 +1418,7 @@ const providerApiKeyMetadataSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/provider-settings/api-keys/create.ts
-const request$8 = {
+const request$2 = {
 	params: z.object({
 		applicationId: cuidSchema,
 		provider: providerSchema
@@ -1264,947 +1427,433 @@ const request$8 = {
 		name: z.string().min(1).max(255),
 		value: z.string().min(1)
 	})
-};
-const response$9 = z.object({ data: z.object({ apiKey: providerApiKeyMetadataSchema }) });
-
-//#endregion
-//#region ../models/src/api/provider-settings/api-keys/delete.ts
-const request$7 = { params: z.object({
-	applicationId: cuidSchema,
-	provider: providerSchema,
-	apiKeyId: cuidSchema
-}) };
-const response$8 = z.null();
-
-//#endregion
-//#region ../models/src/api/provider-settings/api-keys/getAll.ts
-const request$6 = { params: z.object({
-	applicationId: cuidSchema,
-	provider: providerSchema
-}) };
-const response$7 = z.object({ data: z.object({ apiKeys: z.array(providerApiKeyMetadataSchema) }) });
-
-//#endregion
-//#region ../models/src/api/provider-settings/create.ts
-const request$5 = {
-	params: z.object({ applicationId: cuidSchema }),
-	body: z.object({
-		provider: providerSchema,
-		settings: providerSettingsSchema.optional()
-	})
-};
-const response$6 = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
-
-//#endregion
-//#region ../models/src/api/provider-settings/delete.ts
-const request$4 = { params: z.object({
-	applicationId: cuidSchema,
-	provider: providerSchema
-}) };
-const response$5 = z.null();
-
-//#endregion
-//#region ../models/src/api/provider-settings/get.ts
-const request$3 = { params: z.object({
-	applicationId: cuidSchema,
-	provider: providerSchema
-}) };
-const response$4 = z.object({ data: z.object({
-	providerSetting: providerSettingResponseSchema,
-	apiKeys: z.array(providerApiKeyMetadataSchema)
-}) });
-
-//#endregion
-//#region ../models/src/api/provider-settings/getAll.ts
-const request$2 = { params: z.object({ applicationId: cuidSchema }) };
-const response$3 = z.object({ data: z.object({ providerSettings: z.array(providerSettingResponseSchema) }) });
-
-//#endregion
-//#region ../models/src/api/provider-settings/update.ts
-const request$1 = {
-	params: z.object({
-		applicationId: cuidSchema,
-		provider: providerSchema
-	}),
-	body: z.object({ settings: providerSettingsSchema.optional() })
-};
-const response$2 = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
-
-//#endregion
-//#region ../models/src/api/session/get.ts
-const response$1 = z.object({ data: z.object({
-	user: userSchema,
-	organization: organizationSchema,
-	application: applicationSchema.nullable()
-}) });
-
-//#endregion
-//#region ../models/src/api/session/setApplication.ts
-const request = { body: z.object({ applicationId: z.string().min(1, "Application ID is required") }) };
-const response = z.object({ data: z.object({ success: z.literal(true) }) });
-
-//#endregion
-//#region ../models/src/domain/providerApiKey.ts
-const providerApiKeyNameSchema = z.string().min(1).max(255);
-const providerApiKeyValueSchema = z.string().min(1);
-const providerApiKeySchema = z.object({
-	type: z.literal("providerApiKey"),
-	id: cuidSchema,
-	providerSettingId: cuidSchema,
-	name: providerApiKeyNameSchema,
-	lastUsedAt: datetimeSchema.optional(),
-	expiresAt: datetimeSchema.optional(),
-	providerSetting: providerSettingSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-
-//#endregion
-//#region ../models/src/domain/run.ts
-const runStatusSchema = z.enum([
-	"queued",
-	"processing",
-	"completed",
-	"stoppedByInteractiveTool",
-	"stoppedByDelegate",
-	"stoppedByExceededMaxSteps",
-	"stoppedByError"
-]);
-const runSchema = z.object({
-	type: z.literal("run"),
-	id: cuidSchema,
-	jobId: cuidSchema,
-	parentRunId: cuidSchema.optional(),
-	organizationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	status: runStatusSchema,
-	runtimeVersion: runtimeVersionSchema,
-	expertKey: expertKeyFieldSchema,
-	interactiveToolCallResult: z.boolean().optional(),
-	expert: expertWithMetadataSchema,
-	stepNumber: z.number().int().min(0),
-	usage: usageSchema,
-	machineId: z.string().optional()
-});
-
-//#endregion
-//#region src/lib/errors.ts
-function createValidationError(error) {
-	return {
-		errorType: "validation",
-		code: 400,
-		message: `Validation failed: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
-		reason: error.issues
-	};
-}
-function createAbortError() {
-	return {
-		errorType: "abort",
-		code: 0,
-		message: "Request aborted",
-		aborted: true
-	};
-}
-function createTimeoutError() {
-	return {
-		errorType: "timeout",
-		code: 0,
-		message: "Request timed out"
-	};
-}
-function createNetworkError(error) {
-	return {
-		errorType: "network",
-		code: 0,
-		message: error instanceof Error ? error.message : "Network error",
-		reason: error,
-		cause: error instanceof Error ? error : void 0
-	};
-}
-async function handleHttpError(response$52) {
-	let errorBody;
-	try {
-		errorBody = await response$52.json();
-	} catch {
-		errorBody = void 0;
-	}
-	return {
-		ok: false,
-		error: createHttpError(response$52.status, response$52.statusText, errorBody)
-	};
-}
-function createHttpError(status, statusText, body) {
-	if (typeof body === "object" && body !== null) {
-		const hasReason = "reason" in body;
-		if ("error" in body && typeof body.error === "string") return {
-			errorType: "http",
-			code: status,
-			message: body.error,
-			reason: hasReason ? body.reason : void 0
-		};
-		if (hasReason) return {
-			errorType: "http",
-			code: status,
-			message: statusText,
-			reason: body.reason
-		};
-	}
-	return {
-		errorType: "http",
-		code: status,
-		message: statusText
-	};
-}
-function isHttpError(error) {
-	return error.errorType === "http";
-}
-function isNetworkError(error) {
-	return error.errorType === "network";
-}
-function isTimeoutError(error) {
-	return error.errorType === "timeout";
-}
-function isValidationError(error) {
-	return error.errorType === "validation";
-}
-function isAbortError(error) {
-	return error.errorType === "abort";
-}
-function isClientError(error) {
-	return error.errorType !== "http";
-}
-
-//#endregion
-//#region src/endpoints/api-keys.ts
-const BASE_PATH$6 = "/api/v1/api_keys";
-function createApiKeysApi(fetcher) {
-	return {
-		async create(input, options) {
-			const result = request$49.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$6, input, options);
-		},
-		async list(input, options) {
-			const queryParams = new URLSearchParams();
-			if (input?.take !== void 0) queryParams.set("take", String(input.take));
-			if (input?.skip !== void 0) queryParams.set("skip", String(input.skip));
-			const queryString = queryParams.toString();
-			const url = queryString ? `${BASE_PATH$6}?${queryString}` : BASE_PATH$6;
-			return fetcher.get(url, options);
-		},
-		async get(id, options) {
-			const result = request$48.params.safeParse({ apiKeyId: id });
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.get(`${BASE_PATH$6}/${id}`, options);
-		},
-		async revoke(id, options) {
-			const result = request$46.params.safeParse({ apiKeyId: id });
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${BASE_PATH$6}/${id}/revoke`, {}, options);
-		}
-	};
-}
-
-//#endregion
-//#region src/lib/query-string.ts
-function buildQueryString(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	for (const [key, value] of Object.entries(params)) if (value !== void 0) searchParams.set(key, String(value));
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
-
-//#endregion
-//#region src/endpoints/applications.ts
-const BASE_PATH$5 = "/api/v1/applications";
-function createApplicationsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$42.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$5}${queryString}`, options);
-		},
-		async get(id, options) {
-			return fetcher.get(`${BASE_PATH$5}/${id}`, options);
-		},
-		async create(input, options) {
-			const result = request$45.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$5, input, options);
-		},
-		async update(id, input, options) {
-			const result = request$41.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${BASE_PATH$5}/${id}`, input, options);
-		},
-		async delete(id, options) {
-			return fetcher.delete(`${BASE_PATH$5}/${id}`, options);
-		}
-	};
-}
+};
+const response$2 = z.object({ data: z.object({ apiKey: providerApiKeyMetadataSchema }) });
 
 //#endregion
-//#region src/endpoints/env-secrets.ts
-const BASE_PATH$4 = "/api/v1/env/secrets";
-function createSecretsApi(fetcher) {
+//#region ../models/src/api/provider-settings/create.ts
+const request$1 = {
+	params: z.object({ applicationId: cuidSchema }),
+	body: z.object({
+		provider: providerSchema,
+		settings: providerSettingsSchema.optional()
+	})
+};
+const response$1 = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
+
+//#endregion
+//#region ../models/src/api/provider-settings/update.ts
+const request = {
+	params: z.object({
+		applicationId: cuidSchema,
+		provider: providerSchema
+	}),
+	body: z.object({ settings: providerSettingsSchema.optional() })
+};
+const response = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
+
+//#endregion
+//#region src/endpoints/api-keys.ts
+const BASE_PATH$6 = "/api/v1/api_keys";
+function createApiKeysApi(fetcher) {
 	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$37.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
-		},
-		async get(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$4}/${encodedName}`, options);
-		},
 		async create(input, options) {
-			const result = request$40.body.safeParse(input);
+			const result = request$22.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH$4, input, options);
+			return fetcher.post(BASE_PATH$6, input, options);
 		},
-		async update(name, input, options) {
-			const result = request$36.body.safeParse(input);
+		async list(input, options) {
+			const queryParams = new URLSearchParams();
+			if (input?.take !== void 0) queryParams.set("take", String(input.take));
+			if (input?.skip !== void 0) queryParams.set("skip", String(input.skip));
+			const queryString = queryParams.toString();
+			const url = queryString ? `${BASE_PATH$6}?${queryString}` : BASE_PATH$6;
+			return fetcher.get(url, options);
+		},
+		async get(id, options) {
+			const result = request$21.params.safeParse({ apiKeyId: id });
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$4}/${encodedName}`, input, options);
+			return fetcher.get(`${BASE_PATH$6}/${id}`, options);
 		},
-		async delete(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$4}/${encodedName}`, options);
-		}
-	};
-}
-
-//#endregion
-//#region src/endpoints/env-variables.ts
-const BASE_PATH$3 = "/api/v1/env/variables";
-function createVariablesApi(fetcher) {
-	return {
-		async list(params, options) {
-			const result = request$32.query.safeParse(params);
+		async revoke(id, options) {
+			const result = request$20.params.safeParse({ apiKeyId: id });
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$3}${queryString}`, options);
-		},
-		async get(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.post(`${BASE_PATH$6}/${id}/revoke`, {}, options);
 		},
-		async create(input, options) {
-			const result = request$35.body.safeParse(input);
-			if (!result.success) return {
+		async update(id, input, options) {
+			const paramsResult = request$19.params.safeParse({ apiKeyId: id });
+			if (!paramsResult.success) return {
 				ok: false,
-				error: createValidationError(result.error)
+				error: createValidationError(paramsResult.error)
 			};
-			return fetcher.post(BASE_PATH$3, input, options);
-		},
-		async update(name, input, options) {
-			const result = request$31.body.safeParse(input);
-			if (!result.success) return {
+			const bodyResult = request$19.body.safeParse(input);
+			if (!bodyResult.success) return {
 				ok: false,
-				error: createValidationError(result.error)
+				error: createValidationError(bodyResult.error)
 			};
-			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
-		},
-		async delete(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.post(`${BASE_PATH$6}/${id}`, input, options);
 		}
 	};
 }
 
 //#endregion
-//#region src/endpoints/env.ts
-function createEnvApi(fetcher) {
-	return {
-		secrets: createSecretsApi(fetcher),
-		variables: createVariablesApi(fetcher)
-	};
-}
-
-//#endregion
-//#region src/endpoints/experts-drafts.ts
-function createDraftsApi(fetcher, basePath) {
+//#region src/endpoints/applications.ts
+const BASE_PATH$5 = "/api/v1/applications";
+function createApplicationsApi(fetcher) {
 	return {
-		async list(scopeName, params, options) {
+		async list(params, options) {
 			if (params) {
-				const result = request$26.query.safeParse(params);
+				const result = request$17.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const encodedScopeName = encodeURIComponent(scopeName);
 			const queryString = buildQueryString(params);
-			return fetcher.get(`${basePath}/${encodedScopeName}/drafts${queryString}`, options);
-		},
-		async get(scopeName, draftRef, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			const encodedDraftRef = encodeURIComponent(draftRef);
-			return fetcher.get(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
-		},
-		async create(scopeName, input, options) {
-			const result = request$29.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${basePath}/${encodedScopeName}/drafts`, input, options);
-		},
-		async update(scopeName, draftRef, input, options) {
-			const result = request$25.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			const encodedScopeName = encodeURIComponent(scopeName);
-			const encodedDraftRef = encodeURIComponent(draftRef);
-			return fetcher.post(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, input, options);
+			return fetcher.get(`${BASE_PATH$5}${queryString}`, options);
 		},
-		async delete(scopeName, draftRef, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			const encodedDraftRef = encodeURIComponent(draftRef);
-			return fetcher.delete(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
+		async get(id, options) {
+			return fetcher.get(`${BASE_PATH$5}/${id}`, options);
 		},
-		async assignVersion(scopeName, draftRef, input, options) {
-			const result = request$24.body.safeParse(input);
+		async create(input, options) {
+			const result = request$18.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			const encodedScopeName = encodeURIComponent(scopeName);
-			const encodedDraftRef = encodeURIComponent(draftRef);
-			return fetcher.post(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}/version`, input, options);
-		}
-	};
-}
-
-//#endregion
-//#region src/endpoints/experts-versions.ts
-function createVersionsApi(fetcher, basePath) {
-	return { async list(scopeName, options) {
-		const encodedScopeName = encodeURIComponent(scopeName);
-		return fetcher.get(`${basePath}/${encodedScopeName}/versions`, options);
-	} };
-}
-
-//#endregion
-//#region src/endpoints/experts.ts
-const BASE_PATH$2 = "/api/v1/experts";
-function createExpertsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$22.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$2}${queryString}`, options);
-		},
-		async get(key, options) {
-			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$2}/${encodedKey}`, options);
-		},
-		async getFeatured(options) {
-			return fetcher.get(`${BASE_PATH$2}/featured`, options);
-		},
-		async getMeta(key, options) {
-			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$2}/${encodedKey}/meta`, options);
-		},
-		async publish(scopeName, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/publish`, {}, options);
-		},
-		async unpublish(scopeName, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/unpublish`, {}, options);
-		},
-		async yank(key, options) {
-			const encodedKey = encodeURIComponent(key);
-			return fetcher.delete(`${BASE_PATH$2}/${encodedKey}`, options);
-		},
-		drafts: createDraftsApi(fetcher, BASE_PATH$2),
-		versions: createVersionsApi(fetcher, BASE_PATH$2)
-	};
-}
-
-//#endregion
-//#region src/lib/sse.ts
-async function* parseSSE(reader) {
-	const decoder = new TextDecoder();
-	let buffer = "";
-	while (true) {
-		const { value, done } = await reader.read();
-		if (done) break;
-		buffer += decoder.decode(value, { stream: true });
-		const events = buffer.split("\n\n");
-		buffer = events.pop() || "";
-		for (const event of events) {
-			if (event.trim() === "") continue;
-			const lines = event.split("\n");
-			const eventType = lines.find((line) => line.startsWith("event:"))?.slice(6).trim();
-			const data = lines.find((line) => line.startsWith("data:"))?.slice(5).trim();
-			if (eventType !== "message" || !data) continue;
-			try {
-				yield JSON.parse(data);
-			} catch {}
-		}
-	}
-}
-
-//#endregion
-//#region src/endpoints/jobs-checkpoints.ts
-function createCheckpointsApi(fetcher, basePath) {
-	return {
-		async list(jobId, params, options) {
-			if (params) {
-				const result = request$15.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${basePath}/${jobId}/checkpoints${queryString}`, options);
-		},
-		async get(jobId, checkpointId, options) {
-			return fetcher.get(`${basePath}/${jobId}/checkpoints/${checkpointId}`, options);
+			return fetcher.post(BASE_PATH$5, input, options);
 		},
-		async create(jobId, input, options) {
-			const result = request$17.body.safeParse(input);
+		async update(id, input, options) {
+			const result = request$16.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${basePath}/${jobId}/checkpoints`, input, options);
+			return fetcher.post(`${BASE_PATH$5}/${id}`, input, options);
 		},
-		async *stream(jobId, options) {
-			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
-			if (!result.ok) {
-				yield {
-					ok: false,
-					error: result.error
-				};
-				return;
-			}
-			const reader = result.data.getReader();
-			try {
-				for await (const checkpoint of parseSSE(reader)) yield {
-					ok: true,
-					data: checkpoint
-				};
-			} catch (error) {
-				if (error instanceof DOMException && error.name === "AbortError") yield {
-					ok: false,
-					error: createAbortError()
-				};
-				else yield {
-					ok: false,
-					error: createNetworkError(error)
-				};
-			}
+		async delete(id, options) {
+			return fetcher.delete(`${BASE_PATH$5}/${id}`, options);
 		}
 	};
 }
 
 //#endregion
-//#region src/endpoints/jobs.ts
-const BASE_PATH$1 = "/api/v1/jobs";
-function createJobsApi(fetcher) {
+//#region src/endpoints/env-secrets.ts
+const BASE_PATH$4 = "/api/v1/env/secrets";
+function createSecretsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$10.query.safeParse(params);
+				const result = request$14.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
 			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
-		},
-		async get(id, options) {
-			return fetcher.get(`${BASE_PATH$1}/${id}`, options);
+			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
 		},
-		async start(input, options) {
-			const result = request$12.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$1, input, options);
+		async get(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.get(`${BASE_PATH$4}/${encodedName}`, options);
 		},
-		async update(id, input, options) {
-			const result = request$9.body.safeParse(input);
+		async create(input, options) {
+			const result = request$15.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH$1}/${id}`, input, options);
+			return fetcher.post(BASE_PATH$4, input, options);
 		},
-		async continue(id, input, options) {
+		async update(name, input, options) {
 			const result = request$13.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH$1}/${id}/continue`, input, options);
-		},
-		async cancel(id, options) {
-			return fetcher.post(`${BASE_PATH$1}/${id}/cancel`, {}, options);
+			const encodedName = encodeURIComponent(name);
+			return fetcher.put(`${BASE_PATH$4}/${encodedName}`, input, options);
 		},
-		checkpoints: createCheckpointsApi(fetcher, BASE_PATH$1)
+		async delete(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.deleteNoContent(`${BASE_PATH$4}/${encodedName}`, options);
+		}
 	};
 }
 
 //#endregion
-//#region src/endpoints/provider-settings.ts
-const BASE_PATH = "/api/v1/applications";
-function createProviderSettingsApi(fetcher) {
+//#region src/endpoints/env-variables.ts
+const BASE_PATH$3 = "/api/v1/env/variables";
+function createVariablesApi(fetcher) {
 	return {
-		async list(applicationId, options) {
-			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings`, options);
-		},
-		async get(applicationId, provider, options) {
-			const encodedProvider = encodeURIComponent(provider);
-			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
-		},
-		async create(applicationId, input, options) {
-			const result = request$5.body.safeParse(input);
+		async list(params, options) {
+			const result = request$11.query.safeParse(params);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings`, input, options);
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$3}${queryString}`, options);
 		},
-		async update(applicationId, provider, input, options) {
-			const result = request$1.body.safeParse(input);
+		async get(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+		},
+		async create(input, options) {
+			const result = request$12.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			const encodedProvider = encodeURIComponent(provider);
-			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, input, options);
-		},
-		async delete(applicationId, provider, options) {
-			const encodedProvider = encodeURIComponent(provider);
-			return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
-		},
-		async listApiKeys(applicationId, provider, options) {
-			const encodedProvider = encodeURIComponent(provider);
-			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, options);
+			return fetcher.post(BASE_PATH$3, input, options);
 		},
-		async createApiKey(applicationId, provider, input, options) {
-			const result = request$8.body.safeParse(input);
+		async update(name, input, options) {
+			const result = request$10.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			const encodedProvider = encodeURIComponent(provider);
-			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, input, options);
+			const encodedName = encodeURIComponent(name);
+			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
 		},
-		async deleteApiKey(applicationId, provider, apiKeyId, options) {
-			const encodedProvider = encodeURIComponent(provider);
-			const encodedApiKeyId = encodeURIComponent(apiKeyId);
-			return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys/${encodedApiKeyId}`, options);
+		async delete(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
 		}
 	};
 }
 
 //#endregion
-//#region src/lib/fetcher.ts
-const DEFAULT_BASE_URL = "https://api.perstack.ai";
-const DEFAULT_TIMEOUT = 3e4;
-function createFetcher(config) {
-	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
-	const timeout = config.timeout ?? DEFAULT_TIMEOUT;
-	const useCredentials = "credentials" in config && config.credentials === "include";
-	const apiKey = "apiKey" in config ? config.apiKey : void 0;
-	function buildUrl(path) {
-		return `${baseUrl}${path}`;
-	}
-	function buildHeaders(options) {
-		const headers = {};
-		if (options?.hasBody) headers["Content-Type"] = "application/json";
-		if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-		return headers;
-	}
-	function getCredentials() {
-		return useCredentials ? "include" : void 0;
-	}
-	function createTimeoutSignal(externalSignal) {
-		const controller = new AbortController();
-		let timedOut = false;
-		const timeoutId = setTimeout(() => {
-			timedOut = true;
-			controller.abort();
-		}, timeout);
-		let abortHandler;
-		if (externalSignal) if (externalSignal.aborted) controller.abort();
-		else {
-			abortHandler = () => controller.abort();
-			externalSignal.addEventListener("abort", abortHandler);
-		}
-		return {
-			signal: controller.signal,
-			cleanup: () => {
-				clearTimeout(timeoutId);
-				if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
-			},
-			isTimeout: () => timedOut
-		};
-	}
-	function wrapStreamWithIdleTimeout(stream, idleTimeoutMs, externalSignal) {
-		const reader = stream.getReader();
-		const controller = new AbortController();
-		let timeoutId;
-		let abortHandler;
-		if (externalSignal) if (externalSignal.aborted) controller.abort();
-		else {
-			abortHandler = () => controller.abort();
-			externalSignal.addEventListener("abort", abortHandler);
-		}
-		function resetTimeout() {
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = setTimeout(() => controller.abort(), idleTimeoutMs);
-		}
-		function cleanup() {
-			if (timeoutId) clearTimeout(timeoutId);
-			if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
-		}
-		return new ReadableStream({
-			start() {
-				resetTimeout();
-			},
-			async pull(streamController) {
-				try {
-					const result = await Promise.race([reader.read(), new Promise((_, reject) => {
-						if (controller.signal.aborted) reject(new DOMException("Stream idle timeout", "AbortError"));
-						controller.signal.addEventListener("abort", () => {
-							reject(new DOMException("Stream idle timeout", "AbortError"));
-						});
-					})]);
-					if (result.done) {
-						cleanup();
-						streamController.close();
-						return;
-					}
-					resetTimeout();
-					streamController.enqueue(result.value);
-				} catch (error) {
-					cleanup();
-					reader.cancel().catch(() => {});
-					if (error instanceof DOMException && error.name === "AbortError") streamController.error(new DOMException("Stream idle timeout", "AbortError"));
-					else streamController.error(error);
-				}
-			},
-			cancel(reason) {
-				cleanup();
-				reader.cancel(reason).catch(() => {});
-			}
-		});
-	}
-	async function request$50(method, path, body, options) {
-		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
-		try {
-			const response$52 = await fetch(buildUrl(path), {
-				method,
-				headers: buildHeaders(body ? { hasBody: true } : void 0),
-				body: body ? JSON.stringify(body) : void 0,
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$52.ok) return handleHttpError(response$52);
-			return {
-				ok: true,
-				data: await response$52.json()
-			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") {
-				if (isTimeout()) return {
+//#region src/endpoints/env.ts
+function createEnvApi(fetcher) {
+	return {
+		secrets: createSecretsApi(fetcher),
+		variables: createVariablesApi(fetcher)
+	};
+}
+
+//#endregion
+//#region src/endpoints/experts-versions.ts
+function createVersionsApi(fetcher, basePath) {
+	return { async list(scopeName, options) {
+		const encodedScopeName = encodeURIComponent(scopeName);
+		return fetcher.get(`${basePath}/${encodedScopeName}/versions`, options);
+	} };
+}
+
+//#endregion
+//#region src/endpoints/experts.ts
+const BASE_PATH$2 = "/api/v1/experts";
+function createExpertsApi(fetcher) {
+	return {
+		async list(params, options) {
+			if (params) {
+				const result = request$9.query.safeParse(params);
+				if (!result.success) return {
 					ok: false,
-					error: createTimeoutError()
+					error: createValidationError(result.error)
 				};
-				return {
+			}
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$2}${queryString}`, options);
+		},
+		async get(key, options) {
+			const encodedKey = encodeURIComponent(key);
+			return fetcher.get(`${BASE_PATH$2}/${encodedKey}`, options);
+		},
+		async getFeatured(options) {
+			return fetcher.get(`${BASE_PATH$2}/featured`, options);
+		},
+		async getMeta(key, options) {
+			const encodedKey = encodeURIComponent(key);
+			return fetcher.get(`${BASE_PATH$2}/${encodedKey}/meta`, options);
+		},
+		async publish(scopeName, options) {
+			const encodedScopeName = encodeURIComponent(scopeName);
+			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/publish`, {}, options);
+		},
+		async unpublish(scopeName, options) {
+			const encodedScopeName = encodeURIComponent(scopeName);
+			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/unpublish`, {}, options);
+		},
+		async yank(key, options) {
+			const encodedKey = encodeURIComponent(key);
+			return fetcher.delete(`${BASE_PATH$2}/${encodedKey}`, options);
+		},
+		versions: createVersionsApi(fetcher, BASE_PATH$2)
+	};
+}
+
+//#endregion
+//#region src/endpoints/jobs-checkpoints.ts
+function createCheckpointsApi(fetcher, basePath) {
+	return {
+		async list(jobId, params, options) {
+			if (params) {
+				const result = request$7.query.safeParse(params);
+				if (!result.success) return {
 					ok: false,
-					error: createAbortError()
+					error: createValidationError(result.error)
 				};
 			}
-			return {
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${basePath}/${jobId}/checkpoints${queryString}`, options);
+		},
+		async get(jobId, checkpointId, options) {
+			return fetcher.get(`${basePath}/${jobId}/checkpoints/${checkpointId}`, options);
+		},
+		async create(jobId, input, options) {
+			const result = request$8.body.safeParse(input);
+			if (!result.success) return {
 				ok: false,
-				error: createNetworkError(error)
-			};
-		} finally {
-			cleanup();
-		}
-	}
-	async function requestBlob(path, options) {
-		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
-		try {
-			const response$52 = await fetch(buildUrl(path), {
-				method: "GET",
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$52.ok) return handleHttpError(response$52);
-			return {
-				ok: true,
-				data: await response$52.blob()
+				error: createValidationError(result.error)
 			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") {
-				if (isTimeout()) return {
+			return fetcher.post(`${basePath}/${jobId}/checkpoints`, input, options);
+		},
+		async *stream(jobId, options) {
+			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
+			if (!result.ok) {
+				yield {
 					ok: false,
-					error: createTimeoutError()
+					error: result.error
 				};
-				return {
+				return;
+			}
+			const reader = result.data.getReader();
+			try {
+				for await (const checkpoint of parseSSE(reader)) yield {
+					ok: true,
+					data: checkpoint
+				};
+			} catch (error) {
+				if (error instanceof DOMException && error.name === "AbortError") yield {
 					ok: false,
 					error: createAbortError()
 				};
-			}
-			return {
-				ok: false,
-				error: createNetworkError(error)
-			};
-		} finally {
-			cleanup();
-		}
-	}
-	async function requestStream(path, options) {
-		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
-		try {
-			const response$52 = await fetch(buildUrl(path), {
-				method: "GET",
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$52.ok) {
-				cleanup();
-				return handleHttpError(response$52);
-			}
-			if (!response$52.body) {
-				cleanup();
-				return {
+				else yield {
 					ok: false,
-					error: createNetworkError(/* @__PURE__ */ new Error("Response body is null"))
+					error: createNetworkError(error)
 				};
 			}
-			cleanup();
-			const idleTimeout = options?.streamIdleTimeout ?? timeout;
-			return {
-				ok: true,
-				data: wrapStreamWithIdleTimeout(response$52.body, idleTimeout, options?.signal)
-			};
-		} catch (error) {
-			cleanup();
-			if (error instanceof Error && error.name === "AbortError") {
-				if (isTimeout()) return {
-					ok: false,
-					error: createTimeoutError()
-				};
-				return {
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/jobs.ts
+const BASE_PATH$1 = "/api/v1/jobs";
+function createJobsApi(fetcher) {
+	return {
+		async list(params, options) {
+			if (params) {
+				const result = request$4.query.safeParse(params);
+				if (!result.success) return {
 					ok: false,
-					error: createAbortError()
+					error: createValidationError(result.error)
 				};
 			}
-			return {
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
+		},
+		async get(id, options) {
+			return fetcher.get(`${BASE_PATH$1}/${id}`, options);
+		},
+		async start(input, options) {
+			const result = request$5.body.safeParse(input);
+			if (!result.success) return {
 				ok: false,
-				error: createNetworkError(error)
+				error: createValidationError(result.error)
 			};
-		}
-	}
-	async function requestNoContent(method, path, options) {
-		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
-		try {
-			const response$52 = await fetch(buildUrl(path), {
-				method,
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$52.ok) return handleHttpError(response$52);
-			return {
-				ok: true,
-				data: void 0
+			return fetcher.post(BASE_PATH$1, input, options);
+		},
+		async update(id, input, options) {
+			const result = request$3.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
 			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") {
-				if (isTimeout()) return {
-					ok: false,
-					error: createTimeoutError()
-				};
-				return {
-					ok: false,
-					error: createAbortError()
-				};
-			}
-			return {
+			return fetcher.post(`${BASE_PATH$1}/${id}`, input, options);
+		},
+		async continue(id, input, options) {
+			const result = request$6.body.safeParse(input);
+			if (!result.success) return {
 				ok: false,
-				error: createNetworkError(error)
+				error: createValidationError(result.error)
 			};
-		} finally {
-			cleanup();
-		}
-	}
+			return fetcher.post(`${BASE_PATH$1}/${id}/continue`, input, options);
+		},
+		async cancel(id, options) {
+			return fetcher.post(`${BASE_PATH$1}/${id}/cancel`, {}, options);
+		},
+		checkpoints: createCheckpointsApi(fetcher, BASE_PATH$1)
+	};
+}
+
+//#endregion
+//#region src/endpoints/provider-settings.ts
+const BASE_PATH = "/api/v1/applications";
+function createProviderSettingsApi(fetcher) {
 	return {
-		get: (path, options) => request$50("GET", path, void 0, options),
-		post: (path, body, options) => request$50("POST", path, body, options),
-		put: (path, body, options) => request$50("PUT", path, body, options),
-		delete: (path, options) => request$50("DELETE", path, void 0, options),
-		deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
-		getBlob: (path, options) => requestBlob(path, options),
-		getStream: (path, options) => requestStream(path, options)
+		async list(applicationId, options) {
+			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings`, options);
+		},
+		async get(applicationId, provider, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
+		},
+		async create(applicationId, input, options) {
+			const result = request$1.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings`, input, options);
+		},
+		async update(applicationId, provider, input, options) {
+			const result = request.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, input, options);
+		},
+		async delete(applicationId, provider, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
+		},
+		async listApiKeys(applicationId, provider, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, options);
+		},
+		async createApiKey(applicationId, provider, input, options) {
+			const result = request$2.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, input, options);
+		},
+		async deleteApiKey(applicationId, provider, apiKeyId, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			const encodedApiKeyId = encodeURIComponent(apiKeyId);
+			return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys/${encodedApiKeyId}`, options);
+		}
 	};
 }
 
 //#endregion
-//#region src/client-public.ts
+//#region src/public/client.ts
 function createApiClient(config) {
 	const fetcher = createFetcher(config);
 	return {
@@ -2217,45 +1866,6 @@ function createApiClient(config) {
 	};
 }
 
-//#endregion
-//#region src/lib/api-key.ts
-function matchWildcard(value, pattern) {
-	if (pattern === "*") return true;
-	if (pattern.endsWith("*")) return value.startsWith(pattern.slice(0, -1));
-	if (pattern.startsWith("*")) return value.endsWith(pattern.slice(1));
-	return value === pattern;
-}
-function matchOperations(operations, requiredOperation) {
-	return operations.some((pattern) => matchWildcard(requiredOperation, pattern));
-}
-function matchExperts(experts, expertId) {
-	if (experts === void 0 || experts === "*") return true;
-	return experts.some((pattern) => matchWildcard(expertId, pattern));
-}
-function isApiKeyPermissions(parsed) {
-	return typeof parsed === "object" && parsed !== null && "operations" in parsed && Array.isArray(parsed.operations);
-}
-function parseApiKeyPermissions(permissionsJson) {
-	if (!permissionsJson) return null;
-	try {
-		const parsed = JSON.parse(permissionsJson);
-		if (!isApiKeyPermissions(parsed)) return null;
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-function stringifyApiKeyPermissions(permissions) {
-	return JSON.stringify(permissions);
-}
-
-//#endregion
-//#region src/lib/auth.ts
-function buildAuthHeaders(auth) {
-	if (auth.type === "apiKey") return { Authorization: `Bearer ${auth.apiKey}` };
-	return { Cookie: auth.cookie };
-}
-
 //#endregion
 export { buildAuthHeaders, buildQueryString, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createTimeoutError, createValidationError, handleHttpError, isAbortError, isClientError, isHttpError, isNetworkError, isTimeoutError, isValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, stringifyApiKeyPermissions };
-//# sourceMappingURL=bundle.mjs.map
+//# sourceMappingURL=index.mjs.map