@keystrokehq/cli 0.0.164 → 0.0.166

package/dist/{schemas-Bq8SXmZk.mjs → dist-D_0UmqFb.mjs}

@@ -605,7 +605,7 @@ const string$1 = (params) => {
 	return new RegExp(`^${regex}$`);
 };
 const integer = /^-?\d+$/;
-const number$1 = /^-?\d+(?:\.\d+)?$/;
+const number$2 = /^-?\d+(?:\.\d+)?$/;
 const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
@@ -1379,7 +1379,7 @@ const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
 });
 const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
 	inst._zod.parse = (payload, _ctx) => {
 		if (def.coerce) try {
 			payload.value = Number(payload.value);
@@ -2081,7 +2081,7 @@ const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 					issues: []
 				}, ctx);
 				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+				if (typeof key === "string" && number$2.test(key) && keyResult.issues.length) {
 					const retryResult = def.keyType._zod.run({
 						value: Number(key),
 						issues: []
@@ -4229,7 +4229,7 @@ const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
 	inst.isFinite = true;
 	inst.format = bag.format ?? null;
 });
-function number(params) {
+function number$1(params) {
 	return /* @__PURE__ */ _number(ZodNumber, params);
 }
 const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
@@ -4671,6 +4671,2113 @@ function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
 //#endregion
-export { toJSONSchema as _, array as a, discriminatedUnion as c, object as d, record as f, url as g, unknown as h, _function as i, literal as l, union as m, ZodType as n, boolean as o, string as p, _enum as r, custom as s, ZodNumber as t, number as u, _coercedNumber as v };
+//#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
+function number(params) {
+	return /* @__PURE__ */ _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()
+	})
+]);
+const StoredRouteManifestSchema = object({
+	version: literal(1),
+	entries: array(serializedRouteManifestEntrySchema),
+	skills: array(StoredRouteManifestSkillSchema).default([]),
+	integrations: array(string()).optional()
+});
+/** Messaging platforms that support agent gateway bindings. */
+const ChannelPlatformKeySchema = _enum(["slack"]);
+const ChannelReactionSupportSchema = _enum([
+	"full",
+	"read-only",
+	"none"
+]);
+const ChannelCardSupportSchema = _enum([
+	"full",
+	"partial",
+	"none"
+]);
+const ChannelStreamingSupportSchema = _enum([
+	"native",
+	"post-edit",
+	"buffered",
+	"drafts",
+	"none"
+]);
+const ChannelCapabilitiesSchema = object({
+	mentions: boolean(),
+	reactions: ChannelReactionSupportSchema,
+	cards: ChannelCardSupportSchema,
+	modals: boolean(),
+	streaming: ChannelStreamingSupportSchema,
+	dms: boolean()
+});
+const ChannelListenModeSchema = _enum([
+	"mention",
+	"all",
+	"dm"
+]);
+const ChannelBindingKindSchema = _enum([
+	"public",
+	"private",
+	"dm",
+	"group",
+	"space"
+]);
+const AppGatewaySchema = object({
+	capabilities: ChannelCapabilitiesSchema,
+	supportedModes: array(ChannelListenModeSchema).min(1),
+	resourceNoun: object({
+		singular: string().min(1),
+		plural: string().min(1)
+	}),
+	supportsChannelDirectory: boolean(),
+	webhookPathHint: string().min(1),
+	docsUrl: string().url().optional(),
+	tagline: string().min(1).optional()
+});
+/** Projected catalog row for the agent channels panel (derived from apps with `gateway`). */
+const ChannelPlatformSchema = object({
+	key: ChannelPlatformKeySchema,
+	name: string().min(1),
+	appLogoId: string().min(1),
+	fallbackDomain: string().min(1),
+	description: string().min(1),
+	tagline: string().min(1),
+	authKind: _enum(["oauth", "api_key"]),
+	credentialFields: array(object({
+		key: string().min(1),
+		label: string().min(1),
+		placeholder: string().optional(),
+		helpText: string().optional(),
+		type: _enum([
+			"text",
+			"password",
+			"textarea"
+		]),
+		required: boolean(),
+		prefix: string().optional()
+	})),
+	capabilities: ChannelCapabilitiesSchema,
+	supportedModes: array(ChannelListenModeSchema).min(1),
+	resourceNoun: object({
+		singular: string().min(1),
+		plural: string().min(1)
+	}),
+	webhookPathHint: string().min(1),
+	supportsChannelDirectory: boolean(),
+	docsUrl: string().url().optional()
+});
+const ChannelBindingSchema = object({
+	id: string().min(1),
+	channelId: string().min(1),
+	channelName: string().min(1),
+	channelKind: ChannelBindingKindSchema,
+	mode: ChannelListenModeSchema,
+	subscribeOnMention: boolean(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const ChannelConnectionSchema = object({
+	id: string().min(1),
+	platform: ChannelPlatformKeySchema,
+	agentId: string().min(1),
+	accountLabel: string().min(1),
+	accountId: string().min(1),
+	connectedAt: string(),
+	bindings: array(ChannelBindingSchema)
+});
+const ChannelDirectoryEntrySchema = object({
+	id: string().min(1),
+	name: string().min(1),
+	kind: ChannelBindingKindSchema,
+	memberCount: number$1().int().nonnegative().optional(),
+	isArchived: boolean().optional()
+});
+const ChannelConnectionListResponseSchema = object({ connections: array(ChannelConnectionSchema) });
+const ChannelDirectoryListResponseSchema = object({ channels: array(ChannelDirectoryEntrySchema) });
+object({ teamName: string().min(1).optional() });
+const ChannelAccountListResponseSchema = object({ accounts: array(object({
+	id: string().min(1),
+	platform: ChannelPlatformKeySchema,
+	label: string().min(1),
+	connectedAt: string()
+})) });
+const NewChannelBindingInputSchema = object({
+	channelId: string().min(1),
+	channelName: string().min(1),
+	channelKind: ChannelBindingKindSchema.optional(),
+	mode: ChannelListenModeSchema.optional(),
+	subscribeOnMention: boolean().optional()
+});
+const BindChannelBodySchema = object({
+	platform: ChannelPlatformKeySchema,
+	accountId: string().min(1),
+	binding: NewChannelBindingInputSchema
+});
+const UpdateChannelBindingBodySchema = object({ patch: object({
+	mode: ChannelListenModeSchema.optional(),
+	subscribeOnMention: boolean().optional()
+}) });
+/** A single OAuth scope an app can request, with human copy for connect UI. */
+const OAuthScopeOptionSchema = object({
+	name: string().min(1),
+	description: string().min(1),
+	defaultSelected: boolean().optional(),
+	required: boolean().optional()
+});
+/** How an app authenticates when connecting credentials. */
+const AppAuthKindSchema = _enum(["oauth", "api_key"]);
+const ListAppsResponseSchema = object({ apps: array(object({
+	id: string().min(1),
+	name: string().min(1),
+	description: string().min(1),
+	category: string().min(1),
+	integrationDescription: string().min(1),
+	authKind: AppAuthKindSchema,
+	oauthScopes: array(OAuthScopeOptionSchema),
+	/** When present, the app supports agent gateway bindings (external channels). */
+	gateway: AppGatewaySchema.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([
+	"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"];
+/** Scope of a platform app credential (maps to `credential_instances.scope_type`). */
+const AppCredentialScopeSchema = _enum([
+	"user",
+	"project",
+	"organization"
+]);
+/** How the credential was connected (OAuth vs manual api-key entry). */
+const AppCredentialConnectionKindSchema = _enum(["oauth", "manual"]);
+/** Connect-dialog permission preset for OAuth scope selection. */
+const OAuthPermissionModeSchema = _enum(["default", "restricted"]);
+const optionalTimestamp$1 = string().optional();
+const nullableOptionalTimestamp = string().nullable().optional();
+/**
+* Summary row for the apps/credentials table and credential detail page.
+* Plaintext secrets are never returned — only masked `keyPreviews`.
+*/
+const AppCredentialSummarySchema = object({
+	id: string().min(1),
+	appId: string().min(1),
+	label: string().min(1),
+	scope: AppCredentialScopeSchema,
+	lastRefreshedAt: string().nullable(),
+	appName: string().min(1).optional(),
+	projectId: string().min(1).optional(),
+	projectName: string().min(1).optional(),
+	status: string().optional(),
+	createdAt: optionalTimestamp$1,
+	lastUsedAt: nullableOptionalTimestamp,
+	isDefault: boolean().optional(),
+	connectionKind: AppCredentialConnectionKindSchema.optional(),
+	ownerUserId: string().min(1).optional(),
+	ownerName: string().min(1).optional(),
+	ownerAvatarUrl: string().url().optional(),
+	grantedScopes: array(string().min(1)).optional(),
+	credentialKeys: array(string().min(1)).optional(),
+	keyPreviews: record(string(), string()).optional(),
+	expiresAt: optionalTimestamp$1
+});
+const credentialSecretValueSchema = record(string(), unknown()).refine((value) => Object.keys(value).length > 0, { message: "value must be a non-empty object" });
+function hasCredentialTarget(input) {
+	return input.projects.length > 0 || input.createOrganizationCredential || input.createUserProvidedCredential;
+}
+function addMissingCredentialTargetIssue(ctx, path = ["projects"]) {
+	ctx.addIssue({
+		code: "custom",
+		message: "At least one credential target is required",
+		path
+	});
+}
+/** Target fields shared by create and OAuth start flows. */
+const CredentialTargetsFieldsSchema = object({
+	projects: array(string().min(1)).default([]),
+	createOrganizationCredential: boolean().default(false),
+	createUserProvidedCredential: boolean().default(false)
+});
+/** Input for starting an OAuth connection (connect dialog / CLI connect). */
+const StartOAuthConnectionInputSchema = CredentialTargetsFieldsSchema.extend({
+	appId: string().min(1),
+	scopes: array(string().min(1)),
+	permissionMode: OAuthPermissionModeSchema
+});
+/** Result of starting an OAuth connection. */
+const StartOAuthConnectionResultSchema = object({
+	status: _enum(["connected", "redirecting"]),
+	authorizeUrl: string().url().nullable()
+});
+/** Request body for `POST /api/credentials` (manual api-key fan-out). */
+const CreateCredentialsRequestSchema = CredentialTargetsFieldsSchema.extend({
+	appId: string().min(1),
+	connectionKind: AppCredentialConnectionKindSchema,
+	value: credentialSecretValueSchema.optional(),
+	scopes: array(string().min(1)).optional()
+}).superRefine((input, ctx) => {
+	if (!hasCredentialTarget(input)) addMissingCredentialTargetIssue(ctx);
+	if (input.connectionKind === "manual" && !input.value) ctx.addIssue({
+		code: "custom",
+		message: "value is required for manual connections",
+		path: ["value"]
+	});
+	if (input.connectionKind === "oauth") ctx.addIssue({
+		code: "custom",
+		message: "OAuth credentials are created via the OAuth callback",
+		path: ["connectionKind"]
+	});
+});
+/** Request body for `PATCH /api/credentials/:id`. */
+const UpdateCredentialRequestSchema = object({
+	label: string().trim().min(1).optional(),
+	isDefault: boolean().optional(),
+	value: credentialSecretValueSchema.optional()
+}).refine((input) => input.label !== void 0 || input.isDefault !== void 0 || input.value !== void 0, { message: "At least one field is required" });
+const ListCredentialsResponseSchema = object({ credentials: array(AppCredentialSummarySchema) });
+const GetCredentialResponseSchema = object({ credential: AppCredentialSummarySchema });
+const CreateCredentialsResponseSchema = object({ credentials: array(AppCredentialSummarySchema) });
+const SubmitTeamRequestRequestSchema = object({
+	type: _enum([
+		"org-deletion",
+		"contact",
+		"enterprise-upgrade"
+	]),
+	message: string().trim().max(5e3).optional()
+});
+object({ ok: literal(true) });
+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$5 = string().datetime();
+const OrganizationSchema = object({
+	id: string(),
+	name: string(),
+	slug: OrganizationSlugSchema,
+	createdAt: isoDateTime$5,
+	updatedAt: isoDateTime$5
+});
+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$5,
+	updatedAt: isoDateTime$5
+});
+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$5.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",
+	"run_canceled"
+]);
+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",
+	"canceled"
+]);
+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()
+});
+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"),
+	runId: string(),
+	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$4 = string().datetime();
+const OrganizationMemberSchema = object({
+	id: string(),
+	name: string(),
+	email: string().email(),
+	role: OrganizationMemberRoleSchema,
+	status: OrganizationMemberStatusSchema,
+	avatarUrl: string().optional(),
+	joinedAt: isoDateTime$4.optional(),
+	lastActiveAt: isoDateTime$4.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) });
+const isoDateTime$3 = string().datetime();
+const ApiKeyCreatorSchema = object({
+	id: string(),
+	name: string(),
+	email: string().email().optional(),
+	avatarUrl: string().optional(),
+	/** True when the creator user row no longer exists. */
+	deleted: boolean().optional()
+});
+const ApiKeySummarySchema = object({
+	id: string(),
+	name: string(),
+	keyPreview: string(),
+	createdAt: isoDateTime$3,
+	createdBy: ApiKeyCreatorSchema,
+	isCreatedByCurrentUser: boolean()
+});
+const ListApiKeysResponseSchema = object({ apiKeys: array(ApiKeySummarySchema) });
+const CreateApiKeyRequestSchema = object({ name: string().trim().min(1).max(128) });
+const CreateApiKeyResponseSchema = ApiKeySummarySchema.extend({ secret: string() });
+const ProjectUserRoleSchema = _enum(["admin", "builder"]);
+const ProjectInvitePermissionSchema = _enum(["admin", "all"]);
+const ProjectMemberStatusSchema = _enum(["active", "invited"]);
+const isoDateTime$2 = string().datetime();
+const ProjectMemberSchema = object({
+	id: string(),
+	projectId: string(),
+	name: string(),
+	email: string().email(),
+	role: ProjectUserRoleSchema,
+	status: ProjectMemberStatusSchema,
+	image: string().nullable(),
+	createdAt: isoDateTime$2,
+	isCurrentUser: boolean().optional()
+});
+const ListProjectMembersResponseSchema = object({ members: array(ProjectMemberSchema) });
+const InviteProjectMembersRequestSchema = object({
+	emails: array(string().trim().email()).min(1),
+	role: ProjectUserRoleSchema
+});
+const InviteProjectMemberResultStatusSchema = _enum([
+	"added",
+	"already_member",
+	"not_org_member",
+	"invalid"
+]);
+const InviteProjectMembersResponseSchema = object({ results: array(object({
+	email: string(),
+	status: InviteProjectMemberResultStatusSchema
+})) });
+const UpdateProjectMemberRequestSchema = object({ role: ProjectUserRoleSchema });
+const UpdateProjectMemberResponseSchema = object({ member: ProjectMemberSchema });
+const ProjectSettingsSchema = object({
+	description: string(),
+	defaultRole: ProjectUserRoleSchema,
+	invitePermission: ProjectInvitePermissionSchema
+});
+const UpdateProjectSettingsRequestSchema = object({
+	description: string().optional(),
+	defaultRole: ProjectUserRoleSchema.optional(),
+	invitePermission: ProjectInvitePermissionSchema.optional()
+}).refine((data) => data.description !== void 0 || data.defaultRole !== void 0 || data.invitePermission !== void 0, { message: "At least one field is required" });
+const ProjectSettingsResponseSchema = object({ settings: ProjectSettingsSchema });
+/** 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 UserInterfaceThemeSchema = _enum([
+	"system",
+	"light",
+	"dark"
+]);
+const UserSurfaceContrastSchema = _enum(["off", "on"]);
+const UserWorkspaceLayoutModeSchema = _enum(["default", "linear"]);
+const UserWorkspaceFontSizeSchema = _enum(["default", "large"]);
+const UserSidebarNavIconVisibilitySchema = _enum(["hidden", "visible"]);
+const UserSidebarFooterChatRowVisibilitySchema = _enum(["hidden", "visible"]);
+const UserWorkspaceFavoriteSchema = object({
+	kind: _enum([
+		"agent",
+		"workflow",
+		"skill",
+		"run"
+	]),
+	resourceId: string().min(1)
+});
+const UserPreferencesSchema = object({
+	interfaceTheme: UserInterfaceThemeSchema,
+	surfaceContrast: UserSurfaceContrastSchema,
+	layoutMode: UserWorkspaceLayoutModeSchema,
+	fontSize: UserWorkspaceFontSizeSchema,
+	sidebar: object({
+		navIconVisibility: UserSidebarNavIconVisibilitySchema,
+		footerChatRowVisibility: UserSidebarFooterChatRowVisibilitySchema,
+		hiddenNavItemIds: array(string()),
+		topNavItemOrderIds: array(string()),
+		workspaceNavItemOrderIds: array(string())
+	}),
+	favorites: array(UserWorkspaceFavoriteSchema),
+	projectOrderIds: array(string()),
+	projectDotColors: record(string(), string()),
+	onboardingTabVisible: boolean()
+});
+const UserSidebarPreferencesPatchSchema = object({
+	navIconVisibility: UserSidebarNavIconVisibilitySchema.optional(),
+	footerChatRowVisibility: UserSidebarFooterChatRowVisibilitySchema.optional(),
+	hiddenNavItemIds: array(string()).optional(),
+	topNavItemOrderIds: array(string()).optional(),
+	workspaceNavItemOrderIds: array(string()).optional()
+});
+const UserPreferencesPatchSchema = object({
+	interfaceTheme: UserInterfaceThemeSchema.optional(),
+	surfaceContrast: UserSurfaceContrastSchema.optional(),
+	layoutMode: UserWorkspaceLayoutModeSchema.optional(),
+	fontSize: UserWorkspaceFontSizeSchema.optional(),
+	sidebar: UserSidebarPreferencesPatchSchema.optional(),
+	favorites: array(UserWorkspaceFavoriteSchema).optional(),
+	projectOrderIds: array(string()).optional(),
+	projectDotColors: record(string(), string()).optional(),
+	onboardingTabVisible: boolean().optional()
+}).refine((value) => value.interfaceTheme !== void 0 || value.surfaceContrast !== void 0 || value.layoutMode !== void 0 || value.fontSize !== void 0 || value.sidebar !== void 0 || value.favorites !== void 0 || value.projectOrderIds !== void 0 || value.projectDotColors !== void 0 || value.onboardingTabVisible !== void 0, { message: "At least one preference field is required" });
+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 DownloadActiveProjectArtifactResponseSchema = object({
+	artifactId: string(),
+	downloadUrl: string().url(),
+	expiresInSeconds: number$1().int().positive()
+});
+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 { ListProjectsResponseSchema as $, normalizeCredentialList as $t, DownloadActiveProjectArtifactResponseSchema as A, TriggerRunListResponseSchema as At, InviteOrganizationMembersResponseSchema as B, UpdateProjectSettingsRequestSchema as Bt, CreateOrganizationResponseSchema as C, StartOAuthConnectionInputSchema as Ct, CredentialInstanceListResponseSchema as D, TriggerDetailResponseSchema as Dt, CreateProjectResponseSchema as E, SubmitTeamRequestRequestSchema as Et, HistoryRunCancelResponseSchema as F, UpdateOrganizationMemberResponseSchema as Ft, ListCredentialsResponseSchema as G, UserAvatarSchema as Gt, InviteProjectMembersResponseSchema as H, UploadProjectSourceResponseSchema as Ht, HistoryRunDetailResponseSchema as I, UpdateOrganizationRequestSchema as It, ListOrganizationsResponseSchema as J, WorkflowRunDetailResponseSchema as Jt, ListOrganizationInvitationsResponseSchema as K, UserPreferencesPatchSchema as Kt, HistoryRunListQuerySchema as L, UpdateProjectMemberRequestSchema as Lt, GatewayAttachmentRecordSchema as M, UpdateCredentialInstanceBodySchema as Mt, GetCredentialResponseSchema as N, UpdateCredentialRequestSchema as Nt, CredentialInstanceRecordSchema as O, TriggerListResponseSchema as Ot, HealthResponseSchema as P, UpdateOrganizationMemberRequestSchema as Pt, ListProjectMetricsResponseSchema as Q, listenPortFromPublicUrl as Qt, HistoryRunListResponseSchema as R, UpdateProjectMemberResponseSchema as Rt, CreateOrganizationRequestSchema as S, SlugAvailabilityResponseSchema as St, CreateProjectRequestSchema as T, StoredRouteManifestSchema as Tt, ListApiKeysResponseSchema as U, UpsertGatewayAttachmentBodySchema as Ut, InviteProjectMembersRequestSchema as V, UploadProjectSourceManifestRequestSchema as Vt, ListAppsResponseSchema as W, UserAvatarPatchSchema as Wt, ListProjectFilesResponseSchema as X, WorkflowSummaryDetailResponseSchema as Xt, ListProjectDeploymentsResponseSchema as Y, WorkflowRunListResponseSchema as Yt, ListProjectMembersResponseSchema as Z, WorkflowSummaryListResponseSchema as Zt, CreateApiKeyRequestSchema as _, QueuedRunResponseSchema as _t, AgentSessionListResponseSchema as a, custom as an, PresignOrgLogoResponseSchema as at, CreateCredentialsRequestSchema as b, SkillSummaryDetailResponseSchema as bt, BindChannelBodySchema as c, object as cn, PresignUserAvatarRequestSchema as ct, ChannelConnectionSchema as d, toJSONSchema as dn, ProjectResponseSchema as dt, originFromPublicUrl as en, OrganizationSidebarBrandingPatchSchema as et, ChannelDirectoryListResponseSchema as f, ProjectSettingsResponseSchema as ft, ConnectProvidersResponseSchema as g, QueuedAgentPromptResponseSchema as gt, ConnectAuthorizeUrlResponseSchema as h, PromptResponseSchema as ht, AgentSessionDetailResponseSchema as i, array as in, PresignOrgLogoRequestSchema as it, ErrorResponseSchema as j, UpdateChannelBindingBodySchema as jt, DeclineOrganizationInvitationResponseSchema as k, TriggerRunDetailResponseSchema as kt, ChannelAccountListResponseSchema as l, string as ln, PresignUserAvatarResponseSchema as lt, CompleteProjectArtifactResponseSchema as m, PromptInputSchema as mt, AcceptOrganizationInvitationResponseSchema as n, ZodType as nn, PROJECT_REACHABILITY_REQUEST_TIMEOUT_MS as nt, AgentSummaryDetailResponseSchema as o, discriminatedUnion as on, PresignProjectSourceRequestSchema as ot, ChannelPlatformSchema as p, ProjectSlugAvailabilityResponseSchema as pt, ListOrganizationMembersResponseSchema as q, UserPreferencesSchema as qt, ActiveOrganizationResponseSchema as r, _function as rn, PollRunResponseSchema as rt, AgentSummaryListResponseSchema as s, literal as sn, PresignProjectSourceResponseSchema as st, ACTIVE_ORG_HEADER as t, parseErrorResponse as tn, OrganizationSidebarBrandingSchema as tt, ChannelConnectionListResponseSchema as u, union as un, ProjectReachabilityResponseSchema as ut, CreateApiKeyResponseSchema as v, ROUTE_MANIFEST_REL_PATH as vt, CreateProjectArtifactResponseSchema as w, StartOAuthConnectionResultSchema as wt, CreateCredentialsResponseSchema as x, SkillSummaryListResponseSchema as xt, CreateCredentialInstanceBodySchema as y, RecentResourceListResponseSchema as yt, InviteOrganizationMembersRequestSchema as z, UpdateProjectRequestSchema as zt };
 
-//# sourceMappingURL=schemas-Bq8SXmZk.mjs.map
+//# sourceMappingURL=dist-D_0UmqFb.mjs.map