@relvo/mcp 0.1.1 → 0.1.3

package/dist/schema/platformTeamSkills.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { projectScopeSchema } from "./platformPublicExecution.js";
+import { PLATFORM_CUSTOM_TOOL_LIMITS, platformVersionAuthorSchema } from "./platformCustomTools.js";
+export const PLATFORM_TEAM_SKILL_LIMITS = {
+    perProject: 200,
+    versions: 50,
+    titleChars: 80,
+    descriptionChars: 500,
+    contentBytes: 32_768,
+};
+export const PLATFORM_TEAM_SKILL_SLUG = /^[a-z][a-z0-9_]{1,39}$/;
+export const platformTeamSkillSlugSchema = z.string().regex(PLATFORM_TEAM_SKILL_SLUG).describe("Lowercase letters, digits and underscores, starting with a letter.");
+export const platformTeamSkillDefinitionSchema = z.object({
+    title: z.string().trim().min(1).max(PLATFORM_TEAM_SKILL_LIMITS.titleChars),
+    description: z.string().trim().min(1).max(PLATFORM_TEAM_SKILL_LIMITS.descriptionChars).describe("When an agent should follow this skill; agents choose skills by it."),
+    content: z.string().trim().min(1).refine(value => new TextEncoder().encode(value).byteLength <= PLATFORM_TEAM_SKILL_LIMITS.contentBytes, "The content is too long")
+        .describe("Markdown: the steps, the tools to use (by name) and what to check. No secrets."),
+}).strict();
+export const platformTeamSkillCreateSchema = platformTeamSkillDefinitionSchema.extend({ slug: platformTeamSkillSlugSchema }).strict();
+export const platformTeamSkillUpdateSchema = platformTeamSkillDefinitionSchema.extend({ expectedVersion: z.number().int().min(1) }).strict();
+export const platformTeamSkillRestoreSchema = z.object({ version: z.number().int().min(1), expectedVersion: z.number().int().min(1) }).strict();
+export const platformTeamSkillSchema = z.object({ slug: platformTeamSkillSlugSchema, title: z.string(), description: z.string(), content: z.string(),
+    version: z.number().int().min(1), createdAt: z.string(), updatedAt: z.string() });
+export const platformTeamSkillSummarySchema = platformTeamSkillSchema.omit({ content: true });
+export const platformTeamSkillVersionSchema = z.object({ version: z.number().int().min(1), title: z.string(), createdAt: z.string() });
+export const platformSuggestionSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("custom_tool"), occurrences: z.number().int().min(2), lastSeenAt: z.string(),
+        executions: z.array(z.string()).min(1).max(3),
+        code: z.string().min(1).max(PLATFORM_CUSTOM_TOOL_LIMITS.codeChars) }),
+    z.object({ kind: z.literal("skill"), occurrences: z.number().int().min(2), lastSeenAt: z.string(), tools: z.array(z.string()).min(2).max(3) }),
+]);
+export const platformSuggestionsSchema = z.object({ suggestions: z.array(platformSuggestionSchema).max(20), since: z.string() });
+export const platformTeamSkillHistorySchema = platformTeamSkillVersionSchema.extend({ author: platformVersionAuthorSchema });
+export const platformTeamSkillVersionDetailSchema = platformTeamSkillSchema.pick({ title: true, description: true, content: true })
+    .extend({ version: z.number().int().min(1), createdAt: z.string(), author: platformVersionAuthorSchema });
+const skillInput = projectScopeSchema.extend({ slug: platformTeamSkillSlugSchema });
+const skillResult = z.object({ skill: platformTeamSkillSchema }).strict();
+export const platformTeamSkillContracts = {
+    listDeveloperTeamSkills: { input: projectScopeSchema.strict(), output: z.object({ skills: z.array(platformTeamSkillSummarySchema.extend({ canEdit: z.boolean(), canDelete: z.boolean() })),
+            canCreate: z.boolean() }).strict() },
+    getDeveloperTeamSkill: { input: skillInput.strict(), output: skillResult },
+    createDeveloperTeamSkill: { input: projectScopeSchema.extend({ skill: platformTeamSkillCreateSchema }).strict(), output: skillResult },
+    updateDeveloperTeamSkill: { input: skillInput.extend({ skill: platformTeamSkillUpdateSchema }).strict(), output: skillResult },
+    restoreDeveloperTeamSkill: { input: skillInput.merge(platformTeamSkillRestoreSchema).strict(), output: skillResult },
+    deleteDeveloperTeamSkill: { input: skillInput.strict(), output: z.object({ success: z.literal(true) }).strict() },
+    listDeveloperTeamSkillVersions: { input: skillInput.strict(), output: z.object({ versions: z.array(platformTeamSkillHistorySchema) }).strict() },
+    getDeveloperTeamSkillVersion: { input: skillInput.extend({ version: z.number().int().min(1) }).strict(), output: z.object({ version: platformTeamSkillVersionDetailSchema }).strict() },
+    listDeveloperSuggestions: { input: projectScopeSchema.strict(), output: platformSuggestionsSchema },
+};

package/dist/schema/platformToolAccess.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { platformCustomToolNameSchema } from "./platformCustomTools.js";
+const connectionId = z.string().regex(/^[A-Za-z0-9-]{1,64}$/);
+export const platformConnectionGrantSchema = z.templateLiteral(["connection:", connectionId]);
+export const platformConnectionOperationGrantSchema = z.templateLiteral(["connection:", connectionId, "/", z.string().regex(/^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/)]);
+export const memberToolAccessSchema = z.array(z.union([platformCustomToolNameSchema, platformConnectionGrantSchema, platformConnectionOperationGrantSchema])).max(20_000).nullable();
+export const keyToolAccessSchema = memberToolAccessSchema;
+export const platformTeamAccessSchema = z.object({
+    members: z.array(z.object({ memberId: z.string(), email: z.string(), name: z.string().nullable(), role: z.string(), toolAccess: memberToolAccessSchema }).loose()),
+    invitations: z.array(z.object({ id: z.string(), email: z.string(), role: z.string(), expiresAt: z.string(), toolAccess: memberToolAccessSchema }).loose()),
+});
+export const platformMemberAccessUpdateSchema = z.object({ toolAccess: memberToolAccessSchema }).strict();
+export const memberTeamSkillAccessSchema = z.enum(["EDIT", "OWN", "READ"]);

package/dist/schema/platformTriggers.js

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { projectScopeSchema, platformJsonObjectSchema, platformMicrosSchema } from "./platformPublicExecution.js";
+import { platformMonitorDestinationInputSchema, platformMonitorDestinationSchema, platformMonitorRecipientSchema, PLATFORM_MONITOR_DESTINATION_LIMITS } from "./platformMonitors.js";
+import { platformWorkflowSlugSchema } from "./platformWorkflows.js";
+import { PLATFORM_FREE_TOOL_OVERAGE_MICROS } from "./platformBillingConstants.js";
+export const PLATFORM_TRIGGER_LIMITS = {
+    perProject: 50,
+    perTeam: 100,
+    nameChars: 80,
+    eventsPage: 100,
+    eventDataBytes: 65_536,
+    ingressBodyBytes: 1_048_576,
+    retentionDays: 30,
+    keptEvents: 10_000,
+    eventsPerBatch: 100,
+    typesPage: 100,
+};
+export const PLATFORM_TRIGGER_INTERVALS = { "1m": 60, "5m": 300, "15m": 900, "1h": 3_600 };
+export const platformTriggerIntervalSchema = z.enum(["1m", "5m", "15m", "1h"]);
+export const PLATFORM_TRIGGER_DEFAULT_MAXIMUM_CHARGE_MICROS_PER_POLL = PLATFORM_FREE_TOOL_OVERAGE_MICROS;
+export const PLATFORM_TRIGGER_ID = /^trg_[A-Za-z0-9_-]{1,100}$/;
+export const platformTriggerIdSchema = z.string().regex(PLATFORM_TRIGGER_ID);
+export const PLATFORM_TRIGGER_TYPE = /^[a-z0-9][a-z0-9_]{0,63}\.[a-z0-9][a-z0-9_.]{0,79}$/;
+export const platformTriggerTypeIdSchema = z.string().regex(PLATFORM_TRIGGER_TYPE);
+const toolName = z.string().regex(/^[a-z][a-z0-9_]{1,127}$/);
+const connectionId = z.string().min(1).max(128);
+const pointer = z.string().max(200).regex(/^(\/[^/]*)*$/);
+export const platformTriggerDestinationKindSchema = z.enum(["webhook", "slack", "discord", "email", "workflow"]);
+const workflowDestination = z.object({
+    kind: z.literal("workflow"),
+    label: z.string().trim().max(PLATFORM_MONITOR_DESTINATION_LIMITS.labelChars).default(""),
+    workflow: platformWorkflowSlugSchema,
+    input: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,63}$/).default("event").describe("The workflow input that receives the event object."),
+    maximumChargeMicros: platformMicrosSchema,
+}).strict();
+export const platformTriggerDestinationInputSchema = z.union([platformMonitorDestinationInputSchema, workflowDestination]);
+export const platformTriggerDestinationSchema = platformMonitorDestinationSchema.extend({
+    kind: platformTriggerDestinationKindSchema,
+    workflow: z.object({ slug: platformWorkflowSlugSchema, input: z.string(), maximumChargeMicros: platformMicrosSchema }).nullable().default(null),
+});
+const common = {
+    name: z.string().trim().max(PLATFORM_TRIGGER_LIMITS.nameChars).default("").describe("Empty names the trigger after its type or operation."),
+    connectionId: connectionId.describe("The connection of the app, from /tools/connections."),
+    destinations: z.array(platformTriggerDestinationInputSchema).max(PLATFORM_MONITOR_DESTINATION_LIMITS.perMonitor).default([]),
+};
+export const platformTriggerCreateSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("poll"),
+        tool: toolName.describe("A read operation of the connected app, for example github__issues_list_for_repo."),
+        arguments: platformJsonObjectSchema.default({}).describe("The operation's arguments without connectionId."),
+        interval: platformTriggerIntervalSchema.default("5m"),
+        itemsPath: pointer.optional().describe("Where the list of items is in the response body. Omit to use the largest list."),
+        maximumChargeMicrosPerPoll: platformMicrosSchema.default(PLATFORM_TRIGGER_DEFAULT_MAXIMUM_CHARGE_MICROS_PER_POLL),
+        ...common,
+    }).strict(),
+    z.object({
+        kind: z.literal("webhook"),
+        type: platformTriggerTypeIdSchema.describe("A trigger type from /trigger-types, for example github.push."),
+        config: platformJsonObjectSchema.default({}).describe("The type's settings, valid against its configSchema."),
+        ...common,
+    }).strict(),
+]);
+export const platformTriggerUpdateSchema = z.object({
+    enabled: z.boolean().optional(),
+    name: z.string().trim().max(PLATFORM_TRIGGER_LIMITS.nameChars).optional().describe("Empty or omitted keeps the name."),
+}).strict();
+export const platformTriggerStatusSchema = z.enum(["active", "disabled", "failed"]);
+export const platformTriggerSchema = z.object({
+    id: platformTriggerIdSchema,
+    name: z.string(),
+    kind: z.enum(["poll", "webhook"]),
+    app: z.string(),
+    connectionId: z.string(),
+    status: platformTriggerStatusSchema,
+    statusReason: z.string().nullable(),
+    tool: z.string().nullable(),
+    arguments: platformJsonObjectSchema.nullable(),
+    interval: platformTriggerIntervalSchema.nullable(),
+    itemsPath: z.string().nullable(),
+    maximumChargeMicrosPerPoll: platformMicrosSchema.nullable(),
+    type: z.string().nullable(),
+    config: platformJsonObjectSchema.nullable(),
+    apiKeyId: z.string(),
+    lastCheckedAt: z.string().nullable(),
+    lastEventAt: z.string().nullable(),
+    nextCheckAt: z.string().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.string(),
+    destinations: z.array(platformTriggerDestinationSchema),
+});
+export const platformTriggerEventSchema = z.object({
+    id: z.string().regex(/^\d{1,20}$/),
+    triggerId: platformTriggerIdSchema,
+    type: z.string(),
+    key: z.string(),
+    title: z.string(),
+    url: z.string(),
+    data: platformJsonObjectSchema,
+    receivedAt: z.string(),
+});
+export const platformTriggerEventsQuerySchema = z.object({
+    after: z.string().regex(/^\d{1,20}$/).optional(),
+    limit: z.coerce.number().int().min(1).max(PLATFORM_TRIGGER_LIMITS.eventsPage).default(50),
+}).strict();
+export const platformTriggerEventsSchema = z.object({ events: z.array(platformTriggerEventSchema), nextAfter: z.string().nullable() });
+export const platformTriggerTypeSchema = z.object({
+    type: platformTriggerTypeIdSchema,
+    app: z.string(),
+    name: z.string(),
+    description: z.string(),
+    configSchema: platformJsonObjectSchema,
+    setup: z.enum(["automatic", "app"]),
+    available: z.boolean(),
+    unavailableReason: z.string().nullable(),
+});
+export const platformTriggerOperationSchema = z.object({ tool: toolName, app: z.string(), description: z.string(), inputSchema: platformJsonObjectSchema });
+export const platformTriggerTypesQuerySchema = z.object({
+    app: z.string().regex(/^[a-z0-9][a-z0-9_]{0,63}$/),
+    connectionId: z.string().max(128).optional(),
+    query: z.string().trim().max(100).default(""),
+    offset: z.coerce.number().int().min(0).max(100_000).default(0),
+    limit: z.coerce.number().int().min(1).max(PLATFORM_TRIGGER_LIMITS.typesPage).default(50),
+}).strict();
+export const platformTriggerTypesSchema = z.object({
+    types: z.array(platformTriggerTypeSchema),
+    operations: z.array(platformTriggerOperationSchema),
+    total: z.number().int().min(0),
+});
+export const platformTriggerDeliverySchema = z.object({
+    version: z.literal(1),
+    type: z.literal("trigger.event"),
+    deliveryId: z.string(),
+    trigger: z.object({ id: platformTriggerIdSchema, name: z.string(), kind: z.enum(["poll", "webhook"]), app: z.string(), source: z.string(), connectionId: z.string() }).strict(),
+    event: platformTriggerEventSchema.omit({ triggerId: true }),
+}).strict();
+const projectTrigger = projectScopeSchema.extend({ triggerId: platformTriggerIdSchema });
+export const platformTriggerContracts = {
+    listDeveloperTriggers: { input: projectScopeSchema.strict(), output: z.object({ triggers: z.array(platformTriggerSchema) }).strict() },
+    createDeveloperTrigger: { input: projectScopeSchema.extend({ apiKeyId: z.string().min(1).max(128), trigger: platformTriggerCreateSchema }).strict(),
+        output: z.object({ trigger: platformTriggerSchema }).strict() },
+    updateDeveloperTrigger: { input: projectTrigger.merge(platformTriggerUpdateSchema).strict(), output: z.object({ trigger: platformTriggerSchema }).strict() },
+    deleteDeveloperTrigger: { input: projectTrigger.strict(), output: z.object({ success: z.literal(true) }).strict() },
+    listDeveloperTriggerEvents: {
+        input: projectScopeSchema.extend({ triggerId: platformTriggerIdSchema.optional(), after: platformTriggerEventsQuerySchema.shape.after,
+            limit: z.number().int().min(1).max(PLATFORM_TRIGGER_LIMITS.eventsPage).default(50) }).strict(),
+        output: platformTriggerEventsSchema,
+    },
+    listDeveloperTriggerTypes: { input: projectScopeSchema.merge(platformTriggerTypesQuerySchema).strict(), output: platformTriggerTypesSchema },
+    addDeveloperTriggerDestination: { input: projectTrigger.extend({ destination: platformTriggerDestinationInputSchema }).strict(), output: z.object({ trigger: platformTriggerSchema }).strict() },
+    removeDeveloperTriggerDestination: { input: projectTrigger.extend({ destinationId: platformTriggerDestinationSchema.shape.id }).strict(), output: z.object({ trigger: platformTriggerSchema }).strict() },
+    listDeveloperTriggerRecipients: { input: projectScopeSchema.strict(), output: z.object({ recipients: z.array(platformMonitorRecipientSchema) }).strict() },
+};

package/dist/schema/platformWorkflows.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { platformExecutionIdSchema, platformJsonObjectSchema, platformMicrosSchema, platformProviderChoiceSchema, platformToolNameSchema } from "./platformPublicExecution.js";
+import { platformCustomToolInputSchemaSchema } from "./platformCustomTools.js";
+export const PLATFORM_WORKFLOW_LIMITS = {
+    perProject: 50,
+    steps: 20,
+    versions: 50,
+    activeRunsPerProject: 10,
+    titleChars: 80,
+    descriptionChars: 1_000,
+    stepsBytes: 32_768,
+    inputBytes: 16_384,
+};
+export const PLATFORM_WORKFLOW_SLUG = /^[a-z][a-z0-9_]{1,39}$/;
+export const platformWorkflowSlugSchema = z.string().regex(PLATFORM_WORKFLOW_SLUG).describe("Lowercase letters, digits and underscores, starting with a letter.");
+export const platformWorkflowStepIdSchema = z.string().regex(/^[a-z][a-z0-9_]{0,39}$/);
+export const platformWorkflowRunIdSchema = z.string().regex(/^wfr_[A-Za-z0-9_-]{1,100}$/);
+const pointerSchema = z.string().max(500).regex(/^(?:\/(?:[^~/]|~[01])*)*$/, "A JSON Pointer such as /data/companies/0/name");
+const referenceSchema = z.union([z.object({ $input: z.string(), path: z.string().optional() }).strict(), z.object({ $step: z.string(), path: z.string().optional() }).strict()]);
+export function platformWorkflowReference(value) {
+    const parsed = referenceSchema.safeParse(value);
+    if (!parsed.success)
+        return undefined;
+    const path = parsed.data.path ?? "";
+    return "$input" in parsed.data ? { kind: "input", name: parsed.data.$input, path } : { kind: "step", step: parsed.data.$step, path };
+}
+export function platformWorkflowReferences(value) {
+    const reference = platformWorkflowReference(value);
+    if (reference)
+        return [reference];
+    if (Array.isArray(value))
+        return value.flatMap(platformWorkflowReferences);
+    if (value !== null && typeof value === "object")
+        return Object.values(value).flatMap(platformWorkflowReferences);
+    return [];
+}
+export const platformWorkflowStepSchema = z.object({
+    id: platformWorkflowStepIdSchema.describe("Names the step for later steps' references: lowercase letters, digits and underscores."),
+    tool: platformToolNameSchema.describe("A tool of the project's catalog."),
+    arguments: platformJsonObjectSchema.describe("The tool's arguments. Write {\"$input\":\"name\"} for a run input or {\"$step\":\"id\",\"path\":\"/data/0/url\"} for a value of an earlier step's output."),
+    provider: platformProviderChoiceSchema,
+}).strict();
+const byteLength = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+const inputNames = (inputSchema) => {
+    const properties = inputSchema.properties;
+    return new Set(properties !== null && typeof properties === "object" && !Array.isArray(properties) ? Object.keys(properties) : []);
+};
+const definitionShape = {
+    title: z.string().trim().min(1).max(PLATFORM_WORKFLOW_LIMITS.titleChars),
+    description: z.string().trim().min(1).max(PLATFORM_WORKFLOW_LIMITS.descriptionChars).describe("What the workflow does and returns; agents choose workflows by it."),
+    inputSchema: platformCustomToolInputSchemaSchema.describe("JSON Schema of the run inputs, e.g. {\"type\":\"object\",\"properties\":{\"domain\":{\"type\":\"string\"}},\"required\":[\"domain\"]}."),
+    steps: z.array(platformWorkflowStepSchema).min(1).max(PLATFORM_WORKFLOW_LIMITS.steps).describe("Tool calls in the order they run; each starts after the previous one succeeded."),
+};
+function checkDefinition(definition, context) {
+    if (byteLength(definition.steps) > PLATFORM_WORKFLOW_LIMITS.stepsBytes)
+        context.addIssue({ code: "custom", path: ["steps"], message: "The steps are too large" });
+    const inputs = inputNames(definition.inputSchema), earlier = new Set();
+    definition.steps.forEach((step, index) => {
+        if (earlier.has(step.id))
+            context.addIssue({ code: "custom", path: ["steps", index, "id"], message: "Each step id is used once" });
+        for (const reference of platformWorkflowReferences(step.arguments)) {
+            if (!pointerSchema.safeParse(reference.path).success)
+                context.addIssue({ code: "custom", path: ["steps", index, "arguments"], message: `Invalid path ${reference.path}` });
+            else if (reference.kind === "input" && !inputs.has(reference.name))
+                context.addIssue({ code: "custom", path: ["steps", index, "arguments"], message: `No input named ${reference.name}` });
+            else if (reference.kind === "step" && !earlier.has(reference.step))
+                context.addIssue({ code: "custom", path: ["steps", index, "arguments"], message: `No earlier step named ${reference.step}` });
+        }
+        earlier.add(step.id);
+    });
+}
+export const platformWorkflowDefinitionSchema = z.object(definitionShape).strict().superRefine(checkDefinition);
+export const platformWorkflowCreateSchema = z.object({ ...definitionShape, slug: platformWorkflowSlugSchema }).strict().superRefine(checkDefinition);
+export const platformWorkflowUpdateSchema = z.object({ ...definitionShape, expectedVersion: z.number().int().min(1) }).strict().superRefine(checkDefinition);
+export const platformWorkflowSchema = z.object({ slug: platformWorkflowSlugSchema, title: z.string(), description: z.string(), inputSchema: platformJsonObjectSchema,
+    steps: z.array(platformWorkflowStepSchema), version: z.number().int().min(1), createdAt: z.string(), updatedAt: z.string() });
+export const platformWorkflowSummarySchema = platformWorkflowSchema.omit({ inputSchema: true, steps: true });
+export const platformWorkflowVersionSchema = z.object({ version: z.number().int().min(1), title: z.string(), createdAt: z.string() });
+export const platformWorkflowRunCreateSchema = z.object({
+    inputs: platformJsonObjectSchema.default({}).refine(value => byteLength(value) <= PLATFORM_WORKFLOW_LIMITS.inputBytes, "The inputs are too large")
+        .describe("Values for the workflow's input schema."),
+    maximumChargeMicros: platformMicrosSchema.describe("The most the whole run may charge, in micros of USD. A step whose price no longer fits stops the run before it is bought."),
+    version: z.number().int().min(1).optional().describe("Run an earlier kept version; omit for the current one."),
+}).strict();
+export const platformWorkflowRunStatusSchema = z.enum(["running", "succeeded", "failed", "needs_review", "cancelled"]);
+export const platformWorkflowRunStepSchema = z.object({
+    id: platformWorkflowStepIdSchema, tool: platformToolNameSchema,
+    status: z.enum(["pending", "queued", "running", "waiting", "succeeded", "failed", "cancelled", "needs_review"]),
+    executionId: platformExecutionIdSchema.nullable(), chargedMicros: platformMicrosSchema, errorCode: z.string().nullable(),
+}).strict();
+export const platformWorkflowRunSchema = z.object({
+    id: platformWorkflowRunIdSchema, workflow: platformWorkflowSlugSchema, version: z.number().int().min(1), status: platformWorkflowRunStatusSchema,
+    cancelRequested: z.boolean(), errorCode: z.string().nullable(), inputs: platformJsonObjectSchema,
+    maximumChargeMicros: platformMicrosSchema, chargedMicros: platformMicrosSchema, steps: z.array(platformWorkflowRunStepSchema),
+    resultExecutionId: platformExecutionIdSchema.nullable(),
+    createdAt: z.string(), updatedAt: z.string(), completedAt: z.string().nullable(),
+}).strict();
+export const platformWorkflowRunSummarySchema = platformWorkflowRunSchema.omit({ inputs: true, steps: true });
+export const platformWorkflowRunListQuerySchema = z.object({ before: platformWorkflowRunIdSchema.optional(), limit: z.coerce.number().int().min(1).max(50).default(20) }).strict();
+export const platformWorkflowRunListSchema = z.object({ runs: z.array(platformWorkflowRunSummarySchema), nextBefore: platformWorkflowRunIdSchema.nullable() }).strict();

package/dist/schema/scheduleTimeZone.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function isScheduleTimeZone(value) {
+    if (!/^[A-Za-z][A-Za-z0-9_+-]*(\/[A-Za-z0-9_+-]+)*$/.test(value))
+        return false;
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: value });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const ScheduleTimeZone = z.string().max(64)
+    .refine(isScheduleTimeZone, "Invalid time zone (must be an IANA tz-database name).")
+    .transform(value => new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone);

package/dist/schema/toolDiscovery.js

@@ -1,26 +1,64 @@
 import { z } from "zod";
-import { platformCatalogSchema } from "./platformPublicExecution.js";
+import { platformCatalogSchema, platformMicrosSchema, platformQuoteSchema, platformRequestIntentSchema, platformToolInputSchema, platformToolNameSchema, validatePlatformArgumentIdentifiers } from "./platformPublicExecution.js";
 export const MAX_DISCOVERED_TOOLS = 16;
 export const SINGLE_QUERY_TOOL_LIMIT = 12;
 export const TOOL_DISCOVERY_CONTEXT_MAX_BYTES = 24_000;
 export const TOOL_DISCOVERY_REQUEST_TIMEOUT_MS = 60_000;
+export const TOOL_DISCOVERY_FILTER_MAX_VALUES = 32;
+export const TOOL_DISCOVERY_APP_MAX_CHARS = 120;
+const scopeFilterSchema = z.object({
+    tools: z.array(platformToolNameSchema).max(TOOL_DISCOVERY_FILTER_MAX_VALUES).default([]),
+    providers: z.array(z.string().regex(/^[a-z][a-z0-9_]{1,63}$/)).max(TOOL_DISCOVERY_FILTER_MAX_VALUES).default([]),
+    categories: z.array(platformCatalogSchema.shape.tools.element.shape.category).max(TOOL_DISCOVERY_FILTER_MAX_VALUES).default([]),
+}).strict();
 export const toolDiscoveryInputSchema = z.object({
-    query: z.string().trim().min(1).max(512).optional().describe("Describe needed capabilities in natural language, or give an exact tool/model name. Omit account names, record IDs and private content."),
-    category: platformCatalogSchema.shape.tools.element.shape.category.optional(),
-    provider: z.string().regex(/^[a-z][a-z0-9_]{1,63}$/).optional().describe("Filter provider metadata; does not select an execution provider."),
+    intent: platformRequestIntentSchema,
+    query: z.string().trim().max(512).transform(value => value || undefined).optional()
+        .describe("Short English words for one capability (e.g. list open pull requests), preserving the requested action and resource, or an exact tool/model name. Put the connected service in app. Empty means browse. Omit private content."),
+    app: z.string().trim().max(TOOL_DISCOVERY_APP_MAX_CHARS).transform(value => value || undefined).optional()
+        .describe("Connected app name/ID, e.g. GitHub: search its indexed API operations only. Unknown/ambiguous or unindexed apps return explicitly unscoped results. Omit or use empty for public-data targets and known tool IDs. Discovery only; does not pin execution."),
+    category: z.union([z.literal("all"), z.literal(""), platformCatalogSchema.shape.tools.element.shape.category])
+        .transform(value => value === "all" || value === "" ? undefined : value).optional().describe("all or empty means any category."),
+    provider: z.string().trim().regex(/^(?:[a-z][a-z0-9_]{1,63})?$/).transform(value => value || undefined).optional()
+        .describe("Filter provider metadata; empty means any provider. Does not pin execution."),
+    maxChargeMicros: platformMicrosSchema.nullable().optional()
+        .describe("Max quoted USD micros per call (1 USD=1000000). 0=free; null/omitted=no cap. Excludes unknown/external costs. Requote actual execution."),
+    quoteArguments: platformToolInputSchema.shape.arguments.nullable().optional()
+        .describe("Arguments to quote each candidate; null/omitted uses its catalog example. Never include secrets."),
+    funding: z.enum(["all", "relvo", "provider", "mixed"]).transform(value => value === "all" ? undefined : value).optional()
+        .describe("Filter who bills the call; all/omitted means any. Provider/mixed can incur external charges."),
+    priceUnit: z.string().trim().max(100).transform(value => value === "all" || value === "" ? undefined : value).optional()
+        .describe("Exact catalog price unit, e.g. request or second; all/empty means any. Unit price is not a call quote."),
+    sortBy: z.enum(["relevance", "price_asc"]).optional().describe("Relevance by default; price_asc uses call quotes, with unknown prices last."),
+    include: scopeFilterSchema.nullable().optional().describe("Match exact tools/providers/categories. OR within each list, AND across lists; empty/null means any. Discovery only."),
+    exclude: scopeFilterSchema.nullable().optional().describe("Remove exact tools, categories, or any tool listing an excluded provider. Exclusion wins; empty/null excludes nothing. Does not pin execution."),
     availableOnly: z.boolean().default(true),
-    summary: z.boolean().default(true).describe("Omit schemas and examples; inspect one selected tool when needed."),
+    summary: z.boolean().default(true).describe("Summaries for comparing candidates. false requests schemas/examples; oversized definitions are omitted and remain inspectable."),
     limit: z.number().int().min(1).max(SINGLE_QUERY_TOOL_LIMIT).default(8),
     mode: z.enum(["auto", "keyword", "semantic"]).default("auto"),
-}).strict();
+}).strict().superRefine((value, context) => {
+    if (value.quoteArguments == null)
+        return;
+    const named = value.include?.tools.length ? value.include.tools.length === 1 ? value.include.tools[0] : undefined
+        : platformToolNameSchema.safeParse(value.query).data;
+    validatePlatformArgumentIdentifiers(named, value.quoteArguments, context, "quoteArguments");
+});
 const toolSummary = platformCatalogSchema.shape.tools.element.omit({ inputSchema: true, example: true }).extend({
+    discoveryQuote: platformQuoteSchema.extend({ basis: z.enum(["arguments", "example"]) }).optional(),
     inputSchema: platformCatalogSchema.shape.tools.element.shape.inputSchema.optional(),
     example: platformCatalogSchema.shape.tools.element.shape.example.optional(),
     models: z.array(platformCatalogSchema.shape.tools.element.shape.models.unwrap().element.omit({ example: true }).extend({
         example: platformCatalogSchema.shape.tools.element.shape.example.optional(),
     })).optional(),
 });
+export const PLATFORM_CONNECTABLE_APPS_MAX = 3;
+export const platformConnectableAppsSchema = z.object({
+    instruction: z.string(),
+    apps: z.array(z.object({ app: z.string(), name: z.string(), status: z.enum(["not_connected", "reauth_required"]), connectUrl: z.url() }))
+        .min(1).max(PLATFORM_CONNECTABLE_APPS_MAX),
+});
 export const toolDiscoveryResultSchema = platformCatalogSchema.extend({ tools: z.array(toolSummary),
     discovery: z.object({ mode: z.enum(["browse", "keyword", "semantic"]), candidateCount: z.number().int().nonnegative(), returnedCount: z.number().int().nonnegative(),
         truncated: z.boolean(), warning: z.string().optional() }),
+    connectableApps: platformConnectableAppsSchema.optional(),
 });

package/dist/schema/toolInputRepair.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+const isNode = (value) => typeof value === "object" && value !== null;
+const OMITTED = Symbol("omitted");
+const jsonStructure = (text) => {
+    if (!/^\s*[[{]/.test(text))
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+function evidentValue(issue, sent) {
+    if (sent === null || sent === "")
+        return OMITTED;
+    if (issue.code === "invalid_type") {
+        if (typeof sent === "string" && issue.expected === "boolean")
+            return sent.toLowerCase() === "true" ? true : sent.toLowerCase() === "false" ? false : undefined;
+        if (typeof sent === "number" && issue.expected === "boolean")
+            return sent === 1 ? true : sent === 0 ? false : undefined;
+        if (typeof sent === "string" && (issue.expected === "number" || issue.expected === "int"))
+            return /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(sent) ? Number(sent) : undefined;
+        const structure = typeof sent === "string" ? jsonStructure(sent) : undefined;
+        if (issue.expected === "array" && Array.isArray(structure))
+            return structure;
+        if ((issue.expected === "object" || issue.expected === "record") && isNode(structure) && !Array.isArray(structure))
+            return structure;
+        if (issue.expected === "array" && structure === undefined && ["string", "number", "boolean"].includes(typeof sent) && !String(sent).includes(","))
+            return [sent];
+        if (issue.expected === "array" && isNode(sent) && !Array.isArray(sent))
+            return [sent];
+    }
+    if (issue.code === "invalid_format" && (issue.format === "url" || issue.format === "regex" && /^\^https\??:\/\//.test((issue.pattern ?? "").replace(/^\//, "").replaceAll("\\/", "/")))
+        && typeof sent === "string" && /^[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::\d+)?(?:[/?#]\S*)?$/i.test(sent))
+        return `https://${sent}`;
+    if (issue.code === "invalid_value" && typeof sent === "string") {
+        const options = issue.values.filter(value => ["string", "number", "boolean"].includes(typeof value));
+        for (const form of [(text) => text.toLowerCase(), (text) => text.toLowerCase().replace(/[\s_-]/g, "")]) {
+            const matches = options.filter(value => form(String(value)) === form(sent));
+            if (matches.length)
+                return matches.length === 1 ? matches[0] : undefined;
+        }
+    }
+    return undefined;
+}
+const valueAt = (root, path) => path.reduce((node, step) => isNode(node) && typeof step !== "symbol" ? node[String(step)] : undefined, root);
+function repairableIssues(issues, input) {
+    return issues.flatMap(issue => issue.code !== "invalid_union" ? [issue] : issue.errors
+        .map(option => repairableIssues(option.map(inner => ({ ...inner, path: [...issue.path, ...inner.path] })), input))
+        .find(option => option.length > 0 && option.every(inner => evidentValue(inner, valueAt(input, inner.path)) !== undefined)) ?? []);
+}
+function repaired(input, issues) {
+    const target = structuredClone(input), changes = [];
+    for (const issue of issues) {
+        const last = issue.path.at(-1), node = valueAt(target, issue.path.slice(0, -1));
+        if (last === undefined || typeof last === "symbol" || !isNode(node))
+            continue;
+        const key = String(last), sent = node[key], value = evidentValue(issue, sent);
+        if (value === undefined || value === OMITTED && Array.isArray(node))
+            continue;
+        if (value === OMITTED)
+            delete node[key];
+        else
+            node[key] = value;
+        changes.push({ path: issue.path, node, key, sent });
+    }
+    return { target, changes };
+}
+function unionOptions(schema) {
+    const source = schema instanceof z.ZodPipe ? schema.in : schema;
+    return source instanceof z.ZodUnion ? source.options.filter((option) => option instanceof z.ZodType) : [];
+}
+function repairPass(schema, input) {
+    const parsed = schema.safeParse(input);
+    if (parsed.success)
+        return input;
+    const { target, changes } = repaired(input, repairableIssues(parsed.error.issues, input));
+    const checked = schema.safeParse(target);
+    if (checked.success)
+        return target;
+    for (const option of unionOptions(schema)) {
+        const repairedOption = withEvidentValues(option, input);
+        if (repairedOption !== input && schema.safeParse(repairedOption).success)
+            return repairedOption;
+    }
+    const evident = (issue) => {
+        const inner = repairableIssues([issue], target);
+        return inner.length > 0 && inner.every(item => evidentValue(item, valueAt(target, item.path)) !== undefined);
+    };
+    const kept = changes.filter(change => {
+        const refused = checked.error.issues.some(issue => change.path.every((step, index) => issue.path[index] === step)
+            && (issue.path.length <= change.path.length || !evident(issue)));
+        if (refused)
+            change.node[change.key] = change.sent;
+        return !refused;
+    });
+    return kept.length ? target : input;
+}
+const REPAIR_PASSES = 32;
+export function withEvidentValues(schema, input) {
+    let current = input;
+    for (let pass = 0; pass < REPAIR_PASSES; pass++) {
+        const next = repairPass(schema, current);
+        if (next === current)
+            break;
+        current = next;
+    }
+    return current;
+}

package/dist/schema/toolResultContext.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
 export const TOOL_RESULT_CONTEXT_MAX_BYTES = 24_000;
-export const TOOL_RESULT_PAGE_MAX_ITEMS = 100;
+export const TOOL_RESULT_PAGE_MAX_ITEMS = 1_000;
 export const TOOL_RESULT_PAGE_MAX_CHARS = 8_000;
+export const TOOL_RESULT_PAGE_MAX_FIELDS = 16;
 export const toolResultSelectionSchema = z.object({
     path: z.array(z.string().max(256)).max(16).default([]).describe("Object keys / array indices, starting at the stored output. Example: [\"results\", \"0\", \"data\"]."),
     offset: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).default(0),
     limit: z.number().int().min(1).max(TOOL_RESULT_PAGE_MAX_ITEMS).default(20),
     maxChars: z.number().int().min(1).max(TOOL_RESULT_PAGE_MAX_CHARS).default(4_000),
+    fields: z.array(z.string().max(256)).max(TOOL_RESULT_PAGE_MAX_FIELDS).optional()
+        .describe("Top-level keys to keep from one object or each object in an array page. Object offsets page the selected keys. Empty keeps every field. Full stored data is unchanged."),
 }).strict();
 export const toolResultContextSchema = z.object({
     offloaded: z.boolean(), totalBytes: z.number().int().nonnegative(), preview: z.json(),
@@ -17,3 +20,32 @@ export const toolResultPageSchema = z.object({
     offset: z.number().int().nonnegative(), total: z.number().int().nonnegative(), nextOffset: z.number().int().nonnegative().nullable(),
     context: toolResultContextSchema,
 });
+export function fitToolResultPage(page, fits) {
+    if (page.context.offloaded || fits(page))
+        return page;
+    const original = page.context.preview;
+    const entries = original !== null && typeof original === "object" && !Array.isArray(original) ? Object.entries(original) : null;
+    const length = typeof original === "string" || Array.isArray(original) ? original.length : entries?.length ?? 0;
+    if (!length)
+        return page;
+    const prefix = (count) => {
+        let end = count;
+        if (typeof original === "string" && end < original.length && /[\uD800-\uDBFF]/.test(original[end - 1] ?? "") && /[\uDC00-\uDFFF]/.test(original[end] ?? ""))
+            end++;
+        const preview = typeof original === "string" || Array.isArray(original) ? original.slice(0, end) : Object.fromEntries(entries?.slice(0, end) ?? []);
+        const next = page.offset + end;
+        return { ...page, nextOffset: next < page.total ? next : null,
+            context: { ...page.context, totalBytes: new TextEncoder().encode(JSON.stringify(preview)).byteLength, preview } };
+    };
+    let lower = 1, upper = length, best;
+    while (lower <= upper) {
+        const count = Math.floor((lower + upper) / 2), candidate = prefix(count);
+        if (fits(candidate)) {
+            best = candidate;
+            lower = count + 1;
+        }
+        else
+            upper = count - 1;
+    }
+    return best ?? page;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relvo/mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Relvo stdio MCP server for research, SEO, social data and media generation.",
   "type": "module",
   "bin": {

package/dist/schema/amazonAds.js

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export const amazonAdsRegionSchema = z.enum(["na", "eu", "fe"]);
-export const amazonAdsProfileIdSchema = z.string().regex(/^[1-9][0-9]{0,18}$/)
-    .pipe(z.string().refine(value => BigInt(value) <= 9223372036854775807n));
-export const amazonAdsProfileResourceIdSchema = z.string().regex(/^(?:na|eu|fe):[1-9][0-9]{0,18}$/)
-    .pipe(z.string().refine(value => BigInt(value.slice(3)) <= 9223372036854775807n));
-export function amazonAdsProfileResourceId(region, profileId) {
-    return amazonAdsProfileResourceIdSchema.parse(`${region}:${profileId}`);
-}
-export function parseAmazonAdsProfileResourceId(input) {
-    const [region, profileId] = amazonAdsProfileResourceIdSchema.parse(input).split(":");
-    return z.object({ region: amazonAdsRegionSchema, profileId: amazonAdsProfileIdSchema }).parse({ region, profileId });
-}