create-expert 0.0.39 → 0.0.41

package/dist/resolve-expert-CTnETi9d.js

@@ -1,1651 +0,0 @@
-import { $ as boolean, B as messageSchema, Ft as PerstackError, G as number$1, H as userMessageSchema, I as usageSchema, L as toolResultSchema, Q as array, R as toolCallSchema, U as activityOrGroupSchema, V as toolMessageSchema, W as boolean$1, X as _undefined, ct as object, dt as record, gt as unknown, ht as union, it as literal, pt as string, q as _enum, st as number, tt as discriminatedUnion, ut as preprocess, z as instructionMessageSchema } from "./src-C0pz_C3h.js";
-
-//#region ../../node_modules/.pnpm/@perstack+api-client@0.0.55_@perstack+core@packages+core_zod@4.3.6/node_modules/@perstack/api-client/dist/index.mjs
-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) {
-	let errorBody;
-	try {
-		errorBody = await response.json();
-	} catch {
-		errorBody = void 0;
-	}
-	return {
-		ok: false,
-		error: createHttpError(response.status, response.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
-	};
-}
-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(method, path, body, options) {
-		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
-		try {
-			const response = await fetch(buildUrl(path), {
-				method,
-				headers: buildHeaders(body ? { hasBody: true } : void 0),
-				body: body ? JSON.stringify(body) : void 0,
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response.ok) return handleHttpError(response);
-			return {
-				ok: true,
-				data: await response.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 = await fetch(buildUrl(path), {
-				method: "GET",
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response.ok) return handleHttpError(response);
-			return {
-				ok: true,
-				data: await response.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 = await fetch(buildUrl(path), {
-				method: "GET",
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response.ok) {
-				cleanup();
-				return handleHttpError(response);
-			}
-			if (!response.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.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 = await fetch(buildUrl(path), {
-				method,
-				headers: buildHeaders(),
-				signal,
-				credentials: getCredentials()
-			});
-			if (!response.ok) return handleHttpError(response);
-			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("GET", path, void 0, options),
-		post: (path, body, options) => request("POST", path, body, options),
-		put: (path, body, options) => request("PUT", path, body, options),
-		delete: (path, options) => request("DELETE", path, void 0, options),
-		deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
-		getBlob: (path, options) => requestBlob(path, options),
-		getStream: (path, options) => requestStream(path, options)
-	};
-}
-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}` : "";
-}
-async function* parseSSEEvents(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 || !data) continue;
-			if (eventType !== "message" && eventType !== "error" && eventType !== "complete") continue;
-			try {
-				yield {
-					event: eventType,
-					data: JSON.parse(data)
-				};
-			} catch {}
-		}
-	}
-}
-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_-]*$/;
-const scopeNameRefRegex = /^[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 expertVersionRegex = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
-const tagNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
-const maxExpertNameLength = 255;
-const maxExpertVersionTagLength = 255;
-const maxExpertKeyLength = 511;
-const maxExpertDescriptionLength = 1024 * 2;
-const maxExpertInstructionLength = 1024 * 20;
-const maxExpertDelegateItems = 255;
-const maxExpertTagItems = 8;
-const maxExpertJobQueryLength = 1024 * 20;
-const packageWithVersionRegex = /^(?:@[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 urlSafeRegex = /^[a-z0-9][a-z0-9_-]*$/;
-const maxSkillNameLength = 255;
-const maxSkillDescriptionLength = 1024 * 2;
-const maxSkillRuleLength = 1024 * 2;
-const maxSkillPickOmitItems = 255;
-const maxSkillRequiredEnvItems = 255;
-const maxSkillToolNameLength = 255;
-const maxSkillEndpointLength = 1024 * 2;
-const maxSkillInputJsonSchemaLength = 1024 * 20;
-const maxCheckpointToolCallIdLength = 255;
-const envNameRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-const maxEnvNameLength = 255;
-const maxProviderBaseUrlLength = 2048;
-const maxProviderHeaderKeyLength = 255;
-const maxProviderHeaderValueLength = 2048;
-const maxProviderHeadersCount = 50;
-const cuidSchema = string().cuid2();
-string().min(24).cuid2();
-const runtimeVersionSchema = _enum(["v1.0"]);
-const providerSchema = _enum([
-	"anthropic",
-	"google",
-	"openai",
-	"deepseek",
-	"azure-openai",
-	"amazon-bedrock",
-	"google-vertex"
-]);
-const datetimeSchema = string().datetime({ offset: true });
-const expertKeyFieldSchema = string().min(1).max(maxExpertKeyLength).regex(expertKeyRegex);
-const expertNameFieldSchema = string().min(1).max(maxExpertNameLength).regex(expertNameRegex);
-const expertVersionFieldSchema = string().min(1).max(maxExpertVersionTagLength).regex(expertVersionRegex);
-const expertTagFieldSchema = string().min(1).max(maxExpertVersionTagLength).regex(tagNameRegex);
-const expertCategoryFieldSchema = _enum([
-	"general",
-	"coding",
-	"research",
-	"writing",
-	"data",
-	"automation"
-]);
-const scopeNameSchema = string().min(1).max(maxExpertNameLength).regex(scopeNameRegex);
-string().min(1).max(maxExpertNameLength + maxExpertVersionTagLength + 1).regex(scopeNameRefRegex);
-string().min(1).max(30);
-const organizationStatusSchema = _enum([
-	"active",
-	"inactive",
-	"deleted"
-]);
-const organizationTypeSchema = _enum([
-	"personal",
-	"personalPlus",
-	"team",
-	"serviceAdmin"
-]);
-const organizationSchema = object({
-	type: literal("organization"),
-	id: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	name: string().min(1).max(maxOrganizationNameLength).regex(organizationNameRegex).optional(),
-	nameChangedAt: datetimeSchema.optional(),
-	status: organizationStatusSchema,
-	organizationType: organizationTypeSchema,
-	maxApplications: number().int().min(0),
-	maxApiKeys: number().int().min(0),
-	maxExperts: number().int().min(0)
-});
-/**
-* Dedent function for multi-line template strings.
-* Adapted from ts-dedent (MIT License) to provide pure ESM support.
-*
-* Removes leading indentation from multi-line strings while preserving
-* relative indentation between lines.
-*/
-function dedent(templ, ...values) {
-	let strings = Array.from(typeof templ === "string" ? [templ] : templ);
-	const lastIndex = strings.length - 1;
-	strings[lastIndex] = (strings[lastIndex] ?? "").replace(/\r?\n([\t ]*)$/, "");
-	const indentLengths = strings.reduce((arr, str) => {
-		const matches = str.match(/\n([\t ]+|(?!\s).)/g);
-		if (matches) return arr.concat(matches.map((match) => match.match(/[\t ]/g)?.length ?? 0));
-		return arr;
-	}, []);
-	if (indentLengths.length) {
-		const pattern = new RegExp(`\n[\t ]{${Math.min(...indentLengths)}}`, "g");
-		strings = strings.map((str) => str.replace(pattern, "\n"));
-	}
-	strings[0] = (strings[0] ?? "").replace(/^\r?\n/, "");
-	let string = strings[0] ?? "";
-	values.forEach((value, i) => {
-		const endentation = string.match(/(?:^|\n)( *)$/)?.[1] ?? "";
-		let indentedValue = value;
-		if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map((str, j) => {
-			return j === 0 ? str : `${endentation}${str}`;
-		}).join("\n");
-		string += String(indentedValue) + (strings[i + 1] ?? "");
-	});
-	return string;
-}
-object({
-	code: literal(400),
-	error: literal("Bad Request"),
-	reason: string()
-}).describe("Bad Request");
-object({
-	code: literal(401),
-	error: literal("Unauthorized"),
-	reason: literal("Failed to authenticate")
-}).describe(dedent`
-    Authentication failed. Possible reasons:
-    - Authorization header is not provided
-    - Invalid API key
-    - Session expired
-  `);
-object({
-	code: literal(403),
-	error: literal("Forbidden"),
-	reason: string()
-}).describe("Access denied. The authenticated user does not have permission to perform this action.");
-object({
-	code: literal(403),
-	error: literal("Forbidden"),
-	reason: string(),
-	details: object({
-		minutesUsed: number(),
-		limitMinutes: number(),
-		upgradeUrl: string()
-	})
-}).describe("Usage limit exceeded. Upgrade your plan to continue.");
-object({
-	code: literal(404),
-	error: literal("Not Found"),
-	reason: string()
-}).describe("Resource not found.");
-object({
-	code: literal(409),
-	error: literal("Conflict"),
-	reason: string()
-}).describe("Request conflicts with current state of the resource.");
-object({
-	code: literal(503),
-	error: literal("Service Unavailable"),
-	reason: string()
-}).describe("Service temporarily unavailable. Retry with exponential backoff.");
-object({
-	code: literal(422),
-	error: literal("Validation Failed"),
-	reason: unknown()
-}).describe("Request validation failed. Check the request body, query parameters, or path parameters.");
-const paginationMeta = object({
-	total: number().int().min(0),
-	take: number().int().min(1),
-	skip: number().int().min(0)
-});
-object({
-	code: literal(401),
-	error: literal("Unauthorized"),
-	reason: string()
-}).describe("Unauthorized");
-const applicationNameSchema = string().min(1).max(maxApplicationNameLength).regex(applicationNameRegex);
-const applicationStatusSchema = _enum([
-	"active",
-	"inactive",
-	"deleted"
-]);
-const applicationSchema = object({
-	type: literal("application"),
-	id: cuidSchema,
-	organizationId: cuidSchema,
-	organization: organizationSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	name: applicationNameSchema,
-	status: applicationStatusSchema,
-	expertCount: number().describe("Number of expert draft scopes associated with this application").optional(),
-	providers: array(providerSchema).describe("List of configured providers for this application").optional(),
-	totalJobs: number().describe("Total number of jobs executed for this application").optional(),
-	lastJobExecutionAt: string().datetime({ offset: true }).nullable().describe("Timestamp of the most recent job execution").optional()
-});
-const request$17 = { body: object({
-	name: applicationNameSchema,
-	applicationGroupId: cuidSchema.optional()
-}) };
-object({ data: object({ application: applicationSchema }) });
-const request$16 = { query: object({
-	name: preprocess((val) => Array.isArray(val) ? val.join(",") : val, string().optional()),
-	sort: _enum([
-		"name",
-		"createdAt",
-		"updatedAt"
-	]).optional(),
-	order: _enum(["asc", "desc"]).optional(),
-	take: number$1().min(1).max(100).default(20),
-	skip: number$1().min(0).default(0)
-}) };
-object({
-	data: object({ applications: array(applicationSchema) }),
-	meta: paginationMeta
-});
-const request$15 = {
-	params: object({ applicationId: cuidSchema }),
-	body: 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" })
-};
-object({ data: object({ application: applicationSchema }) });
-const secretNameSchema = 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 = string().min(1, "Secret value is required").max(maxSecretValueLength);
-const secretMetadataSchema = object({
-	name: string(),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-object({
-	type: literal("secret"),
-	id: cuidSchema,
-	name: secretNameSchema,
-	applicationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-const request$14 = { body: object({
-	applicationId: cuidSchema,
-	name: secretNameSchema,
-	value: secretValueSchema
-}) };
-object({ data: object({ secret: secretMetadataSchema }) });
-const request$13 = { query: object({ applicationId: cuidSchema.optional() }) };
-object({ data: object({ secrets: array(secretMetadataSchema) }) });
-const request$12 = {
-	params: object({ name: string().min(1) }),
-	body: object({
-		applicationId: cuidSchema,
-		value: secretValueSchema
-	})
-};
-object({ data: object({ secret: secretMetadataSchema }) });
-const variableNameSchema = 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 = string().max(maxVariableValueLength);
-object({
-	type: literal("variable"),
-	id: cuidSchema,
-	applicationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	name: variableNameSchema,
-	value: variableValueSchema
-});
-const variableResponseSchema = object({
-	name: variableNameSchema,
-	value: variableValueSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-const request$11 = { body: object({
-	applicationId: cuidSchema,
-	name: variableNameSchema,
-	value: variableValueSchema
-}) };
-object({ data: object({ variable: variableResponseSchema }) });
-const request$10 = { query: object({ applicationId: cuidSchema }) };
-object({ data: object({ variables: array(variableResponseSchema) }) });
-const request$9 = {
-	params: object({ name: string().min(1) }),
-	body: object({
-		applicationId: cuidSchema,
-		value: variableValueSchema
-	})
-};
-object({ data: object({ variable: variableResponseSchema }) });
-const expertScopeSchema = object({
-	id: cuidSchema,
-	name: scopeNameSchema,
-	organizationId: cuidSchema,
-	expertDraftScopeId: cuidSchema,
-	published: boolean(),
-	publishedAt: datetimeSchema.nullable(),
-	category: expertCategoryFieldSchema,
-	totalRuns: number().int().min(0),
-	totalJobs: number().int().min(0),
-	totalStars: number().int().min(0),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	createdBy: cuidSchema,
-	updatedBy: cuidSchema
-});
-const expertVersionSchema = object({
-	id: cuidSchema,
-	expertScopeId: cuidSchema,
-	version: expertVersionFieldSchema,
-	public: boolean(),
-	yanked: boolean(),
-	totalRuns: number().int().min(0),
-	totalJobs: number().int().min(0),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	createdBy: cuidSchema,
-	updatedBy: cuidSchema,
-	tags: array(expertTagFieldSchema),
-	readmeUrl: string().optional()
-});
-expertScopeSchema.extend({ versions: array(expertVersionSchema) });
-function isPrivateOrLocalIP(hostname) {
-	if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") return true;
-	const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
-	if (ipv4Match) {
-		const a = Number(ipv4Match[1]);
-		const b = Number(ipv4Match[2]);
-		if (a === 10) return true;
-		if (a === 172 && b >= 16 && b <= 31) return true;
-		if (a === 192 && b === 168) return true;
-		if (a === 169 && b === 254) return true;
-		if (a === 127) return true;
-	}
-	if (hostname.includes(":")) {
-		if (hostname.startsWith("fe80:") || hostname.startsWith("fc") || hostname.startsWith("fd")) return true;
-	}
-	if (hostname.startsWith("::ffff:")) {
-		if (isPrivateOrLocalIP(hostname.slice(7))) return true;
-	}
-	return false;
-}
-const sseEndpointSchema = string().max(maxSkillEndpointLength).url().refine((url) => {
-	try {
-		const parsed = new URL(url);
-		if (parsed.protocol !== "https:") return false;
-		if (isPrivateOrLocalIP(parsed.hostname)) return false;
-		return true;
-	} catch {
-		return false;
-	}
-}, { message: "Endpoint must be a public HTTPS URL" });
-const skillNameSchema = string().min(1).max(maxSkillNameLength).regex(packageWithVersionRegex);
-const mcpStdioSkillCommandSchema = _enum(["npx", "uvx"]);
-const mcpStdioSkillSchema = object({
-	type: literal("mcpStdioSkill"),
-	name: string().min(1),
-	description: string().min(1).max(maxSkillDescriptionLength),
-	rule: string().min(1).max(maxSkillRuleLength).optional(),
-	pick: array(string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
-	omit: array(string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
-	command: mcpStdioSkillCommandSchema,
-	packageName: string().min(1).max(maxSkillNameLength).regex(packageWithVersionRegex),
-	requiredEnv: array(string().min(1).max(maxEnvNameLength).regex(envNameRegex)).max(maxSkillRequiredEnvItems).optional().default([])
-});
-const mcpSseSkillSchema = object({
-	type: literal("mcpSseSkill"),
-	name: string().min(1),
-	description: string().min(1).max(maxSkillDescriptionLength),
-	rule: string().min(1).max(maxSkillRuleLength).optional(),
-	pick: array(string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
-	omit: array(string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
-	endpoint: sseEndpointSchema
-});
-const interactiveSkillSchema = object({
-	type: literal("interactiveSkill"),
-	name: string().min(1),
-	description: string().min(1).max(maxSkillDescriptionLength),
-	rule: string().min(1).max(maxSkillRuleLength).optional(),
-	tools: record(string().min(1).max(maxSkillToolNameLength).regex(urlSafeRegex), object({
-		description: string().min(1).max(maxSkillDescriptionLength),
-		inputJsonSchema: string().min(1).max(maxSkillInputJsonSchemaLength)
-	}))
-});
-const skillSchema = discriminatedUnion("type", [
-	mcpStdioSkillSchema,
-	mcpSseSkillSchema,
-	interactiveSkillSchema
-]);
-const expertSchema = object({
-	key: expertKeyFieldSchema,
-	name: expertNameFieldSchema,
-	version: expertVersionFieldSchema,
-	description: string().max(maxExpertDescriptionLength).optional(),
-	instruction: string().min(1).max(maxExpertInstructionLength),
-	skills: record(skillNameSchema, skillSchema).optional().default({}),
-	delegates: array(expertKeyFieldSchema).min(0).max(maxExpertDelegateItems).optional().default([]),
-	tags: array(expertTagFieldSchema).min(0).max(maxExpertTagItems).optional().default([]),
-	minRuntimeVersion: runtimeVersionSchema.optional()
-});
-object({
-	scope: expertScopeSchema,
-	version: expertVersionSchema
-});
-const expertWithMetadataSchema = expertSchema.extend({
-	scope: expertScopeSchema,
-	version: expertVersionSchema
-});
-const request$8 = { query: object({
-	filter: string().describe("Filter by scope name (partial match)").optional(),
-	category: _enum([
-		"general",
-		"coding",
-		"research",
-		"writing",
-		"data",
-		"automation"
-	]).describe("Filter by category").optional(),
-	includeDrafts: boolean$1().default(false).describe("Include unpublished scopes (owner only)").optional(),
-	take: number$1().min(1).max(100).default(20),
-	skip: number$1().min(0).default(0)
-}) };
-object({
-	data: object({ experts: array(expertScopeSchema.extend({ currentVersion: expertVersionSchema.nullable() })) }),
-	meta: paginationMeta
-});
-const anthropicSupportModels = [
-	{
-		modelId: "claude-opus-4-5",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-opus-4-1",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-opus-4-20250514",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-sonnet-4-5",
-		default: true,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-sonnet-4-20250514",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-3-7-sonnet-20250219",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-haiku-4-5",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "claude-3-5-haiku-latest",
-		default: false,
-		provider: "anthropic",
-		contextWindow: 2e5
-	}
-];
-const googleSupportModels = [
-	{
-		modelId: "gemini-3-pro-preview",
-		default: false,
-		provider: "google",
-		contextWindow: 1e6
-	},
-	{
-		modelId: "gemini-2.5-pro",
-		default: true,
-		provider: "google",
-		contextWindow: 1e6
-	},
-	{
-		modelId: "gemini-2.5-flash",
-		default: false,
-		provider: "google",
-		contextWindow: 1e6
-	},
-	{
-		modelId: "gemini-2.5-flash-lite",
-		default: false,
-		provider: "google",
-		contextWindow: 1e6
-	}
-];
-const openAiSupportModels = [
-	{
-		modelId: "gpt-5",
-		default: true,
-		provider: "openai",
-		contextWindow: 4e5
-	},
-	{
-		modelId: "gpt-5-mini",
-		default: false,
-		provider: "openai",
-		contextWindow: 4e5
-	},
-	{
-		modelId: "gpt-5-nano",
-		default: false,
-		provider: "openai",
-		contextWindow: 4e5
-	},
-	{
-		modelId: "gpt-5-chat-latest",
-		default: false,
-		provider: "openai",
-		contextWindow: 128e3
-	},
-	{
-		modelId: "o4-mini",
-		default: false,
-		provider: "openai",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "o3",
-		default: false,
-		provider: "openai",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "o3-mini",
-		default: false,
-		provider: "openai",
-		contextWindow: 2e5
-	},
-	{
-		modelId: "gpt-4.1",
-		default: false,
-		provider: "openai",
-		contextWindow: 1e6
-	}
-];
-const deepseekSupportModels = [{
-	modelId: "deepseek-chat",
-	default: true,
-	provider: "deepseek",
-	contextWindow: 128e3
-}, {
-	modelId: "deepseek-reasoner",
-	default: false,
-	provider: "deepseek",
-	contextWindow: 128e3
-}];
-const allSupportModels = [
-	...anthropicSupportModels,
-	...googleSupportModels,
-	...openAiSupportModels,
-	...deepseekSupportModels
-];
-const supportModels = Object.fromEntries(allSupportModels.map((model) => [model.modelId, model]));
-function getSupportModelNames() {
-	return Object.keys(supportModels);
-}
-const reasoningBudgetSchema = union([_enum([
-	"none",
-	"minimal",
-	"low",
-	"medium",
-	"high"
-]), number().int().min(0)]);
-const jobStatusSchema = _enum([
-	"queued",
-	"processing",
-	"completed",
-	"requestInteractiveToolResult",
-	"requestDelegateResult",
-	"exceededMaxSteps",
-	"failed",
-	"canceling",
-	"canceled",
-	"expired"
-]);
-const modelNames = getSupportModelNames();
-const firstModel = modelNames[0];
-if (firstModel === void 0) throw new Error("No support models available");
-const jobModelSchema = _enum([firstModel, ...modelNames.slice(1)]);
-const jobBaseSchema = object({
-	type: literal("job"),
-	id: cuidSchema,
-	organizationId: cuidSchema,
-	applicationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	status: jobStatusSchema,
-	currentExecutionId: cuidSchema.optional(),
-	coordinatorExpertKey: expertKeyFieldSchema,
-	query: string().min(1).max(maxExpertJobQueryLength).optional(),
-	expert: expertWithMetadataSchema,
-	provider: providerSchema,
-	model: jobModelSchema,
-	reasoningBudget: reasoningBudgetSchema,
-	runtimeVersion: runtimeVersionSchema,
-	maxSteps: number().int().min(1),
-	maxRetries: number().int().min(0),
-	currentStep: number().int().min(0),
-	totalSteps: number().int().min(0),
-	totalDuration: number().int().min(0),
-	usage: usageSchema,
-	lastActivity: activityOrGroupSchema.nullable().optional()
-});
-const publishedJobSchema = jobBaseSchema.extend({
-	expertVersionId: cuidSchema,
-	expertDraftRefId: _undefined()
-});
-const draftJobSchema = jobBaseSchema.extend({
-	expertVersionId: _undefined(),
-	expertDraftRefId: cuidSchema
-});
-const jobSchema = union([publishedJobSchema, draftJobSchema]);
-const request$7 = {
-	params: object({ jobId: cuidSchema }),
-	body: object({
-		query: string().min(1).max(maxExpertJobQueryLength),
-		provider: providerSchema.optional(),
-		model: jobModelSchema.optional(),
-		reasoningBudget: reasoningBudgetSchema.optional(),
-		maxSteps: number$1().optional(),
-		maxRetries: number$1().optional()
-	})
-};
-object({ data: object({ job: jobSchema }) });
-const request$6 = { body: object({
-	applicationId: cuidSchema.describe("Application ID to create the job in"),
-	query: string().min(1).max(maxExpertJobQueryLength),
-	provider: providerSchema,
-	model: jobModelSchema.optional(),
-	reasoningBudget: reasoningBudgetSchema.optional(),
-	maxSteps: number$1().optional(),
-	maxRetries: number$1().optional()
-}).extend({
-	expertKey: expertKeyFieldSchema.optional(),
-	draftRefId: cuidSchema.describe("Draft ref ID to run the job with").optional()
-}).refine((data) => {
-	const hasExpertKey = data.expertKey !== void 0;
-	const hasDraftRefId = data.draftRefId !== void 0;
-	return hasExpertKey && !hasDraftRefId || !hasExpertKey && hasDraftRefId;
-}, { message: "Either expertKey or draftRefId must be provided, but not both" }) };
-object({ data: object({ job: jobSchema }) });
-const request$5 = { query: object({
-	sort: _enum(["createdAt", "updatedAt"]).optional(),
-	order: _enum(["asc", "desc"]).optional(),
-	take: number$1().min(1).max(100).default(20),
-	skip: number$1().min(0).default(0),
-	expertScopeId: cuidSchema.optional(),
-	expertDraftScopeId: cuidSchema.optional(),
-	applicationId: cuidSchema.optional(),
-	statuses: preprocess((val) => typeof val === "string" ? val.split(",") : val, array(jobStatusSchema).optional()),
-	expertKeyFilter: string().max(100).optional()
-}) };
-object({
-	data: object({ jobs: array(jobSchema) }),
-	meta: paginationMeta
-});
-const delegationTargetSchema = object({
-	expert: expertSchema,
-	toolCallId: string().min(1).max(maxCheckpointToolCallIdLength),
-	toolName: string().min(1).max(maxSkillToolNameLength),
-	query: string().min(1)
-});
-/**
-* API Checkpoint schema - extended checkpoint format for API responses.
-* Includes additional fields computed from runtime checkpoint and step data:
-* - activities: computed via getActivities() from @perstack/core
-* - inputMessages, newMessages, toolCalls, toolResults: step-related data
-* - expert: full Expert type (with instruction, skills, etc.)
-* - startedAt/finishedAt: ISO string format (runtime uses Unix timestamps)
-*/
-const apiCheckpointSchema = object({
-	type: literal("checkpoint"),
-	id: cuidSchema,
-	jobId: cuidSchema,
-	runId: cuidSchema,
-	activities: array(activityOrGroupSchema),
-	stepNumber: number().int().min(1),
-	status: _enum([
-		"init",
-		"proceeding",
-		"completed",
-		"stoppedByInteractiveTool",
-		"stoppedByDelegate",
-		"stoppedByExceededMaxSteps",
-		"stoppedByError"
-	]),
-	expert: expertSchema,
-	delegateTo: array(delegationTargetSchema).optional(),
-	delegatedBy: object({
-		expert: expertSchema,
-		toolCallId: string().min(1).max(maxCheckpointToolCallIdLength),
-		toolName: string().min(1).max(maxSkillToolNameLength),
-		checkpointId: cuidSchema,
-		runId: cuidSchema
-	}).optional(),
-	inputMessages: array(union([
-		instructionMessageSchema,
-		userMessageSchema,
-		toolMessageSchema
-	])).optional(),
-	messages: array(messageSchema),
-	newMessages: array(messageSchema),
-	toolCalls: array(toolCallSchema).optional(),
-	toolResults: array(toolResultSchema).optional(),
-	pendingToolCalls: array(toolCallSchema).optional(),
-	partialToolResults: array(toolResultSchema).optional(),
-	usage: usageSchema,
-	contextWindow: number().int().min(0).optional(),
-	contextWindowUsage: number().int().min(0).optional(),
-	error: object({
-		name: string().min(1),
-		message: string().min(1),
-		statusCode: number().int().min(100).max(599).optional(),
-		isRetryable: boolean()
-	}).optional(),
-	retryCount: number().int().min(0).optional(),
-	startedAt: datetimeSchema,
-	finishedAt: datetimeSchema.optional()
-});
-const request$4 = {
-	params: object({
-		jobId: cuidSchema,
-		runId: cuidSchema
-	}),
-	query: object({
-		filter: string().min(1).max(256).optional(),
-		sort: _enum(["createdAt", "updatedAt"]).optional(),
-		order: _enum(["asc", "desc"]).optional(),
-		take: number$1().min(1).max(100).default(20),
-		skip: number$1().min(0).default(0)
-	})
-};
-object({
-	data: object({ checkpoints: array(apiCheckpointSchema) }),
-	meta: paginationMeta
-});
-const runStatusSchema = _enum([
-	"queued",
-	"processing",
-	"completed",
-	"stoppedByInteractiveTool",
-	"stoppedByDelegate",
-	"stoppedByExceededMaxSteps",
-	"stoppedByError"
-]);
-const runSchema = object({
-	type: literal("run"),
-	id: cuidSchema,
-	jobId: cuidSchema,
-	executionId: cuidSchema.optional(),
-	parentRunId: cuidSchema.optional(),
-	organizationId: cuidSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	status: runStatusSchema,
-	expertKey: expertKeyFieldSchema,
-	expert: expertWithMetadataSchema,
-	stepNumber: number().int().min(0),
-	usage: usageSchema
-});
-const request$3 = {
-	params: object({ jobId: cuidSchema }),
-	query: object({
-		sort: _enum(["createdAt", "updatedAt"]).optional(),
-		order: _enum(["asc", "desc"]).optional(),
-		take: number$1().min(1).max(100).default(20),
-		skip: number$1().min(0).default(0)
-	})
-};
-object({
-	data: object({ runs: array(runSchema) }),
-	meta: paginationMeta
-});
-const baseUrlSchema = string().url().max(maxProviderBaseUrlLength).optional();
-const headersSchema = record(string().min(1).max(maxProviderHeaderKeyLength), string().max(maxProviderHeaderValueLength)).refine((headers) => Object.keys(headers).length <= maxProviderHeadersCount, { message: `Headers must have at most ${maxProviderHeadersCount} entries` }).optional();
-const anthropicProviderSettingsSchema = object({
-	baseUrl: baseUrlSchema,
-	headers: headersSchema
-});
-const googleProviderSettingsSchema = object({
-	baseUrl: baseUrlSchema,
-	headers: headersSchema
-});
-const openaiProviderSettingsSchema = object({
-	baseUrl: baseUrlSchema,
-	headers: headersSchema,
-	organization: string().min(1).optional(),
-	project: string().min(1).optional(),
-	name: string().min(1).optional()
-});
-const deepseekProviderSettingsSchema = object({
-	baseUrl: baseUrlSchema,
-	headers: headersSchema
-});
-const azureOpenaiProviderSettingsSchema = object({
-	baseUrl: baseUrlSchema,
-	headers: headersSchema,
-	resourceName: string().min(1).optional(),
-	apiVersion: string().min(1).optional(),
-	useDeploymentBasedUrls: boolean().optional()
-});
-const amazonBedrockProviderSettingsSchema = object({ region: string().min(1).optional() });
-const googleVertexProviderSettingsSchema = object({
-	baseUrl: baseUrlSchema,
-	headers: headersSchema,
-	project: string().min(1).optional(),
-	location: string().min(1).optional()
-});
-const providerSettingsSchema = union([
-	anthropicProviderSettingsSchema,
-	googleProviderSettingsSchema,
-	openaiProviderSettingsSchema,
-	deepseekProviderSettingsSchema,
-	azureOpenaiProviderSettingsSchema,
-	amazonBedrockProviderSettingsSchema,
-	googleVertexProviderSettingsSchema
-]);
-object({
-	type: literal("providerSetting"),
-	id: cuidSchema,
-	applicationId: cuidSchema,
-	provider: providerSchema,
-	settings: providerSettingsSchema.optional(),
-	application: applicationSchema,
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-const providerSettingResponseSchema = object({
-	type: literal("providerSetting"),
-	id: cuidSchema,
-	provider: providerSchema,
-	settings: providerSettingsSchema.optional(),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-const providerApiKeyMetadataSchema = object({
-	id: cuidSchema,
-	name: string(),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	lastUsedAt: datetimeSchema.nullable(),
-	expiresAt: datetimeSchema.nullable()
-});
-const request$2 = {
-	params: object({
-		applicationId: cuidSchema,
-		provider: providerSchema
-	}),
-	body: object({
-		name: string().min(1).max(255),
-		value: string().min(1)
-	})
-};
-object({ data: object({ apiKey: providerApiKeyMetadataSchema }) });
-const request$1 = {
-	params: object({ applicationId: cuidSchema }),
-	body: object({
-		provider: providerSchema,
-		settings: providerSettingsSchema.optional()
-	})
-};
-object({ data: object({ providerSetting: providerSettingResponseSchema }) });
-const request = {
-	params: object({
-		applicationId: cuidSchema,
-		provider: providerSchema
-	}),
-	body: object({ settings: providerSettingsSchema.optional() })
-};
-object({ data: object({ providerSetting: providerSettingResponseSchema }) });
-function createRunCheckpointsApi(fetcher, basePath) {
-	return {
-		async list(jobId, runId, params, options) {
-			if (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(`${basePath}/${jobId}/runs/${runId}/checkpoints${queryString}`, options);
-		},
-		async get(jobId, runId, checkpointId, options) {
-			return fetcher.get(`${basePath}/${jobId}/runs/${runId}/checkpoints/${checkpointId}`, options);
-		}
-	};
-}
-function createRunsApi(fetcher, basePath) {
-	return {
-		async list(jobId, params, options) {
-			if (params) {
-				const result = request$3.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${basePath}/${jobId}/runs${queryString}`, options);
-		},
-		async get(jobId, runId, options) {
-			return fetcher.get(`${basePath}/${jobId}/runs/${runId}`, options);
-		},
-		checkpoints: createRunCheckpointsApi(fetcher, basePath)
-	};
-}
-const BASE_PATH$5 = "/api/v1/jobs";
-/**
-* Error thrown when stream ends abnormally.
-*/
-var StreamError = class extends Error {
-	constructor(type, jobId, message) {
-		super(message ?? `Stream error: ${type}`);
-		this.type = type;
-		this.jobId = jobId;
-		this.name = "StreamError";
-	}
-};
-/**
-* Error thrown when stream connection or reading fails.
-*/
-var StreamConnectionError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "StreamConnectionError";
-	}
-};
-function isErrorEventData(data) {
-	return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && "jobId" in data && typeof data.jobId === "string";
-}
-function isCompleteEventData(data) {
-	return typeof data === "object" && data !== null && "status" in data && typeof data.status === "string" && "jobId" in data && typeof data.jobId === "string";
-}
-function createJobsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$5.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 start(input, options) {
-			const result = request$6.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$5, input, options);
-		},
-		async continue(id, input, options) {
-			const result = request$7.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${BASE_PATH$5}/${id}/continue`, input, options);
-		},
-		async cancel(id, options) {
-			return fetcher.post(`${BASE_PATH$5}/${id}/cancel`, {}, options);
-		},
-		async *stream(id, options) {
-			const result = await fetcher.getStream(`${BASE_PATH$5}/${id}/stream`, options);
-			if (!result.ok) throw new StreamConnectionError(result.error.message);
-			const reader = result.data.getReader();
-			try {
-				for await (const sseEvent of parseSSEEvents(reader)) if (sseEvent.event === "message") yield sseEvent.data;
-				else if (sseEvent.event === "error" && isErrorEventData(sseEvent.data)) throw new StreamError(sseEvent.data.type, sseEvent.data.jobId, sseEvent.data.message);
-				else if (sseEvent.event === "complete" && isCompleteEventData(sseEvent.data)) return;
-			} catch (error) {
-				if (error instanceof StreamError || error instanceof StreamConnectionError) throw error;
-				if (error instanceof DOMException && error.name === "AbortError") throw error;
-				throw new StreamConnectionError(error instanceof Error ? error.message : "Stream read error");
-			}
-		},
-		runs: createRunsApi(fetcher, BASE_PATH$5)
-	};
-}
-const BASE_PATH$4 = "/api/v1/applications";
-function createApplicationsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$16.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(id, options) {
-			return fetcher.get(`${BASE_PATH$4}/${id}`, options);
-		},
-		async create(input, options) {
-			const result = request$17.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$4, input, options);
-		},
-		async update(id, input, options) {
-			const result = request$15.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${BASE_PATH$4}/${id}`, input, options);
-		},
-		async delete(id, options) {
-			return fetcher.delete(`${BASE_PATH$4}/${id}`, options);
-		}
-	};
-}
-const BASE_PATH$3 = "/api/v1/env/secrets";
-function createSecretsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$13.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$3}/${encodedName}`, options);
-		},
-		async create(input, options) {
-			const result = request$14.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$3, input, options);
-		},
-		async update(name, input, options) {
-			const result = request$12.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);
-		},
-		async delete(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
-		}
-	};
-}
-const BASE_PATH$2 = "/api/v1/env/variables";
-function createVariablesApi(fetcher) {
-	return {
-		async list(params, options) {
-			const result = request$10.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(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$2}/${encodedName}`, options);
-		},
-		async create(input, options) {
-			const result = request$11.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$2, input, options);
-		},
-		async update(name, input, options) {
-			const result = request$9.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);
-		},
-		async delete(name, options) {
-			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$2}/${encodedName}`, options);
-		}
-	};
-}
-function createEnvApi(fetcher) {
-	return {
-		secrets: createSecretsApi(fetcher),
-		variables: createVariablesApi(fetcher)
-	};
-}
-function createVersionsApi(fetcher, basePath) {
-	return { async list(scopeName, options) {
-		const encodedScopeName = encodeURIComponent(scopeName);
-		return fetcher.get(`${basePath}/${encodedScopeName}/versions`, options);
-	} };
-}
-const BASE_PATH$1 = "/api/v1/experts";
-function createExpertsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$8.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(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);
-		},
-		versions: createVersionsApi(fetcher, BASE_PATH$1)
-	};
-}
-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: 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);
-		}
-	};
-}
-function createApiClient(config) {
-	const fetcher = createFetcher(config);
-	return {
-		applications: createApplicationsApi(fetcher),
-		env: createEnvApi(fetcher),
-		jobs: createJobsApi(fetcher),
-		experts: createExpertsApi(fetcher),
-		providerSettings: createProviderSettingsApi(fetcher)
-	};
-}
-
-//#endregion
-//#region ../../packages/runtime/src/helpers/resolve-expert.ts
-async function resolveExpertToRun(expertKey, experts, clientOptions) {
-	if (experts[expertKey]) return experts[expertKey];
-	if (!clientOptions.perstackApiKey) throw new PerstackError(`PERSTACK_API_KEY is required to resolve published expert "${expertKey}"`);
-	const result = await createApiClient({
-		baseUrl: clientOptions.perstackApiBaseUrl,
-		apiKey: clientOptions.perstackApiKey
-	}).experts.get(expertKey);
-	if (!result.ok) throw new PerstackError(`Failed to resolve expert "${expertKey}": ${result.error.message}`);
-	const publishedExpert = result.data.data.definition.experts[expertKey];
-	if (!publishedExpert) throw new PerstackError(`Expert "${expertKey}" not found in API response`);
-	return toRuntimeExpert(expertKey, publishedExpert);
-}
-function toRuntimeExpert(key, expert) {
-	const skills = Object.fromEntries(Object.entries(expert.skills ?? {}).map(([name, skill]) => {
-		switch (skill.type) {
-			case "mcpStdioSkill": return [name, {
-				type: skill.type,
-				name,
-				description: skill.description,
-				rule: skill.rule,
-				pick: skill.pick ?? [],
-				omit: skill.omit ?? [],
-				command: skill.command,
-				packageName: skill.packageName,
-				requiredEnv: skill.requiredEnv ?? []
-			}];
-			case "mcpSseSkill": return [name, {
-				type: skill.type,
-				name,
-				description: skill.description,
-				rule: skill.rule,
-				pick: skill.pick ?? [],
-				omit: skill.omit ?? [],
-				endpoint: skill.endpoint
-			}];
-			case "interactiveSkill": return [name, {
-				type: skill.type,
-				name,
-				description: skill.description,
-				rule: skill.rule,
-				tools: Object.fromEntries(Object.entries(skill.tools).map(([toolName, tool]) => [toolName, {
-					name: toolName,
-					description: tool.description,
-					inputSchema: JSON.parse(tool.inputJsonSchema)
-				}]))
-			}];
-			default: throw new PerstackError(`Unknown skill type: ${skill.type}`);
-		}
-	}));
-	return {
-		key,
-		name: expert.name,
-		version: expert.version,
-		minRuntimeVersion: expert.minRuntimeVersion ?? "v1.0",
-		description: expert.description ?? "",
-		instruction: expert.instruction,
-		skills,
-		delegates: expert.delegates ?? [],
-		tags: expert.tags ?? []
-	};
-}
-
-//#endregion
-export { resolveExpertToRun };
-//# sourceMappingURL=resolve-expert-CTnETi9d.js.map