@alpic-ai/api 0.0.0-staging.gefad4b9 → 0.0.0-staging.gefb8faf
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 +1556 -59
- package/dist/index.mjs +732 -213
- package/package.json +26 -10
package/dist/index.mjs
CHANGED
|
@@ -2,7 +2,7 @@ import { z } from "zod";
|
|
|
2
2
|
import * as z$1 from "zod/v4";
|
|
3
3
|
import { oc } from "@orpc/contract";
|
|
4
4
|
import ms from "ms";
|
|
5
|
-
//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.
|
|
5
|
+
//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.30.0_supports-color@7.2.0_zod@4.5.4/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
|
|
6
6
|
/**
|
|
7
7
|
* Reusable URL validation that disallows javascript: scheme
|
|
8
8
|
*/
|
|
@@ -169,11 +169,22 @@ z$1.object({
|
|
|
169
169
|
token: z$1.string(),
|
|
170
170
|
token_type_hint: z$1.string().optional()
|
|
171
171
|
}).strip();
|
|
172
|
-
|
|
172
|
+
//#endregion
|
|
173
|
+
//#region ../domains/dist/index.mjs
|
|
174
|
+
const AI_PLATFORMS = ["chatgpt", "claudeai"];
|
|
175
|
+
const platformSchema = z.enum(AI_PLATFORMS);
|
|
173
176
|
const PLATFORM_LABELS = {
|
|
174
177
|
chatgpt: "ChatGPT",
|
|
175
178
|
claudeai: "Claude.ai"
|
|
176
179
|
};
|
|
180
|
+
const WAF_PLATFORMS = [
|
|
181
|
+
"akamai",
|
|
182
|
+
"cato",
|
|
183
|
+
"cloudflare",
|
|
184
|
+
"fastly"
|
|
185
|
+
];
|
|
186
|
+
const ALLOWED_PLATFORMS = [...AI_PLATFORMS, ...WAF_PLATFORMS];
|
|
187
|
+
const allowedPlatformSchema = z.enum(ALLOWED_PLATFORMS);
|
|
177
188
|
const auditStatusSchema = z.enum([
|
|
178
189
|
"pending",
|
|
179
190
|
"partial",
|
|
@@ -246,6 +257,25 @@ z.object({
|
|
|
246
257
|
clientSecret: z.string(),
|
|
247
258
|
clientScopes: z.array(z.string())
|
|
248
259
|
});
|
|
260
|
+
const creditEntryReasonSchema = z.enum([
|
|
261
|
+
"free_seed",
|
|
262
|
+
"paid_conversion_floor",
|
|
263
|
+
"top_up",
|
|
264
|
+
"usage",
|
|
265
|
+
"admin_adjustment"
|
|
266
|
+
]);
|
|
267
|
+
z.enum(["playground"]);
|
|
268
|
+
z.number().int().min(500);
|
|
269
|
+
const creditActivityEntrySchema = z.object({
|
|
270
|
+
reason: creditEntryReasonSchema,
|
|
271
|
+
day: z.number(),
|
|
272
|
+
amountInNanoUSD: z.number(),
|
|
273
|
+
messageCount: z.number().nullable()
|
|
274
|
+
});
|
|
275
|
+
z.object({
|
|
276
|
+
balanceInNanoUSD: z.number(),
|
|
277
|
+
recentActivity: z.array(creditActivityEntrySchema)
|
|
278
|
+
});
|
|
249
279
|
const deploymentStatusSchema$1 = z.enum([
|
|
250
280
|
"ongoing",
|
|
251
281
|
"deployed",
|
|
@@ -273,34 +303,51 @@ const deploymentSummarySchema = z.object({
|
|
|
273
303
|
createdAt: z.coerce.date(),
|
|
274
304
|
updatedAt: z.coerce.date()
|
|
275
305
|
});
|
|
276
|
-
/**
|
|
277
|
-
* Public environment
|
|
278
|
-
*
|
|
279
|
-
* No OAuth metadata exposed.
|
|
280
|
-
*/
|
|
306
|
+
/** Public environment: answers anonymously and exposes no OAuth metadata. */
|
|
281
307
|
const publicEnvironmentSchema = z.object({
|
|
308
|
+
allowsAnonymous: z.literal(true),
|
|
309
|
+
oAuthMetadata: z.strictObject({})
|
|
310
|
+
});
|
|
311
|
+
/** 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. */
|
|
312
|
+
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
313
|
+
allowsAnonymous: z.boolean(),
|
|
314
|
+
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
315
|
+
scope: z.string().optional()
|
|
316
|
+
});
|
|
317
|
+
/** 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. */
|
|
318
|
+
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
319
|
+
allowsAnonymous: z.boolean(),
|
|
320
|
+
oAuthMetadata: z.object({
|
|
321
|
+
externalAuthorizationServerUrl: z.url(),
|
|
322
|
+
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
|
|
323
|
+
}),
|
|
324
|
+
scope: z.string().optional()
|
|
325
|
+
});
|
|
326
|
+
/** Standalone protected environment: the server itself exposes both the /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server endpoints. */
|
|
327
|
+
const standaloneEnvironmentSchema = z.object({
|
|
328
|
+
allowsAnonymous: z.boolean(),
|
|
329
|
+
oAuthMetadata: z.object({
|
|
330
|
+
authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
|
|
331
|
+
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
|
|
332
|
+
}),
|
|
333
|
+
scope: z.string().optional()
|
|
334
|
+
});
|
|
335
|
+
/** Protected environment that enforces authentication but advertises no OAuth discovery metadata; clients must obtain credentials out-of-band. */
|
|
336
|
+
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
337
|
+
allowsAnonymous: z.literal(false),
|
|
338
|
+
oAuthMetadata: z.strictObject({}),
|
|
339
|
+
scope: z.string().optional()
|
|
340
|
+
});
|
|
341
|
+
const legacyPublicEnvironmentSchema = z.object({
|
|
282
342
|
isPublic: z.literal(true),
|
|
283
343
|
oAuthMetadata: z.undefined().optional()
|
|
284
344
|
});
|
|
285
|
-
|
|
286
|
-
* Protected environment with an external resource metadata URL
|
|
287
|
-
*
|
|
288
|
-
* An external resource metadata URL is returned in the WWW-Authenticate header during the first 401 response.
|
|
289
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
290
|
-
*/
|
|
291
|
-
const externalResourceMetadataEnvironmentSchema = z.object({
|
|
345
|
+
const legacyExternalResourceMetadataEnvironmentSchema = z.object({
|
|
292
346
|
isPublic: z.literal(false),
|
|
293
347
|
oAuthMetadata: z.object({ externalResourceMetadataUrl: z.url() }),
|
|
294
348
|
scope: z.string().optional()
|
|
295
349
|
});
|
|
296
|
-
|
|
297
|
-
* Protected environment with an external authorization server URL
|
|
298
|
-
*
|
|
299
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
300
|
-
* An external authorization server URL is returned when requesting the endpoint.
|
|
301
|
-
* Everything that follows is handled outside of the MCP server scope.
|
|
302
|
-
*/
|
|
303
|
-
const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
350
|
+
const legacyExternalAuthorizationServerEnvironmentSchema = z.object({
|
|
304
351
|
isPublic: z.literal(false),
|
|
305
352
|
oAuthMetadata: z.object({
|
|
306
353
|
externalAuthorizationServerUrl: z.url(),
|
|
@@ -308,13 +355,7 @@ const externalAuthorizationServerEnvironmentSchema = z.object({
|
|
|
308
355
|
}),
|
|
309
356
|
scope: z.string().optional()
|
|
310
357
|
});
|
|
311
|
-
|
|
312
|
-
* Standalone protected environment
|
|
313
|
-
*
|
|
314
|
-
* The server itself exposes the /.well-known/oauth-protected-resource endpoint.
|
|
315
|
-
* The server itself exposes the /.well-known/oauth-authorization-server endpoint.
|
|
316
|
-
*/
|
|
317
|
-
const standaloneEnvironmentSchema = z.object({
|
|
358
|
+
const legacyStandaloneEnvironmentSchema = z.object({
|
|
318
359
|
isPublic: z.literal(false),
|
|
319
360
|
oAuthMetadata: z.object({
|
|
320
361
|
authorizationServerMetadata: z.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]),
|
|
@@ -322,14 +363,7 @@ const standaloneEnvironmentSchema = z.object({
|
|
|
322
363
|
}),
|
|
323
364
|
scope: z.string().optional()
|
|
324
365
|
});
|
|
325
|
-
|
|
326
|
-
* Protected environment without OAuth discovery
|
|
327
|
-
*
|
|
328
|
-
* The server enforces authentication but exposes no OAuth discovery metadata.
|
|
329
|
-
* Neither /.well-known/oauth-protected-resource nor /.well-known/oauth-authorization-server
|
|
330
|
-
* are advertised. Clients must obtain credentials out-of-band.
|
|
331
|
-
*/
|
|
332
|
-
const protectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
366
|
+
const legacyProtectedWithoutDiscoveryEnvironmentSchema = z.object({
|
|
333
367
|
isPublic: z.literal(false),
|
|
334
368
|
oAuthMetadata: z.strictObject({}),
|
|
335
369
|
scope: z.string().optional()
|
|
@@ -339,9 +373,13 @@ z.union([
|
|
|
339
373
|
externalResourceMetadataEnvironmentSchema,
|
|
340
374
|
externalAuthorizationServerEnvironmentSchema,
|
|
341
375
|
standaloneEnvironmentSchema,
|
|
342
|
-
protectedWithoutDiscoveryEnvironmentSchema
|
|
376
|
+
protectedWithoutDiscoveryEnvironmentSchema,
|
|
377
|
+
legacyPublicEnvironmentSchema,
|
|
378
|
+
legacyExternalResourceMetadataEnvironmentSchema,
|
|
379
|
+
legacyExternalAuthorizationServerEnvironmentSchema,
|
|
380
|
+
legacyStandaloneEnvironmentSchema,
|
|
381
|
+
legacyProtectedWithoutDiscoveryEnvironmentSchema
|
|
343
382
|
]);
|
|
344
|
-
const allowedPlatformSchema = platformSchema;
|
|
345
383
|
const playgroundModelSchema = z.enum([
|
|
346
384
|
"global.anthropic.claude-haiku-4-5-20251001-v1:0",
|
|
347
385
|
"global.anthropic.claude-sonnet-4-5-20250929-v1:0",
|
|
@@ -381,14 +419,16 @@ z.object({
|
|
|
381
419
|
collectRequestPayload: z.boolean(),
|
|
382
420
|
collectResponsePayload: z.boolean(),
|
|
383
421
|
collectErrorMessage: z.boolean(),
|
|
384
|
-
collectUserData: z.boolean()
|
|
422
|
+
collectUserData: z.boolean(),
|
|
423
|
+
identityTraitKey: z.string().min(1).max(200).nullable()
|
|
385
424
|
});
|
|
386
|
-
z.object({
|
|
425
|
+
const feedbackSchema = z.object({
|
|
387
426
|
id: z.string(),
|
|
388
427
|
createdAt: z.coerce.date(),
|
|
389
428
|
environmentId: z.string(),
|
|
390
429
|
content: z.string(),
|
|
391
|
-
source: z.enum(["model", "user"])
|
|
430
|
+
source: z.enum(["model", "user"]),
|
|
431
|
+
clientName: z.string().nullable()
|
|
392
432
|
});
|
|
393
433
|
z.object({
|
|
394
434
|
content: z.string(),
|
|
@@ -404,7 +444,7 @@ const intentCategoryColorSchema = z.enum([
|
|
|
404
444
|
"pink",
|
|
405
445
|
"gray"
|
|
406
446
|
]);
|
|
407
|
-
intentCategoryColorSchema.options;
|
|
447
|
+
const INTENT_CATEGORY_COLORS = intentCategoryColorSchema.options;
|
|
408
448
|
const intentCategorySchema = z.object({
|
|
409
449
|
id: z.string(),
|
|
410
450
|
createdAt: z.coerce.date(),
|
|
@@ -412,7 +452,7 @@ const intentCategorySchema = z.object({
|
|
|
412
452
|
name: z.string(),
|
|
413
453
|
color: intentCategoryColorSchema
|
|
414
454
|
});
|
|
415
|
-
z.object({
|
|
455
|
+
const intentCategorySummarySchema = z.object({
|
|
416
456
|
id: z.string(),
|
|
417
457
|
name: z.string(),
|
|
418
458
|
color: intentCategoryColorSchema,
|
|
@@ -424,6 +464,7 @@ z.object({
|
|
|
424
464
|
environmentId: z.string(),
|
|
425
465
|
toolName: z.string(),
|
|
426
466
|
message: z.string(),
|
|
467
|
+
clientName: z.string().nullable(),
|
|
427
468
|
categories: z.array(intentCategorySchema)
|
|
428
469
|
});
|
|
429
470
|
const signalCategorySchema = z.object({
|
|
@@ -482,12 +523,262 @@ z.object({
|
|
|
482
523
|
createdAt: z.coerce.date(),
|
|
483
524
|
updatedAt: z.coerce.date()
|
|
484
525
|
});
|
|
526
|
+
const alpicMcpRequestLogSchema = z.object({
|
|
527
|
+
type: z.literal("mcp_request"),
|
|
528
|
+
method: z.string()
|
|
529
|
+
});
|
|
530
|
+
const alpicMcpErrorLogSchema = z.object({
|
|
531
|
+
type: z.literal("mcp_error"),
|
|
532
|
+
method: z.string(),
|
|
533
|
+
error: z.string()
|
|
534
|
+
});
|
|
535
|
+
z.union([alpicMcpRequestLogSchema, alpicMcpErrorLogSchema]);
|
|
485
536
|
z.enum([
|
|
486
537
|
"INFO",
|
|
487
538
|
"WARNING",
|
|
488
539
|
"DEBUG",
|
|
489
540
|
"ERROR"
|
|
490
541
|
]);
|
|
542
|
+
/** Only names a vendor actually ships belong here: lookalikes like `claude-code-test` are customers' own scripts. */
|
|
543
|
+
const MCP_CLIENT_GROUPS = [
|
|
544
|
+
{
|
|
545
|
+
id: "claude_code",
|
|
546
|
+
label: "Claude Code",
|
|
547
|
+
vendor: "anthropic",
|
|
548
|
+
rawNames: ["claude-code", "Anthropic/ClaudeCodeDesktop"]
|
|
549
|
+
},
|
|
550
|
+
{
|
|
551
|
+
id: "claude",
|
|
552
|
+
label: "Claude",
|
|
553
|
+
vendor: "anthropic",
|
|
554
|
+
rawNames: [
|
|
555
|
+
"Anthropic/ClaudeAI",
|
|
556
|
+
"claude-ai",
|
|
557
|
+
"claude",
|
|
558
|
+
"Claude",
|
|
559
|
+
"claude-desktop",
|
|
560
|
+
"claude-desktop-3p"
|
|
561
|
+
]
|
|
562
|
+
},
|
|
563
|
+
{
|
|
564
|
+
id: "claude_mobile",
|
|
565
|
+
label: "Claude mobile",
|
|
566
|
+
vendor: "anthropic",
|
|
567
|
+
rawNames: ["claude-ios", "ClaudeAndroid"]
|
|
568
|
+
},
|
|
569
|
+
{
|
|
570
|
+
id: "claude_cowork",
|
|
571
|
+
label: "Claude Cowork",
|
|
572
|
+
vendor: "anthropic",
|
|
573
|
+
rawNames: ["Anthropic/Cowork"]
|
|
574
|
+
},
|
|
575
|
+
{
|
|
576
|
+
id: "claude_toolbox",
|
|
577
|
+
label: "Claude Toolbox",
|
|
578
|
+
vendor: "anthropic",
|
|
579
|
+
rawNames: ["Anthropic/Toolbox", "Anthropic/toolbox-bootstrap"]
|
|
580
|
+
},
|
|
581
|
+
{
|
|
582
|
+
id: "anthropic_api",
|
|
583
|
+
label: "Anthropic API",
|
|
584
|
+
vendor: "anthropic",
|
|
585
|
+
rawNames: ["Anthropic/API"]
|
|
586
|
+
},
|
|
587
|
+
{
|
|
588
|
+
id: "anthropic_connector_refresh",
|
|
589
|
+
label: "Anthropic (connector refresh)",
|
|
590
|
+
vendor: "anthropic",
|
|
591
|
+
rawNames: ["Anthropic"]
|
|
592
|
+
},
|
|
593
|
+
{
|
|
594
|
+
id: "codex",
|
|
595
|
+
label: "Codex",
|
|
596
|
+
vendor: "openai",
|
|
597
|
+
rawNames: [
|
|
598
|
+
"codex-mcp-client",
|
|
599
|
+
"codex",
|
|
600
|
+
"Codex",
|
|
601
|
+
"codex-cli",
|
|
602
|
+
"openai-mcp (Codex)"
|
|
603
|
+
]
|
|
604
|
+
},
|
|
605
|
+
{
|
|
606
|
+
id: "chatgpt",
|
|
607
|
+
label: "ChatGPT",
|
|
608
|
+
vendor: "openai",
|
|
609
|
+
rawNames: ["openai-mcp (ChatGPT)"]
|
|
610
|
+
},
|
|
611
|
+
{
|
|
612
|
+
id: "openai_responses_api",
|
|
613
|
+
label: "OpenAI Responses API",
|
|
614
|
+
vendor: "openai",
|
|
615
|
+
rawNames: ["openai-mcp (Responses API)"]
|
|
616
|
+
},
|
|
617
|
+
{
|
|
618
|
+
id: "openai_agent_builder",
|
|
619
|
+
label: "OpenAI Agent Builder",
|
|
620
|
+
vendor: "openai",
|
|
621
|
+
rawNames: ["openai-mcp (Agent Builder)"]
|
|
622
|
+
},
|
|
623
|
+
{
|
|
624
|
+
id: "openai_other",
|
|
625
|
+
label: "OpenAI Other",
|
|
626
|
+
vendor: "openai",
|
|
627
|
+
rawNames: ["openai-mcp"]
|
|
628
|
+
},
|
|
629
|
+
{
|
|
630
|
+
id: "cursor",
|
|
631
|
+
label: "Cursor",
|
|
632
|
+
vendor: "cursor",
|
|
633
|
+
rawNames: [
|
|
634
|
+
"cursor-vscode",
|
|
635
|
+
"Cursor",
|
|
636
|
+
"cursor"
|
|
637
|
+
]
|
|
638
|
+
},
|
|
639
|
+
{
|
|
640
|
+
id: "cline",
|
|
641
|
+
label: "Cline",
|
|
642
|
+
vendor: "cline",
|
|
643
|
+
rawNames: [
|
|
644
|
+
"Cline",
|
|
645
|
+
"cline",
|
|
646
|
+
"@cline/core"
|
|
647
|
+
]
|
|
648
|
+
},
|
|
649
|
+
{
|
|
650
|
+
id: "github_copilot",
|
|
651
|
+
label: "GitHub Copilot",
|
|
652
|
+
vendor: "githubCopilot",
|
|
653
|
+
rawNames: [
|
|
654
|
+
"Copilot",
|
|
655
|
+
"github-copilot-developer",
|
|
656
|
+
"Copilot MCP Gateway",
|
|
657
|
+
"Xcode/copilot-xcode"
|
|
658
|
+
]
|
|
659
|
+
},
|
|
660
|
+
{
|
|
661
|
+
id: "gemini_cli",
|
|
662
|
+
label: "Gemini CLI",
|
|
663
|
+
vendor: "google",
|
|
664
|
+
rawNames: ["gemini-cli-mcp-client", "gemini-cli"]
|
|
665
|
+
},
|
|
666
|
+
{
|
|
667
|
+
id: "antigravity",
|
|
668
|
+
label: "Antigravity",
|
|
669
|
+
vendor: "google",
|
|
670
|
+
rawNames: ["antigravity-client"]
|
|
671
|
+
},
|
|
672
|
+
{
|
|
673
|
+
id: "gemini",
|
|
674
|
+
label: "Gemini",
|
|
675
|
+
vendor: "google",
|
|
676
|
+
rawNames: ["Gemini", "google-ai-edge-gallery"]
|
|
677
|
+
},
|
|
678
|
+
{
|
|
679
|
+
id: "windsurf",
|
|
680
|
+
label: "Windsurf",
|
|
681
|
+
vendor: "windsurf",
|
|
682
|
+
rawNames: ["Windsurf", "windsurf-client"]
|
|
683
|
+
},
|
|
684
|
+
{
|
|
685
|
+
id: "mistral",
|
|
686
|
+
label: "Mistral / Le Chat",
|
|
687
|
+
vendor: "mistral",
|
|
688
|
+
rawNames: ["Mistral"],
|
|
689
|
+
rawNamePrefixes: ["connector:custom-mcp:"]
|
|
690
|
+
},
|
|
691
|
+
{
|
|
692
|
+
id: "n8n",
|
|
693
|
+
label: "n8n",
|
|
694
|
+
vendor: "n8n",
|
|
695
|
+
rawNames: [
|
|
696
|
+
"@n8n/n8n-nodes-langchain.mcpClient",
|
|
697
|
+
"@n8n/n8n-nodes-langchain.mcpClientTool",
|
|
698
|
+
"n8n"
|
|
699
|
+
]
|
|
700
|
+
},
|
|
701
|
+
{
|
|
702
|
+
id: "alpic_playground",
|
|
703
|
+
label: "Alpic Playground",
|
|
704
|
+
vendor: "alpic",
|
|
705
|
+
rawNames: ["alpic-playground", "playground"]
|
|
706
|
+
},
|
|
707
|
+
{
|
|
708
|
+
id: "opencode",
|
|
709
|
+
label: "opencode",
|
|
710
|
+
vendor: "opencode",
|
|
711
|
+
rawNames: ["opencode"]
|
|
712
|
+
},
|
|
713
|
+
{
|
|
714
|
+
id: "zed",
|
|
715
|
+
label: "Zed",
|
|
716
|
+
vendor: "zed",
|
|
717
|
+
rawNames: ["Zed", "zed"]
|
|
718
|
+
},
|
|
719
|
+
{
|
|
720
|
+
id: "zapier",
|
|
721
|
+
label: "Zapier",
|
|
722
|
+
vendor: "zapier",
|
|
723
|
+
rawNames: ["Zapier", "zapier"]
|
|
724
|
+
},
|
|
725
|
+
{
|
|
726
|
+
id: "make",
|
|
727
|
+
label: "Make",
|
|
728
|
+
vendor: "make",
|
|
729
|
+
rawNames: ["Make", "make"]
|
|
730
|
+
},
|
|
731
|
+
{
|
|
732
|
+
id: "librechat",
|
|
733
|
+
label: "LibreChat",
|
|
734
|
+
vendor: "mcp",
|
|
735
|
+
rawNames: ["LibreChat", "librechat"]
|
|
736
|
+
},
|
|
737
|
+
{
|
|
738
|
+
id: "jan",
|
|
739
|
+
label: "Jan",
|
|
740
|
+
vendor: "mcp",
|
|
741
|
+
rawNames: ["Jan", "jan"]
|
|
742
|
+
},
|
|
743
|
+
{
|
|
744
|
+
id: "goose",
|
|
745
|
+
label: "goose",
|
|
746
|
+
vendor: "mcp",
|
|
747
|
+
rawNames: ["goose", "Goose"]
|
|
748
|
+
},
|
|
749
|
+
{
|
|
750
|
+
id: "mcphost",
|
|
751
|
+
label: "mcphost",
|
|
752
|
+
vendor: "mcp",
|
|
753
|
+
rawNames: ["mcphost"]
|
|
754
|
+
},
|
|
755
|
+
{
|
|
756
|
+
id: "mcporter",
|
|
757
|
+
label: "mcporter",
|
|
758
|
+
vendor: "mcp",
|
|
759
|
+
rawNames: ["mcporter"]
|
|
760
|
+
},
|
|
761
|
+
{
|
|
762
|
+
id: "rmcp",
|
|
763
|
+
label: "rmcp",
|
|
764
|
+
vendor: "mcp",
|
|
765
|
+
rawNames: ["rmcp"]
|
|
766
|
+
},
|
|
767
|
+
{
|
|
768
|
+
id: "unnamed_client",
|
|
769
|
+
label: "Unnamed client",
|
|
770
|
+
vendor: "mcp",
|
|
771
|
+
rawNames: [
|
|
772
|
+
"mcp",
|
|
773
|
+
"unknown",
|
|
774
|
+
""
|
|
775
|
+
]
|
|
776
|
+
}
|
|
777
|
+
];
|
|
778
|
+
/** A source pattern, not a RegExp, because analytics renders the same rule into ClickHouse RE2, which shares this syntax. */
|
|
779
|
+
const MCP_REMOTE_WRAPPER_SUFFIX = String.raw` \(via mcp-remote [^\n]+?\)$`;
|
|
780
|
+
new RegExp(MCP_REMOTE_WRAPPER_SUFFIX);
|
|
781
|
+
new Map(MCP_CLIENT_GROUPS.map((group) => [group.id, group]));
|
|
491
782
|
const runtimeSchema = z.enum([
|
|
492
783
|
"python3.13",
|
|
493
784
|
"python3.14",
|
|
@@ -565,15 +856,7 @@ z.object({
|
|
|
565
856
|
serverFields: serverFieldsSchema$1,
|
|
566
857
|
source: z.enum(["registry", "defaults"])
|
|
567
858
|
});
|
|
568
|
-
/**
|
|
569
|
-
* Returns a variant of a `maxLength`-constrained string that clamps (truncates) instead of
|
|
570
|
-
* rejecting on overflow — used for AI-generated copy where the model routinely overshoots.
|
|
571
|
-
*
|
|
572
|
-
* NOTE: this rebuilds the schema from scratch, carrying over only `maxLength` (as a clamp),
|
|
573
|
-
* `minLength`, and the description. Any other validators on the source field (`.regex()`,
|
|
574
|
-
* `.email()`, custom refinements) are intentionally dropped — this helper is meant for plain
|
|
575
|
-
* free-text length caps only. A field with `null` `maxLength` is returned unchanged.
|
|
576
|
-
*/
|
|
859
|
+
/** 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. */
|
|
577
860
|
const clampStringField = (field) => {
|
|
578
861
|
const max = field.maxLength;
|
|
579
862
|
if (max === null) return field;
|
|
@@ -581,6 +864,10 @@ const clampStringField = (field) => {
|
|
|
581
864
|
const withMin = field.minLength === null ? clamped : clamped.min(field.minLength);
|
|
582
865
|
return field.description ? withMin.describe(field.description) : withMin;
|
|
583
866
|
};
|
|
867
|
+
const unboundedArrayField = (field) => {
|
|
868
|
+
const unbounded = z.array(field.element);
|
|
869
|
+
return field.description ? unbounded.describe(field.description) : unbounded;
|
|
870
|
+
};
|
|
584
871
|
const toolDefinitionSchema = z.object({
|
|
585
872
|
name: z.string(),
|
|
586
873
|
title: z.string().optional().describe("Human-friendly name for the tool, used in the UI. If not provided, `name` will be used."),
|
|
@@ -593,15 +880,24 @@ const toolDefinitionSchema = z.object({
|
|
|
593
880
|
}).optional()
|
|
594
881
|
});
|
|
595
882
|
const positiveTestCaseSchema = z.object({
|
|
596
|
-
scenario: z.string().describe("Short label for what this case demonstrates."),
|
|
597
|
-
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."),
|
|
883
|
+
scenario: z.string().min(1).describe("Short label for what this case demonstrates."),
|
|
884
|
+
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."),
|
|
598
885
|
toolTriggered: z.string().optional().describe("The tool this prompt should invoke."),
|
|
599
886
|
expectedOutput: z.string().optional().describe("What the user should see, including post-interaction behaviour where relevant.")
|
|
600
|
-
}).
|
|
887
|
+
}).describe("Each case: Scenario, User prompt, Tool triggered, Expected output.");
|
|
888
|
+
const positiveTestCaseDraftSchema = positiveTestCaseSchema.partial();
|
|
889
|
+
const blankPositiveTestCase = () => ({
|
|
890
|
+
scenario: "",
|
|
891
|
+
userPrompt: "",
|
|
892
|
+
toolTriggered: "",
|
|
893
|
+
expectedOutput: ""
|
|
894
|
+
});
|
|
895
|
+
const toFixedLength = (entries, length, blank) => Array.from({ length }, (_, index) => entries[index] ?? blank());
|
|
601
896
|
const screenshotEntrySchema = z.object({
|
|
602
897
|
prompt: z.string(),
|
|
603
|
-
url: z.url()
|
|
898
|
+
url: z.url()
|
|
604
899
|
}).describe("Each screenshot: the user prompt that produced it + the image URL.");
|
|
900
|
+
const screenshotDraftEntrySchema = screenshotEntrySchema.extend({ url: z.string() });
|
|
605
901
|
/** Accepts either a valid email or URL. */
|
|
606
902
|
const supportChannelSchema = z.string().refine((value) => z.email().safeParse(value).success || z.url().safeParse(value).success, { error: "Must be a valid email or URL" });
|
|
607
903
|
/** A URL field whose error spells out that the scheme is required. */
|
|
@@ -909,20 +1205,21 @@ const chatgptTranslationLocaleSchema = z.enum([
|
|
|
909
1205
|
"zh-TW"
|
|
910
1206
|
]);
|
|
911
1207
|
const negativeTestCaseSchema = z.object({
|
|
912
|
-
scenario: z.string(),
|
|
913
|
-
userPrompt: z.string()
|
|
914
|
-
}).
|
|
1208
|
+
scenario: z.string().min(1),
|
|
1209
|
+
userPrompt: z.string().min(1)
|
|
1210
|
+
}).describe("Each case: Scenario + User prompt (the app should NOT trigger).");
|
|
1211
|
+
const negativeTestCaseDraftSchema = negativeTestCaseSchema.partial();
|
|
1212
|
+
const blankNegativeTestCase = () => ({
|
|
1213
|
+
scenario: "",
|
|
1214
|
+
userPrompt: ""
|
|
1215
|
+
});
|
|
915
1216
|
const chatgptToolJustificationSchema = z.object({
|
|
916
1217
|
toolName: z.string(),
|
|
917
1218
|
readOnlyJustification: z.string().describe("One sentence on what the tool reads and returns."),
|
|
918
1219
|
openWorldJustification: z.string().describe("One sentence on whether the tool reaches external systems beyond your own service."),
|
|
919
1220
|
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.\"")
|
|
920
1221
|
}).describe("Per-tool justification of each MCP annotation value (one specific sentence per hint).");
|
|
921
|
-
/**
|
|
922
|
-
* Base copy fields, defined once and reused by both the submission form and per-locale
|
|
923
|
-
* translations so the constraints (tagline ≤ 30 chars) never drift. The translation generation
|
|
924
|
-
* path wraps these in {@link clampStringField} since the LLM tends to overshoot the limit.
|
|
925
|
-
*/
|
|
1222
|
+
/** Defined once and reused by both the submission form and per-locale translations so the tagline ≤ 30 chars constraint never drifts. */
|
|
926
1223
|
const chatgptTaglineSchema = z.string().max(30);
|
|
927
1224
|
const chatgptDescriptionSchema = z.string();
|
|
928
1225
|
const chatgptTranslationSchema = z.object({
|
|
@@ -931,10 +1228,7 @@ const chatgptTranslationSchema = z.object({
|
|
|
931
1228
|
description: chatgptDescriptionSchema
|
|
932
1229
|
}).describe("Locale-scoped override for tagline + description. English (US) is the default.");
|
|
933
1230
|
chatgptTranslationSchema.extend({ tagline: clampStringField(chatgptTaglineSchema) });
|
|
934
|
-
/**
|
|
935
|
-
* Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section.
|
|
936
|
-
* When adding/removing/reordering fields, keep this in sync with the sheet.
|
|
937
|
-
*/
|
|
1231
|
+
/** Field order mirrors the ChatGPT (OpenAI) submission spreadsheet, grouped by section; keep it in sync with the sheet. */
|
|
938
1232
|
const chatgptSubmissionFormDataSchema = z.object({
|
|
939
1233
|
logoLight: z.string().describe("Logo icon for light mode. Square PNG, no borders or rounded corners (clients apply circular cropping)."),
|
|
940
1234
|
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."),
|
|
@@ -953,28 +1247,50 @@ const chatgptSubmissionFormDataSchema = z.object({
|
|
|
953
1247
|
authentication: chatgptAuthenticationSchema.describe("OAuth 2.0 or No auth. OAuth configuration is auto-discovered from the MCP server's metadata."),
|
|
954
1248
|
tools: z.array(toolDefinitionSchema).describe("List of tools exposed by the MCP server (auto-populated from the production server's manifest)."),
|
|
955
1249
|
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."),
|
|
956
|
-
testCases: z.array(positiveTestCaseSchema).describe("
|
|
957
|
-
negativeTestCases: z.array(negativeTestCaseSchema).describe("3 negative test cases: prompts where the app should NOT trigger but the model might think it is relevant. These become production routing metadata that teaches ChatGPT when to stay silent, so pick tight near-misses: a product category the app does not carry, the right brand or domain but an intent the app does not serve, or a boundary with a sibling app."),
|
|
1250
|
+
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."),
|
|
1251
|
+
negativeTestCases: z.array(negativeTestCaseSchema).length(3).describe("Exactly 3 negative test cases: prompts where the app should NOT trigger but the model might think it is relevant. These become production routing metadata that teaches ChatGPT when to stay silent, so pick tight near-misses: a product category the app does not carry, the right brand or domain but an intent the app does not serve, or a boundary with a sibling app."),
|
|
958
1252
|
screenshots: z.array(screenshotEntrySchema.extend({ prompt: z.string().max(75, { error: "Screenshot prompts are limited to 75 characters." }) })).max(3).describe("In-app screenshots paired with the user prompt that produced them (each prompt is 75 characters max). Widget apps must show the widget UI; non-widget apps show the model response. Min 1, max 3 entries, all public. Images: 706px wide, 400–860px tall, PNG."),
|
|
959
1253
|
translations: z.array(chatgptTranslationSchema).describe("Per-locale translation of tagline + description. English (US) is the default."),
|
|
960
1254
|
allowedCountries: chatgptAllowedCountriesSchema.describe("Availability: all supported countries, or an allow-list / block-list of specific ones (ISO alpha-2)."),
|
|
961
1255
|
releaseNotes: z.string().describe("Publicly displayed on the app details page.")
|
|
962
1256
|
});
|
|
963
|
-
chatgptSubmissionFormDataSchema.
|
|
1257
|
+
const chatgptSubmissionDraftSchema = chatgptSubmissionFormDataSchema.partial().extend({
|
|
1258
|
+
tagline: z.string().optional(),
|
|
1259
|
+
companyUrl: z.string().optional(),
|
|
1260
|
+
supportChannel: z.string().optional(),
|
|
1261
|
+
privacyPolicyUrl: z.string().optional(),
|
|
1262
|
+
termsOfServiceUrl: z.string().optional(),
|
|
1263
|
+
demoRecordingUrl: z.string().optional(),
|
|
1264
|
+
serverUrl: z.string().optional(),
|
|
1265
|
+
screenshots: z.array(screenshotDraftEntrySchema).optional(),
|
|
1266
|
+
testCases: z.array(positiveTestCaseDraftSchema).optional(),
|
|
1267
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).optional(),
|
|
1268
|
+
translations: z.array(chatgptTranslationSchema.extend({ tagline: z.string() })).optional()
|
|
1269
|
+
});
|
|
1270
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "chatgpt" })` can populate. */
|
|
1271
|
+
const chatgptPrefillFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
964
1272
|
appName: true,
|
|
965
1273
|
developerName: true,
|
|
966
1274
|
serverUrl: true,
|
|
967
1275
|
tools: true,
|
|
968
1276
|
authentication: true
|
|
969
1277
|
});
|
|
970
|
-
|
|
1278
|
+
/** Source of truth for `SubmissionPrefillService.generate({ platform: "chatgpt" })`. */
|
|
1279
|
+
const chatgptAiGeneratedFormDataSchema = chatgptSubmissionFormDataSchema.pick({
|
|
971
1280
|
tagline: true,
|
|
972
1281
|
description: true,
|
|
973
1282
|
category: true,
|
|
974
1283
|
testCases: true,
|
|
975
1284
|
negativeTestCases: true,
|
|
976
1285
|
toolJustifications: true
|
|
977
|
-
}).extend({
|
|
1286
|
+
}).extend({
|
|
1287
|
+
testCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.testCases),
|
|
1288
|
+
negativeTestCases: unboundedArrayField(chatgptSubmissionFormDataSchema.shape.negativeTestCases)
|
|
1289
|
+
}).extend({
|
|
1290
|
+
tagline: clampStringField(chatgptSubmissionFormDataSchema.shape.tagline),
|
|
1291
|
+
testCases: z.array(positiveTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 5, blankPositiveTestCase)),
|
|
1292
|
+
negativeTestCases: z.array(negativeTestCaseDraftSchema).transform((cases) => toFixedLength(cases, 3, blankNegativeTestCase))
|
|
1293
|
+
});
|
|
978
1294
|
const claudeCategorySchema = z.enum([
|
|
979
1295
|
"Productivity",
|
|
980
1296
|
"Communication",
|
|
@@ -1020,11 +1336,7 @@ const claudePolicyAcknowledgementSchema = z.enum([
|
|
|
1020
1336
|
"My connector does not collect conversation data beyond what is needed for its function.",
|
|
1021
1337
|
"Public documentation for this connector will be live by the publish date."
|
|
1022
1338
|
]);
|
|
1023
|
-
/**
|
|
1024
|
-
* Field order mirrors the claude.ai directory submission wizard
|
|
1025
|
-
* (`claude.ai/admin-settings/directory/submissions/new`), grouped by step.
|
|
1026
|
-
* When adding/removing/reordering fields, keep this in sync with the wizard.
|
|
1027
|
-
*/
|
|
1339
|
+
/** 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. */
|
|
1028
1340
|
const claudeSubmissionFormDataSchema = z.object({
|
|
1029
1341
|
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
|
|
1030
1342
|
from the custom connector you select — the connection is used to verify the URL and the tool list at submission time.
|
|
@@ -1086,7 +1398,23 @@ fully populated account.`),
|
|
|
1086
1398
|
submission. Each is an attestation you are legally agreeing to by submitting.`),
|
|
1087
1399
|
additionalNotes: z.string().optional().describe("Anything else the review team should know about your connector. Optional.")
|
|
1088
1400
|
});
|
|
1089
|
-
claudeSubmissionFormDataSchema.
|
|
1401
|
+
const claudeSubmissionDraftSchema = claudeSubmissionFormDataSchema.partial().extend({
|
|
1402
|
+
serverUrl: z.string().optional(),
|
|
1403
|
+
name: z.string().optional(),
|
|
1404
|
+
slug: z.string().optional(),
|
|
1405
|
+
oneLiner: z.string().optional(),
|
|
1406
|
+
description: z.string().optional(),
|
|
1407
|
+
iconUrl: z.string().optional(),
|
|
1408
|
+
documentation: z.string().optional(),
|
|
1409
|
+
support: z.string().optional(),
|
|
1410
|
+
privacyPolicy: z.string().optional(),
|
|
1411
|
+
companyWebsite: z.string().optional(),
|
|
1412
|
+
primaryContactEmail: z.string().optional(),
|
|
1413
|
+
categories: z.array(claudeCategorySchema).optional(),
|
|
1414
|
+
screenshots: z.array(screenshotDraftEntrySchema).optional()
|
|
1415
|
+
});
|
|
1416
|
+
/** Source of truth for the fields `SubmissionPrefillService.prefill({ platform: "claudeai" })` can populate. */
|
|
1417
|
+
const claudePrefillFormDataSchema = claudeSubmissionFormDataSchema.pick({
|
|
1090
1418
|
serverUrl: true,
|
|
1091
1419
|
name: true,
|
|
1092
1420
|
slug: true,
|
|
@@ -1101,22 +1429,24 @@ claudeSubmissionFormDataSchema.pick({
|
|
|
1101
1429
|
connectionRequirements: claudeSubmissionFormDataSchema.shape.connectionRequirements.optional(),
|
|
1102
1430
|
testInstructions: claudeSubmissionFormDataSchema.shape.testInstructions.optional()
|
|
1103
1431
|
});
|
|
1104
|
-
/**
|
|
1105
|
-
* Narrative fields the LLM-backed generation step produces for Claude submissions.
|
|
1106
|
-
* This schema accepts the slightly loose shape returned by AI generation, then normalizes it into
|
|
1107
|
-
* the strict form shape. Keep transforms here rather than in callers so generation leniency is
|
|
1108
|
-
* colocated with the Claude contract.
|
|
1109
|
-
*/
|
|
1432
|
+
/** Loose shape returned by AI generation for Claude narrative fields; transforms live here so generation leniency stays colocated with the Claude contract. */
|
|
1110
1433
|
const claudeAiGeneratedFormDataRawSchema = z.object({
|
|
1111
1434
|
oneLiner: claudeSubmissionFormDataSchema.shape.oneLiner,
|
|
1112
1435
|
description: claudeSubmissionFormDataSchema.shape.description,
|
|
1113
1436
|
categories: z.array(claudeCategorySchema).describe(claudeCategoryDescription),
|
|
1114
1437
|
primaryUseCases: claudeSubmissionFormDataSchema.shape.primaryUseCases
|
|
1115
1438
|
});
|
|
1116
|
-
claudeAiGeneratedFormDataRawSchema.extend({
|
|
1439
|
+
const claudeAiGeneratedFormDataSchema = claudeAiGeneratedFormDataRawSchema.extend({
|
|
1117
1440
|
oneLiner: clampStringField(claudeSubmissionFormDataSchema.shape.oneLiner),
|
|
1118
1441
|
categories: claudeAiGeneratedFormDataRawSchema.shape.categories.transform((categories) => categories.slice(0, 5))
|
|
1119
1442
|
});
|
|
1443
|
+
function provenanceByField(prefillShape, aiGeneratedShape) {
|
|
1444
|
+
const byField = {};
|
|
1445
|
+
for (const field of Object.keys(prefillShape)) byField[field] = "prefilled";
|
|
1446
|
+
for (const field of Object.keys(aiGeneratedShape)) byField[field] = "ai-generated";
|
|
1447
|
+
return byField;
|
|
1448
|
+
}
|
|
1449
|
+
provenanceByField(claudePrefillFormDataSchema.shape, claudeAiGeneratedFormDataSchema.shape), provenanceByField(chatgptPrefillFormDataSchema.shape, chatgptAiGeneratedFormDataSchema.shape);
|
|
1120
1450
|
const submissionMetaFieldsSchema = z.object({
|
|
1121
1451
|
id: z.string(),
|
|
1122
1452
|
environmentId: z.string(),
|
|
@@ -1126,14 +1456,21 @@ const submissionMetaFieldsSchema = z.object({
|
|
|
1126
1456
|
});
|
|
1127
1457
|
const claudeSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1128
1458
|
platform: z.literal("claudeai"),
|
|
1129
|
-
formData:
|
|
1459
|
+
formData: claudeSubmissionDraftSchema,
|
|
1460
|
+
prefillSnapshot: claudeSubmissionDraftSchema.nullable().default(null)
|
|
1130
1461
|
});
|
|
1131
1462
|
const chatgptSubmissionSchemaInternal = submissionMetaFieldsSchema.extend({
|
|
1132
1463
|
platform: z.literal("chatgpt"),
|
|
1133
|
-
formData:
|
|
1464
|
+
formData: chatgptSubmissionDraftSchema,
|
|
1465
|
+
prefillSnapshot: chatgptSubmissionDraftSchema.nullable().default(null)
|
|
1134
1466
|
});
|
|
1135
1467
|
z.discriminatedUnion("platform", [claudeSubmissionSchemaInternal, chatgptSubmissionSchemaInternal]);
|
|
1136
|
-
z.union([
|
|
1468
|
+
z.union([claudeSubmissionDraftSchema, chatgptSubmissionDraftSchema]);
|
|
1469
|
+
z.literal([
|
|
1470
|
+
100,
|
|
1471
|
+
75,
|
|
1472
|
+
50
|
|
1473
|
+
]);
|
|
1137
1474
|
const subscriptionPlanSchema = z.enum([
|
|
1138
1475
|
"pro",
|
|
1139
1476
|
"business",
|
|
@@ -1145,17 +1482,70 @@ const customerCreditsSchema = z.object({
|
|
|
1145
1482
|
expiresAt: z.number().nullable(),
|
|
1146
1483
|
currency: z.string()
|
|
1147
1484
|
});
|
|
1148
|
-
const customerUsageSchema = z.object({
|
|
1149
|
-
amountInCents: z.number(),
|
|
1150
|
-
currency: z.string(),
|
|
1151
|
-
periodEnd: z.number()
|
|
1152
|
-
});
|
|
1153
1485
|
const partnerDiscountSchema = z.object({ endsAt: z.number() });
|
|
1154
1486
|
z.object({
|
|
1155
1487
|
customerCredits: customerCreditsSchema.nullable(),
|
|
1156
|
-
customerUsage: customerUsageSchema.nullable(),
|
|
1157
1488
|
partnerDiscount: partnerDiscountSchema.nullable()
|
|
1158
1489
|
});
|
|
1490
|
+
const metricsQueueEventSchema = z.object({
|
|
1491
|
+
ts: z.number().int(),
|
|
1492
|
+
method: z.string(),
|
|
1493
|
+
tool: z.string().nullable(),
|
|
1494
|
+
client: z.string(),
|
|
1495
|
+
sessionId: z.string().nullable(),
|
|
1496
|
+
durationMs: z.number().int(),
|
|
1497
|
+
outputTokens: z.number().int().nullable(),
|
|
1498
|
+
errorType: z.enum([
|
|
1499
|
+
"mcp_error",
|
|
1500
|
+
"tool_error",
|
|
1501
|
+
"timeout"
|
|
1502
|
+
]).nullable(),
|
|
1503
|
+
errorCode: z.number().int().nullable()
|
|
1504
|
+
});
|
|
1505
|
+
z.object({
|
|
1506
|
+
v: z.literal(1),
|
|
1507
|
+
envId: z.string(),
|
|
1508
|
+
events: z.array(metricsQueueEventSchema)
|
|
1509
|
+
});
|
|
1510
|
+
z.object({ v: z.number() });
|
|
1511
|
+
const telemetrySignalSchema = z.enum([
|
|
1512
|
+
"logs",
|
|
1513
|
+
"metrics",
|
|
1514
|
+
"traces"
|
|
1515
|
+
]);
|
|
1516
|
+
const otlpProtocolSchema = z.enum(["http/protobuf", "http/json"]);
|
|
1517
|
+
const otlpEndpointSchema = z.string().trim().min(1).max(2048);
|
|
1518
|
+
const OTLP_HEADER_VALUE_MAX_LENGTH = 2048;
|
|
1519
|
+
const otlpHeaderNameSchema = z.string().trim().min(1, "Enter a header name").max(128).regex(/^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/, "Use letters, digits and !#$%&'*+-.^_`|~ only");
|
|
1520
|
+
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");
|
|
1521
|
+
const telemetryDestinationHeaderSchema = z.object({
|
|
1522
|
+
id: z.string(),
|
|
1523
|
+
name: otlpHeaderNameSchema,
|
|
1524
|
+
value: otlpHeaderValueSchema,
|
|
1525
|
+
isSecret: z.boolean()
|
|
1526
|
+
});
|
|
1527
|
+
const otlpPushFailureReasonSchema = z.enum([
|
|
1528
|
+
"credentials",
|
|
1529
|
+
"wrong-path",
|
|
1530
|
+
"wrong-protocol",
|
|
1531
|
+
"invalid-payload",
|
|
1532
|
+
"partial-rejection",
|
|
1533
|
+
"blocked-target",
|
|
1534
|
+
"timeout",
|
|
1535
|
+
"unreachable",
|
|
1536
|
+
"receiver-error",
|
|
1537
|
+
"unexpected-status"
|
|
1538
|
+
]);
|
|
1539
|
+
const telemetryDestinationStatusSchema = z.enum(["active", "suspended"]);
|
|
1540
|
+
z.object({
|
|
1541
|
+
id: z.string(),
|
|
1542
|
+
signal: telemetrySignalSchema,
|
|
1543
|
+
endpoint: otlpEndpointSchema,
|
|
1544
|
+
protocol: otlpProtocolSchema,
|
|
1545
|
+
headers: z.array(telemetryDestinationHeaderSchema),
|
|
1546
|
+
status: telemetryDestinationStatusSchema,
|
|
1547
|
+
lastFailureReason: otlpPushFailureReasonSchema.nullable()
|
|
1548
|
+
});
|
|
1159
1549
|
//#endregion
|
|
1160
1550
|
//#region src/auth-scope.ts
|
|
1161
1551
|
/** Accepts an API key or OAuth access token (default for most routes). */
|
|
@@ -1198,7 +1588,10 @@ const RESERVED_KEYS = [
|
|
|
1198
1588
|
"BUILD_ARG_START_COMMAND",
|
|
1199
1589
|
"ALPIC_HOST",
|
|
1200
1590
|
"ALPIC_CUSTOM_DOMAINS",
|
|
1201
|
-
"ALPIC_INTENT_META_KEY"
|
|
1591
|
+
"ALPIC_INTENT_META_KEY",
|
|
1592
|
+
"ALPIC_FEEDBACK_META_KEY",
|
|
1593
|
+
"ALPIC_EVENTS_META_KEY",
|
|
1594
|
+
"ALPIC_IDENTIFY_META_KEY"
|
|
1202
1595
|
];
|
|
1203
1596
|
const environmentVariableSchema = z.object({
|
|
1204
1597
|
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"),
|
|
@@ -1251,6 +1644,14 @@ const serverFieldsSchema = z.object({
|
|
|
1251
1644
|
});
|
|
1252
1645
|
//#endregion
|
|
1253
1646
|
//#region src/api.contract.ts
|
|
1647
|
+
const isValidIanaTimeZone = (timeZone) => {
|
|
1648
|
+
try {
|
|
1649
|
+
new Intl.DateTimeFormat("en-US", { timeZone });
|
|
1650
|
+
return true;
|
|
1651
|
+
} catch {
|
|
1652
|
+
return false;
|
|
1653
|
+
}
|
|
1654
|
+
};
|
|
1254
1655
|
const deploymentStatusSchema = z.enum([
|
|
1255
1656
|
"ongoing",
|
|
1256
1657
|
"deployed",
|
|
@@ -1279,21 +1680,20 @@ const deploymentSchema = z.object({
|
|
|
1279
1680
|
isCurrent: z.boolean(),
|
|
1280
1681
|
deploymentPageUrl: z.url().nullable()
|
|
1281
1682
|
});
|
|
1282
|
-
const
|
|
1683
|
+
const isValidTimeInput = (value) => {
|
|
1283
1684
|
if (ms(value) !== void 0) return true;
|
|
1284
1685
|
return !Number.isNaN(new Date(value).getTime());
|
|
1285
1686
|
};
|
|
1286
|
-
const
|
|
1687
|
+
const timeInputSchema = z.string().refine(isValidTimeInput, { message: "Invalid time. Use relative (1h, 30m, 2d) or ISO 8601 format." });
|
|
1688
|
+
const base = oc.errors({ BAD_REQUEST: {} });
|
|
1689
|
+
const createEnvironmentContractV1 = base.route({
|
|
1287
1690
|
path: "/v1/environments",
|
|
1288
1691
|
method: "POST",
|
|
1289
1692
|
summary: "Create an environment",
|
|
1290
1693
|
description: "Create an environment for a project",
|
|
1291
1694
|
tags: ["environments"],
|
|
1292
1695
|
successDescription: "The environment has been created successfully"
|
|
1293
|
-
}).errors({
|
|
1294
|
-
NOT_FOUND: {},
|
|
1295
|
-
BAD_REQUEST: {}
|
|
1296
|
-
}).input(z.object({
|
|
1696
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1297
1697
|
projectId: z.string().describe("The ID of the project to create the environment for"),
|
|
1298
1698
|
name: z.string().min(1).describe("The name of the environment"),
|
|
1299
1699
|
sourceBranch: z.string().min(1).describe("The branch used to build the environment"),
|
|
@@ -1306,7 +1706,7 @@ const createEnvironmentContractV1 = oc.route({
|
|
|
1306
1706
|
createdAt: z.coerce.date(),
|
|
1307
1707
|
projectId: z.string().describe("The ID of the project the environment belongs to")
|
|
1308
1708
|
}));
|
|
1309
|
-
const getEnvironmentContractV1 =
|
|
1709
|
+
const getEnvironmentContractV1 = base.route({
|
|
1310
1710
|
path: "/v1/environments/{environmentId}",
|
|
1311
1711
|
method: "GET",
|
|
1312
1712
|
summary: "Get an environment",
|
|
@@ -1322,6 +1722,14 @@ const getEnvironmentContractV1 = oc.route({
|
|
|
1322
1722
|
createdAt: z.coerce.date(),
|
|
1323
1723
|
projectId: z.string()
|
|
1324
1724
|
}));
|
|
1725
|
+
const deleteEnvironmentContractV1 = base.route({
|
|
1726
|
+
path: "/v1/environments/{environmentId}",
|
|
1727
|
+
method: "DELETE",
|
|
1728
|
+
summary: "Delete an environment",
|
|
1729
|
+
description: "All environments can be deleted except the production environment. This operation is not reversible: associated logs, analytics, and metrics are deleted as well.",
|
|
1730
|
+
tags: ["environments"],
|
|
1731
|
+
successDescription: "The environment has been deleted successfully"
|
|
1732
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.object({ success: z.literal(true) }));
|
|
1325
1733
|
const domainSchema = z.object({
|
|
1326
1734
|
domain: z.string(),
|
|
1327
1735
|
status: z.enum([
|
|
@@ -1363,7 +1771,7 @@ const projectOutputSchema = z.object({
|
|
|
1363
1771
|
productionEnvironment: productionEnvironmentSchema.nullable(),
|
|
1364
1772
|
environments: z.array(environmentSchema)
|
|
1365
1773
|
});
|
|
1366
|
-
const getProjectContractV1 =
|
|
1774
|
+
const getProjectContractV1 = base.route({
|
|
1367
1775
|
path: "/v1/projects/{projectId}",
|
|
1368
1776
|
method: "GET",
|
|
1369
1777
|
summary: "Get a project",
|
|
@@ -1371,18 +1779,15 @@ const getProjectContractV1 = oc.route({
|
|
|
1371
1779
|
tags: ["projects"],
|
|
1372
1780
|
successDescription: "The project details"
|
|
1373
1781
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(projectOutputSchema);
|
|
1374
|
-
const listProjectsContractV1 =
|
|
1782
|
+
const listProjectsContractV1 = base.route({
|
|
1375
1783
|
path: "/v1/projects",
|
|
1376
1784
|
method: "GET",
|
|
1377
1785
|
summary: "List projects",
|
|
1378
1786
|
description: "List all projects for a team",
|
|
1379
1787
|
tags: ["projects"],
|
|
1380
1788
|
successDescription: "The list of projects"
|
|
1381
|
-
}).errors({
|
|
1382
|
-
|
|
1383
|
-
BAD_REQUEST: {}
|
|
1384
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1385
|
-
const createProjectContractV1 = oc.route({
|
|
1789
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.array(projectOutputSchema));
|
|
1790
|
+
const createProjectContractV1 = base.route({
|
|
1386
1791
|
path: "/v1/projects",
|
|
1387
1792
|
method: "POST",
|
|
1388
1793
|
summary: "Create a project",
|
|
@@ -1391,7 +1796,6 @@ const createProjectContractV1 = oc.route({
|
|
|
1391
1796
|
successDescription: "The project has been created successfully"
|
|
1392
1797
|
}).errors({
|
|
1393
1798
|
NOT_FOUND: {},
|
|
1394
|
-
BAD_REQUEST: {},
|
|
1395
1799
|
FORBIDDEN: {}
|
|
1396
1800
|
}).input(z.object({
|
|
1397
1801
|
teamId: z.string().optional(),
|
|
@@ -1432,7 +1836,7 @@ const environmentVariableOutputSchema = z.object({
|
|
|
1432
1836
|
isSecret: z.boolean(),
|
|
1433
1837
|
createdAt: z.coerce.date()
|
|
1434
1838
|
});
|
|
1435
|
-
const listEnvironmentVariablesContractV1 =
|
|
1839
|
+
const listEnvironmentVariablesContractV1 = base.route({
|
|
1436
1840
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1437
1841
|
method: "GET",
|
|
1438
1842
|
summary: "List environment variables",
|
|
@@ -1440,48 +1844,39 @@ const listEnvironmentVariablesContractV1 = oc.route({
|
|
|
1440
1844
|
tags: ["environments"],
|
|
1441
1845
|
successDescription: "The list of environment variables"
|
|
1442
1846
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(environmentVariableOutputSchema));
|
|
1443
|
-
const createEnvironmentVariablesContractV1 =
|
|
1847
|
+
const createEnvironmentVariablesContractV1 = base.route({
|
|
1444
1848
|
path: "/v1/environments/{environmentId}/environment-variables",
|
|
1445
1849
|
method: "POST",
|
|
1446
1850
|
summary: "Add environment variables",
|
|
1447
1851
|
description: "Add one or more environment variables to an environment",
|
|
1448
1852
|
tags: ["environments"],
|
|
1449
1853
|
successDescription: "The environment variables have been added successfully"
|
|
1450
|
-
}).errors({
|
|
1451
|
-
NOT_FOUND: {},
|
|
1452
|
-
BAD_REQUEST: {}
|
|
1453
|
-
}).input(z.object({
|
|
1854
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1454
1855
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1455
1856
|
environmentVariables: environmentVariablesSchema
|
|
1456
1857
|
})).output(z.object({ success: z.literal(true) }));
|
|
1457
|
-
const updateEnvironmentVariableContractV1 =
|
|
1858
|
+
const updateEnvironmentVariableContractV1 = base.route({
|
|
1458
1859
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1459
1860
|
method: "PATCH",
|
|
1460
1861
|
summary: "Update an environment variable",
|
|
1461
1862
|
description: "Update an environment variable by ID",
|
|
1462
1863
|
tags: ["environments"],
|
|
1463
1864
|
successDescription: "The environment variable has been updated successfully"
|
|
1464
|
-
}).errors({
|
|
1465
|
-
NOT_FOUND: {},
|
|
1466
|
-
BAD_REQUEST: {}
|
|
1467
|
-
}).input(z.object({
|
|
1865
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1468
1866
|
environmentVariableId: z.string().describe("The ID of the environment variable"),
|
|
1469
1867
|
key: environmentVariableSchema.shape.key,
|
|
1470
1868
|
value: environmentVariableSchema.shape.value.optional(),
|
|
1471
1869
|
isSecret: environmentVariableSchema.shape.isSecret.optional()
|
|
1472
1870
|
})).output(z.object({ success: z.literal(true) }));
|
|
1473
|
-
const deleteEnvironmentVariableContractV1 =
|
|
1871
|
+
const deleteEnvironmentVariableContractV1 = base.route({
|
|
1474
1872
|
path: "/v1/environment-variables/{environmentVariableId}",
|
|
1475
1873
|
method: "DELETE",
|
|
1476
1874
|
summary: "Delete an environment variable",
|
|
1477
1875
|
description: "Delete an environment variable by ID",
|
|
1478
1876
|
tags: ["environments"],
|
|
1479
1877
|
successDescription: "The environment variable has been deleted successfully"
|
|
1480
|
-
}).errors({
|
|
1481
|
-
|
|
1482
|
-
BAD_REQUEST: {}
|
|
1483
|
-
}).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
1484
|
-
const deleteProjectContractV1 = oc.route({
|
|
1878
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentVariableId: z.string().describe("The ID of the environment variable") })).output(z.object({ success: z.literal(true) }));
|
|
1879
|
+
const deleteProjectContractV1 = base.route({
|
|
1485
1880
|
path: "/v1/projects/{projectId}",
|
|
1486
1881
|
method: "DELETE",
|
|
1487
1882
|
summary: "Delete a project",
|
|
@@ -1489,7 +1884,7 @@ const deleteProjectContractV1 = oc.route({
|
|
|
1489
1884
|
tags: ["projects"],
|
|
1490
1885
|
successDescription: "The project has been deleted successfully"
|
|
1491
1886
|
}).errors({ NOT_FOUND: {} }).input(z.object({ projectId: z.string().describe("The ID of the project") })).output(z.object({ success: z.literal(true) }));
|
|
1492
|
-
const updateProjectContractV1 =
|
|
1887
|
+
const updateProjectContractV1 = base.route({
|
|
1493
1888
|
path: "/v1/projects/{projectId}",
|
|
1494
1889
|
method: "PATCH",
|
|
1495
1890
|
summary: "Update a project",
|
|
@@ -1498,14 +1893,13 @@ const updateProjectContractV1 = oc.route({
|
|
|
1498
1893
|
successDescription: "The project has been updated successfully"
|
|
1499
1894
|
}).errors({
|
|
1500
1895
|
NOT_FOUND: {},
|
|
1501
|
-
BAD_REQUEST: {},
|
|
1502
1896
|
FORBIDDEN: {}
|
|
1503
1897
|
}).input(z.object({
|
|
1504
1898
|
projectId: z.string().describe("The ID of the project"),
|
|
1505
1899
|
name: z.string().min(1).max(100).optional().describe("The new name for the project"),
|
|
1506
1900
|
sourceRepository: z.string().nullable().optional().describe("The source repository to connect to the project")
|
|
1507
1901
|
})).output(projectOutputSchema);
|
|
1508
|
-
const deployEnvironmentContractV1 =
|
|
1902
|
+
const deployEnvironmentContractV1 = base.route({
|
|
1509
1903
|
path: "/v1/environments/{environmentId}/deploy",
|
|
1510
1904
|
method: "POST",
|
|
1511
1905
|
summary: "Deploy an environment",
|
|
@@ -1514,27 +1908,25 @@ const deployEnvironmentContractV1 = oc.route({
|
|
|
1514
1908
|
successDescription: "The environment has been deployed successfully"
|
|
1515
1909
|
}).errors({
|
|
1516
1910
|
NOT_FOUND: {},
|
|
1517
|
-
|
|
1911
|
+
CONFLICT: {}
|
|
1518
1912
|
}).input(z.object({
|
|
1519
1913
|
environmentId: z.string().describe("The ID of the environment to deploy"),
|
|
1520
|
-
token: z.string().describe("The token to identify the source archive").optional()
|
|
1914
|
+
token: z.string().describe("The token to identify the source archive").optional(),
|
|
1915
|
+
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.")
|
|
1521
1916
|
})).output(deploymentSchema);
|
|
1522
|
-
const uploadDeploymentArtifactContractV1 =
|
|
1917
|
+
const uploadDeploymentArtifactContractV1 = base.route({
|
|
1523
1918
|
path: "/v1/deployments/upload",
|
|
1524
1919
|
method: "POST",
|
|
1525
1920
|
summary: "Upload deployment artifacts",
|
|
1526
1921
|
description: "Return a presigned S3 URL to upload a deployment artifact",
|
|
1527
1922
|
tags: ["deployments"],
|
|
1528
1923
|
successDescription: "The presigned upload URL has been generated successfully"
|
|
1529
|
-
}).errors({
|
|
1530
|
-
NOT_FOUND: {},
|
|
1531
|
-
BAD_REQUEST: {}
|
|
1532
|
-
}).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
1924
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().optional() }).optional()).output(z.object({
|
|
1533
1925
|
uploadUrl: z.url().describe("Presigned S3 URL to upload the source archive with HTTP PUT"),
|
|
1534
1926
|
token: z.string().describe("Token to identify the source archive"),
|
|
1535
1927
|
expiresAt: z.coerce.date().describe("Expiration date of the presigned URL")
|
|
1536
1928
|
}));
|
|
1537
|
-
const listDeploymentsContractV1 =
|
|
1929
|
+
const listDeploymentsContractV1 = base.route({
|
|
1538
1930
|
path: "/v1/projects/{projectId}/deployments",
|
|
1539
1931
|
method: "GET",
|
|
1540
1932
|
summary: "List project deployments",
|
|
@@ -1546,7 +1938,7 @@ const listDeploymentsContractV1 = oc.route({
|
|
|
1546
1938
|
status: z.array(deploymentStatusSchema).optional().describe("Filter by one or more statuses"),
|
|
1547
1939
|
environmentId: z.string().optional().describe("Filter by environment ID")
|
|
1548
1940
|
})).output(z.array(deploymentSchema));
|
|
1549
|
-
const getDeploymentContractV1 =
|
|
1941
|
+
const getDeploymentContractV1 = base.route({
|
|
1550
1942
|
path: "/v1/deployments/{deploymentId}",
|
|
1551
1943
|
method: "GET",
|
|
1552
1944
|
summary: "Get a deployment",
|
|
@@ -1554,20 +1946,32 @@ const getDeploymentContractV1 = oc.route({
|
|
|
1554
1946
|
tags: ["deployments"],
|
|
1555
1947
|
successDescription: "The deployment details"
|
|
1556
1948
|
}).errors({ NOT_FOUND: {} }).input(z.object({ deploymentId: z.string().describe("The ID of the deployment") })).output(deploymentSchema);
|
|
1557
|
-
const
|
|
1949
|
+
const logEntrySchema = z.object({
|
|
1950
|
+
timestamp: z.coerce.date(),
|
|
1951
|
+
type: z.enum([
|
|
1952
|
+
"START",
|
|
1953
|
+
"END",
|
|
1954
|
+
"INFO",
|
|
1955
|
+
"ERROR",
|
|
1956
|
+
"WARNING",
|
|
1957
|
+
"DEBUG"
|
|
1958
|
+
]),
|
|
1959
|
+
requestId: z.string(),
|
|
1960
|
+
content: z.string().optional(),
|
|
1961
|
+
method: z.string().optional(),
|
|
1962
|
+
durationInMs: z.number().optional()
|
|
1963
|
+
});
|
|
1964
|
+
const getLogsContractV1 = base.route({
|
|
1558
1965
|
path: "/v1/environments/{environmentId}/logs",
|
|
1559
1966
|
method: "GET",
|
|
1560
1967
|
summary: "Get logs",
|
|
1561
1968
|
description: "Get logs for an environment",
|
|
1562
1969
|
tags: ["environments"],
|
|
1563
1970
|
successDescription: "The logs"
|
|
1564
|
-
}).errors({
|
|
1565
|
-
NOT_FOUND: {},
|
|
1566
|
-
BAD_REQUEST: {}
|
|
1567
|
-
}).input(z.object({
|
|
1971
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1568
1972
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1569
|
-
since:
|
|
1570
|
-
until:
|
|
1973
|
+
since: timeInputSchema.optional().describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
1974
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
1571
1975
|
limit: z.coerce.number().int().min(1).max(1e3).default(1e3).describe("Maximum number of log entries to return."),
|
|
1572
1976
|
level: z.array(z.enum([
|
|
1573
1977
|
"INFO",
|
|
@@ -1578,34 +1982,17 @@ const getLogsContractV1 = oc.route({
|
|
|
1578
1982
|
search: z.string().optional().describe("Filter pattern to search for in log content"),
|
|
1579
1983
|
nextToken: z.string().optional().describe("Pagination token from a previous response")
|
|
1580
1984
|
})).output(z.object({
|
|
1581
|
-
logs: z.array(
|
|
1582
|
-
timestamp: z.coerce.date(),
|
|
1583
|
-
type: z.enum([
|
|
1584
|
-
"START",
|
|
1585
|
-
"END",
|
|
1586
|
-
"INFO",
|
|
1587
|
-
"ERROR",
|
|
1588
|
-
"WARNING",
|
|
1589
|
-
"DEBUG"
|
|
1590
|
-
]),
|
|
1591
|
-
requestId: z.string(),
|
|
1592
|
-
content: z.string().optional(),
|
|
1593
|
-
method: z.string().optional(),
|
|
1594
|
-
durationInMs: z.number().optional()
|
|
1595
|
-
})),
|
|
1985
|
+
logs: z.array(logEntrySchema),
|
|
1596
1986
|
nextToken: z.string().nullable()
|
|
1597
1987
|
}));
|
|
1598
|
-
const getLatestLogsContractV1 =
|
|
1988
|
+
const getLatestLogsContractV1 = base.route({
|
|
1599
1989
|
path: "/v1/environments/{environmentId}/latest-logs",
|
|
1600
1990
|
method: "GET",
|
|
1601
1991
|
summary: "Get latest logs",
|
|
1602
1992
|
description: "Get the N most recent logs for an environment",
|
|
1603
1993
|
tags: ["environments"],
|
|
1604
1994
|
successDescription: "The latest logs"
|
|
1605
|
-
}).errors({
|
|
1606
|
-
NOT_FOUND: {},
|
|
1607
|
-
BAD_REQUEST: {}
|
|
1608
|
-
}).input(z.object({
|
|
1995
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1609
1996
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1610
1997
|
limit: z.coerce.number().int().min(1).max(1e3).default(100).describe("Number of most recent log entries to return"),
|
|
1611
1998
|
level: z.array(z.enum([
|
|
@@ -1615,22 +2002,8 @@ const getLatestLogsContractV1 = oc.route({
|
|
|
1615
2002
|
"DEBUG"
|
|
1616
2003
|
])).optional().describe("Filter by log level"),
|
|
1617
2004
|
search: z.string().optional().describe("Filter pattern to search for in log content")
|
|
1618
|
-
})).output(z.object({ logs: z.array(
|
|
1619
|
-
|
|
1620
|
-
type: z.enum([
|
|
1621
|
-
"START",
|
|
1622
|
-
"END",
|
|
1623
|
-
"INFO",
|
|
1624
|
-
"ERROR",
|
|
1625
|
-
"WARNING",
|
|
1626
|
-
"DEBUG"
|
|
1627
|
-
]),
|
|
1628
|
-
requestId: z.string(),
|
|
1629
|
-
content: z.string().optional(),
|
|
1630
|
-
method: z.string().optional(),
|
|
1631
|
-
durationInMs: z.number().optional()
|
|
1632
|
-
})) }));
|
|
1633
|
-
const getDeploymentLogsContractV1 = oc.route({
|
|
2005
|
+
})).output(z.object({ logs: z.array(logEntrySchema) }));
|
|
2006
|
+
const getDeploymentLogsContractV1 = base.route({
|
|
1634
2007
|
path: "/v1/deployments/{deploymentId}/logs",
|
|
1635
2008
|
method: "GET",
|
|
1636
2009
|
summary: "Get deployment logs",
|
|
@@ -1657,22 +2030,19 @@ const analyticsTimeSeriesSchema = z.object({
|
|
|
1657
2030
|
output_token_mean: z.array(analyticsDataPointSchema),
|
|
1658
2031
|
task_count: z.array(analyticsDataPointSchema)
|
|
1659
2032
|
});
|
|
1660
|
-
const getProjectAnalyticsContractV1 =
|
|
2033
|
+
const getProjectAnalyticsContractV1 = base.route({
|
|
1661
2034
|
path: "/v1/analytics/{projectId}",
|
|
1662
2035
|
method: "GET",
|
|
1663
2036
|
summary: "Get project analytics",
|
|
1664
2037
|
description: "Get analytics data for a project over a time range",
|
|
1665
2038
|
tags: ["analytics"],
|
|
1666
2039
|
successDescription: "The project analytics data"
|
|
1667
|
-
}).errors({
|
|
1668
|
-
NOT_FOUND: {},
|
|
1669
|
-
BAD_REQUEST: {}
|
|
1670
|
-
}).input(z.object({
|
|
2040
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1671
2041
|
projectId: z.string().describe("The ID of the project"),
|
|
1672
2042
|
startTimestamp: z.coerce.number().describe("Start timestamp in milliseconds"),
|
|
1673
2043
|
endTimestamp: z.coerce.number().describe("End timestamp in milliseconds"),
|
|
1674
2044
|
timeZone: z.string().describe("IANA timezone (e.g. Europe/Paris)")
|
|
1675
|
-
}).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp > 0, { message: "End date must be after start date" }).refine(({ startTimestamp, endTimestamp }) => endTimestamp - startTimestamp <=
|
|
2045
|
+
}).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({
|
|
1676
2046
|
metadata: z.object({
|
|
1677
2047
|
startTimestamp: z.number(),
|
|
1678
2048
|
endTimestamp: z.number(),
|
|
@@ -1682,7 +2052,132 @@ const getProjectAnalyticsContractV1 = oc.route({
|
|
|
1682
2052
|
}),
|
|
1683
2053
|
timeSeries: analyticsTimeSeriesSchema
|
|
1684
2054
|
}));
|
|
1685
|
-
const
|
|
2055
|
+
const paginatedInsightsInputShape = {
|
|
2056
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2057
|
+
since: timeInputSchema.default("7d").describe("Start time — ISO 8601 (2024-01-01T00:00:00Z) or relative (1h, 30m, 2d)"),
|
|
2058
|
+
until: timeInputSchema.optional().describe("End time — ISO 8601 or relative"),
|
|
2059
|
+
limit: z.coerce.number().int().min(1).max(200).default(50),
|
|
2060
|
+
offset: z.coerce.number().int().min(0).default(0),
|
|
2061
|
+
search: z.string().trim().min(1).max(200).optional()
|
|
2062
|
+
};
|
|
2063
|
+
const listIntentsContractV1 = base.route({
|
|
2064
|
+
path: "/v1/environments/{environmentId}/intents",
|
|
2065
|
+
method: "GET",
|
|
2066
|
+
summary: "List intents",
|
|
2067
|
+
description: "List grouped user intents for an environment over a time range",
|
|
2068
|
+
tags: ["insights"],
|
|
2069
|
+
successDescription: "The grouped user intents"
|
|
2070
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2071
|
+
...paginatedInsightsInputShape,
|
|
2072
|
+
tools: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
2073
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional(),
|
|
2074
|
+
categoryIds: z.array(z.string().trim().min(1)).min(1).max(100).optional(),
|
|
2075
|
+
sortDir: z.enum(["asc", "desc"]).default("desc")
|
|
2076
|
+
})).output(z.object({
|
|
2077
|
+
intents: z.array(z.object({
|
|
2078
|
+
id: z.string(),
|
|
2079
|
+
intentIds: z.array(z.string()).min(1),
|
|
2080
|
+
environmentId: z.string(),
|
|
2081
|
+
message: z.string(),
|
|
2082
|
+
toolName: z.string(),
|
|
2083
|
+
createdAt: z.coerce.date(),
|
|
2084
|
+
occurrenceCount: z.number().int().positive(),
|
|
2085
|
+
clientName: z.string().nullable(),
|
|
2086
|
+
clientId: z.string().nullable(),
|
|
2087
|
+
categories: z.array(z.object({
|
|
2088
|
+
id: z.string(),
|
|
2089
|
+
name: z.string(),
|
|
2090
|
+
color: intentCategoryColorSchema
|
|
2091
|
+
}))
|
|
2092
|
+
})),
|
|
2093
|
+
totalCount: z.number().int().nonnegative()
|
|
2094
|
+
}));
|
|
2095
|
+
const listFeedbacksContractV1 = base.route({
|
|
2096
|
+
path: "/v1/environments/{environmentId}/feedbacks",
|
|
2097
|
+
method: "GET",
|
|
2098
|
+
summary: "List feedbacks",
|
|
2099
|
+
description: "List user feedback for an environment over a time range",
|
|
2100
|
+
tags: ["insights"],
|
|
2101
|
+
successDescription: "The user feedback"
|
|
2102
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2103
|
+
...paginatedInsightsInputShape,
|
|
2104
|
+
clientIds: z.array(z.string().min(1)).min(1).max(100).optional()
|
|
2105
|
+
})).output(z.object({
|
|
2106
|
+
feedbacks: z.array(feedbackSchema.extend({ clientId: z.string().nullable() })),
|
|
2107
|
+
totalCount: z.number().int().nonnegative()
|
|
2108
|
+
}));
|
|
2109
|
+
const intentCategoryNameSchema = z.string().trim().min(1).max(100).describe("The category name");
|
|
2110
|
+
const categorizableIntentIdsSchema = z.array(z.string().trim().min(1)).min(1).max(100).describe("IDs of the intents to categorize");
|
|
2111
|
+
const listIntentCategoriesContractV1 = base.route({
|
|
2112
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
2113
|
+
method: "GET",
|
|
2114
|
+
summary: "List intent categories",
|
|
2115
|
+
description: "List intent categories for an environment, including how many intents each category is linked to",
|
|
2116
|
+
tags: ["insights"],
|
|
2117
|
+
successDescription: "The intent categories"
|
|
2118
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(z.array(intentCategorySummarySchema));
|
|
2119
|
+
const createIntentCategoryContractV1 = base.route({
|
|
2120
|
+
path: "/v1/environments/{environmentId}/intent-categories",
|
|
2121
|
+
method: "POST",
|
|
2122
|
+
summary: "Create an intent category",
|
|
2123
|
+
description: "Create an intent category, optionally linking it to existing intents",
|
|
2124
|
+
tags: ["insights"],
|
|
2125
|
+
successDescription: "The created intent category"
|
|
2126
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2127
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2128
|
+
name: intentCategoryNameSchema,
|
|
2129
|
+
color: intentCategoryColorSchema.optional().describe("The category color; derived from the name when omitted"),
|
|
2130
|
+
intentIds: categorizableIntentIdsSchema.optional().describe("IDs of intents to link to the new category")
|
|
2131
|
+
})).output(intentCategorySchema);
|
|
2132
|
+
const updateIntentCategoryContractV1 = base.route({
|
|
2133
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
2134
|
+
method: "PATCH",
|
|
2135
|
+
summary: "Update an intent category",
|
|
2136
|
+
description: "Rename or recolor an intent category",
|
|
2137
|
+
tags: ["insights"],
|
|
2138
|
+
successDescription: "The updated intent category"
|
|
2139
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2140
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2141
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2142
|
+
name: intentCategoryNameSchema.optional(),
|
|
2143
|
+
color: intentCategoryColorSchema.optional().describe("The category color")
|
|
2144
|
+
}).refine(({ name, color }) => name !== void 0 || color !== void 0, { message: "At least one of name or color must be provided" })).output(intentCategorySchema);
|
|
2145
|
+
const deleteIntentCategoryContractV1 = base.route({
|
|
2146
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}",
|
|
2147
|
+
method: "DELETE",
|
|
2148
|
+
summary: "Delete an intent category",
|
|
2149
|
+
description: "Delete an intent category; its intents are unlinked but not deleted",
|
|
2150
|
+
tags: ["insights"],
|
|
2151
|
+
successDescription: "The intent category has been deleted successfully"
|
|
2152
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2153
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2154
|
+
categoryId: z.string().describe("The ID of the category")
|
|
2155
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2156
|
+
const linkIntentCategoryContractV1 = base.route({
|
|
2157
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/link",
|
|
2158
|
+
method: "POST",
|
|
2159
|
+
summary: "Link an intent category",
|
|
2160
|
+
description: "Link an intent category to intents; already linked intents are ignored",
|
|
2161
|
+
tags: ["insights"],
|
|
2162
|
+
successDescription: "The intents have been linked successfully"
|
|
2163
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2164
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2165
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2166
|
+
intentIds: categorizableIntentIdsSchema
|
|
2167
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2168
|
+
const unlinkIntentCategoryContractV1 = base.route({
|
|
2169
|
+
path: "/v1/environments/{environmentId}/intent-categories/{categoryId}/unlink",
|
|
2170
|
+
method: "POST",
|
|
2171
|
+
summary: "Unlink an intent category",
|
|
2172
|
+
description: "Unlink an intent category from intents; intents without the category are ignored",
|
|
2173
|
+
tags: ["insights"],
|
|
2174
|
+
successDescription: "The intents have been unlinked successfully"
|
|
2175
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
2176
|
+
environmentId: z.string().describe("The ID of the environment"),
|
|
2177
|
+
categoryId: z.string().describe("The ID of the category"),
|
|
2178
|
+
intentIds: categorizableIntentIdsSchema
|
|
2179
|
+
})).output(z.object({ success: z.literal(true) }));
|
|
2180
|
+
const listTeamsContractV1 = base.route({
|
|
1686
2181
|
path: "/v1/teams",
|
|
1687
2182
|
method: "GET",
|
|
1688
2183
|
summary: "List teams",
|
|
@@ -1695,7 +2190,22 @@ const listTeamsContractV1 = oc.route({
|
|
|
1695
2190
|
createdAt: z.coerce.date(),
|
|
1696
2191
|
hasStripeAccount: z.boolean()
|
|
1697
2192
|
})));
|
|
1698
|
-
const
|
|
2193
|
+
const getTeamUsageContractV1 = base.route({
|
|
2194
|
+
path: "/v1/teams/{teamId}/usage",
|
|
2195
|
+
method: "GET",
|
|
2196
|
+
summary: "Get team usage",
|
|
2197
|
+
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.",
|
|
2198
|
+
tags: ["teams"],
|
|
2199
|
+
successDescription: "The current billing window usage"
|
|
2200
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({ teamId: z.string().describe("The ID of the team") })).output(z.object({
|
|
2201
|
+
teamId: z.string(),
|
|
2202
|
+
plan: subscriptionPlanSchema.nullable().describe("The plan in force for the window, null on the Free plan"),
|
|
2203
|
+
periodStart: z.coerce.date().describe("Start of the current billing window"),
|
|
2204
|
+
periodEnd: z.coerce.date().describe("End of the current billing window"),
|
|
2205
|
+
requestCount: z.number().int().describe("MCP requests settled during the current billing window"),
|
|
2206
|
+
includedRequests: z.number().int().nullable().describe("Requests included in the plan for one window, null when the allowance is contract-specific")
|
|
2207
|
+
}));
|
|
2208
|
+
const getTunnelTicketContractV1 = base.route({
|
|
1699
2209
|
path: "/v1/tunnels/ticket",
|
|
1700
2210
|
method: "GET",
|
|
1701
2211
|
summary: "Get a tunnel ticket",
|
|
@@ -1707,16 +2217,13 @@ const getTunnelTicketContractV1 = oc.route({
|
|
|
1707
2217
|
ticket: z.string().describe("The signed tunnel ticket"),
|
|
1708
2218
|
tunnelHost: z.string().describe("The tunnel host to connect to")
|
|
1709
2219
|
}));
|
|
1710
|
-
const publishServerContractV1 =
|
|
2220
|
+
const publishServerContractV1 = base.route({
|
|
1711
2221
|
path: "/v1/distribution/publish",
|
|
1712
2222
|
method: "POST",
|
|
1713
2223
|
summary: "Publish a server to the MCP registry",
|
|
1714
2224
|
tags: ["distribution"],
|
|
1715
2225
|
successDescription: "The server has been published successfully"
|
|
1716
|
-
}).errors({
|
|
1717
|
-
NOT_FOUND: {},
|
|
1718
|
-
BAD_REQUEST: {}
|
|
1719
|
-
}).input(z.object({
|
|
2226
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1720
2227
|
projectId: z.string(),
|
|
1721
2228
|
domain: z.string(),
|
|
1722
2229
|
title: z.string().min(1).max(100),
|
|
@@ -1725,17 +2232,14 @@ const publishServerContractV1 = oc.route({
|
|
|
1725
2232
|
iconSrc: z.url().max(255).optional(),
|
|
1726
2233
|
dryRun: z.boolean().optional()
|
|
1727
2234
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
1728
|
-
const getServerInfoContractV1 =
|
|
2235
|
+
const getServerInfoContractV1 = base.route({
|
|
1729
2236
|
path: "/v1/distribution/get",
|
|
1730
2237
|
method: "GET",
|
|
1731
2238
|
summary: "Get server info",
|
|
1732
2239
|
description: "Get info about a server",
|
|
1733
2240
|
tags: ["distribution"],
|
|
1734
2241
|
successDescription: "The server info"
|
|
1735
|
-
}).errors({
|
|
1736
|
-
NOT_FOUND: {},
|
|
1737
|
-
BAD_REQUEST: {}
|
|
1738
|
-
}).input(z.object({
|
|
2242
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1739
2243
|
projectId: z.string(),
|
|
1740
2244
|
domain: z.string()
|
|
1741
2245
|
})).output(z.object({ serverFields: serverFieldsSchema }));
|
|
@@ -1754,7 +2258,7 @@ const playgroundOutputSchema = z.object({
|
|
|
1754
2258
|
isPlaygroundEnabled: z.boolean(),
|
|
1755
2259
|
serverMetadata: playgroundServerMetadataOutputSchema.nullable()
|
|
1756
2260
|
});
|
|
1757
|
-
const getPlaygroundContractV1 =
|
|
2261
|
+
const getPlaygroundContractV1 = base.route({
|
|
1758
2262
|
path: "/v1/environments/{environmentId}/playground",
|
|
1759
2263
|
method: "GET",
|
|
1760
2264
|
summary: "Get playground configuration",
|
|
@@ -1762,17 +2266,14 @@ const getPlaygroundContractV1 = oc.route({
|
|
|
1762
2266
|
tags: ["environments"],
|
|
1763
2267
|
successDescription: "The playground configuration"
|
|
1764
2268
|
}).errors({ NOT_FOUND: {} }).input(z.object({ environmentId: z.string().describe("The ID of the environment") })).output(playgroundOutputSchema);
|
|
1765
|
-
const upsertPlaygroundContractV1 =
|
|
2269
|
+
const upsertPlaygroundContractV1 = base.route({
|
|
1766
2270
|
path: "/v1/environments/{environmentId}/playground",
|
|
1767
2271
|
method: "PUT",
|
|
1768
2272
|
summary: "Update playground configuration",
|
|
1769
2273
|
description: "Update the playground configuration for an environment. All fields are optional — only provided fields are updated.",
|
|
1770
2274
|
tags: ["environments"],
|
|
1771
2275
|
successDescription: "The updated playground configuration"
|
|
1772
|
-
}).errors({
|
|
1773
|
-
NOT_FOUND: {},
|
|
1774
|
-
BAD_REQUEST: {}
|
|
1775
|
-
}).input(z.object({
|
|
2276
|
+
}).errors({ NOT_FOUND: {} }).input(z.object({
|
|
1776
2277
|
environmentId: z.string().describe("The ID of the environment"),
|
|
1777
2278
|
isPlaygroundEnabled: z.boolean().optional(),
|
|
1778
2279
|
name: z.string().min(1).max(100).optional(),
|
|
@@ -1780,7 +2281,7 @@ const upsertPlaygroundContractV1 = oc.route({
|
|
|
1780
2281
|
headers: z.array(playgroundHeaderSchema).optional(),
|
|
1781
2282
|
examplePrompts: z.array(playgroundExamplePromptSchema).max(5).optional()
|
|
1782
2283
|
})).output(playgroundOutputSchema);
|
|
1783
|
-
const createBeaconContractV1 =
|
|
2284
|
+
const createBeaconContractV1 = base.route({
|
|
1784
2285
|
path: "/v1/beacon/audits",
|
|
1785
2286
|
method: "POST",
|
|
1786
2287
|
summary: "Create a beacon audit",
|
|
@@ -1789,7 +2290,6 @@ const createBeaconContractV1 = oc.route({
|
|
|
1789
2290
|
successDescription: "The audit has been created"
|
|
1790
2291
|
}).errors({
|
|
1791
2292
|
NOT_FOUND: {},
|
|
1792
|
-
BAD_REQUEST: {},
|
|
1793
2293
|
DNS_RESOLUTION_FAILED: { status: 400 }
|
|
1794
2294
|
}).input(z.object({
|
|
1795
2295
|
targetUrl: z.url().describe("The HTTPS URL of the MCP server to audit"),
|
|
@@ -1797,7 +2297,7 @@ const createBeaconContractV1 = oc.route({
|
|
|
1797
2297
|
projectId: z.string().optional().describe("The project ID to associate the audit with"),
|
|
1798
2298
|
excludeCategories: z.array(checkCategorySchema).optional().describe("Check categories to exclude from the audit")
|
|
1799
2299
|
})).output(z.object({ id: z.string() }));
|
|
1800
|
-
const getBeaconContractV1 =
|
|
2300
|
+
const getBeaconContractV1 = base.route({
|
|
1801
2301
|
path: "/v1/beacon/audits/{auditId}",
|
|
1802
2302
|
method: "GET",
|
|
1803
2303
|
summary: "Get a beacon audit",
|
|
@@ -1813,8 +2313,21 @@ const getBeaconContractV1 = oc.route({
|
|
|
1813
2313
|
report: auditReportWithScreenshotsSchema.nullable()
|
|
1814
2314
|
}));
|
|
1815
2315
|
const contract = {
|
|
1816
|
-
teams: {
|
|
2316
|
+
teams: {
|
|
2317
|
+
list: { v1: listTeamsContractV1 },
|
|
2318
|
+
getUsage: { v1: getTeamUsageContractV1 }
|
|
2319
|
+
},
|
|
1817
2320
|
analytics: { get: { v1: getProjectAnalyticsContractV1 } },
|
|
2321
|
+
intents: { list: { v1: listIntentsContractV1 } },
|
|
2322
|
+
intentCategories: {
|
|
2323
|
+
list: { v1: listIntentCategoriesContractV1 },
|
|
2324
|
+
create: { v1: createIntentCategoryContractV1 },
|
|
2325
|
+
update: { v1: updateIntentCategoryContractV1 },
|
|
2326
|
+
delete: { v1: deleteIntentCategoryContractV1 },
|
|
2327
|
+
link: { v1: linkIntentCategoryContractV1 },
|
|
2328
|
+
unlink: { v1: unlinkIntentCategoryContractV1 }
|
|
2329
|
+
},
|
|
2330
|
+
feedbacks: { list: { v1: listFeedbacksContractV1 } },
|
|
1818
2331
|
deployments: {
|
|
1819
2332
|
list: { v1: listDeploymentsContractV1 },
|
|
1820
2333
|
get: { v1: getDeploymentContractV1 },
|
|
@@ -1824,6 +2337,7 @@ const contract = {
|
|
|
1824
2337
|
environments: {
|
|
1825
2338
|
create: { v1: createEnvironmentContractV1 },
|
|
1826
2339
|
get: { v1: getEnvironmentContractV1 },
|
|
2340
|
+
delete: { v1: deleteEnvironmentContractV1 },
|
|
1827
2341
|
deploy: { v1: deployEnvironmentContractV1 },
|
|
1828
2342
|
getLogs: { v1: getLogsContractV1 },
|
|
1829
2343
|
getLatestLogs: { v1: getLatestLogsContractV1 }
|
|
@@ -1855,5 +2369,10 @@ const contract = {
|
|
|
1855
2369
|
get: { v1: getBeaconContractV1 }
|
|
1856
2370
|
}
|
|
1857
2371
|
};
|
|
2372
|
+
const { uploadArtifact: _discard, ...deploymentsForDocs } = contract.deployments;
|
|
2373
|
+
const contractForDocs = {
|
|
2374
|
+
...contract,
|
|
2375
|
+
deployments: deploymentsForDocs
|
|
2376
|
+
};
|
|
1858
2377
|
//#endregion
|
|
1859
|
-
export { AUTH_SCOPE_ANY, AUTH_SCOPE_USER, PLATFORM_LABELS, buildSettingsSchema, contract, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
|
|
2378
|
+
export { AUTH_SCOPE_ANY, AUTH_SCOPE_USER, INTENT_CATEGORY_COLORS, PLATFORM_LABELS, buildSettingsSchema, contract, contractForDocs, createEnvironmentContractV1, deploymentStatusSchema, environmentVariableSchema, environmentVariablesSchema, intentCategoryColorSchema, playgroundExamplePromptSchema, playgroundHeaderSchema, runtimeSchema, serverFieldsSchema, transportSchema, updateEnvironmentVariableSchema };
|