@alpic-ai/api 0.0.0-staging.ge5d5ea3 → 0.0.0-staging.ge61c07a
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +6298 -84
- package/dist/index.mjs +1045 -404
- package/package.json +26 -10
package/dist/index.mjs
CHANGED
|
@@ -2,7 +2,7 @@ import { z } from "zod";
|
|
|
2
2
|
import * as z$1 from "zod/v4";
|
|
3
3
|
import { oc } from "@orpc/contract";
|
|
4
4
|
import ms from "ms";
|
|
5
|
-
//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.
|
|
5
|
+
//#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
|
|
6
6
|
/**
|
|
7
7
|
* Reusable URL validation that disallows javascript: scheme
|
|
8
8
|
*/
|
|
@@ -119,7 +119,12 @@ z$1.object({
|
|
|
119
119
|
token_type: z$1.string(),
|
|
120
120
|
expires_in: z$1.coerce.number().optional(),
|
|
121
121
|
scope: z$1.string().optional(),
|
|
122
|
-
refresh_token: z$1.string().optional()
|
|
122
|
+
refresh_token: z$1.string().optional(),
|
|
123
|
+
/**
|
|
124
|
+
* Not part of the wire format: the authorization server this value was obtained from, added by
|
|
125
|
+
* the client's `auth()` before it is stored and compared when it is read back.
|
|
126
|
+
*/
|
|
127
|
+
issuer: z$1.string().optional().catch(void 0)
|
|
123
128
|
}).strip();
|
|
124
129
|
z$1.object({
|
|
125
130
|
error: z$1.string(),
|
|
@@ -158,7 +163,12 @@ const OAuthClientInformationSchema = z$1.object({
|
|
|
158
163
|
client_id: z$1.string(),
|
|
159
164
|
client_secret: z$1.string().optional(),
|
|
160
165
|
client_id_issued_at: z$1.number().optional(),
|
|
161
|
-
client_secret_expires_at: z$1.number().optional()
|
|
166
|
+
client_secret_expires_at: z$1.number().optional(),
|
|
167
|
+
/**
|
|
168
|
+
* Not part of the wire format: the authorization server this value was obtained from, added by
|
|
169
|
+
* the client's `auth()` before it is stored and compared when it is read back.
|
|
170
|
+
*/
|
|
171
|
+
issuer: z$1.string().optional().catch(void 0)
|
|
162
172
|
}).strip();
|
|
163
173
|
OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
|
|
164
174
|
z$1.object({
|
|
@@ -169,11 +179,22 @@ z$1.object({
|
|
|
169
179
|
token: z$1.string(),
|
|
170
180
|
token_type_hint: z$1.string().optional()
|
|
171
181
|
}).strip();
|
|
172
|
-
|
|
182
|
+
//#endregion
|
|
183
|
+
//#region ../domains/dist/index.mjs
|
|
184
|
+
const AI_PLATFORMS = ["chatgpt", "claudeai"];
|
|
185
|
+
const platformSchema = z.enum(AI_PLATFORMS);
|
|
173
186
|
const PLATFORM_LABELS = {
|
|
174
187
|
chatgpt: "ChatGPT",
|
|
175
188
|
claudeai: "Claude.ai"
|
|
176
189
|
};
|
|
190
|
+
const WAF_PLATFORMS = [
|
|
191
|
+
"akamai",
|
|
192
|
+
"cato",
|
|
193
|
+
"cloudflare",
|
|
194
|
+
"fastly"
|
|
195
|
+
];
|
|
196
|
+
const ALLOWED_PLATFORMS = [...AI_PLATFORMS, ...WAF_PLATFORMS];
|
|
197
|
+
const allowedPlatformSchema = z.enum(ALLOWED_PLATFORMS);
|
|
177
198
|
const auditStatusSchema = z.enum([
|
|
178
199
|
"pending",
|
|
179
200
|
"partial",
|
|
@@ -246,6 +267,25 @@ z.object({
|
|
|
246
267
|
clientSecret: z.string(),
|
|
247
268
|
clientScopes: z.array(z.string())
|
|
248
269
|
});
|
|
270
|
+
const creditEntryReasonSchema = z.enum([
|
|
271
|
+
"free_seed",
|
|
272
|
+
"paid_conversion_floor",
|
|
273
|
+
"top_up",
|
|
274
|
+
"usage",
|
|
275
|
+
"admin_adjustment"
|
|
276
|
+
]);
|
|
277
|
+
z.enum(["playground"]);
|
|
278
|
+
z.number().int().min(500);
|
|
279
|
+
const creditActivityEntrySchema = z.object({
|
|
280
|
+
reason: creditEntryReasonSchema,
|
|
281
|
+
day: z.number(),
|
|
282
|
+
amountInNanoUSD: z.number(),
|
|
283
|
+
messageCount: z.number().nullable()
|
|
284
|
+
});
|
|
285
|
+
z.object({
|
|
286
|
+
balanceInNanoUSD: z.number(),
|
|
287
|
+
recentActivity: z.array(creditActivityEntrySchema)
|
|
288
|
+
});
|
|
249
289
|
const deploymentStatusSchema$1 = z.enum([
|
|
250
290
|
"ongoing",
|
|
251
291
|
"deployed",
|
|
@@ -273,34 +313,51 @@ const deploymentSummarySchema = z.object({
|
|
|
273
313
|
createdAt: z.coerce.date(),
|
|
274
314
|
updatedAt: z.coerce.date()
|
|
275
315
|
});
|
|
276
|
-
/**
|
|
277
|
-
* Public environment
|
|
278
|
-
*
|
|
279
|
-
* No OAuth metadata exposed.
|
|
280
|
-
*/
|
|
316
|
+
/** Public environment: answers anonymously and exposes no OAuth metadata. */
|
|
281
317
|
const publicEnvironmentSchema = z.object({
|
|
318
|
+
allowsAnonymous: z.literal(true),
|
|
319
|
+
oAuthMetadata: z.strictObject({})
|
|
320
|
+
});
|
|
321
|
+
/** 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. */
|
|
322
|
+
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
323
|
+
allowsAnonymous: z.boolean(),
|
|
324
|
+
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
325
|
+
scope: z.string().optional()
|
|
326
|
+
});
|
|
327
|
+
/** 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. */
|
|
328
|
+
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
329
|
+
allowsAnonymous: z.boolean(),
|
|
330
|
+
oAuthMetadata: z.object({
|
|
331
|
+
externalAuthorizationServerUrl: z.url(),
|
|
332
|
+
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
|
|
333
|
+
}),
|
|
334
|
+
scope: z.string().optional()
|
|
335
|
+
});
|
|
336
|
+
/** Standalone protected environment: the server itself exposes both the /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server endpoints. */
|
|
337
|
+
const standaloneEnvironmentSchema = z.object({
|
|
338
|
+
allowsAnonymous: z.boolean(),
|
|
339
|
+
oAuthMetadata: z.object({
|
|
340
|
+
authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
|
|
341
|
+
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
|
|
342
|
+
}),
|
|
343
|
+
scope: z.string().optional()
|
|
344
|
+
});
|
|
345
|
+
/** Protected environment that enforces authentication but advertises no OAuth discovery metadata; clients must obtain credentials out-of-band. */
|
|
346
|
+
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
347
|
+
allowsAnonymous: z.literal(false),
|
|
348
|
+
oAuthMetadata: z.strictObject({}),
|
|
349
|
+
scope: z.string().optional()
|
|
350
|
+
});
|
|
351
|
+
const legacyPublicEnvironmentSchema = z.object({
|
|
282
352
|
isPublic: z.literal(true),
|
|
283
353
|
oAuthMetadata: z.undefined().optional()
|
|
284
354
|
});
|
|
285
|
-
|
|
286
|
-
* Protected environment with an external resource metadata URL
|
|
287
|
-
*
|
|
288
|
-
* An external resource metadata URL is returned in the WWW-Authenticate header during the first 401 response.
|
|
289
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
290
|
-
*/
|
|
291
|
-
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
355
|
+
const legacyExternalResourceMetadataEnvironmentSchema = z.object({
|
|
292
356
|
isPublic: z.literal(false),
|
|
293
357
|
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
294
358
|
scope: z.string().optional()
|
|
295
359
|
});
|
|
296
|
-
|
|
297
|
-
* Protected environment with an external authorization server URL
|
|
298
|
-
*
|
|
299
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
300
|
-
* An external authorization server URL is returned when requesting the endpoint.
|
|
301
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
302
|
-
*/
|
|
303
|
-
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
360
|
+
const legacyExternalAuthorizationServerEnvironmentSchema = z.object({
|
|
304
361
|
isPublic: z.literal(false),
|
|
305
362
|
oAuthMetadata: z.object({
|
|
306
363
|
externalAuthorizationServerUrl: z.url(),
|
|
@@ -308,13 +365,7 @@ const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
|
308
365
|
}),
|
|
309
366
|
scope: z.string().optional()
|
|
310
367
|
});
|
|
311
|
-
|
|
312
|
-
* Standalone protected environment
|
|
313
|
-
*
|
|
314
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
315
|
-
* The server itself exposes the /.well-known/oauth-authorization-server endpoint.
|
|
316
|
-
*/
|
|
317
|
-
const standaloneEnvironmentSchema = z.object({
|
|
368
|
+
const legacyStandaloneEnvironmentSchema = z.object({
|
|
318
369
|
isPublic: z.literal(false),
|
|
319
370
|
oAuthMetadata: z.object({
|
|
320
371
|
authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
|
|
@@ -322,14 +373,7 @@ const standaloneEnvironmentSchema = z.object({
|
|
|
322
373
|
}),
|
|
323
374
|
scope: z.string().optional()
|
|
324
375
|
});
|
|
325
|
-
|
|
326
|
-
* Protected environment without OAuth discovery
|
|
327
|
-
*
|
|
328
|
-
* The server enforces authentication but exposes no OAuth discovery metadata.
|
|
329
|
-
* Neither /.well-known/oauth-protected-resource nor /.well-known/oauth-authorization-server
|
|
330
|
-
* are advertised. Clients must obtain credentials out-of-band.
|
|
331
|
-
*/
|
|
332
|
-
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
376
|
+
const legacyProtectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
333
377
|
isPublic: z.literal(false),
|
|
334
378
|
oAuthMetadata: z.strictObject({}),
|
|
335
379
|
scope: z.string().optional()
|
|
@@ -339,11 +383,21 @@ z.union([
|
|
|
339
383
|
externalResourceMetadataEnvironmentSchema,
|
|
340
384
|
externalAuthorizationServerEnvironmentSchema,
|
|
341
385
|
standaloneEnvironmentSchema,
|
|
342
|
-
protectedWithoutDiscoveryEnvironmentSchema
|
|
386
|
+
protectedWithoutDiscoveryEnvironmentSchema,
|
|
387
|
+
legacyPublicEnvironmentSchema,
|
|
388
|
+
legacyExternalResourceMetadataEnvironmentSchema,
|
|
389
|
+
legacyExternalAuthorizationServerEnvironmentSchema,
|
|
390
|
+
legacyStandaloneEnvironmentSchema,
|
|
391
|
+
legacyProtectedWithoutDiscoveryEnvironmentSchema
|
|
392
|
+
]);
|
|
393
|
+
const playgroundModelSchema = z.enum([
|
|
394
|
+
"global.anthropic.claude-haiku-4-5-20251001-v1:0",
|
|
395
|
+
"global.anthropic.claude-sonnet-4-5-20250929-v1:0",
|
|
396
|
+
"openai.gpt-5.4",
|
|
397
|
+
"openai.gpt-5.5"
|
|
343
398
|
]);
|
|
344
|
-
const allowedPlatformSchema = platformSchema;
|
|
345
399
|
const environmentDomainSchema = z.object({
|
|
346
|
-
|
|
400
|
+
name: z.string(),
|
|
347
401
|
status: z.enum([
|
|
348
402
|
"ongoing",
|
|
349
403
|
"deployed",
|
|
@@ -361,6 +415,7 @@ const environmentSchema$1 = z.object({
|
|
|
361
415
|
latestDeployment: deploymentSummarySchema.optional(),
|
|
362
416
|
openaiAppsChallenge: z.string().nullable().optional(),
|
|
363
417
|
isPlaygroundEnabled: z.boolean(),
|
|
418
|
+
playgroundModel: playgroundModelSchema,
|
|
364
419
|
isIpWhitelistEnabled: z.boolean(),
|
|
365
420
|
ipAllowlist: z.array(z.string()).nullable(),
|
|
366
421
|
allowedPlatforms: z.array(allowedPlatformSchema),
|
|
@@ -370,11 +425,21 @@ const environmentSchema$1 = z.object({
|
|
|
370
425
|
});
|
|
371
426
|
const environmentWithDomainsSchema = environmentSchema$1.extend({ domains: z.array(environmentDomainSchema) });
|
|
372
427
|
z.object({
|
|
428
|
+
sessionReplayEnabled: z.boolean(),
|
|
429
|
+
collectRequestPayload: z.boolean(),
|
|
430
|
+
collectResponsePayload: z.boolean(),
|
|
431
|
+
collectErrorMessage: z.boolean(),
|
|
432
|
+
collectUserData: z.boolean(),
|
|
433
|
+
identityTraitKey: z.string().min(1).max(200).nullable(),
|
|
434
|
+
leadEventName: z.string().min(1).max(200).nullable()
|
|
435
|
+
});
|
|
436
|
+
const feedbackSchema = z.object({
|
|
373
437
|
id: z.string(),
|
|
374
438
|
createdAt: z.coerce.date(),
|
|
375
439
|
environmentId: z.string(),
|
|
376
440
|
content: z.string(),
|
|
377
|
-
source: z.enum(["model", "user"])
|
|
441
|
+
source: z.enum(["model", "user"]),
|
|
442
|
+
clientName: z.string().nullable()
|
|
378
443
|
});
|
|
379
444
|
z.object({
|
|
380
445
|
content: z.string(),
|
|
@@ -390,7 +455,7 @@ const intentCategoryColorSchema = z.enum([
|
|
|
390
455
|
"pink",
|
|
391
456
|
"gray"
|
|
392
457
|
]);
|
|
393
|
-
intentCategoryColorSchema.options;
|
|
458
|
+
const INTENT_CATEGORY_COLORS = intentCategoryColorSchema.options;
|
|
394
459
|
const intentCategorySchema = z.object({
|
|
395
460
|
id: z.string(),
|
|
396
461
|
createdAt: z.coerce.date(),
|
|
@@ -398,7 +463,7 @@ const intentCategorySchema = z.object({
|
|
|
398
463
|
name: z.string(),
|
|
399
464
|
color: intentCategoryColorSchema
|
|
400
465
|
});
|
|
401
|
-
z.object({
|
|
466
|
+
const intentCategorySummarySchema = z.object({
|
|
402
467
|
id: z.string(),
|
|
403
468
|
name: z.string(),
|
|
404
469
|
color: intentCategoryColorSchema,
|
|
@@ -410,6 +475,7 @@ z.object({
|
|
|
410
475
|
environmentId: z.string(),
|
|
411
476
|
toolName: z.string(),
|
|
412
477
|
message: z.string(),
|
|
478
|
+
clientName: z.string().nullable(),
|
|
413
479
|
categories: z.array(intentCategorySchema)
|
|
414
480
|
});
|
|
415
481
|
const signalCategorySchema = z.object({
|
|
@@ -468,12 +534,270 @@ z.object({
|
|
|
468
534
|
createdAt: z.coerce.date(),
|
|
469
535
|
updatedAt: z.coerce.date()
|
|
470
536
|
});
|
|
537
|
+
const alpicMcpRequestLogSchema = z.object({
|
|
538
|
+
type: z.literal("mcp_request"),
|
|
539
|
+
method: z.string()
|
|
540
|
+
});
|
|
541
|
+
const alpicMcpErrorLogSchema = z.object({
|
|
542
|
+
type: z.literal("mcp_error"),
|
|
543
|
+
method: z.string(),
|
|
544
|
+
error: z.string()
|
|
545
|
+
});
|
|
546
|
+
z.union([alpicMcpRequestLogSchema, alpicMcpErrorLogSchema]);
|
|
471
547
|
z.enum([
|
|
472
548
|
"INFO",
|
|
473
549
|
"WARNING",
|
|
474
550
|
"DEBUG",
|
|
475
551
|
"ERROR"
|
|
476
552
|
]);
|
|
553
|
+
const LOG_SEARCH_MAX_ESCAPED_LENGTH = 960;
|
|
554
|
+
function escapeLogSearchTerm(search) {
|
|
555
|
+
return [...search].flatMap((character) => [...new TextEncoder().encode(character)]).map((byte) => {
|
|
556
|
+
const character = String.fromCharCode(byte);
|
|
557
|
+
return /^[a-zA-Z0-9]$/.test(character) ? character : `\\x${byte.toString(16).toUpperCase().padStart(2, "0")}`;
|
|
558
|
+
}).join("");
|
|
559
|
+
}
|
|
560
|
+
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");
|
|
561
|
+
/** Only names a vendor actually ships belong here: lookalikes like `claude-code-test` are customers' own scripts. */
|
|
562
|
+
const MCP_CLIENT_GROUPS = [
|
|
563
|
+
{
|
|
564
|
+
id: "claude_code",
|
|
565
|
+
label: "Claude Code",
|
|
566
|
+
vendor: "anthropic",
|
|
567
|
+
rawNames: ["claude-code", "Anthropic/ClaudeCodeDesktop"]
|
|
568
|
+
},
|
|
569
|
+
{
|
|
570
|
+
id: "claude",
|
|
571
|
+
label: "Claude",
|
|
572
|
+
vendor: "anthropic",
|
|
573
|
+
rawNames: [
|
|
574
|
+
"Anthropic/ClaudeAI",
|
|
575
|
+
"claude-ai",
|
|
576
|
+
"claude",
|
|
577
|
+
"Claude",
|
|
578
|
+
"claude-desktop",
|
|
579
|
+
"claude-desktop-3p"
|
|
580
|
+
]
|
|
581
|
+
},
|
|
582
|
+
{
|
|
583
|
+
id: "claude_mobile",
|
|
584
|
+
label: "Claude mobile",
|
|
585
|
+
vendor: "anthropic",
|
|
586
|
+
rawNames: ["claude-ios", "ClaudeAndroid"]
|
|
587
|
+
},
|
|
588
|
+
{
|
|
589
|
+
id: "claude_cowork",
|
|
590
|
+
label: "Claude Cowork",
|
|
591
|
+
vendor: "anthropic",
|
|
592
|
+
rawNames: ["Anthropic/Cowork"]
|
|
593
|
+
},
|
|
594
|
+
{
|
|
595
|
+
id: "claude_toolbox",
|
|
596
|
+
label: "Claude Toolbox",
|
|
597
|
+
vendor: "anthropic",
|
|
598
|
+
rawNames: ["Anthropic/Toolbox", "Anthropic/toolbox-bootstrap"]
|
|
599
|
+
},
|
|
600
|
+
{
|
|
601
|
+
id: "anthropic_api",
|
|
602
|
+
label: "Anthropic API",
|
|
603
|
+
vendor: "anthropic",
|
|
604
|
+
rawNames: ["Anthropic/API"]
|
|
605
|
+
},
|
|
606
|
+
{
|
|
607
|
+
id: "anthropic_connector_refresh",
|
|
608
|
+
label: "Anthropic (connector refresh)",
|
|
609
|
+
vendor: "anthropic",
|
|
610
|
+
rawNames: ["Anthropic"]
|
|
611
|
+
},
|
|
612
|
+
{
|
|
613
|
+
id: "codex",
|
|
614
|
+
label: "Codex",
|
|
615
|
+
vendor: "openai",
|
|
616
|
+
rawNames: [
|
|
617
|
+
"codex-mcp-client",
|
|
618
|
+
"codex",
|
|
619
|
+
"Codex",
|
|
620
|
+
"codex-cli",
|
|
621
|
+
"openai-mcp (Codex)"
|
|
622
|
+
]
|
|
623
|
+
},
|
|
624
|
+
{
|
|
625
|
+
id: "chatgpt",
|
|
626
|
+
label: "ChatGPT",
|
|
627
|
+
vendor: "openai",
|
|
628
|
+
rawNames: ["openai-mcp (ChatGPT)"]
|
|
629
|
+
},
|
|
630
|
+
{
|
|
631
|
+
id: "openai_responses_api",
|
|
632
|
+
label: "OpenAI Responses API",
|
|
633
|
+
vendor: "openai",
|
|
634
|
+
rawNames: ["openai-mcp (Responses API)"]
|
|
635
|
+
},
|
|
636
|
+
{
|
|
637
|
+
id: "openai_agent_builder",
|
|
638
|
+
label: "OpenAI Agent Builder",
|
|
639
|
+
vendor: "openai",
|
|
640
|
+
rawNames: ["openai-mcp (Agent Builder)"]
|
|
641
|
+
},
|
|
642
|
+
{
|
|
643
|
+
id: "openai_other",
|
|
644
|
+
label: "OpenAI Other",
|
|
645
|
+
vendor: "openai",
|
|
646
|
+
rawNames: ["openai-mcp"]
|
|
647
|
+
},
|
|
648
|
+
{
|
|
649
|
+
id: "cursor",
|
|
650
|
+
label: "Cursor",
|
|
651
|
+
vendor: "cursor",
|
|
652
|
+
rawNames: [
|
|
653
|
+
"cursor-vscode",
|
|
654
|
+
"Cursor",
|
|
655
|
+
"cursor"
|
|
656
|
+
]
|
|
657
|
+
},
|
|
658
|
+
{
|
|
659
|
+
id: "cline",
|
|
660
|
+
label: "Cline",
|
|
661
|
+
vendor: "cline",
|
|
662
|
+
rawNames: [
|
|
663
|
+
"Cline",
|
|
664
|
+
"cline",
|
|
665
|
+
"@cline/core"
|
|
666
|
+
]
|
|
667
|
+
},
|
|
668
|
+
{
|
|
669
|
+
id: "github_copilot",
|
|
670
|
+
label: "GitHub Copilot",
|
|
671
|
+
vendor: "githubCopilot",
|
|
672
|
+
rawNames: [
|
|
673
|
+
"Copilot",
|
|
674
|
+
"github-copilot-developer",
|
|
675
|
+
"Copilot MCP Gateway",
|
|
676
|
+
"Xcode/copilot-xcode"
|
|
677
|
+
]
|
|
678
|
+
},
|
|
679
|
+
{
|
|
680
|
+
id: "gemini_cli",
|
|
681
|
+
label: "Gemini CLI",
|
|
682
|
+
vendor: "google",
|
|
683
|
+
rawNames: ["gemini-cli-mcp-client", "gemini-cli"]
|
|
684
|
+
},
|
|
685
|
+
{
|
|
686
|
+
id: "antigravity",
|
|
687
|
+
label: "Antigravity",
|
|
688
|
+
vendor: "google",
|
|
689
|
+
rawNames: ["antigravity-client"]
|
|
690
|
+
},
|
|
691
|
+
{
|
|
692
|
+
id: "gemini",
|
|
693
|
+
label: "Gemini",
|
|
694
|
+
vendor: "google",
|
|
695
|
+
rawNames: ["Gemini", "google-ai-edge-gallery"]
|
|
696
|
+
},
|
|
697
|
+
{
|
|
698
|
+
id: "windsurf",
|
|
699
|
+
label: "Windsurf",
|
|
700
|
+
vendor: "windsurf",
|
|
701
|
+
rawNames: ["Windsurf", "windsurf-client"]
|
|
702
|
+
},
|
|
703
|
+
{
|
|
704
|
+
id: "mistral",
|
|
705
|
+
label: "Mistral / Le Chat",
|
|
706
|
+
vendor: "mistral",
|
|
707
|
+
rawNames: ["Mistral"],
|
|
708
|
+
rawNamePrefixes: ["connector:custom-mcp:"]
|
|
709
|
+
},
|
|
710
|
+
{
|
|
711
|
+
id: "n8n",
|
|
712
|
+
label: "n8n",
|
|
713
|
+
vendor: "n8n",
|
|
714
|
+
rawNames: [
|
|
715
|
+
"@n8n/n8n-nodes-langchain.mcpClient",
|
|
716
|
+
"@n8n/n8n-nodes-langchain.mcpClientTool",
|
|
717
|
+
"n8n"
|
|
718
|
+
]
|
|
719
|
+
},
|
|
720
|
+
{
|
|
721
|
+
id: "alpic_playground",
|
|
722
|
+
label: "Alpic Playground",
|
|
723
|
+
vendor: "alpic",
|
|
724
|
+
rawNames: ["alpic-playground", "playground"]
|
|
725
|
+
},
|
|
726
|
+
{
|
|
727
|
+
id: "opencode",
|
|
728
|
+
label: "opencode",
|
|
729
|
+
vendor: "opencode",
|
|
730
|
+
rawNames: ["opencode"]
|
|
731
|
+
},
|
|
732
|
+
{
|
|
733
|
+
id: "zed",
|
|
734
|
+
label: "Zed",
|
|
735
|
+
vendor: "zed",
|
|
736
|
+
rawNames: ["Zed", "zed"]
|
|
737
|
+
},
|
|
738
|
+
{
|
|
739
|
+
id: "zapier",
|
|
740
|
+
label: "Zapier",
|
|
741
|
+
vendor: "zapier",
|
|
742
|
+
rawNames: ["Zapier", "zapier"]
|
|
743
|
+
},
|
|
744
|
+
{
|
|
745
|
+
id: "make",
|
|
746
|
+
label: "Make",
|
|
747
|
+
vendor: "make",
|
|
748
|
+
rawNames: ["Make", "make"]
|
|
749
|
+
},
|
|
750
|
+
{
|
|
751
|
+
id: "librechat",
|
|
752
|
+
label: "LibreChat",
|
|
753
|
+
vendor: "mcp",
|
|
754
|
+
rawNames: ["LibreChat", "librechat"]
|
|
755
|
+
},
|
|
756
|
+
{
|
|
757
|
+
id: "jan",
|
|
758
|
+
label: "Jan",
|
|
759
|
+
vendor: "mcp",
|
|
760
|
+
rawNames: ["Jan", "jan"]
|
|
761
|
+
},
|
|
762
|
+
{
|
|
763
|
+
id: "goose",
|
|
764
|
+
label: "goose",
|
|
765
|
+
vendor: "mcp",
|
|
766
|
+
rawNames: ["goose", "Goose"]
|
|
767
|
+
},
|
|
768
|
+
{
|
|
769
|
+
id: "mcphost",
|
|
770
|
+
label: "mcphost",
|
|
771
|
+
vendor: "mcp",
|
|
772
|
+
rawNames: ["mcphost"]
|
|
773
|
+
},
|
|
774
|
+
{
|
|
775
|
+
id: "mcporter",
|
|
776
|
+
label: "mcporter",
|
|
777
|
+
vendor: "mcp",
|
|
778
|
+
rawNames: ["mcporter"]
|
|
779
|
+
},
|
|
780
|
+
{
|
|
781
|
+
id: "rmcp",
|
|
782
|
+
label: "rmcp",
|
|
783
|
+
vendor: "mcp",
|
|
784
|
+
rawNames: ["rmcp"]
|
|
785
|
+
},
|
|
786
|
+
{
|
|
787
|
+
id: "unnamed_client",
|
|
788
|
+
label: "Unnamed client",
|
|
789
|
+
vendor: "mcp",
|
|
790
|
+
rawNames: [
|
|
791
|
+
"mcp",
|
|
792
|
+
"unknown",
|
|
793
|
+
""
|
|
794
|
+
]
|
|
795
|
+
}
|
|
796
|
+
];
|
|
797
|
+
/** A source pattern, not a RegExp, because analytics renders the same rule into ClickHouse RE2, which shares this syntax. */
|
|
798
|
+
const MCP_REMOTE_WRAPPER_SUFFIX = String.raw` \(via mcp-remote [^\n]+?\)$`;
|
|
799
|
+
new RegExp(MCP_REMOTE_WRAPPER_SUFFIX);
|
|
800
|
+
new Map(MCP_CLIENT_GROUPS.map((group) => [group.id, group]));
|
|
477
801
|
const runtimeSchema = z.enum([
|
|
478
802
|
"python3.13",
|
|
479
803
|
"python3.14",
|
|
@@ -502,15 +826,27 @@ z.object({
|
|
|
502
826
|
environments: z.array(environmentWithDomainsSchema),
|
|
503
827
|
productionEnvironment: environmentWithDomainsSchema.nullable()
|
|
504
828
|
});
|
|
829
|
+
const domainFailureReasonSchema = z.enum([
|
|
830
|
+
"caa",
|
|
831
|
+
"dns",
|
|
832
|
+
"invalid_domain",
|
|
833
|
+
"other"
|
|
834
|
+
]);
|
|
835
|
+
const projectDomainMappingSchema = z.object({
|
|
836
|
+
pathPrefix: z.string(),
|
|
837
|
+
environment: environmentSchema$1
|
|
838
|
+
});
|
|
505
839
|
z.object({
|
|
506
|
-
|
|
840
|
+
name: z.string(),
|
|
507
841
|
createdAt: z.coerce.date(),
|
|
508
842
|
status: z.enum([
|
|
509
843
|
"ongoing",
|
|
510
844
|
"deployed",
|
|
511
845
|
"failed"
|
|
512
846
|
]),
|
|
513
|
-
|
|
847
|
+
failureReason: domainFailureReasonSchema.nullable(),
|
|
848
|
+
environment: environmentSchema$1,
|
|
849
|
+
mappings: z.array(projectDomainMappingSchema)
|
|
514
850
|
});
|
|
515
851
|
const serverFieldsSchema$1 = z.object({
|
|
516
852
|
$schema: z.string(),
|
|
@@ -539,15 +875,7 @@ z.object({
|
|
|
539
875
|
serverFields: serverFieldsSchema$1,
|
|
540
876
|
source: z.enum(["registry", "defaults"])
|
|
541
877
|
});
|
|
542
|
-
/**
|
|
543
|
-
* Returns a variant of a `maxLength`-constrained string that clamps (truncates) instead of
|
|
544
|
-
* rejecting on overflow — used for AI-generated copy where the model routinely overshoots.
|
|
545
|
-
*
|
|
546
|
-
* NOTE: this rebuilds the schema from scratch, carrying over only `maxLength` (as a clamp),
|
|
547
|
-
* `minLength`, and the description. Any other validators on the source field (`.regex()`,
|
|
548
|
-
* `.email()`, custom refinements) are intentionally dropped — this helper is meant for plain
|
|
549
|
-
* free-text length caps only. A field with `null` `maxLength` is returned unchanged.
|
|
550
|
-
*/
|
|
878
|
+
/** 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. */
|
|
551
879
|
const clampStringField = (field) => {
|
|
552
880
|
const max = field.maxLength;
|
|
553
881
|
if (max === null) return field;
|
|
@@ -555,6 +883,10 @@ const clampStringField = (field) => {
|
|
|
555
883
|
const withMin = field.minLength === null ? clamped : clamped.min(field.minLength);
|
|
556
884
|
return field.description ? withMin.describe(field.description) : withMin;
|
|
557
885
|
};
|
|
886
|
+
const unboundedArrayField = (field) => {
|
|
887
|
+
const unbounded = z.array(field.element);
|
|
888
|
+
return field.description ? unbounded.describe(field.description) : unbounded;
|
|
889
|
+
};
|
|
558
890
|
const toolDefinitionSchema = z.object({
|
|
559
891
|
name: z.string(),
|
|
560
892
|
title: z.string().optional().describe("Human-friendly name for the tool, used in the UI. If not provided, `name` will be used."),
|
|
@@ -567,17 +899,31 @@ const toolDefinitionSchema = z.object({
|
|
|
567
899
|
}).optional()
|
|
568
900
|
});
|
|
569
901
|
const positiveTestCaseSchema = z.object({
|
|
570
|
-
scenario: z.string().describe("Short label for what this case demonstrates."),
|
|
571
|
-
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."),
|
|
902
|
+
scenario: z.string().min(1).describe("Short label for what this case demonstrates."),
|
|
903
|
+
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."),
|
|
572
904
|
toolTriggered: z.string().optional().describe("The tool this prompt should invoke."),
|
|
573
905
|
expectedOutput: z.string().optional().describe("What the user should see, including post-interaction behaviour where relevant.")
|
|
574
|
-
}).
|
|
906
|
+
}).describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
|
|
907
|
+
const positiveTestCaseDraftSchema = positiveTestCaseSchema.partial().extend({
|
|
908
|
+
scenario: z.string().optional(),
|
|
909
|
+
userPrompt: z.string().optional()
|
|
910
|
+
});
|
|
911
|
+
const blankPositiveTestCase = () => ({
|
|
912
|
+
scenario: "",
|
|
913
|
+
userPrompt: "",
|
|
914
|
+
toolTriggered: "",
|
|
915
|
+
expectedOutput: ""
|
|
916
|
+
});
|
|
917
|
+
const toFixedLength = (entries, length, blank) => Array.from({ length }, (_, index) => entries[index] ?? blank());
|
|
575
918
|
const screenshotEntrySchema = z.object({
|
|
576
919
|
prompt: z.string(),
|
|
577
|
-
url: z.url()
|
|
920
|
+
url: z.url()
|
|
578
921
|
}).describe("Each screenshot: the user prompt that produced it + the image URL.");
|
|
922
|
+
const screenshotDraftEntrySchema = screenshotEntrySchema.extend({ url: z.string() });
|
|
579
923
|
/** Accepts either a valid email or URL. */
|
|
580
924
|
const supportChannelSchema = z.string().refine((value) => z.email().safeParse(value).success || z.url().safeParse(value).success, { error: "Must be a valid email or URL" });
|
|
925
|
+
/** A URL field whose error spells out that the scheme is required. */
|
|
926
|
+
const urlField = z.url({ error: "Enter a full URL including https:// (e.g. https://example.com)" });
|
|
581
927
|
const chatgptCategorySchema = z.enum([
|
|
582
928
|
"BUSINESS",
|
|
583
929
|
"COLLABORATION",
|
|
@@ -881,20 +1227,25 @@ const chatgptTranslationLocaleSchema = z.enum([
|
|
|
881
1227
|
"zh-TW"
|
|
882
1228
|
]);
|
|
883
1229
|
const negativeTestCaseSchema = z.object({
|
|
884
|
-
scenario: z.string(),
|
|
885
|
-
userPrompt: z.string()
|
|
886
|
-
}).
|
|
1230
|
+
scenario: z.string().min(1),
|
|
1231
|
+
userPrompt: z.string().min(1)
|
|
1232
|
+
}).describe("Each case: Scenario + User prompt (the plugin should NOT trigger).");
|
|
1233
|
+
const negativeTestCaseDraftSchema = negativeTestCaseSchema.partial().extend({
|
|
1234
|
+
scenario: z.string().optional(),
|
|
1235
|
+
userPrompt: z.string().optional()
|
|
1236
|
+
});
|
|
1237
|
+
const blankNegativeTestCase = () => ({
|
|
1238
|
+
scenario: "",
|
|
1239
|
+
userPrompt: ""
|
|
1240
|
+
});
|
|
1241
|
+
const chatgptSkillSchema = z.object({ name: z.string() }).describe("A skill discovered on the MCP server, by name.");
|
|
887
1242
|
const chatgptToolJustificationSchema = z.object({
|
|
888
1243
|
toolName: z.string(),
|
|
889
1244
|
readOnlyJustification: z.string().describe("One sentence on what the tool reads and returns."),
|
|
890
1245
|
openWorldJustification: z.string().describe("One sentence on whether the tool reaches external systems beyond your own service."),
|
|
891
1246
|
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.\"")
|
|
892
1247
|
}).describe("Per-tool justification of each MCP annotation value (one specific sentence per hint).");
|
|
893
|
-
/**
|
|
894
|
-
* Base copy fields, defined once and reused by both the submission form and per-locale
|
|
895
|
-
* translations so the constraints (tagline ≤ 30 chars) never drift. The translation generation
|
|
896
|
-
* path wraps these in {@link clampStringField} since the LLM tends to overshoot the limit.
|
|
897
|
-
*/
|
|
1248
|
+
/** Defined once and reused by both the submission form and per-locale translations so the tagline ≤ 30 chars constraint never drifts. */
|
|
898
1249
|
const chatgptTaglineSchema = z.string().max(30);
|
|
899
1250
|
const chatgptDescriptionSchema = z.string();
|
|
900
1251
|
const chatgptTranslationSchema = z.object({
|
|
@@ -903,52 +1254,73 @@ const chatgptTranslationSchema = z.object({
|
|
|
903
1254
|
description: chatgptDescriptionSchema
|
|
904
1255
|
}).describe("Locale-scoped override for tagline + description. English (US) is the default.");
|
|
905
1256
|
chatgptTranslationSchema.extend({ tagline: clampStringField(chatgptTaglineSchema) });
|
|
906
|
-
/**
|
|
907
|
-
* Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section.
|
|
908
|
-
* When adding/removing/reordering fields, keep this in sync with the sheet.
|
|
909
|
-
*/
|
|
1257
|
+
/** Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section; keep it in sync with the sheet. */
|
|
910
1258
|
const chatgptSubmissionFormDataSchema = z.object({
|
|
911
1259
|
logoLight: z.string().describe("Logo icon for light mode. Square PNG, no borders or rounded corners (clients apply circular cropping)."),
|
|
912
1260
|
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."),
|
|
913
|
-
appName: z.string().describe("The name users will see in ChatGPT and in the
|
|
1261
|
+
appName: z.string().describe("The name users will see in ChatGPT and in the Plugin Directory."),
|
|
914
1262
|
tagline: chatgptTaglineSchema.describe("Plain-language phrase focused on function and user value, 30 chars max. Avoid generic superlatives like \"the best …\"."),
|
|
915
|
-
description: chatgptDescriptionSchema.describe("Clear, engaging description highlighting what the
|
|
1263
|
+
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)."),
|
|
916
1264
|
category: chatgptCategorySchema.describe("Category from the OpenAI taxonomy."),
|
|
917
|
-
developerName: z.string().describe("Developer name shown publicly on the
|
|
918
|
-
companyUrl:
|
|
1265
|
+
developerName: z.string().describe("Developer name shown publicly on the plugin's directory page."),
|
|
1266
|
+
companyUrl: urlField.describe("Your company's main website URL."),
|
|
919
1267
|
supportChannel: supportChannelSchema.describe("Customer support URL or email address."),
|
|
920
|
-
privacyPolicyUrl:
|
|
921
|
-
termsOfServiceUrl:
|
|
922
|
-
demoRecordingUrl:
|
|
923
|
-
appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My
|
|
924
|
-
serverUrl:
|
|
1268
|
+
privacyPolicyUrl: urlField.describe("URL to your privacy policy."),
|
|
1269
|
+
termsOfServiceUrl: urlField.describe("URL to the plugin's terms of service."),
|
|
1270
|
+
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."),
|
|
1271
|
+
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."),
|
|
1272
|
+
serverUrl: urlField.describe("URL of the MCP server."),
|
|
925
1273
|
authentication: chatgptAuthenticationSchema.describe("OAuth 2.0 or No auth. OAuth configuration is auto-discovered from the MCP server's metadata."),
|
|
926
1274
|
tools: z.array(toolDefinitionSchema).describe("List of tools exposed by the MCP server (auto-populated from the production server's manifest)."),
|
|
927
1275
|
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."),
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
1276
|
+
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."),
|
|
1277
|
+
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."),
|
|
1278
|
+
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."),
|
|
1279
|
+
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."),
|
|
931
1280
|
translations: z.array(chatgptTranslationSchema).describe("Per-locale translation of tagline + description. English (US) is the default."),
|
|
932
1281
|
allowedCountries: chatgptAllowedCountriesSchema.describe("Availability: all supported countries, or an allow-list / block-list of specific ones (ISO alpha-2)."),
|
|
933
|
-
releaseNotes: z.string().describe("Publicly displayed on the
|
|
1282
|
+
releaseNotes: z.string().describe("Publicly displayed on the plugin details page.")
|
|
1283
|
+
});
|
|
1284
|
+
const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().extend({
|
|
1285
|
+
tagline: z.string().optional(),
|
|
1286
|
+
companyUrl: z.string().optional(),
|
|
1287
|
+
supportChannel: z.string().optional(),
|
|
1288
|
+
privacyPolicyUrl: z.string().optional(),
|
|
1289
|
+
termsOfServiceUrl: z.string().optional(),
|
|
1290
|
+
demoRecordingUrl: z.string().optional(),
|
|
1291
|
+
serverUrl: z.string().optional(),
|
|
1292
|
+
screenshots: z.array(screenshotDraftEntrySchema).optional(),
|
|
1293
|
+
testCases: z.array(positiveTestCaseDraftSchema).optional(),
|
|
1294
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).optional(),
|
|
1295
|
+
translations: z.array(chatgptTranslationSchema.extend({ tagline: z.string() })).optional()
|
|
934
1296
|
});
|
|
935
|
-
|
|
1297
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "chatgpt" })` can populate. */
|
|
1298
|
+
const chatgptPrefillFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
936
1299
|
appName: true,
|
|
937
1300
|
developerName: true,
|
|
938
1301
|
serverUrl: true,
|
|
939
1302
|
tools: true,
|
|
1303
|
+
skills: true,
|
|
940
1304
|
authentication: true
|
|
941
1305
|
});
|
|
942
|
-
|
|
1306
|
+
/** Source of truth for `SubmissionPrefillService.generate({ platform: "chatgpt" })`. */
|
|
1307
|
+
const chatgptAiGeneratedFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
943
1308
|
tagline: true,
|
|
944
1309
|
description: true,
|
|
945
1310
|
category: true,
|
|
946
1311
|
testCases: true,
|
|
947
1312
|
negativeTestCases: true,
|
|
948
1313
|
toolJustifications: true
|
|
949
|
-
}).extend({
|
|
1314
|
+
}).extend({
|
|
1315
|
+
testCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.testCases),
|
|
1316
|
+
negativeTestCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.negativeTestCases)
|
|
1317
|
+
}).extend({
|
|
1318
|
+
tagline: clampStringField(chatgptSubmissionFormDataSchema.shape.tagline),
|
|
1319
|
+
testCases: z.array(positiveTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 5, blankPositiveTestCase)),
|
|
1320
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 3, blankNegativeTestCase))
|
|
1321
|
+
});
|
|
950
1322
|
const claudeCategorySchema = z.enum([
|
|
951
|
-
"
|
|
1323
|
+
"Productivity",
|
|
952
1324
|
"Communication",
|
|
953
1325
|
"Data & Analytics",
|
|
954
1326
|
"Development tools",
|
|
@@ -956,222 +1328,222 @@ const claudeCategorySchema = z.enum([
|
|
|
956
1328
|
"Consumer Health",
|
|
957
1329
|
"Health & Life Sciences",
|
|
958
1330
|
"Media & Entertainment",
|
|
959
|
-
"Commerce & Shopping"
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
"
|
|
963
|
-
"
|
|
964
|
-
"
|
|
1331
|
+
"Commerce & Shopping",
|
|
1332
|
+
"Legal",
|
|
1333
|
+
"Sales and marketing",
|
|
1334
|
+
"Creative",
|
|
1335
|
+
"Nonprofit",
|
|
1336
|
+
"Education",
|
|
1337
|
+
"Other"
|
|
965
1338
|
]);
|
|
966
|
-
const
|
|
967
|
-
z.enum(["Static OAuth Client", "Dynamic OAuth Client (DCR / CIMD)"]);
|
|
1339
|
+
const claudeCategoryDescription = `The categories used to filter connectors in the directory UI. Select up to 5 that best describe your connector.`;
|
|
968
1340
|
const claudeReadWriteCapabilitiesSchema = z.enum([
|
|
969
|
-
"
|
|
970
|
-
"
|
|
971
|
-
"
|
|
1341
|
+
"read_only",
|
|
1342
|
+
"write_only",
|
|
1343
|
+
"read_write"
|
|
972
1344
|
]);
|
|
973
|
-
const
|
|
974
|
-
|
|
975
|
-
"
|
|
976
|
-
"
|
|
977
|
-
"
|
|
978
|
-
"
|
|
979
|
-
]);
|
|
980
|
-
const claudeThirdPartySchema = z.enum([
|
|
981
|
-
"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)",
|
|
982
|
-
"Third-party AI model integration: Sends data to or receives data from a generative AI model other than Claude",
|
|
983
|
-
"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)",
|
|
984
|
-
"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)",
|
|
985
|
-
"N/A"
|
|
1345
|
+
const claudeAuthenticationSchema = z.enum([
|
|
1346
|
+
"oauth_dcr",
|
|
1347
|
+
"oauth_cimd",
|
|
1348
|
+
"oauth_anthropic_creds",
|
|
1349
|
+
"custom_connection",
|
|
1350
|
+
"none"
|
|
986
1351
|
]);
|
|
987
|
-
const
|
|
988
|
-
"
|
|
989
|
-
"
|
|
990
|
-
"
|
|
991
|
-
"GDPR compliant (if applicable)"
|
|
1352
|
+
const claudeApiOwnershipSchema = z.enum([
|
|
1353
|
+
"first_party",
|
|
1354
|
+
"proxied",
|
|
1355
|
+
"third_party"
|
|
992
1356
|
]);
|
|
993
|
-
const
|
|
994
|
-
|
|
995
|
-
"
|
|
996
|
-
"
|
|
1357
|
+
const claudeYesNoOtherSchema = z.union([z.boolean(), z.object({ other: z.string() })]);
|
|
1358
|
+
const claudePolicyAcknowledgementSchema = z.enum([
|
|
1359
|
+
"I have read and understand the MCP Directory developer guidelines.",
|
|
1360
|
+
"My server calls our own first-party APIs (or APIs we legitimately proxy with permission).",
|
|
1361
|
+
"My connector does not transfer money, cryptocurrency, or other financial assets on a user's behalf.",
|
|
1362
|
+
"My connector does not use AI models to generate images, video, or audio.",
|
|
1363
|
+
"Tool descriptions contain no instructions about model behavior, other tools, or external instruction sources, and no hidden or encoded text.",
|
|
1364
|
+
"My connector does not collect conversation data beyond what is needed for its function.",
|
|
1365
|
+
"Public documentation for this connector will be live by the publish date."
|
|
997
1366
|
]);
|
|
998
|
-
/**
|
|
999
|
-
* Field order mirrors the Claude (Anthropic) submission spreadsheet, grouped by section.
|
|
1000
|
-
* When adding/removing/reordering fields, keep this in sync with the sheet.
|
|
1001
|
-
*/
|
|
1367
|
+
/** 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. */
|
|
1002
1368
|
const claudeSubmissionFormDataSchema = z.object({
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
1012
|
-
(
|
|
1013
|
-
|
|
1014
|
-
(
|
|
1015
|
-
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
|
|
1019
|
-
|
|
1020
|
-
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
•
|
|
1032
|
-
•
|
|
1033
|
-
•
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
• '
|
|
1049
|
-
• '
|
|
1050
|
-
• '
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
|
|
1064
|
-
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
|
|
1080
|
-
• '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.
|
|
1081
|
-
If you support both, select both. If you're building from scratch, implement Streamable HTTP only.`),
|
|
1082
|
-
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:
|
|
1083
|
-
• What the connector does and its key capabilities
|
|
1084
|
-
• How to connect/set it up (step by step)
|
|
1085
|
-
• What each tool does (or at least the main ones)
|
|
1086
|
-
• How to troubleshoot common issues
|
|
1087
|
-
• A support contact or channel
|
|
1088
|
-
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.`),
|
|
1089
|
-
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:
|
|
1090
|
-
• What data you collect (and how)
|
|
1091
|
-
• How you use the collected data
|
|
1092
|
-
• Where and how long you store it
|
|
1093
|
-
• Whether you share data with third parties (and who)
|
|
1094
|
-
• How users can contact you about data concerns
|
|
1095
|
-
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.`),
|
|
1096
|
-
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:
|
|
1097
|
-
• Email address (e.g. support@myapp.com)
|
|
1098
|
-
• Link to a GitHub Issues page
|
|
1099
|
-
• Link to a help center or support article
|
|
1100
|
-
• Link to a Discord/Slack community
|
|
1101
|
-
• Link to your documentation's troubleshooting section
|
|
1102
|
-
Also uses this to notify you of security or compliance issues, so make sure it's actively monitored.`),
|
|
1103
|
-
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:
|
|
1104
|
-
• The account must have sample/demo data loaded — reviewers need to actually test your tools with real data.
|
|
1105
|
-
• No 2FA — reviewers can't receive SMS codes. Disable 2FA on this account.
|
|
1106
|
-
• 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.
|
|
1107
|
-
• Credentials must remain valid for at least 30 days from submission.
|
|
1108
|
-
• If your service requires API keys instead of a password, provide those.
|
|
1109
|
-
Format suggestion: Username/email: xxx | Password: xxx | Any other notes`),
|
|
1110
|
-
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.
|
|
1111
|
-
Example: list_issues (List Issues), create_issue (Create Issue), update_issue (Update Issue), delete_issue (Delete Issue), search_issues (Search Issues)
|
|
1112
|
-
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.`),
|
|
1113
|
-
toolTitlesAnnotationsConfirmed: z.boolean().describe(`This is a compliance confirmation — check both boxes only if you have actually implemented these in your server code:
|
|
1114
|
-
• 'I've specified user-friendly titles for all tools' — every tool has a 'title' annotation (a human-readable label, different from the tool name).
|
|
1115
|
-
• '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).
|
|
1116
|
-
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.`),
|
|
1117
|
-
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.`),
|
|
1118
|
-
logoLight: z.string().describe(`Your connector's logo for light backgrounds. Requirements:
|
|
1119
|
-
• Format: SVG only
|
|
1120
|
-
• Aspect ratio: square (1:1)
|
|
1121
|
-
• Should work on a light background
|
|
1122
|
-
• Provide via URL (Google Drive link is fine) or upload directly
|
|
1123
|
-
Tip: use a simple, recognizable icon — not a full wordmark. The logo appears at small sizes in the directory grid.`),
|
|
1124
|
-
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.`),
|
|
1125
|
-
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:
|
|
1126
|
-
• 3–5 images is ideal
|
|
1127
|
-
• Minimum 1000px width, PNG format preferred
|
|
1128
|
-
• Each screenshot is paired with the user prompt that produced it
|
|
1129
|
-
• Crop to just the relevant part of the Claude interface (the tool response area)
|
|
1130
|
-
• Show your connector doing something impressive and useful — real data, real results
|
|
1131
|
-
• If you're an MCP App, include screenshots of your interactive UI elements
|
|
1132
|
-
These images appear in your directory listing and are a key factor in driving user installs.`)
|
|
1133
|
-
});
|
|
1134
|
-
claudeSubmissionFormDataSchema.pick({
|
|
1135
|
-
companyName: true,
|
|
1136
|
-
appName: true,
|
|
1137
|
-
mcpUrlType: true,
|
|
1369
|
+
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
|
|
1370
|
+
from the custom connector you select — the connection is used to verify the URL and the tool list at submission time.
|
|
1371
|
+
The server must be publicly accessible without VPN or whitelisting.`),
|
|
1372
|
+
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
|
|
1373
|
+
own or have the right to use this name. Max 100 characters.`),
|
|
1374
|
+
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.
|
|
1375
|
+
PERMANENT after submission — it cannot be changed. Pre-filled from the name. Max 50 characters.`),
|
|
1376
|
+
oneLiner: z.string().max(200).describe(`A short tagline shown below your connector name in the directory listing. Max 200 characters. Avoid generic
|
|
1377
|
+
phrases like 'The best MCP server for...'. Example: 'Manage tasks and projects in Linear'.`),
|
|
1378
|
+
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
|
|
1379
|
+
claude.ai. Write it from a user perspective and be specific. Max 2000 characters.`),
|
|
1380
|
+
categories: z.array(claudeCategorySchema).max(5).describe(claudeCategoryDescription),
|
|
1381
|
+
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
|
|
1382
|
+
(recommended); upload a custom icon only to override it.`),
|
|
1383
|
+
documentation: z.url().describe(`A public URL pointing to documentation that helps users understand and use your connector. Must be publicly
|
|
1384
|
+
accessible without login. IT admins often review these when deciding whether to approve a server. Required to be live
|
|
1385
|
+
by your publish date.`),
|
|
1386
|
+
support: supportChannelSchema.describe(`A support URL or email address where users can get help with your connector. Displayed in the directory listing and
|
|
1387
|
+
used to notify you of security or compliance issues, so make sure it's actively monitored.`),
|
|
1388
|
+
privacyPolicy: z.url().describe(`URL to your privacy policy. Mandatory and displayed in the directory listing. Must be publicly accessible and cover
|
|
1389
|
+
what data you collect, how you use and store it, and whether you share it with third parties.`),
|
|
1390
|
+
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
|
|
1391
|
+
it. This is editable on the directory page only after the connector is submitted — optional here so you can prepare it.`),
|
|
1392
|
+
primaryUseCases: z.string().describe(`Describe the main tasks users will accomplish with this connector, and include a few example prompts a user might
|
|
1393
|
+
type. These may be shown publicly but are primarily used for internal review — reviewers test your server using them.`),
|
|
1394
|
+
connectionRequirements: z.string().describe(`What accounts, permissions, or setup a user needs before connecting (e.g. 'Requires a paid Acme account with admin
|
|
1395
|
+
permissions'). If there are genuinely no special requirements, say so explicitly.`),
|
|
1396
|
+
readWriteCapabilities: claudeReadWriteCapabilitiesSchema.describe(`What your server can do:
|
|
1397
|
+
• 'read_only': retrieves data but never modifies it.
|
|
1398
|
+
• 'write_only': creates or modifies data but does not read it.
|
|
1399
|
+
• 'read_write': both retrieves and modifies data (most common).`),
|
|
1400
|
+
companyName: z.string().describe("The company or organization behind this connector — its legal name or publicly known product name."),
|
|
1401
|
+
companyWebsite: z.url().describe("The company's main website URL, e.g. https://example.com."),
|
|
1402
|
+
primaryContactName: z.string().describe("Full name of the person Anthropic should contact about this submission. Receives review feedback and follow-up questions."),
|
|
1403
|
+
primaryContactEmail: z.email().describe("Email for the primary contact (pre-filled from the Claude account). Anthropic uses this to communicate about your submission."),
|
|
1404
|
+
primaryContactRole: z.string().optional().describe("The primary contact's role at the company (e.g. 'Engineer', 'Product Manager'). Optional."),
|
|
1405
|
+
anthropicPointOfContact: z.string().optional().describe("If you've been working with someone at Anthropic, their name or email. Optional, can expedite review."),
|
|
1406
|
+
authentication: claudeAuthenticationSchema.describe(`How users authenticate with your server:
|
|
1407
|
+
• 'oauth_dcr': OAuth 2.0 + Dynamic Client Registration (RFC 7591) — clients register themselves.
|
|
1408
|
+
• 'oauth_cimd': OAuth 2.0 + Client ID Metadata Document — a published client_id metadata document.
|
|
1409
|
+
• 'oauth_anthropic_creds': OAuth 2.0 with Anthropic-held client credentials (a static client_id, and secret if needed).
|
|
1410
|
+
• 'custom_connection': users supply their own URL or client details at connection time (e.g. Snowflake).
|
|
1411
|
+
• 'none': no authentication (authless) — anyone can connect and call tools without credentials.`),
|
|
1412
|
+
partialAuth: z.boolean().optional().describe("Whether some tools return 401 and prompt for auth on demand while the server otherwise starts authless (partial auth)."),
|
|
1413
|
+
apiOwnership: claudeApiOwnershipSchema.describe(`How your connector relates to the API it calls:
|
|
1414
|
+
• 'first_party': the MCP server calls your own production APIs.
|
|
1415
|
+
• 'proxied': calls go to a third-party API you're authorized to integrate (e.g. a Zapier-style integration).
|
|
1416
|
+
• 'third_party': calls a third-party API you don't control — typically blocks listing; explain in 'additionalNotes'.`),
|
|
1417
|
+
personalHealthData: claudeYesNoOtherSchema.describe(`Whether this connector accesses, processes, or stores personal health information.
|
|
1418
|
+
No → false, Yes → true, or { other: explanation } when it depends on configuration.`),
|
|
1419
|
+
sponsoredContent: claudeYesNoOtherSchema.describe(`Whether this connector surfaces sponsored, promoted, or advertising content (prohibited in directory connectors).
|
|
1420
|
+
No → false, Yes → true, or { other: explanation }.`),
|
|
1421
|
+
testInstructions: z.string().optional().describe(`Clear test-account setup and access instructions for reviewers: every link, credential, and step needed to access
|
|
1422
|
+
the MCP server autonomously. For accounts that need to be populated, provide test credentials granting access to a
|
|
1423
|
+
fully populated account.`),
|
|
1424
|
+
selfTested: z.boolean().optional().describe("Confirmation that you have run every tool via MCP Inspector or as a custom connector in Claude."),
|
|
1425
|
+
policyAcknowledgements: z.array(claudePolicyAcknowledgementSchema).describe(`Anthropic directory policy acknowledgements. All items must be acknowledged before the claude.ai wizard allows
|
|
1426
|
+
submission. Each is an attestation you are legally agreeing to by submitting.`),
|
|
1427
|
+
additionalNotes: z.string().optional().describe("Anything else the review team should know about your connector. Optional.")
|
|
1428
|
+
});
|
|
1429
|
+
const claudeSubmissionDraftSchema = claudeSubmissionFormDataSchema.partial().extend({
|
|
1430
|
+
serverUrl: z.string().optional(),
|
|
1431
|
+
name: z.string().optional(),
|
|
1432
|
+
slug: z.string().optional(),
|
|
1433
|
+
oneLiner: z.string().optional(),
|
|
1434
|
+
description: z.string().optional(),
|
|
1435
|
+
iconUrl: z.string().optional(),
|
|
1436
|
+
documentation: z.string().optional(),
|
|
1437
|
+
support: z.string().optional(),
|
|
1438
|
+
privacyPolicy: z.string().optional(),
|
|
1439
|
+
companyWebsite: z.string().optional(),
|
|
1440
|
+
primaryContactEmail: z.string().optional(),
|
|
1441
|
+
categories: z.array(claudeCategorySchema).optional(),
|
|
1442
|
+
screenshots: z.array(screenshotDraftEntrySchema).optional()
|
|
1443
|
+
});
|
|
1444
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "claudeai" })` can populate. */
|
|
1445
|
+
const claudePrefillFormDataSchema = claudeSubmissionFormDataSchema.pick({
|
|
1138
1446
|
serverUrl: true,
|
|
1139
|
-
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
transportSupport: true,
|
|
1447
|
+
name: true,
|
|
1448
|
+
slug: true,
|
|
1449
|
+
companyName: true,
|
|
1143
1450
|
primaryContactEmail: true,
|
|
1144
1451
|
primaryContactName: true,
|
|
1452
|
+
readWriteCapabilities: true,
|
|
1145
1453
|
authentication: true,
|
|
1146
|
-
|
|
1147
|
-
|
|
1454
|
+
apiOwnership: true,
|
|
1455
|
+
personalHealthData: true
|
|
1148
1456
|
}).extend({
|
|
1149
1457
|
connectionRequirements: claudeSubmissionFormDataSchema.shape.connectionRequirements.optional(),
|
|
1150
|
-
|
|
1458
|
+
testInstructions: claudeSubmissionFormDataSchema.shape.testInstructions.optional()
|
|
1459
|
+
});
|
|
1460
|
+
/** Loose shape returned by AI generation for Claude narrative fields; transforms live here so generation leniency stays colocated with the Claude contract. */
|
|
1461
|
+
const claudeAiGeneratedFormDataRawSchema = z.object({
|
|
1462
|
+
oneLiner: claudeSubmissionFormDataSchema.shape.oneLiner,
|
|
1463
|
+
description: claudeSubmissionFormDataSchema.shape.description,
|
|
1464
|
+
categories: z.array(claudeCategorySchema).describe(claudeCategoryDescription),
|
|
1465
|
+
primaryUseCases: claudeSubmissionFormDataSchema.shape.primaryUseCases
|
|
1466
|
+
});
|
|
1467
|
+
const claudeAiGeneratedFormDataSchema = claudeAiGeneratedFormDataRawSchema.extend({
|
|
1468
|
+
oneLiner: clampStringField(claudeSubmissionFormDataSchema.shape.oneLiner),
|
|
1469
|
+
categories: claudeAiGeneratedFormDataRawSchema.shape.categories.transform((categories) => categories.slice(0, 5))
|
|
1470
|
+
});
|
|
1471
|
+
function provenanceByField(prefillShape, aiGeneratedShape) {
|
|
1472
|
+
const byField = {};
|
|
1473
|
+
for (const field of Object.keys(prefillShape)) byField[field] = "prefilled";
|
|
1474
|
+
for (const field of Object.keys(aiGeneratedShape)) byField[field] = "ai-generated";
|
|
1475
|
+
return byField;
|
|
1476
|
+
}
|
|
1477
|
+
provenanceByField(claudePrefillFormDataSchema.shape, claudeAiGeneratedFormDataSchema.shape), provenanceByField(chatgptPrefillFormDataSchema.shape, chatgptAiGeneratedFormDataSchema.shape);
|
|
1478
|
+
const urlVerificationOutcomeSchema = z.enum([
|
|
1479
|
+
"pass",
|
|
1480
|
+
"fail",
|
|
1481
|
+
"unverified"
|
|
1482
|
+
]);
|
|
1483
|
+
const VERIFIABLE_URL_FIELDS = {
|
|
1484
|
+
chatgpt: ["privacyPolicyUrl", "termsOfServiceUrl"],
|
|
1485
|
+
claudeai: ["privacyPolicy"]
|
|
1486
|
+
};
|
|
1487
|
+
const verifiableUrlFieldSchema = z.enum([...VERIFIABLE_URL_FIELDS.chatgpt, ...VERIFIABLE_URL_FIELDS.claudeai]);
|
|
1488
|
+
const policyDisclosureSchema = z.enum([
|
|
1489
|
+
"dataCategories",
|
|
1490
|
+
"purposesOfUse",
|
|
1491
|
+
"recipients",
|
|
1492
|
+
"retention"
|
|
1493
|
+
]);
|
|
1494
|
+
const urlVerificationFieldResultSchema = z.object({
|
|
1495
|
+
field: verifiableUrlFieldSchema,
|
|
1496
|
+
url: z.string(),
|
|
1497
|
+
outcome: urlVerificationOutcomeSchema,
|
|
1498
|
+
reason: z.string(),
|
|
1499
|
+
concerns: z.array(z.string()).optional(),
|
|
1500
|
+
scrapedWith: z.enum(["fetch", "firecrawl"]).optional()
|
|
1501
|
+
});
|
|
1502
|
+
const urlVerificationSchema = z.object({
|
|
1503
|
+
verifiedAt: z.coerce.date(),
|
|
1504
|
+
results: z.array(urlVerificationFieldResultSchema)
|
|
1505
|
+
});
|
|
1506
|
+
const pageKindSchema = z.enum([
|
|
1507
|
+
"expectedDocument",
|
|
1508
|
+
"errorPage",
|
|
1509
|
+
"loginWall",
|
|
1510
|
+
"parkedDomain",
|
|
1511
|
+
"comingSoon",
|
|
1512
|
+
"marketingPage",
|
|
1513
|
+
"unrelatedDocument"
|
|
1514
|
+
]);
|
|
1515
|
+
z.object({
|
|
1516
|
+
pageKind: pageKindSchema.describe("What the page actually is. Use 'expectedDocument' only when it is genuinely the document the field claims."),
|
|
1517
|
+
reason: z.string().max(200).describe("One sentence naming what the page is, addressed to the developer who entered the URL."),
|
|
1518
|
+
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.")
|
|
1151
1519
|
});
|
|
1152
|
-
claudeSubmissionFormDataSchema.pick({
|
|
1153
|
-
tagline: true,
|
|
1154
|
-
description: true,
|
|
1155
|
-
category: true,
|
|
1156
|
-
testCases: true
|
|
1157
|
-
}).extend({ tagline: clampStringField(claudeSubmissionFormDataSchema.shape.tagline) });
|
|
1158
1520
|
const submissionMetaFieldsSchema = z.object({
|
|
1159
1521
|
id: z.string(),
|
|
1160
1522
|
environmentId: z.string(),
|
|
1161
1523
|
auditId: z.string().nullable(),
|
|
1524
|
+
urlVerification: urlVerificationSchema.nullable().default(null),
|
|
1162
1525
|
createdAt: z.coerce.date(),
|
|
1163
1526
|
updatedAt: z.coerce.date()
|
|
1164
1527
|
});
|
|
1165
1528
|
const claudeSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1166
1529
|
platform: z.literal("claudeai"),
|
|
1167
|
-
formData:
|
|
1530
|
+
formData: claudeSubmissionDraftSchema,
|
|
1531
|
+
prefillSnapshot: claudeSubmissionDraftSchema.nullable().default(null)
|
|
1168
1532
|
});
|
|
1169
1533
|
const chatgptSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1170
1534
|
platform: z.literal("chatgpt"),
|
|
1171
|
-
formData:
|
|
1535
|
+
formData: chatgptSubmissionDraftSchema,
|
|
1536
|
+
prefillSnapshot: chatgptSubmissionDraftSchema.nullable().default(null)
|
|
1172
1537
|
});
|
|
1173
|
-
z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
1174
|
-
z.union([
|
|
1538
|
+
const submissionSchemaInternal = z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
1539
|
+
z.union([claudeSubmissionDraftSchema, chatgptSubmissionDraftSchema]);
|
|
1540
|
+
/** Discriminated on `platform`, which pins the shape of `formData`: a Claude submission cannot carry chatgpt-only fields, and vice-versa. */
|
|
1541
|
+
const submissionSchema = submissionSchemaInternal;
|
|
1542
|
+
z.literal([
|
|
1543
|
+
100,
|
|
1544
|
+
75,
|
|
1545
|
+
50
|
|
1546
|
+
]);
|
|
1175
1547
|
const subscriptionPlanSchema = z.enum([
|
|
1176
1548
|
"pro",
|
|
1177
1549
|
"business",
|
|
@@ -1183,17 +1555,77 @@ const customerCreditsSchema = z.object({
|
|
|
1183
1555
|
expiresAt: z.number().nullable(),
|
|
1184
1556
|
currency: z.string()
|
|
1185
1557
|
});
|
|
1186
|
-
const customerUsageSchema = z.object({
|
|
1187
|
-
amountInCents: z.number(),
|
|
1188
|
-
currency: z.string(),
|
|
1189
|
-
periodEnd: z.number()
|
|
1190
|
-
});
|
|
1191
1558
|
const partnerDiscountSchema = z.object({ endsAt: z.number() });
|
|
1192
1559
|
z.object({
|
|
1193
1560
|
customerCredits: customerCreditsSchema.nullable(),
|
|
1194
|
-
customerUsage: customerUsageSchema.nullable(),
|
|
1195
1561
|
partnerDiscount: partnerDiscountSchema.nullable()
|
|
1196
1562
|
});
|
|
1563
|
+
const metricsQueueEventSchema = z.object({
|
|
1564
|
+
ts: z.number().int(),
|
|
1565
|
+
method: z.string(),
|
|
1566
|
+
tool: z.string().nullable(),
|
|
1567
|
+
client: z.string(),
|
|
1568
|
+
sessionId: z.string().nullable(),
|
|
1569
|
+
durationMs: z.number().int(),
|
|
1570
|
+
outputTokens: z.number().int().nullable(),
|
|
1571
|
+
errorType: z.enum([
|
|
1572
|
+
"mcp_error",
|
|
1573
|
+
"tool_error",
|
|
1574
|
+
"timeout"
|
|
1575
|
+
]).nullable(),
|
|
1576
|
+
errorCode: z.number().int().nullable()
|
|
1577
|
+
});
|
|
1578
|
+
z.object({
|
|
1579
|
+
v: z.literal(1),
|
|
1580
|
+
envId: z.string(),
|
|
1581
|
+
events: z.array(metricsQueueEventSchema)
|
|
1582
|
+
});
|
|
1583
|
+
z.object({ v: z.number() });
|
|
1584
|
+
const telemetrySignalSchema = z.enum([
|
|
1585
|
+
"logs",
|
|
1586
|
+
"metrics",
|
|
1587
|
+
"traces"
|
|
1588
|
+
]);
|
|
1589
|
+
const otlpProtocolSchema = z.enum(["http/protobuf", "http/json"]);
|
|
1590
|
+
const otlpEndpointSchema = z.string().trim().min(1).max(2048);
|
|
1591
|
+
const OTLP_HEADER_VALUE_MAX_LENGTH = 2048;
|
|
1592
|
+
const otlpHeaderNameSchema = z.string().trim().min(1, "Enter a header name").max(128).regex(/^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/, "Use letters, digits and !#$%&'*+-.^_`|~ only");
|
|
1593
|
+
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");
|
|
1594
|
+
const telemetryDestinationHeaderSchema = z.object({
|
|
1595
|
+
id: z.string(),
|
|
1596
|
+
name: otlpHeaderNameSchema,
|
|
1597
|
+
value: otlpHeaderValueSchema,
|
|
1598
|
+
isSecret: z.boolean()
|
|
1599
|
+
});
|
|
1600
|
+
const otlpPushFailureReasonSchema = z.enum([
|
|
1601
|
+
"credentials",
|
|
1602
|
+
"wrong-path",
|
|
1603
|
+
"wrong-protocol",
|
|
1604
|
+
"invalid-payload",
|
|
1605
|
+
"partial-rejection",
|
|
1606
|
+
"blocked-target",
|
|
1607
|
+
"timeout",
|
|
1608
|
+
"unreachable",
|
|
1609
|
+
"receiver-error",
|
|
1610
|
+
"unexpected-status"
|
|
1611
|
+
]);
|
|
1612
|
+
const telemetryDestinationStatusSchema = z.enum(["active", "suspended"]);
|
|
1613
|
+
z.object({
|
|
1614
|
+
id: z.string(),
|
|
1615
|
+
signal: telemetrySignalSchema,
|
|
1616
|
+
endpoint: otlpEndpointSchema,
|
|
1617
|
+
protocol: otlpProtocolSchema,
|
|
1618
|
+
headers: z.array(telemetryDestinationHeaderSchema),
|
|
1619
|
+
status: telemetryDestinationStatusSchema,
|
|
1620
|
+
lastFailureReason: otlpPushFailureReasonSchema.nullable(),
|
|
1621
|
+
isScopedToIntentionalRequestsOnly: z.boolean()
|
|
1622
|
+
});
|
|
1623
|
+
//#endregion
|
|
1624
|
+
//#region src/auth-scope.ts
|
|
1625
|
+
/** Accepts an API key or OAuth access token (default for most routes). */
|
|
1626
|
+
const AUTH_SCOPE_ANY = "any";
|
|
1627
|
+
/** Requires a user OAuth access token; API keys are not accepted. */
|
|
1628
|
+
const AUTH_SCOPE_USER = "user";
|
|
1197
1629
|
//#endregion
|
|
1198
1630
|
//#region src/schemas.ts
|
|
1199
1631
|
const RESERVED_KEYS = [
|
|
@@ -1230,7 +1662,10 @@ const RESERVED_KEYS = [
|
|
|
1230
1662
|
"BUILD_ARG_START_COMMAND",
|
|
1231
1663
|
"ALPIC_HOST",
|
|
1232
1664
|
"ALPIC_CUSTOM_DOMAINS",
|
|
1233
|
-
"ALPIC_INTENT_META_KEY"
|
|
1665
|
+
"ALPIC_INTENT_META_KEY",
|
|
1666
|
+
"ALPIC_FEEDBACK_META_KEY",
|
|
1667
|
+
"ALPIC_EVENTS_META_KEY",
|
|
1668
|
+
"ALPIC_IDENTIFY_META_KEY"
|
|
1234
1669
|
];
|
|
1235
1670
|
const environmentVariableSchema = z.object({
|
|
1236
1671
|
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"),
|
|
@@ -1283,6 +1718,14 @@ const serverFieldsSchema = z.object({
|
|
|
1283
1718
|
});
|
|
1284
1719
|
//#endregion
|
|
1285
1720
|
//#region src/api.contract.ts
|
|
1721
|
+
const isValidIanaTimeZone = (timeZone) => {
|
|
1722
|
+
try {
|
|
1723
|
+
new Intl.DateTimeFormat("en-US", { timeZone });
|
|
1724
|
+
return true;
|
|
1725
|
+
} catch {
|
|
1726
|
+
return false;
|
|
1727
|
+
}
|
|
1728
|
+
};
|
|
1286
1729
|
const deploymentStatusSchema = z.enum([
|
|
1287
1730
|
"ongoing",
|
|
1288
1731
|
"deployed",
|
|
@@ -1311,21 +1754,20 @@ const deploymentSchema = z.object({
|
|
|
1311
1754
|
isCurrent: z.boolean(),
|
|
1312
1755
|
deploymentPageUrl: z.url().nullable()
|
|
1313
1756
|
});
|
|
1314
|
-
const
|
|
1757
|
+
const isValidTimeInput = (value) => {
|
|
1315
1758
|
if (ms(value) !== void 0) return true;
|
|
1316
1759
|
return !Number.isNaN(new Date(value).getTime());
|
|
1317
1760
|
};
|
|
1318
|
-
const
|
|
1761
|
+
const timeInputSchema = z.string().refine(isValidTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." });
|
|
1762
|
+
const base = oc.errors({ BAD_REQUEST: {} });
|
|
1763
|
+
const createEnvironmentContractV1 = base.route({
|
|
1319
1764
|
path: "/v1/environments",
|
|
1320
1765
|
method: "POST",
|
|
1321
1766
|
summary: "Create an environment",
|
|
1322
1767
|
description: "Create an environment for a project",
|
|
1323
1768
|
tags: ["environments"],
|
|
1324
1769
|
successDescription: "The environment has been created successfully"
|
|
1325
|
-
}).errors({
|
|
1326
|
-
NOT_FOUND: {},
|
|
1327
|
-
BAD_REQUEST: {}
|
|
1328
|
-
}).input(z.object({
|
|
1770
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1329
1771
|
projectId: z.string().describe("The ID of the project to create the environment for"),
|
|
1330
1772
|
name: z.string().min(1).describe("The name of the environment"),
|
|
1331
1773
|
sourceBranch: z.string().min(1).describe("The branch used to build the environment"),
|
|
@@ -1338,7 +1780,7 @@ const createEnvironmentContractV1 = oc.route({
|
|
|
1338
1780
|
createdAt: z.coerce.date(),
|
|
1339
1781
|
projectId: z.string().describe("The ID of the project the environment belongs to")
|
|
1340
1782
|
}));
|
|
1341
|
-
const getEnvironmentContractV1 =
|
|
1783
|
+
const getEnvironmentContractV1 = base.route({
|
|
1342
1784
|
path: "/v1/environments/{environmentId}",
|
|
1343
1785
|
method: "GET",
|
|
1344
1786
|
summary: "Get an environment",
|
|
@@ -1354,6 +1796,14 @@ const getEnvironmentContractV1 = oc.route({
|
|
|
1354
1796
|
createdAt: z.coerce.date(),
|
|
1355
1797
|
projectId: z.string()
|
|
1356
1798
|
}));
|
|
1799
|
+
const deleteEnvironmentContractV1 = base.route({
|
|
1800
|
+
path: "/v1/environments/{environmentId}",
|
|
1801
|
+
method: "DELETE",
|
|
1802
|
+
summary: "Delete an environment",
|
|
1803
|
+
description: "All environments can be deleted except the production environment. This operation is not reversible: associated logs, analytics, and metrics are deleted as well.",
|
|
1804
|
+
tags: ["environments"],
|
|
1805
|
+
successDescription: "The environment has been deleted successfully"
|
|
1806
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.object({ success: z.literal(true) }));
|
|
1357
1807
|
const domainSchema = z.object({
|
|
1358
1808
|
domain: z.string(),
|
|
1359
1809
|
status: z.enum([
|
|
@@ -1395,7 +1845,7 @@ const projectOutputSchema = z.object({
|
|
|
1395
1845
|
productionEnvironment: productionEnvironmentSchema.nullable(),
|
|
1396
1846
|
environments: z.array(environmentSchema)
|
|
1397
1847
|
});
|
|
1398
|
-
const getProjectContractV1 =
|
|
1848
|
+
const getProjectContractV1 = base.route({
|
|
1399
1849
|
path: "/v1/projects/{projectId}",
|
|
1400
1850
|
method: "GET",
|
|
1401
1851
|
summary: "Get a project",
|
|
@@ -1403,18 +1853,15 @@ const getProjectContractV1 = oc.route({
|
|
|
1403
1853
|
tags: ["projects"],
|
|
1404
1854
|
successDescription: "The project details"
|
|
1405
1855
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(projectOutputSchema);
|
|
1406
|
-
const listProjectsContractV1 =
|
|
1856
|
+
const listProjectsContractV1 = base.route({
|
|
1407
1857
|
path: "/v1/projects",
|
|
1408
1858
|
method: "GET",
|
|
1409
1859
|
summary: "List projects",
|
|
1410
1860
|
description: "List all projects for a team",
|
|
1411
1861
|
tags: ["projects"],
|
|
1412
1862
|
successDescription: "The list of projects"
|
|
1413
|
-
}).errors({
|
|
1414
|
-
|
|
1415
|
-
BAD_REQUEST: {}
|
|
1416
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1417
|
-
const createProjectContractV1 = oc.route({
|
|
1863
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1864
|
+
const createProjectContractV1 = base.route({
|
|
1418
1865
|
path: "/v1/projects",
|
|
1419
1866
|
method: "POST",
|
|
1420
1867
|
summary: "Create a project",
|
|
@@ -1423,7 +1870,7 @@ const createProjectContractV1 = oc.route({
|
|
|
1423
1870
|
successDescription: "The project has been created successfully"
|
|
1424
1871
|
}).errors({
|
|
1425
1872
|
NOT_FOUND: {},
|
|
1426
|
-
|
|
1873
|
+
FORBIDDEN: {}
|
|
1427
1874
|
}).input(z.object({
|
|
1428
1875
|
teamId: z.string().optional(),
|
|
1429
1876
|
name: z.string().trim().min(1).max(100),
|
|
@@ -1463,7 +1910,7 @@ const environmentVariableOutputSchema = z.object({
|
|
|
1463
1910
|
isSecret: z.boolean(),
|
|
1464
1911
|
createdAt: z.coerce.date()
|
|
1465
1912
|
});
|
|
1466
|
-
const listEnvironmentVariablesContractV1 =
|
|
1913
|
+
const listEnvironmentVariablesContractV1 = base.route({
|
|
1467
1914
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1468
1915
|
method: "GET",
|
|
1469
1916
|
summary: "List environment variables",
|
|
@@ -1471,48 +1918,39 @@ const listEnvironmentVariablesContractV1 = oc.route({
|
|
|
1471
1918
|
tags: ["environments"],
|
|
1472
1919
|
successDescription: "The list of environment variables"
|
|
1473
1920
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(environmentVariableOutputSchema));
|
|
1474
|
-
const createEnvironmentVariablesContractV1 =
|
|
1921
|
+
const createEnvironmentVariablesContractV1 = base.route({
|
|
1475
1922
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1476
1923
|
method: "POST",
|
|
1477
1924
|
summary: "Add environment variables",
|
|
1478
1925
|
description: "Add one or more environment variables to an environment",
|
|
1479
1926
|
tags: ["environments"],
|
|
1480
1927
|
successDescription: "The environment variables have been added successfully"
|
|
1481
|
-
}).errors({
|
|
1482
|
-
NOT_FOUND: {},
|
|
1483
|
-
BAD_REQUEST: {}
|
|
1484
|
-
}).input(z.object({
|
|
1928
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1485
1929
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1486
1930
|
environmentVariables: environmentVariablesSchema
|
|
1487
1931
|
})).output(z.object({ success: z.literal(true) }));
|
|
1488
|
-
const updateEnvironmentVariableContractV1 =
|
|
1932
|
+
const updateEnvironmentVariableContractV1 = base.route({
|
|
1489
1933
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1490
1934
|
method: "PATCH",
|
|
1491
1935
|
summary: "Update an environment variable",
|
|
1492
1936
|
description: "Update an environment variable by ID",
|
|
1493
1937
|
tags: ["environments"],
|
|
1494
1938
|
successDescription: "The environment variable has been updated successfully"
|
|
1495
|
-
}).errors({
|
|
1496
|
-
NOT_FOUND: {},
|
|
1497
|
-
BAD_REQUEST: {}
|
|
1498
|
-
}).input(z.object({
|
|
1939
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1499
1940
|
environmentVariableId: z.string().describe("The ID of the environment variable"),
|
|
1500
1941
|
key: environmentVariableSchema.shape.key,
|
|
1501
1942
|
value: environmentVariableSchema.shape.value.optional(),
|
|
1502
1943
|
isSecret: environmentVariableSchema.shape.isSecret.optional()
|
|
1503
1944
|
})).output(z.object({ success: z.literal(true) }));
|
|
1504
|
-
const deleteEnvironmentVariableContractV1 =
|
|
1945
|
+
const deleteEnvironmentVariableContractV1 = base.route({
|
|
1505
1946
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1506
1947
|
method: "DELETE",
|
|
1507
1948
|
summary: "Delete an environment variable",
|
|
1508
1949
|
description: "Delete an environment variable by ID",
|
|
1509
1950
|
tags: ["environments"],
|
|
1510
1951
|
successDescription: "The environment variable has been deleted successfully"
|
|
1511
|
-
}).errors({
|
|
1512
|
-
|
|
1513
|
-
BAD_REQUEST: {}
|
|
1514
|
-
}).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
1515
|
-
const deleteProjectContractV1 = oc.route({
|
|
1952
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
1953
|
+
const deleteProjectContractV1 = base.route({
|
|
1516
1954
|
path: "/v1/projects/{projectId}",
|
|
1517
1955
|
method: "DELETE",
|
|
1518
1956
|
summary: "Delete a project",
|
|
@@ -1520,7 +1958,7 @@ const deleteProjectContractV1 = oc.route({
|
|
|
1520
1958
|
tags: ["projects"],
|
|
1521
1959
|
successDescription: "The project has been deleted successfully"
|
|
1522
1960
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.object({ success: z.literal(true) }));
|
|
1523
|
-
const updateProjectContractV1 =
|
|
1961
|
+
const updateProjectContractV1 = base.route({
|
|
1524
1962
|
path: "/v1/projects/{projectId}",
|
|
1525
1963
|
method: "PATCH",
|
|
1526
1964
|
summary: "Update a project",
|
|
@@ -1529,13 +1967,13 @@ const updateProjectContractV1 = oc.route({
|
|
|
1529
1967
|
successDescription: "The project has been updated successfully"
|
|
1530
1968
|
}).errors({
|
|
1531
1969
|
NOT_FOUND: {},
|
|
1532
|
-
|
|
1970
|
+
FORBIDDEN: {}
|
|
1533
1971
|
}).input(z.object({
|
|
1534
1972
|
projectId: z.string().describe("The ID of the project"),
|
|
1535
1973
|
name: z.string().min(1).max(100).optional().describe("The new name for the project"),
|
|
1536
1974
|
sourceRepository: z.string().nullable().optional().describe("The source repository to connect to the project")
|
|
1537
1975
|
})).output(projectOutputSchema);
|
|
1538
|
-
const deployEnvironmentContractV1 =
|
|
1976
|
+
const deployEnvironmentContractV1 = base.route({
|
|
1539
1977
|
path: "/v1/environments/{environmentId}/deploy",
|
|
1540
1978
|
method: "POST",
|
|
1541
1979
|
summary: "Deploy an environment",
|
|
@@ -1544,27 +1982,25 @@ const deployEnvironmentContractV1 = oc.route({
|
|
|
1544
1982
|
successDescription: "The environment has been deployed successfully"
|
|
1545
1983
|
}).errors({
|
|
1546
1984
|
NOT_FOUND: {},
|
|
1547
|
-
|
|
1985
|
+
CONFLICT: {}
|
|
1548
1986
|
}).input(z.object({
|
|
1549
1987
|
environmentId: z.string().describe("The ID of the environment to deploy"),
|
|
1550
|
-
token: z.string().describe("The token to identify the source archive").optional()
|
|
1988
|
+
token: z.string().describe("The token to identify the source archive").optional(),
|
|
1989
|
+
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.")
|
|
1551
1990
|
})).output(deploymentSchema);
|
|
1552
|
-
const uploadDeploymentArtifactContractV1 =
|
|
1991
|
+
const uploadDeploymentArtifactContractV1 = base.route({
|
|
1553
1992
|
path: "/v1/deployments/upload",
|
|
1554
1993
|
method: "POST",
|
|
1555
1994
|
summary: "Upload deployment artifacts",
|
|
1556
1995
|
description: "Return a presigned S3 URL to upload a deployment artifact",
|
|
1557
1996
|
tags: ["deployments"],
|
|
1558
1997
|
successDescription: "The presigned upload URL has been generated successfully"
|
|
1559
|
-
}).errors({
|
|
1560
|
-
NOT_FOUND: {},
|
|
1561
|
-
BAD_REQUEST: {}
|
|
1562
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
1998
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
1563
1999
|
uploadUrl: z.url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
|
|
1564
2000
|
token: z.string().describe("Token to identify the source archive"),
|
|
1565
2001
|
expiresAt: z.coerce.date().describe("Expiration date of the presigned URL")
|
|
1566
2002
|
}));
|
|
1567
|
-
const listDeploymentsContractV1 =
|
|
2003
|
+
const listDeploymentsContractV1 = base.route({
|
|
1568
2004
|
path: "/v1/projects/{projectId}/deployments",
|
|
1569
2005
|
method: "GET",
|
|
1570
2006
|
summary: "List project deployments",
|
|
@@ -1576,7 +2012,7 @@ const listDeploymentsContractV1 = oc.route({
|
|
|
1576
2012
|
status: z.array(deploymentStatusSchema).optional().describe("Filter by one or more statuses"),
|
|
1577
2013
|
environmentId: z.string().optional().describe("Filter by environment ID")
|
|
1578
2014
|
})).output(z.array(deploymentSchema));
|
|
1579
|
-
const getDeploymentContractV1 =
|
|
2015
|
+
const getDeploymentContractV1 = base.route({
|
|
1580
2016
|
path: "/v1/deployments/{deploymentId}",
|
|
1581
2017
|
method: "GET",
|
|
1582
2018
|
summary: "Get a deployment",
|
|
@@ -1584,20 +2020,32 @@ const getDeploymentContractV1 = oc.route({
|
|
|
1584
2020
|
tags: ["deployments"],
|
|
1585
2021
|
successDescription: "The deployment details"
|
|
1586
2022
|
}).errors({ NOT_FOUND: {} }).input(z.object({ deploymentId: z.string().describe("The ID of the deployment") })).output(deploymentSchema);
|
|
1587
|
-
const
|
|
2023
|
+
const logEntrySchema = z.object({
|
|
2024
|
+
timestamp: z.coerce.date(),
|
|
2025
|
+
type: z.enum([
|
|
2026
|
+
"START",
|
|
2027
|
+
"END",
|
|
2028
|
+
"INFO",
|
|
2029
|
+
"ERROR",
|
|
2030
|
+
"WARNING",
|
|
2031
|
+
"DEBUG"
|
|
2032
|
+
]),
|
|
2033
|
+
requestId: z.string(),
|
|
2034
|
+
content: z.string().optional(),
|
|
2035
|
+
method: z.string().optional(),
|
|
2036
|
+
durationInMs: z.number().optional()
|
|
2037
|
+
});
|
|
2038
|
+
const getLogsContractV1 = base.route({
|
|
1588
2039
|
path: "/v1/environments/{environmentId}/logs",
|
|
1589
2040
|
method: "GET",
|
|
1590
2041
|
summary: "Get logs",
|
|
1591
2042
|
description: "Get logs for an environment",
|
|
1592
2043
|
tags: ["environments"],
|
|
1593
2044
|
successDescription: "The logs"
|
|
1594
|
-
}).errors({
|
|
1595
|
-
NOT_FOUND: {},
|
|
1596
|
-
BAD_REQUEST: {}
|
|
1597
|
-
}).input(z.object({
|
|
2045
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1598
2046
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1599
|
-
since:
|
|
1600
|
-
until:
|
|
2047
|
+
since: timeInputSchema.optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
2048
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
1601
2049
|
limit: z.coerce.number().int().min(1).max(1e3).default(1e3).describe("Maximum number of log entries to return."),
|
|
1602
2050
|
level: z.array(z.enum([
|
|
1603
2051
|
"INFO",
|
|
@@ -1605,37 +2053,20 @@ const getLogsContractV1 = oc.route({
|
|
|
1605
2053
|
"WARNING",
|
|
1606
2054
|
"DEBUG"
|
|
1607
2055
|
])).optional().describe("Filter by log level"),
|
|
1608
|
-
search:
|
|
2056
|
+
search: logSearchSchema.optional().describe("Term to search for in log content"),
|
|
1609
2057
|
nextToken: z.string().optional().describe("Pagination token from a previous response")
|
|
1610
2058
|
})).output(z.object({
|
|
1611
|
-
logs: z.array(
|
|
1612
|
-
timestamp: z.coerce.date(),
|
|
1613
|
-
type: z.enum([
|
|
1614
|
-
"START",
|
|
1615
|
-
"END",
|
|
1616
|
-
"INFO",
|
|
1617
|
-
"ERROR",
|
|
1618
|
-
"WARNING",
|
|
1619
|
-
"DEBUG"
|
|
1620
|
-
]),
|
|
1621
|
-
requestId: z.string(),
|
|
1622
|
-
content: z.string().optional(),
|
|
1623
|
-
method: z.string().optional(),
|
|
1624
|
-
durationInMs: z.number().optional()
|
|
1625
|
-
})),
|
|
2059
|
+
logs: z.array(logEntrySchema),
|
|
1626
2060
|
nextToken: z.string().nullable()
|
|
1627
2061
|
}));
|
|
1628
|
-
const getLatestLogsContractV1 =
|
|
2062
|
+
const getLatestLogsContractV1 = base.route({
|
|
1629
2063
|
path: "/v1/environments/{environmentId}/latest-logs",
|
|
1630
2064
|
method: "GET",
|
|
1631
2065
|
summary: "Get latest logs",
|
|
1632
2066
|
description: "Get the N most recent logs for an environment",
|
|
1633
2067
|
tags: ["environments"],
|
|
1634
2068
|
successDescription: "The latest logs"
|
|
1635
|
-
}).errors({
|
|
1636
|
-
NOT_FOUND: {},
|
|
1637
|
-
BAD_REQUEST: {}
|
|
1638
|
-
}).input(z.object({
|
|
2069
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1639
2070
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1640
2071
|
limit: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of most recent log entries to return"),
|
|
1641
2072
|
level: z.array(z.enum([
|
|
@@ -1644,23 +2075,9 @@ const getLatestLogsContractV1 = oc.route({
|
|
|
1644
2075
|
"WARNING",
|
|
1645
2076
|
"DEBUG"
|
|
1646
2077
|
])).optional().describe("Filter by log level"),
|
|
1647
|
-
search:
|
|
1648
|
-
})).output(z.object({ logs: z.array(
|
|
1649
|
-
|
|
1650
|
-
type: z.enum([
|
|
1651
|
-
"START",
|
|
1652
|
-
"END",
|
|
1653
|
-
"INFO",
|
|
1654
|
-
"ERROR",
|
|
1655
|
-
"WARNING",
|
|
1656
|
-
"DEBUG"
|
|
1657
|
-
]),
|
|
1658
|
-
requestId: z.string(),
|
|
1659
|
-
content: z.string().optional(),
|
|
1660
|
-
method: z.string().optional(),
|
|
1661
|
-
durationInMs: z.number().optional()
|
|
1662
|
-
})) }));
|
|
1663
|
-
const getDeploymentLogsContractV1 = oc.route({
|
|
2078
|
+
search: logSearchSchema.optional().describe("Term to search for in log content")
|
|
2079
|
+
})).output(z.object({ logs: z.array(logEntrySchema) }));
|
|
2080
|
+
const getDeploymentLogsContractV1 = base.route({
|
|
1664
2081
|
path: "/v1/deployments/{deploymentId}/logs",
|
|
1665
2082
|
method: "GET",
|
|
1666
2083
|
summary: "Get deployment logs",
|
|
@@ -1687,22 +2104,19 @@ const analyticsTimeSeriesSchema = z.object({
|
|
|
1687
2104
|
output_token_mean: z.array(analyticsDataPointSchema),
|
|
1688
2105
|
task_count: z.array(analyticsDataPointSchema)
|
|
1689
2106
|
});
|
|
1690
|
-
const getProjectAnalyticsContractV1 =
|
|
2107
|
+
const getProjectAnalyticsContractV1 = base.route({
|
|
1691
2108
|
path: "/v1/analytics/{projectId}",
|
|
1692
2109
|
method: "GET",
|
|
1693
2110
|
summary: "Get project analytics",
|
|
1694
2111
|
description: "Get analytics data for a project over a time range",
|
|
1695
2112
|
tags: ["analytics"],
|
|
1696
2113
|
successDescription: "The project analytics data"
|
|
1697
|
-
}).errors({
|
|
1698
|
-
NOT_FOUND: {},
|
|
1699
|
-
BAD_REQUEST: {}
|
|
1700
|
-
}).input(z.object({
|
|
2114
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1701
2115
|
projectId: z.string().describe("The ID of the project"),
|
|
1702
2116
|
startTimestamp: z.coerce.number().describe("Start timestamp in milliseconds"),
|
|
1703
2117
|
endTimestamp: z.coerce.number().describe("End timestamp in milliseconds"),
|
|
1704
2118
|
timeZone: z.string().describe("IANA timezone (e.g. Europe/Paris)")
|
|
1705
|
-
}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <=
|
|
2119
|
+
}).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({
|
|
1706
2120
|
metadata: z.object({
|
|
1707
2121
|
startTimestamp: z.number(),
|
|
1708
2122
|
endTimestamp: z.number(),
|
|
@@ -1712,7 +2126,132 @@ const getProjectAnalyticsContractV1 = oc.route({
|
|
|
1712
2126
|
}),
|
|
1713
2127
|
timeSeries: analyticsTimeSeriesSchema
|
|
1714
2128
|
}));
|
|
1715
|
-
const
|
|
2129
|
+
const paginatedInsightsInputShape = {
|
|
2130
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2131
|
+
since: timeInputSchema.default("7d").describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
2132
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
2133
|
+
limit: z.coerce.number().int().min(1).max(200).default(50),
|
|
2134
|
+
offset: z.coerce.number().int().min(0).default(0),
|
|
2135
|
+
search: z.string().trim().min(1).max(200).optional()
|
|
2136
|
+
};
|
|
2137
|
+
const listIntentsContractV1 = base.route({
|
|
2138
|
+
path: "/v1/environments/{environmentId}/intents",
|
|
2139
|
+
method: "GET",
|
|
2140
|
+
summary: "List intents",
|
|
2141
|
+
description: "List grouped user intents for an environment over a time range",
|
|
2142
|
+
tags: ["insights"],
|
|
2143
|
+
successDescription: "The grouped user intents"
|
|
2144
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2145
|
+
...paginatedInsightsInputShape,
|
|
2146
|
+
tools: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
2147
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional(),
|
|
2148
|
+
categoryIds: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
2149
|
+
sortDir: z.enum(["asc", "desc"]).default("desc")
|
|
2150
|
+
})).output(z.object({
|
|
2151
|
+
intents: z.array(z.object({
|
|
2152
|
+
id: z.string(),
|
|
2153
|
+
intentIds: z.array(z.string()).min(1),
|
|
2154
|
+
environmentId: z.string(),
|
|
2155
|
+
message: z.string(),
|
|
2156
|
+
toolName: z.string(),
|
|
2157
|
+
createdAt: z.coerce.date(),
|
|
2158
|
+
occurrenceCount: z.number().int().positive(),
|
|
2159
|
+
clientName: z.string().nullable(),
|
|
2160
|
+
clientId: z.string().nullable(),
|
|
2161
|
+
categories: z.array(z.object({
|
|
2162
|
+
id: z.string(),
|
|
2163
|
+
name: z.string(),
|
|
2164
|
+
color: intentCategoryColorSchema
|
|
2165
|
+
}))
|
|
2166
|
+
})),
|
|
2167
|
+
totalCount: z.number().int().nonnegative()
|
|
2168
|
+
}));
|
|
2169
|
+
const listFeedbacksContractV1 = base.route({
|
|
2170
|
+
path: "/v1/environments/{environmentId}/feedbacks",
|
|
2171
|
+
method: "GET",
|
|
2172
|
+
summary: "List feedbacks",
|
|
2173
|
+
description: "List user feedback for an environment over a time range",
|
|
2174
|
+
tags: ["insights"],
|
|
2175
|
+
successDescription: "The user feedback"
|
|
2176
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2177
|
+
...paginatedInsightsInputShape,
|
|
2178
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional()
|
|
2179
|
+
})).output(z.object({
|
|
2180
|
+
feedbacks: z.array(feedbackSchema.extend({ clientId: z.string().nullable() })),
|
|
2181
|
+
totalCount: z.number().int().nonnegative()
|
|
2182
|
+
}));
|
|
2183
|
+
const intentCategoryNameSchema = z.string().trim().min(1).max(100).describe("The category name");
|
|
2184
|
+
const categorizableIntentIdsSchema = z.array(z.string().trim().min(1)).min(1).max(100).describe("IDs of the intents to categorize");
|
|
2185
|
+
const listIntentCategoriesContractV1 = base.route({
|
|
2186
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
2187
|
+
method: "GET",
|
|
2188
|
+
summary: "List intent categories",
|
|
2189
|
+
description: "List intent categories for an environment, including how many intents each category is linked to",
|
|
2190
|
+
tags: ["insights"],
|
|
2191
|
+
successDescription: "The intent categories"
|
|
2192
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(intentCategorySummarySchema));
|
|
2193
|
+
const createIntentCategoryContractV1 = base.route({
|
|
2194
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
2195
|
+
method: "POST",
|
|
2196
|
+
summary: "Create an intent category",
|
|
2197
|
+
description: "Create an intent category, optionally linking it to existing intents",
|
|
2198
|
+
tags: ["insights"],
|
|
2199
|
+
successDescription: "The created intent category"
|
|
2200
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2201
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2202
|
+
name: intentCategoryNameSchema,
|
|
2203
|
+
color: intentCategoryColorSchema.optional().describe("The category color; derived from the name when omitted"),
|
|
2204
|
+
intentIds: categorizableIntentIdsSchema.optional().describe("IDs of intents to link to the new category")
|
|
2205
|
+
})).output(intentCategorySchema);
|
|
2206
|
+
const updateIntentCategoryContractV1 = base.route({
|
|
2207
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
2208
|
+
method: "PATCH",
|
|
2209
|
+
summary: "Update an intent category",
|
|
2210
|
+
description: "Rename or recolor an intent category",
|
|
2211
|
+
tags: ["insights"],
|
|
2212
|
+
successDescription: "The updated intent category"
|
|
2213
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2214
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2215
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2216
|
+
name: intentCategoryNameSchema.optional(),
|
|
2217
|
+
color: intentCategoryColorSchema.optional().describe("The category color")
|
|
2218
|
+
}).refine(({ name, color }) => name !== void 0 || color !== void 0, { message: "At least one of name or color must be provided" })).output(intentCategorySchema);
|
|
2219
|
+
const deleteIntentCategoryContractV1 = base.route({
|
|
2220
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
2221
|
+
method: "DELETE",
|
|
2222
|
+
summary: "Delete an intent category",
|
|
2223
|
+
description: "Delete an intent category; its intents are unlinked but not deleted",
|
|
2224
|
+
tags: ["insights"],
|
|
2225
|
+
successDescription: "The intent category has been deleted successfully"
|
|
2226
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2227
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2228
|
+
categoryId: z.string().describe("The ID of the category")
|
|
2229
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2230
|
+
const linkIntentCategoryContractV1 = base.route({
|
|
2231
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/link",
|
|
2232
|
+
method: "POST",
|
|
2233
|
+
summary: "Link an intent category",
|
|
2234
|
+
description: "Link an intent category to intents; already linked intents are ignored",
|
|
2235
|
+
tags: ["insights"],
|
|
2236
|
+
successDescription: "The intents have been linked successfully"
|
|
2237
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2238
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2239
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2240
|
+
intentIds: categorizableIntentIdsSchema
|
|
2241
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2242
|
+
const unlinkIntentCategoryContractV1 = base.route({
|
|
2243
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/unlink",
|
|
2244
|
+
method: "POST",
|
|
2245
|
+
summary: "Unlink an intent category",
|
|
2246
|
+
description: "Unlink an intent category from intents; intents without the category are ignored",
|
|
2247
|
+
tags: ["insights"],
|
|
2248
|
+
successDescription: "The intents have been unlinked successfully"
|
|
2249
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2250
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2251
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2252
|
+
intentIds: categorizableIntentIdsSchema
|
|
2253
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2254
|
+
const listTeamsContractV1 = base.route({
|
|
1716
2255
|
path: "/v1/teams",
|
|
1717
2256
|
method: "GET",
|
|
1718
2257
|
summary: "List teams",
|
|
@@ -1725,28 +2264,40 @@ const listTeamsContractV1 = oc.route({
|
|
|
1725
2264
|
createdAt: z.coerce.date(),
|
|
1726
2265
|
hasStripeAccount: z.boolean()
|
|
1727
2266
|
})));
|
|
1728
|
-
const
|
|
2267
|
+
const getTeamUsageContractV1 = base.route({
|
|
2268
|
+
path: "/v1/teams/{teamId}/usage",
|
|
2269
|
+
method: "GET",
|
|
2270
|
+
summary: "Get team usage",
|
|
2271
|
+
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.",
|
|
2272
|
+
tags: ["teams"],
|
|
2273
|
+
successDescription: "The current billing window usage"
|
|
2274
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().describe("The ID of the team") })).output(z.object({
|
|
2275
|
+
teamId: z.string(),
|
|
2276
|
+
plan: subscriptionPlanSchema.nullable().describe("The plan in force for the window, null on the Free plan"),
|
|
2277
|
+
periodStart: z.coerce.date().describe("Start of the current billing window"),
|
|
2278
|
+
periodEnd: z.coerce.date().describe("End of the current billing window"),
|
|
2279
|
+
requestCount: z.number().int().describe("MCP requests settled during the current billing window"),
|
|
2280
|
+
includedRequests: z.number().int().nullable().describe("Requests included in the plan for one window, null when the allowance is contract-specific")
|
|
2281
|
+
}));
|
|
2282
|
+
const getTunnelTicketContractV1 = base.route({
|
|
1729
2283
|
path: "/v1/tunnels/ticket",
|
|
1730
2284
|
method: "GET",
|
|
1731
2285
|
summary: "Get a tunnel ticket",
|
|
1732
2286
|
description: "Get a signed ticket for establishing a tunnel connection. Requires user authentication (API keys are not supported).",
|
|
1733
2287
|
tags: ["tunnels"],
|
|
1734
2288
|
successDescription: "The tunnel ticket"
|
|
1735
|
-
}).errors({ FORBIDDEN: {} }).output(z.object({
|
|
2289
|
+
}).meta({ authScope: AUTH_SCOPE_USER }).errors({ FORBIDDEN: {} }).output(z.object({
|
|
1736
2290
|
subdomain: z.string().describe("The subdomain assigned to the user"),
|
|
1737
2291
|
ticket: z.string().describe("The signed tunnel ticket"),
|
|
1738
2292
|
tunnelHost: z.string().describe("The tunnel host to connect to")
|
|
1739
2293
|
}));
|
|
1740
|
-
const publishServerContractV1 =
|
|
2294
|
+
const publishServerContractV1 = base.route({
|
|
1741
2295
|
path: "/v1/distribution/publish",
|
|
1742
2296
|
method: "POST",
|
|
1743
2297
|
summary: "Publish a server to the MCP registry",
|
|
1744
2298
|
tags: ["distribution"],
|
|
1745
2299
|
successDescription: "The server has been published successfully"
|
|
1746
|
-
}).errors({
|
|
1747
|
-
NOT_FOUND: {},
|
|
1748
|
-
BAD_REQUEST: {}
|
|
1749
|
-
}).input(z.object({
|
|
2300
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1750
2301
|
projectId: z.string(),
|
|
1751
2302
|
domain: z.string(),
|
|
1752
2303
|
title: z.string().min(1).max(100),
|
|
@@ -1755,17 +2306,14 @@ const publishServerContractV1 = oc.route({
|
|
|
1755
2306
|
iconSrc: z.url().max(255).optional(),
|
|
1756
2307
|
dryRun: z.boolean().optional()
|
|
1757
2308
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
1758
|
-
const getServerInfoContractV1 =
|
|
2309
|
+
const getServerInfoContractV1 = base.route({
|
|
1759
2310
|
path: "/v1/distribution/get",
|
|
1760
2311
|
method: "GET",
|
|
1761
2312
|
summary: "Get server info",
|
|
1762
2313
|
description: "Get info about a server",
|
|
1763
2314
|
tags: ["distribution"],
|
|
1764
2315
|
successDescription: "The server info"
|
|
1765
|
-
}).errors({
|
|
1766
|
-
NOT_FOUND: {},
|
|
1767
|
-
BAD_REQUEST: {}
|
|
1768
|
-
}).input(z.object({
|
|
2316
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1769
2317
|
projectId: z.string(),
|
|
1770
2318
|
domain: z.string()
|
|
1771
2319
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
@@ -1784,7 +2332,7 @@ const playgroundOutputSchema = z.object({
|
|
|
1784
2332
|
isPlaygroundEnabled: z.boolean(),
|
|
1785
2333
|
serverMetadata: playgroundServerMetadataOutputSchema.nullable()
|
|
1786
2334
|
});
|
|
1787
|
-
const getPlaygroundContractV1 =
|
|
2335
|
+
const getPlaygroundContractV1 = base.route({
|
|
1788
2336
|
path: "/v1/environments/{environmentId}/playground",
|
|
1789
2337
|
method: "GET",
|
|
1790
2338
|
summary: "Get playground configuration",
|
|
@@ -1792,17 +2340,14 @@ const getPlaygroundContractV1 = oc.route({
|
|
|
1792
2340
|
tags: ["environments"],
|
|
1793
2341
|
successDescription: "The playground configuration"
|
|
1794
2342
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(playgroundOutputSchema);
|
|
1795
|
-
const upsertPlaygroundContractV1 =
|
|
2343
|
+
const upsertPlaygroundContractV1 = base.route({
|
|
1796
2344
|
path: "/v1/environments/{environmentId}/playground",
|
|
1797
2345
|
method: "PUT",
|
|
1798
2346
|
summary: "Update playground configuration",
|
|
1799
2347
|
description: "Update the playground configuration for an environment. All fields are optional — only provided fields are updated.",
|
|
1800
2348
|
tags: ["environments"],
|
|
1801
2349
|
successDescription: "The updated playground configuration"
|
|
1802
|
-
}).errors({
|
|
1803
|
-
NOT_FOUND: {},
|
|
1804
|
-
BAD_REQUEST: {}
|
|
1805
|
-
}).input(z.object({
|
|
2350
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1806
2351
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1807
2352
|
isPlaygroundEnabled: z.boolean().optional(),
|
|
1808
2353
|
name: z.string().min(1).max(100).optional(),
|
|
@@ -1810,7 +2355,7 @@ const upsertPlaygroundContractV1 = oc.route({
|
|
|
1810
2355
|
headers: z.array(playgroundHeaderSchema).optional(),
|
|
1811
2356
|
examplePrompts: z.array(playgroundExamplePromptSchema).max(5).optional()
|
|
1812
2357
|
})).output(playgroundOutputSchema);
|
|
1813
|
-
const createBeaconContractV1 =
|
|
2358
|
+
const createBeaconContractV1 = base.route({
|
|
1814
2359
|
path: "/v1/beacon/audits",
|
|
1815
2360
|
method: "POST",
|
|
1816
2361
|
summary: "Create a beacon audit",
|
|
@@ -1819,7 +2364,6 @@ const createBeaconContractV1 = oc.route({
|
|
|
1819
2364
|
successDescription: "The audit has been created"
|
|
1820
2365
|
}).errors({
|
|
1821
2366
|
NOT_FOUND: {},
|
|
1822
|
-
BAD_REQUEST: {},
|
|
1823
2367
|
DNS_RESOLUTION_FAILED: { status: 400 }
|
|
1824
2368
|
}).input(z.object({
|
|
1825
2369
|
targetUrl: z.url().describe("The HTTPS URL of the MCP server to audit"),
|
|
@@ -1827,7 +2371,7 @@ const createBeaconContractV1 = oc.route({
|
|
|
1827
2371
|
projectId: z.string().optional().describe("The project ID to associate the audit with"),
|
|
1828
2372
|
excludeCategories: z.array(checkCategorySchema).optional().describe("Check categories to exclude from the audit")
|
|
1829
2373
|
})).output(z.object({ id: z.string() }));
|
|
1830
|
-
const getBeaconContractV1 =
|
|
2374
|
+
const getBeaconContractV1 = base.route({
|
|
1831
2375
|
path: "/v1/beacon/audits/{auditId}",
|
|
1832
2376
|
method: "GET",
|
|
1833
2377
|
summary: "Get a beacon audit",
|
|
@@ -1842,9 +2386,73 @@ const getBeaconContractV1 = oc.route({
|
|
|
1842
2386
|
createdAt: z.coerce.date(),
|
|
1843
2387
|
report: auditReportWithScreenshotsSchema.nullable()
|
|
1844
2388
|
}));
|
|
2389
|
+
const PLATFORM_DESCRIPTION = "The directory the package targets: `chatgpt` for the OpenAI App Directory, `claudeai` for the Anthropic MCP Directory";
|
|
2390
|
+
const submissionIdSchema = z.string().describe("The ID of the submission package");
|
|
2391
|
+
const claudeSubmissionUpdateSchema = claudeSubmissionDraftSchema.strict();
|
|
2392
|
+
const chatgptSubmissionUpdateSchema = chatgptSubmissionDraftSchema.strict();
|
|
2393
|
+
const createSubmissionContractV1 = base.route({
|
|
2394
|
+
path: "/v1/submissions",
|
|
2395
|
+
method: "POST",
|
|
2396
|
+
summary: "Create a submission package",
|
|
2397
|
+
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.",
|
|
2398
|
+
tags: ["submissions"],
|
|
2399
|
+
successDescription: "The created submission package, with its prefilled fields"
|
|
2400
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2401
|
+
environmentId: z.string().describe("The ID of the environment to build the package from"),
|
|
2402
|
+
platform: platformSchema.describe(PLATFORM_DESCRIPTION)
|
|
2403
|
+
})).output(submissionSchema);
|
|
2404
|
+
const listSubmissionsContractV1 = base.route({
|
|
2405
|
+
path: "/v1/projects/{projectId}/submissions",
|
|
2406
|
+
method: "GET",
|
|
2407
|
+
summary: "List submission packages",
|
|
2408
|
+
description: "List the submission packages of a project, grouped by directory and most recently updated first, optionally narrowed to one environment or one directory",
|
|
2409
|
+
tags: ["submissions"],
|
|
2410
|
+
successDescription: "The list of submission packages"
|
|
2411
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2412
|
+
projectId: z.string().describe("The ID of the project"),
|
|
2413
|
+
environmentId: z.string().optional().describe("Filter by environment ID"),
|
|
2414
|
+
platform: platformSchema.optional().describe(PLATFORM_DESCRIPTION)
|
|
2415
|
+
})).output(z.array(submissionSchema));
|
|
2416
|
+
const getSubmissionContractV1 = base.route({
|
|
2417
|
+
path: "/v1/submissions/{submissionId}",
|
|
2418
|
+
method: "GET",
|
|
2419
|
+
summary: "Get a submission package",
|
|
2420
|
+
description: "Get a submission package by ID, including its form data and the prefill it started from",
|
|
2421
|
+
tags: ["submissions"],
|
|
2422
|
+
successDescription: "The submission package"
|
|
2423
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ submissionId: submissionIdSchema })).output(submissionSchema);
|
|
2424
|
+
const updateSubmissionContractV1 = base.route({
|
|
2425
|
+
path: "/v1/submissions/{submissionId}",
|
|
2426
|
+
method: "PUT",
|
|
2427
|
+
summary: "Update a submission package",
|
|
2428
|
+
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.",
|
|
2429
|
+
tags: ["submissions"],
|
|
2430
|
+
successDescription: "The updated submission package"
|
|
2431
|
+
}).errors({ NOT_FOUND: {} }).input(z.discriminatedUnion("platform", [z.object({
|
|
2432
|
+
submissionId: submissionIdSchema,
|
|
2433
|
+
platform: z.literal("claudeai").describe(PLATFORM_DESCRIPTION),
|
|
2434
|
+
formData: claudeSubmissionUpdateSchema
|
|
2435
|
+
}), z.object({
|
|
2436
|
+
submissionId: submissionIdSchema,
|
|
2437
|
+
platform: z.literal("chatgpt").describe(PLATFORM_DESCRIPTION),
|
|
2438
|
+
formData: chatgptSubmissionUpdateSchema
|
|
2439
|
+
})])).output(submissionSchema);
|
|
1845
2440
|
const contract = {
|
|
1846
|
-
teams: {
|
|
2441
|
+
teams: {
|
|
2442
|
+
list: { v1: listTeamsContractV1 },
|
|
2443
|
+
getUsage: { v1: getTeamUsageContractV1 }
|
|
2444
|
+
},
|
|
1847
2445
|
analytics: { get: { v1: getProjectAnalyticsContractV1 } },
|
|
2446
|
+
intents: { list: { v1: listIntentsContractV1 } },
|
|
2447
|
+
intentCategories: {
|
|
2448
|
+
list: { v1: listIntentCategoriesContractV1 },
|
|
2449
|
+
create: { v1: createIntentCategoryContractV1 },
|
|
2450
|
+
update: { v1: updateIntentCategoryContractV1 },
|
|
2451
|
+
delete: { v1: deleteIntentCategoryContractV1 },
|
|
2452
|
+
link: { v1: linkIntentCategoryContractV1 },
|
|
2453
|
+
unlink: { v1: unlinkIntentCategoryContractV1 }
|
|
2454
|
+
},
|
|
2455
|
+
feedbacks: { list: { v1: listFeedbacksContractV1 } },
|
|
1848
2456
|
deployments: {
|
|
1849
2457
|
list: { v1: listDeploymentsContractV1 },
|
|
1850
2458
|
get: { v1: getDeploymentContractV1 },
|
|
@@ -1854,6 +2462,7 @@ const contract = {
|
|
|
1854
2462
|
environments: {
|
|
1855
2463
|
create: { v1: createEnvironmentContractV1 },
|
|
1856
2464
|
get: { v1: getEnvironmentContractV1 },
|
|
2465
|
+
delete: { v1: deleteEnvironmentContractV1 },
|
|
1857
2466
|
deploy: { v1: deployEnvironmentContractV1 },
|
|
1858
2467
|
getLogs: { v1: getLogsContractV1 },
|
|
1859
2468
|
getLatestLogs: { v1: getLatestLogsContractV1 }
|
|
@@ -1883,7 +2492,39 @@ const contract = {
|
|
|
1883
2492
|
beacon: {
|
|
1884
2493
|
create: { v1: createBeaconContractV1 },
|
|
1885
2494
|
get: { v1: getBeaconContractV1 }
|
|
2495
|
+
},
|
|
2496
|
+
submissions: {
|
|
2497
|
+
create: { v1: createSubmissionContractV1 },
|
|
2498
|
+
list: { v1: listSubmissionsContractV1 },
|
|
2499
|
+
get: { v1: getSubmissionContractV1 },
|
|
2500
|
+
update: { v1: updateSubmissionContractV1 }
|
|
2501
|
+
}
|
|
2502
|
+
};
|
|
2503
|
+
const { uploadArtifact: _discard, ...deploymentsForDocs } = contract.deployments;
|
|
2504
|
+
const contractForDocs = {
|
|
2505
|
+
...contract,
|
|
2506
|
+
deployments: deploymentsForDocs
|
|
2507
|
+
};
|
|
2508
|
+
/** Shared by the served `openapi.json` and the snapshot test that guards it, so the two cannot drift. */
|
|
2509
|
+
const OPENAPI_DOC_OPTIONS = {
|
|
2510
|
+
info: {
|
|
2511
|
+
title: "Alpic API",
|
|
2512
|
+
version: "1.0.0"
|
|
2513
|
+
},
|
|
2514
|
+
servers: [{ url: "https://api.alpic.ai" }],
|
|
2515
|
+
security: [{ bearerAuth: [] }],
|
|
2516
|
+
components: { securitySchemes: { bearerAuth: {
|
|
2517
|
+
type: "http",
|
|
2518
|
+
description: "Bearer token for authentication. Use an API key from the API Keys page in team settings, or an OAuth access token.",
|
|
2519
|
+
scheme: "bearer"
|
|
2520
|
+
} } },
|
|
2521
|
+
commonSchemas: {
|
|
2522
|
+
Submission: { schema: submissionSchema },
|
|
2523
|
+
ClaudeSubmissionFormData: { schema: claudeSubmissionDraftSchema },
|
|
2524
|
+
ChatgptSubmissionFormData: { schema: chatgptSubmissionDraftSchema },
|
|
2525
|
+
ClaudeSubmissionFormDataUpdate: { schema: claudeSubmissionUpdateSchema },
|
|
2526
|
+
ChatgptSubmissionFormDataUpdate: { schema: chatgptSubmissionUpdateSchema }
|
|
1886
2527
|
}
|
|
1887
2528
|
};
|
|
1888
2529
|
//#endregion
|
|
1889
|
-
export { PLATFORM_LABELS, buildSettingsSchema, contract, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
|
|
2530
|
+
export { AI_PLATFORMS, AUTH_SCOPE_ANY, AUTH_SCOPE_USER, INTENT_CATEGORY_COLORS, OPENAPI_DOC_OPTIONS, PLATFORM_LABELS, buildSettingsSchema, chatgptSubmissionUpdateSchema, claudeSubmissionUpdateSchema, contract, contractForDocs, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, intentCategoryColorSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
|