@perstack/api-client 0.0.47 → 0.0.50

package/dist/index.mjs

@@ -2,10 +2,421 @@ 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;
+const applicationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
 const maxApplicationNameLength = 255;
+const maxVariableValueLength = 65536;
+const maxSecretValueLength = 65536;
 const expertKeyRegex = /^((?:@[a-z0-9][a-z0-9_.-]*\/)?[a-z0-9][a-z0-9_.-]*)(?:@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?)|@([a-z0-9][a-z0-9_.-]*))?$/;
 const expertNameRegex = /^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/;
 const scopeNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
@@ -41,19 +452,19 @@ 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",
 	"google-vertex"
 ]);
-const datetimeSchema = z.string().datetime();
+const datetimeSchema = z.string().datetime({ offset: true });
 const expertKeyFieldSchema = z.string().min(1).max(maxExpertKeyLength).regex(expertKeyRegex);
 const expertNameFieldSchema = z.string().min(1).max(maxExpertNameLength).regex(expertNameRegex);
 const expertVersionFieldSchema = z.string().min(1).max(maxExpertVersionTagLength).regex(expertVersionRegex);
@@ -98,41 +509,84 @@ const organizationSchema = z.object({
 });
 
 //#endregion
-//#region ../models/src/domain/application.ts
-const applicationNameSchema = z.string().min(1).max(maxApplicationNameLength);
-const applicationStatusSchema = z.enum([
+//#region ../models/src/domain/user.ts
+const userStatusSchema = z.enum([
 	"active",
 	"inactive",
 	"deleted"
 ]);
-const applicationSchema = z.object({
-	type: z.literal("application"),
+const userSchema = z.object({
+	type: z.literal("user"),
 	id: cuidSchema,
-	organizationId: cuidSchema,
-	organization: organizationSchema,
+	email: z.string().email(),
+	emailVerified: z.boolean(),
+	name: z.string().min(1).max(255).optional(),
+	image: z.string().url().optional(),
+	status: userStatusSchema,
+	organizations: z.array(organizationSchema),
 	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	name: applicationNameSchema,
-	status: applicationStatusSchema
+	updatedAt: datetimeSchema
 });
 
 //#endregion
-//#region ../models/src/api/applications/create.ts
-const request$38 = { body: z.object({
-	name: applicationNameSchema,
-	applicationGroupId: cuidSchema.optional()
-}) };
-const response$40 = z.object({ data: z.object({ application: applicationSchema }) });
+//#region ../models/src/domain/apiKey.ts
+const apiKeyPermissionsSchema = z.object({
+	operations: z.array(z.string()),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional()
+});
+const apiKeySchema = z.object({
+	type: z.literal("apiKey"),
+	id: cuidSchema,
+	name: z.string().min(1).max(255).optional(),
+	start: z.string().optional(),
+	prefix: z.string().optional(),
+	user: userSchema.optional(),
+	enabled: z.boolean(),
+	expiresAt: datetimeSchema.optional(),
+	permissions: apiKeyPermissionsSchema.optional(),
+	lastRequest: datetimeSchema.optional(),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+const createApiKeyInputSchema = z.object({
+	name: z.string().min(1).max(255).optional(),
+	organizationId: cuidSchema,
+	operations: z.array(z.string()).optional(),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
+	expiresIn: z.number().min(60).optional()
+});
+const createApiKeyResponseSchema = z.object({
+	apiKey: apiKeySchema,
+	key: z.string()
+});
 
 //#endregion
-//#region ../models/src/api/applications/delete.ts
-const request$37 = { params: z.object({ applicationId: cuidSchema }) };
-const response$39 = z.object({ data: z.object({ application: applicationSchema }) });
+//#region ../models/src/api/api-keys/create.ts
+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(),
+	wildcardApplicationAccess: z.boolean().optional(),
+	applicationIds: z.array(cuidSchema).optional(),
+	expiresIn: z.number().min(60).optional()
+}) };
+const response$22 = z.object({ data: z.object({
+	apiKey: apiKeySchema.extend({
+		permissions: apiKeyPermissionsSchema.optional(),
+		wildcardApplicationAccess: z.boolean(),
+		applicationIds: z.array(cuidSchema)
+	}),
+	key: z.string()
+}) });
 
 //#endregion
-//#region ../models/src/api/applications/get.ts
-const request$36 = { params: z.object({ applicationId: cuidSchema }) };
-const response$38 = z.object({ data: z.object({ application: applicationSchema }) });
+//#region ../models/src/api/api-keys/get.ts
+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)
+}) }) });
 
 //#endregion
 //#region ../../node_modules/ts-dedent/dist/index.js
@@ -213,15 +667,68 @@ const paginationMeta = z.object({
 	take: z.number().int().min(1),
 	skip: z.number().int().min(0)
 });
-const errorUnauthorizedFlexible = z.object({
-	code: z.literal(401),
-	error: z.literal("Unauthorized"),
-	reason: z.string()
-}).describe("Unauthorized");
+const errorUnauthorizedFlexible = z.object({
+	code: z.literal(401),
+	error: z.literal("Unauthorized"),
+	reason: z.string()
+}).describe("Unauthorized");
+
+//#endregion
+//#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)
+}) }) });
+
+//#endregion
+//#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)
+}) }) });
+
+//#endregion
+//#region ../models/src/domain/application.ts
+const applicationNameSchema = z.string().min(1).max(maxApplicationNameLength).regex(applicationNameRegex);
+const applicationStatusSchema = z.enum([
+	"active",
+	"inactive",
+	"deleted"
+]);
+const applicationSchema = z.object({
+	type: z.literal("application"),
+	id: cuidSchema,
+	organizationId: cuidSchema,
+	organization: organizationSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	name: applicationNameSchema,
+	status: applicationStatusSchema,
+	expertCount: z.number().describe("Number of expert draft scopes associated with this application").optional(),
+	providers: z.array(providerSchema).describe("List of configured providers for this application").optional()
+});
+
+//#endregion
+//#region ../models/src/api/applications/create.ts
+const request$18 = { body: z.object({
+	name: applicationNameSchema,
+	applicationGroupId: cuidSchema.optional()
+}) };
+const response$18 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/api/applications/getAll.ts
-const request$35 = { 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",
@@ -229,29 +736,29 @@ const request$35 = { query: z.object({
 		"updatedAt"
 	]).optional(),
 	order: z.enum(["asc", "desc"]).optional(),
-	take: z.coerce.number().min(1).max(100).default(100),
+	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$37 = 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$34 = {
+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$36 = z.object({ data: z.object({ application: applicationSchema }) });
+const response$16 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/domain/secret.ts
 const secretNameSchema = z.string().min(1, "Secret name is required").max(255, "Secret name must be 255 characters or less").regex(/^[A-Z][A-Z0-9_]*$/, "Secret name must start with uppercase letter and contain only uppercase letters, numbers, and underscores");
-const secretValueSchema = z.string().min(1, "Secret value is required");
+const secretValueSchema = z.string().min(1, "Secret value is required").max(maxSecretValueLength);
 const secretMetadataSchema = z.object({
 	name: z.string(),
 	createdAt: datetimeSchema,
@@ -268,49 +775,33 @@ const secretSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/secrets/create.ts
-const request$33 = { body: z.object({
+const request$15 = { body: z.object({
 	applicationId: cuidSchema,
 	name: secretNameSchema,
 	value: secretValueSchema
 }) };
-const response$35 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
-
-//#endregion
-//#region ../models/src/api/env/secrets/delete.ts
-const request$32 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$34 = z.null();
-
-//#endregion
-//#region ../models/src/api/env/secrets/get.ts
-const request$31 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$33 = 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$30 = { query: z.object({ applicationId: cuidSchema.optional() }) };
-const response$32 = 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$29 = {
+const request$13 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: secretValueSchema
 	})
 };
-const response$31 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$13 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/domain/variable.ts
-const variableNameSchema = z.string().min(1).max(255).regex(/^[A-Z_][A-Z0-9_]*$/, "Variable name must start with uppercase letter or underscore, and contain only uppercase letters, digits, and underscores");
-const variableValueSchema = z.string();
+const variableNameSchema = z.string().min(1).max(255).regex(/^[A-Z][A-Z0-9_]*$/, "Variable name must start with uppercase letter and contain only uppercase letters, digits, and underscores");
+const variableValueSchema = z.string().max(maxVariableValueLength);
 const variableSchema = z.object({
 	type: z.literal("variable"),
 	id: cuidSchema,
@@ -329,44 +820,28 @@ const variableResponseSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/variables/create.ts
-const request$28 = { body: z.object({
+const request$12 = { body: z.object({
 	applicationId: cuidSchema,
 	name: variableNameSchema,
 	value: variableValueSchema
 }) };
-const response$30 = z.object({ data: z.object({ variable: variableResponseSchema }) });
-
-//#endregion
-//#region ../models/src/api/env/variables/delete.ts
-const request$27 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$29 = z.null();
-
-//#endregion
-//#region ../models/src/api/env/variables/get.ts
-const request$26 = {
-	params: z.object({ name: z.string().min(1) }),
-	query: z.object({ applicationId: cuidSchema })
-};
-const response$28 = 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$25 = { query: z.object({ applicationId: cuidSchema }) };
-const response$27 = 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$24 = {
+const request$10 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: variableValueSchema
 	})
 };
-const response$26 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$10 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/domain/expertScope.ts
@@ -374,6 +849,7 @@ const expertScopeSchema = z.object({
 	id: cuidSchema,
 	name: scopeNameSchema,
 	organizationId: cuidSchema,
+	expertDraftScopeId: cuidSchema,
 	published: z.boolean(),
 	publishedAt: datetimeSchema.optional(),
 	category: expertCategoryFieldSchema,
@@ -492,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$23 = { params: z.object({ scopeName: scopeNameRefSchema }) };
-const response$25 = 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$22 = {
-	params: z.object({ scopeName: scopeNameSchema }),
-	body: z.object({
-		applicationId: cuidSchema,
-		experts: z.array(expertSchema)
-	})
-};
-const response$24 = z.object({ data: z.object({
-	scope: expertDraftScopeSchema,
-	draftRef: expertDraftRefSchema,
-	definition: expertDefinitionContentSchema
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/delete.ts
-const request$21 = { params: z.object({
-	scopeName: scopeNameSchema,
-	draftRef: expertDraftRefSchema.shape.id
-}) };
-const response$23 = z.object({ data: z.object({
-	deleted: z.boolean(),
-	draftRef: z.string()
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/get.ts
-const request$20 = { params: z.object({
-	scopeName: scopeNameSchema,
-	draftRef: expertDraftRefSchema.shape.id
-}) };
-const response$22 = z.object({ data: z.object({
-	scope: expertDraftScopeSchema,
-	draftRef: expertDraftRefSchema,
-	definition: expertDefinitionContentSchema
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/getAll.ts
-const request$19 = {
-	params: z.object({ scopeName: expertDraftScopeSchema.shape.name }),
-	query: z.object({
-		limit: z.coerce.number().int().min(1).max(100).optional().default(20),
-		offset: z.coerce.number().int().min(0).optional().default(0)
-	})
-};
-const response$21 = z.object({ data: z.object({
-	draftRefs: z.array(expertDraftRefSchema),
-	total: z.number().int().min(0)
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/update.ts
-const request$18 = {
-	params: z.object({
-		scopeName: scopeNameSchema,
-		draftRef: expertDraftRefSchema.shape.id
-	}),
-	body: z.object({ experts: z.array(expertSchema) })
-};
-const response$20 = z.object({ data: z.object({
-	scope: expertDraftScopeSchema,
-	draftRef: expertDraftRefSchema,
-	definition: expertDefinitionContentSchema
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/drafts/version.ts
-const request$17 = {
-	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$19 = z.object({ data: z.object({
-	scope: expertScopeSchema,
-	version: expertVersionSchema,
-	definitionUrl: z.string()
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/featured.ts
-const response$18 = 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$16 = { params: z.object({ scopeName: scopeNameRefSchema }) };
-const response$17 = z.object({ data: z.object({
-	definition: expertDefinitionSchema,
-	yanked: z.boolean().optional()
-}) });
-
 //#endregion
 //#region ../models/src/api/experts/getAll.ts
-const request$15 = { query: z.object({
+const request$9 = { query: z.object({
 	filter: z.string().describe("Filter by scope name (partial match)").optional(),
 	category: z.enum([
 		"general",
@@ -667,36 +981,13 @@ const request$15 = { query: z.object({
 		"automation"
 	]).describe("Filter by category").optional(),
 	includeDrafts: z.coerce.boolean().default(false).describe("Include unpublished scopes (owner only)").optional(),
-	limit: z.coerce.number().min(1).max(100).default(20).describe("Maximum results").optional(),
-	offset: z.coerce.number().min(0).default(0).describe("Pagination offset").optional()
+	take: z.coerce.number().min(1).max(100).default(20),
+	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$16 = z.object({ data: z.object({
-	experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema })),
-	total: z.number()
-}) });
-
-//#endregion
-//#region ../models/src/api/experts/meta.ts
-const request$14 = {
-	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$15 = z.object({ data: expertMetadataSchema.extend({ definitionUrl: z.string() }) });
-
-//#endregion
-//#region ../models/src/api/experts/publish.ts
-const request$13 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$14 = z.object({ data: z.object({ scope: expertScopeSchema }) });
-
-//#endregion
-//#region ../models/src/api/experts/unpublish.ts
-const request$12 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$13 = z.object({ data: z.object({ scope: expertScopeSchema }) });
-
-//#endregion
-//#region ../models/src/api/experts/versions.ts
-const request$11 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$12 = z.object({ data: z.object({ versions: z.array(expertVersionSchema) }) });
+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
@@ -775,45 +1066,32 @@ const requestCheckpointSchema = perstackCheckpointSchema.omit({
 	id: true,
 	runId: true
 }).extend({ runId: z.string().optional() });
-const request$10 = {
+const request$8 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({
 		checkpoint: requestCheckpointSchema,
 		step: stepSchema
 	})
 };
-const response$11 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/checkpoints/get.ts
-const request$9 = { params: z.object({
-	jobId: cuidSchema,
-	checkpointId: cuidSchema
-}) };
-const response$10 = 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$8 = {
+const request$7 = {
 	params: z.object({ jobId: cuidSchema }),
 	query: z.object({
 		filter: z.string().min(1).max(256).optional(),
 		sort: z.enum(["createdAt", "updatedAt"]).optional(),
 		order: z.enum(["asc", "desc"]).optional(),
-		take: z.coerce.number().min(1).max(100).default(10),
+		take: z.coerce.number().min(1).max(100).default(20),
 		skip: z.coerce.number().min(0).default(0)
 	})
 };
-const response$9 = 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$7 = { params: z.object({ jobId: cuidSchema }) };
-const response$8 = z.object({ data: apiCheckpointSchema });
-
 //#endregion
 //#region ../support-models/src/index.ts
 const anthropicSupportModels = [
@@ -1027,151 +1305,44 @@ const request$6 = {
 		maxRetries: z.coerce.number().optional()
 	})
 };
-const response$7 = z.object({ data: z.object({ job: jobSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/create.ts
-const request$5 = { body: z.object({
-	applicationId: cuidSchema.describe("Application ID to create the job in"),
-	expertKey: expertKeyFieldSchema,
-	query: jobSchema.shape.query.optional(),
-	files: z.union([z.instanceof(File), z.array(z.instanceof(File))]).optional(),
-	provider: providerSchema,
-	model: jobSchema.shape.model.optional(),
-	reasoningBudget: reasoningBudgetSchema.optional(),
-	maxSteps: z.coerce.number().optional(),
-	maxRetries: z.coerce.number().optional()
-}) };
 const response$6 = z.object({ data: z.object({ job: jobSchema }) });
 
-//#endregion
-//#region ../models/src/api/jobs/get.ts
-const request$4 = { params: z.object({ jobId: cuidSchema }) };
-const response$5 = z.object({ data: z.object({ job: jobSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/getAll.ts
-const request$3 = { query: z.object({
-	sort: z.enum(["createdAt", "updatedAt"]).optional(),
-	order: z.enum(["asc", "desc"]).optional(),
-	take: z.coerce.number().min(1).max(100).default(100),
-	skip: z.coerce.number().min(0).default(0)
-}) };
-const response$4 = z.object({
-	data: z.object({ jobs: z.array(jobSchema) }),
-	meta: paginationMeta
-});
-
-//#endregion
-//#region ../models/src/api/jobs/update.ts
-const request$2 = {
-	params: z.object({ jobId: cuidSchema }),
-	body: z.object({ status: jobStatusSchema })
-};
-const response$3 = z.object({ data: z.object({ job: jobSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/workspace/get.ts
-const workspaceCommitSchema = z.object({
-	sha: z.string(),
-	message: z.string(),
-	author: z.string(),
-	timestamp: z.string()
-});
-const workspaceStatsSchema = z.object({
-	commits: z.number().int().min(0),
-	filesChanged: z.number().int().min(0),
-	additions: z.number().int().min(0),
-	deletions: z.number().int().min(0)
-});
-const workspaceSchema = z.object({
-	jobId: z.string(),
-	branch: z.string(),
-	baseBranch: z.string(),
-	lastCommit: workspaceCommitSchema.optional(),
-	stats: workspaceStatsSchema.optional()
-});
-const request$1 = { params: z.object({ jobId: cuidSchema }) };
-const response$2 = z.object({ data: z.object({ workspace: workspaceSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/workspace/tree.ts
-const workspaceItemSchema = z.object({
-	type: z.enum(["directory", "file"]),
-	path: z.string(),
-	name: z.string(),
-	size: z.number().optional(),
-	sha: z.string().optional()
-});
-const request = {
-	params: z.object({ jobId: cuidSchema }),
-	query: z.object({
-		path: z.string().optional(),
-		recursive: z.coerce.boolean().optional()
-	})
-};
-const response$1 = z.object({ data: z.object({ items: z.array(workspaceItemSchema) }) });
-
-//#endregion
-//#region ../models/src/domain/user.ts
-const userStatusSchema = z.enum([
-	"active",
-	"inactive",
-	"deleted"
-]);
-const userSchema = z.object({
-	type: z.literal("user"),
-	id: cuidSchema,
-	email: z.string().email(),
-	emailVerified: z.boolean(),
-	name: z.string().min(1).max(255).optional(),
-	image: z.string().url().optional(),
-	status: userStatusSchema,
-	organizations: z.array(organizationSchema),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-
-//#endregion
-//#region ../models/src/api/session/get.ts
-const response = z.object({ data: z.object({
-	user: userSchema,
-	organization: organizationSchema,
-	application: applicationSchema.nullable()
-}) });
-
-//#endregion
-//#region ../models/src/domain/apiKey.ts
-const apiKeyPermissionsSchema = z.object({
-	operations: z.array(z.string()),
-	experts: z.union([z.array(z.string()), z.literal("*")]).optional()
-});
-const apiKeySchema = z.object({
-	type: z.literal("apiKey"),
-	id: cuidSchema,
-	name: z.string().min(1).max(255).optional(),
-	start: z.string().optional(),
-	prefix: z.string().optional(),
-	user: userSchema.optional(),
-	enabled: z.boolean(),
-	expiresAt: datetimeSchema.optional(),
-	permissions: apiKeyPermissionsSchema.optional(),
-	lastRequest: datetimeSchema.optional(),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-const createApiKeyInputSchema = z.object({
-	name: z.string().min(1).max(255).optional(),
-	organizationId: cuidSchema,
-	operations: z.array(z.string()).optional(),
-	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
-	expiresIn: z.number().min(60).optional()
-});
-const createApiKeyResponseSchema = z.object({
-	apiKey: apiKeySchema,
-	key: z.string()
+//#endregion
+//#region ../models/src/api/jobs/create.ts
+const request$5 = { body: z.object({
+	applicationId: cuidSchema.describe("Application ID to create the job in"),
+	expertKey: expertKeyFieldSchema,
+	query: jobSchema.shape.query.optional(),
+	files: z.union([z.instanceof(File), z.array(z.instanceof(File))]).optional(),
+	provider: providerSchema,
+	model: jobSchema.shape.model.optional(),
+	reasoningBudget: reasoningBudgetSchema.optional(),
+	maxSteps: z.coerce.number().optional(),
+	maxRetries: z.coerce.number().optional()
+}) };
+const response$5 = z.object({ data: z.object({ job: jobSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/getAll.ts
+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$4 = z.object({
+	data: z.object({ jobs: z.array(jobSchema) }),
+	meta: paginationMeta
 });
 
+//#endregion
+//#region ../models/src/api/jobs/update.ts
+const request$3 = {
+	params: z.object({ jobId: cuidSchema }),
+	body: z.object({ status: jobStatusSchema })
+};
+const response$3 = z.object({ data: z.object({ job: jobSchema }) });
+
 //#endregion
 //#region ../models/src/domain/providerSetting.ts
 const baseUrlSchema = z.string().url().max(maxProviderBaseUrlLength).optional();
@@ -1228,215 +1399,235 @@ const providerSettingSchema = z.object({
 	createdAt: datetimeSchema,
 	updatedAt: datetimeSchema
 });
-
-//#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"),
+const providerSettingResponseSchema = z.object({
+	type: z.literal("providerSetting"),
 	id: cuidSchema,
-	providerSettingId: cuidSchema,
-	name: providerApiKeyNameSchema,
-	lastUsedAt: datetimeSchema.optional(),
-	expiresAt: datetimeSchema.optional(),
-	providerSetting: providerSettingSchema,
+	provider: providerSchema,
+	settings: providerSettingsSchema.optional(),
 	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"),
+const providerApiKeyMetadataSchema = z.object({
 	id: cuidSchema,
-	jobId: cuidSchema,
-	parentRunId: cuidSchema.optional(),
-	organizationId: cuidSchema,
+	name: z.string(),
 	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()
+	lastUsedAt: datetimeSchema.nullable(),
+	expiresAt: datetimeSchema.nullable()
 });
 
 //#endregion
-//#region src/lib/errors.ts
-function createValidationError(error) {
-	return {
-		code: 400,
-		message: `Validation failed: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
-		reason: error.issues
-	};
-}
-function createAbortError() {
-	return {
-		code: 0,
-		message: "Request aborted",
-		aborted: true
-	};
-}
-function createNetworkError(error) {
-	return {
-		code: 0,
-		message: error instanceof Error ? error.message : "Network error",
-		reason: error
-	};
-}
-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 {
-			code: status,
-			message: body.error,
-			reason: hasReason ? body.reason : void 0
-		};
-		if (hasReason) return {
-			code: status,
-			message: statusText,
-			reason: body.reason
-		};
-	}
+//#region ../models/src/api/provider-settings/api-keys/create.ts
+const request$2 = {
+	params: z.object({
+		applicationId: cuidSchema,
+		provider: providerSchema
+	}),
+	body: z.object({
+		name: z.string().min(1).max(255),
+		value: z.string().min(1)
+	})
+};
+const response$2 = z.object({ data: z.object({ apiKey: providerApiKeyMetadataSchema }) });
+
+//#endregion
+//#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 {
-		code: status,
-		message: statusText
+		async create(input, options) {
+			const result = request$22.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$21.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$20.params.safeParse({ apiKeyId: id });
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH$6}/${id}/revoke`, {}, options);
+		},
+		async update(id, input, options) {
+			const paramsResult = request$19.params.safeParse({ apiKeyId: id });
+			if (!paramsResult.success) return {
+				ok: false,
+				error: createValidationError(paramsResult.error)
+			};
+			const bodyResult = request$19.body.safeParse(input);
+			if (!bodyResult.success) return {
+				ok: false,
+				error: createValidationError(bodyResult.error)
+			};
+			return fetcher.post(`${BASE_PATH$6}/${id}`, input, options);
+		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/applications.ts
-const BASE_PATH$4 = "/api/v1/applications";
-function buildQueryString$4(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.name !== void 0) searchParams.set("name", params.name);
-	if (params.sort !== void 0) searchParams.set("sort", params.sort);
-	if (params.order !== void 0) searchParams.set("order", params.order);
-	if (params.take !== void 0) searchParams.set("take", params.take.toString());
-	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
+const BASE_PATH$5 = "/api/v1/applications";
 function createApplicationsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$35.query.safeParse(params);
+				const result = request$17.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const queryString = buildQueryString$4(params);
-			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$5}${queryString}`, options);
 		},
 		async get(id, options) {
-			return fetcher.get(`${BASE_PATH$4}/${id}`, options);
+			return fetcher.get(`${BASE_PATH$5}/${id}`, options);
 		},
 		async create(input, options) {
-			const result = request$38.body.safeParse(input);
+			const result = request$18.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$5, input, options);
 		},
 		async update(id, input, options) {
-			const result = request$34.body.safeParse(input);
+			const result = request$16.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH$4}/${id}`, input, options);
+			return fetcher.post(`${BASE_PATH$5}/${id}`, input, options);
 		},
 		async delete(id, options) {
-			return fetcher.delete(`${BASE_PATH$4}/${id}`, options);
+			return fetcher.delete(`${BASE_PATH$5}/${id}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/env-secrets.ts
-const BASE_PATH$3 = "/api/v1/env/secrets";
+const BASE_PATH$4 = "/api/v1/env/secrets";
 function createSecretsApi(fetcher) {
 	return {
-		async list(options) {
-			return fetcher.get(BASE_PATH$3, options);
+		async list(params, options) {
+			if (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$4}${queryString}`, options);
 		},
 		async get(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.get(`${BASE_PATH$4}/${encodedName}`, options);
 		},
 		async create(input, options) {
-			const result = request$33.body.safeParse(input);
+			const result = request$15.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH$3, input, options);
+			return fetcher.post(BASE_PATH$4, input, options);
 		},
 		async update(name, input, options) {
-			const result = request$29.body.safeParse(input);
+			const result = request$13.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
+			return fetcher.put(`${BASE_PATH$4}/${encodedName}`, input, options);
 		},
 		async delete(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.deleteNoContent(`${BASE_PATH$4}/${encodedName}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/env-variables.ts
-const BASE_PATH$2 = "/api/v1/env/variables";
+const BASE_PATH$3 = "/api/v1/env/variables";
 function createVariablesApi(fetcher) {
 	return {
-		async list(options) {
-			return fetcher.get(BASE_PATH$2, options);
+		async list(params, options) {
+			const result = request$11.query.safeParse(params);
+			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$2}/${encodedName}`, options);
+			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
 		},
 		async create(input, options) {
-			const result = request$28.body.safeParse(input);
+			const result = request$12.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH$2, input, options);
+			return fetcher.post(BASE_PATH$3, input, options);
 		},
 		async update(name, input, options) {
-			const result = request$24.body.safeParse(input);
+			const result = request$10.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$2}/${encodedName}`, input, options);
+			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
 		},
 		async delete(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$2}/${encodedName}`, options);
+			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
 		}
 	};
 }
@@ -1450,72 +1641,6 @@ function createEnvApi(fetcher) {
 	};
 }
 
-//#endregion
-//#region src/endpoints/experts-drafts.ts
-function buildQueryString$3(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.limit !== void 0) searchParams.set("limit", params.limit.toString());
-	if (params.offset !== void 0) searchParams.set("offset", params.offset.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
-function createDraftsApi(fetcher, basePath) {
-	return {
-		async list(scopeName, params, options) {
-			if (params) {
-				const result = request$19.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const encodedScopeName = encodeURIComponent(scopeName);
-			const queryString = buildQueryString$3(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$22.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$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}`, input, options);
-		},
-		async delete(scopeName, draftRef, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			const encodedDraftRef = encodeURIComponent(draftRef);
-			return fetcher.delete(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
-		},
-		async assignVersion(scopeName, draftRef, input, options) {
-			const result = request$17.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) {
@@ -1527,113 +1652,67 @@ function createVersionsApi(fetcher, basePath) {
 
 //#endregion
 //#region src/endpoints/experts.ts
-const BASE_PATH$1 = "/api/v1/experts";
-function buildQueryString$2(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.filter !== void 0) searchParams.set("filter", params.filter);
-	if (params.category !== void 0) searchParams.set("category", params.category);
-	if (params.includeDrafts !== void 0) searchParams.set("includeDrafts", params.includeDrafts.toString());
-	if (params.limit !== void 0) searchParams.set("limit", params.limit.toString());
-	if (params.offset !== void 0) searchParams.set("offset", params.offset.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
+const BASE_PATH$2 = "/api/v1/experts";
 function createExpertsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$15.query.safeParse(params);
+				const result = request$9.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const queryString = buildQueryString$2(params);
-			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
+			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$1}/${encodedKey}`, options);
-		},
-		async getFeatured(options) {
-			return fetcher.get(`${BASE_PATH$1}/featured`, options);
-		},
-		async getMeta(key, options) {
-			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$1}/${encodedKey}/meta`, options);
-		},
-		async publish(scopeName, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/publish`, {}, options);
-		},
-		async unpublish(scopeName, options) {
-			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/unpublish`, {}, options);
-		},
-		async yank(key, options) {
-			const encodedKey = encodeURIComponent(key);
-			return fetcher.delete(`${BASE_PATH$1}/${encodedKey}`, options);
-		},
-		drafts: createDraftsApi(fetcher, BASE_PATH$1),
-		versions: createVersionsApi(fetcher, BASE_PATH$1)
-	};
-}
-
-//#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 {}
-		}
-	}
+			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 buildQueryString$1(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.take !== void 0) searchParams.set("take", params.take.toString());
-	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-	if (params.sort !== void 0) searchParams.set("sort", params.sort);
-	if (params.order !== void 0) searchParams.set("order", params.order);
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
 function createCheckpointsApi(fetcher, basePath) {
 	return {
 		async list(jobId, params, options) {
 			if (params) {
-				const result = request$8.query.safeParse(params);
+				const result = request$7.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const queryString = buildQueryString$1(params);
+			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$10.body.safeParse(input);
+			const result = request$8.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
@@ -1642,74 +1721,51 @@ function createCheckpointsApi(fetcher, basePath) {
 		},
 		async *stream(jobId, options) {
 			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
-			if (!result.ok) throw new Error(`Failed to start checkpoint stream: ${result.error.message}`);
+			if (!result.ok) {
+				yield {
+					ok: false,
+					error: result.error
+				};
+				return;
+			}
 			const reader = result.data.getReader();
-			for await (const checkpoint of parseSSE(reader)) yield checkpoint;
-		}
-	};
-}
-
-//#endregion
-//#region src/endpoints/jobs-workspace.ts
-function buildTreeQueryString(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.path !== void 0) searchParams.set("path", params.path);
-	if (params.recursive !== void 0) searchParams.set("recursive", params.recursive.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
-function createWorkspaceApi(fetcher, basePath) {
-	return {
-		async get(jobId, options) {
-			return fetcher.get(`${basePath}/${jobId}/workspace`, options);
-		},
-		async tree(jobId, params, options) {
-			if (params) {
-				const result = request.query.safeParse(params);
-				if (!result.success) return {
+			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: createValidationError(result.error)
+					error: createAbortError()
+				};
+				else yield {
+					ok: false,
+					error: createNetworkError(error)
 				};
 			}
-			const queryString = buildTreeQueryString(params);
-			return fetcher.get(`${basePath}/${jobId}/workspace/tree${queryString}`, options);
-		},
-		async blob(jobId, path, options) {
-			const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-			return fetcher.getBlob(`${basePath}/${jobId}/workspace/blob/${normalizedPath}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/jobs.ts
-const BASE_PATH = "/api/v1/jobs";
-function buildQueryString(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.take !== void 0) searchParams.set("take", params.take.toString());
-	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-	if (params.sort !== void 0) searchParams.set("sort", params.sort);
-	if (params.order !== void 0) searchParams.set("order", params.order);
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
+const BASE_PATH$1 = "/api/v1/jobs";
 function createJobsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$3.query.safeParse(params);
+				const result = request$4.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
 			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH}${queryString}`, options);
+			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
 		},
 		async get(id, options) {
-			return fetcher.get(`${BASE_PATH}/${id}`, options);
+			return fetcher.get(`${BASE_PATH$1}/${id}`, options);
 		},
 		async start(input, options) {
 			const result = request$5.body.safeParse(input);
@@ -1717,15 +1773,15 @@ function createJobsApi(fetcher) {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH, input, options);
+			return fetcher.post(BASE_PATH$1, input, options);
 		},
 		async update(id, input, options) {
-			const result = request$2.body.safeParse(input);
+			const result = request$3.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH}/${id}`, input, options);
+			return fetcher.post(`${BASE_PATH$1}/${id}`, input, options);
 		},
 		async continue(id, input, options) {
 			const result = request$6.body.safeParse(input);
@@ -1733,279 +1789,83 @@ function createJobsApi(fetcher) {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH}/${id}/continue`, input, options);
+			return fetcher.post(`${BASE_PATH$1}/${id}/continue`, input, options);
 		},
 		async cancel(id, options) {
-			return fetcher.post(`${BASE_PATH}/${id}/cancel`, {}, options);
+			return fetcher.post(`${BASE_PATH$1}/${id}/cancel`, {}, options);
 		},
-		checkpoints: createCheckpointsApi(fetcher, BASE_PATH),
-		workspace: createWorkspaceApi(fetcher, BASE_PATH)
+		checkpoints: createCheckpointsApi(fetcher, BASE_PATH$1)
 	};
 }
 
 //#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() {
-		const 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();
-		const timeoutId = setTimeout(() => 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);
-			}
-		};
-	}
-	async function request$39(method, path, body, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
-		try {
-			const response$41 = await fetch(buildUrl(path), {
-				method,
-				headers: buildHeaders(),
-				body: body ? JSON.stringify(body) : void 0,
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
-			return {
-				ok: true,
-				data: await response$41.json()
-			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
-			return {
-				ok: false,
-				error: createNetworkError(error)
-			};
-		} finally {
-			cleanup();
-		}
-	}
-	async function requestBlob(path, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
-		try {
-			const response$41 = await fetch(buildUrl(path), {
-				method: "GET",
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
-			return {
-				ok: true,
-				data: await response$41.blob()
-			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
-			return {
-				ok: false,
-				error: createNetworkError(error)
-			};
-		} finally {
-			cleanup();
-		}
-	}
-	async function requestStream(path, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
-		try {
-			const response$41 = await fetch(buildUrl(path), {
-				method: "GET",
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				cleanup();
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
-			if (!response$41.body) {
-				cleanup();
-				return {
-					ok: false,
-					error: createNetworkError(/* @__PURE__ */ new Error("Response body is null"))
-				};
-			}
-			cleanup();
-			return {
-				ok: true,
-				data: response$41.body
-			};
-		} catch (error) {
-			cleanup();
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
-			return {
+//#region src/endpoints/provider-settings.ts
+const BASE_PATH = "/api/v1/applications";
+function createProviderSettingsApi(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$1.body.safeParse(input);
+			if (!result.success) return {
 				ok: false,
-				error: createNetworkError(error)
-			};
-		}
-	}
-	async function requestNoContent(method, path, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
-		try {
-			const response$41 = await fetch(buildUrl(path), {
-				method,
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
-			return {
-				ok: true,
-				data: void 0
+				error: createValidationError(result.error)
 			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return {
+			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: createAbortError()
+				error: createValidationError(result.error)
 			};
-			return {
+			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: createNetworkError(error)
+				error: createValidationError(result.error)
 			};
-		} finally {
-			cleanup();
+			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);
 		}
-	}
-	return {
-		get: (path, options) => request$39("GET", path, void 0, options),
-		post: (path, body, options) => request$39("POST", path, body, options),
-		put: (path, body, options) => request$39("PUT", path, body, options),
-		delete: (path, options) => request$39("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/client.ts
+//#region src/public/client.ts
 function createApiClient(config) {
 	const fetcher = createFetcher(config);
 	return {
+		apiKeys: createApiKeysApi(fetcher),
 		applications: createApplicationsApi(fetcher),
 		env: createEnvApi(fetcher),
 		jobs: createJobsApi(fetcher),
-		experts: createExpertsApi(fetcher)
+		experts: createExpertsApi(fetcher),
+		providerSettings: createProviderSettingsApi(fetcher)
 	};
 }
 
 //#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
-/**
-* Build authentication headers from AuthOptions.
-*/
-function buildAuthHeaders(auth) {
-	if (auth.type === "apiKey") return { Authorization: `Bearer ${auth.apiKey}` };
-	return { Cookie: auth.cookie };
-}
-
-//#endregion
-export { buildAuthHeaders, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, stringifyApiKeyPermissions };
+export { buildAuthHeaders, buildQueryString, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createTimeoutError, createValidationError, handleHttpError, isAbortError, isClientError, isHttpError, isNetworkError, isTimeoutError, isValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, stringifyApiKeyPermissions };
 //# sourceMappingURL=index.mjs.map