@keystrokehq/cli 0.0.137 → 0.0.139

package/dist/dist-B27Z3YpE.mjs

@@ -0,0 +1,1737 @@
+#!/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",
+	"sleeping",
+	"waiting_hook",
+	"completed",
+	"failed",
+	"canceled"
+]);
+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()
+})) });
+const HistoryRunKindSchema = _enum(["workflow", "agent"]);
+const HistoryRunStatusSchema = _enum([
+	"pending",
+	"running",
+	"sleeping",
+	"waiting_hook",
+	"completed",
+	"failed",
+	"canceled"
+]);
+const HistoryRunActorSchema = object({
+	userId: string(),
+	name: string(),
+	avatarUrl: string().nullable().optional()
+});
+const HistoryRunUsageLineItemSchema = object({
+	id: string(),
+	label: string(),
+	amountUsd: number$1()
+});
+const HistoryRunUsageSchema = object({
+	runDurationMs: number$1().nullable(),
+	lineItems: array(HistoryRunUsageLineItemSchema),
+	totalExcludingDurationUsd: number$1().nullable()
+});
+const HistoryRunSchema = object({
+	id: string(),
+	kind: HistoryRunKindSchema,
+	traceId: string().nullable(),
+	projectId: string(),
+	projectName: string(),
+	resourceKey: string(),
+	resourceId: string(),
+	resourceName: string(),
+	status: HistoryRunStatusSchema,
+	triggeredAt: string(),
+	timeInQueueMs: number$1().nullable(),
+	startedAt: string(),
+	finishedAt: string().nullable(),
+	durationMs: number$1().nullable(),
+	triggerLabel: string(),
+	triggerRaw: string(),
+	ranAs: HistoryRunActorSchema.nullable(),
+	modelsUsed: array(string()),
+	otherServicesUsed: array(string()),
+	totalCostUsd: number$1().nullable(),
+	messageCount: number$1().optional(),
+	stepCount: number$1().optional()
+});
+const HistoryTraceSpanSchema = 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 HistoryTraceLogSchema = object({
+	id: string(),
+	traceId: string(),
+	spanId: string(),
+	seq: number$1(),
+	level: string(),
+	message: string(),
+	data: unknown().nullable(),
+	source: string(),
+	createdAt: string()
+});
+const HistoryTraceTriggerSchema = object({
+	triggerType: string(),
+	triggerRunId: string(),
+	workflowKey: string().optional(),
+	agentKey: string().optional(),
+	attachmentId: string().nullable().optional(),
+	attachmentKey: string().nullable().optional(),
+	route: string().optional(),
+	sourcePath: string().nullable().optional()
+}).nullable();
+const HistoryTraceGatewaySchema = object({
+	gatewayAttachmentId: string(),
+	gatewayAttachmentKey: string(),
+	threadId: string().optional(),
+	channelId: string().optional(),
+	mode: string().optional()
+}).nullable();
+const HistoryTraceSchema = object({
+	traceId: string(),
+	trigger: HistoryTraceTriggerSchema,
+	gateway: HistoryTraceGatewaySchema,
+	spans: array(HistoryTraceSpanSchema),
+	logs: array(HistoryTraceLogSchema)
+});
+const HistoryWorkflowStepSchema = object({
+	id: string(),
+	actionKey: string(),
+	output: unknown(),
+	completedAt: string()
+});
+const HistoryRunDetailSchema = discriminatedUnion("kind", [object({
+	kind: literal("workflow"),
+	run: object({
+		id: string(),
+		workflowKey: string(),
+		status: HistoryRunStatusSchema,
+		trigger: string(),
+		triggeredAt: string(),
+		startedAt: string().nullable(),
+		finishedAt: string().nullable(),
+		input: unknown().nullable(),
+		output: unknown().nullable(),
+		error: unknown().nullable()
+	}),
+	trigger: object({
+		id: string(),
+		attachmentKey: string().nullable(),
+		triggerType: string(),
+		sourcePath: string().nullable(),
+		payload: unknown().nullable(),
+		triggeredAt: string()
+	}).nullable(),
+	steps: array(HistoryWorkflowStepSchema),
+	trace: HistoryTraceSchema.nullable(),
+	ranAs: HistoryRunActorSchema.nullable().optional(),
+	usage: HistoryRunUsageSchema.nullable().optional()
+}), object({
+	kind: literal("agent"),
+	session: object({
+		id: string(),
+		agentKey: string(),
+		status: HistoryRunStatusSchema,
+		source: _enum([
+			"api",
+			"gateway",
+			"trigger",
+			"workflow",
+			"agent"
+		]),
+		sourceId: string().nullable(),
+		createdAt: string(),
+		updatedAt: string(),
+		messageCount: number$1(),
+		error: unknown().nullable()
+	}),
+	gateway: object({
+		threadId: string(),
+		attachmentKey: string().nullable()
+	}).nullable(),
+	messages: array(record(string(), unknown())),
+	trace: HistoryTraceSchema.nullable(),
+	ranAs: HistoryRunActorSchema.nullable().optional(),
+	usage: HistoryRunUsageSchema.nullable().optional()
+})]);
+const HistoryRunListQuerySchema = object({
+	project: string().min(1).optional(),
+	status: HistoryRunStatusSchema.optional(),
+	kind: HistoryRunKindSchema.optional()
+});
+const HistoryRunListResponseSchema = array(HistoryRunSchema);
+const HistoryRunDetailResponseSchema = HistoryRunDetailSchema.nullable();
+const HistoryRunCancelResponseSchema = HistoryRunSchema.nullable();
+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 { QueuedRunResponseSchema as $, ListOrganizationInvitationsResponseSchema as A, PollRunResponseSchema as B, HealthResponseSchema as C, listenPortFromPublicUrl as Ct, HistoryRunListResponseSchema as D, HistoryRunListQuerySchema as E, parseErrorResponse as Et, ListProjectMetricsResponseSchema as F, PresignUserAvatarRequestSchema as G, PresignOrgLogoResponseSchema as H, ListProjectsResponseSchema as I, ProjectResponseSchema as J, PresignUserAvatarResponseSchema as K, OrganizationSidebarBrandingPatchSchema as L, ListOrganizationsResponseSchema as M, ListProjectDeploymentsResponseSchema as N, InviteOrganizationMembersRequestSchema as O, ListProjectFilesResponseSchema as P, QueuedAgentPromptResponseSchema as Q, OrganizationSidebarBrandingSchema as R, GatewayAttachmentRecordSchema as S, WorkflowSummaryListResponseSchema as St, HistoryRunDetailResponseSchema as T, originFromPublicUrl as Tt, PresignProjectSourceRequestSchema as U, PresignOrgLogoRequestSchema as V, PresignProjectSourceResponseSchema as W, PromptInputSchema as X, ProjectSlugAvailabilityResponseSchema as Y, PromptResponseSchema as Z, CreateProjectResponseSchema as _, UserAvatarPatchSchema as _t, AgentSessionDetailResponseSchema as a, TriggerDetailResponseSchema as at, DeclineOrganizationInvitationResponseSchema as b, WorkflowRunListResponseSchema as bt, AgentSummaryListResponseSchema as c, TriggerRunListResponseSchema as ct, ConnectProvidersResponseSchema as d, UpdateOrganizationMemberResponseSchema as dt, ROUTE_MANIFEST_REL_PATH as et, CreateCredentialInstanceBodySchema as f, UpdateOrganizationRequestSchema as ft, CreateProjectRequestSchema as g, UpsertGatewayAttachmentBodySchema as gt, CreateProjectArtifactResponseSchema as h, UploadProjectSourceResponseSchema as ht, AgentListResponseSchema as i, SlugAvailabilityResponseSchema as it, ListOrganizationMembersResponseSchema as j, InviteOrganizationMembersResponseSchema as k, CompleteProjectArtifactResponseSchema as l, UpdateCredentialInstanceBodySchema as lt, CreateOrganizationResponseSchema as m, UploadProjectSourceManifestRequestSchema as mt, AcceptOrganizationInvitationResponseSchema as n, SkillSummaryDetailResponseSchema as nt, AgentSessionListResponseSchema as o, TriggerListResponseSchema as ot, CreateOrganizationRequestSchema as p, UpdateProjectRequestSchema as pt, ProjectReachabilityResponseSchema as q, ActiveOrganizationResponseSchema as r, SkillSummaryListResponseSchema as rt, AgentSummaryDetailResponseSchema as s, TriggerRunDetailResponseSchema as st, ACTIVE_ORG_HEADER as t, RecentResourceListResponseSchema as tt, ConnectAuthorizeUrlResponseSchema as u, UpdateOrganizationMemberRequestSchema as ut, CredentialInstanceListResponseSchema as v, UserAvatarSchema as vt, HistoryRunCancelResponseSchema as w, normalizeCredentialList as wt, ErrorResponseSchema as x, WorkflowSummaryDetailResponseSchema as xt, CredentialInstanceRecordSchema as y, WorkflowRunDetailResponseSchema as yt, PROJECT_REACHABILITY_REQUEST_TIMEOUT_MS as z };
+
+//# sourceMappingURL=dist-B27Z3YpE.mjs.map