@relvo/mcp 0.1.2 → 0.1.4

package/dist/mcp/server.js

@@ -1,26 +1,41 @@
 import { McpServer } from "@modelcontextprotocol/server";
-import { fitToolResultPage, executionReceiptContext, executionPageContext, hasRelvoEnvironment, relvoEnvironmentValue, platformToolInputSchema, platformCreateExecutionSchema, platformExecutionIdSchema, platformArtifactIdSchema, platformExecutionListQuerySchema, toolDiscoveryInputSchema, platformSkillSchema, toolResultSelectionSchema, platformConnectionCatalogQuerySchema } from "../client/index.js";
+import { fitToolResultPage, executionReceiptContext, executionPageContext, hasRelvoEnvironment, platformQuoteRequestSchema, platformCreateExecutionSchema, platformExecutionIdSchema, platformArtifactIdSchema, platformExecutionListQuerySchema, toolDiscoveryInputSchema, platformSkillSchema, toolResultSelectionSchema, platformConnectionCatalogQuerySchema, platformMonitorCreateSchema, platformMonitorEventsQuerySchema, platformMonitorQuoteSchema, platformMonitorResumeSchema, PLATFORM_MONITOR_ID, platformCustomEndpointDefinitionSchema, platformCustomToolSlugSchema, platformCustomToolDefinitionSchema, platformCustomToolRestoreSchema, platformTeamSkillCreateSchema, platformTeamSkillDefinitionSchema, platformTeamSkillRestoreSchema, platformTeamSkillUpdateSchema } from "../client/index.js";
+import { platformWorkflowDefinitionSchema, platformWorkflowRunCreateSchema, platformWorkflowRunIdSchema, platformWorkflowRunListQuerySchema, platformWorkflowSlugSchema, platformWorkflowStepSchema } from "../client/index.js";
+import { platformTriggerCreateSchema, platformTriggerDestinationInputSchema, platformTriggerEventsQuerySchema, platformTriggerIdSchema, platformTriggerIntervalSchema, platformTriggerTypesQuerySchema, platformTriggerUpdateSchema } from "../client/index.js";
 import { z } from "zod";
 import { uploadAuthorizedFile } from "./local-upload.js";
 import { platformMetaSearchSchema, platformMetaSchemasSchema, platformMetaConnectionsSchema, platformMetaExecuteSchema, platformMetaWorkbenchSchema, platformMetaBashSchema } from "../client/index.js";
 import { boundedMcpResult, inspectJsonContext, mcpContextFits, MCP_RESULT_MAX_BYTES } from "./context.js";
+import { forHosts } from "./host-schema.js";
 import { RELVO_MCP_INSTRUCTIONS } from "./instructions.js";
+import { PLATFORM_MCP_VERSION } from "./version.js";
+import { PlatformOperations } from "./operations.js";
 const projectionOptions = { maximumBytes: Math.floor(MCP_RESULT_MAX_BYTES / 4), readWith: "platform_result" };
 const jsonObject = z.record(z.string(), z.json());
 const inspectInput = { ...toolResultSelectionSchema.omit({ fields: true }).shape,
     path: toolResultSelectionSchema.shape.path.describe("Own JSON keys in the definition or guide, e.g. [\"inputSchema\",\"properties\"]. Follow entry paths for omitted subtrees.") };
 const summary = (tool) => {
     const { inputSchema: _schema, example: _example, models: _models, ...metadata } = tool;
-    return metadata;
+    return { ...metadata, description: tool.description.split("\n")[0] };
 };
-export function createPlatformMcp(client, version = "0.1.2", localFilesystem = false, managedProfile = false) {
+export function compactToolDiscovery(value, fits) {
+    const tools = value.data.tools.map(summary);
+    const response = () => ({ data: { ...value.data, tools, discovery: { ...value.data.discovery, returnedCount: tools.length, truncated: true } } });
+    while (tools.length && !fits(response()))
+        tools.pop();
+    return response();
+}
+export function createPlatformMcp(client, version = PLATFORM_MCP_VERSION, localFilesystem = false, managedProfile = false) {
+    const server = new McpServer({ name: "relvo", version }, { instructions: RELVO_MCP_INSTRUCTIONS });
+    createPlatformOperations(client, localFilesystem, managedProfile).attach(server);
+    return server;
+}
+export function createPlatformOperations(client, localFilesystem = false, managedProfile = false) {
     const relvoCredentials = managedProfile || hasRelvoEnvironment(process.env);
-    const uploadRoots = relvoEnvironmentValue(process.env, "RELVO_MCP_ALLOWED_UPLOAD_ROOTS") ?? (relvoCredentials ? undefined : process.env.NOIMOS_MCP_ALLOWED_UPLOAD_ROOTS);
-    const server = new McpServer({ name: "relvo", version }, {
-        instructions: RELVO_MCP_INSTRUCTIONS,
-    });
-    server.registerTool("platform_search_tools", { description: "Search up to four independent capabilities and open/continue a project tool session. Retain session.id for batches or remote processing. Free; omit private data from queries.",
-        inputSchema: platformMetaSearchSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: false } }, input => respond(() => client.searchMetaTools(input), undefined, (value, fits) => {
+    const uploadRoots = process.env.RELVO_MCP_ALLOWED_UPLOAD_ROOTS ?? (relvoCredentials ? undefined : process.env.NOIMOS_MCP_ALLOWED_UPLOAD_ROOTS);
+    const server = new PlatformOperations();
+    server.registerTool("platform_search_tools", { description: "Search up to four independent capabilities and open/continue a project tool session. Retain session.id for batches or remote processing. Each query counts toward the team's monthly free calls, then is charged; omit private data from queries.",
+        inputSchema: forHosts(platformMetaSearchSchema), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: false } }, input => respond(() => client.searchMetaTools(input), undefined, (value, fits) => {
         const results = value.data.results.map(result => ({ ...result, tools: result.tools.slice(0, 0) }));
         const response = () => ({ data: { ...value.data, results: results.map((result, index) => ({ ...result,
                     discovery: { ...result.discovery, returnedCount: result.tools.length, truncated: result.discovery.truncated || result.tools.length < value.data.results[index].tools.length } })) } });
@@ -37,7 +52,7 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
         return response();
     }));
     server.registerTool("platform_get_tool_schemas", { description: "Read selected schemas, examples and prices in a session. Inspect remaining names with platform_tool; large definitions provide exact paths/pages. Free.",
-        inputSchema: platformMetaSchemasSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.getToolSchemas(input), undefined, (value, fits) => {
+        inputSchema: forHosts(platformMetaSchemasSchema), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.getToolSchemas(input), undefined, (value, fits) => {
         const data = { ...value.data, tools: [...value.data.tools], remaining: [...value.data.remaining] };
         while (data.tools.length && !fits({ data })) {
             const tool = data.tools.pop();
@@ -47,14 +62,14 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
         return { data };
     }));
     server.registerTool("platform_manage_connections", { description: "Check OAuth accounts required by a selected tool. Reuse the intended connected account; request console consent only for a missing/expired connection. Free read; no account changes.",
-        inputSchema: platformMetaConnectionsSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, input => respond(() => client.manageConnections(input), undefined, (value, fits) => {
+        inputSchema: forHosts(platformMetaConnectionsSchema), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, input => respond(() => client.manageConnections(input), undefined, (value, fits) => {
         const data = { ...value.data, connections: [...value.data.connections] };
         while (data.connections.length && !fits({ data }))
             data.connections.pop();
         return { data };
     }));
     server.registerTool("platform_multi_execute", { description: "Submit independent quoted calls within an accepted total cap. Save the complete request and per-item keys first. Read every admission even on error; wait for accepted IDs. Compact receipts use index to identify original calls. Dependencies require a later batch.",
-        inputSchema: platformMetaExecuteSchema, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, async (input) => {
+        inputSchema: forHosts(platformMetaExecuteSchema), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, async (input) => {
         let allAccepted = false;
         const result = await respond(async () => { const value = await client.multiExecute(input); allAccepted = value.data.allAccepted; return value; }, undefined, (value, fits) => {
             const data = { ...value.data, results: value.data.results.map(({ tool: _tool, idempotencyKey: _key, ...receipt }) => receipt),
@@ -68,10 +83,10 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
         return allAccepted ? result : { ...result, isError: true };
     });
     server.registerTool("platform_remote_workbench", { description: "Submit a quoted Python cell to this session's remote sandbox. Stage full prior outputs with sourceExecutionIds. Wait for success and a ready session before the next cell. Files/checkpointable variables persist; no credentials or authenticated tool proxy.",
-        inputSchema: platformMetaWorkbenchSchema, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, input => respond(() => client.remoteWorkbench(input), "platform_remote_workbench", value => ({ data: { ...value.data,
+        inputSchema: forHosts(platformMetaWorkbenchSchema), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, input => respond(() => client.remoteWorkbench(input), "platform_remote_workbench", value => ({ data: { ...value.data,
             execution: executionReceiptContext({ data: value.data.execution }, projectionOptions).data } })));
     server.registerTool("platform_remote_bash", { description: "Submit a quoted remote Bash cell. Shares files with Python and retains its own checkpointed shell state. Wait for success and a ready session before another cell. Deployment controls network; never runs on the user's machine.",
-        inputSchema: platformMetaBashSchema, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, input => respond(() => client.remoteBash(input), "platform_remote_bash", value => ({ data: { ...value.data,
+        inputSchema: forHosts(platformMetaBashSchema), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, input => respond(() => client.remoteBash(input), "platform_remote_bash", value => ({ data: { ...value.data,
             execution: executionReceiptContext({ data: value.data.execution }, projectionOptions).data } })));
     const respond = async (operation, untrustedTool, compact) => {
         try {
@@ -84,20 +99,162 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
     if (localFilesystem)
         server.registerTool("platform_upload_file", {
             description: "Upload an authorized media file under configured RELVO_MCP_ALLOWED_UPLOAD_ROOTS, up to 12 MiB. A request to use that exact file authorizes upload. Never upload credentials/configs or broaden roots. Returns data.id for documented fileId inputs.",
-            inputSchema: z.object({ path: z.string().min(1).max(4096), confirmedByUser: z.literal(true).describe("True only when the user has authorized uploading this exact file.") }).strict(),
+            inputSchema: forHosts(z.object({ path: z.string().min(1).max(4096), confirmedByUser: z.literal(true).describe("True only when the user has authorized uploading this exact file.") }).strict()),
             annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true, idempotentHint: true },
         }, ({ path }) => respond(() => uploadAuthorizedFile(client, path, uploadRoots)));
     for (const [name, description, operation] of [
         ["platform_project", "Read the developer organization and project bound to this API key.", () => client.project()],
         ["platform_usage", "Read this developer project's current monthly requests and spend in USD.", () => client.usage()],
     ]) {
-        server.registerTool(name, { description, inputSchema: z.object({}), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, async () => {
+        server.registerTool(name, { description, inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, async () => {
             return respond(async () => operation());
         });
     }
+    const monitorId = z.string().regex(PLATFORM_MONITOR_ID);
+    server.registerTool("platform_monitors", { description: "List this project's monitors: saved tool calls Relvo re-runs on a schedule and diffs. Shows subscribers, price (chargeCeilingMicros per run, charged to every subscriber in full; members), status (suspended when a run could not be paid or its price rose above the accepted maximum), last check/change and last error. Free.",
+        inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.monitors()));
+    server.registerTool("platform_monitor_quote", { description: "Price a monitor before creating it. A run costs what one execution of the tool costs (at most chargeCeilingMicros) and every project watching the target pays that in full; they only share the fetch. Only tools whose execution is priced 0 cost 0. Free.",
+        inputSchema: forHosts(z.object({ ...platformMonitorQuoteSchema.shape, arguments: z.record(z.string(), z.unknown()).default({}).describe("The tool's arguments, exactly as for platform_execute.") }).strict()),
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.quoteMonitor(platformMonitorQuoteSchema.parse(input))));
+    server.registerTool("platform_monitor_create", { description: "Watch a tool for changes. platform_monitor_tools lists monitorable tools and the provider to pin. A monitor charges this project the full price of every run from the balance until deleted (0 only for tools priced 0): quote it, get the user's approval of that recurring price, and pass maximumChargeMicrosPerRun of at least the quote's chargeCeilingMicros. The first run is a baseline with no events; later runs report only new items (list results) or changed fields (single results). Identical monitors are shared and idempotent.",
+        inputSchema: forHosts(z.object({ ...platformMonitorCreateSchema.shape, arguments: z.record(z.string(), z.unknown()).default({}).describe("The tool's arguments, exactly as for platform_execute.") }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, input => respond(async () => client.createMonitor(platformMonitorCreateSchema.parse(input))));
+    server.registerTool("platform_monitor_resume", { description: "Resume a suspended monitor from now on; events detected while suspended stay hidden. Pass maximumChargeMicrosPerRun to accept a higher price, with the user's approval.",
+        inputSchema: forHosts(z.object({ id: monitorId, ...platformMonitorResumeSchema.shape }).strict()), annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, ({ id, ...input }) => respond(() => client.resumeMonitor(id, input)));
+    server.registerTool("platform_monitor_delete", { description: "Stop one monitor of this project. Its events and other projects' monitors are unaffected. Free.",
+        inputSchema: forHosts(z.object({ id: monitorId }).strict()), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: true } }, ({ id }) => respond(() => client.deleteMonitor(id)));
+    server.registerTool("platform_monitor_events", { description: "Read what changed: events oldest first. Omit monitorId for every monitor. Pass the returned nextAfter as after to read only newer events. Without after, returns the latest events. Free.",
+        inputSchema: forHosts(platformMonitorEventsQuerySchema.extend({ monitorId: monitorId.optional() }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.monitorEvents(input)));
+    server.registerTool("platform_monitors_popular", { description: "Monitors that at least 3 organizations already watch (tool, provider, arguments, interval, organizations, chargeCeilingMicros). Joining one shares its fetch but you pay the full price per run. Copy one to platform_monitor_quote. Free.",
+        inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.popularMonitors()));
+    server.registerTool("platform_monitor_tools", { description: "Tools that can be monitored, with the provider to pin (empty when none) and chargeCeilingMicros, the most one run of the tool's example costs in total (0 = free). Narrow with query or freeOnly and follow nextOffset. Free.",
+        inputSchema: forHosts(z.object({
+            query: z.string().trim().max(100).optional().describe("Part of a tool name to keep; empty means every tool."),
+            freeOnly: z.boolean().default(false).describe("Keep only tools a monitor runs for free (chargeCeilingMicros 0)."),
+            offset: z.number().int().min(0).default(0),
+            limit: z.number().int().min(1).max(200).default(100),
+        }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ query, freeOnly, offset, limit }) => respond(async () => {
+        const needle = query?.toLowerCase() ?? "";
+        const matching = (await client.monitorableTools()).data.tools.filter(tool => tool.name.includes(needle) && (!freeOnly || tool.chargeCeilingMicros === 0));
+        const tools = matching.slice(offset, offset + limit);
+        return { data: { tools, total: matching.length, nextOffset: offset + tools.length < matching.length ? offset + tools.length : null } };
+    }, undefined, (value, fits) => {
+        const tools = [...value.data.tools];
+        const page = () => ({ data: { tools, total: value.data.total, nextOffset: offset + tools.length < value.data.total ? offset + tools.length : null } });
+        while (tools.length && !fits(page()))
+            tools.pop();
+        return page();
+    }));
+    const customToolName = z.string().max(64).describe("The tool's name, custom__<slug> (the slug alone works too).");
+    const customToolDefinition = z.object({ ...platformCustomToolDefinitionSchema.shape,
+        inputSchema: z.record(z.string(), z.unknown()).describe(platformCustomToolDefinitionSchema.shape.inputSchema.description ?? "JSON Schema of the input object.") });
+    const definitionOf = (input) => platformCustomToolDefinitionSchema.parse(input);
+    server.registerTool("platform_custom_tools", { description: "List this project's custom tools: the team's own Python tools, each listed in the catalog as custom__<slug> and run like any tool (quote and execute). Free.",
+        inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.customTools()));
+    server.registerTool("platform_custom_tool", { description: "Read one custom tool's input schema, Python code and version, before running or editing it. Free.",
+        inputSchema: forHosts(z.object({ name: customToolName }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ name }) => respond(() => client.customTool(name)));
+    server.registerTool("platform_custom_tool_create", { description: "Add a tool for the whole team: Python that Relvo runs in its isolated sandbox with the validated input as the dict `input`; print the result. It is listed as custom__<slug> and billed like run_python. Save a step the team repeats as a tool. No credentials exist in the sandbox: to use connected data, run that tool first and pass its execution in sourceExecutionIds.",
+        inputSchema: forHosts(customToolDefinition.extend({ slug: platformCustomToolSlugSchema }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false, idempotentHint: false } }, ({ slug, ...input }) => respond(() => client.createCustomTool({ slug, ...definitionOf(input) })));
+    server.registerTool("platform_custom_tool_update", { description: "Replace a custom tool's whole definition. Read it first and pass its version as expectedVersion; an edit made since is refused instead of lost. Every version is kept and can be restored. Only its creator or an admin may change it.",
+        inputSchema: forHosts(customToolDefinition.extend({ name: customToolName, expectedVersion: z.number().int().min(1) }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: false } }, ({ name, expectedVersion, ...input }) => respond(() => client.updateCustomTool(name, { ...definitionOf(input), expectedVersion })));
+    const endpointDefinition = platformCustomEndpointDefinitionSchema.omit({ kind: true });
+    server.registerTool("platform_custom_endpoint_create", { description: "Register an API endpoint for the whole team as custom__<slug>: a base URL plus the credentials Relvo adds to every request (each binding names a header or query parameter, a template with {secret}, and the secret). Agents then call the endpoint with method, path under the base URL, query, json or form; Relvo adds the credentials and never shows them, so pass each secret only here. No Relvo usage fee; the API bills its own account. The response never repeats a secret.",
+        inputSchema: forHosts(endpointDefinition.extend({ slug: platformCustomToolSlugSchema }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false, idempotentHint: false } }, ({ slug, ...input }) => respond(() => client.createCustomTool({ slug, ...endpointDefinition.parse(input), kind: "http" })));
+    server.registerTool("platform_custom_endpoint_update", { description: "Replace an API endpoint's whole definition. Read it first and pass its version as expectedVersion. Keep a saved binding's secret by passing the binding's id without a secret; a secret sent replaces it. If the base URL moves to another origin every binding needs its secret again.",
+        inputSchema: forHosts(endpointDefinition.extend({ name: customToolName, expectedVersion: z.number().int().min(1) }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: false } }, ({ name, expectedVersion, ...input }) => respond(() => client.updateCustomTool(name, { ...endpointDefinition.parse(input), kind: "http", expectedVersion })));
+    server.registerTool("platform_custom_tool_versions", { description: "List a custom tool's kept versions, newest first. Free.",
+        inputSchema: forHosts(z.object({ name: customToolName }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ name }) => respond(() => client.customToolVersions(name)));
+    server.registerTool("platform_custom_tool_restore", { description: "Make an earlier version of a custom tool current again; this adds a new version, so it can be undone. Pass the current version as expectedVersion.",
+        inputSchema: forHosts(platformCustomToolRestoreSchema.extend({ name: customToolName }).strict()), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: false } }, ({ name, ...input }) => respond(() => client.restoreCustomTool(name, input)));
+    server.registerTool("platform_custom_tool_delete", { description: "Delete a custom tool and its versions for the whole team. Only its creator or an admin may delete it.",
+        inputSchema: forHosts(z.object({ name: customToolName }).strict()), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: true } }, ({ name }) => respond(() => client.deleteCustomTool(name)));
+    const teamSkillSlug = platformTeamSkillCreateSchema.shape.slug;
+    server.registerTool("platform_team_skills", { description: "List this project's team skills: procedures the team's agents wrote for each other, each with when to use it. Before a Relvo task, read one whose description fits it and follow it within the user's request. Free.",
+        inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.teamSkills()));
+    server.registerTool("platform_team_skill", { description: "Read one team skill's steps and version. Free.",
+        inputSchema: forHosts(z.object({ slug: teamSkillSlug }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ slug }) => respond(() => client.teamSkill(slug)));
+    server.registerTool("platform_team_skill_create", { description: "Write down, for the whole team, how a Relvo task was done once it worked: when to use it, the steps, the tools by name and what to check. Other members' agents follow it next time. Check the list first and improve an existing skill instead of adding a near copy. No secrets or private code or file contents. Free.",
+        inputSchema: forHosts(platformTeamSkillCreateSchema), annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false, idempotentHint: false } }, input => respond(() => client.createTeamSkill(input)));
+    server.registerTool("platform_team_skill_update", { description: "Improve a team skill when following it showed a missing step, a better tool or a mistake. Read it first, send the whole new text and its version as expectedVersion; an edit made since is refused instead of lost. Every version is kept. Free.",
+        inputSchema: forHosts(platformTeamSkillDefinitionSchema.extend({ slug: teamSkillSlug, expectedVersion: platformTeamSkillUpdateSchema.shape.expectedVersion }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: false } }, ({ slug, ...input }) => respond(() => client.updateTeamSkill(slug, input)));
+    server.registerTool("platform_team_skill_versions", { description: "List a team skill's kept versions, newest first. Free.",
+        inputSchema: forHosts(z.object({ slug: teamSkillSlug }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ slug }) => respond(() => client.teamSkillVersions(slug)));
+    server.registerTool("platform_team_skill_restore", { description: "Make an earlier version of a team skill current again; this adds a new version, so it can be undone. Pass the current version as expectedVersion. Free.",
+        inputSchema: forHosts(platformTeamSkillRestoreSchema.extend({ slug: teamSkillSlug }).strict()), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: false } }, ({ slug, ...input }) => respond(() => client.restoreTeamSkill(slug, input)));
+    server.registerTool("platform_team_skill_delete", { description: "Delete a team skill and its versions for the whole team. Only its creator or an admin may delete it.",
+        inputSchema: forHosts(z.object({ slug: teamSkillSlug }).strict()), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: true } }, ({ slug }) => respond(() => client.deleteTeamSkill(slug)));
+    server.registerTool("platform_suggestions", { description: "Repeated work in the last 14 days: the same Python your keys ran again and again, with its code (save it with platform_custom_tool_create, taking the values that change as input), and the same tool sequence in several sessions of this project (write it down with platform_team_skill_create). Check it at the end of a Relvo task. Free.",
+        inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.suggestions()));
+    server.registerTool("platform_team_access", { description: "List the team's members and pending invitations with what each may use of the team's own connections, custom tools, skills and secrets: `toolAccess` null is everything, a list names `connection:<id>`, `connection:<id>/<tool>`, `connection:<id>/reads`, `custom__<slug>`, `skill:<projectId>/<slug>` and `secret:<projectId>/<NAME>`, and hides what it does not name. Needs a key of the team's owner or an admin made with access:write. Free.",
+        inputSchema: forHosts(z.object({}).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.access()));
+    server.registerTool("platform_member_access_update", { description: "Replace one member's list of the team's connections, connection operations, custom tools, skills and secrets they may use, with the whole new list in the grammar platform_team_access shows; \"all\" gives every one, those added later included. Read the current list first. An admin changes no admin's or owner's list and gives nothing they do not hold; the member's role is never changed. Needs a key of the team's owner or an admin made with access:write.",
+        inputSchema: forHosts(z.object({ memberId: z.string().regex(/^[A-Za-z0-9-]{1,128}$/), toolAccess: z.union([z.literal("all"), z.array(z.string().max(200)).max(20_000)]) }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: true } }, ({ memberId, toolAccess }) => respond(() => client.updateMemberAccess(memberId, { toolAccess: toolAccess === "all" ? null : toolAccess })));
+    const workflowDefinition = z.object({ ...platformWorkflowDefinitionSchema.shape,
+        inputSchema: z.record(z.string(), z.unknown()).describe(platformWorkflowDefinitionSchema.shape.inputSchema.description ?? "JSON Schema of the run inputs."),
+        steps: z.array(z.object({ ...platformWorkflowStepSchema.shape, arguments: z.record(z.string(), z.unknown()).describe(platformWorkflowStepSchema.shape.arguments.description ?? "The tool's arguments.") }).strict())
+            .min(1).describe(platformWorkflowDefinitionSchema.shape.steps.description ?? "Tool calls in order.") }).strict();
+    const workflowDefinitionOf = (input) => platformWorkflowDefinitionSchema.parse(input);
+    const workflowSlug = z.object({ slug: platformWorkflowSlugSchema }).strict();
+    const workflowRun = z.object({ id: platformWorkflowRunIdSchema }).strict();
+    server.registerTool("platform_workflows", { description: "List this project's saved workflows: tool calls in a fixed order that a run repeats with new inputs and a budget. Free.",
+        inputSchema: forHosts(z.object({})), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, () => respond(() => client.workflows()));
+    server.registerTool("platform_workflow", { description: "Read one workflow's input schema, steps and version. Free.",
+        inputSchema: forHosts(workflowSlug), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ slug }) => respond(() => client.workflow(slug)));
+    server.registerTool("platform_workflow_create", { description: "Save, for the whole team, a sequence of tool calls that worked so it can be run again: an input schema and steps, each a catalog tool with its arguments. In arguments, {\"$input\":\"name\"} takes a run input and {\"$step\":\"id\",\"path\":\"/data/0/url\"} a value of an earlier step's output (a JSON Pointer). Saving buys nothing. Free.",
+        inputSchema: forHosts(workflowDefinition.extend({ slug: platformWorkflowSlugSchema }).strict()), annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false, idempotentHint: false } }, ({ slug, ...input }) => respond(() => client.createWorkflow({ slug, ...workflowDefinitionOf(input) })));
+    server.registerTool("platform_workflow_update", { description: "Replace a workflow's whole definition. Read it first and pass its version as expectedVersion; an edit made since is refused instead of lost. Runs keep the version they started with. Only its creator or an admin may change it. Free.",
+        inputSchema: forHosts(workflowDefinition.extend({ slug: platformWorkflowSlugSchema, expectedVersion: z.number().int().min(1) }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: false } }, ({ slug, expectedVersion, ...input }) => respond(() => client.updateWorkflow(slug, { ...workflowDefinitionOf(input), expectedVersion })));
+    server.registerTool("platform_workflow_versions", { description: "List a workflow's kept versions, newest first. Free.",
+        inputSchema: forHosts(workflowSlug), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ slug }) => respond(() => client.workflowVersions(slug)));
+    server.registerTool("platform_workflow_delete", { description: "Delete a workflow and its versions for the whole team; its runs stay readable. Only its creator or an admin may delete it.",
+        inputSchema: forHosts(workflowSlug), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: true } }, ({ slug }) => respond(() => client.deleteWorkflow(slug)));
+    server.registerTool("platform_workflow_run", { description: "Run a saved workflow. Relvo buys each step in order as an ordinary execution under this key and stops before a step whose price no longer fits what is left of maximumChargeMicros. Keep idempotencyKey: repeating it returns the same run instead of buying again. Read progress with platform_workflow_run_status and the result with the execution in resultExecutionId.",
+        inputSchema: forHosts(platformWorkflowRunCreateSchema.extend({ slug: platformWorkflowSlugSchema, inputs: z.record(z.string(), z.unknown()).default({}).describe("Values for the workflow's input schema."),
+            idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/) }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, ({ slug, idempotencyKey, ...input }) => respond(() => client.runWorkflow(slug, platformWorkflowRunCreateSchema.parse(input), idempotencyKey)));
+    server.registerTool("platform_workflow_runs", { description: "List a workflow's runs, newest first, with status and charge. Free.",
+        inputSchema: forHosts(platformWorkflowRunListQuerySchema.extend({ slug: platformWorkflowSlugSchema }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ slug, ...query }) => respond(() => client.workflowRuns(slug, query)));
+    server.registerTool("platform_workflow_run_status", { description: "Read a workflow run: its version, each step's execution, status and charge, and resultExecutionId once it succeeded. Free.",
+        inputSchema: forHosts(workflowRun), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ id }) => respond(() => client.workflowRun(id)));
+    server.registerTool("platform_workflow_run_cancel", { description: "Cancel a workflow run: its running step is asked to stop and no later step is bought. Only the member who started it or an admin may cancel it.",
+        inputSchema: forHosts(workflowRun), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false, idempotentHint: true } }, ({ id }) => respond(() => client.cancelWorkflowRun(id)));
+    const readTriggerOnly = { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true };
+    const triggerId = platformTriggerIdSchema;
+    server.registerTool("platform_triggers", { description: "List this project's triggers: events from a connected app, delivered as they happen. Shows kind (poll or webhook), app, status (failed when Relvo stopped it, see statusReason), last check/event, last error and destinations. Free.",
+        inputSchema: forHosts(z.object({})), annotations: readTriggerOnly }, () => respond(() => client.triggers()));
+    server.registerTool("platform_trigger_types", { description: "For one app, list the webhook trigger types (type, configSchema, available) and a page of its read operations a poll trigger can run (tool, inputSchema). Page with offset while offset + limit < total. Free.",
+        inputSchema: forHosts(platformTriggerTypesQuerySchema), annotations: readTriggerOnly }, input => respond(() => client.triggerTypes(input)));
+    server.registerTool("platform_trigger_create", { description: "Get events from a connected app. kind:poll runs a read operation (tool, arguments without connectionId) every interval and reports what is new; the first run is a baseline. Each poll is one execution that counts toward the plan's free runs and is charged beyond them, up to maximumChargeMicrosPerPoll. kind:webhook registers type (from platform_trigger_types) with the app and needs config valid against its configSchema. The trigger runs as this API key. Read events with platform_trigger_events. destinations: webhook (signing secret shown once), slack, discord or workflow {workflow, input, maximumChargeMicros}; email is console only. Get the user's approval before creating a poll trigger.",
+        inputSchema: forHosts(z.object({
+            kind: z.enum(["poll", "webhook"]),
+            connectionId: z.string().describe("The connection of the app, from platform_connections."),
+            name: z.string().optional().describe("Omit to name it after its type or operation."),
+            tool: z.string().optional().describe("poll only: a read operation of the app, for example github__issues_list_for_repo."),
+            arguments: z.record(z.string(), z.unknown()).optional().describe("poll only: the operation's arguments without connectionId."),
+            interval: platformTriggerIntervalSchema.optional().describe("poll only. Omit for 5m."),
+            itemsPath: z.string().optional().describe("poll only: JSON Pointer to the list in the response, for example /data/items. Omit to use the largest list."),
+            maximumChargeMicrosPerPoll: z.number().int().min(0).optional().describe("poll only: the most one poll may charge. Omit for the default."),
+            type: z.string().optional().describe("webhook only: a type from platform_trigger_types, for example github.push."),
+            config: z.record(z.string(), z.unknown()).optional().describe("webhook only: the type's settings."),
+            destinations: z.array(platformTriggerDestinationInputSchema).optional().describe("Where each event is sent. Omit for none; read events with platform_trigger_events."),
+        }).strict()), annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true, idempotentHint: false } }, input => respond(async () => client.createTrigger(platformTriggerCreateSchema.parse(Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== ""))))));
+    server.registerTool("platform_trigger_update", { description: "Enable or disable a trigger, or rename it. A failed trigger is checked again when enabled. Omitted fields stay as they are.",
+        inputSchema: forHosts(z.object({ id: triggerId, enabled: z.boolean().optional(), name: z.string().optional().describe("Empty or omitted keeps the name.") }).strict()),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, ({ id, ...input }) => respond(() => client.updateTrigger(id, platformTriggerUpdateSchema.parse(Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== ""))))));
+    server.registerTool("platform_trigger_delete", { description: "Delete one trigger of this project; a webhook is removed from the app. Its kept events go with it. Free.",
+        inputSchema: forHosts(z.object({ id: triggerId }).strict()), annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, ({ id }) => respond(() => client.deleteTrigger(id)));
+    server.registerTool("platform_trigger_events", { description: "Read trigger events oldest first. Omit triggerId for every trigger. Pass the returned nextAfter as after to read only newer events. Free.",
+        inputSchema: forHosts(platformTriggerEventsQuerySchema.extend({ triggerId: triggerId.optional() }).strict()), annotations: readTriggerOnly }, input => respond(() => client.triggerEvents(input)));
     server.registerTool("platform_connections", {
         description: "Page project OAuth IDs and account labels for a tool's connectionId. Follow nextOffset. No tokens or account changes. Empty scopes do not establish lack of access; reauth_required needs console consent.",
-        inputSchema: platformConnectionCatalogQuerySchema,
+        inputSchema: forHosts(platformConnectionCatalogQuerySchema),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true },
     }, ({ provider, offset, limit }) => respond(async () => {
         const catalog = (await client.connections({ provider, offset, limit })).data;
@@ -111,42 +268,39 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
             throw new Error("This connection's metadata exceeds the context budget. Inspect it in the Relvo console.");
         return page();
     }));
-    server.registerTool("platform_tools", { description: "Find a capability or exact tool/model name; filter quotes, funding, unit, category or provider. summary:false with limit:1 can include its schema; reuse it, inspecting omitted definitions with platform_tool. Example quotes need actual-input requoting. Free. No match does not imply missing OAuth; provider does not pin execution.",
-        inputSchema: toolDiscoveryInputSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.searchTools(input), undefined, (value, fits) => {
-        const tools = value.data.tools.map(summary);
-        const response = () => ({ data: { ...value.data, tools, discovery: { ...value.data.discovery, returnedCount: tools.length, truncated: true } } });
-        while (tools.length && !fits(response()))
-            tools.pop();
-        return response();
-    }));
+    server.registerTool("platform_tools", { description: "Find a capability or exact tool/model name; filter quotes, funding, unit, category or provider. summary:false with limit:1 can include its schema; reuse it, inspecting omitted definitions with platform_tool. Example quotes need actual-input requoting. Counts toward the team's monthly free calls, then is charged. No match does not imply missing OAuth; provider does not pin execution.",
+        inputSchema: forHosts(toolDiscoveryInputSchema), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.searchTools(input), undefined, compactToolDiscovery));
     server.registerTool("platform_quote", { description: "Quote exact tool arguments, optional provider and session without executing. Auto is default. Retain priceVersion, maximumChargeMicros and the unchanged selection for submission within the user's budget.",
-        inputSchema: platformToolInputSchema, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, (input) => respond(() => client.quote(input)));
+        inputSchema: forHosts(platformQuoteRequestSchema), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, (input) => respond(() => client.quote(input)));
     server.registerTool("platform_execute", { description: "Enqueue an authorized paid call using its accepted quote and a saved idempotencyKey. Auto is default. Wait on the returned ID. Retry uncertain admission with identical input/key to recover the same purchase.",
-        inputSchema: platformCreateExecutionSchema.extend({ idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/) }),
+        inputSchema: forHosts(platformCreateExecutionSchema.extend({ idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/) }), json => {
+            const { runRequestHash: _receiptMetadata, ...properties } = jsonObject.parse(json.properties);
+            return { ...json, properties };
+        }),
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, ({ idempotencyKey, ...input }) => respond(async () => executionReceiptContext(await client.createExecution(input, idempotencyKey)), "platform_execute", value => executionReceiptContext(value, projectionOptions)));
     server.registerTool("platform_execution", { description: "Read status, charges and a bounded result preview. Use platform_result for offloaded content. Pending zero charges are not final. needs_review requires operator reconciliation, not replacement work.",
-        inputSchema: z.object({ id: platformExecutionIdSchema }).strict(),
+        inputSchema: forHosts(z.object({ id: platformExecutionIdSchema }).strict()),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, ({ id }) => respond(() => client.executionContext(id), "platform_execution", value => executionReceiptContext(value, projectionOptions)));
     server.registerTool("platform_result", { description: "Read saved results without regenerating. Select a path, page and optional row fields. Pages fit the response budget automatically; follow nextOffset. An offloaded single value needs a narrower path. Process bulk data in an available remote sandbox.",
-        inputSchema: z.object({ id: platformExecutionIdSchema, ...toolResultSelectionSchema.shape }).strict(),
+        inputSchema: forHosts(z.object({ id: platformExecutionIdSchema, ...toolResultSelectionSchema.shape }).strict()),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, ({ id, ...selection }) => respond(() => client.readExecutionResult(id, selection), "platform_result", (value, fits) => {
         const fitted = { data: { ...value.data, page: fitToolResultPage(value.data.page, page => fits({ data: { ...value.data, page } })) } };
         return fits(fitted) ? fitted : executionPageContext(value, projectionOptions);
     }));
     server.registerTool("platform_cancel", { description: "Request cancellation of this execution's unstarted work. Already incurred provider costs may still be charged. Requires ownership of the execution or project ADMIN access.",
-        inputSchema: z.object({ id: platformExecutionIdSchema }).strict(),
+        inputSchema: forHosts(z.object({ id: platformExecutionIdSchema }).strict()),
         annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true, idempotentHint: true } }, ({ id }) => respond(async () => executionReceiptContext(await client.cancelExecution(id)), "platform_cancel", value => executionReceiptContext(value, projectionOptions)));
     server.registerTool("platform_artifact_url", { description: "Get a completed execution's private output download URL, including generated media and downloaded social videos, valid for at most 5 minutes. Use execution and artifact IDs from platform_execution. Treat the URL as temporary access to private data; share it only within the caller's authorized scope.",
-        inputSchema: z.object({ id: platformExecutionIdSchema, artifactId: platformArtifactIdSchema }).strict(),
+        inputSchema: forHosts(z.object({ id: platformExecutionIdSchema, artifactId: platformArtifactIdSchema }).strict()),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ id, artifactId }) => respond(() => client.artifactDownload(id, artifactId)));
     server.registerTool("platform_tool", { description: "Inspect one discovered tool's schema, example and price. Small definitions are complete; large ones return page.entries with exact paths. Read entries without value at their path; follow nextOffset for siblings. Free.",
-        inputSchema: z.object({ name: z.string().regex(/^[a-z][a-z0-9_]{1,63}$/).describe("Exact discovered tool name."), ...inspectInput }).strict(),
+        inputSchema: forHosts(z.object({ name: z.string().regex(/^[a-z][a-z0-9_]{1,63}$/).describe("Exact discovered tool name."), ...inspectInput }).strict()),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ name, ...selection }) => respond(async () => {
         const value = await client.inspectTool(name);
         return inspectJsonContext(name, jsonObject.parse(value.data), selection, mcpContextFits);
     }));
     server.registerTool("platform_executions", { description: "Recover prior project jobs, newest first. Follow nextBefore; summaries omit output. Inspect a known execution ID instead of purchasing replacement work. Free.",
-        inputSchema: platformExecutionListQuerySchema,
+        inputSchema: forHosts(platformExecutionListQuerySchema),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, input => respond(() => client.executions(input), undefined, (value, fits) => {
         const executions = [...value.data.executions];
         const page = () => ({ data: { executions, nextBefore: executions.at(-1)?.id ?? value.data.nextBefore } });
@@ -157,8 +311,8 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
         return page();
     }));
     server.registerTool("platform_wait", { description: "Wait for an existing job, up to 25 seconds per call. timedOut leaves it running: wait again on the same ID. Terminal failures include status/charges and isError. Free; never submits or cancels.",
-        inputSchema: z.object({ id: platformExecutionIdSchema.describe("Execution ID from platform_execute or platform_executions."),
-            timeoutSeconds: z.number().int().min(1).max(25).default(20).describe("Wait limit, 1–25 seconds; accepted work continues afterwards.") }).strict(),
+        inputSchema: forHosts(z.object({ id: platformExecutionIdSchema.describe("Execution ID from platform_execute or platform_executions."),
+            timeoutSeconds: z.number().int().min(1).max(25).default(20).describe("Wait limit, 1–25 seconds; accepted work continues afterwards.") }).strict()),
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, async ({ id, timeoutSeconds }, { mcpReq }) => {
         let failed = false;
         const result = await respond(async () => {
@@ -169,9 +323,9 @@ export function createPlatformMcp(client, version = "0.1.2", localFilesystem = f
         return failed ? { ...result, isError: true } : result;
     });
     server.registerTool("platform_skills", { description: "List current first-party guide summaries. Inspect only a needed guide with platform_skill. Guides do not grant permissions or budget. Oversized full lists return summaries.",
-        inputSchema: z.object({ summary: z.boolean().default(true) }).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ summary }) => respond(async () => { const { data } = await client.skills(); return { data: { version: data.version, skills: summary ? data.skills.map(({ content, ...skill }) => skill) : data.skills } }; }, undefined, value => ({ data: { ...value.data, skills: value.data.skills.map(skill => ({ name: skill.name, description: skill.description, sha256: skill.sha256 })), offloaded: true, readWith: "platform_skill" } })));
+        inputSchema: forHosts(z.object({ summary: z.boolean().default(true) }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ summary }) => respond(async () => { const { data } = await client.skills(); return { data: { version: data.version, skills: summary ? data.skills.map(({ content, ...skill }) => skill) : data.skills } }; }, undefined, value => ({ data: { ...value.data, skills: value.data.skills.map(skill => ({ name: skill.name, description: skill.description, sha256: skill.sha256 })), offloaded: true, readWith: "platform_skill" } })));
     server.registerTool("platform_skill", { description: "Read one needed first-party guide. Large guides return paths/pages like platform_tool. Current endpoint names come from discovery; guides do not authorize paid work.",
-        inputSchema: z.object({ name: platformSkillSchema.shape.name, ...inspectInput }).strict(), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ name, ...selection }) => respond(async () => {
+        inputSchema: forHosts(z.object({ name: platformSkillSchema.shape.name, ...inspectInput }).strict()), annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true } }, ({ name, ...selection }) => respond(async () => {
         const value = await client.skill(name);
         return inspectJsonContext(name, jsonObject.parse(value.data), selection, mcpContextFits);
     }));

package/dist/mcp/version.js

@@ -0,0 +1 @@
+export const PLATFORM_MCP_VERSION = "0.1.3";

package/dist/schema/accountRequestMethods.js

@@ -0,0 +1 @@
+export const ACCOUNT_REQUEST_HTTP_METHODS = ["GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"];

package/dist/schema/cronValidator.js

@@ -0,0 +1,150 @@
+const STRICT_CRON_RE = /^([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)\s+([\*0-9A-Za-z,\-\/]+)$/;
+export function isStrictCron5Field(cron) {
+    if (typeof cron !== "string")
+        return false;
+    return STRICT_CRON_RE.test(cron.trim());
+}
+const RANGES = {
+    minute: { min: 0, max: 59 },
+    hour: { min: 0, max: 23 },
+    dayOfMonth: { min: 1, max: 31 },
+    month: { min: 1, max: 12 },
+    dayOfWeek: { min: 0, max: 6 },
+};
+const MONTH_NAMES = {
+    JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6,
+    JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12,
+};
+const DOW_NAMES = {
+    SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6,
+};
+function normalizeToken(token, names) {
+    if (!names)
+        return token;
+    const upper = token.trim().toUpperCase();
+    return upper in names ? String(names[upper]) : token;
+}
+function expandField(field, range, names) {
+    const out = new Set();
+    for (const part of field.split(",")) {
+        const stepMatch = part.match(/^(.+)\/(\d+)$/);
+        let base = part;
+        let step = 1;
+        if (stepMatch) {
+            base = stepMatch[1];
+            step = Number.parseInt(stepMatch[2], 10);
+            if (!Number.isFinite(step) || step <= 0)
+                return null;
+        }
+        let lo;
+        let hi;
+        if (base === "*") {
+            lo = range.min;
+            hi = range.openMax ?? range.max;
+        }
+        else if (base.includes("-")) {
+            const [a, b] = base.split("-");
+            lo = Number.parseInt(normalizeToken(a ?? "", names), 10);
+            hi = Number.parseInt(normalizeToken(b ?? "", names), 10);
+            if (!Number.isFinite(lo) || !Number.isFinite(hi))
+                return null;
+        }
+        else {
+            const v = Number.parseInt(normalizeToken(base, names), 10);
+            if (!Number.isFinite(v))
+                return null;
+            lo = v;
+            hi = stepMatch ? (range.openMax ?? range.max) : v;
+        }
+        if (lo < range.min || hi > range.max || lo > hi)
+            return null;
+        for (let i = lo; i <= hi; i += step)
+            out.add(i);
+    }
+    return out.size > 0 ? out : null;
+}
+export function parseCron(cron) {
+    if (!isStrictCron5Field(cron))
+        return null;
+    const [minute, hour, dom, month, dow] = cron.trim().split(/\s+/);
+    const minutes = expandField(minute, RANGES.minute);
+    const hours = expandField(hour, RANGES.hour);
+    const daysOfMonth = expandField(dom, RANGES.dayOfMonth);
+    const months = expandField(month, RANGES.month, MONTH_NAMES);
+    const dowRaw = expandField(dow, { min: RANGES.dayOfWeek.min, max: 7, openMax: RANGES.dayOfWeek.max }, DOW_NAMES);
+    const dowExpanded = dowRaw && new Set([...dowRaw].map((d) => (d === 7 ? 0 : d)));
+    if (!minutes || !hours || !daysOfMonth || !months || !dowExpanded)
+        return null;
+    return {
+        minutes,
+        hours,
+        daysOfMonth,
+        months,
+        daysOfWeek: dowExpanded,
+        dayRestrictionOr: dom !== "*" && dow !== "*",
+    };
+}
+export function isValidCron(cron) {
+    if (typeof cron !== "string")
+        return false;
+    return parseCron(cron) !== null;
+}
+export function isCronTooFrequent(cron, minIntervalMinutes) {
+    const fields = cron.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return true;
+    const minutes = expandField(fields[0], RANGES.minute);
+    const hours = expandField(fields[1], RANGES.hour);
+    if (!minutes || !hours)
+        return true;
+    const slots = [];
+    for (const h of hours) {
+        for (const m of minutes)
+            slots.push(h * 60 + m);
+    }
+    slots.sort((a, b) => a - b);
+    for (let i = 1; i < slots.length; i++) {
+        if (slots[i] - slots[i - 1] < minIntervalMinutes)
+            return true;
+    }
+    return slots[0] + 1440 - slots[slots.length - 1] < minIntervalMinutes;
+}
+function matches(parsed, d) {
+    if (!parsed.minutes.has(d.getMinutes()))
+        return false;
+    if (!parsed.hours.has(d.getHours()))
+        return false;
+    if (!parsed.months.has(d.getMonth() + 1))
+        return false;
+    const domMatch = parsed.daysOfMonth.has(d.getDate());
+    const dowMatch = parsed.daysOfWeek.has(d.getDay());
+    if (parsed.dayRestrictionOr)
+        return domMatch || dowMatch;
+    return domMatch && dowMatch;
+}
+export function findNextFires(cron, from, deadline, max = 30) {
+    const parsed = parseCron(cron);
+    if (!parsed)
+        return [];
+    if (!(deadline.getTime() > from.getTime()))
+        return [];
+    const fires = [];
+    const cursor = new Date(from.getTime());
+    cursor.setSeconds(0, 0);
+    cursor.setTime(cursor.getTime() + 60_000);
+    const HARD_CAP_MINUTES = 370 * 24 * 60;
+    let ticks = 0;
+    while (cursor.getTime() <= deadline.getTime() && ticks < HARD_CAP_MINUTES) {
+        if (matches(parsed, cursor)) {
+            fires.push(new Date(cursor.getTime()));
+            if (fires.length >= max)
+                break;
+        }
+        cursor.setTime(cursor.getTime() + 60_000);
+        ticks++;
+    }
+    return fires;
+}
+export function cronFiresBeforeDeadline(cron, deadline, from = new Date()) {
+    return findNextFires(cron, from, deadline, 1).length > 0;
+}

package/dist/schema/platformApiKey.js

@@ -1,13 +1,13 @@
-export const PLATFORM_KEY_PREFIXES = { noimos: "nmp_", relvo: "rlv_", toolhub: "thk_" };
-export const PLATFORM_API_KEY_PATTERN = /^(?:nmp|rlv|thk)_[A-Za-z0-9_-]{43}$/;
-export const PLATFORM_CLIENT_HEADERS = { noimos: "x-noimos-client", relvo: "x-relvo-client", toolhub: "x-toolhub-client" };
+export const PLATFORM_KEY_PREFIXES = { noimos: "nmp_", relvo: "rlv_" };
+export const PLATFORM_API_KEY_PATTERN = /^(?:nmp|rlv)_[A-Za-z0-9_-]{43}$/;
+export const PLATFORM_CLIENT_HEADERS = { noimos: "x-noimos-client", relvo: "x-relvo-client" };
 export const PLATFORM_PRODUCT_NAMES = { noimos: "NoimosAI Platform", relvo: "Relvo" };
 export function isRelvoProduct(product) {
-    return product === "relvo" || product === "toolhub";
+    return product === "relvo";
 }
 export function platformKeyProduct(key) {
     for (const product of Object.keys(PLATFORM_KEY_PREFIXES))
         if (key.startsWith(PLATFORM_KEY_PREFIXES[product]))
-            return product === "toolhub" ? "relvo" : product;
+            return product;
     return null;
 }

package/dist/schema/platformBillingConstants.js

@@ -0,0 +1,3 @@
+export const PLATFORM_CHECKOUT_MIN_CENTS = 500;
+export const PLATFORM_SETTLEMENT_MIN_CENTS = 100;
+export const PLATFORM_FREE_TOOL_OVERAGE_MICROS = 300;