@noimosai/platform-mcp 0.1.3 → 0.1.4

package/dist/schema/platformMonitors.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { projectScopeSchema, platformJsonObjectSchema, platformMicrosSchema } from "./platformPublicExecution.js";
+import { platformMonitorCronSchema, platformMonitorIntervalSchema, platformMonitorTimeZoneSchema } from "./platformMonitorSchedule.js";
+export { PLATFORM_MONITOR_INTERVALS, platformMonitorIntervalSchema } from "./platformMonitorSchedule.js";
+export const PLATFORM_MONITOR_LIMITS = {
+    perProject: 25,
+    nameChars: 80,
+    eventsPage: 100,
+    eventItemBytes: 8_192,
+    snapshotItems: 500,
+    retentionDays: 30,
+    popularMinimumOrganizations: 3,
+    popularPage: 50,
+};
+export const PLATFORM_MONITOR_DESTINATION_LIMITS = {
+    perMonitor: 5,
+    emailRecipients: 5,
+    labelChars: 80,
+    urlChars: 512,
+    digestEvents: 10,
+};
+export const PLATFORM_MONITOR_EMAIL_PRICE_MICROS = 900;
+export const platformMonitorDestinationKindSchema = z.enum(["webhook", "slack", "discord", "email"]);
+const httpsUrl = (value) => {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" && !url.username && !url.password && url.hash === "" ? url : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const isPlatformWebhookUrl = (value) => {
+    const url = httpsUrl(value);
+    return Boolean(url && url.port === "");
+};
+export const isPlatformSlackWebhookUrl = (value) => {
+    const url = httpsUrl(value);
+    return Boolean(url && url.hostname === "hooks.slack.com" && url.port === "" && url.search === "" && /^\/services\/[A-Za-z0-9]+\/[A-Za-z0-9]+\/[A-Za-z0-9]+$/.test(url.pathname));
+};
+export const isPlatformDiscordWebhookUrl = (value) => {
+    const url = httpsUrl(value);
+    return Boolean(url && ["discord.com", "discordapp.com"].includes(url.hostname) && url.port === "" && url.search === "" &&
+        /^\/api(\/v\d{1,2})?\/webhooks\/\d{1,25}\/[A-Za-z0-9_-]{1,200}$/.test(url.pathname));
+};
+const destinationUrl = z.string().trim().max(PLATFORM_MONITOR_DESTINATION_LIMITS.urlChars);
+const destinationLabel = z.string().trim().max(PLATFORM_MONITOR_DESTINATION_LIMITS.labelChars).default("");
+const memberId = z.string().min(1).max(64);
+export const platformMonitorDestinationInputSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("webhook"), label: destinationLabel, url: destinationUrl.refine(isPlatformWebhookUrl, "platform_monitor_destination_url_invalid") }).strict(),
+    z.object({ kind: z.literal("slack"), label: destinationLabel, url: destinationUrl.refine(isPlatformSlackWebhookUrl, "platform_monitor_destination_url_invalid") }).strict(),
+    z.object({ kind: z.literal("discord"), label: destinationLabel, url: destinationUrl.refine(isPlatformDiscordWebhookUrl, "platform_monitor_destination_url_invalid") }).strict(),
+    z.object({ kind: z.literal("email"), label: destinationLabel,
+        memberIds: z.array(memberId).min(1).max(PLATFORM_MONITOR_DESTINATION_LIMITS.emailRecipients) }).strict(),
+]);
+export const platformMonitorDestinationSchema = z.object({
+    id: z.string().regex(/^dst_[A-Za-z0-9_-]{1,100}$/),
+    kind: platformMonitorDestinationKindSchema,
+    label: z.string(),
+    target: z.string(),
+    memberIds: z.array(z.string()),
+    createdAt: z.string(),
+    lastDeliveredAt: z.string().nullable(),
+    lastStatus: z.enum(["ok", "failed"]).nullable(),
+    lastError: z.string().nullable(),
+    signingSecret: z.string().optional(),
+});
+export const platformMonitorRecipientSchema = z.object({ memberId, email: z.string(), name: z.string() });
+const toolName = z.string().regex(/^[a-z][a-z0-9_]{1,63}$/);
+export const PLATFORM_MONITOR_ID = /^mon_[A-Za-z0-9_-]{1,100}$/;
+const monitorId = z.string().regex(PLATFORM_MONITOR_ID);
+export const platformMonitorCreateSchema = z.object({
+    tool: toolName,
+    arguments: platformJsonObjectSchema.default({}),
+    provider: z.string().trim().max(64).default(""),
+    interval: platformMonitorIntervalSchema.optional().describe("Run every 15m, 1h (default) or 1d. Omit when using cron."),
+    cron: platformMonitorCronSchema.optional().describe("5-field cron for fixed times, at least 15 minutes between runs, for example '0 9 * * 1-5' (weekdays 09:00). Omit when using interval."),
+    timeZone: platformMonitorTimeZoneSchema.optional().describe("IANA time zone the cron is read in, for example Asia/Tokyo; UTC when omitted. Only with cron."),
+    name: z.string().trim().max(PLATFORM_MONITOR_LIMITS.nameChars).default(""),
+    maximumChargeMicrosPerRun: platformMicrosSchema.default(0),
+    destinations: z.array(platformMonitorDestinationInputSchema).max(PLATFORM_MONITOR_DESTINATION_LIMITS.perMonitor).default([]),
+}).strict();
+export const platformMonitorPoolSchema = z.object({
+    chargeCeilingMicros: platformMicrosSchema,
+    members: z.number().int().min(0),
+    shareMicros: platformMicrosSchema,
+});
+export const platformMonitorQuoteSchema = platformMonitorCreateSchema.pick({ tool: true, arguments: true, provider: true, interval: true, cron: true, timeZone: true }).strict();
+export const platformMonitorQuoteResultSchema = platformMonitorPoolSchema.extend({
+    joined: z.boolean(),
+    payers: z.number().int().min(1),
+});
+export const platformMonitorResumeSchema = z.object({ maximumChargeMicrosPerRun: platformMicrosSchema.optional() }).strict();
+export const platformMonitorSchema = z.object({
+    id: monitorId,
+    name: z.string(),
+    tool: toolName,
+    provider: z.string(),
+    arguments: platformJsonObjectSchema,
+    interval: platformMonitorIntervalSchema.nullable(),
+    cron: z.string().nullable().default(null),
+    timeZone: z.string().nullable().default(null),
+    subscribers: z.number().int().min(1),
+    lastCheckedAt: z.string().nullable(),
+    lastChangedAt: z.string().nullable(),
+    nextCheckAt: z.string().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.string(),
+    maximumChargeMicrosPerRun: platformMicrosSchema,
+    pool: platformMonitorPoolSchema,
+    status: z.enum(["active", "suspended"]),
+    suspendedReason: z.string().nullable(),
+    destinations: z.array(platformMonitorDestinationSchema).default([]),
+});
+const changeValue = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+export const platformMonitorEventSchema = z.object({
+    id: z.string().regex(/^\d{1,20}$/),
+    monitorId: monitorId,
+    kind: z.enum(["added", "changed", "removed"]),
+    itemKey: z.string(),
+    title: z.string(),
+    url: z.string(),
+    item: platformJsonObjectSchema,
+    changes: z.array(z.object({ field: z.string(), before: changeValue, after: changeValue })),
+    detectedAt: z.string(),
+});
+export const platformMonitorEventsQuerySchema = z.object({
+    after: z.string().regex(/^\d{1,20}$/).optional(),
+    limit: z.coerce.number().int().min(1).max(PLATFORM_MONITOR_LIMITS.eventsPage).default(50),
+}).strict();
+export const platformMonitorEventsSchema = z.object({ events: z.array(platformMonitorEventSchema), nextAfter: z.string().nullable() });
+export const platformPopularMonitorSchema = z.object({
+    tool: toolName, provider: z.string(), arguments: platformJsonObjectSchema,
+    interval: platformMonitorIntervalSchema.nullable(), cron: z.string().nullable().default(null), timeZone: z.string().nullable().default(null),
+    organizations: z.number().int().min(1),
+    chargeCeilingMicros: platformMicrosSchema,
+});
+export const platformMonitorableToolSchema = z.object({ name: toolName, provider: z.string(), chargeCeilingMicros: platformMicrosSchema });
+export function platformMonitorWire(monitor) {
+    const { cron, timeZone, destinations, ...rest } = monitor;
+    return { ...rest, ...(cron == null ? {} : { cron }), ...(timeZone == null ? {} : { timeZone }), ...(destinations?.length ? { destinations } : {}) };
+}
+export const platformMonitorContracts = {
+    listDeveloperMonitors: { input: projectScopeSchema.strict(), output: z.object({ monitors: z.array(platformMonitorSchema) }).strict() },
+    createDeveloperMonitor: { input: projectScopeSchema.extend({ monitor: platformMonitorCreateSchema }).strict(), output: z.object({ monitor: platformMonitorSchema }).strict() },
+    deleteDeveloperMonitor: { input: projectScopeSchema.extend({ monitorId }).strict(), output: z.object({ success: z.literal(true) }).strict() },
+    quoteDeveloperMonitor: { input: projectScopeSchema.extend({ monitor: platformMonitorQuoteSchema }).strict(), output: z.object({ quote: platformMonitorQuoteResultSchema }).strict() },
+    resumeDeveloperMonitor: { input: projectScopeSchema.extend({ monitorId }).merge(platformMonitorResumeSchema).strict(), output: z.object({ monitor: platformMonitorSchema }).strict() },
+    listDeveloperMonitorEvents: {
+        input: projectScopeSchema.extend({ monitorId: monitorId.optional(), after: platformMonitorEventsQuerySchema.shape.after,
+            limit: z.number().int().min(1).max(PLATFORM_MONITOR_LIMITS.eventsPage).default(50) }).strict(),
+        output: platformMonitorEventsSchema,
+    },
+    addDeveloperMonitorDestination: { input: projectScopeSchema.extend({ monitorId, destination: platformMonitorDestinationInputSchema }).strict(), output: z.object({ monitor: platformMonitorSchema }).strict() },
+    removeDeveloperMonitorDestination: { input: projectScopeSchema.extend({ monitorId, destinationId: platformMonitorDestinationSchema.shape.id }).strict(), output: z.object({ monitor: platformMonitorSchema }).strict() },
+    listDeveloperMonitorRecipients: { input: projectScopeSchema.strict(), output: z.object({ recipients: z.array(platformMonitorRecipientSchema) }).strict() },
+    listPopularMonitors: { input: projectScopeSchema.strict(), output: z.object({ monitors: z.array(platformPopularMonitorSchema) }).strict() },
+    listMonitorableTools: { input: projectScopeSchema.strict(), output: z.object({ tools: z.array(platformMonitorableToolSchema) }).strict() },
+};

package/dist/schema/platformOAuth.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+const PLATFORM_APP_METHOD_TYPES = ["key", "none", "oauth1", "oauth2", "client_credentials", "mcp_oauth", "service_account"];
+export const platformAppMethodTypeSchema = z.enum(PLATFORM_APP_METHOD_TYPES);
+export const platformAppMethodTypesSchema = z.array(platformAppMethodTypeSchema).min(1).max(PLATFORM_APP_METHOD_TYPES.length)
+    .refine(methods => new Set(methods).size === methods.length, "Duplicate connection method");
+export const platformOAuthScopeAlternativesSchema = z.array(z.array(z.string().min(1).max(256)).max(128)).min(1).max(128);
+export const platformOAuthPermissionSchema = z.object({
+    status: z.enum(["available", "missing_scopes", "unsupported_auth_method", "unknown_grant", "unknown_requirements", "not_applicable"]),
+    required: platformOAuthScopeAlternativesSchema.optional(),
+    missing: z.array(z.string()).optional(),
+    connectionMethod: platformAppMethodTypeSchema.optional(),
+    requiredMethods: platformAppMethodTypesSchema.optional(),
+});

package/dist/schema/platformProjectPermissions.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { organizationScopeSchema, projectScopeSchema } from "./platformPublicExecution.js";
+import { memberTeamSkillAccessSchema, memberToolAccessSchema, platformProjectRoleSchema, platformTeamContextSchema, platformTeamQuerySchema, projectPermissionPolicySchema, projectPermissionSetDefinitionSchema, projectPermissionSetSchema, projectPermissionSetRefSchema } from "./platformToolAccess.js";
+export const platformProjectStatusQuerySchema = platformTeamQuerySchema;
+const projectRosterMember = platformTeamContextSchema.shape.member.extend({ role: platformProjectRoleSchema, permissionSet: projectPermissionSetRefSchema.nullable() });
+const projectInvitation = projectRosterMember.omit({ memberId: true, name: true }).extend({ id: z.string(), expiresAt: z.string() });
+export const platformProjectStatusSchema = platformTeamContextSchema.extend({
+    permissions: z.object({
+        permissionSet: projectPermissionSetRefSchema.nullable(), teamSkillAccess: memberTeamSkillAccessSchema,
+        toolExecution: z.object({ restricted: z.boolean(), allowedCount: z.number().int().nonnegative().nullable() }),
+        memberResourcesRestricted: z.boolean(), keyResourcesRestricted: z.boolean(),
+    }),
+    members: z.object({ items: z.array(projectRosterMember), nextOffset: z.number().int().nonnegative().nullable() }).nullable(),
+    invitations: z.object({ items: z.array(projectInvitation), nextOffset: z.number().int().nonnegative().nullable() }).nullable(),
+});
+const id = z.string().min(1).max(128), success = z.object({ success: z.literal(true) });
+export const platformProjectPermissionContracts = {
+    updateDeveloperProjectTools: { input: projectScopeSchema.extend({ tools: projectPermissionPolicySchema.shape.tools, expectedVersion: z.number().int().positive() }).strict(),
+        output: z.object({ tools: projectPermissionPolicySchema.shape.tools, version: z.number().int().positive() }) },
+    listDeveloperUnmanagedProjects: { input: organizationScopeSchema.strict(), output: z.object({ projects: z.array(z.object({ id, name: z.string() })) }) },
+    recoverDeveloperProjectAdministration: { input: projectScopeSchema.strict(), output: success },
+    deleteDeveloperProject: { input: projectScopeSchema.extend({ name: z.string().max(200) }).strict(), output: success },
+    listDeveloperPermissionSets: { input: organizationScopeSchema.strict(), output: z.object({ permissionSets: z.array(projectPermissionSetSchema), canManage: z.boolean() }) },
+    createDeveloperPermissionSet: { input: organizationScopeSchema.extend({ permissionSet: projectPermissionSetDefinitionSchema }).strict(), output: z.object({ permissionSet: projectPermissionSetSchema }) },
+    updateDeveloperPermissionSet: { input: organizationScopeSchema.extend({ permissionSetId: id, expectedVersion: z.number().int().positive(), permissionSet: projectPermissionSetDefinitionSchema }).strict(), output: z.object({ permissionSet: projectPermissionSetSchema }) },
+    archiveDeveloperPermissionSet: { input: organizationScopeSchema.extend({ permissionSetId: id, expectedVersion: z.number().int().positive() }).strict(), output: success },
+    getDeveloperProjectAccess: { input: projectScopeSchema.strict(), output: z.object({
+            project: z.object({ id: z.string(), name: z.string() }), role: platformProjectRoleSchema,
+            permissionSet: projectPermissionSetSchema.nullable(), toolAccess: memberToolAccessSchema, tools: projectPermissionPolicySchema.shape.tools,
+            toolExecutionVersion: z.number().int().positive().default(1),
+            teamSkillAccess: memberTeamSkillAccessSchema, canManageMembers: z.boolean(), canDeleteProject: z.boolean().default(false),
+        }) },
+};

package/dist/schema/platformPublicExecution.js

@@ -1,44 +1,203 @@
 import { z } from "zod";
+import { fitToolResultPage, TOOL_RESULT_CONTEXT_MAX_BYTES, toolResultContextSchema, toolResultPageSchema } from "./toolResultContext.js";
+import { platformOAuthPermissionSchema } from "./platformOAuth.js";
 export const PLATFORM_EXECUTION_MAX_STEPS = 20;
+export const PLATFORM_EXECUTION_MAX_WAIT_SECONDS = 25;
 export const PLATFORM_STEP_OUTPUT_MAX_BYTES = 1_048_576;
 export const PLATFORM_EXECUTION_RESPONSE_MAX_BYTES = PLATFORM_EXECUTION_MAX_STEPS * PLATFORM_STEP_OUTPUT_MAX_BYTES + 65_536;
+export const PLATFORM_TOOL_REQUEST_MAX_BYTES = 1_048_576;
+export const PLATFORM_CONSOLE_REQUEST_MAX_BYTES = 65_536;
+export const PLATFORM_SEARCH_MAX_LENGTH = 100;
+export const PLATFORM_MEDIA_URL_MAX_LENGTH = 4096;
 export const platformJsonObjectSchema = z.record(z.string(), z.json());
+export const organizationScopeSchema = z.object({ developerOrganizationId: z.string().min(1).max(128) });
+export const projectScopeSchema = organizationScopeSchema.extend({ developerProjectId: z.string().min(1).max(128) });
+export const developerKeyScopeSchema = z.enum(["project:read", "usage:read", "tools:read", "tools:execute", "executions:read"]);
+export const developerKeyAnyScopeSchema = z.enum([...developerKeyScopeSchema.options, "access:write", "sessions:write"]);
 export const PLATFORM_INPUT_MAX_BYTES = 12 * 1024 * 1024;
+export const PLATFORM_FILE_CHUNK_MAX_BYTES = 32 * 1024 * 1024;
 export const PLATFORM_UPLOAD_MAX_BYTES = 16 * 1024 * 1024 + 4096;
 export const platformInputFileIdSchema = z.string().regex(/^f_[a-f0-9]{64}$/);
-export const platformInputMimeSchema = z.enum(["image/jpeg", "image/png", "image/webp", "audio/wav", "audio/mpeg", "video/mp4"]);
-export const platformInputUploadSchema = z.object({ mimeType: platformInputMimeSchema, data: z.string().min(4).max(16 * 1024 * 1024) }).strict();
-export const platformInputFileSchema = z.object({ id: platformInputFileIdSchema, mimeType: platformInputMimeSchema,
+export const platformInputMimeSchema = z.enum(["image/jpeg", "image/png", "image/webp", "audio/wav", "audio/mpeg", "video/mp4", "video/quicktime"]);
+export const platformInputFileMimeSchema = z.string().max(255).regex(/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/);
+export const platformInputUploadSchema = z.object({ mimeType: platformInputFileMimeSchema, data: z.string().min(4).max(16 * 1024 * 1024),
+    purpose: z.literal("file").optional().describe("file stores opaque bytes for provider uploads, including GIF, documents, archives and local upload chunks. Omit for validated AI media.") }).strict();
+export const platformInputFileSchema = z.object({ id: platformInputFileIdSchema, mimeType: platformInputFileMimeSchema,
     sizeBytes: z.number().int().positive().max(PLATFORM_INPUT_MAX_BYTES), sha256: z.string().regex(/^[a-f0-9]{64}$/), expiresAt: z.iso.datetime() });
 export const platformMicrosSchema = z.number().int().min(0).max(1_000_000_000_000);
 export const platformToolNameSchema = z.string().regex(/^[a-z][a-z0-9_]{1,63}$/);
+export const platformExecutionIdSchema = z.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
+export const platformToolSessionIdSchema = z.uuid();
+export const platformOptionalToolSessionIdSchema = z.union([platformToolSessionIdSchema, z.literal("")]).transform(value => value || undefined).optional();
+export const PLATFORM_SANDBOX_LIMITS = { code: 64000, sourceExecutions: 10, timeoutMs: 60000, sourceBytes: 32 * 1024 * 1024 };
+export const platformProviderChoiceSchema = z.string().trim().regex(/^(?:[a-z][a-z0-9_]{0,63})?$/)
+    .transform(value => value === "" || value === "auto" ? undefined : value).optional()
+    .describe("Omit, use auto, or use an empty string for automatic routing. A catalog provider ID strictly selects that compatible provider; no other provider is substituted.");
+export const platformRelevanceCheckSchema = z.enum(["", "auto", "light"])
+    .transform(value => value === "light" ? "light" : undefined).optional()
+    .describe("Auto result filtering: auto (default) or light, a cheaper check that keeps rows it cannot decide.");
+export const platformInvalidArgumentFieldsSchema = z.array(z.string().max(200).regex(/^[\w.-]*$/)).max(50);
+export const PLATFORM_REQUEST_INTENT_MAX_CHARS = 1000;
+export const platformRequestIntentSchema = z.string().trim().max(PLATFORM_REQUEST_INTENT_MAX_CHARS).transform(value => value || undefined).optional()
+    .describe("Brief user goal without secrets or private content. Empty means omitted.");
 export const platformExecutionStatusSchema = z.enum(["queued", "running", "waiting", "succeeded", "failed", "cancelled", "needs_review"]);
+export const platformFundingSchema = z.enum(["relvo", "provider", "mixed"]);
+const platformModelFundingSchema = z.enum(["relvo", "provider"]);
 const workspaceArgumentNames = new Set(["workspaceid", "workspaceids", "teamid", "provideraccountid", "provideraccountids", "datasetid", "datasetids", "knowledgebaseid", "sessionid", "skillid"]);
-const standaloneArgumentsSchema = platformJsonObjectSchema.superRefine((value, context) => {
-    for (const key of Object.keys(value))
-        if (workspaceArgumentNames.has(key.replaceAll("_", "").toLowerCase())) {
-            context.addIssue({ code: "custom", path: [key], message: "Workspace-owned data is unavailable on the standalone Platform." });
+export function validatePlatformArgumentIdentifiers(tool, input, context, field = "arguments") {
+    if (tool?.includes("__"))
+        return;
+    const nativeFields = tool?.startsWith("tikhub_") ? ["session_id"]
+        : tool?.startsWith("brightdata_") ? ["dataset_id"]
+            : tool?.startsWith("firecrawl_") ? ["dataset_id", "session_id", "team_id"] : [];
+    for (const key of Object.keys(input))
+        if (workspaceArgumentNames.has(key.replaceAll("_", "").toLowerCase()) && !nativeFields.includes(key)) {
+            context.addIssue({ code: "custom", path: [field, key], message: "Workspace-owned data is unavailable on the standalone Platform." });
         }
-}).describe("Self-contained tool arguments: prompts, public URLs or public account identifiers. Web workspace identifiers are not supported.");
-export const platformToolInputSchema = z.object({ tool: platformToolNameSchema.describe("Tool name from the standalone Platform catalog."), arguments: standaloneArgumentsSchema }).strict();
+}
+const standaloneArgumentsSchema = z.record(z.string(), z.unknown()).pipe(platformJsonObjectSchema)
+    .describe("Self-contained tool arguments: prompts, public URLs or public account identifiers. Web workspace identifiers are not supported.");
+export const platformToolInputSchema = z.object({ tool: platformToolNameSchema.describe("Tool name from the standalone Platform catalog."), arguments: standaloneArgumentsSchema,
+    provider: platformProviderChoiceSchema,
+    relevanceCheck: platformRelevanceCheckSchema,
+    intent: platformRequestIntentSchema,
+    sessionId: platformOptionalToolSessionIdSchema.describe("Relvo tool session returned by platform_search_tools. Omit or use an empty string for standalone executions.") }).strict()
+    .superRefine((value, context) => validatePlatformArgumentIdentifiers(value.tool, value.arguments, context));
+export const platformQuoteRequestSchema = platformToolInputSchema.extend({
+    maximumChargeMicros: platformMicrosSchema.optional()
+        .describe("Optional cap: an Auto quote above it returns the best plan within it as plan; execute with plan's fields."),
+}).strict();
+export const platformRunRequestHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+export const platformRecoverExecutionSchema = z.object({ idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/),
+    requestHash: platformRunRequestHashSchema.optional() }).strict();
 export const platformCreateExecutionSchema = platformToolInputSchema.extend({
     maximumChargeMicros: platformMicrosSchema,
     priceVersion: z.string().min(1).max(100),
+    runRequestHash: platformRunRequestHashSchema.optional(),
 }).strict();
 export const platformQuoteSchema = z.object({
     tool: platformToolNameSchema, priceVersion: z.string(), currency: z.literal("usd"),
     minimumChargeMicros: platformMicrosSchema, maximumChargeMicros: platformMicrosSchema,
+    lowestChargeMicros: platformMicrosSchema.optional(),
     expiresAt: z.string(),
+    funding: platformFundingSchema.optional(), externalBillingProviders: z.array(z.string()).optional(),
+    plan: z.object({ provider: z.string().optional(), relevanceCheck: z.literal("light").optional() }).strict().optional(),
+});
+export const platformUpstreamRefusalSchema = z.object({
+    kind: z.enum(["rate_limited", "permission", "rejected"]),
+    httpStatus: z.number().int().min(100).max(599).optional(),
+    code: z.string().max(100).optional(),
+    retryAfterSeconds: z.number().int().nonnegative().optional(),
+    neededScopes: z.array(z.string().max(100)).max(20).optional(),
 });
+const refusedStepSchema = z.object({ requestSucceeded: z.literal(false), response: z.object({ status: z.number().int().min(100).max(599).optional(), body: z.unknown().optional(),
+        headers: z.object({ retryAfter: z.string().optional() }).loose().optional() }).loose().optional() }).loose();
+const multiStepOutputSchema = z.object({ results: z.array(z.object({ data: z.unknown() }).loose()) }).loose();
+const refusalBodySchema = z.object({ error: z.union([z.string(), z.object({ code: z.union([z.string(), z.number()]) }).loose()]).optional(),
+    code: z.union([z.string(), z.number()]).optional(), needed: z.string().optional(),
+    errors: z.array(z.object({ extensions: z.object({ code: z.string() }).loose().optional() }).loose()).min(1).optional() }).loose();
+const REFUSAL_CODE = /^[A-Za-z0-9_.:-]{1,100}$/;
+const PERMISSION_CODES = new Set(["missing_scope", "no_permission", "not_allowed_token_type", "scope_not_authorized"]);
+export function retryAfterSeconds(value, now = Date.now()) {
+    if (value === undefined || !value.trim())
+        return undefined;
+    const delay = Number(value), seconds = Number.isFinite(delay) ? delay : (Date.parse(value) - now) / 1000;
+    return Number.isFinite(seconds) ? Math.max(0, Math.ceil(seconds)) : undefined;
+}
+function refusalOf(step) {
+    const body = refusalBodySchema.safeParse(step.response?.body ?? step.response).data, status = step.response?.status;
+    const error = typeof body?.error === "object" ? body.error.code : body?.error;
+    const raw = String((typeof body?.code === "string" ? body.code : undefined) ?? error ?? body?.errors?.[0]?.extensions?.code ?? body?.code ?? "");
+    const code = REFUSAL_CODE.test(raw) ? raw : undefined;
+    const neededScopes = body?.needed?.split(",").map(scope => scope.trim()).filter(scope => REFUSAL_CODE.test(scope)).slice(0, 20) ?? [];
+    const wait = retryAfterSeconds(step.response?.headers?.retryAfter);
+    const kind = status === 429 || code === "ratelimited" ? "rate_limited"
+        : status === 401 || status === 403 || neededScopes.length || code !== undefined && PERMISSION_CODES.has(code) ? "permission" : "rejected";
+    return { kind, ...(status === undefined ? {} : { httpStatus: status }), ...(code ? { code } : {}), ...(wait === undefined ? {} : { retryAfterSeconds: wait }),
+        ...(neededScopes.length ? { neededScopes } : {}) };
+}
+export function connectedRequestRefusal(output) {
+    const step = refusedStepSchema.safeParse(output);
+    if (step.success)
+        return refusalOf(step.data);
+    const steps = multiStepOutputSchema.safeParse(output);
+    if (!steps.success)
+        return undefined;
+    for (const { data } of steps.data.results) {
+        const refused = refusedStepSchema.safeParse(data);
+        if (refused.success)
+            return refusalOf(refused.data);
+    }
+    return undefined;
+}
 export const platformExecutionSchema = z.object({
-    id: z.string(), tool: platformToolNameSchema, status: platformExecutionStatusSchema, cancelRequested: z.boolean(),
+    id: platformExecutionIdSchema, tool: platformToolNameSchema, status: platformExecutionStatusSchema, cancelRequested: z.boolean(),
     priceVersion: z.string(), currency: z.literal("usd"), reservedMicros: platformMicrosSchema, chargedMicros: platformMicrosSchema,
+    funding: platformFundingSchema.optional(), externalBillingProviders: z.array(z.string()).optional(),
     output: platformJsonObjectSchema.nullable(), errorCode: z.string().nullable(),
+    upstreamRefusal: platformUpstreamRefusalSchema.optional(),
+    rateLimitedUntil: z.string().optional(),
+    reconnectUrl: z.url().optional(),
+    actionUrl: z.url().optional(),
+    sourceRefusals: z.array(z.object({ source: z.string(), inputs: z.array(z.string()), applies: z.array(z.string()).optional() })).optional(),
     createdAt: z.string(), updatedAt: z.string(), completedAt: z.string().nullable(),
 });
+export const platformExecutionContextSchema = platformExecutionSchema.extend({ resultContext: toolResultContextSchema.omit({ preview: true }) });
+export function platformExecutionHasPartialOutput(execution) {
+    const output = execution.output, keys = output === null ? [] : Object.keys(output);
+    return ["failed", "cancelled"].includes(execution.status) && keys.length > 0
+        && !(keys.length === 1 && Array.isArray(output?.results) && output.results.length === 0);
+}
+export const platformExecutionResultPageSchema = z.object({ executionId: platformExecutionIdSchema, page: toolResultPageSchema,
+    status: platformExecutionStatusSchema.optional(), chargedMicros: platformMicrosSchema.nullable().optional(), errorCode: z.string().nullable().optional(), partial: z.boolean().optional(),
+    upstreamRefusal: platformUpstreamRefusalSchema.optional() });
+export const PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR = "platform_execution_context_budget_exceeded";
+export class PlatformExecutionContextBudgetError extends Error {
+    executionId;
+    kind;
+    code = PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR;
+    constructor(executionId, kind = "execution") {
+        super(kind === "page"
+            ? `Execution ${executionId} selected result page metadata exceeds the context budget. Read a narrower path or use a smaller limit/maxChars; the full result remains retained.`
+            : `Execution ${executionId} metadata exceeds the context budget. Recover it by this ID or the retained idempotency key.`);
+        this.executionId = executionId;
+        this.kind = kind;
+        this.name = "PlatformExecutionContextBudgetError";
+    }
+}
+const executionContextBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+export function platformExecutionReceiptContext(result, options) {
+    const maximumBytes = options.maximumBytes ?? TOOL_RESULT_CONTEXT_MAX_BYTES;
+    if (executionContextBytes(result) <= maximumBytes)
+        return result;
+    const existing = platformExecutionContextSchema.safeParse(result.data);
+    const compact = { data: platformExecutionContextSchema.parse({ ...result.data, output: null,
+            resultContext: { offloaded: true, totalBytes: existing.success ? existing.data.resultContext.totalBytes : executionContextBytes(result.data.output),
+                reference: { ...(existing.success ? existing.data.resultContext.reference : {}), executionId: result.data.id, readWith: options.readWith } },
+        }) };
+    if (executionContextBytes(compact) > maximumBytes)
+        throw new PlatformExecutionContextBudgetError(result.data.id);
+    return compact;
+}
+export function platformExecutionResultPageContext(result, options) {
+    const maximumBytes = options.maximumBytes ?? TOOL_RESULT_CONTEXT_MAX_BYTES;
+    if (executionContextBytes(result) <= maximumBytes)
+        return result;
+    const { executionId, page, ...metadata } = result.data;
+    const fitted = { data: { executionId, ...metadata, page: fitToolResultPage(page, candidate => executionContextBytes({ data: { executionId, ...metadata, page: candidate } }) <= maximumBytes) } };
+    if (executionContextBytes(fitted) <= maximumBytes)
+        return fitted;
+    const compact = { data: platformExecutionResultPageSchema.parse({ executionId, ...metadata, page: { ...page,
+                context: { ...page.context, offloaded: true, preview: null, reference: { ...page.context.reference,
+                        executionId, readWith: options.readWith, path: page.path, offset: page.offset } },
+            } }) };
+    if (executionContextBytes(compact) > maximumBytes)
+        throw new PlatformExecutionContextBudgetError(executionId, "page");
+    return compact;
+}
 export const platformExecutionListQuerySchema = z.object({
     limit: z.number().int().min(1).max(100).default(20).describe("Page size, 1–100."),
-    before: z.string().regex(/^[A-Za-z0-9_-]{1,128}$/).optional().describe("nextBefore from the previous page."),
+    before: platformExecutionIdSchema.optional().describe("nextBefore from the previous page."),
     status: platformExecutionStatusSchema.optional().describe("Only executions with this status."),
     tool: platformToolNameSchema.optional().describe("Only executions of this catalog tool."),
 }).strict();
@@ -48,17 +207,39 @@ export const platformExecutionListSchema = z.object({
 });
 export const platformArtifactIdSchema = z.string().regex(/^a_[A-Za-z0-9_-]{1,100}$/);
 export const platformArtifactSchema = z.object({
-    id: platformArtifactIdSchema, mimeType: z.enum(["image/jpeg", "image/png", "image/webp", "audio/wav", "audio/mpeg", "video/mp4"]),
+    id: platformArtifactIdSchema, mimeType: z.enum(["image/jpeg", "image/png", "image/webp", "image/svg+xml", "audio/wav", "audio/mpeg", "audio/flac", "audio/l16", "audio/mulaw", "audio/alaw", "video/mp4", "video/quicktime", "model/gltf-binary", "application/zip"]),
     sizeBytes: z.number().int().positive().max(64 * 1024 * 1024), sha256: z.string().regex(/^[a-f0-9]{64}$/),
     generation: z.string().regex(/^\d{1,30}$/), expiresAt: z.iso.datetime(),
 });
-export const platformArtifactDownloadSchema = z.object({ url: z.url().refine((value) => { const url = new URL(value); return url.protocol === "https:" && !url.username && !url.password; }), expiresAt: z.iso.datetime() });
-export const platformCatalogSchema = z.object({
-    priceVersion: z.string(), currency: z.literal("usd"), executionEnabled: z.boolean(),
-    tools: z.array(z.object({
-        name: platformToolNameSchema, description: z.string(), category: z.enum(["research", "seo", "social", "generation"]),
-        available: z.boolean(), inputSchema: platformJsonObjectSchema, example: platformJsonObjectSchema,
-        models: z.array(z.object({ id: z.string(), available: z.boolean(), example: platformJsonObjectSchema, priceDescription: z.string() })).optional(),
-        price: z.object({ minimumChargeMicros: platformMicrosSchema, unit: z.string(), unitPriceMicros: platformMicrosSchema.nullable(), description: z.string() }),
-    })),
+export const platformArtifactDownloadSchema = z.object({ url: z.url().refine(value => {
+        if (!URL.canParse(value))
+            return false;
+        const url = new URL(value);
+        return !url.username && !url.password && !url.hash && (url.protocol === "https:" || url.protocol === "http:" && ["127.0.0.1", "localhost"].includes(url.hostname));
+    }), expiresAt: z.iso.datetime() });
+export const platformUnavailableReasonSchema = z.enum(["setup", "own_key", "connection", "permission", "retired"]);
+export const PLATFORM_TOOL_RESPONSE_SUMMARY_MAX = 2000;
+export const platformCatalogToolSchema = z.object({
+    name: platformToolNameSchema, title: z.string().optional(), description: z.string(), category: z.enum(["research", "seo", "social", "generation", "enrichment", "finance", "news"]),
+    available: z.boolean(), unavailable: platformUnavailableReasonSchema.optional(), inputSchema: platformJsonObjectSchema, example: platformJsonObjectSchema,
+    responseSummary: z.string().max(PLATFORM_TOOL_RESPONSE_SUMMARY_MAX).optional(),
+    permission: platformOAuthPermissionSchema.optional(),
+    providers: z.array(z.object({ id: z.string(), name: z.string(), available: z.boolean(), unavailable: platformUnavailableReasonSchema.optional(),
+        role: z.enum(["primary", "fallback", "alternative"]), condition: z.string().optional(),
+        applies: z.array(z.string()).optional() })).optional(),
+    models: z.array(z.object({ id: z.string(), available: z.boolean(), unavailable: platformUnavailableReasonSchema.optional(), example: platformJsonObjectSchema, priceDescription: z.string(), funding: platformModelFundingSchema.optional() })).optional(),
+    price: z.object({ minimumChargeMicros: platformMicrosSchema, unit: z.string(), unitPriceMicros: platformMicrosSchema.nullable(), unitPriceCeilingMicros: platformMicrosSchema.optional(), description: z.string(),
+        unitsPerRequest: z.object({ minimum: z.number().int().positive(), maximum: z.number().int().positive() }).refine(range => range.minimum <= range.maximum).optional(),
+        funding: platformFundingSchema.optional(), externalBillingProviders: z.array(z.string()).optional() }),
 });
+const platformCatalogHeader = { priceVersion: z.string(), currency: z.literal("usd"), executionEnabled: z.boolean() };
+export const platformCatalogSchema = z.object({ ...platformCatalogHeader, tools: z.array(platformCatalogToolSchema) });
+export const PLATFORM_CATALOG_PAGE_MAX = 50;
+export const PLATFORM_READ_UNIT_BYTES = 262_144;
+export const platformCatalogPageQuerySchema = z.object({
+    offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+    limit: z.number().int().min(1).max(PLATFORM_CATALOG_PAGE_MAX).default(PLATFORM_CATALOG_PAGE_MAX),
+}).strict();
+export const platformCatalogPageSchema = platformCatalogSchema.extend({ total: z.number().int().min(0), nextOffset: z.number().int().min(0).nullable() });
+export const platformCatalogSummarySchema = z.object({ ...platformCatalogHeader, tools: z.array(platformCatalogToolSchema.omit({ inputSchema: true })) });
+export const platformCatalogToolDetailSchema = z.object({ ...platformCatalogHeader, tool: platformCatalogToolSchema });

package/dist/schema/platformRoutes.js

@@ -0,0 +1,122 @@
+const TOOL = "[a-z][a-z0-9_]{1,63}";
+const EXECUTION = "[A-Za-z0-9_-]{1,128}";
+const ARTIFACT = "a_[A-Za-z0-9_-]{1,100}";
+const MONITOR = "mon_[A-Za-z0-9_-]{1,100}";
+const CUSTOM_TOOL = "custom__[a-z][a-z0-9_]{1,39}";
+const TEAM_SKILL = "[a-z][a-z0-9_]{1,39}";
+const WORKFLOW = "[a-z][a-z0-9_]{1,39}";
+const WORKFLOW_RUN = "wfr_[A-Za-z0-9_-]{1,100}";
+const TRIGGER = "trg_[A-Za-z0-9_-]{1,100}";
+const MEMBER = "[A-Za-z0-9-]{1,128}";
+export const PLATFORM_ROUTES = {
+    tools: "/v1/tools",
+    connections: "/v1/connections",
+    connectApp: "/v1/connect-app",
+    quote: "/v1/quote",
+    project: "/v1/project",
+    projectStatus: "/v1/project/status",
+    team: "/v1/team",
+    usage: "/v1/usage",
+    executions: "/v1/executions",
+    executionRecovery: "/v1/executions/recover",
+    execution: `/v1/executions/:id{${EXECUTION}}`,
+    executionContext: `/v1/executions/:id{${EXECUTION}}/context`,
+    executionResult: `/v1/executions/:id{${EXECUTION}}/result`,
+    executionCancel: `/v1/executions/:id{${EXECUTION}}/cancel`,
+    artifactDownload: `/v1/executions/:id{${EXECUTION}}/artifacts/:artifact{${ARTIFACT}}/download`,
+    monitors: "/v1/monitors",
+    monitorTools: "/v1/monitors/tools",
+    monitorsPopular: "/v1/monitors/popular",
+    monitorQuote: "/v1/monitors/quote",
+    monitorResume: `/v1/monitors/:id{${MONITOR}}/resume`,
+    monitor: `/v1/monitors/:id{${MONITOR}}`,
+    monitorDelete: `/v1/monitors/:id{${MONITOR}}/delete`,
+    monitorEvents: `/v1/monitors/:id{${MONITOR}}/events`,
+    monitorDestinations: `/v1/monitors/:id{${MONITOR}}/destinations`,
+    monitorDestinationDelete: `/v1/monitors/:id{${MONITOR}}/destinations/:destinationId{dst_[A-Za-z0-9_-]{1,100}}/delete`,
+    monitorRecipients: "/v1/monitor-recipients",
+    monitorFeed: "/v1/monitor-events",
+    customTools: "/v1/custom-tools",
+    customTool: `/v1/custom-tools/:name{${CUSTOM_TOOL}}`,
+    customToolUpdate: `/v1/custom-tools/:name{${CUSTOM_TOOL}}/update`,
+    customToolDelete: `/v1/custom-tools/:name{${CUSTOM_TOOL}}/delete`,
+    customToolVersions: `/v1/custom-tools/:name{${CUSTOM_TOOL}}/versions`,
+    customToolRestore: `/v1/custom-tools/:name{${CUSTOM_TOOL}}/restore`,
+    teamSkills: "/v1/team-skills",
+    teamSkill: `/v1/team-skills/:slug{${TEAM_SKILL}}`,
+    teamSkillUpdate: `/v1/team-skills/:slug{${TEAM_SKILL}}/update`,
+    teamSkillDelete: `/v1/team-skills/:slug{${TEAM_SKILL}}/delete`,
+    teamSkillVersions: `/v1/team-skills/:slug{${TEAM_SKILL}}/versions`,
+    teamSkillRestore: `/v1/team-skills/:slug{${TEAM_SKILL}}/restore`,
+    workflows: "/v1/workflows",
+    workflow: `/v1/workflows/:slug{${WORKFLOW}}`,
+    workflowUpdate: `/v1/workflows/:slug{${WORKFLOW}}/update`,
+    workflowDelete: `/v1/workflows/:slug{${WORKFLOW}}/delete`,
+    workflowVersions: `/v1/workflows/:slug{${WORKFLOW}}/versions`,
+    workflowRuns: `/v1/workflows/:slug{${WORKFLOW}}/runs`,
+    workflowRun: `/v1/workflow-runs/:id{${WORKFLOW_RUN}}`,
+    workflowRunCancel: `/v1/workflow-runs/:id{${WORKFLOW_RUN}}/cancel`,
+    triggers: "/v1/triggers",
+    trigger: `/v1/triggers/:id{${TRIGGER}}`,
+    triggerUpdate: `/v1/triggers/:id{${TRIGGER}}/update`,
+    triggerDelete: `/v1/triggers/:id{${TRIGGER}}/delete`,
+    triggerEvents: `/v1/triggers/:id{${TRIGGER}}/events`,
+    triggerDestinations: `/v1/triggers/:id{${TRIGGER}}/destinations`,
+    triggerDestinationDelete: `/v1/triggers/:id{${TRIGGER}}/destinations/:destinationId{dst_[A-Za-z0-9_-]{1,100}}/delete`,
+    triggerFeed: "/v1/trigger-events",
+    triggerTypes: "/v1/trigger-types",
+    suggestions: "/v1/suggestions",
+    access: "/v1/access",
+    memberAccess: `/v1/access/members/:id{${MEMBER}}/update`,
+    definition: `/tools/definition/:name{${TOOL}}`,
+    tool: `/tools/:tool{${TOOL}}`,
+    discover: "/tools/discover",
+    upload: "/tools/upload",
+    skills: "/tools/skills",
+    metaSearch: "/tools/meta/search",
+    metaSchemas: "/tools/meta/schemas",
+    metaConnections: "/tools/meta/connections",
+    metaExecute: "/tools/meta/execute",
+    metaWorkbench: "/tools/meta/workbench",
+    metaBash: "/tools/meta/bash",
+};
+export const PLATFORM_TRIGGER_INGRESS_ROUTES = {
+    endpoint: "/v1/trigger-ingress/:endpoint{tep_[a-f0-9]{32}}",
+    app: "/v1/trigger-ingress/app/:app{[a-z0-9][a-z0-9_]{0,63}}",
+};
+export const PLATFORM_WALLET_ROUTES = {
+    signIn: "/v1/wallet/sign-in",
+    topUp: "/v1/wallet/top-up",
+};
+export const PLATFORM_META_ROUTES = [PLATFORM_ROUTES.metaSearch, PLATFORM_ROUTES.metaSchemas, PLATFORM_ROUTES.metaConnections,
+    PLATFORM_ROUTES.metaExecute, PLATFORM_ROUTES.metaWorkbench, PLATFORM_ROUTES.metaBash];
+export const PLATFORM_BRIDGE_ROUTES = [
+    PLATFORM_ROUTES.tools, PLATFORM_ROUTES.connections, PLATFORM_ROUTES.quote, PLATFORM_ROUTES.project, PLATFORM_ROUTES.projectStatus, PLATFORM_ROUTES.team, PLATFORM_ROUTES.usage,
+    PLATFORM_ROUTES.executions, PLATFORM_ROUTES.executionRecovery, PLATFORM_ROUTES.execution, PLATFORM_ROUTES.executionContext, PLATFORM_ROUTES.executionResult,
+    PLATFORM_ROUTES.executionCancel, PLATFORM_ROUTES.artifactDownload, PLATFORM_ROUTES.definition, PLATFORM_ROUTES.tool,
+];
+const ALIASED = "(?:project|team|usage|quote|executions|connections)(?:\\/|$)";
+const TOOLS_ALIASES = new RegExp(`^\\/tools\\/${ALIASED}`), V1_ALIASED = new RegExp(`^\\/v1\\/(?=${ALIASED})`);
+export function platformRoutePath(pathname) {
+    if (pathname === "/tools")
+        return PLATFORM_ROUTES.tools;
+    return TOOLS_ALIASES.test(pathname) ? pathname.replace(/^\/tools\//, "/v1/") : pathname;
+}
+const PARAMETER = /:([A-Za-z]+)\{((?:[^{}]|\{[^{}]*\})*)\}/g;
+export function platformToolsPath(route, values = {}) {
+    const path = route === PLATFORM_ROUTES.tools ? "/tools" : route.replace(V1_ALIASED, "/tools/");
+    return path.replace(PARAMETER, (_, name) => values[name] ?? `{${name}}`);
+}
+function routeExpression(pattern) {
+    let source = "", last = 0;
+    for (const match of pattern.matchAll(PARAMETER)) {
+        source += escapeLiteral(pattern.slice(last, match.index)) + `(?:${match[2]})`;
+        last = match.index + match[0].length;
+    }
+    return source + escapeLiteral(pattern.slice(last));
+}
+const escapeLiteral = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const BRIDGE_PATH = new RegExp(`^(?:${PLATFORM_BRIDGE_ROUTES.map(routeExpression).join("|")})$`);
+export function isPlatformBridgePath(pathname) {
+    return BRIDGE_PATH.test(platformRoutePath(pathname));
+}

package/dist/schema/platformSkills.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const PLATFORM_SKILLS_MAX_BYTES = 1_048_576;
+export const PLATFORM_SKILL_MAX_BYTES = 65_536;
+export const platformSkillSchema = z.object({ name: z.string().regex(/^relvo(?:-[a-z0-9]+)*$/).max(64),
+    description: z.string().min(1).max(1000), sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    content: z.string().min(1).max(PLATFORM_SKILL_MAX_BYTES).refine(value => new TextEncoder().encode(value).byteLength <= PLATFORM_SKILL_MAX_BYTES) }).strict();
+export const platformSkillsBundleSchema = z.object({ version: z.string().regex(/^[a-f0-9]{64}$/),
+    skills: z.array(platformSkillSchema).min(1).max(32) }).strict().superRefine((value, context) => {
+    if (new Set(value.skills.map(skill => skill.name)).size !== value.skills.length || new TextEncoder().encode(JSON.stringify(value)).byteLength > PLATFORM_SKILLS_MAX_BYTES)
+        context.addIssue({ code: "custom", message: "Invalid skill bundle" });
+});

package/dist/schema/platformTeamSecretName.js

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export const PLATFORM_TEAM_SECRET_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+export const platformTeamSecretNameSchema = z.string().regex(PLATFORM_TEAM_SECRET_NAME).describe("Letters, digits and underscores, not starting with a digit, e.g. STRIPE_API_KEY.");

package/dist/schema/platformTeamSkillSlug.js

@@ -0,0 +1 @@
+export const PLATFORM_TEAM_SKILL_SLUG = /^[a-z][a-z0-9_]{1,39}$/;