@alpic-ai/api 0.0.0-staging.g1fe83ac → 0.0.0-staging.g202acfa
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 +6701 -97
- package/dist/index.mjs +907 -187
- package/package.json +9 -9
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@8.1.1_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({
|
|
@@ -179,6 +189,7 @@ const PLATFORM_LABELS = {
|
|
|
179
189
|
};
|
|
180
190
|
const WAF_PLATFORMS = [
|
|
181
191
|
"akamai",
|
|
192
|
+
"cato",
|
|
182
193
|
"cloudflare",
|
|
183
194
|
"fastly"
|
|
184
195
|
];
|
|
@@ -256,6 +267,25 @@ z.object({
|
|
|
256
267
|
clientSecret: z.string(),
|
|
257
268
|
clientScopes: z.array(z.string())
|
|
258
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
|
+
});
|
|
259
289
|
const deploymentStatusSchema$1 = z.enum([
|
|
260
290
|
"ongoing",
|
|
261
291
|
"deployed",
|
|
@@ -283,33 +313,18 @@ const deploymentSummarySchema = z.object({
|
|
|
283
313
|
createdAt: z.coerce.date(),
|
|
284
314
|
updatedAt: z.coerce.date()
|
|
285
315
|
});
|
|
286
|
-
/**
|
|
287
|
-
* Public environment
|
|
288
|
-
*
|
|
289
|
-
* Answers anonymously and exposes no OAuth metadata.
|
|
290
|
-
*/
|
|
316
|
+
/** Public environment: answers anonymously and exposes no OAuth metadata. */
|
|
291
317
|
const publicEnvironmentSchema = z.object({
|
|
292
318
|
allowsAnonymous: z.literal(true),
|
|
293
319
|
oAuthMetadata: z.strictObject({})
|
|
294
320
|
});
|
|
295
|
-
/**
|
|
296
|
-
* Protected environment with an external resource metadata URL
|
|
297
|
-
*
|
|
298
|
-
* An external resource metadata URL is returned in the WWW-Authenticate header during the first 401 response.
|
|
299
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
300
|
-
*/
|
|
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. */
|
|
301
322
|
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
302
323
|
allowsAnonymous: z.boolean(),
|
|
303
324
|
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
304
325
|
scope: z.string().optional()
|
|
305
326
|
});
|
|
306
|
-
/**
|
|
307
|
-
* Protected environment with an external authorization server URL
|
|
308
|
-
*
|
|
309
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
310
|
-
* An external authorization server URL is returned when requesting the endpoint.
|
|
311
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
312
|
-
*/
|
|
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. */
|
|
313
328
|
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
314
329
|
allowsAnonymous: z.boolean(),
|
|
315
330
|
oAuthMetadata: z.object({
|
|
@@ -318,12 +333,7 @@ const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
|
318
333
|
}),
|
|
319
334
|
scope: z.string().optional()
|
|
320
335
|
});
|
|
321
|
-
/**
|
|
322
|
-
* Standalone protected environment
|
|
323
|
-
*
|
|
324
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
325
|
-
* The server itself exposes the /.well-known/oauth-authorization-server endpoint.
|
|
326
|
-
*/
|
|
336
|
+
/** Standalone protected environment: the server itself exposes both the /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server endpoints. */
|
|
327
337
|
const standaloneEnvironmentSchema = z.object({
|
|
328
338
|
allowsAnonymous: z.boolean(),
|
|
329
339
|
oAuthMetadata: z.object({
|
|
@@ -332,17 +342,12 @@ const standaloneEnvironmentSchema = z.object({
|
|
|
332
342
|
}),
|
|
333
343
|
scope: z.string().optional()
|
|
334
344
|
});
|
|
335
|
-
/**
|
|
336
|
-
* Protected environment without OAuth discovery
|
|
337
|
-
*
|
|
338
|
-
* The server enforces authentication but exposes no OAuth discovery metadata.
|
|
339
|
-
* Neither /.well-known/oauth-protected-resource nor /.well-known/oauth-authorization-server
|
|
340
|
-
* are advertised. Clients must obtain credentials out-of-band.
|
|
341
|
-
*/
|
|
345
|
+
/** Protected environment that enforces authentication but advertises no OAuth discovery metadata; clients must obtain credentials out-of-band. */
|
|
342
346
|
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
343
347
|
allowsAnonymous: z.literal(false),
|
|
344
348
|
oAuthMetadata: z.strictObject({}),
|
|
345
|
-
scope: z.string().optional()
|
|
349
|
+
scope: z.string().optional(),
|
|
350
|
+
wwwAuthenticate: z.string().optional()
|
|
346
351
|
});
|
|
347
352
|
const legacyPublicEnvironmentSchema = z.object({
|
|
348
353
|
isPublic: z.literal(true),
|
|
@@ -425,14 +430,17 @@ z.object({
|
|
|
425
430
|
collectRequestPayload: z.boolean(),
|
|
426
431
|
collectResponsePayload: z.boolean(),
|
|
427
432
|
collectErrorMessage: z.boolean(),
|
|
428
|
-
collectUserData: z.boolean()
|
|
433
|
+
collectUserData: z.boolean(),
|
|
434
|
+
identityTraitKey: z.string().min(1).max(200).nullable(),
|
|
435
|
+
leadEventName: z.string().min(1).max(200).nullable()
|
|
429
436
|
});
|
|
430
|
-
z.object({
|
|
437
|
+
const feedbackSchema = z.object({
|
|
431
438
|
id: z.string(),
|
|
432
439
|
createdAt: z.coerce.date(),
|
|
433
440
|
environmentId: z.string(),
|
|
434
441
|
content: z.string(),
|
|
435
|
-
source: z.enum(["model", "user"])
|
|
442
|
+
source: z.enum(["model", "user"]),
|
|
443
|
+
clientName: z.string().nullable()
|
|
436
444
|
});
|
|
437
445
|
z.object({
|
|
438
446
|
content: z.string(),
|
|
@@ -448,7 +456,7 @@ const intentCategoryColorSchema = z.enum([
|
|
|
448
456
|
"pink",
|
|
449
457
|
"gray"
|
|
450
458
|
]);
|
|
451
|
-
intentCategoryColorSchema.options;
|
|
459
|
+
const INTENT_CATEGORY_COLORS = intentCategoryColorSchema.options;
|
|
452
460
|
const intentCategorySchema = z.object({
|
|
453
461
|
id: z.string(),
|
|
454
462
|
createdAt: z.coerce.date(),
|
|
@@ -456,7 +464,7 @@ const intentCategorySchema = z.object({
|
|
|
456
464
|
name: z.string(),
|
|
457
465
|
color: intentCategoryColorSchema
|
|
458
466
|
});
|
|
459
|
-
z.object({
|
|
467
|
+
const intentCategorySummarySchema = z.object({
|
|
460
468
|
id: z.string(),
|
|
461
469
|
name: z.string(),
|
|
462
470
|
color: intentCategoryColorSchema,
|
|
@@ -468,6 +476,7 @@ z.object({
|
|
|
468
476
|
environmentId: z.string(),
|
|
469
477
|
toolName: z.string(),
|
|
470
478
|
message: z.string(),
|
|
479
|
+
clientName: z.string().nullable(),
|
|
471
480
|
categories: z.array(intentCategorySchema)
|
|
472
481
|
});
|
|
473
482
|
const signalCategorySchema = z.object({
|
|
@@ -526,12 +535,270 @@ z.object({
|
|
|
526
535
|
createdAt: z.coerce.date(),
|
|
527
536
|
updatedAt: z.coerce.date()
|
|
528
537
|
});
|
|
538
|
+
const alpicMcpRequestLogSchema = z.object({
|
|
539
|
+
type: z.literal("mcp_request"),
|
|
540
|
+
method: z.string()
|
|
541
|
+
});
|
|
542
|
+
const alpicMcpErrorLogSchema = z.object({
|
|
543
|
+
type: z.literal("mcp_error"),
|
|
544
|
+
method: z.string(),
|
|
545
|
+
error: z.string()
|
|
546
|
+
});
|
|
547
|
+
z.union([alpicMcpRequestLogSchema, alpicMcpErrorLogSchema]);
|
|
529
548
|
z.enum([
|
|
530
549
|
"INFO",
|
|
531
550
|
"WARNING",
|
|
532
551
|
"DEBUG",
|
|
533
552
|
"ERROR"
|
|
534
553
|
]);
|
|
554
|
+
const LOG_SEARCH_MAX_ESCAPED_LENGTH = 960;
|
|
555
|
+
function escapeLogSearchTerm(search) {
|
|
556
|
+
return [...search].flatMap((character) => [...new TextEncoder().encode(character)]).map((byte) => {
|
|
557
|
+
const character = String.fromCharCode(byte);
|
|
558
|
+
return /^[a-zA-Z0-9]$/.test(character) ? character : `\\x${byte.toString(16).toUpperCase().padStart(2, "0")}`;
|
|
559
|
+
}).join("");
|
|
560
|
+
}
|
|
561
|
+
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");
|
|
562
|
+
/** Only names a vendor actually ships belong here: lookalikes like `claude-code-test` are customers' own scripts. */
|
|
563
|
+
const MCP_CLIENT_GROUPS = [
|
|
564
|
+
{
|
|
565
|
+
id: "claude_code",
|
|
566
|
+
label: "Claude Code",
|
|
567
|
+
vendor: "anthropic",
|
|
568
|
+
rawNames: ["claude-code", "Anthropic/ClaudeCodeDesktop"]
|
|
569
|
+
},
|
|
570
|
+
{
|
|
571
|
+
id: "claude",
|
|
572
|
+
label: "Claude",
|
|
573
|
+
vendor: "anthropic",
|
|
574
|
+
rawNames: [
|
|
575
|
+
"Anthropic/ClaudeAI",
|
|
576
|
+
"claude-ai",
|
|
577
|
+
"claude",
|
|
578
|
+
"Claude",
|
|
579
|
+
"claude-desktop",
|
|
580
|
+
"claude-desktop-3p"
|
|
581
|
+
]
|
|
582
|
+
},
|
|
583
|
+
{
|
|
584
|
+
id: "claude_mobile",
|
|
585
|
+
label: "Claude mobile",
|
|
586
|
+
vendor: "anthropic",
|
|
587
|
+
rawNames: ["claude-ios", "ClaudeAndroid"]
|
|
588
|
+
},
|
|
589
|
+
{
|
|
590
|
+
id: "claude_cowork",
|
|
591
|
+
label: "Claude Cowork",
|
|
592
|
+
vendor: "anthropic",
|
|
593
|
+
rawNames: ["Anthropic/Cowork"]
|
|
594
|
+
},
|
|
595
|
+
{
|
|
596
|
+
id: "claude_toolbox",
|
|
597
|
+
label: "Claude Toolbox",
|
|
598
|
+
vendor: "anthropic",
|
|
599
|
+
rawNames: ["Anthropic/Toolbox", "Anthropic/toolbox-bootstrap"]
|
|
600
|
+
},
|
|
601
|
+
{
|
|
602
|
+
id: "anthropic_api",
|
|
603
|
+
label: "Anthropic API",
|
|
604
|
+
vendor: "anthropic",
|
|
605
|
+
rawNames: ["Anthropic/API"]
|
|
606
|
+
},
|
|
607
|
+
{
|
|
608
|
+
id: "anthropic_connector_refresh",
|
|
609
|
+
label: "Anthropic (connector refresh)",
|
|
610
|
+
vendor: "anthropic",
|
|
611
|
+
rawNames: ["Anthropic"]
|
|
612
|
+
},
|
|
613
|
+
{
|
|
614
|
+
id: "codex",
|
|
615
|
+
label: "Codex",
|
|
616
|
+
vendor: "openai",
|
|
617
|
+
rawNames: [
|
|
618
|
+
"codex-mcp-client",
|
|
619
|
+
"codex",
|
|
620
|
+
"Codex",
|
|
621
|
+
"codex-cli",
|
|
622
|
+
"openai-mcp (Codex)"
|
|
623
|
+
]
|
|
624
|
+
},
|
|
625
|
+
{
|
|
626
|
+
id: "chatgpt",
|
|
627
|
+
label: "ChatGPT",
|
|
628
|
+
vendor: "openai",
|
|
629
|
+
rawNames: ["openai-mcp (ChatGPT)"]
|
|
630
|
+
},
|
|
631
|
+
{
|
|
632
|
+
id: "openai_responses_api",
|
|
633
|
+
label: "OpenAI Responses API",
|
|
634
|
+
vendor: "openai",
|
|
635
|
+
rawNames: ["openai-mcp (Responses API)"]
|
|
636
|
+
},
|
|
637
|
+
{
|
|
638
|
+
id: "openai_agent_builder",
|
|
639
|
+
label: "OpenAI Agent Builder",
|
|
640
|
+
vendor: "openai",
|
|
641
|
+
rawNames: ["openai-mcp (Agent Builder)"]
|
|
642
|
+
},
|
|
643
|
+
{
|
|
644
|
+
id: "openai_other",
|
|
645
|
+
label: "OpenAI Other",
|
|
646
|
+
vendor: "openai",
|
|
647
|
+
rawNames: ["openai-mcp"]
|
|
648
|
+
},
|
|
649
|
+
{
|
|
650
|
+
id: "cursor",
|
|
651
|
+
label: "Cursor",
|
|
652
|
+
vendor: "cursor",
|
|
653
|
+
rawNames: [
|
|
654
|
+
"cursor-vscode",
|
|
655
|
+
"Cursor",
|
|
656
|
+
"cursor"
|
|
657
|
+
]
|
|
658
|
+
},
|
|
659
|
+
{
|
|
660
|
+
id: "cline",
|
|
661
|
+
label: "Cline",
|
|
662
|
+
vendor: "cline",
|
|
663
|
+
rawNames: [
|
|
664
|
+
"Cline",
|
|
665
|
+
"cline",
|
|
666
|
+
"@cline/core"
|
|
667
|
+
]
|
|
668
|
+
},
|
|
669
|
+
{
|
|
670
|
+
id: "github_copilot",
|
|
671
|
+
label: "GitHub Copilot",
|
|
672
|
+
vendor: "githubCopilot",
|
|
673
|
+
rawNames: [
|
|
674
|
+
"Copilot",
|
|
675
|
+
"github-copilot-developer",
|
|
676
|
+
"Copilot MCP Gateway",
|
|
677
|
+
"Xcode/copilot-xcode"
|
|
678
|
+
]
|
|
679
|
+
},
|
|
680
|
+
{
|
|
681
|
+
id: "gemini_cli",
|
|
682
|
+
label: "Gemini CLI",
|
|
683
|
+
vendor: "google",
|
|
684
|
+
rawNames: ["gemini-cli-mcp-client", "gemini-cli"]
|
|
685
|
+
},
|
|
686
|
+
{
|
|
687
|
+
id: "antigravity",
|
|
688
|
+
label: "Antigravity",
|
|
689
|
+
vendor: "google",
|
|
690
|
+
rawNames: ["antigravity-client"]
|
|
691
|
+
},
|
|
692
|
+
{
|
|
693
|
+
id: "gemini",
|
|
694
|
+
label: "Gemini",
|
|
695
|
+
vendor: "google",
|
|
696
|
+
rawNames: ["Gemini", "google-ai-edge-gallery"]
|
|
697
|
+
},
|
|
698
|
+
{
|
|
699
|
+
id: "windsurf",
|
|
700
|
+
label: "Windsurf",
|
|
701
|
+
vendor: "windsurf",
|
|
702
|
+
rawNames: ["Windsurf", "windsurf-client"]
|
|
703
|
+
},
|
|
704
|
+
{
|
|
705
|
+
id: "mistral",
|
|
706
|
+
label: "Mistral / Le Chat",
|
|
707
|
+
vendor: "mistral",
|
|
708
|
+
rawNames: ["Mistral"],
|
|
709
|
+
rawNamePrefixes: ["connector:custom-mcp:"]
|
|
710
|
+
},
|
|
711
|
+
{
|
|
712
|
+
id: "n8n",
|
|
713
|
+
label: "n8n",
|
|
714
|
+
vendor: "n8n",
|
|
715
|
+
rawNames: [
|
|
716
|
+
"@n8n/n8n-nodes-langchain.mcpClient",
|
|
717
|
+
"@n8n/n8n-nodes-langchain.mcpClientTool",
|
|
718
|
+
"n8n"
|
|
719
|
+
]
|
|
720
|
+
},
|
|
721
|
+
{
|
|
722
|
+
id: "alpic_playground",
|
|
723
|
+
label: "Alpic Playground",
|
|
724
|
+
vendor: "alpic",
|
|
725
|
+
rawNames: ["alpic-playground", "playground"]
|
|
726
|
+
},
|
|
727
|
+
{
|
|
728
|
+
id: "opencode",
|
|
729
|
+
label: "opencode",
|
|
730
|
+
vendor: "opencode",
|
|
731
|
+
rawNames: ["opencode"]
|
|
732
|
+
},
|
|
733
|
+
{
|
|
734
|
+
id: "zed",
|
|
735
|
+
label: "Zed",
|
|
736
|
+
vendor: "zed",
|
|
737
|
+
rawNames: ["Zed", "zed"]
|
|
738
|
+
},
|
|
739
|
+
{
|
|
740
|
+
id: "zapier",
|
|
741
|
+
label: "Zapier",
|
|
742
|
+
vendor: "zapier",
|
|
743
|
+
rawNames: ["Zapier", "zapier"]
|
|
744
|
+
},
|
|
745
|
+
{
|
|
746
|
+
id: "make",
|
|
747
|
+
label: "Make",
|
|
748
|
+
vendor: "make",
|
|
749
|
+
rawNames: ["Make", "make"]
|
|
750
|
+
},
|
|
751
|
+
{
|
|
752
|
+
id: "librechat",
|
|
753
|
+
label: "LibreChat",
|
|
754
|
+
vendor: "mcp",
|
|
755
|
+
rawNames: ["LibreChat", "librechat"]
|
|
756
|
+
},
|
|
757
|
+
{
|
|
758
|
+
id: "jan",
|
|
759
|
+
label: "Jan",
|
|
760
|
+
vendor: "mcp",
|
|
761
|
+
rawNames: ["Jan", "jan"]
|
|
762
|
+
},
|
|
763
|
+
{
|
|
764
|
+
id: "goose",
|
|
765
|
+
label: "goose",
|
|
766
|
+
vendor: "mcp",
|
|
767
|
+
rawNames: ["goose", "Goose"]
|
|
768
|
+
},
|
|
769
|
+
{
|
|
770
|
+
id: "mcphost",
|
|
771
|
+
label: "mcphost",
|
|
772
|
+
vendor: "mcp",
|
|
773
|
+
rawNames: ["mcphost"]
|
|
774
|
+
},
|
|
775
|
+
{
|
|
776
|
+
id: "mcporter",
|
|
777
|
+
label: "mcporter",
|
|
778
|
+
vendor: "mcp",
|
|
779
|
+
rawNames: ["mcporter"]
|
|
780
|
+
},
|
|
781
|
+
{
|
|
782
|
+
id: "rmcp",
|
|
783
|
+
label: "rmcp",
|
|
784
|
+
vendor: "mcp",
|
|
785
|
+
rawNames: ["rmcp"]
|
|
786
|
+
},
|
|
787
|
+
{
|
|
788
|
+
id: "unnamed_client",
|
|
789
|
+
label: "Unnamed client",
|
|
790
|
+
vendor: "mcp",
|
|
791
|
+
rawNames: [
|
|
792
|
+
"mcp",
|
|
793
|
+
"unknown",
|
|
794
|
+
""
|
|
795
|
+
]
|
|
796
|
+
}
|
|
797
|
+
];
|
|
798
|
+
/** A source pattern, not a RegExp, because analytics renders the same rule into ClickHouse RE2, which shares this syntax. */
|
|
799
|
+
const MCP_REMOTE_WRAPPER_SUFFIX = String.raw` \(via mcp-remote [^\n]+?\)$`;
|
|
800
|
+
new RegExp(MCP_REMOTE_WRAPPER_SUFFIX);
|
|
801
|
+
new Map(MCP_CLIENT_GROUPS.map((group) => [group.id, group]));
|
|
535
802
|
const runtimeSchema = z.enum([
|
|
536
803
|
"python3.13",
|
|
537
804
|
"python3.14",
|
|
@@ -609,15 +876,7 @@ z.object({
|
|
|
609
876
|
serverFields: serverFieldsSchema$1,
|
|
610
877
|
source: z.enum(["registry", "defaults"])
|
|
611
878
|
});
|
|
612
|
-
/**
|
|
613
|
-
* Returns a variant of a `maxLength`-constrained string that clamps (truncates) instead of
|
|
614
|
-
* rejecting on overflow — used for AI-generated copy where the model routinely overshoots.
|
|
615
|
-
*
|
|
616
|
-
* NOTE: this rebuilds the schema from scratch, carrying over only `maxLength` (as a clamp),
|
|
617
|
-
* `minLength`, and the description. Any other validators on the source field (`.regex()`,
|
|
618
|
-
* `.email()`, custom refinements) are intentionally dropped — this helper is meant for plain
|
|
619
|
-
* free-text length caps only. A field with `null` `maxLength` is returned unchanged.
|
|
620
|
-
*/
|
|
879
|
+
/** 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. */
|
|
621
880
|
const clampStringField = (field) => {
|
|
622
881
|
const max = field.maxLength;
|
|
623
882
|
if (max === null) return field;
|
|
@@ -625,6 +884,10 @@ const clampStringField = (field) => {
|
|
|
625
884
|
const withMin = field.minLength === null ? clamped : clamped.min(field.minLength);
|
|
626
885
|
return field.description ? withMin.describe(field.description) : withMin;
|
|
627
886
|
};
|
|
887
|
+
const unboundedArrayField = (field) => {
|
|
888
|
+
const unbounded = z.array(field.element);
|
|
889
|
+
return field.description ? unbounded.describe(field.description) : unbounded;
|
|
890
|
+
};
|
|
628
891
|
const toolDefinitionSchema = z.object({
|
|
629
892
|
name: z.string(),
|
|
630
893
|
title: z.string().optional().describe("Human-friendly name for the tool, used in the UI. If not provided, `name` will be used."),
|
|
@@ -637,11 +900,22 @@ const toolDefinitionSchema = z.object({
|
|
|
637
900
|
}).optional()
|
|
638
901
|
});
|
|
639
902
|
const positiveTestCaseSchema = z.object({
|
|
640
|
-
scenario: z.string().describe("Short label for what this case demonstrates."),
|
|
641
|
-
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."),
|
|
903
|
+
scenario: z.string().min(1).describe("Short label for what this case demonstrates."),
|
|
904
|
+
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."),
|
|
642
905
|
toolTriggered: z.string().optional().describe("The tool this prompt should invoke."),
|
|
643
906
|
expectedOutput: z.string().optional().describe("What the user should see, including post-interaction behaviour where relevant.")
|
|
644
|
-
}).
|
|
907
|
+
}).describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
|
|
908
|
+
const positiveTestCaseDraftSchema = positiveTestCaseSchema.partial().extend({
|
|
909
|
+
scenario: z.string().optional(),
|
|
910
|
+
userPrompt: z.string().optional()
|
|
911
|
+
});
|
|
912
|
+
const blankPositiveTestCase = () => ({
|
|
913
|
+
scenario: "",
|
|
914
|
+
userPrompt: "",
|
|
915
|
+
toolTriggered: "",
|
|
916
|
+
expectedOutput: ""
|
|
917
|
+
});
|
|
918
|
+
const toFixedLength = (entries, length, blank) => Array.from({ length }, (_, index) => entries[index] ?? blank());
|
|
645
919
|
const screenshotEntrySchema = z.object({
|
|
646
920
|
prompt: z.string(),
|
|
647
921
|
url: z.url()
|
|
@@ -954,20 +1228,25 @@ const chatgptTranslationLocaleSchema = z.enum([
|
|
|
954
1228
|
"zh-TW"
|
|
955
1229
|
]);
|
|
956
1230
|
const negativeTestCaseSchema = z.object({
|
|
957
|
-
scenario: z.string(),
|
|
958
|
-
userPrompt: z.string()
|
|
959
|
-
}).
|
|
1231
|
+
scenario: z.string().min(1),
|
|
1232
|
+
userPrompt: z.string().min(1)
|
|
1233
|
+
}).describe("Each case: Scenario + User prompt (the plugin should NOT trigger).");
|
|
1234
|
+
const negativeTestCaseDraftSchema = negativeTestCaseSchema.partial().extend({
|
|
1235
|
+
scenario: z.string().optional(),
|
|
1236
|
+
userPrompt: z.string().optional()
|
|
1237
|
+
});
|
|
1238
|
+
const blankNegativeTestCase = () => ({
|
|
1239
|
+
scenario: "",
|
|
1240
|
+
userPrompt: ""
|
|
1241
|
+
});
|
|
1242
|
+
const chatgptSkillSchema = z.object({ name: z.string() }).describe("A skill discovered on the MCP server, by name.");
|
|
960
1243
|
const chatgptToolJustificationSchema = z.object({
|
|
961
1244
|
toolName: z.string(),
|
|
962
1245
|
readOnlyJustification: z.string().describe("One sentence on what the tool reads and returns."),
|
|
963
1246
|
openWorldJustification: z.string().describe("One sentence on whether the tool reaches external systems beyond your own service."),
|
|
964
1247
|
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.\"")
|
|
965
1248
|
}).describe("Per-tool justification of each MCP annotation value (one specific sentence per hint).");
|
|
966
|
-
/**
|
|
967
|
-
* Base copy fields, defined once and reused by both the submission form and per-locale
|
|
968
|
-
* translations so the constraints (tagline ≤ 30 chars) never drift. The translation generation
|
|
969
|
-
* path wraps these in {@link clampStringField} since the LLM tends to overshoot the limit.
|
|
970
|
-
*/
|
|
1249
|
+
/** Defined once and reused by both the submission form and per-locale translations so the tagline ≤ 30 chars constraint never drifts. */
|
|
971
1250
|
const chatgptTaglineSchema = z.string().max(30);
|
|
972
1251
|
const chatgptDescriptionSchema = z.string();
|
|
973
1252
|
const chatgptTranslationSchema = z.object({
|
|
@@ -976,34 +1255,32 @@ const chatgptTranslationSchema = z.object({
|
|
|
976
1255
|
description: chatgptDescriptionSchema
|
|
977
1256
|
}).describe("Locale-scoped override for tagline + description. English (US) is the default.");
|
|
978
1257
|
chatgptTranslationSchema.extend({ tagline: clampStringField(chatgptTaglineSchema) });
|
|
979
|
-
/**
|
|
980
|
-
* Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section.
|
|
981
|
-
* When adding/removing/reordering fields, keep this in sync with the sheet.
|
|
982
|
-
*/
|
|
1258
|
+
/** Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section; keep it in sync with the sheet. */
|
|
983
1259
|
const chatgptSubmissionFormDataSchema = z.object({
|
|
984
1260
|
logoLight: z.string().describe("Logo icon for light mode. Square PNG, no borders or rounded corners (clients apply circular cropping)."),
|
|
985
1261
|
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."),
|
|
986
|
-
appName: z.string().describe("The name users will see in ChatGPT and in the
|
|
1262
|
+
appName: z.string().describe("The name users will see in ChatGPT and in the Plugin Directory."),
|
|
987
1263
|
tagline: chatgptTaglineSchema.describe("Plain-language phrase focused on function and user value, 30 chars max. Avoid generic superlatives like \"the best …\"."),
|
|
988
|
-
description: chatgptDescriptionSchema.describe("Clear, engaging description highlighting what the
|
|
1264
|
+
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)."),
|
|
989
1265
|
category: chatgptCategorySchema.describe("Category from the OpenAI taxonomy."),
|
|
990
|
-
developerName: z.string().describe("Developer name shown publicly on the
|
|
1266
|
+
developerName: z.string().describe("Developer name shown publicly on the plugin's directory page."),
|
|
991
1267
|
companyUrl: urlField.describe("Your company's main website URL."),
|
|
992
1268
|
supportChannel: supportChannelSchema.describe("Customer support URL or email address."),
|
|
993
1269
|
privacyPolicyUrl: urlField.describe("URL to your privacy policy."),
|
|
994
|
-
termsOfServiceUrl: urlField.describe("URL to the
|
|
995
|
-
demoRecordingUrl: urlField.describe("URL to a video demonstrating the
|
|
996
|
-
appCommerceAndPurchasing: z.boolean().describe("Checkbox: 'My
|
|
1270
|
+
termsOfServiceUrl: urlField.describe("URL to the plugin's terms of service."),
|
|
1271
|
+
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."),
|
|
1272
|
+
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."),
|
|
997
1273
|
serverUrl: urlField.describe("URL of the MCP server."),
|
|
998
1274
|
authentication: chatgptAuthenticationSchema.describe("OAuth 2.0 or No auth. OAuth configuration is auto-discovered from the MCP server's metadata."),
|
|
999
1275
|
tools: z.array(toolDefinitionSchema).describe("List of tools exposed by the MCP server (auto-populated from the production server's manifest)."),
|
|
1000
1276
|
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."),
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1277
|
+
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."),
|
|
1278
|
+
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."),
|
|
1279
|
+
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."),
|
|
1280
|
+
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."),
|
|
1004
1281
|
translations: z.array(chatgptTranslationSchema).describe("Per-locale translation of tagline + description. English (US) is the default."),
|
|
1005
1282
|
allowedCountries: chatgptAllowedCountriesSchema.describe("Availability: all supported countries, or an allow-list / block-list of specific ones (ISO alpha-2)."),
|
|
1006
|
-
releaseNotes: z.string().describe("Publicly displayed on the
|
|
1283
|
+
releaseNotes: z.string().describe("Publicly displayed on the plugin details page.")
|
|
1007
1284
|
});
|
|
1008
1285
|
const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().extend({
|
|
1009
1286
|
tagline: z.string().optional(),
|
|
@@ -1014,23 +1291,35 @@ const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().e
|
|
|
1014
1291
|
demoRecordingUrl: z.string().optional(),
|
|
1015
1292
|
serverUrl: z.string().optional(),
|
|
1016
1293
|
screenshots: z.array(screenshotDraftEntrySchema).optional(),
|
|
1294
|
+
testCases: z.array(positiveTestCaseDraftSchema).optional(),
|
|
1295
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).optional(),
|
|
1017
1296
|
translations: z.array(chatgptTranslationSchema.extend({ tagline: z.string() })).optional()
|
|
1018
1297
|
});
|
|
1019
|
-
|
|
1298
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "chatgpt" })` can populate. */
|
|
1299
|
+
const chatgptPrefillFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
1020
1300
|
appName: true,
|
|
1021
1301
|
developerName: true,
|
|
1022
1302
|
serverUrl: true,
|
|
1023
1303
|
tools: true,
|
|
1304
|
+
skills: true,
|
|
1024
1305
|
authentication: true
|
|
1025
1306
|
});
|
|
1026
|
-
|
|
1307
|
+
/** Source of truth for `SubmissionPrefillService.generate({ platform: "chatgpt" })`. */
|
|
1308
|
+
const chatgptAiGeneratedFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
1027
1309
|
tagline: true,
|
|
1028
1310
|
description: true,
|
|
1029
1311
|
category: true,
|
|
1030
1312
|
testCases: true,
|
|
1031
1313
|
negativeTestCases: true,
|
|
1032
1314
|
toolJustifications: true
|
|
1033
|
-
}).extend({
|
|
1315
|
+
}).extend({
|
|
1316
|
+
testCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.testCases),
|
|
1317
|
+
negativeTestCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.negativeTestCases)
|
|
1318
|
+
}).extend({
|
|
1319
|
+
tagline: clampStringField(chatgptSubmissionFormDataSchema.shape.tagline),
|
|
1320
|
+
testCases: z.array(positiveTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 5, blankPositiveTestCase)),
|
|
1321
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 3, blankNegativeTestCase))
|
|
1322
|
+
});
|
|
1034
1323
|
const claudeCategorySchema = z.enum([
|
|
1035
1324
|
"Productivity",
|
|
1036
1325
|
"Communication",
|
|
@@ -1076,11 +1365,7 @@ const claudePolicyAcknowledgementSchema = z.enum([
|
|
|
1076
1365
|
"My connector does not collect conversation data beyond what is needed for its function.",
|
|
1077
1366
|
"Public documentation for this connector will be live by the publish date."
|
|
1078
1367
|
]);
|
|
1079
|
-
/**
|
|
1080
|
-
* Field order mirrors the claude.ai directory submission wizard
|
|
1081
|
-
* (`claude.ai/admin-settings/directory/submissions/new`), grouped by step.
|
|
1082
|
-
* When adding/removing/reordering fields, keep this in sync with the wizard.
|
|
1083
|
-
*/
|
|
1368
|
+
/** 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. */
|
|
1084
1369
|
const claudeSubmissionFormDataSchema = z.object({
|
|
1085
1370
|
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
|
|
1086
1371
|
from the custom connector you select — the connection is used to verify the URL and the tool list at submission time.
|
|
@@ -1157,7 +1442,8 @@ const claudeSubmissionDraftSchema = claudeSubmissionFormDataSchema.partial().ext
|
|
|
1157
1442
|
categories: z.array(claudeCategorySchema).optional(),
|
|
1158
1443
|
screenshots: z.array(screenshotDraftEntrySchema).optional()
|
|
1159
1444
|
});
|
|
1160
|
-
|
|
1445
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "claudeai" })` can populate. */
|
|
1446
|
+
const claudePrefillFormDataSchema = claudeSubmissionFormDataSchema.pick({
|
|
1161
1447
|
serverUrl: true,
|
|
1162
1448
|
name: true,
|
|
1163
1449
|
slug: true,
|
|
@@ -1172,39 +1458,93 @@ claudeSubmissionFormDataSchema.pick({
|
|
|
1172
1458
|
connectionRequirements: claudeSubmissionFormDataSchema.shape.connectionRequirements.optional(),
|
|
1173
1459
|
testInstructions: claudeSubmissionFormDataSchema.shape.testInstructions.optional()
|
|
1174
1460
|
});
|
|
1175
|
-
/**
|
|
1176
|
-
* Narrative fields the LLM-backed generation step produces for Claude submissions.
|
|
1177
|
-
* This schema accepts the slightly loose shape returned by AI generation, then normalizes it into
|
|
1178
|
-
* the strict form shape. Keep transforms here rather than in callers so generation leniency is
|
|
1179
|
-
* colocated with the Claude contract.
|
|
1180
|
-
*/
|
|
1461
|
+
/** Loose shape returned by AI generation for Claude narrative fields; transforms live here so generation leniency stays colocated with the Claude contract. */
|
|
1181
1462
|
const claudeAiGeneratedFormDataRawSchema = z.object({
|
|
1182
1463
|
oneLiner: claudeSubmissionFormDataSchema.shape.oneLiner,
|
|
1183
1464
|
description: claudeSubmissionFormDataSchema.shape.description,
|
|
1184
1465
|
categories: z.array(claudeCategorySchema).describe(claudeCategoryDescription),
|
|
1185
1466
|
primaryUseCases: claudeSubmissionFormDataSchema.shape.primaryUseCases
|
|
1186
1467
|
});
|
|
1187
|
-
claudeAiGeneratedFormDataRawSchema.extend({
|
|
1468
|
+
const claudeAiGeneratedFormDataSchema = claudeAiGeneratedFormDataRawSchema.extend({
|
|
1188
1469
|
oneLiner: clampStringField(claudeSubmissionFormDataSchema.shape.oneLiner),
|
|
1189
1470
|
categories: claudeAiGeneratedFormDataRawSchema.shape.categories.transform((categories) => categories.slice(0, 5))
|
|
1190
1471
|
});
|
|
1472
|
+
function provenanceByField(prefillShape, aiGeneratedShape) {
|
|
1473
|
+
const byField = {};
|
|
1474
|
+
for (const field of Object.keys(prefillShape)) byField[field] = "prefilled";
|
|
1475
|
+
for (const field of Object.keys(aiGeneratedShape)) byField[field] = "ai-generated";
|
|
1476
|
+
return byField;
|
|
1477
|
+
}
|
|
1478
|
+
provenanceByField(claudePrefillFormDataSchema.shape, claudeAiGeneratedFormDataSchema.shape), provenanceByField(chatgptPrefillFormDataSchema.shape, chatgptAiGeneratedFormDataSchema.shape);
|
|
1479
|
+
const urlVerificationOutcomeSchema = z.enum([
|
|
1480
|
+
"pass",
|
|
1481
|
+
"fail",
|
|
1482
|
+
"unverified"
|
|
1483
|
+
]);
|
|
1484
|
+
const VERIFIABLE_URL_FIELDS = {
|
|
1485
|
+
chatgpt: ["privacyPolicyUrl", "termsOfServiceUrl"],
|
|
1486
|
+
claudeai: ["privacyPolicy"]
|
|
1487
|
+
};
|
|
1488
|
+
const verifiableUrlFieldSchema = z.enum([...VERIFIABLE_URL_FIELDS.chatgpt, ...VERIFIABLE_URL_FIELDS.claudeai]);
|
|
1489
|
+
const policyDisclosureSchema = z.enum([
|
|
1490
|
+
"dataCategories",
|
|
1491
|
+
"purposesOfUse",
|
|
1492
|
+
"recipients",
|
|
1493
|
+
"retention"
|
|
1494
|
+
]);
|
|
1495
|
+
const urlVerificationFieldResultSchema = z.object({
|
|
1496
|
+
field: verifiableUrlFieldSchema,
|
|
1497
|
+
url: z.string(),
|
|
1498
|
+
outcome: urlVerificationOutcomeSchema,
|
|
1499
|
+
reason: z.string(),
|
|
1500
|
+
concerns: z.array(z.string()).optional(),
|
|
1501
|
+
scrapedWith: z.enum(["fetch", "firecrawl"]).optional()
|
|
1502
|
+
});
|
|
1503
|
+
const urlVerificationSchema = z.object({
|
|
1504
|
+
verifiedAt: z.coerce.date(),
|
|
1505
|
+
results: z.array(urlVerificationFieldResultSchema)
|
|
1506
|
+
});
|
|
1507
|
+
const pageKindSchema = z.enum([
|
|
1508
|
+
"expectedDocument",
|
|
1509
|
+
"errorPage",
|
|
1510
|
+
"loginWall",
|
|
1511
|
+
"parkedDomain",
|
|
1512
|
+
"comingSoon",
|
|
1513
|
+
"marketingPage",
|
|
1514
|
+
"unrelatedDocument"
|
|
1515
|
+
]);
|
|
1516
|
+
z.object({
|
|
1517
|
+
pageKind: pageKindSchema.describe("What the page actually is. Use 'expectedDocument' only when it is genuinely the document the field claims."),
|
|
1518
|
+
reason: z.string().max(200).describe("One sentence naming what the page is, addressed to the developer who entered the URL."),
|
|
1519
|
+
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.")
|
|
1520
|
+
});
|
|
1191
1521
|
const submissionMetaFieldsSchema = z.object({
|
|
1192
1522
|
id: z.string(),
|
|
1193
1523
|
environmentId: z.string(),
|
|
1194
1524
|
auditId: z.string().nullable(),
|
|
1525
|
+
urlVerification: urlVerificationSchema.nullable().default(null),
|
|
1195
1526
|
createdAt: z.coerce.date(),
|
|
1196
1527
|
updatedAt: z.coerce.date()
|
|
1197
1528
|
});
|
|
1198
1529
|
const claudeSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1199
1530
|
platform: z.literal("claudeai"),
|
|
1200
|
-
formData: claudeSubmissionDraftSchema
|
|
1531
|
+
formData: claudeSubmissionDraftSchema,
|
|
1532
|
+
prefillSnapshot: claudeSubmissionDraftSchema.nullable().default(null)
|
|
1201
1533
|
});
|
|
1202
1534
|
const chatgptSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1203
1535
|
platform: z.literal("chatgpt"),
|
|
1204
|
-
formData: chatgptSubmissionDraftSchema
|
|
1536
|
+
formData: chatgptSubmissionDraftSchema,
|
|
1537
|
+
prefillSnapshot: chatgptSubmissionDraftSchema.nullable().default(null)
|
|
1205
1538
|
});
|
|
1206
|
-
z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
1539
|
+
const submissionSchemaInternal = z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
1207
1540
|
z.union([claudeSubmissionDraftSchema, chatgptSubmissionDraftSchema]);
|
|
1541
|
+
/** Discriminated on `platform`, which pins the shape of `formData`: a Claude submission cannot carry chatgpt-only fields, and vice-versa. */
|
|
1542
|
+
const submissionSchema = submissionSchemaInternal;
|
|
1543
|
+
z.literal([
|
|
1544
|
+
100,
|
|
1545
|
+
75,
|
|
1546
|
+
50
|
|
1547
|
+
]);
|
|
1208
1548
|
const subscriptionPlanSchema = z.enum([
|
|
1209
1549
|
"pro",
|
|
1210
1550
|
"business",
|
|
@@ -1216,17 +1556,78 @@ const customerCreditsSchema = z.object({
|
|
|
1216
1556
|
expiresAt: z.number().nullable(),
|
|
1217
1557
|
currency: z.string()
|
|
1218
1558
|
});
|
|
1219
|
-
const customerUsageSchema = z.object({
|
|
1220
|
-
amountInCents: z.number(),
|
|
1221
|
-
currency: z.string(),
|
|
1222
|
-
periodEnd: z.number()
|
|
1223
|
-
});
|
|
1224
1559
|
const partnerDiscountSchema = z.object({ endsAt: z.number() });
|
|
1225
1560
|
z.object({
|
|
1226
1561
|
customerCredits: customerCreditsSchema.nullable(),
|
|
1227
|
-
customerUsage: customerUsageSchema.nullable(),
|
|
1228
1562
|
partnerDiscount: partnerDiscountSchema.nullable()
|
|
1229
1563
|
});
|
|
1564
|
+
const metricsQueueEventSchema = z.object({
|
|
1565
|
+
ts: z.number().int(),
|
|
1566
|
+
method: z.string(),
|
|
1567
|
+
tool: z.string().nullable(),
|
|
1568
|
+
client: z.string(),
|
|
1569
|
+
sessionId: z.string().nullable(),
|
|
1570
|
+
conversationId: z.string().nullable().optional(),
|
|
1571
|
+
durationMs: z.number().int(),
|
|
1572
|
+
outputTokens: z.number().int().nullable(),
|
|
1573
|
+
errorType: z.enum([
|
|
1574
|
+
"mcp_error",
|
|
1575
|
+
"tool_error",
|
|
1576
|
+
"timeout"
|
|
1577
|
+
]).nullable(),
|
|
1578
|
+
errorCode: z.number().int().nullable()
|
|
1579
|
+
});
|
|
1580
|
+
z.object({
|
|
1581
|
+
v: z.literal(1),
|
|
1582
|
+
envId: z.string(),
|
|
1583
|
+
events: z.array(metricsQueueEventSchema)
|
|
1584
|
+
});
|
|
1585
|
+
z.object({ v: z.number() });
|
|
1586
|
+
const TELEMETRY_SIGNALS = [
|
|
1587
|
+
"logs",
|
|
1588
|
+
"metrics",
|
|
1589
|
+
"traces"
|
|
1590
|
+
];
|
|
1591
|
+
const telemetrySignalSchema = z.enum(TELEMETRY_SIGNALS);
|
|
1592
|
+
const OTLP_PROTOCOLS = ["http/protobuf", "http/json"];
|
|
1593
|
+
const otlpProtocolSchema = z.enum(OTLP_PROTOCOLS);
|
|
1594
|
+
const otlpEndpointSchema = z.string().trim().min(1).max(2048);
|
|
1595
|
+
const OTLP_HEADER_VALUE_MAX_LENGTH = 2048;
|
|
1596
|
+
const otlpHeaderNameSchema = z.string().trim().min(1, "Enter a header name").max(128).regex(/^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/, "Use letters, digits and !#$%&'*+-.^_`|~ only");
|
|
1597
|
+
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");
|
|
1598
|
+
const telemetryDestinationHeaderSchema = z.object({
|
|
1599
|
+
id: z.string(),
|
|
1600
|
+
name: otlpHeaderNameSchema,
|
|
1601
|
+
value: otlpHeaderValueSchema,
|
|
1602
|
+
isSecret: z.boolean()
|
|
1603
|
+
});
|
|
1604
|
+
const otlpPushFailureReasonSchema = z.enum([
|
|
1605
|
+
"credentials",
|
|
1606
|
+
"wrong-path",
|
|
1607
|
+
"wrong-protocol",
|
|
1608
|
+
"invalid-payload",
|
|
1609
|
+
"partial-rejection",
|
|
1610
|
+
"blocked-target",
|
|
1611
|
+
"timeout",
|
|
1612
|
+
"unreachable",
|
|
1613
|
+
"receiver-error",
|
|
1614
|
+
"unexpected-status"
|
|
1615
|
+
]);
|
|
1616
|
+
const telemetryDestinationStatusSchema = z.enum(["active", "suspended"]);
|
|
1617
|
+
z.object({
|
|
1618
|
+
id: z.string(),
|
|
1619
|
+
signal: telemetrySignalSchema,
|
|
1620
|
+
endpoint: otlpEndpointSchema,
|
|
1621
|
+
protocol: otlpProtocolSchema,
|
|
1622
|
+
headers: z.array(telemetryDestinationHeaderSchema),
|
|
1623
|
+
status: telemetryDestinationStatusSchema,
|
|
1624
|
+
lastFailureReason: otlpPushFailureReasonSchema.nullable(),
|
|
1625
|
+
isScopedToIntentionalRequestsOnly: z.boolean()
|
|
1626
|
+
});
|
|
1627
|
+
const hasDuplicateHeaderNames = (headers) => {
|
|
1628
|
+
const names = headers.map(({ name }) => name.trim().toLowerCase());
|
|
1629
|
+
return new Set(names).size !== names.length;
|
|
1630
|
+
};
|
|
1230
1631
|
//#endregion
|
|
1231
1632
|
//#region src/auth-scope.ts
|
|
1232
1633
|
/** Accepts an API key or OAuth access token (default for most routes). */
|
|
@@ -1269,7 +1670,10 @@ const RESERVED_KEYS = [
|
|
|
1269
1670
|
"BUILD_ARG_START_COMMAND",
|
|
1270
1671
|
"ALPIC_HOST",
|
|
1271
1672
|
"ALPIC_CUSTOM_DOMAINS",
|
|
1272
|
-
"ALPIC_INTENT_META_KEY"
|
|
1673
|
+
"ALPIC_INTENT_META_KEY",
|
|
1674
|
+
"ALPIC_FEEDBACK_META_KEY",
|
|
1675
|
+
"ALPIC_EVENTS_META_KEY",
|
|
1676
|
+
"ALPIC_IDENTIFY_META_KEY"
|
|
1273
1677
|
];
|
|
1274
1678
|
const environmentVariableSchema = z.object({
|
|
1275
1679
|
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"),
|
|
@@ -1322,6 +1726,14 @@ const serverFieldsSchema = z.object({
|
|
|
1322
1726
|
});
|
|
1323
1727
|
//#endregion
|
|
1324
1728
|
//#region src/api.contract.ts
|
|
1729
|
+
const isValidIanaTimeZone = (timeZone) => {
|
|
1730
|
+
try {
|
|
1731
|
+
new Intl.DateTimeFormat("en-US", { timeZone });
|
|
1732
|
+
return true;
|
|
1733
|
+
} catch {
|
|
1734
|
+
return false;
|
|
1735
|
+
}
|
|
1736
|
+
};
|
|
1325
1737
|
const deploymentStatusSchema = z.enum([
|
|
1326
1738
|
"ongoing",
|
|
1327
1739
|
"deployed",
|
|
@@ -1350,21 +1762,20 @@ const deploymentSchema = z.object({
|
|
|
1350
1762
|
isCurrent: z.boolean(),
|
|
1351
1763
|
deploymentPageUrl: z.url().nullable()
|
|
1352
1764
|
});
|
|
1353
|
-
const
|
|
1765
|
+
const isValidTimeInput = (value) => {
|
|
1354
1766
|
if (ms(value) !== void 0) return true;
|
|
1355
1767
|
return !Number.isNaN(new Date(value).getTime());
|
|
1356
1768
|
};
|
|
1357
|
-
const
|
|
1769
|
+
const timeInputSchema = z.string().refine(isValidTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." });
|
|
1770
|
+
const base = oc.errors({ BAD_REQUEST: {} });
|
|
1771
|
+
const createEnvironmentContractV1 = base.route({
|
|
1358
1772
|
path: "/v1/environments",
|
|
1359
1773
|
method: "POST",
|
|
1360
1774
|
summary: "Create an environment",
|
|
1361
1775
|
description: "Create an environment for a project",
|
|
1362
1776
|
tags: ["environments"],
|
|
1363
1777
|
successDescription: "The environment has been created successfully"
|
|
1364
|
-
}).errors({
|
|
1365
|
-
NOT_FOUND: {},
|
|
1366
|
-
BAD_REQUEST: {}
|
|
1367
|
-
}).input(z.object({
|
|
1778
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1368
1779
|
projectId: z.string().describe("The ID of the project to create the environment for"),
|
|
1369
1780
|
name: z.string().min(1).describe("The name of the environment"),
|
|
1370
1781
|
sourceBranch: z.string().min(1).describe("The branch used to build the environment"),
|
|
@@ -1377,7 +1788,7 @@ const createEnvironmentContractV1 = oc.route({
|
|
|
1377
1788
|
createdAt: z.coerce.date(),
|
|
1378
1789
|
projectId: z.string().describe("The ID of the project the environment belongs to")
|
|
1379
1790
|
}));
|
|
1380
|
-
const getEnvironmentContractV1 =
|
|
1791
|
+
const getEnvironmentContractV1 = base.route({
|
|
1381
1792
|
path: "/v1/environments/{environmentId}",
|
|
1382
1793
|
method: "GET",
|
|
1383
1794
|
summary: "Get an environment",
|
|
@@ -1393,6 +1804,14 @@ const getEnvironmentContractV1 = oc.route({
|
|
|
1393
1804
|
createdAt: z.coerce.date(),
|
|
1394
1805
|
projectId: z.string()
|
|
1395
1806
|
}));
|
|
1807
|
+
const deleteEnvironmentContractV1 = base.route({
|
|
1808
|
+
path: "/v1/environments/{environmentId}",
|
|
1809
|
+
method: "DELETE",
|
|
1810
|
+
summary: "Delete an environment",
|
|
1811
|
+
description: "All environments can be deleted except the production environment. This operation is not reversible: associated logs, analytics, and metrics are deleted as well.",
|
|
1812
|
+
tags: ["environments"],
|
|
1813
|
+
successDescription: "The environment has been deleted successfully"
|
|
1814
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.object({ success: z.literal(true) }));
|
|
1396
1815
|
const domainSchema = z.object({
|
|
1397
1816
|
domain: z.string(),
|
|
1398
1817
|
status: z.enum([
|
|
@@ -1434,7 +1853,7 @@ const projectOutputSchema = z.object({
|
|
|
1434
1853
|
productionEnvironment: productionEnvironmentSchema.nullable(),
|
|
1435
1854
|
environments: z.array(environmentSchema)
|
|
1436
1855
|
});
|
|
1437
|
-
const getProjectContractV1 =
|
|
1856
|
+
const getProjectContractV1 = base.route({
|
|
1438
1857
|
path: "/v1/projects/{projectId}",
|
|
1439
1858
|
method: "GET",
|
|
1440
1859
|
summary: "Get a project",
|
|
@@ -1442,18 +1861,15 @@ const getProjectContractV1 = oc.route({
|
|
|
1442
1861
|
tags: ["projects"],
|
|
1443
1862
|
successDescription: "The project details"
|
|
1444
1863
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(projectOutputSchema);
|
|
1445
|
-
const listProjectsContractV1 =
|
|
1864
|
+
const listProjectsContractV1 = base.route({
|
|
1446
1865
|
path: "/v1/projects",
|
|
1447
1866
|
method: "GET",
|
|
1448
1867
|
summary: "List projects",
|
|
1449
1868
|
description: "List all projects for a team",
|
|
1450
1869
|
tags: ["projects"],
|
|
1451
1870
|
successDescription: "The list of projects"
|
|
1452
|
-
}).errors({
|
|
1453
|
-
|
|
1454
|
-
BAD_REQUEST: {}
|
|
1455
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1456
|
-
const createProjectContractV1 = oc.route({
|
|
1871
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1872
|
+
const createProjectContractV1 = base.route({
|
|
1457
1873
|
path: "/v1/projects",
|
|
1458
1874
|
method: "POST",
|
|
1459
1875
|
summary: "Create a project",
|
|
@@ -1462,7 +1878,6 @@ const createProjectContractV1 = oc.route({
|
|
|
1462
1878
|
successDescription: "The project has been created successfully"
|
|
1463
1879
|
}).errors({
|
|
1464
1880
|
NOT_FOUND: {},
|
|
1465
|
-
BAD_REQUEST: {},
|
|
1466
1881
|
FORBIDDEN: {}
|
|
1467
1882
|
}).input(z.object({
|
|
1468
1883
|
teamId: z.string().optional(),
|
|
@@ -1503,7 +1918,101 @@ const environmentVariableOutputSchema = z.object({
|
|
|
1503
1918
|
isSecret: z.boolean(),
|
|
1504
1919
|
createdAt: z.coerce.date()
|
|
1505
1920
|
});
|
|
1506
|
-
const
|
|
1921
|
+
const telemetryDestinationHeaderOutputSchema = z.discriminatedUnion("isSecret", [z.object({
|
|
1922
|
+
id: z.string(),
|
|
1923
|
+
name: otlpHeaderNameSchema,
|
|
1924
|
+
value: z.null(),
|
|
1925
|
+
isSecret: z.literal(true)
|
|
1926
|
+
}), z.object({
|
|
1927
|
+
id: z.string(),
|
|
1928
|
+
name: otlpHeaderNameSchema,
|
|
1929
|
+
value: otlpHeaderValueSchema,
|
|
1930
|
+
isSecret: z.literal(false)
|
|
1931
|
+
})]);
|
|
1932
|
+
const telemetryDestinationOutputSchema = z.object({
|
|
1933
|
+
id: z.string(),
|
|
1934
|
+
signal: telemetrySignalSchema,
|
|
1935
|
+
endpoint: otlpEndpointSchema,
|
|
1936
|
+
protocol: otlpProtocolSchema,
|
|
1937
|
+
headers: z.array(telemetryDestinationHeaderOutputSchema),
|
|
1938
|
+
status: telemetryDestinationStatusSchema,
|
|
1939
|
+
lastFailureReason: otlpPushFailureReasonSchema.nullable(),
|
|
1940
|
+
isScopedToIntentionalRequestsOnly: z.boolean()
|
|
1941
|
+
});
|
|
1942
|
+
const createTelemetryDestinationHeaderInputSchema = z.object({
|
|
1943
|
+
name: otlpHeaderNameSchema,
|
|
1944
|
+
value: otlpHeaderValueSchema.min(1, "Enter a header value"),
|
|
1945
|
+
isSecret: z.boolean()
|
|
1946
|
+
});
|
|
1947
|
+
const updateTelemetryDestinationHeaderInputSchema = z.object({
|
|
1948
|
+
id: z.string().optional(),
|
|
1949
|
+
name: otlpHeaderNameSchema,
|
|
1950
|
+
value: otlpHeaderValueSchema.optional(),
|
|
1951
|
+
isSecret: z.boolean()
|
|
1952
|
+
});
|
|
1953
|
+
const uniqueTelemetryHeaders = (headers) => !hasDuplicateHeaderNames(headers);
|
|
1954
|
+
const listTelemetryDestinationsContractV1 = base.route({
|
|
1955
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations",
|
|
1956
|
+
method: "GET",
|
|
1957
|
+
summary: "List telemetry destinations",
|
|
1958
|
+
description: "List the OTLP destinations configured for an environment. Secret header values are never returned.",
|
|
1959
|
+
tags: ["telemetry"],
|
|
1960
|
+
successDescription: "The list of telemetry destinations"
|
|
1961
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(telemetryDestinationOutputSchema));
|
|
1962
|
+
const createTelemetryDestinationContractV1 = base.route({
|
|
1963
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations",
|
|
1964
|
+
method: "POST",
|
|
1965
|
+
summary: "Create a telemetry destination",
|
|
1966
|
+
description: "Verify and save an OTLP destination for logs, metrics, or traces.",
|
|
1967
|
+
tags: ["telemetry"],
|
|
1968
|
+
successDescription: "The telemetry destination has been created"
|
|
1969
|
+
}).errors({
|
|
1970
|
+
NOT_FOUND: {},
|
|
1971
|
+
FORBIDDEN: {},
|
|
1972
|
+
OTLP_DESTINATION_UNVERIFIED: { status: 400 },
|
|
1973
|
+
INTERNAL_SERVER_ERROR: {}
|
|
1974
|
+
}).input(z.object({
|
|
1975
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
1976
|
+
signal: telemetrySignalSchema,
|
|
1977
|
+
endpoint: otlpEndpointSchema,
|
|
1978
|
+
protocol: otlpProtocolSchema.default("http/protobuf"),
|
|
1979
|
+
isScopedToIntentionalRequestsOnly: z.boolean().default(false),
|
|
1980
|
+
headers: z.array(createTelemetryDestinationHeaderInputSchema).default([]).refine(uniqueTelemetryHeaders, "Header names must be unique")
|
|
1981
|
+
})).output(telemetryDestinationOutputSchema);
|
|
1982
|
+
const updateTelemetryDestinationContractV1 = base.route({
|
|
1983
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations/{destinationId}",
|
|
1984
|
+
method: "PATCH",
|
|
1985
|
+
summary: "Update a telemetry destination",
|
|
1986
|
+
description: "Verify and save changes to an OTLP destination. Omit headers to keep them unchanged; omit the value of an existing header to preserve it. A secret header value must be re-entered when the endpoint changes.",
|
|
1987
|
+
tags: ["telemetry"],
|
|
1988
|
+
successDescription: "The telemetry destination has been updated"
|
|
1989
|
+
}).errors({
|
|
1990
|
+
NOT_FOUND: {},
|
|
1991
|
+
FORBIDDEN: {},
|
|
1992
|
+
OTLP_DESTINATION_UNVERIFIED: { status: 400 }
|
|
1993
|
+
}).input(z.object({
|
|
1994
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
1995
|
+
destinationId: z.string().describe("The ID of the telemetry destination"),
|
|
1996
|
+
endpoint: otlpEndpointSchema.optional(),
|
|
1997
|
+
protocol: otlpProtocolSchema.optional(),
|
|
1998
|
+
isScopedToIntentionalRequestsOnly: z.boolean().optional(),
|
|
1999
|
+
headers: z.array(updateTelemetryDestinationHeaderInputSchema).refine(uniqueTelemetryHeaders, "Header names must be unique").optional()
|
|
2000
|
+
})).output(telemetryDestinationOutputSchema);
|
|
2001
|
+
const deleteTelemetryDestinationContractV1 = base.route({
|
|
2002
|
+
path: "/v1/environments/{environmentId}/telemetry-destinations/{destinationId}",
|
|
2003
|
+
method: "DELETE",
|
|
2004
|
+
summary: "Delete a telemetry destination",
|
|
2005
|
+
description: "Delete an OTLP destination from an environment.",
|
|
2006
|
+
tags: ["telemetry"],
|
|
2007
|
+
successDescription: "The telemetry destination has been deleted"
|
|
2008
|
+
}).errors({
|
|
2009
|
+
NOT_FOUND: {},
|
|
2010
|
+
INTERNAL_SERVER_ERROR: {}
|
|
2011
|
+
}).input(z.object({
|
|
2012
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2013
|
+
destinationId: z.string().describe("The ID of the telemetry destination")
|
|
2014
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2015
|
+
const listEnvironmentVariablesContractV1 = base.route({
|
|
1507
2016
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1508
2017
|
method: "GET",
|
|
1509
2018
|
summary: "List environment variables",
|
|
@@ -1511,48 +2020,39 @@ const listEnvironmentVariablesContractV1 = oc.route({
|
|
|
1511
2020
|
tags: ["environments"],
|
|
1512
2021
|
successDescription: "The list of environment variables"
|
|
1513
2022
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(environmentVariableOutputSchema));
|
|
1514
|
-
const createEnvironmentVariablesContractV1 =
|
|
2023
|
+
const createEnvironmentVariablesContractV1 = base.route({
|
|
1515
2024
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1516
2025
|
method: "POST",
|
|
1517
2026
|
summary: "Add environment variables",
|
|
1518
2027
|
description: "Add one or more environment variables to an environment",
|
|
1519
2028
|
tags: ["environments"],
|
|
1520
2029
|
successDescription: "The environment variables have been added successfully"
|
|
1521
|
-
}).errors({
|
|
1522
|
-
NOT_FOUND: {},
|
|
1523
|
-
BAD_REQUEST: {}
|
|
1524
|
-
}).input(z.object({
|
|
2030
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1525
2031
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1526
2032
|
environmentVariables: environmentVariablesSchema
|
|
1527
2033
|
})).output(z.object({ success: z.literal(true) }));
|
|
1528
|
-
const updateEnvironmentVariableContractV1 =
|
|
2034
|
+
const updateEnvironmentVariableContractV1 = base.route({
|
|
1529
2035
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1530
2036
|
method: "PATCH",
|
|
1531
2037
|
summary: "Update an environment variable",
|
|
1532
2038
|
description: "Update an environment variable by ID",
|
|
1533
2039
|
tags: ["environments"],
|
|
1534
2040
|
successDescription: "The environment variable has been updated successfully"
|
|
1535
|
-
}).errors({
|
|
1536
|
-
NOT_FOUND: {},
|
|
1537
|
-
BAD_REQUEST: {}
|
|
1538
|
-
}).input(z.object({
|
|
2041
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1539
2042
|
environmentVariableId: z.string().describe("The ID of the environment variable"),
|
|
1540
2043
|
key: environmentVariableSchema.shape.key,
|
|
1541
2044
|
value: environmentVariableSchema.shape.value.optional(),
|
|
1542
2045
|
isSecret: environmentVariableSchema.shape.isSecret.optional()
|
|
1543
2046
|
})).output(z.object({ success: z.literal(true) }));
|
|
1544
|
-
const deleteEnvironmentVariableContractV1 =
|
|
2047
|
+
const deleteEnvironmentVariableContractV1 = base.route({
|
|
1545
2048
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1546
2049
|
method: "DELETE",
|
|
1547
2050
|
summary: "Delete an environment variable",
|
|
1548
2051
|
description: "Delete an environment variable by ID",
|
|
1549
2052
|
tags: ["environments"],
|
|
1550
2053
|
successDescription: "The environment variable has been deleted successfully"
|
|
1551
|
-
}).errors({
|
|
1552
|
-
|
|
1553
|
-
BAD_REQUEST: {}
|
|
1554
|
-
}).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
1555
|
-
const deleteProjectContractV1 = oc.route({
|
|
2054
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
2055
|
+
const deleteProjectContractV1 = base.route({
|
|
1556
2056
|
path: "/v1/projects/{projectId}",
|
|
1557
2057
|
method: "DELETE",
|
|
1558
2058
|
summary: "Delete a project",
|
|
@@ -1560,7 +2060,7 @@ const deleteProjectContractV1 = oc.route({
|
|
|
1560
2060
|
tags: ["projects"],
|
|
1561
2061
|
successDescription: "The project has been deleted successfully"
|
|
1562
2062
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.object({ success: z.literal(true) }));
|
|
1563
|
-
const updateProjectContractV1 =
|
|
2063
|
+
const updateProjectContractV1 = base.route({
|
|
1564
2064
|
path: "/v1/projects/{projectId}",
|
|
1565
2065
|
method: "PATCH",
|
|
1566
2066
|
summary: "Update a project",
|
|
@@ -1569,14 +2069,13 @@ const updateProjectContractV1 = oc.route({
|
|
|
1569
2069
|
successDescription: "The project has been updated successfully"
|
|
1570
2070
|
}).errors({
|
|
1571
2071
|
NOT_FOUND: {},
|
|
1572
|
-
BAD_REQUEST: {},
|
|
1573
2072
|
FORBIDDEN: {}
|
|
1574
2073
|
}).input(z.object({
|
|
1575
2074
|
projectId: z.string().describe("The ID of the project"),
|
|
1576
2075
|
name: z.string().min(1).max(100).optional().describe("The new name for the project"),
|
|
1577
2076
|
sourceRepository: z.string().nullable().optional().describe("The source repository to connect to the project")
|
|
1578
2077
|
})).output(projectOutputSchema);
|
|
1579
|
-
const deployEnvironmentContractV1 =
|
|
2078
|
+
const deployEnvironmentContractV1 = base.route({
|
|
1580
2079
|
path: "/v1/environments/{environmentId}/deploy",
|
|
1581
2080
|
method: "POST",
|
|
1582
2081
|
summary: "Deploy an environment",
|
|
@@ -1585,28 +2084,25 @@ const deployEnvironmentContractV1 = oc.route({
|
|
|
1585
2084
|
successDescription: "The environment has been deployed successfully"
|
|
1586
2085
|
}).errors({
|
|
1587
2086
|
NOT_FOUND: {},
|
|
1588
|
-
|
|
2087
|
+
CONFLICT: {}
|
|
1589
2088
|
}).input(z.object({
|
|
1590
2089
|
environmentId: z.string().describe("The ID of the environment to deploy"),
|
|
1591
2090
|
token: z.string().describe("The token to identify the source archive").optional(),
|
|
1592
2091
|
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.")
|
|
1593
2092
|
})).output(deploymentSchema);
|
|
1594
|
-
const uploadDeploymentArtifactContractV1 =
|
|
2093
|
+
const uploadDeploymentArtifactContractV1 = base.route({
|
|
1595
2094
|
path: "/v1/deployments/upload",
|
|
1596
2095
|
method: "POST",
|
|
1597
2096
|
summary: "Upload deployment artifacts",
|
|
1598
2097
|
description: "Return a presigned S3 URL to upload a deployment artifact",
|
|
1599
2098
|
tags: ["deployments"],
|
|
1600
2099
|
successDescription: "The presigned upload URL has been generated successfully"
|
|
1601
|
-
}).errors({
|
|
1602
|
-
NOT_FOUND: {},
|
|
1603
|
-
BAD_REQUEST: {}
|
|
1604
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
2100
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
1605
2101
|
uploadUrl: z.url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
|
|
1606
2102
|
token: z.string().describe("Token to identify the source archive"),
|
|
1607
2103
|
expiresAt: z.coerce.date().describe("Expiration date of the presigned URL")
|
|
1608
2104
|
}));
|
|
1609
|
-
const listDeploymentsContractV1 =
|
|
2105
|
+
const listDeploymentsContractV1 = base.route({
|
|
1610
2106
|
path: "/v1/projects/{projectId}/deployments",
|
|
1611
2107
|
method: "GET",
|
|
1612
2108
|
summary: "List project deployments",
|
|
@@ -1618,7 +2114,7 @@ const listDeploymentsContractV1 = oc.route({
|
|
|
1618
2114
|
status: z.array(deploymentStatusSchema).optional().describe("Filter by one or more statuses"),
|
|
1619
2115
|
environmentId: z.string().optional().describe("Filter by environment ID")
|
|
1620
2116
|
})).output(z.array(deploymentSchema));
|
|
1621
|
-
const getDeploymentContractV1 =
|
|
2117
|
+
const getDeploymentContractV1 = base.route({
|
|
1622
2118
|
path: "/v1/deployments/{deploymentId}",
|
|
1623
2119
|
method: "GET",
|
|
1624
2120
|
summary: "Get a deployment",
|
|
@@ -1641,20 +2137,17 @@ const logEntrySchema = z.object({
|
|
|
1641
2137
|
method: z.string().optional(),
|
|
1642
2138
|
durationInMs: z.number().optional()
|
|
1643
2139
|
});
|
|
1644
|
-
const getLogsContractV1 =
|
|
2140
|
+
const getLogsContractV1 = base.route({
|
|
1645
2141
|
path: "/v1/environments/{environmentId}/logs",
|
|
1646
2142
|
method: "GET",
|
|
1647
2143
|
summary: "Get logs",
|
|
1648
2144
|
description: "Get logs for an environment",
|
|
1649
2145
|
tags: ["environments"],
|
|
1650
2146
|
successDescription: "The logs"
|
|
1651
|
-
}).errors({
|
|
1652
|
-
NOT_FOUND: {},
|
|
1653
|
-
BAD_REQUEST: {}
|
|
1654
|
-
}).input(z.object({
|
|
2147
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1655
2148
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1656
|
-
since:
|
|
1657
|
-
until:
|
|
2149
|
+
since: timeInputSchema.optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
2150
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
1658
2151
|
limit: z.coerce.number().int().min(1).max(1e3).default(1e3).describe("Maximum number of log entries to return."),
|
|
1659
2152
|
level: z.array(z.enum([
|
|
1660
2153
|
"INFO",
|
|
@@ -1662,23 +2155,20 @@ const getLogsContractV1 = oc.route({
|
|
|
1662
2155
|
"WARNING",
|
|
1663
2156
|
"DEBUG"
|
|
1664
2157
|
])).optional().describe("Filter by log level"),
|
|
1665
|
-
search:
|
|
2158
|
+
search: logSearchSchema.optional().describe("Term to search for in log content"),
|
|
1666
2159
|
nextToken: z.string().optional().describe("Pagination token from a previous response")
|
|
1667
2160
|
})).output(z.object({
|
|
1668
2161
|
logs: z.array(logEntrySchema),
|
|
1669
2162
|
nextToken: z.string().nullable()
|
|
1670
2163
|
}));
|
|
1671
|
-
const getLatestLogsContractV1 =
|
|
2164
|
+
const getLatestLogsContractV1 = base.route({
|
|
1672
2165
|
path: "/v1/environments/{environmentId}/latest-logs",
|
|
1673
2166
|
method: "GET",
|
|
1674
2167
|
summary: "Get latest logs",
|
|
1675
2168
|
description: "Get the N most recent logs for an environment",
|
|
1676
2169
|
tags: ["environments"],
|
|
1677
2170
|
successDescription: "The latest logs"
|
|
1678
|
-
}).errors({
|
|
1679
|
-
NOT_FOUND: {},
|
|
1680
|
-
BAD_REQUEST: {}
|
|
1681
|
-
}).input(z.object({
|
|
2171
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1682
2172
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1683
2173
|
limit: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of most recent log entries to return"),
|
|
1684
2174
|
level: z.array(z.enum([
|
|
@@ -1687,9 +2177,9 @@ const getLatestLogsContractV1 = oc.route({
|
|
|
1687
2177
|
"WARNING",
|
|
1688
2178
|
"DEBUG"
|
|
1689
2179
|
])).optional().describe("Filter by log level"),
|
|
1690
|
-
search:
|
|
2180
|
+
search: logSearchSchema.optional().describe("Term to search for in log content")
|
|
1691
2181
|
})).output(z.object({ logs: z.array(logEntrySchema) }));
|
|
1692
|
-
const getDeploymentLogsContractV1 =
|
|
2182
|
+
const getDeploymentLogsContractV1 = base.route({
|
|
1693
2183
|
path: "/v1/deployments/{deploymentId}/logs",
|
|
1694
2184
|
method: "GET",
|
|
1695
2185
|
summary: "Get deployment logs",
|
|
@@ -1716,22 +2206,19 @@ const analyticsTimeSeriesSchema = z.object({
|
|
|
1716
2206
|
output_token_mean: z.array(analyticsDataPointSchema),
|
|
1717
2207
|
task_count: z.array(analyticsDataPointSchema)
|
|
1718
2208
|
});
|
|
1719
|
-
const getProjectAnalyticsContractV1 =
|
|
2209
|
+
const getProjectAnalyticsContractV1 = base.route({
|
|
1720
2210
|
path: "/v1/analytics/{projectId}",
|
|
1721
2211
|
method: "GET",
|
|
1722
2212
|
summary: "Get project analytics",
|
|
1723
2213
|
description: "Get analytics data for a project over a time range",
|
|
1724
2214
|
tags: ["analytics"],
|
|
1725
2215
|
successDescription: "The project analytics data"
|
|
1726
|
-
}).errors({
|
|
1727
|
-
NOT_FOUND: {},
|
|
1728
|
-
BAD_REQUEST: {}
|
|
1729
|
-
}).input(z.object({
|
|
2216
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1730
2217
|
projectId: z.string().describe("The ID of the project"),
|
|
1731
2218
|
startTimestamp: z.coerce.number().describe("Start timestamp in milliseconds"),
|
|
1732
2219
|
endTimestamp: z.coerce.number().describe("End timestamp in milliseconds"),
|
|
1733
2220
|
timeZone: z.string().describe("IANA timezone (e.g. Europe/Paris)")
|
|
1734
|
-
}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <=
|
|
2221
|
+
}).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({
|
|
1735
2222
|
metadata: z.object({
|
|
1736
2223
|
startTimestamp: z.number(),
|
|
1737
2224
|
endTimestamp: z.number(),
|
|
@@ -1741,7 +2228,132 @@ const getProjectAnalyticsContractV1 = oc.route({
|
|
|
1741
2228
|
}),
|
|
1742
2229
|
timeSeries: analyticsTimeSeriesSchema
|
|
1743
2230
|
}));
|
|
1744
|
-
const
|
|
2231
|
+
const paginatedInsightsInputShape = {
|
|
2232
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2233
|
+
since: timeInputSchema.default("7d").describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
2234
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
2235
|
+
limit: z.coerce.number().int().min(1).max(200).default(50),
|
|
2236
|
+
offset: z.coerce.number().int().min(0).default(0),
|
|
2237
|
+
search: z.string().trim().min(1).max(200).optional()
|
|
2238
|
+
};
|
|
2239
|
+
const listIntentsContractV1 = base.route({
|
|
2240
|
+
path: "/v1/environments/{environmentId}/intents",
|
|
2241
|
+
method: "GET",
|
|
2242
|
+
summary: "List intents",
|
|
2243
|
+
description: "List grouped user intents for an environment over a time range",
|
|
2244
|
+
tags: ["insights"],
|
|
2245
|
+
successDescription: "The grouped user intents"
|
|
2246
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2247
|
+
...paginatedInsightsInputShape,
|
|
2248
|
+
tools: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
2249
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional(),
|
|
2250
|
+
categoryIds: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
2251
|
+
sortDir: z.enum(["asc", "desc"]).default("desc")
|
|
2252
|
+
})).output(z.object({
|
|
2253
|
+
intents: z.array(z.object({
|
|
2254
|
+
id: z.string(),
|
|
2255
|
+
intentIds: z.array(z.string()).min(1),
|
|
2256
|
+
environmentId: z.string(),
|
|
2257
|
+
message: z.string(),
|
|
2258
|
+
toolName: z.string(),
|
|
2259
|
+
createdAt: z.coerce.date(),
|
|
2260
|
+
occurrenceCount: z.number().int().positive(),
|
|
2261
|
+
clientName: z.string().nullable(),
|
|
2262
|
+
clientId: z.string().nullable(),
|
|
2263
|
+
categories: z.array(z.object({
|
|
2264
|
+
id: z.string(),
|
|
2265
|
+
name: z.string(),
|
|
2266
|
+
color: intentCategoryColorSchema
|
|
2267
|
+
}))
|
|
2268
|
+
})),
|
|
2269
|
+
totalCount: z.number().int().nonnegative()
|
|
2270
|
+
}));
|
|
2271
|
+
const listFeedbacksContractV1 = base.route({
|
|
2272
|
+
path: "/v1/environments/{environmentId}/feedbacks",
|
|
2273
|
+
method: "GET",
|
|
2274
|
+
summary: "List feedbacks",
|
|
2275
|
+
description: "List user feedback for an environment over a time range",
|
|
2276
|
+
tags: ["insights"],
|
|
2277
|
+
successDescription: "The user feedback"
|
|
2278
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2279
|
+
...paginatedInsightsInputShape,
|
|
2280
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional()
|
|
2281
|
+
})).output(z.object({
|
|
2282
|
+
feedbacks: z.array(feedbackSchema.extend({ clientId: z.string().nullable() })),
|
|
2283
|
+
totalCount: z.number().int().nonnegative()
|
|
2284
|
+
}));
|
|
2285
|
+
const intentCategoryNameSchema = z.string().trim().min(1).max(100).describe("The category name");
|
|
2286
|
+
const categorizableIntentIdsSchema = z.array(z.string().trim().min(1)).min(1).max(100).describe("IDs of the intents to categorize");
|
|
2287
|
+
const listIntentCategoriesContractV1 = base.route({
|
|
2288
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
2289
|
+
method: "GET",
|
|
2290
|
+
summary: "List intent categories",
|
|
2291
|
+
description: "List intent categories for an environment, including how many intents each category is linked to",
|
|
2292
|
+
tags: ["insights"],
|
|
2293
|
+
successDescription: "The intent categories"
|
|
2294
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(intentCategorySummarySchema));
|
|
2295
|
+
const createIntentCategoryContractV1 = base.route({
|
|
2296
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
2297
|
+
method: "POST",
|
|
2298
|
+
summary: "Create an intent category",
|
|
2299
|
+
description: "Create an intent category, optionally linking it to existing intents",
|
|
2300
|
+
tags: ["insights"],
|
|
2301
|
+
successDescription: "The created intent category"
|
|
2302
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2303
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2304
|
+
name: intentCategoryNameSchema,
|
|
2305
|
+
color: intentCategoryColorSchema.optional().describe("The category color; derived from the name when omitted"),
|
|
2306
|
+
intentIds: categorizableIntentIdsSchema.optional().describe("IDs of intents to link to the new category")
|
|
2307
|
+
})).output(intentCategorySchema);
|
|
2308
|
+
const updateIntentCategoryContractV1 = base.route({
|
|
2309
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
2310
|
+
method: "PATCH",
|
|
2311
|
+
summary: "Update an intent category",
|
|
2312
|
+
description: "Rename or recolor an intent category",
|
|
2313
|
+
tags: ["insights"],
|
|
2314
|
+
successDescription: "The updated intent category"
|
|
2315
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2316
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2317
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2318
|
+
name: intentCategoryNameSchema.optional(),
|
|
2319
|
+
color: intentCategoryColorSchema.optional().describe("The category color")
|
|
2320
|
+
}).refine(({ name, color }) => name !== void 0 || color !== void 0, { message: "At least one of name or color must be provided" })).output(intentCategorySchema);
|
|
2321
|
+
const deleteIntentCategoryContractV1 = base.route({
|
|
2322
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
2323
|
+
method: "DELETE",
|
|
2324
|
+
summary: "Delete an intent category",
|
|
2325
|
+
description: "Delete an intent category; its intents are unlinked but not deleted",
|
|
2326
|
+
tags: ["insights"],
|
|
2327
|
+
successDescription: "The intent category has been deleted successfully"
|
|
2328
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2329
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2330
|
+
categoryId: z.string().describe("The ID of the category")
|
|
2331
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2332
|
+
const linkIntentCategoryContractV1 = base.route({
|
|
2333
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/link",
|
|
2334
|
+
method: "POST",
|
|
2335
|
+
summary: "Link an intent category",
|
|
2336
|
+
description: "Link an intent category to intents; already linked intents are ignored",
|
|
2337
|
+
tags: ["insights"],
|
|
2338
|
+
successDescription: "The intents have been linked successfully"
|
|
2339
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2340
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2341
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2342
|
+
intentIds: categorizableIntentIdsSchema
|
|
2343
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2344
|
+
const unlinkIntentCategoryContractV1 = base.route({
|
|
2345
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/unlink",
|
|
2346
|
+
method: "POST",
|
|
2347
|
+
summary: "Unlink an intent category",
|
|
2348
|
+
description: "Unlink an intent category from intents; intents without the category are ignored",
|
|
2349
|
+
tags: ["insights"],
|
|
2350
|
+
successDescription: "The intents have been unlinked successfully"
|
|
2351
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2352
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2353
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2354
|
+
intentIds: categorizableIntentIdsSchema
|
|
2355
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2356
|
+
const listTeamsContractV1 = base.route({
|
|
1745
2357
|
path: "/v1/teams",
|
|
1746
2358
|
method: "GET",
|
|
1747
2359
|
summary: "List teams",
|
|
@@ -1754,7 +2366,22 @@ const listTeamsContractV1 = oc.route({
|
|
|
1754
2366
|
createdAt: z.coerce.date(),
|
|
1755
2367
|
hasStripeAccount: z.boolean()
|
|
1756
2368
|
})));
|
|
1757
|
-
const
|
|
2369
|
+
const getTeamUsageContractV1 = base.route({
|
|
2370
|
+
path: "/v1/teams/{teamId}/usage",
|
|
2371
|
+
method: "GET",
|
|
2372
|
+
summary: "Get team usage",
|
|
2373
|
+
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.",
|
|
2374
|
+
tags: ["teams"],
|
|
2375
|
+
successDescription: "The current billing window usage"
|
|
2376
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().describe("The ID of the team") })).output(z.object({
|
|
2377
|
+
teamId: z.string(),
|
|
2378
|
+
plan: subscriptionPlanSchema.nullable().describe("The plan in force for the window, null on the Free plan"),
|
|
2379
|
+
periodStart: z.coerce.date().describe("Start of the current billing window"),
|
|
2380
|
+
periodEnd: z.coerce.date().describe("End of the current billing window"),
|
|
2381
|
+
requestCount: z.number().int().describe("MCP requests settled during the current billing window"),
|
|
2382
|
+
includedRequests: z.number().int().nullable().describe("Requests included in the plan for one window, null when the allowance is contract-specific")
|
|
2383
|
+
}));
|
|
2384
|
+
const getTunnelTicketContractV1 = base.route({
|
|
1758
2385
|
path: "/v1/tunnels/ticket",
|
|
1759
2386
|
method: "GET",
|
|
1760
2387
|
summary: "Get a tunnel ticket",
|
|
@@ -1766,16 +2393,13 @@ const getTunnelTicketContractV1 = oc.route({
|
|
|
1766
2393
|
ticket: z.string().describe("The signed tunnel ticket"),
|
|
1767
2394
|
tunnelHost: z.string().describe("The tunnel host to connect to")
|
|
1768
2395
|
}));
|
|
1769
|
-
const publishServerContractV1 =
|
|
2396
|
+
const publishServerContractV1 = base.route({
|
|
1770
2397
|
path: "/v1/distribution/publish",
|
|
1771
2398
|
method: "POST",
|
|
1772
2399
|
summary: "Publish a server to the MCP registry",
|
|
1773
2400
|
tags: ["distribution"],
|
|
1774
2401
|
successDescription: "The server has been published successfully"
|
|
1775
|
-
}).errors({
|
|
1776
|
-
NOT_FOUND: {},
|
|
1777
|
-
BAD_REQUEST: {}
|
|
1778
|
-
}).input(z.object({
|
|
2402
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1779
2403
|
projectId: z.string(),
|
|
1780
2404
|
domain: z.string(),
|
|
1781
2405
|
title: z.string().min(1).max(100),
|
|
@@ -1784,17 +2408,14 @@ const publishServerContractV1 = oc.route({
|
|
|
1784
2408
|
iconSrc: z.url().max(255).optional(),
|
|
1785
2409
|
dryRun: z.boolean().optional()
|
|
1786
2410
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
1787
|
-
const getServerInfoContractV1 =
|
|
2411
|
+
const getServerInfoContractV1 = base.route({
|
|
1788
2412
|
path: "/v1/distribution/get",
|
|
1789
2413
|
method: "GET",
|
|
1790
2414
|
summary: "Get server info",
|
|
1791
2415
|
description: "Get info about a server",
|
|
1792
2416
|
tags: ["distribution"],
|
|
1793
2417
|
successDescription: "The server info"
|
|
1794
|
-
}).errors({
|
|
1795
|
-
NOT_FOUND: {},
|
|
1796
|
-
BAD_REQUEST: {}
|
|
1797
|
-
}).input(z.object({
|
|
2418
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1798
2419
|
projectId: z.string(),
|
|
1799
2420
|
domain: z.string()
|
|
1800
2421
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
@@ -1813,7 +2434,7 @@ const playgroundOutputSchema = z.object({
|
|
|
1813
2434
|
isPlaygroundEnabled: z.boolean(),
|
|
1814
2435
|
serverMetadata: playgroundServerMetadataOutputSchema.nullable()
|
|
1815
2436
|
});
|
|
1816
|
-
const getPlaygroundContractV1 =
|
|
2437
|
+
const getPlaygroundContractV1 = base.route({
|
|
1817
2438
|
path: "/v1/environments/{environmentId}/playground",
|
|
1818
2439
|
method: "GET",
|
|
1819
2440
|
summary: "Get playground configuration",
|
|
@@ -1821,17 +2442,14 @@ const getPlaygroundContractV1 = oc.route({
|
|
|
1821
2442
|
tags: ["environments"],
|
|
1822
2443
|
successDescription: "The playground configuration"
|
|
1823
2444
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(playgroundOutputSchema);
|
|
1824
|
-
const upsertPlaygroundContractV1 =
|
|
2445
|
+
const upsertPlaygroundContractV1 = base.route({
|
|
1825
2446
|
path: "/v1/environments/{environmentId}/playground",
|
|
1826
2447
|
method: "PUT",
|
|
1827
2448
|
summary: "Update playground configuration",
|
|
1828
2449
|
description: "Update the playground configuration for an environment. All fields are optional — only provided fields are updated.",
|
|
1829
2450
|
tags: ["environments"],
|
|
1830
2451
|
successDescription: "The updated playground configuration"
|
|
1831
|
-
}).errors({
|
|
1832
|
-
NOT_FOUND: {},
|
|
1833
|
-
BAD_REQUEST: {}
|
|
1834
|
-
}).input(z.object({
|
|
2452
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1835
2453
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1836
2454
|
isPlaygroundEnabled: z.boolean().optional(),
|
|
1837
2455
|
name: z.string().min(1).max(100).optional(),
|
|
@@ -1839,7 +2457,7 @@ const upsertPlaygroundContractV1 = oc.route({
|
|
|
1839
2457
|
headers: z.array(playgroundHeaderSchema).optional(),
|
|
1840
2458
|
examplePrompts: z.array(playgroundExamplePromptSchema).max(5).optional()
|
|
1841
2459
|
})).output(playgroundOutputSchema);
|
|
1842
|
-
const createBeaconContractV1 =
|
|
2460
|
+
const createBeaconContractV1 = base.route({
|
|
1843
2461
|
path: "/v1/beacon/audits",
|
|
1844
2462
|
method: "POST",
|
|
1845
2463
|
summary: "Create a beacon audit",
|
|
@@ -1848,7 +2466,6 @@ const createBeaconContractV1 = oc.route({
|
|
|
1848
2466
|
successDescription: "The audit has been created"
|
|
1849
2467
|
}).errors({
|
|
1850
2468
|
NOT_FOUND: {},
|
|
1851
|
-
BAD_REQUEST: {},
|
|
1852
2469
|
DNS_RESOLUTION_FAILED: { status: 400 }
|
|
1853
2470
|
}).input(z.object({
|
|
1854
2471
|
targetUrl: z.url().describe("The HTTPS URL of the MCP server to audit"),
|
|
@@ -1856,7 +2473,7 @@ const createBeaconContractV1 = oc.route({
|
|
|
1856
2473
|
projectId: z.string().optional().describe("The project ID to associate the audit with"),
|
|
1857
2474
|
excludeCategories: z.array(checkCategorySchema).optional().describe("Check categories to exclude from the audit")
|
|
1858
2475
|
})).output(z.object({ id: z.string() }));
|
|
1859
|
-
const getBeaconContractV1 =
|
|
2476
|
+
const getBeaconContractV1 = base.route({
|
|
1860
2477
|
path: "/v1/beacon/audits/{auditId}",
|
|
1861
2478
|
method: "GET",
|
|
1862
2479
|
summary: "Get a beacon audit",
|
|
@@ -1871,9 +2488,73 @@ const getBeaconContractV1 = oc.route({
|
|
|
1871
2488
|
createdAt: z.coerce.date(),
|
|
1872
2489
|
report: auditReportWithScreenshotsSchema.nullable()
|
|
1873
2490
|
}));
|
|
2491
|
+
const PLATFORM_DESCRIPTION = "The directory the package targets: `chatgpt` for the OpenAI App Directory, `claudeai` for the Anthropic MCP Directory";
|
|
2492
|
+
const submissionIdSchema = z.string().describe("The ID of the submission package");
|
|
2493
|
+
const claudeSubmissionUpdateSchema = claudeSubmissionDraftSchema.strict();
|
|
2494
|
+
const chatgptSubmissionUpdateSchema = chatgptSubmissionDraftSchema.strict();
|
|
2495
|
+
const createSubmissionContractV1 = base.route({
|
|
2496
|
+
path: "/v1/submissions",
|
|
2497
|
+
method: "POST",
|
|
2498
|
+
summary: "Create a submission package",
|
|
2499
|
+
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.",
|
|
2500
|
+
tags: ["submissions"],
|
|
2501
|
+
successDescription: "The created submission package, with its prefilled fields"
|
|
2502
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2503
|
+
environmentId: z.string().describe("The ID of the environment to build the package from"),
|
|
2504
|
+
platform: platformSchema.describe(PLATFORM_DESCRIPTION)
|
|
2505
|
+
})).output(submissionSchema);
|
|
2506
|
+
const listSubmissionsContractV1 = base.route({
|
|
2507
|
+
path: "/v1/projects/{projectId}/submissions",
|
|
2508
|
+
method: "GET",
|
|
2509
|
+
summary: "List submission packages",
|
|
2510
|
+
description: "List the submission packages of a project, grouped by directory and most recently updated first, optionally narrowed to one environment or one directory",
|
|
2511
|
+
tags: ["submissions"],
|
|
2512
|
+
successDescription: "The list of submission packages"
|
|
2513
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2514
|
+
projectId: z.string().describe("The ID of the project"),
|
|
2515
|
+
environmentId: z.string().optional().describe("Filter by environment ID"),
|
|
2516
|
+
platform: platformSchema.optional().describe(PLATFORM_DESCRIPTION)
|
|
2517
|
+
})).output(z.array(submissionSchema));
|
|
2518
|
+
const getSubmissionContractV1 = base.route({
|
|
2519
|
+
path: "/v1/submissions/{submissionId}",
|
|
2520
|
+
method: "GET",
|
|
2521
|
+
summary: "Get a submission package",
|
|
2522
|
+
description: "Get a submission package by ID, including its form data and the prefill it started from",
|
|
2523
|
+
tags: ["submissions"],
|
|
2524
|
+
successDescription: "The submission package"
|
|
2525
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ submissionId: submissionIdSchema })).output(submissionSchema);
|
|
2526
|
+
const updateSubmissionContractV1 = base.route({
|
|
2527
|
+
path: "/v1/submissions/{submissionId}",
|
|
2528
|
+
method: "PUT",
|
|
2529
|
+
summary: "Update a submission package",
|
|
2530
|
+
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.",
|
|
2531
|
+
tags: ["submissions"],
|
|
2532
|
+
successDescription: "The updated submission package"
|
|
2533
|
+
}).errors({ NOT_FOUND: {} }).input(z.discriminatedUnion("platform", [z.object({
|
|
2534
|
+
submissionId: submissionIdSchema,
|
|
2535
|
+
platform: z.literal("claudeai").describe(PLATFORM_DESCRIPTION),
|
|
2536
|
+
formData: claudeSubmissionUpdateSchema
|
|
2537
|
+
}), z.object({
|
|
2538
|
+
submissionId: submissionIdSchema,
|
|
2539
|
+
platform: z.literal("chatgpt").describe(PLATFORM_DESCRIPTION),
|
|
2540
|
+
formData: chatgptSubmissionUpdateSchema
|
|
2541
|
+
})])).output(submissionSchema);
|
|
1874
2542
|
const contract = {
|
|
1875
|
-
teams: {
|
|
2543
|
+
teams: {
|
|
2544
|
+
list: { v1: listTeamsContractV1 },
|
|
2545
|
+
getUsage: { v1: getTeamUsageContractV1 }
|
|
2546
|
+
},
|
|
1876
2547
|
analytics: { get: { v1: getProjectAnalyticsContractV1 } },
|
|
2548
|
+
intents: { list: { v1: listIntentsContractV1 } },
|
|
2549
|
+
intentCategories: {
|
|
2550
|
+
list: { v1: listIntentCategoriesContractV1 },
|
|
2551
|
+
create: { v1: createIntentCategoryContractV1 },
|
|
2552
|
+
update: { v1: updateIntentCategoryContractV1 },
|
|
2553
|
+
delete: { v1: deleteIntentCategoryContractV1 },
|
|
2554
|
+
link: { v1: linkIntentCategoryContractV1 },
|
|
2555
|
+
unlink: { v1: unlinkIntentCategoryContractV1 }
|
|
2556
|
+
},
|
|
2557
|
+
feedbacks: { list: { v1: listFeedbacksContractV1 } },
|
|
1877
2558
|
deployments: {
|
|
1878
2559
|
list: { v1: listDeploymentsContractV1 },
|
|
1879
2560
|
get: { v1: getDeploymentContractV1 },
|
|
@@ -1883,6 +2564,7 @@ const contract = {
|
|
|
1883
2564
|
environments: {
|
|
1884
2565
|
create: { v1: createEnvironmentContractV1 },
|
|
1885
2566
|
get: { v1: getEnvironmentContractV1 },
|
|
2567
|
+
delete: { v1: deleteEnvironmentContractV1 },
|
|
1886
2568
|
deploy: { v1: deployEnvironmentContractV1 },
|
|
1887
2569
|
getLogs: { v1: getLogsContractV1 },
|
|
1888
2570
|
getLatestLogs: { v1: getLatestLogsContractV1 }
|
|
@@ -1893,6 +2575,12 @@ const contract = {
|
|
|
1893
2575
|
update: { v1: updateEnvironmentVariableContractV1 },
|
|
1894
2576
|
delete: { v1: deleteEnvironmentVariableContractV1 }
|
|
1895
2577
|
},
|
|
2578
|
+
telemetryDestinations: {
|
|
2579
|
+
list: { v1: listTelemetryDestinationsContractV1 },
|
|
2580
|
+
create: { v1: createTelemetryDestinationContractV1 },
|
|
2581
|
+
update: { v1: updateTelemetryDestinationContractV1 },
|
|
2582
|
+
delete: { v1: deleteTelemetryDestinationContractV1 }
|
|
2583
|
+
},
|
|
1896
2584
|
projects: {
|
|
1897
2585
|
update: { v1: updateProjectContractV1 },
|
|
1898
2586
|
get: { v1: getProjectContractV1 },
|
|
@@ -1912,7 +2600,39 @@ const contract = {
|
|
|
1912
2600
|
beacon: {
|
|
1913
2601
|
create: { v1: createBeaconContractV1 },
|
|
1914
2602
|
get: { v1: getBeaconContractV1 }
|
|
2603
|
+
},
|
|
2604
|
+
submissions: {
|
|
2605
|
+
create: { v1: createSubmissionContractV1 },
|
|
2606
|
+
list: { v1: listSubmissionsContractV1 },
|
|
2607
|
+
get: { v1: getSubmissionContractV1 },
|
|
2608
|
+
update: { v1: updateSubmissionContractV1 }
|
|
2609
|
+
}
|
|
2610
|
+
};
|
|
2611
|
+
const { uploadArtifact: _discard, ...deploymentsForDocs } = contract.deployments;
|
|
2612
|
+
const contractForDocs = {
|
|
2613
|
+
...contract,
|
|
2614
|
+
deployments: deploymentsForDocs
|
|
2615
|
+
};
|
|
2616
|
+
/** Shared by the served `openapi.json` and the snapshot test that guards it, so the two cannot drift. */
|
|
2617
|
+
const OPENAPI_DOC_OPTIONS = {
|
|
2618
|
+
info: {
|
|
2619
|
+
title: "Alpic API",
|
|
2620
|
+
version: "1.0.0"
|
|
2621
|
+
},
|
|
2622
|
+
servers: [{ url: "https://api.alpic.ai" }],
|
|
2623
|
+
security: [{ bearerAuth: [] }],
|
|
2624
|
+
components: { securitySchemes: { bearerAuth: {
|
|
2625
|
+
type: "http",
|
|
2626
|
+
description: "Bearer token for authentication. Use an API key from the API Keys page in team settings, or an OAuth access token.",
|
|
2627
|
+
scheme: "bearer"
|
|
2628
|
+
} } },
|
|
2629
|
+
commonSchemas: {
|
|
2630
|
+
Submission: { schema: submissionSchema },
|
|
2631
|
+
ClaudeSubmissionFormData: { schema: claudeSubmissionDraftSchema },
|
|
2632
|
+
ChatgptSubmissionFormData: { schema: chatgptSubmissionDraftSchema },
|
|
2633
|
+
ClaudeSubmissionFormDataUpdate: { schema: claudeSubmissionUpdateSchema },
|
|
2634
|
+
ChatgptSubmissionFormDataUpdate: { schema: chatgptSubmissionUpdateSchema }
|
|
1915
2635
|
}
|
|
1916
2636
|
};
|
|
1917
2637
|
//#endregion
|
|
1918
|
-
export { AUTH_SCOPE_ANY, AUTH_SCOPE_USER, PLATFORM_LABELS, buildSettingsSchema, contract, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
|
|
2638
|
+
export { AI_PLATFORMS, AUTH_SCOPE_ANY, AUTH_SCOPE_USER, INTENT_CATEGORY_COLORS, OPENAPI_DOC_OPTIONS, OTLP_PROTOCOLS, PLATFORM_LABELS, TELEMETRY_SIGNALS, buildSettingsSchema, chatgptSubmissionUpdateSchema, claudeSubmissionUpdateSchema, contract, contractForDocs, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, intentCategoryColorSchema, otlpProtocolSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, telemetrySignalSchema, transportSchema, updateEnvironmentVariableSchema };
|