@alpic-ai/api 0.0.0-dev.ge4c0895 → 0.0.0-dev.ge4e4833

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { z } from "zod";
 import * as z$1 from "zod/v4";
 import { oc } from "@orpc/contract";
 import ms from "ms";
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.32.0_supports-color@7.2.0_zod@4.5.4/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
 /**
 * Reusable URL validation that disallows javascript: scheme
 */
@@ -119,7 +119,12 @@ z$1.object({
 	token_type: z$1.string(),
 	expires_in: z$1.coerce.number().optional(),
 	scope: z$1.string().optional(),
-	refresh_token: z$1.string().optional()
+	refresh_token: z$1.string().optional(),
+	/**
+	* Not part of the wire format: the authorization server this value was obtained from, added by
+	* the client's `auth()` before it is stored and compared when it is read back.
+	*/
+	issuer: z$1.string().optional().catch(void 0)
 }).strip();
 z$1.object({
 	error: z$1.string(),
@@ -158,7 +163,12 @@ const OAuthClientInformationSchema = z$1.object({
 	client_id: z$1.string(),
 	client_secret: z$1.string().optional(),
 	client_id_issued_at: z$1.number().optional(),
-	client_secret_expires_at: z$1.number().optional()
+	client_secret_expires_at: z$1.number().optional(),
+	/**
+	* Not part of the wire format: the authorization server this value was obtained from, added by
+	* the client's `auth()` before it is stored and compared when it is read back.
+	*/
+	issuer: z$1.string().optional().catch(void 0)
 }).strip();
 OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
 z$1.object({
@@ -169,11 +179,22 @@ z$1.object({
 	token: z$1.string(),
 	token_type_hint: z$1.string().optional()
 }).strip();
-const platformSchema = z.enum(["chatgpt", "claudeai"]);
+//#endregion
+//#region ../domains/dist/index.mjs
+const AI_PLATFORMS = ["chatgpt", "claudeai"];
+const platformSchema = z.enum(AI_PLATFORMS);
 const PLATFORM_LABELS = {
 	chatgpt: "ChatGPT",
 	claudeai: "Claude.ai"
 };
+const WAF_PLATFORMS = [
+	"akamai",
+	"cato",
+	"cloudflare",
+	"fastly"
+];
+const ALLOWED_PLATFORMS = [...AI_PLATFORMS, ...WAF_PLATFORMS];
+const allowedPlatformSchema = z.enum(ALLOWED_PLATFORMS);
 const auditStatusSchema = z.enum([
 	"pending",
 	"partial",
@@ -246,6 +267,25 @@ z.object({
 	clientSecret: z.string(),
 	clientScopes: z.array(z.string())
 });
+const creditEntryReasonSchema = z.enum([
+	"free_seed",
+	"paid_conversion_floor",
+	"top_up",
+	"usage",
+	"admin_adjustment"
+]);
+z.enum(["playground"]);
+z.number().int().min(500);
+const creditActivityEntrySchema = z.object({
+	reason: creditEntryReasonSchema,
+	day: z.number(),
+	amountInNanoUSD: z.number(),
+	messageCount: z.number().nullable()
+});
+z.object({
+	balanceInNanoUSD: z.number(),
+	recentActivity: z.array(creditActivityEntrySchema)
+});
 const deploymentStatusSchema$1 = z.enum([
 	"ongoing",
 	"deployed",
@@ -273,34 +313,51 @@ const deploymentSummarySchema = z.object({
 	createdAt: z.coerce.date(),
 	updatedAt: z.coerce.date()
 });
-/**
-* Public environment
-*
-* No OAuth metadata exposed.
-*/
+/** Public environment: answers anonymously and exposes no OAuth metadata. */
 const publicEnvironmentSchema = z.object({
+	allowsAnonymous: z.literal(true),
+	oAuthMetadata: z.strictObject({})
+});
+/** Protected environment whose external resource metadata URL is returned in the WWW-Authenticate header on the first 401; everything after is handled outside the MCP server scope. */
+const externalResourceMetadataEnvironmentSchema = z.object({
+	allowsAnonymous: z.boolean(),
+	oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
+	scope: z.string().optional()
+});
+/** Protected environment whose own /.well-known/oauth-protected-resource endpoint points at an external authorization server; everything after is handled outside the MCP server scope. */
+const externalAuthorizationServerEnvironmentSchema = z.object({
+	allowsAnonymous: z.boolean(),
+	oAuthMetadata: z.object({
+		externalAuthorizationServerUrl: z.url(),
+		resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
+	}),
+	scope: z.string().optional()
+});
+/** Standalone protected environment: the server itself exposes both the /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server endpoints. */
+const standaloneEnvironmentSchema = z.object({
+	allowsAnonymous: z.boolean(),
+	oAuthMetadata: z.object({
+		authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
+		resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
+	}),
+	scope: z.string().optional()
+});
+/** Protected environment that enforces authentication but advertises no OAuth discovery metadata; clients must obtain credentials out-of-band. */
+const protectedWithoutDiscoveryEnvironmentSchema = z.object({
+	allowsAnonymous: z.literal(false),
+	oAuthMetadata: z.strictObject({}),
+	scope: z.string().optional()
+});
+const legacyPublicEnvironmentSchema = z.object({
 	isPublic: z.literal(true),
 	oAuthMetadata: z.undefined().optional()
 });
-/**
-* Protected environment with an external resource metadata URL
-*
-* An external resource metadata URL is returned in the WWW-Authenticate header during the first 401 response.
-* Everything that follows is handled outside of the MCP server scope.
-*/
-const externalResourceMetadataEnvironmentSchema = z.object({
+const legacyExternalResourceMetadataEnvironmentSchema = z.object({
 	isPublic: z.literal(false),
 	oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
 	scope: z.string().optional()
 });
-/**
-* Protected environment with an external authorization server URL
-*
-* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
-* An external authorization server URL is returned when requesting the endpoint.
-* Everything that follows is handled outside of the MCP server scope.
-*/
-const externalAuthorizationServerEnvironmentSchema = z.object({
+const legacyExternalAuthorizationServerEnvironmentSchema = z.object({
 	isPublic: z.literal(false),
 	oAuthMetadata: z.object({
 		externalAuthorizationServerUrl: z.url(),
@@ -308,13 +365,7 @@ const externalAuthorizationServerEnvironmentSchema = z.object({
 	}),
 	scope: z.string().optional()
 });
-/**
-* Standalone protected environment
-*
-* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
-* The server itself exposes the /.well-known/oauth-authorization-server endpoint.
-*/
-const standaloneEnvironmentSchema = z.object({
+const legacyStandaloneEnvironmentSchema = z.object({
 	isPublic: z.literal(false),
 	oAuthMetadata: z.object({
 		authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
@@ -322,14 +373,7 @@ const standaloneEnvironmentSchema = z.object({
 	}),
 	scope: z.string().optional()
 });
-/**
-* Protected environment without OAuth discovery
-*
-* The server enforces authentication but exposes no OAuth discovery metadata.
-* Neither /.well-known/oauth-protected-resource nor /.well-known/oauth-authorization-server
-* are advertised. Clients must obtain credentials out-of-band.
-*/
-const protectedWithoutDiscoveryEnvironmentSchema = z.object({
+const legacyProtectedWithoutDiscoveryEnvironmentSchema = z.object({
 	isPublic: z.literal(false),
 	oAuthMetadata: z.strictObject({}),
 	scope: z.string().optional()
@@ -339,11 +383,21 @@ z.union([
 	externalResourceMetadataEnvironmentSchema,
 	externalAuthorizationServerEnvironmentSchema,
 	standaloneEnvironmentSchema,
-	protectedWithoutDiscoveryEnvironmentSchema
+	protectedWithoutDiscoveryEnvironmentSchema,
+	legacyPublicEnvironmentSchema,
+	legacyExternalResourceMetadataEnvironmentSchema,
+	legacyExternalAuthorizationServerEnvironmentSchema,
+	legacyStandaloneEnvironmentSchema,
+	legacyProtectedWithoutDiscoveryEnvironmentSchema
+]);
+const playgroundModelSchema = z.enum([
+	"global.anthropic.claude-haiku-4-5-20251001-v1:0",
+	"global.anthropic.claude-sonnet-4-5-20250929-v1:0",
+	"openai.gpt-5.4",
+	"openai.gpt-5.5"
 ]);
-const allowedPlatformSchema = platformSchema;
 const environmentDomainSchema = z.object({
-	domain: z.string(),
+	name: z.string(),
 	status: z.enum([
 		"ongoing",
 		"deployed",
@@ -361,6 +415,7 @@ const environmentSchema$1 = z.object({
 	latestDeployment: deploymentSummarySchema.optional(),
 	openaiAppsChallenge: z.string().nullable().optional(),
 	isPlaygroundEnabled: z.boolean(),
+	playgroundModel: playgroundModelSchema,
 	isIpWhitelistEnabled: z.boolean(),
 	ipAllowlist: z.array(z.string()).nullable(),
 	allowedPlatforms: z.array(allowedPlatformSchema),
@@ -373,14 +428,18 @@ z.object({
 	sessionReplayEnabled: z.boolean(),
 	collectRequestPayload: z.boolean(),
 	collectResponsePayload: z.boolean(),
-	collectErrorMessage: z.boolean()
+	collectErrorMessage: z.boolean(),
+	collectUserData: z.boolean(),
+	identityTraitKey: z.string().min(1).max(200).nullable(),
+	leadEventName: z.string().min(1).max(200).nullable()
 });
-z.object({
+const feedbackSchema = z.object({
 	id: z.string(),
 	createdAt: z.coerce.date(),
 	environmentId: z.string(),
 	content: z.string(),
-	source: z.enum(["model", "user"])
+	source: z.enum(["model", "user"]),
+	clientName: z.string().nullable()
 });
 z.object({
 	content: z.string(),
@@ -396,7 +455,7 @@ const intentCategoryColorSchema = z.enum([
 	"pink",
 	"gray"
 ]);
-intentCategoryColorSchema.options;
+const INTENT_CATEGORY_COLORS = intentCategoryColorSchema.options;
 const intentCategorySchema = z.object({
 	id: z.string(),
 	createdAt: z.coerce.date(),
@@ -404,7 +463,7 @@ const intentCategorySchema = z.object({
 	name: z.string(),
 	color: intentCategoryColorSchema
 });
-z.object({
+const intentCategorySummarySchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	color: intentCategoryColorSchema,
@@ -416,6 +475,7 @@ z.object({
 	environmentId: z.string(),
 	toolName: z.string(),
 	message: z.string(),
+	clientName: z.string().nullable(),
 	categories: z.array(intentCategorySchema)
 });
 const signalCategorySchema = z.object({
@@ -474,12 +534,270 @@ z.object({
 	createdAt: z.coerce.date(),
 	updatedAt: z.coerce.date()
 });
+const alpicMcpRequestLogSchema = z.object({
+	type: z.literal("mcp_request"),
+	method: z.string()
+});
+const alpicMcpErrorLogSchema = z.object({
+	type: z.literal("mcp_error"),
+	method: z.string(),
+	error: z.string()
+});
+z.union([alpicMcpRequestLogSchema, alpicMcpErrorLogSchema]);
 z.enum([
 	"INFO",
 	"WARNING",
 	"DEBUG",
 	"ERROR"
 ]);
+const LOG_SEARCH_MAX_ESCAPED_LENGTH = 960;
+function escapeLogSearchTerm(search) {
+	return [...search].flatMap((character) => [...new TextEncoder().encode(character)]).map((byte) => {
+		const character = String.fromCharCode(byte);
+		return /^[a-zA-Z0-9]$/.test(character) ? character : `\\x${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	}).join("");
+}
+const logSearchSchema = z.string().max(240, `Search must be 240 characters or fewer`).refine((search) => escapeLogSearchTerm(search).length <= LOG_SEARCH_MAX_ESCAPED_LENGTH, "Search is too complex; shorten it or use fewer special characters");
+/** Only names a vendor actually ships belong here: lookalikes like `claude-code-test` are customers' own scripts. */
+const MCP_CLIENT_GROUPS = [
+	{
+		id: "claude_code",
+		label: "Claude Code",
+		vendor: "anthropic",
+		rawNames: ["claude-code", "Anthropic/ClaudeCodeDesktop"]
+	},
+	{
+		id: "claude",
+		label: "Claude",
+		vendor: "anthropic",
+		rawNames: [
+			"Anthropic/ClaudeAI",
+			"claude-ai",
+			"claude",
+			"Claude",
+			"claude-desktop",
+			"claude-desktop-3p"
+		]
+	},
+	{
+		id: "claude_mobile",
+		label: "Claude mobile",
+		vendor: "anthropic",
+		rawNames: ["claude-ios", "ClaudeAndroid"]
+	},
+	{
+		id: "claude_cowork",
+		label: "Claude Cowork",
+		vendor: "anthropic",
+		rawNames: ["Anthropic/Cowork"]
+	},
+	{
+		id: "claude_toolbox",
+		label: "Claude Toolbox",
+		vendor: "anthropic",
+		rawNames: ["Anthropic/Toolbox", "Anthropic/toolbox-bootstrap"]
+	},
+	{
+		id: "anthropic_api",
+		label: "Anthropic API",
+		vendor: "anthropic",
+		rawNames: ["Anthropic/API"]
+	},
+	{
+		id: "anthropic_connector_refresh",
+		label: "Anthropic (connector refresh)",
+		vendor: "anthropic",
+		rawNames: ["Anthropic"]
+	},
+	{
+		id: "codex",
+		label: "Codex",
+		vendor: "openai",
+		rawNames: [
+			"codex-mcp-client",
+			"codex",
+			"Codex",
+			"codex-cli",
+			"openai-mcp (Codex)"
+		]
+	},
+	{
+		id: "chatgpt",
+		label: "ChatGPT",
+		vendor: "openai",
+		rawNames: ["openai-mcp (ChatGPT)"]
+	},
+	{
+		id: "openai_responses_api",
+		label: "OpenAI Responses API",
+		vendor: "openai",
+		rawNames: ["openai-mcp (Responses API)"]
+	},
+	{
+		id: "openai_agent_builder",
+		label: "OpenAI Agent Builder",
+		vendor: "openai",
+		rawNames: ["openai-mcp (Agent Builder)"]
+	},
+	{
+		id: "openai_other",
+		label: "OpenAI Other",
+		vendor: "openai",
+		rawNames: ["openai-mcp"]
+	},
+	{
+		id: "cursor",
+		label: "Cursor",
+		vendor: "cursor",
+		rawNames: [
+			"cursor-vscode",
+			"Cursor",
+			"cursor"
+		]
+	},
+	{
+		id: "cline",
+		label: "Cline",
+		vendor: "cline",
+		rawNames: [
+			"Cline",
+			"cline",
+			"@cline/core"
+		]
+	},
+	{
+		id: "github_copilot",
+		label: "GitHub Copilot",
+		vendor: "githubCopilot",
+		rawNames: [
+			"Copilot",
+			"github-copilot-developer",
+			"Copilot MCP Gateway",
+			"Xcode/copilot-xcode"
+		]
+	},
+	{
+		id: "gemini_cli",
+		label: "Gemini CLI",
+		vendor: "google",
+		rawNames: ["gemini-cli-mcp-client", "gemini-cli"]
+	},
+	{
+		id: "antigravity",
+		label: "Antigravity",
+		vendor: "google",
+		rawNames: ["antigravity-client"]
+	},
+	{
+		id: "gemini",
+		label: "Gemini",
+		vendor: "google",
+		rawNames: ["Gemini", "google-ai-edge-gallery"]
+	},
+	{
+		id: "windsurf",
+		label: "Windsurf",
+		vendor: "windsurf",
+		rawNames: ["Windsurf", "windsurf-client"]
+	},
+	{
+		id: "mistral",
+		label: "Mistral / Le Chat",
+		vendor: "mistral",
+		rawNames: ["Mistral"],
+		rawNamePrefixes: ["connector:custom-mcp:"]
+	},
+	{
+		id: "n8n",
+		label: "n8n",
+		vendor: "n8n",
+		rawNames: [
+			"@n8n/n8n-nodes-langchain.mcpClient",
+			"@n8n/n8n-nodes-langchain.mcpClientTool",
+			"n8n"
+		]
+	},
+	{
+		id: "alpic_playground",
+		label: "Alpic Playground",
+		vendor: "alpic",
+		rawNames: ["alpic-playground", "playground"]
+	},
+	{
+		id: "opencode",
+		label: "opencode",
+		vendor: "opencode",
+		rawNames: ["opencode"]
+	},
+	{
+		id: "zed",
+		label: "Zed",
+		vendor: "zed",
+		rawNames: ["Zed", "zed"]
+	},
+	{
+		id: "zapier",
+		label: "Zapier",
+		vendor: "zapier",
+		rawNames: ["Zapier", "zapier"]
+	},
+	{
+		id: "make",
+		label: "Make",
+		vendor: "make",
+		rawNames: ["Make", "make"]
+	},
+	{
+		id: "librechat",
+		label: "LibreChat",
+		vendor: "mcp",
+		rawNames: ["LibreChat", "librechat"]
+	},
+	{
+		id: "jan",
+		label: "Jan",
+		vendor: "mcp",
+		rawNames: ["Jan", "jan"]
+	},
+	{
+		id: "goose",
+		label: "goose",
+		vendor: "mcp",
+		rawNames: ["goose", "Goose"]
+	},
+	{
+		id: "mcphost",
+		label: "mcphost",
+		vendor: "mcp",
+		rawNames: ["mcphost"]
+	},
+	{
+		id: "mcporter",
+		label: "mcporter",
+		vendor: "mcp",
+		rawNames: ["mcporter"]
+	},
+	{
+		id: "rmcp",
+		label: "rmcp",
+		vendor: "mcp",
+		rawNames: ["rmcp"]
+	},
+	{
+		id: "unnamed_client",
+		label: "Unnamed client",
+		vendor: "mcp",
+		rawNames: [
+			"mcp",
+			"unknown",
+			""
+		]
+	}
+];
+/** A source pattern, not a RegExp, because analytics renders the same rule into ClickHouse RE2, which shares this syntax. */
+const MCP_REMOTE_WRAPPER_SUFFIX = String.raw` \(via mcp-remote [^\n]+?\)$`;
+new RegExp(MCP_REMOTE_WRAPPER_SUFFIX);
+new Map(MCP_CLIENT_GROUPS.map((group) => [group.id, group]));
 const runtimeSchema = z.enum([
 	"python3.13",
 	"python3.14",
@@ -508,15 +826,27 @@ z.object({
 	environments: z.array(environmentWithDomainsSchema),
 	productionEnvironment: environmentWithDomainsSchema.nullable()
 });
+const domainFailureReasonSchema = z.enum([
+	"caa",
+	"dns",
+	"invalid_domain",
+	"other"
+]);
+const projectDomainMappingSchema = z.object({
+	pathPrefix: z.string(),
+	environment: environmentSchema$1
+});
 z.object({
-	domain: z.string(),
+	name: z.string(),
 	createdAt: z.coerce.date(),
 	status: z.enum([
 		"ongoing",
 		"deployed",
 		"failed"
 	]),
-	environment: environmentSchema$1
+	failureReason: domainFailureReasonSchema.nullable(),
+	environment: environmentSchema$1,
+	mappings: z.array(projectDomainMappingSchema)
 });
 const serverFieldsSchema$1 = z.object({
 	$schema: z.string(),
@@ -545,15 +875,7 @@ z.object({
 	serverFields: serverFieldsSchema$1,
 	source: z.enum(["registry", "defaults"])
 });
-/**
-* Returns a variant of a `maxLength`-constrained string that clamps (truncates) instead of
-* rejecting on overflow — used for AI-generated copy where the model routinely overshoots.
-*
-* NOTE: this rebuilds the schema from scratch, carrying over only `maxLength` (as a clamp),
-* `minLength`, and the description. Any other validators on the source field (`.regex()`,
-* `.email()`, custom refinements) are intentionally dropped — this helper is meant for plain
-* free-text length caps only. A field with `null` `maxLength` is returned unchanged.
-*/
+/** Clamps instead of rejecting on max-length overflow (for AI-generated copy that overshoots); intentionally carries over only maxLength, minLength, and description, dropping any other validators. */
 const clampStringField = (field) => {
 	const max = field.maxLength;
 	if (max === null) return field;
@@ -561,6 +883,10 @@ const clampStringField = (field) => {
 	const withMin = field.minLength === null ? clamped : clamped.min(field.minLength);
 	return field.description ? withMin.describe(field.description) : withMin;
 };
+const unboundedArrayField = (field) => {
+	const unbounded = z.array(field.element);
+	return field.description ? unbounded.describe(field.description) : unbounded;
+};
 const toolDefinitionSchema = z.object({
 	name: z.string(),
 	title: z.string().optional().describe("Human-friendly name for the tool, used in the UI. If not provided, `name` will be used."),
@@ -573,17 +899,31 @@ const toolDefinitionSchema = z.object({
 	}).optional()
 });
 const positiveTestCaseSchema = z.object({
-	scenario: z.string().describe("Short label for what this case demonstrates."),
-	userPrompt: z.string().describe("A realistic, standalone user message a reviewer can paste and run with no prior state or multi-turn setup. Vary phrasing and tone across cases."),
+	scenario: z.string().min(1).describe("Short label for what this case demonstrates."),
+	userPrompt: z.string().min(1).describe("A realistic, standalone user message a reviewer can paste and run with no prior state or multi-turn setup. Vary phrasing and tone across cases."),
 	toolTriggered: z.string().optional().describe("The tool this prompt should invoke."),
 	expectedOutput: z.string().optional().describe("What the user should see, including post-interaction behaviour where relevant.")
-}).partial().describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
+}).describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
+const positiveTestCaseDraftSchema = positiveTestCaseSchema.partial().extend({
+	scenario: z.string().optional(),
+	userPrompt: z.string().optional()
+});
+const blankPositiveTestCase = () => ({
+	scenario: "",
+	userPrompt: "",
+	toolTriggered: "",
+	expectedOutput: ""
+});
+const toFixedLength = (entries, length, blank) => Array.from({ length }, (_, index) => entries[index] ?? blank());
 const screenshotEntrySchema = z.object({
 	prompt: z.string(),
-	url: z.url().or(z.literal(""))
+	url: z.url()
 }).describe("Each screenshot: the user prompt that produced it + the image URL.");
+const screenshotDraftEntrySchema = screenshotEntrySchema.extend({ url: z.string() });
 /** Accepts either a valid email or URL. */
 const supportChannelSchema = z.string().refine((value) => z.email().safeParse(value).success || z.url().safeParse(value).success, { error: "Must be a valid email or URL" });
+/** A URL field whose error spells out that the scheme is required. */
+const urlField = z.url({ error: "Enter a full URL including https:// (e.g. https://example.com)" });
 const chatgptCategorySchema = z.enum([
 	"BUSINESS",
 	"COLLABORATION",
@@ -887,20 +1227,25 @@ const chatgptTranslationLocaleSchema = z.enum([
 	"zh-TW"
 ]);
 const negativeTestCaseSchema = z.object({
-	scenario: z.string(),
-	userPrompt: z.string()
-}).partial().describe("Each case: Scenario + User prompt (the app should NOT trigger).");
+	scenario: z.string().min(1),
+	userPrompt: z.string().min(1)
+}).describe("Each case: Scenario + User prompt (the plugin should NOT trigger).");
+const negativeTestCaseDraftSchema = negativeTestCaseSchema.partial().extend({
+	scenario: z.string().optional(),
+	userPrompt: z.string().optional()
+});
+const blankNegativeTestCase = () => ({
+	scenario: "",
+	userPrompt: ""
+});
+const chatgptSkillSchema = z.object({ name: z.string() }).describe("A skill discovered on the MCP server, by name.");
 const chatgptToolJustificationSchema = z.object({
 	toolName: z.string(),
 	readOnlyJustification: z.string().describe("One sentence on what the tool reads and returns."),
 	openWorldJustification: z.string().describe("One sentence on whether the tool reaches external systems beyond your own service."),
 	destructiveJustification: z.string().describe("One sentence on whether the tool changes data. For a read-only tool, state the full triad: \"No data is created, modified, or deleted.\"")
 }).describe("Per-tool justification of each MCP annotation value (one specific sentence per hint).");
-/**
-* Base copy fields, defined once and reused by both the submission form and per-locale
-* translations so the constraints (tagline ≤ 30 chars) never drift. The translation generation
-* path wraps these in {@link clampStringField} since the LLM tends to overshoot the limit.
-*/
+/** Defined once and reused by both the submission form and per-locale translations so the tagline ≤ 30 chars constraint never drifts. */
 const chatgptTaglineSchema = z.string().max(30);
 const chatgptDescriptionSchema = z.string();
 const chatgptTranslationSchema = z.object({
@@ -909,52 +1254,73 @@ const chatgptTranslationSchema = z.object({
 	description: chatgptDescriptionSchema
 }).describe("Locale-scoped override for tagline + description. English (US) is the default.");
 chatgptTranslationSchema.extend({ tagline: clampStringField(chatgptTaglineSchema) });
-/**
-* Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section.
-* When adding/removing/reordering fields, keep this in sync with the sheet.
-*/
+/** Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section; keep it in sync with the sheet. */
 const chatgptSubmissionFormDataSchema = z.object({
 	logoLight: z.string().describe("Logo icon for light mode. Square PNG, no borders or rounded corners (clients apply circular cropping)."),
 	logoDark: z.string().optional().describe("Optional dark-mode logo icon. Square PNG, same specs as the light icon. Leave empty if the light icon also works on dark backgrounds."),
-	appName: z.string().describe("The name users will see in ChatGPT and in the Apps Directory."),
+	appName: z.string().describe("The name users will see in ChatGPT and in the Plugin Directory."),
 	tagline: chatgptTaglineSchema.describe("Plain-language phrase focused on function and user value, 30 chars max. Avoid generic superlatives like \"the best …\"."),
-	description: chatgptDescriptionSchema.describe("Clear, engaging description highlighting what the app does and why people will love it. Appears publicly on the directory page. End it by naming the product categories or intents the app does NOT cover, so ChatGPT learns when not to route to it (define exclusions by absent categories or wrong intents, never by naming other brands)."),
+	description: chatgptDescriptionSchema.describe("Clear, engaging description highlighting what the plugin does and why people will love it. Appears publicly on the directory page. End it by naming the product categories or intents the plugin does NOT cover, so ChatGPT learns when not to route to it (define exclusions by absent categories or wrong intents, never by naming other brands)."),
 	category: chatgptCategorySchema.describe("Category from the OpenAI taxonomy."),
-	developerName: z.string().describe("Developer name shown publicly on the app's directory page."),
-	companyUrl: z.url().describe("Your company's main website URL."),
+	developerName: z.string().describe("Developer name shown publicly on the plugin's directory page."),
+	companyUrl: urlField.describe("Your company's main website URL."),
 	supportChannel: supportChannelSchema.describe("Customer support URL or email address."),
-	privacyPolicyUrl: z.url().describe("URL to your privacy policy."),
-	termsOfServiceUrl: z.url().describe("URL to the app's terms of service."),
-	demoRecordingUrl: z.url().describe("URL to a video demonstrating the app, recorded via OpenAI Developer Mode. Cover all main use cases on web, iOS, and Android."),
-	appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My app links or directs users out of ChatGPT to make purchases.' Defaults to false. Verify the app does not offer digital goods."),
-	serverUrl: z.url().describe("URL of the MCP server."),
+	privacyPolicyUrl: urlField.describe("URL to your privacy policy."),
+	termsOfServiceUrl: urlField.describe("URL to the plugin's terms of service."),
+	demoRecordingUrl: urlField.describe("URL to a video demonstrating the plugin, recorded via OpenAI Developer Mode. Cover all main use cases on web, iOS, and Android."),
+	appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My plugin links or directs users out of ChatGPT to make purchases.' Defaults to false. Verify the plugin does not offer digital goods."),
+	serverUrl: urlField.describe("URL of the MCP server."),
 	authentication: chatgptAuthenticationSchema.describe("OAuth 2.0 or No auth. OAuth configuration is auto-discovered from the MCP server's metadata."),
 	tools: z.array(toolDefinitionSchema).describe("List of tools exposed by the MCP server (auto-populated from the production server's manifest)."),
 	toolJustifications: z.array(chatgptToolJustificationSchema).describe("Per-tool justification of `readOnlyHint`, `openWorldHint`, and `destructiveHint` annotation values. One short, specific sentence per hint describing what the tool actually does."),
-	testCases: z.array(positiveTestCaseSchema).describe("At least 5 positive test cases. Each: Scenario, User prompt, Tool triggered, Expected output. Collectively cover the full capability across different flow stages (initial search or browse, market or locale handling, post-interaction detail, an action ChatGPT performs on the user's behalf, and a conversion or secondary tool) rather than five variations of the same first step."),
-	negativeTestCases: z.array(negativeTestCaseSchema).describe("3 negative test cases: prompts where the app should NOT trigger but the model might think it is relevant. These become production routing metadata that teaches ChatGPT when to stay silent, so pick tight near-misses: a product category the app does not carry, the right brand or domain but an intent the app does not serve, or a boundary with a sibling app."),
-	screenshots: z.array(screenshotEntrySchema).max(3).describe("In-app screenshots paired with the user prompt that produced them. Widget apps must show the widget UI; non-widget apps show the model response. Min 1, max 3 entries, all public. Images: 706px wide, 400–860px tall, PNG."),
+	skills: z.array(chatgptSkillSchema).optional().describe("Skills the server exposes over MCP (auto-populated from the production server's manifest). Left unset when the server does not advertise the skills extension, which is a different state from advertising it and exposing none."),
+	testCases: z.array(positiveTestCaseSchema).length(5).describe("Exactly 5 positive test cases. Each: Scenario, User prompt, Tool triggered, Expected output. Collectively cover the full capability across different flow stages (initial search or browse, market or locale handling, post-interaction detail, an action ChatGPT performs on the user's behalf, and a conversion or secondary tool) rather than five variations of the same first step."),
+	negativeTestCases: z.array(negativeTestCaseSchema).length(3).describe("Exactly 3 negative test cases: prompts where the plugin should NOT trigger but the model might think it is relevant. These become production routing metadata that teaches ChatGPT when to stay silent, so pick tight near-misses: a product category the plugin does not carry, the right brand or domain but an intent the plugin does not serve, or a boundary with a sibling plugin."),
+	screenshots: z.array(screenshotEntrySchema.extend({ prompt: z.string().max(75, { error: "Screenshot prompts are limited to 75 characters." }) })).max(3).describe("In-plugin screenshots paired with the user prompt that produced them (each prompt is 75 characters max). Widget plugins must show the widget UI; non-widget plugins show the model response. Min 1, max 3 entries, all public. Images: 706px wide, 400–860px tall, PNG."),
 	translations: z.array(chatgptTranslationSchema).describe("Per-locale translation of tagline + description. English (US) is the default."),
 	allowedCountries: chatgptAllowedCountriesSchema.describe("Availability: all supported countries, or an allow-list / block-list of specific ones (ISO alpha-2)."),
-	releaseNotes: z.string().describe("Publicly displayed on the app details page.")
+	releaseNotes: z.string().describe("Publicly displayed on the plugin details page.")
 });
-chatgptSubmissionFormDataSchema.pick({
+const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().extend({
+	tagline: z.string().optional(),
+	companyUrl: z.string().optional(),
+	supportChannel: z.string().optional(),
+	privacyPolicyUrl: z.string().optional(),
+	termsOfServiceUrl: z.string().optional(),
+	demoRecordingUrl: z.string().optional(),
+	serverUrl: z.string().optional(),
+	screenshots: z.array(screenshotDraftEntrySchema).optional(),
+	testCases: z.array(positiveTestCaseDraftSchema).optional(),
+	negativeTestCases: z.array(negativeTestCaseDraftSchema).optional(),
+	translations: z.array(chatgptTranslationSchema.extend({ tagline: z.string() })).optional()
+});
+/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "chatgpt" })` can populate. */
+const chatgptPrefillFormDataSchema = chatgptSubmissionFormDataSchema.pick({
 	appName: true,
 	developerName: true,
 	serverUrl: true,
 	tools: true,
+	skills: true,
 	authentication: true
 });
-chatgptSubmissionFormDataSchema.pick({
+/** Source of truth for `SubmissionPrefillService.generate({ platform: "chatgpt" })`. */
+const chatgptAiGeneratedFormDataSchema = chatgptSubmissionFormDataSchema.pick({
 	tagline: true,
 	description: true,
 	category: true,
 	testCases: true,
 	negativeTestCases: true,
 	toolJustifications: true
-}).extend({ tagline: clampStringField(chatgptSubmissionFormDataSchema.shape.tagline) });
+}).extend({
+	testCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.testCases),
+	negativeTestCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.negativeTestCases)
+}).extend({
+	tagline: clampStringField(chatgptSubmissionFormDataSchema.shape.tagline),
+	testCases: z.array(positiveTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 5, blankPositiveTestCase)),
+	negativeTestCases: z.array(negativeTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 3, blankNegativeTestCase))
+});
 const claudeCategorySchema = z.enum([
-	"Business & Productivity",
+	"Productivity",
 	"Communication",
 	"Data & Analytics",
 	"Development tools",
@@ -962,222 +1328,222 @@ const claudeCategorySchema = z.enum([
 	"Consumer Health",
 	"Health & Life Sciences",
 	"Media & Entertainment",
-	"Commerce & Shopping"
+	"Commerce & Shopping",
+	"Legal",
+	"Sales and marketing",
+	"Creative",
+	"Nonprofit",
+	"Education",
+	"Other"
 ]);
-const claudeAuthenticationSchema = z.enum([
-	"No auth needed",
-	"OAuth 2.0",
-	"Custom URL"
-]);
-const claudeMcpUrlTypeSchema = z.enum(["Universal URL", "Custom MCP URLs"]);
-z.enum(["Static OAuth Client", "Dynamic OAuth Client (DCR / CIMD)"]);
+const claudeCategoryDescription = `The categories used to filter connectors in the directory UI. Select up to 5 that best describe your connector.`;
 const claudeReadWriteCapabilitiesSchema = z.enum([
-	"Read Only",
-	"Write Only",
-	"Read + Write"
-]);
-const claudeTransportSchema = z.enum(["Streamable HTTP", "SSE"]);
-const claudeTestedSurfaceSchema = z.enum([
-	"Claude.ai (web)",
-	"Claude Desktop",
-	"Claude Code",
-	"Cowork"
+	"read_only",
+	"write_only",
+	"read_write"
 ]);
-const claudeThirdPartySchema = z.enum([
-	"Web access: Fetches information from the open web (e.g., web scraping, search engines, or browsing arbitrary URLs, not just connecting to a specific API)",
-	"Third-party AI model integration: Sends data to or receives data from a generative AI model other than Claude",
-	"Third-party data retrieval: Connects to external services that themselves retrieve data from other sources (e.g., workflow automation platforms or other services that aggregate or relay data from multiple third-party sources)",
-	"Third-party data modification: Can connect to external services that themselves create, update, or delete data in other sources (e.g., workflow automation platforms or other services that write to multiple third-party sources)",
-	"N/A"
+const claudeAuthenticationSchema = z.enum([
+	"oauth_dcr",
+	"oauth_cimd",
+	"oauth_anthropic_creds",
+	"custom_connection",
+	"none"
 ]);
-const claudeDataHandlingSchema = z.enum([
-	"Server only accesses data explicitly requested by user",
-	"No data is stored beyond session requirements",
-	"Data transmission is encrypted (HTTPS/TLS)",
-	"GDPR compliant (if applicable)"
+const claudeApiOwnershipSchema = z.enum([
+	"first_party",
+	"proxied",
+	"third_party"
 ]);
-const claudeSponsoredContentSchema = z.enum([
-	"No, there is no sponsored content or advertisements",
-	"Yes, there are banner ads or other paid visual elements",
-	"Yes, the returned content or ranking of returned content is impacted by sponsorship or ad placement"
+const claudeYesNoOtherSchema = z.union([z.boolean(), z.object({ other: z.string() })]);
+const claudePolicyAcknowledgementSchema = z.enum([
+	"I have read and understand the MCP Directory developer guidelines.",
+	"My server calls our own first-party APIs (or APIs we legitimately proxy with permission).",
+	"My connector does not transfer money, cryptocurrency, or other financial assets on a user's behalf.",
+	"My connector does not use AI models to generate images, video, or audio.",
+	"Tool descriptions contain no instructions about model behavior, other tools, or external instruction sources, and no hidden or encoded text.",
+	"My connector does not collect conversation data beyond what is needed for its function.",
+	"Public documentation for this connector will be live by the publish date."
 ]);
-/**
-* Field order mirrors the Claude (Anthropic) submission spreadsheet, grouped by section.
-* When adding/removing/reordering fields, keep this in sync with the sheet.
-*/
+/** Field order mirrors the claude.ai directory submission wizard (`claude.ai/admin-settings/directory/submissions/new`), grouped by step; keep it in sync with the wizard. */
 const claudeSubmissionFormDataSchema = z.object({
-	companyName: z.string().describe("Enter your company's legal name or the name under which your product is publicly known. This is used for internal tracking and may appear in directory listings."),
-	companyUrl: z.url().describe("Your company's main website URL, e.g. https://mycompany.com. Must be a valid URL with https://. This should be the root domain of the company behind this MCP server."),
-	primaryContactName: z.string().describe("Full name of the person Anthropic should contact about this submission. This person will receive review feedback, approval notices, and any follow-up questions."),
-	primaryContactEmail: z.email().describe("Business email for the primary contact. Must be a valid email address. Anthropic uses this to communicate about your submission status, required changes, and post-listing issues. Avoid using personal email addresses."),
-	primaryContactRole: z.string().optional().describe("The job title or role of the primary contact (e.g. 'CTO', 'Developer Relations Lead', 'Founder'). Optional but helps Anthropic route questions to the right person."),
-	anthropicPointOfContact: z.string().optional().describe("If you have a direct contact at Anthropic (e.g. from a partnership or sales conversation), enter their name here. This is optional but can greatly help expedite the review process. Leave blank if you don't have one."),
-	appName: z.string().describe(`The public display name for your connector as it will appear in the Connectors Directory.
-
-Rules:
-(1) Do NOT include the words 'MCP' or 'Server' — these are auto-rejected.
-(2) Use your brand/product name, e.g. 'Notion', 'Linear', 'Slack'.
-(3) You must own or have the right to use this brand name. For example, don't call it 'Google Drive Helper' if you're not Google.`),
-	mcpUrlType: claudeMcpUrlTypeSchema.describe(`Choose how your server URL works:
-• 'Universal URL': one single URL that all users connect to (most common). Example: https://mcp.myapp.com
-• 'Custom MCP URLs': each user gets their own unique URL (e.g. based on their workspace or instance). 
-If you choose this, you'll need to provide both a signup URL and a regex pattern that matches valid server URLs for your service.`),
-	serverUrl: z.url().describe(`If 'Universal URL': enter the full https:// URL where your MCP server is hosted and reachable. Example: https://mcp.myapp.com/
-If 'Custom MCP URLs': provide (1) the signup/onboarding URL where users create an account, and (2) a regex pattern that matches all valid server URLs for your service (e.g. https://[a-z0-9-]+\\.myapp\\.com/mcp). The server must be publicly accessible without VPN or whitelisting required.`),
-	tagline: z.string().max(55).describe(`A very short, punchy description shown below your server name in the directory listing. Max 55 characters including spaces.
-Think of it as a subtitle or elevator pitch fragment. Example: 'Manage tasks and projects in Linear' or 'Search and read your Notion workspace'. Avoid generic phrases like 'The best MCP server for...'`),
-	description: z.string().describe(`A 50–100 word description of what your MCP server does. This appears in the connector's detail page inside Claude. Write it from a user perspective: what can users do with this connector? What are the key features/tools? Avoid marketing fluff. Be specific. Example: 'Connect Claude to your Linear workspace. Create and update issues, search projects, manage teams, and track engineering cycles, all from within Claude.' Anthropic reviewers check this for accuracy against your actual tools.`),
-	testCases: z.array(positiveTestCaseSchema).describe(`Provide at least 3 concrete use cases, each with an example prompt a user could type to Claude. These are critical: Anthropic reviewers literally test your server using these prompts. Good examples are specific and demonstrate real value. 
-Best format: [Use case]: [exact prompt]"
-Example for a task manager:
-1. Create a task: 'Create a task called Review Q3 report, due Friday, assigned to Alice'
-2. Search tasks: 'Show me all open bugs in the Mobile project'
-3. Update status: 'Mark the Deploy v2.1 task as done'"`),
-	connectionRequirements: z.string().describe(`Describe any prerequisites a user must have before they can connect your server. Be exhaustive. Examples of things to mention:
-• Account type required (free vs paid plan)
-• Admin permissions or specific roles needed
-• Geographic restrictions (e.g. 'US only' or 'Not available in EU')
-• If users need to provide their own server URL or instance domain
-• Any setup steps needed before connecting (e.g. 'Enable API access in your account settings')
-If there are genuinely no special requirements, write exactly: 'No special requirements.'`),
-	readWriteCapabilities: claudeReadWriteCapabilitiesSchema.describe(`Select the option that best describes what your server can do:
-
-'Read Only': your tools only fetch/retrieve data (GET operations). Claude cannot modify anything via your server.
-'Write Only': your tools only create/update/delete data (rare).
-'Read + Write': your tools can both retrieve AND modify data (most common for full-featured connectors).
-
-Note: Anthropic rejects catch-all tools that accept both safe (GET) and unsafe (POST, PUT, DELETE) HTTP methods via a parameter e.g. a single api_request(method, endpoint) tool. Each tool should have a fixed, specific purpose. `),
-	isMcpApp: z.boolean().describe(`Select 'Yes' if your MCP server renders interactive UI elements (aka widgets or views) inside the Claude conversation.
-Select 'No' if your server only returns text/data responses.
-If 'Yes', you will also be required to provide screenshots of your UI (see Promotional Images section). MCP Apps are displayed with a special badge in the directory.`),
-	thirdPartyConnectionsAndWebAccess: z.array(claudeThirdPartySchema).describe(`Multi-select all that apply to your server's behavior:
-• 'Web access' — your server fetches arbitrary URLs, scrapes websites, or makes open-ended HTTP requests to the web (not just your own API).
-• 'Third-party AI model integration' — your server calls another AI model (e.g. OpenAI, Gemini, Cohere) as part of its processing.
-• 'Third-party data retrieval' — your server retrieves data via a workflow or aggregator platform (e.g. Zapier, Make, n8n) rather than calling your own API directly.
-• 'Third-party data modification' — your server modifies data via such a platform.
-• 'N/A' — your server only calls your own first-party API and does nothing else. Select this only if none of the above apply.`),
-	dataHandling: z.array(claudeDataHandlingSchema).describe(`Multi-select all data handling practices that accurately apply to your server. You must select at least 3. Key points:
-• 'Server only accesses data explicitly requested by user' — your server doesn't silently read unrelated user data.
-• 'No data is stored beyond session requirements' — you don't log or retain conversation data after the session.
-• 'Data transmission is encrypted (HTTPS/TLS)' — all data in transit is encrypted. This should always apply for remote servers.
-• 'GDPR compliant' — if you operate in the EU or serve EU users, check this only if you are genuinely compliant. Don't check it without having proper data processing agreements and procedures in place.
-Note: These are attestations — you are legally agreeing to these practices by submitting the form.`),
-	personalDataHealthAccess: z.boolean().describe(`Select 'Yes' ONLY if your connector gives users access to their own personal health information — such as medical records, lab results, diagnoses, prescriptions, wearable health metrics (heart rate, sleep data, etc.), or mental health data.
-Select 'No' for the vast majority of business/productivity/dev tools. When in doubt, select 'No'. This field triggers additional compliance review if 'Yes'.`),
-	category: claudeCategorySchema.describe(`Select the category that best describes your connector. This determines where it appears in the directory's browse experience. Choose the most specific fit:
-• Business & Productivity — project management, CRM, HR, office tools
-• Communication — email, chat, messaging, notifications
-• Data & Analytics — dashboards, reporting, databases, BI tools
-• Development tools — code repositories, CI/CD, issue trackers, monitoring
-• Financial Services — accounting, invoicing, fintech (note: financial transaction execution is not permitted)
-• Consumer Health — fitness, wellness, personal health tracking
-• Health & Life Sciences — clinical, pharma, medical professional tools
-• Media & Entertainment — content, publishing, streaming
-• Commerce & Shopping — e-commerce, inventory, orders
-Anthropic's submission form only accepts a single category.`),
-	sponsoredContentsOrAdvertisement: claudeSponsoredContentSchema.describe(`Be honest here — advertising is not permitted in the Connectors Directory per Anthropic's policy. Select the option that accurately describes your server:
-• 'No, there is no sponsored content or advertisements' — the results your server returns are not influenced by paid placement or sponsorship. This is what almost all connectors should select.
-• 'Yes, there are banner ads or other paid visual elements' — your UI includes visual ads. NOTE: this will likely lead to rejection, as Anthropic prohibits advertising in Claude.
-• 'Yes, the returned content or ranking of returned content is impacted by sponsorship or ad placement' — paid results affect what you return. NOTE: this also likely leads to rejection.
-If your server returns organic results from a platform that has ads in its own UI (but your API results are not affected by ads), select 'No'.`),
-	authentication: claudeAuthenticationSchema.describe("How users authenticate with the server. No auth / OAuth 2.0 / Custom URL (not supported)."),
-	transportSupport: z.array(claudeTransportSchema).describe(`Select all transport protocols your server supports:
-• 'Streamable HTTP' — the modern, recommended transport. Anthropic strongly recommends implementing this. This is the future-proof option and should be your default.
-• 'SSE (Server-Sent Events)' — the older transport. SSE may be deprecated by Anthropic later in 2025/2026. If you currently only support SSE, you should plan to migrate to Streamable HTTP.
-If you support both, select both. If you're building from scratch, implement Streamable HTTP only.`),
-	serverDocumentationLink: z.url().describe(`A public URL pointing to documentation that helps users understand and use your connector. This is displayed in the Directory listing and must be publicly accessible without login. Minimum requirements for the docs page:
-• What the connector does and its key capabilities
-• How to connect/set it up (step by step)
-• What each tool does (or at least the main ones)
-• How to troubleshoot common issues
-• A support contact or channel
-Acceptable formats: a dedicated docs page, a help center article, a README on GitHub, or a blog post — as long as it's comprehensive. Note: Anthropic requires public documentation to be live by your publish date.`),
-	privacyPolicyUrl: z.url().describe(`URL to your privacy policy. This is mandatory and displayed in the directory listing. Missing or incomplete privacy policies result in immediate rejection. Your privacy policy must cover:
-• What data you collect (and how)
-• How you use the collected data
-• Where and how long you store it
-• Whether you share data with third parties (and who)
-• How users can contact you about data concerns
-The policy must be publicly accessible. If you don't have one yet, create one before submitting — there are free generators online, but make sure it accurately reflects your actual practices. If you're GDPR-compliant, your policy should reflect that.`),
-	supportChannel: supportChannelSchema.describe(`A URL or email address where users can get help with your connector. This is displayed in the Directory listing. Acceptable options:
-• Email address (e.g. support@myapp.com)
-• Link to a GitHub Issues page
-• Link to a help center or support article
-• Link to a Discord/Slack community
-• Link to your documentation's troubleshooting section
-Also uses this to notify you of security or compliance issues, so make sure it's actively monitored.`),
-	testingCredentials: z.string().describe(`Provide login credentials for a test account that Anthropic reviewers can use to verify your server works end-to-end. Critical requirements:
-• The account must have sample/demo data loaded — reviewers need to actually test your tools with real data.
-• No 2FA — reviewers can't receive SMS codes. Disable 2FA on this account.
-• If your service uses Google OAuth or another OAuth that requires email verification, use mcp-review@anthropic.com as the account email — Anthropic has access to this inbox.
-• Credentials must remain valid for at least 30 days from submission.
-• If your service requires API keys instead of a password, provide those.
-Format suggestion: Username/email: xxx | Password: xxx | Any other notes`),
-	tools: z.array(toolDefinitionSchema).describe(`A comma-separated list of all tools your MCP server exposes. Use the format: tool_name (Human-Readable Name). The tool_name is the internal identifier (snake_case, max 64 characters). The Human-Readable Name is what users see.
-Example: list_issues (List Issues), create_issue (Create Issue), update_issue (Update Issue), delete_issue (Delete Issue), search_issues (Search Issues)
-Reviewers test every single tool you list here — don't list tools that don't work. Also: do not have a single catch-all tool like api_request(method, endpoint) — Anthropic rejects these. Each action should be its own purpose-built tool.`),
-	toolTitlesAnnotationsConfirmed: z.boolean().describe(`This is a compliance confirmation — check both boxes only if you have actually implemented these in your server code:
-• 'I've specified user-friendly titles for all tools' — every tool has a 'title' annotation (a human-readable label, different from the tool name).
-• 'I've specified accurate tool annotations for all tools' — every tool has the correct annotation: readOnlyHint: true for read operations (search, get, list, fetch), OR destructiveHint: true for write operations (create, update, delete, send).
-This is the #1 reason submissions get rejected (30% of all rejections). Do not check these boxes without actually having implemented the annotations. See MCP spec for how to add them.`),
-	testedSurfaces: z.array(claudeTestedSurfaceSchema).describe(`Confirm testing is complete and your server works as intended in these surfaces. Select every surface you've verified. Claude.ai (web) and Claude Desktop are the usual targets for remote MCP servers; Claude Code and Cowork compatibility is not required. Anthropic requires at least two surfaces.`),
-	logoLight: z.string().describe(`Your connector's logo for light backgrounds. Requirements:
-• Format: SVG only
-• Aspect ratio: square (1:1)
-• Should work on a light background
-• Provide via URL (Google Drive link is fine) or upload directly
-Tip: use a simple, recognizable icon — not a full wordmark. The logo appears at small sizes in the directory grid.`),
-	logoDark: z.string().optional().describe(`Optional dark-mode variant of the connector logo. Same specs as the light variant (SVG, square 1:1) but designed to read on a dark background. Leave empty if the light logo already works on dark.`),
-	screenshots: z.array(screenshotEntrySchema).describe(`Screenshots or promotional images of your connector in action within Claude. Strongly recommended for all connectors, and required for MCP Apps (interactive UI). Guidelines:
-• 3–5 images is ideal
-• Minimum 1000px width, PNG format preferred
-• Each screenshot is paired with the user prompt that produced it
-• Crop to just the relevant part of the Claude interface (the tool response area)
-• Show your connector doing something impressive and useful — real data, real results
-• If you're an MCP App, include screenshots of your interactive UI elements
-These images appear in your directory listing and are a key factor in driving user installs.`)
-});
-claudeSubmissionFormDataSchema.pick({
-	companyName: true,
-	appName: true,
-	mcpUrlType: true,
+	serverUrl: z.url().describe(`The full https:// URL where your MCP server is hosted and reachable. In the claude.ai wizard this is read live
+from the custom connector you select — the connection is used to verify the URL and the tool list at submission time.
+The server must be publicly accessible without VPN or whitelisting.`),
+	name: z.string().max(100).describe(`The public display name for your connector as it appears in the directory. Use your brand/product name. You must
+own or have the right to use this name. Max 100 characters.`),
+	slug: z.string().max(50).regex(/^[a-z0-9-]+$/).describe(`URL-safe identifier for your connector's directory page. Lowercase letters, numbers, and hyphens only.
+PERMANENT after submission — it cannot be changed. Pre-filled from the name. Max 50 characters.`),
+	oneLiner: z.string().max(200).describe(`A short tagline shown below your connector name in the directory listing. Max 200 characters. Avoid generic
+phrases like 'The best MCP server for...'. Example: 'Manage tasks and projects in Linear'.`),
+	description: z.string().max(2e3).describe(`A description of what your connector does and its key features, shown on the connector's detail page in
+claude.ai. Write it from a user perspective and be specific. Max 2000 characters.`),
+	categories: z.array(claudeCategorySchema).max(5).describe(claudeCategoryDescription),
+	iconUrl: z.url().optional().describe(`Optional custom icon for the directory listing — a square SVG. By default the favicon from your MCP URL is used
+(recommended); upload a custom icon only to override it.`),
+	documentation: z.url().describe(`A public URL pointing to documentation that helps users understand and use your connector. Must be publicly
+accessible without login. IT admins often review these when deciding whether to approve a server. Required to be live
+by your publish date.`),
+	support: supportChannelSchema.describe(`A support URL or email address where users can get help with your connector. Displayed in the directory listing and
+used to notify you of security or compliance issues, so make sure it's actively monitored.`),
+	privacyPolicy: z.url().describe(`URL to your privacy policy. Mandatory and displayed in the directory listing. Must be publicly accessible and cover
+what data you collect, how you use and store it, and whether you share it with third parties.`),
+	screenshots: z.array(screenshotEntrySchema).optional().describe(`Carousel images shown on your connector's directory page (PNG). Each is paired with the user prompt that produced
+it. This is editable on the directory page only after the connector is submitted — optional here so you can prepare it.`),
+	primaryUseCases: z.string().describe(`Describe the main tasks users will accomplish with this connector, and include a few example prompts a user might
+type. These may be shown publicly but are primarily used for internal review — reviewers test your server using them.`),
+	connectionRequirements: z.string().describe(`What accounts, permissions, or setup a user needs before connecting (e.g. 'Requires a paid Acme account with admin
+permissions'). If there are genuinely no special requirements, say so explicitly.`),
+	readWriteCapabilities: claudeReadWriteCapabilitiesSchema.describe(`What your server can do:
+• 'read_only': retrieves data but never modifies it.
+• 'write_only': creates or modifies data but does not read it.
+• 'read_write': both retrieves and modifies data (most common).`),
+	companyName: z.string().describe("The company or organization behind this connector — its legal name or publicly known product name."),
+	companyWebsite: z.url().describe("The company's main website URL, e.g. https://example.com."),
+	primaryContactName: z.string().describe("Full name of the person Anthropic should contact about this submission. Receives review feedback and follow-up questions."),
+	primaryContactEmail: z.email().describe("Email for the primary contact (pre-filled from the Claude account). Anthropic uses this to communicate about your submission."),
+	primaryContactRole: z.string().optional().describe("The primary contact's role at the company (e.g. 'Engineer', 'Product Manager'). Optional."),
+	anthropicPointOfContact: z.string().optional().describe("If you've been working with someone at Anthropic, their name or email. Optional, can expedite review."),
+	authentication: claudeAuthenticationSchema.describe(`How users authenticate with your server:
+• 'oauth_dcr': OAuth 2.0 + Dynamic Client Registration (RFC 7591) — clients register themselves.
+• 'oauth_cimd': OAuth 2.0 + Client ID Metadata Document — a published client_id metadata document.
+• 'oauth_anthropic_creds': OAuth 2.0 with Anthropic-held client credentials (a static client_id, and secret if needed).
+• 'custom_connection': users supply their own URL or client details at connection time (e.g. Snowflake).
+• 'none': no authentication (authless) — anyone can connect and call tools without credentials.`),
+	partialAuth: z.boolean().optional().describe("Whether some tools return 401 and prompt for auth on demand while the server otherwise starts authless (partial auth)."),
+	apiOwnership: claudeApiOwnershipSchema.describe(`How your connector relates to the API it calls:
+• 'first_party': the MCP server calls your own production APIs.
+• 'proxied': calls go to a third-party API you're authorized to integrate (e.g. a Zapier-style integration).
+• 'third_party': calls a third-party API you don't control — typically blocks listing; explain in 'additionalNotes'.`),
+	personalHealthData: claudeYesNoOtherSchema.describe(`Whether this connector accesses, processes, or stores personal health information.
+No → false, Yes → true, or { other: explanation } when it depends on configuration.`),
+	sponsoredContent: claudeYesNoOtherSchema.describe(`Whether this connector surfaces sponsored, promoted, or advertising content (prohibited in directory connectors).
+No → false, Yes → true, or { other: explanation }.`),
+	testInstructions: z.string().optional().describe(`Clear test-account setup and access instructions for reviewers: every link, credential, and step needed to access
+the MCP server autonomously. For accounts that need to be populated, provide test credentials granting access to a
+fully populated account.`),
+	selfTested: z.boolean().optional().describe("Confirmation that you have run every tool via MCP Inspector or as a custom connector in Claude."),
+	policyAcknowledgements: z.array(claudePolicyAcknowledgementSchema).describe(`Anthropic directory policy acknowledgements. All items must be acknowledged before the claude.ai wizard allows
+submission. Each is an attestation you are legally agreeing to by submitting.`),
+	additionalNotes: z.string().optional().describe("Anything else the review team should know about your connector. Optional.")
+});
+const claudeSubmissionDraftSchema = claudeSubmissionFormDataSchema.partial().extend({
+	serverUrl: z.string().optional(),
+	name: z.string().optional(),
+	slug: z.string().optional(),
+	oneLiner: z.string().optional(),
+	description: z.string().optional(),
+	iconUrl: z.string().optional(),
+	documentation: z.string().optional(),
+	support: z.string().optional(),
+	privacyPolicy: z.string().optional(),
+	companyWebsite: z.string().optional(),
+	primaryContactEmail: z.string().optional(),
+	categories: z.array(claudeCategorySchema).optional(),
+	screenshots: z.array(screenshotDraftEntrySchema).optional()
+});
+/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "claudeai" })` can populate. */
+const claudePrefillFormDataSchema = claudeSubmissionFormDataSchema.pick({
 	serverUrl: true,
-	tools: true,
-	readWriteCapabilities: true,
-	isMcpApp: true,
-	transportSupport: true,
+	name: true,
+	slug: true,
+	companyName: true,
 	primaryContactEmail: true,
 	primaryContactName: true,
+	readWriteCapabilities: true,
 	authentication: true,
-	personalDataHealthAccess: true,
-	testedSurfaces: true
+	apiOwnership: true,
+	personalHealthData: true
 }).extend({
 	connectionRequirements: claudeSubmissionFormDataSchema.shape.connectionRequirements.optional(),
-	testingCredentials: claudeSubmissionFormDataSchema.shape.testingCredentials.optional()
+	testInstructions: claudeSubmissionFormDataSchema.shape.testInstructions.optional()
+});
+/** Loose shape returned by AI generation for Claude narrative fields; transforms live here so generation leniency stays colocated with the Claude contract. */
+const claudeAiGeneratedFormDataRawSchema = z.object({
+	oneLiner: claudeSubmissionFormDataSchema.shape.oneLiner,
+	description: claudeSubmissionFormDataSchema.shape.description,
+	categories: z.array(claudeCategorySchema).describe(claudeCategoryDescription),
+	primaryUseCases: claudeSubmissionFormDataSchema.shape.primaryUseCases
+});
+const claudeAiGeneratedFormDataSchema = claudeAiGeneratedFormDataRawSchema.extend({
+	oneLiner: clampStringField(claudeSubmissionFormDataSchema.shape.oneLiner),
+	categories: claudeAiGeneratedFormDataRawSchema.shape.categories.transform((categories) => categories.slice(0, 5))
+});
+function provenanceByField(prefillShape, aiGeneratedShape) {
+	const byField = {};
+	for (const field of Object.keys(prefillShape)) byField[field] = "prefilled";
+	for (const field of Object.keys(aiGeneratedShape)) byField[field] = "ai-generated";
+	return byField;
+}
+provenanceByField(claudePrefillFormDataSchema.shape, claudeAiGeneratedFormDataSchema.shape), provenanceByField(chatgptPrefillFormDataSchema.shape, chatgptAiGeneratedFormDataSchema.shape);
+const urlVerificationOutcomeSchema = z.enum([
+	"pass",
+	"fail",
+	"unverified"
+]);
+const VERIFIABLE_URL_FIELDS = {
+	chatgpt: ["privacyPolicyUrl", "termsOfServiceUrl"],
+	claudeai: ["privacyPolicy"]
+};
+const verifiableUrlFieldSchema = z.enum([...VERIFIABLE_URL_FIELDS.chatgpt, ...VERIFIABLE_URL_FIELDS.claudeai]);
+const policyDisclosureSchema = z.enum([
+	"dataCategories",
+	"purposesOfUse",
+	"recipients",
+	"retention"
+]);
+const urlVerificationFieldResultSchema = z.object({
+	field: verifiableUrlFieldSchema,
+	url: z.string(),
+	outcome: urlVerificationOutcomeSchema,
+	reason: z.string(),
+	concerns: z.array(z.string()).optional(),
+	scrapedWith: z.enum(["fetch", "firecrawl"]).optional()
+});
+const urlVerificationSchema = z.object({
+	verifiedAt: z.coerce.date(),
+	results: z.array(urlVerificationFieldResultSchema)
+});
+const pageKindSchema = z.enum([
+	"expectedDocument",
+	"errorPage",
+	"loginWall",
+	"parkedDomain",
+	"comingSoon",
+	"marketingPage",
+	"unrelatedDocument"
+]);
+z.object({
+	pageKind: pageKindSchema.describe("What the page actually is. Use 'expectedDocument' only when it is genuinely the document the field claims."),
+	reason: z.string().max(200).describe("One sentence naming what the page is, addressed to the developer who entered the URL."),
+	missingDisclosures: z.array(policyDisclosureSchema).describe("For a privacy policy only: which of the four required disclosures the text does not cover. Empty for every other page kind.")
 });
-claudeSubmissionFormDataSchema.pick({
-	tagline: true,
-	description: true,
-	category: true,
-	testCases: true
-}).extend({ tagline: clampStringField(claudeSubmissionFormDataSchema.shape.tagline) });
 const submissionMetaFieldsSchema = z.object({
 	id: z.string(),
 	environmentId: z.string(),
 	auditId: z.string().nullable(),
+	urlVerification: urlVerificationSchema.nullable().default(null),
 	createdAt: z.coerce.date(),
 	updatedAt: z.coerce.date()
 });
 const claudeSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
 	platform: z.literal("claudeai"),
-	formData: claudeSubmissionFormDataSchema.partial()
+	formData: claudeSubmissionDraftSchema,
+	prefillSnapshot: claudeSubmissionDraftSchema.nullable().default(null)
 });
 const chatgptSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
 	platform: z.literal("chatgpt"),
-	formData: chatgptSubmissionFormDataSchema.partial()
+	formData: chatgptSubmissionDraftSchema,
+	prefillSnapshot: chatgptSubmissionDraftSchema.nullable().default(null)
 });
-z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
-z.union([claudeSubmissionFormDataSchema.partial(), chatgptSubmissionFormDataSchema.partial()]);
+const submissionSchemaInternal = z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
+z.union([claudeSubmissionDraftSchema, chatgptSubmissionDraftSchema]);
+/** Discriminated on `platform`, which pins the shape of `formData`: a Claude submission cannot carry chatgpt-only fields, and vice-versa. */
+const submissionSchema = submissionSchemaInternal;
+z.literal([
+	100,
+	75,
+	50
+]);
 const subscriptionPlanSchema = z.enum([
 	"pro",
 	"business",
@@ -1189,17 +1555,83 @@ const customerCreditsSchema = z.object({
 	expiresAt: z.number().nullable(),
 	currency: z.string()
 });
-const customerUsageSchema = z.object({
-	amountInCents: z.number(),
-	currency: z.string(),
-	periodEnd: z.number()
-});
 const partnerDiscountSchema = z.object({ endsAt: z.number() });
 z.object({
 	customerCredits: customerCreditsSchema.nullable(),
-	customerUsage: customerUsageSchema.nullable(),
 	partnerDiscount: partnerDiscountSchema.nullable()
 });
+const metricsQueueEventSchema = z.object({
+	ts: z.number().int(),
+	method: z.string(),
+	tool: z.string().nullable(),
+	client: z.string(),
+	sessionId: z.string().nullable(),
+	durationMs: z.number().int(),
+	outputTokens: z.number().int().nullable(),
+	errorType: z.enum([
+		"mcp_error",
+		"tool_error",
+		"timeout"
+	]).nullable(),
+	errorCode: z.number().int().nullable()
+});
+z.object({
+	v: z.literal(1),
+	envId: z.string(),
+	events: z.array(metricsQueueEventSchema)
+});
+z.object({ v: z.number() });
+const TELEMETRY_SIGNALS = [
+	"logs",
+	"metrics",
+	"traces"
+];
+const telemetrySignalSchema = z.enum(TELEMETRY_SIGNALS);
+const OTLP_PROTOCOLS = ["http/protobuf", "http/json"];
+const otlpProtocolSchema = z.enum(OTLP_PROTOCOLS);
+const otlpEndpointSchema = z.string().trim().min(1).max(2048);
+const OTLP_HEADER_VALUE_MAX_LENGTH = 2048;
+const otlpHeaderNameSchema = z.string().trim().min(1, "Enter a header name").max(128).regex(/^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/, "Use letters, digits and !#$%&'*+-.^_`|~ only");
+const otlpHeaderValueSchema = z.string().trim().max(OTLP_HEADER_VALUE_MAX_LENGTH).refine((value) => !/[\r\n]/.test(value), "Line breaks are not allowed in a header value");
+const telemetryDestinationHeaderSchema = z.object({
+	id: z.string(),
+	name: otlpHeaderNameSchema,
+	value: otlpHeaderValueSchema,
+	isSecret: z.boolean()
+});
+const otlpPushFailureReasonSchema = z.enum([
+	"credentials",
+	"wrong-path",
+	"wrong-protocol",
+	"invalid-payload",
+	"partial-rejection",
+	"blocked-target",
+	"timeout",
+	"unreachable",
+	"receiver-error",
+	"unexpected-status"
+]);
+const telemetryDestinationStatusSchema = z.enum(["active", "suspended"]);
+z.object({
+	id: z.string(),
+	signal: telemetrySignalSchema,
+	endpoint: otlpEndpointSchema,
+	protocol: otlpProtocolSchema,
+	headers: z.array(telemetryDestinationHeaderSchema),
+	status: telemetryDestinationStatusSchema,
+	lastFailureReason: otlpPushFailureReasonSchema.nullable(),
+	isScopedToIntentionalRequestsOnly: z.boolean()
+});
+const hasDuplicateHeaderNames = (headers) => {
+	const names = headers.map(({ name }) => name.trim().toLowerCase());
+	return new Set(names).size !== names.length;
+};
+//#endregion
+//#region src/auth-scope.ts
+/** Accepts an API key or OAuth access token (default for most routes). */
+const AUTH_SCOPE_ANY = "any";
+/** Requires a user OAuth access token; API keys are not accepted. */
+const AUTH_SCOPE_USER = "user";
 //#endregion
 //#region src/schemas.ts
 const RESERVED_KEYS = [
@@ -1236,7 +1668,10 @@ const RESERVED_KEYS = [
 	"BUILD_ARG_START_COMMAND",
 	"ALPIC_HOST",
 	"ALPIC_CUSTOM_DOMAINS",
-	"ALPIC_INTENT_META_KEY"
+	"ALPIC_INTENT_META_KEY",
+	"ALPIC_FEEDBACK_META_KEY",
+	"ALPIC_EVENTS_META_KEY",
+	"ALPIC_IDENTIFY_META_KEY"
 ];
 const environmentVariableSchema = z.object({
 	key: z.string().min(2, "Key must be at least 2 characters").regex(/^[a-zA-Z]([a-zA-Z0-9_])+$/, "Key must start with a letter and contain only letters, numbers, and underscores").refine((key) => !RESERVED_KEYS.includes(key), "This key is reserved and cannot be used as an environment variable key"),
@@ -1289,6 +1724,14 @@ const serverFieldsSchema = z.object({
 });
 //#endregion
 //#region src/api.contract.ts
+const isValidIanaTimeZone = (timeZone) => {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone });
+		return true;
+	} catch {
+		return false;
+	}
+};
 const deploymentStatusSchema = z.enum([
 	"ongoing",
 	"deployed",
@@ -1317,21 +1760,20 @@ const deploymentSchema = z.object({
 	isCurrent: z.boolean(),
 	deploymentPageUrl: z.url().nullable()
 });
-const isValidLogTimeInput = (value) => {
+const isValidTimeInput = (value) => {
 	if (ms(value) !== void 0) return true;
 	return !Number.isNaN(new Date(value).getTime());
 };
-const createEnvironmentContractV1 = oc.route({
+const timeInputSchema = z.string().refine(isValidTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." });
+const base = oc.errors({ BAD_REQUEST: {} });
+const createEnvironmentContractV1 = base.route({
 	path: "/v1/environments",
 	method: "POST",
 	summary: "Create an environment",
 	description: "Create an environment for a project",
 	tags: ["environments"],
 	successDescription: "The environment has been created successfully"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	projectId: z.string().describe("The ID of the project to create the environment for"),
 	name: z.string().min(1).describe("The name of the environment"),
 	sourceBranch: z.string().min(1).describe("The branch used to build the environment"),
@@ -1344,7 +1786,7 @@ const createEnvironmentContractV1 = oc.route({
 	createdAt: z.coerce.date(),
 	projectId: z.string().describe("The ID of the project the environment belongs to")
 }));
-const getEnvironmentContractV1 = oc.route({
+const getEnvironmentContractV1 = base.route({
 	path: "/v1/environments/{environmentId}",
 	method: "GET",
 	summary: "Get an environment",
@@ -1360,6 +1802,14 @@ const getEnvironmentContractV1 = oc.route({
 	createdAt: z.coerce.date(),
 	projectId: z.string()
 }));
+const deleteEnvironmentContractV1 = base.route({
+	path: "/v1/environments/{environmentId}",
+	method: "DELETE",
+	summary: "Delete an environment",
+	description: "All environments can be deleted except the production environment. This operation is not reversible: associated logs, analytics, and metrics are deleted as well.",
+	tags: ["environments"],
+	successDescription: "The environment has been deleted successfully"
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.object({ success: z.literal(true) }));
 const domainSchema = z.object({
 	domain: z.string(),
 	status: z.enum([
@@ -1401,7 +1851,7 @@ const projectOutputSchema = z.object({
 	productionEnvironment: productionEnvironmentSchema.nullable(),
 	environments: z.array(environmentSchema)
 });
-const getProjectContractV1 = oc.route({
+const getProjectContractV1 = base.route({
 	path: "/v1/projects/{projectId}",
 	method: "GET",
 	summary: "Get a project",
@@ -1409,18 +1859,15 @@ const getProjectContractV1 = oc.route({
 	tags: ["projects"],
 	successDescription: "The project details"
 }).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(projectOutputSchema);
-const listProjectsContractV1 = oc.route({
+const listProjectsContractV1 = base.route({
 	path: "/v1/projects",
 	method: "GET",
 	summary: "List projects",
 	description: "List all projects for a team",
 	tags: ["projects"],
 	successDescription: "The list of projects"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
-const createProjectContractV1 = oc.route({
+}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
+const createProjectContractV1 = base.route({
 	path: "/v1/projects",
 	method: "POST",
 	summary: "Create a project",
@@ -1429,7 +1876,7 @@ const createProjectContractV1 = oc.route({
 	successDescription: "The project has been created successfully"
 }).errors({
 	NOT_FOUND: {},
-	BAD_REQUEST: {}
+	FORBIDDEN: {}
 }).input(z.object({
 	teamId: z.string().optional(),
 	name: z.string().trim().min(1).max(100),
@@ -1469,7 +1916,97 @@ const environmentVariableOutputSchema = z.object({
 	isSecret: z.boolean(),
 	createdAt: z.coerce.date()
 });
-const listEnvironmentVariablesContractV1 = oc.route({
+const telemetryDestinationHeaderOutputSchema = z.discriminatedUnion("isSecret", [z.object({
+	id: z.string(),
+	name: otlpHeaderNameSchema,
+	value: z.null(),
+	isSecret: z.literal(true)
+}), z.object({
+	id: z.string(),
+	name: otlpHeaderNameSchema,
+	value: otlpHeaderValueSchema,
+	isSecret: z.literal(false)
+})]);
+const telemetryDestinationOutputSchema = z.object({
+	id: z.string(),
+	signal: telemetrySignalSchema,
+	endpoint: otlpEndpointSchema,
+	protocol: otlpProtocolSchema,
+	headers: z.array(telemetryDestinationHeaderOutputSchema),
+	status: telemetryDestinationStatusSchema,
+	lastFailureReason: otlpPushFailureReasonSchema.nullable(),
+	isScopedToIntentionalRequestsOnly: z.boolean()
+});
+const createTelemetryDestinationHeaderInputSchema = z.object({
+	name: otlpHeaderNameSchema,
+	value: otlpHeaderValueSchema.min(1, "Enter a header value"),
+	isSecret: z.boolean()
+});
+const updateTelemetryDestinationHeaderInputSchema = z.object({
+	id: z.string().optional(),
+	name: otlpHeaderNameSchema,
+	value: otlpHeaderValueSchema.optional(),
+	isSecret: z.boolean()
+});
+const uniqueTelemetryHeaders = (headers) => !hasDuplicateHeaderNames(headers);
+const listTelemetryDestinationsContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/telemetry-destinations",
+	method: "GET",
+	summary: "List telemetry destinations",
+	description: "List the OTLP destinations configured for an environment. Secret header values are never returned.",
+	tags: ["telemetry"],
+	successDescription: "The list of telemetry destinations"
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(telemetryDestinationOutputSchema));
+const createTelemetryDestinationContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/telemetry-destinations",
+	method: "POST",
+	summary: "Create a telemetry destination",
+	description: "Verify and save an OTLP destination for logs, metrics, or traces.",
+	tags: ["telemetry"],
+	successDescription: "The telemetry destination has been created"
+}).errors({
+	NOT_FOUND: {},
+	FORBIDDEN: {},
+	OTLP_DESTINATION_UNVERIFIED: { status: 400 }
+}).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	signal: telemetrySignalSchema,
+	endpoint: otlpEndpointSchema,
+	protocol: otlpProtocolSchema.default("http/protobuf"),
+	isScopedToIntentionalRequestsOnly: z.boolean().default(false),
+	headers: z.array(createTelemetryDestinationHeaderInputSchema).default([]).refine(uniqueTelemetryHeaders, "Header names must be unique")
+})).output(telemetryDestinationOutputSchema);
+const updateTelemetryDestinationContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/telemetry-destinations/{destinationId}",
+	method: "PATCH",
+	summary: "Update a telemetry destination",
+	description: "Verify and save changes to an OTLP destination. Omit headers to keep them unchanged; omit the value of an existing header to preserve it. A secret header value must be re-entered when the endpoint changes.",
+	tags: ["telemetry"],
+	successDescription: "The telemetry destination has been updated"
+}).errors({
+	NOT_FOUND: {},
+	FORBIDDEN: {},
+	OTLP_DESTINATION_UNVERIFIED: { status: 400 }
+}).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	destinationId: z.string().describe("The ID of the telemetry destination"),
+	endpoint: otlpEndpointSchema.optional(),
+	protocol: otlpProtocolSchema.optional(),
+	isScopedToIntentionalRequestsOnly: z.boolean().optional(),
+	headers: z.array(updateTelemetryDestinationHeaderInputSchema).refine(uniqueTelemetryHeaders, "Header names must be unique").optional()
+})).output(telemetryDestinationOutputSchema);
+const deleteTelemetryDestinationContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/telemetry-destinations/{destinationId}",
+	method: "DELETE",
+	summary: "Delete a telemetry destination",
+	description: "Delete an OTLP destination from an environment.",
+	tags: ["telemetry"],
+	successDescription: "The telemetry destination has been deleted"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	destinationId: z.string().describe("The ID of the telemetry destination")
+})).output(z.object({ success: z.literal(true) }));
+const listEnvironmentVariablesContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/environment-variables",
 	method: "GET",
 	summary: "List environment variables",
@@ -1477,48 +2014,39 @@ const listEnvironmentVariablesContractV1 = oc.route({
 	tags: ["environments"],
 	successDescription: "The list of environment variables"
 }).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(environmentVariableOutputSchema));
-const createEnvironmentVariablesContractV1 = oc.route({
+const createEnvironmentVariablesContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/environment-variables",
 	method: "POST",
 	summary: "Add environment variables",
 	description: "Add one or more environment variables to an environment",
 	tags: ["environments"],
 	successDescription: "The environment variables have been added successfully"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	environmentId: z.string().describe("The ID of the environment"),
 	environmentVariables: environmentVariablesSchema
 })).output(z.object({ success: z.literal(true) }));
-const updateEnvironmentVariableContractV1 = oc.route({
+const updateEnvironmentVariableContractV1 = base.route({
 	path: "/v1/environment-variables/{environmentVariableId}",
 	method: "PATCH",
 	summary: "Update an environment variable",
 	description: "Update an environment variable by ID",
 	tags: ["environments"],
 	successDescription: "The environment variable has been updated successfully"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	environmentVariableId: z.string().describe("The ID of the environment variable"),
 	key: environmentVariableSchema.shape.key,
 	value: environmentVariableSchema.shape.value.optional(),
 	isSecret: environmentVariableSchema.shape.isSecret.optional()
 })).output(z.object({ success: z.literal(true) }));
-const deleteEnvironmentVariableContractV1 = oc.route({
+const deleteEnvironmentVariableContractV1 = base.route({
 	path: "/v1/environment-variables/{environmentVariableId}",
 	method: "DELETE",
 	summary: "Delete an environment variable",
 	description: "Delete an environment variable by ID",
 	tags: ["environments"],
 	successDescription: "The environment variable has been deleted successfully"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
-const deleteProjectContractV1 = oc.route({
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
+const deleteProjectContractV1 = base.route({
 	path: "/v1/projects/{projectId}",
 	method: "DELETE",
 	summary: "Delete a project",
@@ -1526,7 +2054,7 @@ const deleteProjectContractV1 = oc.route({
 	tags: ["projects"],
 	successDescription: "The project has been deleted successfully"
 }).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.object({ success: z.literal(true) }));
-const updateProjectContractV1 = oc.route({
+const updateProjectContractV1 = base.route({
 	path: "/v1/projects/{projectId}",
 	method: "PATCH",
 	summary: "Update a project",
@@ -1535,13 +2063,13 @@ const updateProjectContractV1 = oc.route({
 	successDescription: "The project has been updated successfully"
 }).errors({
 	NOT_FOUND: {},
-	BAD_REQUEST: {}
+	FORBIDDEN: {}
 }).input(z.object({
 	projectId: z.string().describe("The ID of the project"),
 	name: z.string().min(1).max(100).optional().describe("The new name for the project"),
 	sourceRepository: z.string().nullable().optional().describe("The source repository to connect to the project")
 })).output(projectOutputSchema);
-const deployEnvironmentContractV1 = oc.route({
+const deployEnvironmentContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/deploy",
 	method: "POST",
 	summary: "Deploy an environment",
@@ -1550,27 +2078,25 @@ const deployEnvironmentContractV1 = oc.route({
 	successDescription: "The environment has been deployed successfully"
 }).errors({
 	NOT_FOUND: {},
-	BAD_REQUEST: {}
+	CONFLICT: {}
 }).input(z.object({
 	environmentId: z.string().describe("The ID of the environment to deploy"),
-	token: z.string().describe("The token to identify the source archive").optional()
+	token: z.string().describe("The token to identify the source archive").optional(),
+	settings: buildSettingsSchema.extend({ transport: transportSchema }).optional().describe("Project settings detected by the client from the source. When provided, the server skips downloading and extracting the source archive to detect them.")
 })).output(deploymentSchema);
-const uploadDeploymentArtifactContractV1 = oc.route({
+const uploadDeploymentArtifactContractV1 = base.route({
 	path: "/v1/deployments/upload",
 	method: "POST",
 	summary: "Upload deployment artifacts",
 	description: "Return a presigned S3 URL to upload a deployment artifact",
 	tags: ["deployments"],
 	successDescription: "The presigned upload URL has been generated successfully"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
 	uploadUrl: z.url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
 	token: z.string().describe("Token to identify the source archive"),
 	expiresAt: z.coerce.date().describe("Expiration date of the presigned URL")
 }));
-const listDeploymentsContractV1 = oc.route({
+const listDeploymentsContractV1 = base.route({
 	path: "/v1/projects/{projectId}/deployments",
 	method: "GET",
 	summary: "List project deployments",
@@ -1582,7 +2108,7 @@ const listDeploymentsContractV1 = oc.route({
 	status: z.array(deploymentStatusSchema).optional().describe("Filter by one or more statuses"),
 	environmentId: z.string().optional().describe("Filter by environment ID")
 })).output(z.array(deploymentSchema));
-const getDeploymentContractV1 = oc.route({
+const getDeploymentContractV1 = base.route({
 	path: "/v1/deployments/{deploymentId}",
 	method: "GET",
 	summary: "Get a deployment",
@@ -1590,20 +2116,32 @@ const getDeploymentContractV1 = oc.route({
 	tags: ["deployments"],
 	successDescription: "The deployment details"
 }).errors({ NOT_FOUND: {} }).input(z.object({ deploymentId: z.string().describe("The ID of the deployment") })).output(deploymentSchema);
-const getLogsContractV1 = oc.route({
+const logEntrySchema = z.object({
+	timestamp: z.coerce.date(),
+	type: z.enum([
+		"START",
+		"END",
+		"INFO",
+		"ERROR",
+		"WARNING",
+		"DEBUG"
+	]),
+	requestId: z.string(),
+	content: z.string().optional(),
+	method: z.string().optional(),
+	durationInMs: z.number().optional()
+});
+const getLogsContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/logs",
 	method: "GET",
 	summary: "Get logs",
 	description: "Get logs for an environment",
 	tags: ["environments"],
 	successDescription: "The logs"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	environmentId: z.string().describe("The ID of the environment"),
-	since: z.string().refine(isValidLogTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." }).optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
-	until: z.string().refine(isValidLogTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." }).optional().describe("End time — ISO 8601 or relative"),
+	since: timeInputSchema.optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
+	until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
 	limit: z.coerce.number().int().min(1).max(1e3).default(1e3).describe("Maximum number of log entries to return."),
 	level: z.array(z.enum([
 		"INFO",
@@ -1611,37 +2149,20 @@ const getLogsContractV1 = oc.route({
 		"WARNING",
 		"DEBUG"
 	])).optional().describe("Filter by log level"),
-	search: z.string().optional().describe("Filter pattern to search for in log content"),
+	search: logSearchSchema.optional().describe("Term to search for in log content"),
 	nextToken: z.string().optional().describe("Pagination token from a previous response")
 })).output(z.object({
-	logs: z.array(z.object({
-		timestamp: z.coerce.date(),
-		type: z.enum([
-			"START",
-			"END",
-			"INFO",
-			"ERROR",
-			"WARNING",
-			"DEBUG"
-		]),
-		requestId: z.string(),
-		content: z.string().optional(),
-		method: z.string().optional(),
-		durationInMs: z.number().optional()
-	})),
+	logs: z.array(logEntrySchema),
 	nextToken: z.string().nullable()
 }));
-const getLatestLogsContractV1 = oc.route({
+const getLatestLogsContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/latest-logs",
 	method: "GET",
 	summary: "Get latest logs",
 	description: "Get the N most recent logs for an environment",
 	tags: ["environments"],
 	successDescription: "The latest logs"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	environmentId: z.string().describe("The ID of the environment"),
 	limit: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of most recent log entries to return"),
 	level: z.array(z.enum([
@@ -1650,23 +2171,9 @@ const getLatestLogsContractV1 = oc.route({
 		"WARNING",
 		"DEBUG"
 	])).optional().describe("Filter by log level"),
-	search: z.string().optional().describe("Filter pattern to search for in log content")
-})).output(z.object({ logs: z.array(z.object({
-	timestamp: z.coerce.date(),
-	type: z.enum([
-		"START",
-		"END",
-		"INFO",
-		"ERROR",
-		"WARNING",
-		"DEBUG"
-	]),
-	requestId: z.string(),
-	content: z.string().optional(),
-	method: z.string().optional(),
-	durationInMs: z.number().optional()
-})) }));
-const getDeploymentLogsContractV1 = oc.route({
+	search: logSearchSchema.optional().describe("Term to search for in log content")
+})).output(z.object({ logs: z.array(logEntrySchema) }));
+const getDeploymentLogsContractV1 = base.route({
 	path: "/v1/deployments/{deploymentId}/logs",
 	method: "GET",
 	summary: "Get deployment logs",
@@ -1693,22 +2200,19 @@ const analyticsTimeSeriesSchema = z.object({
 	output_token_mean: z.array(analyticsDataPointSchema),
 	task_count: z.array(analyticsDataPointSchema)
 });
-const getProjectAnalyticsContractV1 = oc.route({
+const getProjectAnalyticsContractV1 = base.route({
 	path: "/v1/analytics/{projectId}",
 	method: "GET",
 	summary: "Get project analytics",
 	description: "Get analytics data for a project over a time range",
 	tags: ["analytics"],
 	successDescription: "The project analytics data"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	projectId: z.string().describe("The ID of the project"),
 	startTimestamp: z.coerce.number().describe("Start timestamp in milliseconds"),
 	endTimestamp: z.coerce.number().describe("End timestamp in milliseconds"),
 	timeZone: z.string().describe("IANA timezone (e.g. Europe/Paris)")
-}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <= 744 * 60 * 60 * 1e3, { message: "Date range must be less than 1 month" }).refine(({ timeZone }) => Intl.supportedValuesOf("timeZone").includes(timeZone), { message: "Time zone must be a valid IANA timezone" })).output(z.object({
+}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <= 26784e5, { message: "Date range must be less than 1 month" }).refine(({ timeZone }) => isValidIanaTimeZone(timeZone), { message: "Time zone must be a valid IANA timezone" })).output(z.object({
 	metadata: z.object({
 		startTimestamp: z.number(),
 		endTimestamp: z.number(),
@@ -1718,7 +2222,132 @@ const getProjectAnalyticsContractV1 = oc.route({
 	}),
 	timeSeries: analyticsTimeSeriesSchema
 }));
-const listTeamsContractV1 = oc.route({
+const paginatedInsightsInputShape = {
+	environmentId: z.string().describe("The ID of the environment"),
+	since: timeInputSchema.default("7d").describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
+	until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
+	limit: z.coerce.number().int().min(1).max(200).default(50),
+	offset: z.coerce.number().int().min(0).default(0),
+	search: z.string().trim().min(1).max(200).optional()
+};
+const listIntentsContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intents",
+	method: "GET",
+	summary: "List intents",
+	description: "List grouped user intents for an environment over a time range",
+	tags: ["insights"],
+	successDescription: "The grouped user intents"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	...paginatedInsightsInputShape,
+	tools: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
+	clientIds: z.array(z.string().min(1)).min(1).max(100).optional(),
+	categoryIds: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
+	sortDir: z.enum(["asc", "desc"]).default("desc")
+})).output(z.object({
+	intents: z.array(z.object({
+		id: z.string(),
+		intentIds: z.array(z.string()).min(1),
+		environmentId: z.string(),
+		message: z.string(),
+		toolName: z.string(),
+		createdAt: z.coerce.date(),
+		occurrenceCount: z.number().int().positive(),
+		clientName: z.string().nullable(),
+		clientId: z.string().nullable(),
+		categories: z.array(z.object({
+			id: z.string(),
+			name: z.string(),
+			color: intentCategoryColorSchema
+		}))
+	})),
+	totalCount: z.number().int().nonnegative()
+}));
+const listFeedbacksContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/feedbacks",
+	method: "GET",
+	summary: "List feedbacks",
+	description: "List user feedback for an environment over a time range",
+	tags: ["insights"],
+	successDescription: "The user feedback"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	...paginatedInsightsInputShape,
+	clientIds: z.array(z.string().min(1)).min(1).max(100).optional()
+})).output(z.object({
+	feedbacks: z.array(feedbackSchema.extend({ clientId: z.string().nullable() })),
+	totalCount: z.number().int().nonnegative()
+}));
+const intentCategoryNameSchema = z.string().trim().min(1).max(100).describe("The category name");
+const categorizableIntentIdsSchema = z.array(z.string().trim().min(1)).min(1).max(100).describe("IDs of the intents to categorize");
+const listIntentCategoriesContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intent-categories",
+	method: "GET",
+	summary: "List intent categories",
+	description: "List intent categories for an environment, including how many intents each category is linked to",
+	tags: ["insights"],
+	successDescription: "The intent categories"
+}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(intentCategorySummarySchema));
+const createIntentCategoryContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intent-categories",
+	method: "POST",
+	summary: "Create an intent category",
+	description: "Create an intent category, optionally linking it to existing intents",
+	tags: ["insights"],
+	successDescription: "The created intent category"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	name: intentCategoryNameSchema,
+	color: intentCategoryColorSchema.optional().describe("The category color; derived from the name when omitted"),
+	intentIds: categorizableIntentIdsSchema.optional().describe("IDs of intents to link to the new category")
+})).output(intentCategorySchema);
+const updateIntentCategoryContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
+	method: "PATCH",
+	summary: "Update an intent category",
+	description: "Rename or recolor an intent category",
+	tags: ["insights"],
+	successDescription: "The updated intent category"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	categoryId: z.string().describe("The ID of the category"),
+	name: intentCategoryNameSchema.optional(),
+	color: intentCategoryColorSchema.optional().describe("The category color")
+}).refine(({ name, color }) => name !== void 0 || color !== void 0, { message: "At least one of name or color must be provided" })).output(intentCategorySchema);
+const deleteIntentCategoryContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
+	method: "DELETE",
+	summary: "Delete an intent category",
+	description: "Delete an intent category; its intents are unlinked but not deleted",
+	tags: ["insights"],
+	successDescription: "The intent category has been deleted successfully"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	categoryId: z.string().describe("The ID of the category")
+})).output(z.object({ success: z.literal(true) }));
+const linkIntentCategoryContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/link",
+	method: "POST",
+	summary: "Link an intent category",
+	description: "Link an intent category to intents; already linked intents are ignored",
+	tags: ["insights"],
+	successDescription: "The intents have been linked successfully"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	categoryId: z.string().describe("The ID of the category"),
+	intentIds: categorizableIntentIdsSchema
+})).output(z.object({ success: z.literal(true) }));
+const unlinkIntentCategoryContractV1 = base.route({
+	path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/unlink",
+	method: "POST",
+	summary: "Unlink an intent category",
+	description: "Unlink an intent category from intents; intents without the category are ignored",
+	tags: ["insights"],
+	successDescription: "The intents have been unlinked successfully"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment"),
+	categoryId: z.string().describe("The ID of the category"),
+	intentIds: categorizableIntentIdsSchema
+})).output(z.object({ success: z.literal(true) }));
+const listTeamsContractV1 = base.route({
 	path: "/v1/teams",
 	method: "GET",
 	summary: "List teams",
@@ -1731,28 +2360,40 @@ const listTeamsContractV1 = oc.route({
 	createdAt: z.coerce.date(),
 	hasStripeAccount: z.boolean()
 })));
-const getTunnelTicketContractV1 = oc.route({
+const getTeamUsageContractV1 = base.route({
+	path: "/v1/teams/{teamId}/usage",
+	method: "GET",
+	summary: "Get team usage",
+	description: "Get the MCP request usage of a team for its current billing window. A team that has made no request in the window reports zero.",
+	tags: ["teams"],
+	successDescription: "The current billing window usage"
+}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().describe("The ID of the team") })).output(z.object({
+	teamId: z.string(),
+	plan: subscriptionPlanSchema.nullable().describe("The plan in force for the window, null on the Free plan"),
+	periodStart: z.coerce.date().describe("Start of the current billing window"),
+	periodEnd: z.coerce.date().describe("End of the current billing window"),
+	requestCount: z.number().int().describe("MCP requests settled during the current billing window"),
+	includedRequests: z.number().int().nullable().describe("Requests included in the plan for one window, null when the allowance is contract-specific")
+}));
+const getTunnelTicketContractV1 = base.route({
 	path: "/v1/tunnels/ticket",
 	method: "GET",
 	summary: "Get a tunnel ticket",
 	description: "Get a signed ticket for establishing a tunnel connection. Requires user authentication (API keys are not supported).",
 	tags: ["tunnels"],
 	successDescription: "The tunnel ticket"
-}).errors({ FORBIDDEN: {} }).output(z.object({
+}).meta({ authScope: AUTH_SCOPE_USER }).errors({ FORBIDDEN: {} }).output(z.object({
 	subdomain: z.string().describe("The subdomain assigned to the user"),
 	ticket: z.string().describe("The signed tunnel ticket"),
 	tunnelHost: z.string().describe("The tunnel host to connect to")
 }));
-const publishServerContractV1 = oc.route({
+const publishServerContractV1 = base.route({
 	path: "/v1/distribution/publish",
 	method: "POST",
 	summary: "Publish a server to the MCP registry",
 	tags: ["distribution"],
 	successDescription: "The server has been published successfully"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	projectId: z.string(),
 	domain: z.string(),
 	title: z.string().min(1).max(100),
@@ -1761,17 +2402,14 @@ const publishServerContractV1 = oc.route({
 	iconSrc: z.url().max(255).optional(),
 	dryRun: z.boolean().optional()
 })).output(z.object({ serverFields: serverFieldsSchema }));
-const getServerInfoContractV1 = oc.route({
+const getServerInfoContractV1 = base.route({
 	path: "/v1/distribution/get",
 	method: "GET",
 	summary: "Get server info",
 	description: "Get info about a server",
 	tags: ["distribution"],
 	successDescription: "The server info"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	projectId: z.string(),
 	domain: z.string()
 })).output(z.object({ serverFields: serverFieldsSchema }));
@@ -1790,7 +2428,7 @@ const playgroundOutputSchema = z.object({
 	isPlaygroundEnabled: z.boolean(),
 	serverMetadata: playgroundServerMetadataOutputSchema.nullable()
 });
-const getPlaygroundContractV1 = oc.route({
+const getPlaygroundContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/playground",
 	method: "GET",
 	summary: "Get playground configuration",
@@ -1798,17 +2436,14 @@ const getPlaygroundContractV1 = oc.route({
 	tags: ["environments"],
 	successDescription: "The playground configuration"
 }).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(playgroundOutputSchema);
-const upsertPlaygroundContractV1 = oc.route({
+const upsertPlaygroundContractV1 = base.route({
 	path: "/v1/environments/{environmentId}/playground",
 	method: "PUT",
 	summary: "Update playground configuration",
 	description: "Update the playground configuration for an environment. All fields are optional — only provided fields are updated.",
 	tags: ["environments"],
 	successDescription: "The updated playground configuration"
-}).errors({
-	NOT_FOUND: {},
-	BAD_REQUEST: {}
-}).input(z.object({
+}).errors({ NOT_FOUND: {} }).input(z.object({
 	environmentId: z.string().describe("The ID of the environment"),
 	isPlaygroundEnabled: z.boolean().optional(),
 	name: z.string().min(1).max(100).optional(),
@@ -1816,7 +2451,7 @@ const upsertPlaygroundContractV1 = oc.route({
 	headers: z.array(playgroundHeaderSchema).optional(),
 	examplePrompts: z.array(playgroundExamplePromptSchema).max(5).optional()
 })).output(playgroundOutputSchema);
-const createBeaconContractV1 = oc.route({
+const createBeaconContractV1 = base.route({
 	path: "/v1/beacon/audits",
 	method: "POST",
 	summary: "Create a beacon audit",
@@ -1825,7 +2460,6 @@ const createBeaconContractV1 = oc.route({
 	successDescription: "The audit has been created"
 }).errors({
 	NOT_FOUND: {},
-	BAD_REQUEST: {},
 	DNS_RESOLUTION_FAILED: { status: 400 }
 }).input(z.object({
 	targetUrl: z.url().describe("The HTTPS URL of the MCP server to audit"),
@@ -1833,7 +2467,7 @@ const createBeaconContractV1 = oc.route({
 	projectId: z.string().optional().describe("The project ID to associate the audit with"),
 	excludeCategories: z.array(checkCategorySchema).optional().describe("Check categories to exclude from the audit")
 })).output(z.object({ id: z.string() }));
-const getBeaconContractV1 = oc.route({
+const getBeaconContractV1 = base.route({
 	path: "/v1/beacon/audits/{auditId}",
 	method: "GET",
 	summary: "Get a beacon audit",
@@ -1848,9 +2482,73 @@ const getBeaconContractV1 = oc.route({
 	createdAt: z.coerce.date(),
 	report: auditReportWithScreenshotsSchema.nullable()
 }));
+const PLATFORM_DESCRIPTION = "The directory the package targets: `chatgpt` for the OpenAI App Directory, `claudeai` for the Anthropic MCP Directory";
+const submissionIdSchema = z.string().describe("The ID of the submission package");
+const claudeSubmissionUpdateSchema = claudeSubmissionDraftSchema.strict();
+const chatgptSubmissionUpdateSchema = chatgptSubmissionDraftSchema.strict();
+const createSubmissionContractV1 = base.route({
+	path: "/v1/submissions",
+	method: "POST",
+	summary: "Create a submission package",
+	description: "Create a submission package for an environment. Alpic reads the environment's live MCP server and prefills every field it can infer, so the response already carries the populated package. The environment must have a successful deployment and must not require authentication.",
+	tags: ["submissions"],
+	successDescription: "The created submission package, with its prefilled fields"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	environmentId: z.string().describe("The ID of the environment to build the package from"),
+	platform: platformSchema.describe(PLATFORM_DESCRIPTION)
+})).output(submissionSchema);
+const listSubmissionsContractV1 = base.route({
+	path: "/v1/projects/{projectId}/submissions",
+	method: "GET",
+	summary: "List submission packages",
+	description: "List the submission packages of a project, grouped by directory and most recently updated first, optionally narrowed to one environment or one directory",
+	tags: ["submissions"],
+	successDescription: "The list of submission packages"
+}).errors({ NOT_FOUND: {} }).input(z.object({
+	projectId: z.string().describe("The ID of the project"),
+	environmentId: z.string().optional().describe("Filter by environment ID"),
+	platform: platformSchema.optional().describe(PLATFORM_DESCRIPTION)
+})).output(z.array(submissionSchema));
+const getSubmissionContractV1 = base.route({
+	path: "/v1/submissions/{submissionId}",
+	method: "GET",
+	summary: "Get a submission package",
+	description: "Get a submission package by ID, including its form data and the prefill it started from",
+	tags: ["submissions"],
+	successDescription: "The submission package"
+}).errors({ NOT_FOUND: {} }).input(z.object({ submissionId: submissionIdSchema })).output(submissionSchema);
+const updateSubmissionContractV1 = base.route({
+	path: "/v1/submissions/{submissionId}",
+	method: "PUT",
+	summary: "Update a submission package",
+	description: "Update the form data of a submission package. Only the fields you send are changed; the rest are left as they are. Unknown field names are rejected rather than ignored, so a typo fails the call. `platform` must match the package's own platform.",
+	tags: ["submissions"],
+	successDescription: "The updated submission package"
+}).errors({ NOT_FOUND: {} }).input(z.discriminatedUnion("platform", [z.object({
+	submissionId: submissionIdSchema,
+	platform: z.literal("claudeai").describe(PLATFORM_DESCRIPTION),
+	formData: claudeSubmissionUpdateSchema
+}), z.object({
+	submissionId: submissionIdSchema,
+	platform: z.literal("chatgpt").describe(PLATFORM_DESCRIPTION),
+	formData: chatgptSubmissionUpdateSchema
+})])).output(submissionSchema);
 const contract = {
-	teams: { list: { v1: listTeamsContractV1 } },
+	teams: {
+		list: { v1: listTeamsContractV1 },
+		getUsage: { v1: getTeamUsageContractV1 }
+	},
 	analytics: { get: { v1: getProjectAnalyticsContractV1 } },
+	intents: { list: { v1: listIntentsContractV1 } },
+	intentCategories: {
+		list: { v1: listIntentCategoriesContractV1 },
+		create: { v1: createIntentCategoryContractV1 },
+		update: { v1: updateIntentCategoryContractV1 },
+		delete: { v1: deleteIntentCategoryContractV1 },
+		link: { v1: linkIntentCategoryContractV1 },
+		unlink: { v1: unlinkIntentCategoryContractV1 }
+	},
+	feedbacks: { list: { v1: listFeedbacksContractV1 } },
 	deployments: {
 		list: { v1: listDeploymentsContractV1 },
 		get: { v1: getDeploymentContractV1 },
@@ -1860,6 +2558,7 @@ const contract = {
 	environments: {
 		create: { v1: createEnvironmentContractV1 },
 		get: { v1: getEnvironmentContractV1 },
+		delete: { v1: deleteEnvironmentContractV1 },
 		deploy: { v1: deployEnvironmentContractV1 },
 		getLogs: { v1: getLogsContractV1 },
 		getLatestLogs: { v1: getLatestLogsContractV1 }
@@ -1870,6 +2569,12 @@ const contract = {
 		update: { v1: updateEnvironmentVariableContractV1 },
 		delete: { v1: deleteEnvironmentVariableContractV1 }
 	},
+	telemetryDestinations: {
+		list: { v1: listTelemetryDestinationsContractV1 },
+		create: { v1: createTelemetryDestinationContractV1 },
+		update: { v1: updateTelemetryDestinationContractV1 },
+		delete: { v1: deleteTelemetryDestinationContractV1 }
+	},
 	projects: {
 		update: { v1: updateProjectContractV1 },
 		get: { v1: getProjectContractV1 },
@@ -1889,7 +2594,39 @@ const contract = {
 	beacon: {
 		create: { v1: createBeaconContractV1 },
 		get: { v1: getBeaconContractV1 }
+	},
+	submissions: {
+		create: { v1: createSubmissionContractV1 },
+		list: { v1: listSubmissionsContractV1 },
+		get: { v1: getSubmissionContractV1 },
+		update: { v1: updateSubmissionContractV1 }
+	}
+};
+const { uploadArtifact: _discard, ...deploymentsForDocs } = contract.deployments;
+const contractForDocs = {
+	...contract,
+	deployments: deploymentsForDocs
+};
+/** Shared by the served `openapi.json` and the snapshot test that guards it, so the two cannot drift. */
+const OPENAPI_DOC_OPTIONS = {
+	info: {
+		title: "Alpic API",
+		version: "1.0.0"
+	},
+	servers: [{ url: "https://api.alpic.ai" }],
+	security: [{ bearerAuth: [] }],
+	components: { securitySchemes: { bearerAuth: {
+		type: "http",
+		description: "Bearer token for authentication. Use an API key from the API Keys page in team settings, or an OAuth access token.",
+		scheme: "bearer"
+	} } },
+	commonSchemas: {
+		Submission: { schema: submissionSchema },
+		ClaudeSubmissionFormData: { schema: claudeSubmissionDraftSchema },
+		ChatgptSubmissionFormData: { schema: chatgptSubmissionDraftSchema },
+		ClaudeSubmissionFormDataUpdate: { schema: claudeSubmissionUpdateSchema },
+		ChatgptSubmissionFormDataUpdate: { schema: chatgptSubmissionUpdateSchema }
 	}
 };
 //#endregion
-export { PLATFORM_LABELS, buildSettingsSchema, contract, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
+export { AI_PLATFORMS, AUTH_SCOPE_ANY, AUTH_SCOPE_USER, INTENT_CATEGORY_COLORS, OPENAPI_DOC_OPTIONS, OTLP_PROTOCOLS, PLATFORM_LABELS, TELEMETRY_SIGNALS, buildSettingsSchema, chatgptSubmissionUpdateSchema, claudeSubmissionUpdateSchema, contract, contractForDocs, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, intentCategoryColorSchema, otlpProtocolSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, telemetrySignalSchema, transportSchema, updateEnvironmentVariableSchema };