@keystrokehq/cli 0.0.137 → 0.0.138

package/dist/dist-CqVk9JsS.mjs

@@ -0,0 +1,1569 @@
+#!/usr/bin/env node
+import { S as _coercedNumber, _ as string, a as ZodNumber, b as url, d as custom, f as discriminatedUnion, g as record, h as object, l as array, m as number$1, o as ZodType, p as literal, s as _enum, u as boolean, v as union, y as unknown } from "./discovery-DV7FkTRA-BFmtZG9u.mjs";
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
+function number(params) {
+	return _coercedNumber(ZodNumber, params);
+}
+//#endregion
+//#region ../../packages/shared/dist/index.mjs
+const ACTIVE_ORG_HEADER = "x-keystroke-org-id";
+/** Auth, session, and account-entry URL segments. */
+const AUTH_ACCOUNT_SLUGS = [
+	"2fa",
+	"accept-invite",
+	"auth",
+	"authorize",
+	"callback",
+	"callbacks",
+	"confirm-email",
+	"confirmation",
+	"connect",
+	"device",
+	"email-verification",
+	"forgot-password",
+	"invite",
+	"invites",
+	"login",
+	"logout",
+	"magic-link",
+	"mfa",
+	"oauth",
+	"onboarding",
+	"password",
+	"recovery",
+	"register",
+	"reset-password",
+	"saml",
+	"session",
+	"sessions",
+	"sign-in",
+	"sign-up",
+	"signin",
+	"signout",
+	"signup",
+	"sso",
+	"token",
+	"tokens",
+	"unlink",
+	"verify",
+	"verify-email"
+];
+/** Org, workspace, billing, and account-management URL segments. */
+const ORG_ACCOUNT_SLUGS = [
+	"account",
+	"accounts",
+	"billing",
+	"console",
+	"invoice",
+	"invoices",
+	"member",
+	"members",
+	"me",
+	"org",
+	"organization",
+	"organizations",
+	"orgs",
+	"payment",
+	"payments",
+	"plan",
+	"plans",
+	"portal",
+	"preferences",
+	"profile",
+	"settings",
+	"subscription",
+	"subscriptions",
+	"team",
+	"teams",
+	"upgrade",
+	"usage",
+	"user",
+	"users",
+	"workspace",
+	"workspaces"
+];
+/** Product surfaces, resource types, and in-app navigation segments. */
+const PRODUCT_SLUGS = [
+	"action",
+	"actions",
+	"activity",
+	"agent",
+	"agents",
+	"analytics",
+	"app",
+	"apps",
+	"artifact",
+	"artifacts",
+	"assistant",
+	"assistants",
+	"audit",
+	"audit-log",
+	"automation",
+	"automations",
+	"branch",
+	"branches",
+	"canvas",
+	"chat",
+	"chats",
+	"connection",
+	"connections",
+	"create",
+	"credential",
+	"credentials",
+	"dashboard",
+	"deployment",
+	"deployments",
+	"examples",
+	"execute",
+	"execution",
+	"executions",
+	"explore",
+	"get-started",
+	"history",
+	"inbox",
+	"inspector",
+	"integration",
+	"integrations",
+	"library",
+	"logs",
+	"marketplace",
+	"mcp",
+	"mcps",
+	"new",
+	"notifications",
+	"observe",
+	"plugin",
+	"plugins",
+	"primitive",
+	"primitives",
+	"project",
+	"projects",
+	"recents",
+	"registry",
+	"reports",
+	"run",
+	"runs",
+	"runtime",
+	"runtimes",
+	"sandbox",
+	"sandboxes",
+	"search",
+	"skill",
+	"skills",
+	"templates",
+	"thread",
+	"threads",
+	"trigger",
+	"triggers",
+	"version",
+	"versions",
+	"workflow",
+	"workflows"
+];
+/** Marketing, docs, company, and go-to-market URL segments. */
+const MARKETING_SITE_SLUGS = [
+	"about",
+	"affiliates",
+	"ai",
+	"announcements",
+	"anthropic",
+	"blog",
+	"book-demo",
+	"brand",
+	"campaigns",
+	"career",
+	"careers",
+	"case-studies",
+	"casestudies",
+	"changelog",
+	"chatgpt",
+	"chrome-extension",
+	"claude",
+	"codex",
+	"community",
+	"company",
+	"compare",
+	"contact",
+	"contribute",
+	"creators",
+	"customers",
+	"demo",
+	"demos",
+	"discord",
+	"docs",
+	"documentation",
+	"download",
+	"downloads",
+	"dust",
+	"emerging-talent",
+	"engineering-blog",
+	"enterprise",
+	"events",
+	"experts",
+	"extension",
+	"faq",
+	"faqs",
+	"features",
+	"forum",
+	"glean",
+	"grok",
+	"guide",
+	"guides",
+	"gumloop",
+	"handbook",
+	"help",
+	"help-center",
+	"home",
+	"how-it-works",
+	"howitworks",
+	"inspo",
+	"intern",
+	"investors",
+	"jobs",
+	"legal",
+	"lindy",
+	"llm",
+	"llms",
+	"love",
+	"make",
+	"manifesto",
+	"media",
+	"merch",
+	"mission",
+	"mobile",
+	"models",
+	"n8n",
+	"news",
+	"newsroom",
+	"open",
+	"open-claw",
+	"open-source",
+	"openai",
+	"our-story",
+	"overview",
+	"partners",
+	"pi",
+	"pipedream",
+	"platform",
+	"press",
+	"press-kit",
+	"pricing",
+	"privacy",
+	"product",
+	"products",
+	"provider",
+	"providers",
+	"quick-start",
+	"quickstart",
+	"refer",
+	"relay",
+	"relay-app",
+	"reporting",
+	"request-demo",
+	"resources",
+	"roadmap",
+	"schedule-demo",
+	"security",
+	"solutions",
+	"stack-ai",
+	"stackai",
+	"startup",
+	"startups",
+	"status",
+	"stories",
+	"story",
+	"students",
+	"support",
+	"swag",
+	"switch",
+	"talent",
+	"terms",
+	"testimonials",
+	"thesis",
+	"tines",
+	"trust",
+	"tutorials",
+	"university",
+	"use-case",
+	"use-cases",
+	"usecases",
+	"versus",
+	"vellum",
+	"vs",
+	"webinars",
+	"workato",
+	"xai",
+	"yc",
+	"zapier"
+];
+/** Integrations, competitors, and partner brand slugs (marketing / integration pages). */
+const INTEGRATION_BRAND_SLUGS = [
+	"airtable",
+	"asana",
+	"aws",
+	"azure",
+	"bun",
+	"confluence",
+	"copilot",
+	"cursor",
+	"databricks",
+	"figma",
+	"firebase",
+	"fly",
+	"gcp",
+	"gemini",
+	"github",
+	"gitlab",
+	"gmail",
+	"heroku",
+	"hubspot",
+	"huggingface",
+	"jira",
+	"linear",
+	"mailchimp",
+	"meta",
+	"mistral",
+	"mixmax",
+	"monday",
+	"netlify",
+	"neon",
+	"notion",
+	"npm",
+	"outlook",
+	"outreach",
+	"perplexity",
+	"planetscale",
+	"pnpm",
+	"postmark",
+	"ramp",
+	"railway",
+	"render",
+	"resend",
+	"salesforce",
+	"segment",
+	"sendgrid",
+	"shopify",
+	"slack",
+	"snowflake",
+	"stripe",
+	"supabase",
+	"terraform",
+	"trello",
+	"turso",
+	"twilio",
+	"typeform",
+	"vercel",
+	"vscode",
+	"windsurf",
+	"yarn"
+];
+/** Company, team, and department landing-page segments. */
+const COMPANY_TEAM_SLUGS = [
+	"engineers",
+	"engineering",
+	"executives",
+	"hc",
+	"intern",
+	"it",
+	"leadership",
+	"marketing",
+	"ops",
+	"revops",
+	"sales",
+	"services",
+	"tech"
+];
+/** Legal, trust, compliance, and policy URL segments. */
+const LEGAL_TRUST_SLUGS = [
+	"accessibility",
+	"agreement",
+	"a11y",
+	"bug-bounty",
+	"compliance",
+	"cookie-policy",
+	"cookies",
+	"disclose",
+	"dpa",
+	"eula",
+	"gdpr",
+	"hipaa",
+	"iso",
+	"msa",
+	"pci",
+	"responsible-disclosure",
+	"sla",
+	"soc2",
+	"tos",
+	"trust-center",
+	"trustcenter",
+	"vulnerability"
+];
+/** Developer, API, CLI, and technical URL segments. */
+const DEVELOPER_TECH_SLUGS = [
+	"api",
+	"api-docs",
+	"cli",
+	"code",
+	"config",
+	"developer",
+	"developer-tools",
+	"developers",
+	"dev-tools",
+	"devtools",
+	"dev",
+	"dev-states",
+	"graphql",
+	"graphql-playground",
+	"mcp-server",
+	"mcp-servers",
+	"openapi",
+	"sdk",
+	"swagger"
+];
+/** Infra, ops, static assets, and system URL segments. */
+const INFRA_SYSTEM_SLUGS = [
+	"acme-challenge",
+	"admin",
+	"apple-app-site-association",
+	"assets",
+	"batch",
+	"cache",
+	"cdn",
+	"cron",
+	"debug",
+	"error",
+	"errors",
+	"favicon",
+	"feed",
+	"files",
+	"health",
+	"healthcheck",
+	"healthz",
+	"hooks",
+	"internal",
+	"item",
+	"manifest",
+	"metrics",
+	"null",
+	"ping",
+	"prod",
+	"public",
+	"redirect",
+	"robots",
+	"rpc",
+	"rss",
+	"sharer",
+	"sitemap",
+	"staging",
+	"static",
+	"storage",
+	"test",
+	"undefined",
+	"universal",
+	"webhooks",
+	"well-known",
+	"www"
+];
+/** Reserved slugs that are valid org names in theory but blocked for routing safety. */
+const ROUTING_SAFETY_SLUGS = [
+	"alpha",
+	"anonymous",
+	"archive",
+	"archived",
+	"beta",
+	"clone",
+	"copy",
+	"default",
+	"deleted",
+	"demo-org",
+	"draft",
+	"drafts",
+	"duplicate",
+	"early-access",
+	"embed",
+	"embedded",
+	"export",
+	"fork",
+	"free",
+	"guest",
+	"import",
+	"index",
+	"list",
+	"manage",
+	"moderator",
+	"newsletter",
+	"owner",
+	"preview",
+	"previews",
+	"private",
+	"pro",
+	"public-api",
+	"publish",
+	"published",
+	"queue",
+	"remove",
+	"root",
+	"sample",
+	"samples",
+	"selection",
+	"share",
+	"shared",
+	"sponsor",
+	"sponsors",
+	"sponsorship",
+	"subscribe",
+	"super",
+	"superuser",
+	"system",
+	"sys",
+	"test-org",
+	"trash",
+	"unpublish",
+	"unsubscribe",
+	"upload",
+	"uploads",
+	"waitlist",
+	"widget",
+	"widgets",
+	"worker",
+	"workers"
+];
+/**
+* URL segments reserved for global (non-org) routes — cannot be used as an org slug.
+* Prefer adding new entries to the category arrays above; the Set is the enforcement surface.
+*/
+const RESERVED_ORGANIZATION_SLUGS = new Set([
+	...AUTH_ACCOUNT_SLUGS,
+	...ORG_ACCOUNT_SLUGS,
+	...PRODUCT_SLUGS,
+	...MARKETING_SITE_SLUGS,
+	...INTEGRATION_BRAND_SLUGS,
+	...COMPANY_TEAM_SLUGS,
+	...LEGAL_TRUST_SLUGS,
+	...DEVELOPER_TECH_SLUGS,
+	...INFRA_SYSTEM_SLUGS,
+	...ROUTING_SAFETY_SLUGS
+]);
+/**
+* Base slug format: lowercase, 2-64 chars, alphanumeric + dashes.
+*
+* IMPORTANT: this is the schema for *reading* slugs (persisted rows, API
+* responses). It intentionally does NOT enforce the reserved-name list — an org
+* created before a name became reserved must still parse on read. Use
+* `ClaimableOrganizationSlugSchema` to validate slugs a user is trying to claim.
+*/
+const OrganizationSlugSchema = string().trim().toLowerCase().min(2, "Slug must be at least 2 characters").max(64, "Slug must be at most 64 characters").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers, and dashes only");
+/**
+* Slug validation for *claiming* a slug (organization create/rename). Adds the
+* reserved-name check on top of the base format. Never use this to parse
+* existing org data, or pre-existing orgs whose slug later became reserved would
+* fail to load.
+*/
+const ClaimableOrganizationSlugSchema = OrganizationSlugSchema.refine((slug) => !RESERVED_ORGANIZATION_SLUGS.has(slug), "This slug is reserved");
+/** Same format as organization slugs — org-scoped, no global reserved list. */
+const ProjectSlugSchema = OrganizationSlugSchema;
+/** Browser→platform request budget (ping + small platform overhead). */
+const PROJECT_REACHABILITY_REQUEST_TIMEOUT_MS = 17e3;
+/** Normalize a public origin URL (no trailing slash). */
+function originFromPublicUrl(value, fallback) {
+	const trimmed = value?.trim();
+	if (!trimmed) return fallback.replace(/\/+$/, "");
+	return trimmed.replace(/\/+$/, "");
+}
+/** TCP port to bind for a local server, derived from a public URL. */
+function listenPortFromUrl(url, fallback) {
+	const parsed = new URL(url);
+	if (parsed.port) {
+		const port = Number(parsed.port);
+		if (Number.isFinite(port) && port > 0) return port;
+	}
+	if (parsed.protocol === "https:") return 443;
+	if (parsed.protocol === "http:") return 80;
+	return fallback;
+}
+/** Shorthand: listen port from `PUBLIC_*_URL` or fallback. */
+function listenPortFromPublicUrl(value, fallback) {
+	const trimmed = value?.trim();
+	if (!trimmed) return fallback;
+	try {
+		return listenPortFromUrl(trimmed, fallback);
+	} catch {
+		return fallback;
+	}
+}
+/** On-disk path under the project root (packed in deploy artifacts when present). */
+const ROUTE_MANIFEST_REL_PATH = "dist/.keystroke/route-manifest.json";
+const StoredRouteManifestSkillSchema = object({
+	slug: string(),
+	name: string().optional(),
+	description: string().optional(),
+	moduleFile: string()
+});
+const serializedRouteManifestEntrySchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("health"),
+		method: literal("GET"),
+		path: literal("/health")
+	}),
+	object({
+		kind: literal("agent"),
+		method: literal("POST"),
+		path: string(),
+		agentSlug: string(),
+		moduleFile: string(),
+		name: string().optional(),
+		description: string().optional(),
+		model: string(),
+		systemPrompt: string(),
+		toolCount: number$1().int().nonnegative(),
+		credentialCount: number$1().int().nonnegative(),
+		requestSchema: record(string(), unknown()),
+		responseSchema: record(string(), unknown())
+	}),
+	object({
+		kind: literal("agent-sessions-list"),
+		method: literal("GET"),
+		path: string(),
+		agentSlug: string(),
+		moduleFile: string()
+	}),
+	object({
+		kind: literal("agent-session-detail"),
+		method: literal("GET"),
+		path: string(),
+		agentSlug: string(),
+		moduleFile: string()
+	}),
+	object({
+		kind: literal("workflow"),
+		method: literal("POST"),
+		path: string(),
+		workflowSlug: string(),
+		workflowName: string().optional(),
+		description: string().optional(),
+		subscribable: boolean(),
+		moduleFile: string(),
+		requestSchema: record(string(), unknown()),
+		responseSchema: record(string(), unknown())
+	}),
+	object({
+		kind: literal("workflow-runs-list"),
+		method: literal("GET"),
+		path: string(),
+		workflowSlug: string(),
+		workflowName: string().optional(),
+		moduleFile: string()
+	}),
+	object({
+		kind: literal("workflow-run-detail"),
+		method: literal("GET"),
+		path: string(),
+		workflowSlug: string(),
+		workflowName: string().optional(),
+		moduleFile: string()
+	}),
+	object({
+		kind: literal("trigger-webhook"),
+		method: literal("POST"),
+		path: string(),
+		attachmentIds: array(string()),
+		moduleFile: string(),
+		requestSchema: record(string(), unknown()),
+		attachmentSchemas: record(string(), object({
+			requestSchema: record(string(), unknown()),
+			filterSchema: record(string(), unknown()).optional()
+		})),
+		responseSchema: record(string(), unknown())
+	}),
+	object({
+		kind: literal("trigger-poll"),
+		method: literal("POST"),
+		path: string(),
+		attachmentId: string(),
+		moduleFile: string(),
+		schedule: string(),
+		responseSchema: record(string(), unknown())
+	}),
+	object({
+		kind: literal("trigger-poll-group"),
+		method: literal("POST"),
+		path: string(),
+		pollId: string(),
+		attachmentIds: array(string()),
+		moduleFile: string(),
+		schedule: string(),
+		responseSchema: record(string(), unknown())
+	}),
+	object({
+		kind: literal("trigger-runs-list"),
+		method: literal("GET"),
+		path: string(),
+		attachmentId: string(),
+		moduleFile: string()
+	}),
+	object({
+		kind: literal("trigger-run-detail"),
+		method: literal("GET"),
+		path: string(),
+		attachmentId: string(),
+		moduleFile: string()
+	}),
+	object({
+		kind: literal("cron-schedule"),
+		attachmentId: string(),
+		moduleFile: string(),
+		schedule: string()
+	}),
+	object({
+		kind: literal("plugin"),
+		method: _enum([
+			"GET",
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE"
+		]),
+		path: string(),
+		plugin: string()
+	})
+]);
+object({
+	version: literal(1),
+	entries: array(serializedRouteManifestEntrySchema),
+	skills: array(StoredRouteManifestSkillSchema).default([]),
+	integrations: array(string()).optional()
+});
+/** How a credential instance is stored (`credential_instances.auth_kind`). */
+const CredentialAuthKindSchema = _enum(["api_key", "oauth_managed"]);
+/** Where a credential instance is stored (`credential_instances.scope_type`). */
+const CredentialScopeTypeSchema = _enum([
+	"global",
+	"organization",
+	"project",
+	"user"
+]);
+/**
+* Resolution chain step when an action/tool looks up credentials.
+* `selection` uses explicit instance ids; other levels map to {@link CredentialScopeType}.
+*/
+const CredentialScopeLevelSchema = _enum([
+	"selection",
+	"organization",
+	"project",
+	"user"
+]);
+CredentialAuthKindSchema.options;
+CredentialScopeTypeSchema.options;
+CredentialScopeLevelSchema.options;
+/** Default chain when `credential.static(...).scope()` is called with no args. */
+const DEFAULT_CREDENTIAL_RESOLUTION_CHAIN = ["organization", "project"];
+function isCredentialInput(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.key === "string" && CredentialAuthKindSchema.safeParse(candidate.kind).success && candidate.schema instanceof ZodType;
+}
+custom((value) => isCredentialInput(value), "must be a credential requirement");
+function normalizeCredentialList(list) {
+	return list.map((item) => toCredentialRequirement(item));
+}
+function isCredentialRequirement(item) {
+	return "chain" in item;
+}
+function toCredentialRequirement(item) {
+	if (isCredentialRequirement(item)) return item;
+	return {
+		key: item.key,
+		kind: item.kind,
+		schema: item.schema,
+		chain: DEFAULT_CREDENTIAL_RESOLUTION_CHAIN,
+		...item.tokenField !== void 0 ? { tokenField: item.tokenField } : {}
+	};
+}
+const OrganizationSlugErrorCodeSchema = _enum([
+	"slug_taken",
+	"slug_reserved",
+	"slug_invalid"
+]);
+const SlugAvailabilityReasonSchema = _enum([
+	"taken",
+	"reserved",
+	"invalid"
+]);
+const SlugAvailabilityResponseSchema = object({
+	slug: string(),
+	available: boolean(),
+	reason: SlugAvailabilityReasonSchema.optional(),
+	suggestion: OrganizationSlugSchema.optional()
+});
+object({
+	slug: string().trim().min(1),
+	excludeOrganizationId: string().min(1).optional()
+});
+const ProjectSlugAvailabilityReasonSchema = _enum(["taken", "invalid"]);
+const ProjectSlugAvailabilityResponseSchema = object({
+	slug: string(),
+	available: boolean(),
+	reason: ProjectSlugAvailabilityReasonSchema.optional(),
+	suggestion: ProjectSlugSchema.optional()
+});
+object({
+	slug: string().trim().min(1),
+	excludeProjectId: string().min(1).optional()
+});
+const ProjectStatusSchema = _enum([
+	"inactive",
+	"starting",
+	"active",
+	"failed"
+]);
+const OrganizationUserRoleSchema = _enum([
+	"owner",
+	"admin",
+	"builder"
+]);
+const isoDateTime$3 = string().datetime();
+const OrganizationSchema = object({
+	id: string(),
+	name: string(),
+	slug: OrganizationSlugSchema,
+	createdAt: isoDateTime$3,
+	updatedAt: isoDateTime$3
+});
+const ProjectSchema = object({
+	id: string(),
+	organizationId: string(),
+	name: string(),
+	slug: ProjectSlugSchema,
+	description: string().nullable(),
+	status: ProjectStatusSchema,
+	baseUrl: string().nullable(),
+	runtimeId: string().nullable(),
+	lastError: string().nullable(),
+	createdAt: isoDateTime$3,
+	updatedAt: isoDateTime$3
+});
+const UserOrganizationSchema = object({
+	organization: OrganizationSchema,
+	role: OrganizationUserRoleSchema
+});
+const ActiveOrganizationResponseSchema = object({ organization: UserOrganizationSchema.nullable() });
+const ListOrganizationsResponseSchema = object({ organizations: array(UserOrganizationSchema) });
+const CreateOrganizationRequestSchema = object({
+	name: string().trim().min(1),
+	/** Format-only at the wire boundary; reserved-name checks run in platform-database. */
+	slug: OrganizationSlugSchema.optional()
+});
+const UpdateOrganizationRequestSchema = object({
+	name: string().trim().min(1).optional(),
+	slug: ClaimableOrganizationSlugSchema.optional()
+}).refine((data) => data.name !== void 0 || data.slug !== void 0, { message: "At least one field is required" });
+const CreateOrganizationResponseSchema = object({ organization: UserOrganizationSchema });
+const ListProjectsResponseSchema = object({ projects: array(ProjectSchema) });
+const ProjectListMetricsSchema = object({
+	agentCount: number$1(),
+	workflowCount: number$1(),
+	skillCount: number$1(),
+	credentialCount: number$1(),
+	lastDeploymentAt: isoDateTime$3.nullable()
+});
+const ListProjectMetricsResponseSchema = object({ metrics: record(string(), ProjectListMetricsSchema) });
+const CreateProjectRequestSchema = object({
+	name: string().trim().min(1),
+	description: string().trim().min(1).optional()
+});
+const UpdateProjectRequestSchema = object({
+	name: string().trim().min(1).optional(),
+	description: string().trim().optional(),
+	slug: ProjectSlugSchema.optional()
+}).refine((data) => data.name !== void 0 || data.description !== void 0 || data.slug !== void 0, { message: "At least one field is required" });
+const CreateProjectResponseSchema = object({ project: ProjectSchema });
+const ProjectResponseSchema = object({ project: ProjectSchema });
+const ProjectReachabilityResponseSchema = object({ reachable: boolean() });
+const ValidationErrorDetailSchema = object({
+	path: string(),
+	message: string()
+});
+/** Machine-readable codes returned in standard API error bodies. */
+const ErrorResponseCodeSchema = OrganizationSlugErrorCodeSchema.or(_enum(["needs_org_selection"]));
+/** Standard JSON error body returned by the HTTP API. */
+const ErrorResponseSchema = object({
+	error: string(),
+	code: ErrorResponseCodeSchema.optional(),
+	message: string().optional(),
+	details: array(ValidationErrorDetailSchema).optional()
+});
+const MessageOnlyErrorBodySchema = object({ message: string() });
+/** Parse a JSON error body from the API. */
+function parseErrorResponse(body) {
+	const parsed = ErrorResponseSchema.safeParse(body);
+	if (parsed.success) return parsed.data;
+	const messageOnly = MessageOnlyErrorBodySchema.safeParse(body);
+	if (messageOnly.success) return {
+		error: messageOnly.data.message,
+		message: messageOnly.data.message
+	};
+}
+const CredentialRunContextSchema = object({
+	orgId: string().min(1).optional(),
+	projectId: string().min(1).optional(),
+	userId: string().min(1).optional(),
+	userIds: record(string(), string()).optional(),
+	selection: record(string(), string()).optional()
+});
+const ThinkingLevelSchema = _enum([
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+const PromptInputSchema = object({
+	message: string().min(1),
+	sessionId: string().min(1).optional(),
+	subscriptionId: string().min(1).optional(),
+	context: CredentialRunContextSchema.optional(),
+	thinkingLevel: ThinkingLevelSchema.optional()
+});
+const PromptResponseSchema = object({
+	sessionId: string(),
+	messages: array(record(string(), unknown())),
+	error: string().nullable()
+});
+const SkipResponseSchema = object({
+	ok: literal(true),
+	skipped: literal(true)
+});
+const HealthResponseSchema = object({ ok: literal(true) });
+object({ service: string() });
+const ConnectProvidersResponseSchema = object({ providers: array(object({
+	key: string(),
+	mode: _enum(["authorize-url", "browser-redirect"]),
+	path: string(),
+	requiresAuth: boolean()
+})) });
+const ConnectAuthorizeUrlResponseSchema = object({ url: string() });
+const QueuedRunResponseSchema = object({ runId: string() });
+const QueuedAgentPromptResponseSchema = object({ sessionId: string() });
+object({
+	workflows: array(string().min(1)).optional(),
+	attachments: array(string().min(1)).optional()
+});
+const PollRunMultiResponseSchema = object({ results: array(object({
+	attachmentKey: string(),
+	workflowKey: string(),
+	runId: string().optional(),
+	body: unknown().optional(),
+	queued: boolean(),
+	skipped: boolean().optional()
+})) });
+const PollRunResponseSchema = union([
+	record(string(), unknown()),
+	PollRunMultiResponseSchema,
+	SkipResponseSchema,
+	object({ runId: string() })
+]);
+const RunSourceKindSchema = _enum([
+	"api",
+	"trigger",
+	"gateway",
+	"workflow",
+	"agent"
+]);
+object({
+	kind: RunSourceKindSchema,
+	id: string().nullable()
+});
+const WorkflowRunStatusSchema = _enum([
+	"pending",
+	"running",
+	"completed",
+	"failed"
+]);
+const WorkflowRunTriggerSchema = _enum([
+	"api",
+	"cron",
+	"webhook",
+	"poll",
+	"retry"
+]);
+_enum([
+	"run_started",
+	"step_completed",
+	"step_failed",
+	"step_retrying",
+	"sleep_scheduled",
+	"sleep_completed",
+	"hook_created",
+	"hook_resumed",
+	"run_completed",
+	"run_failed"
+]);
+const WorkflowRunSummarySchema = object({
+	id: string(),
+	status: WorkflowRunStatusSchema,
+	trigger: WorkflowRunTriggerSchema,
+	triggeredAt: string(),
+	startedAt: string().nullable(),
+	finishedAt: string().nullable(),
+	sourceKind: RunSourceKindSchema,
+	sourceId: string().nullable(),
+	triggerRunId: string().nullable(),
+	attachmentId: string().nullable()
+});
+const WorkflowRunRecordSchema = object({
+	id: string(),
+	workflowSlug: string(),
+	status: WorkflowRunStatusSchema,
+	trigger: WorkflowRunTriggerSchema,
+	triggeredAt: string(),
+	startedAt: string().nullable(),
+	finishedAt: string().nullable(),
+	sourceKind: RunSourceKindSchema,
+	sourceId: string().nullable(),
+	triggerRunId: string().nullable(),
+	attachmentId: string().nullable(),
+	parentWorkflowRunId: string().nullable(),
+	parentSpanId: string().nullable(),
+	input: unknown().nullable(),
+	output: unknown().nullable(),
+	error: unknown().nullable()
+});
+object({
+	limit: number().int().min(1).max(100).optional().default(20),
+	cursor: string().min(1).optional(),
+	status: WorkflowRunStatusSchema.optional(),
+	trigger: WorkflowRunTriggerSchema.optional()
+});
+const WorkflowRunListResponseSchema = object({
+	items: array(WorkflowRunSummarySchema),
+	nextCursor: string().nullable()
+});
+_enum([
+	"trigger",
+	"steps",
+	"trace"
+]);
+object({ include: string().optional() });
+const TriggerRunDetailSchema = object({
+	id: string(),
+	attachmentId: string(),
+	attachmentSlug: string().nullable(),
+	triggerType: _enum([
+		"cron",
+		"webhook",
+		"poll"
+	]),
+	sourcePath: string().nullable(),
+	payload: unknown().nullable(),
+	triggeredAt: string()
+});
+const WorkflowStepRunSchema = object({
+	id: string(),
+	actionKey: string(),
+	output: unknown(),
+	completedAt: string()
+});
+const TraceTriggerSummarySchema = object({
+	triggerType: string(),
+	triggerRunId: string(),
+	workflowSlug: string().optional(),
+	agentSlug: string().optional(),
+	attachmentId: string().nullable().optional(),
+	attachmentSlug: string().nullable().optional(),
+	route: string().optional(),
+	sourcePath: string().nullable().optional()
+}).nullable();
+const TraceGatewaySummarySchema = object({
+	gatewayAttachmentId: string(),
+	gatewayAttachmentKey: string(),
+	threadId: string().optional(),
+	channelId: string().optional(),
+	mode: string().optional()
+}).nullable();
+const TraceSpanSchema = object({
+	id: string(),
+	traceId: string(),
+	parentSpanId: string().nullable(),
+	kind: string(),
+	refId: string(),
+	name: string(),
+	status: string(),
+	startedAt: string(),
+	finishedAt: string().nullable(),
+	metadata: unknown().nullable(),
+	error: unknown().nullable()
+});
+const TraceLogSchema = object({
+	id: string(),
+	traceId: string(),
+	spanId: string(),
+	seq: number$1(),
+	level: string(),
+	message: string(),
+	data: unknown().nullable(),
+	source: string(),
+	createdAt: string()
+});
+const TraceResponseSchema = object({
+	traceId: string(),
+	trigger: TraceTriggerSummarySchema,
+	gateway: TraceGatewaySummarySchema,
+	spans: array(TraceSpanSchema),
+	logs: array(TraceLogSchema)
+});
+const WorkflowRunDetailResponseSchema = object({
+	run: WorkflowRunRecordSchema,
+	trigger: TriggerRunDetailSchema.nullable(),
+	steps: array(WorkflowStepRunSchema),
+	trace: TraceResponseSchema.nullable()
+});
+const AgentSessionStatusSchema = _enum([
+	"running",
+	"completed",
+	"failed"
+]);
+const AgentSessionSummarySchema = object({
+	id: string(),
+	status: AgentSessionStatusSchema,
+	source: RunSourceKindSchema,
+	sourceId: string().nullable(),
+	createdAt: string(),
+	updatedAt: string(),
+	messageCount: number$1()
+});
+const AgentSessionRecordSchema = object({
+	id: string(),
+	agentSlug: string(),
+	status: AgentSessionStatusSchema,
+	source: RunSourceKindSchema,
+	sourceId: string().nullable(),
+	createdAt: string(),
+	updatedAt: string(),
+	parentSpanId: string().nullable(),
+	messageCount: number$1(),
+	error: unknown().nullable()
+});
+object({
+	limit: number().int().min(1).max(100).optional().default(20),
+	cursor: string().min(1).optional(),
+	status: AgentSessionStatusSchema.optional(),
+	source: RunSourceKindSchema.optional()
+});
+const AgentSessionListResponseSchema = object({
+	items: array(AgentSessionSummarySchema),
+	nextCursor: string().nullable()
+});
+_enum([
+	"gateway",
+	"messages",
+	"events",
+	"trace"
+]);
+object({ include: string().optional() });
+const GatewaySessionDetailSchema = object({
+	threadId: string(),
+	attachmentId: string(),
+	attachmentSlug: string().nullable()
+});
+const AgentEventSchema = object({
+	id: string(),
+	sessionId: string(),
+	seq: number$1(),
+	eventType: string(),
+	payload: unknown(),
+	createdAt: string()
+});
+const AgentSessionDetailResponseSchema = object({
+	session: AgentSessionRecordSchema,
+	gateway: GatewaySessionDetailSchema.nullable(),
+	messages: array(record(string(), unknown())),
+	events: array(AgentEventSchema),
+	trace: TraceResponseSchema.nullable()
+});
+const SlackGatewayModeSchema = _enum([
+	"mention",
+	"channel",
+	"dm"
+]);
+const GatewayAttachmentSourceSchema = object({
+	kind: literal("slack"),
+	mode: SlackGatewayModeSchema,
+	credentialKey: string(),
+	channelIds: array(string()).optional(),
+	subscribeOnMention: boolean()
+});
+const GatewayAttachmentRecordSchema = object({
+	id: string(),
+	key: string(),
+	agentKey: string(),
+	channelId: string(),
+	teamId: string().nullable().optional(),
+	platform: string(),
+	source: GatewayAttachmentSourceSchema,
+	registeredAt: string(),
+	updatedAt: string()
+});
+object({ attachments: array(GatewayAttachmentRecordSchema) });
+const UpsertGatewayAttachmentBodySchema = object({
+	agentKey: string().min(1),
+	teamId: string().min(1).optional(),
+	mode: SlackGatewayModeSchema.optional(),
+	subscribeOnMention: boolean().optional()
+});
+const AgentListResponseSchema = object({ agents: array(object({
+	key: string(),
+	name: string().optional(),
+	route: string()
+})) });
+object({ subscriptions: array(object({
+	id: string(),
+	workflowKey: string(),
+	userId: string(),
+	enabled: boolean(),
+	createdAt: string(),
+	updatedAt: string()
+})) });
+object({
+	userId: string().min(1).optional(),
+	enabled: boolean().optional()
+});
+const CredentialInstanceRecordSchema = object({
+	id: string(),
+	key: string(),
+	scopeType: CredentialScopeTypeSchema,
+	scopeId: string().nullable(),
+	label: string().nullable(),
+	isDefault: boolean(),
+	authKind: CredentialAuthKindSchema
+});
+const CredentialInstanceListResponseSchema = object({ instances: array(CredentialInstanceRecordSchema) });
+const CreateCredentialInstanceBodySchema = object({
+	key: string().min(1),
+	scopeType: CredentialScopeTypeSchema,
+	scopeId: string().nullable().optional(),
+	label: string().nullable().optional(),
+	isDefault: boolean().optional(),
+	value: record(string(), unknown()).refine((value) => Object.keys(value).length > 0, { message: "value must be a non-empty object" })
+});
+const UpdateCredentialInstanceBodySchema = object({
+	label: string().nullable().optional(),
+	isDefault: boolean().optional(),
+	value: record(string(), unknown()).refine((value) => Object.keys(value).length > 0, { message: "value must be a non-empty object" }).optional()
+});
+const TriggerRunTypeSchema = _enum([
+	"cron",
+	"webhook",
+	"poll"
+]);
+const TriggerRunWorkflowSummarySchema = object({
+	id: string(),
+	status: WorkflowRunStatusSchema,
+	workflowSlug: string()
+});
+const TriggerRunAgentSessionSummarySchema = object({
+	id: string(),
+	agentSlug: string()
+});
+const TriggerRunSummarySchema = object({
+	id: string(),
+	triggerType: TriggerRunTypeSchema,
+	triggeredAt: string(),
+	sourcePath: string().nullable(),
+	workflowRun: TriggerRunWorkflowSummarySchema.nullable(),
+	agentSession: TriggerRunAgentSessionSummarySchema.nullable()
+});
+const TriggerRunRecordSchema = object({
+	id: string(),
+	attachmentId: string(),
+	attachmentSlug: string(),
+	triggerType: TriggerRunTypeSchema,
+	sourcePath: string().nullable(),
+	payload: unknown().nullable(),
+	triggeredAt: string()
+});
+object({
+	limit: number().int().min(1).max(100).optional().default(20),
+	cursor: string().min(1).optional(),
+	triggerType: TriggerRunTypeSchema.optional()
+});
+const TriggerRunListResponseSchema = object({
+	items: array(TriggerRunSummarySchema),
+	nextCursor: string().nullable()
+});
+_enum([
+	"workflows",
+	"agents",
+	"trace"
+]);
+object({ include: string().optional() });
+const TriggerRunAgentSessionDetailSchema = object({
+	id: string(),
+	agentSlug: string()
+});
+const TriggerRunDetailResponseSchema = object({
+	run: TriggerRunRecordSchema,
+	workflowRuns: array(WorkflowRunSummarySchema),
+	agentSessions: array(TriggerRunAgentSessionDetailSchema),
+	trace: TraceResponseSchema.nullable()
+});
+const TriggerTypeSchema = _enum([
+	"webhook",
+	"poll",
+	"cron"
+]);
+const TriggerTargetKindSchema = _enum(["workflow", "agent"]);
+const TriggerListItemSchema = object({
+	key: string(),
+	type: TriggerTypeSchema,
+	route: string().optional(),
+	webhookUrl: string().url().optional(),
+	targetKind: TriggerTargetKindSchema,
+	workflowKey: string().optional(),
+	agentKey: string().optional()
+});
+const TriggerListResponseSchema = object({ triggers: array(TriggerListItemSchema) });
+object({ endpoint: string().min(1).optional() });
+const TriggerDetailResponseSchema = TriggerListItemSchema;
+const OrganizationMemberRoleSchema = _enum([
+	"owner",
+	"admin",
+	"builder"
+]);
+const OrganizationMemberStatusSchema = _enum([
+	"invited",
+	"active",
+	"rejected",
+	"suspended"
+]);
+const InvitableOrganizationMemberRoleSchema = _enum(["admin", "builder"]);
+const isoDateTime$2 = string().datetime();
+const OrganizationMemberSchema = object({
+	id: string(),
+	name: string(),
+	email: string().email(),
+	role: OrganizationMemberRoleSchema,
+	status: OrganizationMemberStatusSchema,
+	avatarUrl: string().optional(),
+	joinedAt: isoDateTime$2.optional(),
+	lastActiveAt: isoDateTime$2.nullable().optional()
+});
+const ListOrganizationMembersResponseSchema = object({ members: array(OrganizationMemberSchema) });
+const InviteOrganizationMembersRequestSchema = object({
+	emails: array(string().trim().email()).min(1),
+	role: InvitableOrganizationMemberRoleSchema
+});
+const InviteOrganizationMemberResultStatusSchema = _enum([
+	"sent",
+	"already_member",
+	"pending",
+	"invalid"
+]);
+const InviteOrganizationMembersResponseSchema = object({ results: array(object({
+	email: string(),
+	status: InviteOrganizationMemberResultStatusSchema,
+	invitationId: string().optional()
+})) });
+const UpdateOrganizationMemberRequestSchema = object({ role: InvitableOrganizationMemberRoleSchema });
+const UpdateOrganizationMemberResponseSchema = object({ member: OrganizationMemberSchema });
+const ListOrganizationInvitationsResponseSchema = object({ invitations: array(object({
+	id: string(),
+	organizationName: string(),
+	organizationSlug: OrganizationSlugSchema,
+	invitedByName: string().optional(),
+	invitedByEmail: string().email().optional(),
+	role: OrganizationMemberRoleSchema
+})) });
+const AcceptOrganizationInvitationResponseSchema = object({ organization: UserOrganizationSchema });
+const DeclineOrganizationInvitationResponseSchema = object({ success: literal(true) });
+/** Custom avatar override; null means fall back to OAuth `users.image`. */
+const UserAvatarSchema = object({ url: url().nullable() });
+const UserAvatarPatchSchema = object({ 
+/** Storage key returned from presign; null removes the custom override. */
+storageKey: string().min(1).nullable() });
+const PresignUserAvatarRequestSchema = object({ contentType: string().trim().min(1) });
+const PresignUserAvatarResponseSchema = object({
+	uploadUrl: url(),
+	storageKey: string().min(1)
+});
+const OrganizationLogoVariantSchema = _enum(["light", "dark"]);
+const OrganizationSidebarBrandingSchema = object({
+	customLogoEnabled: boolean(),
+	customLogoExplicitlyDisabled: boolean(),
+	logoLightUrl: url().nullable(),
+	logoDarkUrl: url().nullable(),
+	logoHeightPx: number$1().int().min(14).max(32)
+});
+const OrganizationSidebarBrandingPatchSchema = object({
+	customLogoEnabled: boolean().optional(),
+	customLogoExplicitlyDisabled: boolean().optional(),
+	logoLightStorageKey: string().min(1).nullable().optional(),
+	logoDarkStorageKey: string().min(1).nullable().optional(),
+	logoHeightPx: number$1().int().min(14).max(32).optional()
+}).refine((value) => value.customLogoEnabled !== void 0 || value.customLogoExplicitlyDisabled !== void 0 || value.logoLightStorageKey !== void 0 || value.logoDarkStorageKey !== void 0 || value.logoHeightPx !== void 0, { message: "At least one branding field is required" });
+const PresignOrgLogoRequestSchema = object({
+	variant: OrganizationLogoVariantSchema,
+	contentType: string().trim().min(1)
+});
+const PresignOrgLogoResponseSchema = object({
+	uploadUrl: url(),
+	storageKey: string().min(1)
+});
+const ProjectArtifactStatusSchema = _enum(["pending", "ready"]);
+const isoDateTime$1 = string().datetime();
+const ProjectArtifactSchema = object({
+	id: string(),
+	projectId: string(),
+	storageKey: string(),
+	status: ProjectArtifactStatusSchema,
+	createdAt: isoDateTime$1,
+	updatedAt: isoDateTime$1
+});
+const CreateProjectArtifactResponseSchema = object({
+	artifact: ProjectArtifactSchema,
+	uploadUrl: string().url(),
+	expiresInSeconds: number$1().int().positive()
+});
+const CompleteProjectArtifactResponseSchema = object({
+	artifact: ProjectArtifactSchema,
+	project: ProjectSchema
+});
+const ListProjectDeploymentsResponseSchema = object({ deployments: array(object({
+	id: string(),
+	projectId: string(),
+	version: number$1().int().positive(),
+	deployedBy: string().nullable(),
+	deployedByEmail: string().optional(),
+	deployedByAvatarUrl: string().optional(),
+	createdAt: isoDateTime$1,
+	active: boolean()
+})) });
+const optionalCount = number$1().int().nonnegative().nullable().optional();
+const optionalTimestamp = string().nullable().optional();
+const AgentSummarySchema = object({
+	id: string().min(1),
+	slug: string().min(1),
+	name: string().min(1),
+	projectId: string().min(1),
+	updatedAt: string().min(1),
+	description: string().optional(),
+	sourcePath: string().min(1).optional(),
+	model: string().optional(),
+	toolCount: optionalCount,
+	credentialCount: optionalCount,
+	lastRunAt: optionalTimestamp
+});
+const WorkflowSummarySchema = object({
+	id: string().min(1),
+	slug: string().min(1),
+	name: string().min(1),
+	projectId: string().min(1),
+	updatedAt: string().min(1),
+	description: string().optional(),
+	sourcePath: string().min(1).optional(),
+	lastRunAt: optionalTimestamp
+});
+const SkillSummarySchema = object({
+	id: string().min(1),
+	slug: string().min(1),
+	name: string().min(1),
+	projectId: string().min(1),
+	updatedAt: string().min(1),
+	description: string().optional(),
+	sourcePath: string().min(1).optional()
+});
+const AgentSummaryListResponseSchema = array(AgentSummarySchema);
+const AgentSummaryDetailResponseSchema = AgentSummarySchema.nullable();
+const WorkflowSummaryListResponseSchema = array(WorkflowSummarySchema);
+const WorkflowSummaryDetailResponseSchema = WorkflowSummarySchema.nullable();
+const SkillSummaryListResponseSchema = array(SkillSummarySchema);
+const SkillSummaryDetailResponseSchema = SkillSummarySchema.nullable();
+const RecentResourceKindSchema = _enum([
+	"agent",
+	"workflow",
+	"skill"
+]);
+const RecentResourceSourceSchema = _enum(["owned", "shared"]);
+const RecentResourceListResponseSchema = array(object({
+	id: string().min(1),
+	resourceKind: RecentResourceKindSchema,
+	resourceId: string().min(1),
+	name: string().min(1),
+	description: string().optional(),
+	projectId: string().min(1),
+	projectName: string().min(1),
+	sourcePath: string().min(1).optional(),
+	source: RecentResourceSourceSchema,
+	lastOpenedAt: string().min(1),
+	lastModifiedAt: string().min(1)
+}));
+const isoDateTime = string().datetime();
+const sha256Hex = string().regex(/^[a-f0-9]{64}$/, "Expected a lowercase hex sha256 digest");
+/**
+* A single entry in a deploy's file tree, as served to the dashboard. Carries
+* no contents: `id` is a stable, path-derived handle used for selection and
+* `?file=` deep links; `hash` is the content address used to fetch the bytes
+* lazily and to cache them immutably in the browser.
+*/
+const ProjectFileSummarySchema = object({
+	id: string(),
+	path: string().min(1),
+	hash: sha256Hex
+});
+/** Maps a runtime resource slug (agent/workflow/skill) to its source file path. */
+const ProjectSourceResourceRefSchema = object({
+	slug: string().min(1),
+	path: string().min(1)
+});
+const ProjectSourceResourcesSchema = object({
+	agents: array(ProjectSourceResourceRefSchema).default([]),
+	workflows: array(ProjectSourceResourceRefSchema).default([]),
+	skills: array(ProjectSourceResourceRefSchema).default([])
+});
+const emptyResources = () => ({
+	agents: [],
+	workflows: [],
+	skills: []
+});
+/** Response for the file-tree listing of a project's active deploy. */
+const ListProjectFilesResponseSchema = object({
+	artifactId: string().nullable(),
+	files: array(ProjectFileSummarySchema),
+	resources: ProjectSourceResourcesSchema.default(emptyResources())
+});
+object({
+	path: string().min(1),
+	contents: string(),
+	hash: sha256Hex
+});
+/** Request: ask the platform which blobs are missing and get presigned PUTs. */
+const PresignProjectSourceRequestSchema = object({ blobs: array(object({
+	hash: sha256Hex,
+	size: number$1().int().nonnegative()
+})) });
+/** Response: presigned PUTs for the subset of blobs not already stored. */
+const PresignProjectSourceResponseSchema = object({ uploads: array(object({
+	hash: sha256Hex,
+	url: string().url()
+})) });
+/** Request body the CLI sends to finalize a deploy's source manifest. */
+const UploadProjectSourceManifestRequestSchema = object({ files: array(object({
+	path: string().min(1),
+	hash: sha256Hex
+})) });
+const UploadProjectSourceResponseSchema = object({
+	ok: literal(true),
+	fileCount: number$1().int().nonnegative()
+});
+object({
+	files: array(object({
+		id: string(),
+		path: string().min(1),
+		hash: sha256Hex
+	})),
+	generatedAt: isoDateTime
+});
+//#endregion
+export { SkillSummaryListResponseSchema as $, ListProjectFilesResponseSchema as A, PresignProjectSourceResponseSchema as B, HealthResponseSchema as C, ListOrganizationMembersResponseSchema as D, ListOrganizationInvitationsResponseSchema as E, PROJECT_REACHABILITY_REQUEST_TIMEOUT_MS as F, ProjectSlugAvailabilityResponseSchema as G, PresignUserAvatarResponseSchema as H, PollRunResponseSchema as I, QueuedAgentPromptResponseSchema as J, PromptInputSchema as K, PresignOrgLogoRequestSchema as L, ListProjectsResponseSchema as M, OrganizationSidebarBrandingPatchSchema as N, ListOrganizationsResponseSchema as O, OrganizationSidebarBrandingSchema as P, SkillSummaryDetailResponseSchema as Q, PresignOrgLogoResponseSchema as R, GatewayAttachmentRecordSchema as S, parseErrorResponse as St, InviteOrganizationMembersResponseSchema as T, ProjectReachabilityResponseSchema as U, PresignUserAvatarRequestSchema as V, ProjectResponseSchema as W, ROUTE_MANIFEST_REL_PATH as X, QueuedRunResponseSchema as Y, RecentResourceListResponseSchema as Z, CreateProjectResponseSchema as _, WorkflowSummaryDetailResponseSchema as _t, AgentSessionDetailResponseSchema as a, UpdateCredentialInstanceBodySchema as at, DeclineOrganizationInvitationResponseSchema as b, normalizeCredentialList as bt, AgentSummaryListResponseSchema as c, UpdateOrganizationRequestSchema as ct, ConnectProvidersResponseSchema as d, UploadProjectSourceResponseSchema as dt, SlugAvailabilityResponseSchema as et, CreateCredentialInstanceBodySchema as f, UpsertGatewayAttachmentBodySchema as ft, CreateProjectRequestSchema as g, WorkflowRunListResponseSchema as gt, CreateProjectArtifactResponseSchema as h, WorkflowRunDetailResponseSchema as ht, AgentListResponseSchema as i, TriggerRunListResponseSchema as it, ListProjectMetricsResponseSchema as j, ListProjectDeploymentsResponseSchema as k, CompleteProjectArtifactResponseSchema as l, UpdateProjectRequestSchema as lt, CreateOrganizationResponseSchema as m, UserAvatarSchema as mt, AcceptOrganizationInvitationResponseSchema as n, TriggerListResponseSchema as nt, AgentSessionListResponseSchema as o, UpdateOrganizationMemberRequestSchema as ot, CreateOrganizationRequestSchema as p, UserAvatarPatchSchema as pt, PromptResponseSchema as q, ActiveOrganizationResponseSchema as r, TriggerRunDetailResponseSchema as rt, AgentSummaryDetailResponseSchema as s, UpdateOrganizationMemberResponseSchema as st, ACTIVE_ORG_HEADER as t, TriggerDetailResponseSchema as tt, ConnectAuthorizeUrlResponseSchema as u, UploadProjectSourceManifestRequestSchema as ut, CredentialInstanceListResponseSchema as v, WorkflowSummaryListResponseSchema as vt, InviteOrganizationMembersRequestSchema as w, ErrorResponseSchema as x, originFromPublicUrl as xt, CredentialInstanceRecordSchema as y, listenPortFromPublicUrl as yt, PresignProjectSourceRequestSchema as z };
+
+//# sourceMappingURL=dist-CqVk9JsS.mjs.map