@relvo/mcp 0.1.4 → 0.1.5

package/README.md

@@ -49,6 +49,14 @@ For a price-only check, use `platform` to call `platform_quote` before any run.
 Schemas load on demand. Set `RELVO_MCP_MODE=full` only if your host needs every
 original operation listed as a separate tool.
 
+## Team skill references
+
+Use `platform` with operation `team_skills` to list your team's procedures. Operation `team_skill` reads one by `slug` and lists
+its files. Add a relative `path` to read `SKILL.md`, a reference document, an image or a script. Images return MCP image content;
+long text and binary files return pages with `nextOffset`. The same access permissions apply to every file.
+
+For local folder installation, use **Use in your environment** in [Customize → Skills](https://app.relvo.si/customization).
+
 ## Costs and retries
 
 Quotes are free. Searches count toward your team's monthly free calls and are
@@ -62,5 +70,9 @@ and key or resume its `runId`. Read stored results instead of purchasing them ag
 Local file uploads are disabled by default. Enable only the directories you need
 with `RELVO_MCP_ALLOWED_UPLOAD_ROOTS`, and upload only user-authorized files.
 
+The server reads the npm registry once per start. When a newer release has been
+public for 72 hours, a one-time note in a tool result says how to update; nothing
+is installed. `RELVO_AUTO_UPDATE=0` turns this off.
+
 See [Relvo docs](https://app.relvo.si/docs) for workflows and configuration,
 or run `npx --yes @relvo/mcp --help` for server options.

package/bin/relvo-mcp.mjs

@@ -7,7 +7,7 @@ if (args.length === 1 && args[0] === "--version") {
   const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
   console.log(manifest.version);
 } else if (args.length === 1 && ["--help", "-h", "help"].includes(args[0])) {
-  console.log("Usage: relvo-mcp\nStart the Relvo MCP server over stdio.\nEnvironment: RELVO_API_URL, RELVO_API_KEY\nOptional: RELVO_MCP_MODE=full loads every operation as its own tool; the compact agent surface is the default.\nOptional: RELVO_MCP_TOOLS=web_search,serp_lookup also lists those catalog tools as tools of their own, to call without discovery (agent surface, at most 20).\nLocal uploads are disabled unless RELVO_MCP_ALLOWED_UPLOAD_ROOTS lists allowed absolute directories.\nExample: npx -y @relvo/mcp\nStandard output is reserved for MCP protocol messages.");
+  console.log("Usage: relvo-mcp\nStart the Relvo MCP server over stdio.\nEnvironment: RELVO_API_URL, RELVO_API_KEY\nOptional: RELVO_MCP_MODE=full loads every operation as its own tool; the compact agent surface is the default.\nOptional: RELVO_MCP_TOOLS=web_search,serp_lookup also lists those catalog tools as tools of their own, to call without discovery (agent surface, at most 20).\nLocal uploads are disabled unless RELVO_MCP_ALLOWED_UPLOAD_ROOTS lists allowed absolute directories.\nThe server reads the npm registry once per start and adds a one-time note to a tool result when a newer release exists. RELVO_AUTO_UPDATE=0 turns this off.\nExample: npx -y @relvo/mcp\nStandard output is reserved for MCP protocol messages.");
 } else if (args.length && !(args.length === 2 && args[0] === "--profile")) {
   console.error("Usage: relvo-mcp [--help | --version]");
   process.exitCode = 2;

package/dist/client/agent-run.js

@@ -8,6 +8,12 @@ import { fitToolResultPage, toolResultSelectionSchema, TOOL_RESULT_PAGE_MAX_CHAR
 import { platformFundingShortfallSchema } from "../schema/platformFunding.js";
 import { AUTO_CAPABILITY_VARIANTS } from "../schema/platformCapabilityFamilies.js";
 const keySchema = z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/);
+export const RETAINED_READ_MS = 5 * 60 * 1000;
+function lastFinishedExecution() {
+    let kept;
+    return { read: id => kept?.execution.id === id && Date.now() < kept.until ? kept.execution : undefined,
+        keep: execution => { kept = { until: Date.now() + RETAINED_READ_MS, execution }; } };
+}
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
 const recoveryReferencePattern = /^run:([a-f0-9]{64}):([A-Za-z0-9._:-]{8,128})$/;
 const recoveryReferenceSchema = z.string().regex(recoveryReferencePattern);
@@ -351,16 +357,20 @@ export function agentResultView(value, raw, picks, rowsOnly = false) {
 export function resultFilesFor(env, cwd = process.cwd()) {
     return env.RELVO_RESULT_DIRECTORY ? { directory: env.RELVO_RESULT_DIRECTORY } : { directory: join(cwd, ".relvo", "results"), within: cwd };
 }
+const readableByOthers = (mode) => process.platform !== "win32" && (mode & 0o077) !== 0;
+const failureText = (error) => error instanceof Error ? error.message : "The result could not be read.";
 export class AgentRun {
     client;
     directory;
     resultFiles;
     topUp;
-    constructor(client, directory = join(tmpdir(), `relvo-runs-${process.getuid?.() ?? "user"}`), resultFiles, topUp) {
+    retained;
+    constructor(client, directory = join(tmpdir(), `relvo-runs-${process.getuid?.() ?? "user"}`), resultFiles, topUp, retained = lastFinishedExecution()) {
         this.client = client;
         this.directory = directory;
         this.resultFiles = resultFiles;
         this.topUp = topUp;
+        this.retained = retained;
     }
     async resultFolder() {
         if (!this.resultFiles) {
@@ -436,12 +446,12 @@ export class AgentRun {
     async folder() {
         await mkdir(this.directory, { recursive: true, mode: 0o700 });
         const root = await lstat(this.directory);
-        if (!root.isDirectory() || root.isSymbolicLink() || root.mode & 0o077 || process.getuid && root.uid !== process.getuid())
+        if (!root.isDirectory() || root.isSymbolicLink() || readableByOthers(root.mode) || process.getuid && root.uid !== process.getuid())
             throw new Error("The private run directory must belong to this user and allow owner access only.");
         const path = join(this.directory, await this.client.requestJournalScope());
         await mkdir(path, { recursive: true, mode: 0o700 });
         const scoped = await lstat(path);
-        if (!scoped.isDirectory() || scoped.isSymbolicLink() || scoped.mode & 0o077 || process.getuid && scoped.uid !== process.getuid())
+        if (!scoped.isDirectory() || scoped.isSymbolicLink() || readableByOthers(scoped.mode) || process.getuid && scoped.uid !== process.getuid())
             throw new Error("Invalid private run directory.");
         return path;
     }
@@ -449,7 +459,7 @@ export class AgentRun {
         const path = join(await this.folder(), digestSchema.parse(runId) + ".json");
         try {
             const info = await lstat(path);
-            if (!info.isFile() || info.isSymbolicLink() || info.mode & 0o077)
+            if (!info.isFile() || info.isSymbolicLink() || readableByOthers(info.mode))
                 throw new Error("Invalid saved run file.");
             return savedSchema.parse(JSON.parse(await readFile(path, "utf8")));
         }
@@ -616,17 +626,37 @@ export class AgentRun {
     async finish(runId, execution, quote, { waitSeconds, selection, pick, file }, toppedUp = null) {
         let timedOut = false;
         if (PENDING.includes(execution.status)) {
-            const waited = await this.client.waitExecution(execution.id, waitSeconds * 1000);
-            timedOut = waited.timedOut;
-            execution = waited.data ?? execution;
+            try {
+                const waited = await this.client.waitExecution(execution.id, waitSeconds * 1000);
+                timedOut = waited.timedOut;
+                execution = waited.data ?? execution;
+            }
+            catch {
+                timedOut = true;
+            }
         }
         const view = { ...this.view(runId, execution, quote, timedOut, selection, pick), ...(toppedUp ? { toppedUp } : {}) };
-        return file && execution.status === "succeeded" ? { ...view, file: await this.exportFile(execution.id, execution.output, selection?.path ?? [], selection?.fields) } : view;
+        if (!file || execution.status !== "succeeded")
+            return view;
+        try {
+            return { ...view, file: await this.exportFile(execution.id, execution.output, selection?.path ?? [], selection?.fields) };
+        }
+        catch (error) {
+            return { ...view, fileError: `${failureText(error)} The run succeeded and is retained: operation:result {id} reads it.` };
+        }
+    }
+    readableResult(execution, selection, pick) {
+        try {
+            return { result: agentResultView(execution.output, selection, pick) };
+        }
+        catch (error) {
+            return { resultError: `${failureText(error)} The run succeeded and is retained: operation:result {id} reads it with another selection.` };
+        }
     }
     view(runId, execution, quote, timedOut, selection, pick) {
         return { runId, admitted: true, ...(quote?.plan ? { quote: { plan: quote.plan } } : {}), id: execution.id, status: execution.status, timedOut,
             reservedMicros: execution.reservedMicros, chargedMicros: ["succeeded", "failed", "cancelled"].includes(execution.status) ? execution.chargedMicros : null,
-            errorCode: execution.errorCode, ...(execution.status === "succeeded" ? { result: agentResultView(execution.output, selection, pick) } : {}),
+            errorCode: execution.errorCode, ...(execution.status === "succeeded" ? this.readableResult(execution, selection, pick) : {}),
             ...(PENDING.includes(execution.status) ? { next: "Still running and paid for: operation:result {id} waits for it again. Answer from it only after it succeeds or fails." } : {}),
             retained: { readWith: "result", input: { id: execution.id } } };
     }
@@ -665,12 +695,15 @@ export class AgentRun {
         const { id, pick, file, waitSeconds, ...selection } = agentResultSchema.parse(raw);
         if (file && pick)
             throw new Error("file writes one selected path; use path and fields, not pick.");
-        let execution = (await this.client.execution(id)).data, timedOut = false;
+        const retained = this.retained.read(id);
+        let execution = retained ?? (await this.client.execution(id)).data, timedOut = false;
         if (PENDING.includes(execution.status)) {
             const waited = await this.client.waitExecution(id, waitSeconds * 1000);
             timedOut = waited.timedOut;
             execution = waited.data ?? execution;
         }
+        if (execution.status === "succeeded" && !retained)
+            this.retained.keep(execution);
         if (execution.status === "succeeded" && file)
             return { id: execution.id, status: execution.status, file: await this.exportFile(execution.id, execution.output, selection.path, selection.fields) };
         if (execution.status === "succeeded")

package/dist/client/browser.js

@@ -10,7 +10,7 @@ export { executionReceiptContext, executionPageContext } from "./execution-conte
 export { UNTRUSTED_CONTENT_RULE, wrapUntrusted } from "../schema/untrustedContent.js";
 export { fitToolResultPage, TOOL_RESULT_CONTEXT_MAX_BYTES, TOOL_RESULT_PAGE_MAX_ITEMS, toolResultSelectionSchema } from "../schema/toolResultContext.js";
 export { withEvidentValues } from "../schema/toolInputRepair.js";
-export { platformJsonObjectSchema } from "../schema/platformPublicExecution.js";
+export { platformJsonObjectSchema, PLATFORM_TOOL_REQUEST_MAX_BYTES } from "../schema/platformPublicExecution.js";
 import { toolDiscoveryInputSchema, toolDiscoveryResultSchema, TOOL_DISCOVERY_REQUEST_TIMEOUT_MS } from "../schema/toolDiscovery.js";
 export { toolDiscoveryInputSchema } from "../schema/toolDiscovery.js";
 export { PLATFORM_MCP_DIRECT_TOOLS_MAX, platformMcpDirectToolNames } from "../schema/platformMetaTools.js";
@@ -20,19 +20,19 @@ import { platformFundingShortfallSchema } from "../schema/platformFunding.js";
 import { PLATFORM_META_ROUTES, PLATFORM_ROUTES, platformToolsPath as route } from "../schema/platformRoutes.js";
 import { platformSkillsBundleSchema, platformSkillSchema } from "../schema/platformSkills.js";
 export { platformSkillsBundleSchema, platformSkillSchema } from "../schema/platformSkills.js";
-import { platformMonitorCreateSchema, platformMonitorSchema, platformMonitorEventsSchema, platformMonitorEventsQuerySchema, platformPopularMonitorSchema, platformMonitorableToolSchema, platformMonitorQuoteSchema, platformMonitorQuoteResultSchema, platformMonitorResumeSchema, PLATFORM_MONITOR_ID } from "../schema/platformMonitors.js";
-export { platformMonitorCreateSchema, platformMonitorEventsQuerySchema, platformMonitorQuoteSchema, platformMonitorResumeSchema, PLATFORM_MONITOR_ID } from "../schema/platformMonitors.js";
+import { platformMonitorCreateSchema, platformMonitorSchema, platformMonitorEventsSchema, platformMonitorEventsQuerySchema, platformPopularMonitorSchema, platformMonitorableToolSchema, platformMonitorQuoteSchema, platformMonitorQuoteResultSchema, platformMonitorResumeSchema, platformMonitorDestinationInputSchema, PLATFORM_MONITOR_ID } from "../schema/platformMonitors.js";
+export { platformMonitorCreateSchema, platformMonitorEventsQuerySchema, platformMonitorQuoteSchema, platformMonitorResumeSchema, platformMonitorDestinationInputSchema, PLATFORM_MONITOR_ID } from "../schema/platformMonitors.js";
 import { platformCustomToolCreateSchema, platformCustomToolNameSchema, platformCustomToolRestoreSchema, platformCustomToolSchema, platformCustomToolSummarySchema, platformCustomToolUpdateSchema, platformCustomToolVersionSchema, PLATFORM_CUSTOM_TOOL_PREFIX } from "../schema/platformCustomTools.js";
 export { platformCustomEndpointDefinitionSchema, platformCustomToolCreateSchema, platformCustomToolDefinitionSchema, platformCustomToolNameSchema, platformCustomToolSlugSchema, platformCustomToolRestoreSchema, platformCustomToolUpdateSchema, PLATFORM_CUSTOM_TOOL_PREFIX } from "../schema/platformCustomTools.js";
-import { platformSuggestionsSchema, platformTeamSkillCreateSchema, platformTeamSkillRestoreSchema, platformTeamSkillSchema, platformTeamSkillSummarySchema, platformTeamSkillUpdateSchema, platformTeamSkillVersionSchema, PLATFORM_TEAM_SKILL_SLUG } from "../schema/platformTeamSkills.js";
-export { platformTeamSkillCreateSchema, platformTeamSkillDefinitionSchema, platformTeamSkillRestoreSchema, platformTeamSkillUpdateSchema, PLATFORM_TEAM_SKILL_SLUG } from "../schema/platformTeamSkills.js";
+import { platformSuggestionsSchema, platformTeamSkillCreateSchema, platformTeamSkillRestoreSchema, platformTeamSkillSchema, platformTeamSkillSummarySchema, platformTeamSkillUpdateSchema, platformTeamSkillVersionSchema, PLATFORM_TEAM_SKILL_SLUG, PLATFORM_TEAM_SKILL_LIMITS } from "../schema/platformTeamSkills.js";
+export { platformTeamSkillCreateSchema, platformTeamSkillDefinitionSchema, platformTeamSkillRestoreSchema, platformTeamSkillUpdateSchema, PLATFORM_TEAM_SKILL_SLUG, PLATFORM_TEAM_SKILL_LIMITS, platformSkillPathSchema, renderSkillMarkdown, skillFileBytes } from "../schema/platformTeamSkills.js";
 import { platformWorkflowCreateSchema, platformWorkflowRunCreateSchema, platformWorkflowRunIdSchema, platformWorkflowRunListQuerySchema, platformWorkflowRunListSchema, platformWorkflowRunSchema, platformWorkflowSchema, platformWorkflowSummarySchema, platformWorkflowUpdateSchema, platformWorkflowVersionSchema, PLATFORM_WORKFLOW_SLUG } from "../schema/platformWorkflows.js";
 export { platformWorkflowCreateSchema, platformWorkflowDefinitionSchema, platformWorkflowRunCreateSchema, platformWorkflowRunIdSchema, platformWorkflowRunListQuerySchema, platformWorkflowSlugSchema, platformWorkflowStepSchema, platformWorkflowUpdateSchema, PLATFORM_WORKFLOW_SLUG } from "../schema/platformWorkflows.js";
 import { platformTriggerCreateSchema, platformTriggerDestinationInputSchema, platformTriggerEventsQuerySchema, platformTriggerEventsSchema, platformTriggerIdSchema, platformTriggerSchema, platformTriggerTypesQuerySchema, platformTriggerTypesSchema, platformTriggerUpdateSchema } from "../schema/platformTriggers.js";
 export { platformTriggerCreateSchema, platformTriggerDestinationInputSchema, platformTriggerEventsQuerySchema, platformTriggerIdSchema, platformTriggerIntervalSchema, platformTriggerTypesQuerySchema, platformTriggerUpdateSchema } from "../schema/platformTriggers.js";
 import { platformMemberAccessUpdateSchema, platformTeamAccessSchema } from "../schema/platformToolAccess.js";
 export { platformMemberAccessUpdateSchema } from "../schema/platformToolAccess.js";
-import { platformInputFileSchema, platformInputUploadSchema, PLATFORM_UPLOAD_MAX_BYTES } from "../schema/platformPublicExecution.js";
+import { platformInputFileSchema, platformInputUploadSchema, PLATFORM_UPLOAD_MAX_BYTES, PLATFORM_TOOL_REQUEST_MAX_BYTES } from "../schema/platformPublicExecution.js";
 export { platformInputFileSchema, platformInputMimeSchema, platformInputFileMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "../schema/platformPublicExecution.js";
 import { PLATFORM_EXECUTION_MAX_WAIT_SECONDS, PLATFORM_EXECUTION_RESPONSE_MAX_BYTES, platformCatalogSchema, platformCatalogPageQuerySchema, platformCatalogPageSchema, platformQuoteSchema, platformExecutionSchema, platformExecutionContextSchema, platformExecutionResultPageSchema, platformExecutionIdSchema, platformCreateExecutionSchema, platformRecoverExecutionSchema, platformQuoteRequestSchema, platformInvalidArgumentFieldsSchema, platformToolNameSchema, platformArtifactIdSchema, platformArtifactDownloadSchema, platformExecutionListQuerySchema, platformExecutionListSchema } from "../schema/platformPublicExecution.js";
 import { PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR, PlatformExecutionContextBudgetError, platformExecutionResultPageContext } from "../schema/platformPublicExecution.js";
@@ -83,7 +83,7 @@ function triggerId(id) {
         throw new Error("Provide a trigger ID such as trg_….");
     return id;
 }
-const idempotencySchema = z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/);
+export const platformIdempotencyKeySchema = z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/);
 function normalizeToolSearch(value) { return value.toLowerCase().replace(/[\s_-]+/g, ""); }
 const publicErrors = {
     platform_quote_changed: "The priceVersion is stale or the maximum charge is below the current quote. This request was not admitted. Request a new quote for the same arguments/provider, copy its priceVersion and use an authorized maximum covering it. Keep the same idempotency key.",
@@ -283,8 +283,9 @@ export class PlatformClient {
     async request(path, schema, options) {
         const body = options?.body === undefined ? undefined : JSON.stringify(options.body);
         const upload = path === PLATFORM_ROUTES.upload, meta = PLATFORM_META_ROUTES.includes(path);
-        if (body && new TextEncoder().encode(body).byteLength > (upload ? PLATFORM_UPLOAD_MAX_BYTES : meta ? PLATFORM_META_LIMITS.requestBytes : 65536))
-            throw new Error(upload ? "The upload exceeds 12 MiB." : meta ? "The meta tool request exceeds 1 MiB." : "The tool request exceeds 64 KiB.");
+        const maximumRequestBytes = options?.maximumRequestBytes ?? (upload ? PLATFORM_UPLOAD_MAX_BYTES : meta ? PLATFORM_META_LIMITS.requestBytes : options?.toolInput ? PLATFORM_TOOL_REQUEST_MAX_BYTES : 65536);
+        if (body && new TextEncoder().encode(body).byteLength > maximumRequestBytes)
+            throw new Error(options?.maximumRequestBytes ? "The skill package exceeds 20 MiB." : upload ? "The upload exceeds 12 MiB." : meta ? "The meta tool request exceeds 1 MiB." : options?.toolInput ? "The tool request exceeds 1 MiB." : "The tool request exceeds 64 KiB.");
         let response;
         const timeoutMs = options?.timeoutMs ?? 20000;
         const timeoutMessage = `The ${this.productName} API did not answer within ${Math.round(timeoutMs / 1000)} s. If submitting an execution, retry with the same body and idempotency key.`;
@@ -379,7 +380,7 @@ export class PlatformClient {
     }
     searchTools(options = {}) {
         const credential = this.config.apiKey;
-        return this.request(PLATFORM_ROUTES.discover, z.object({ data: toolDiscoveryResultSchema }), { method: "POST", body: toolDiscoveryInputSchema.parse(options), timeoutMs: TOOL_DISCOVERY_REQUEST_TIMEOUT_MS })
+        return this.request(PLATFORM_ROUTES.discover, z.object({ data: toolDiscoveryResultSchema }), { method: "POST", body: toolDiscoveryInputSchema.parse(options), timeoutMs: TOOL_DISCOVERY_REQUEST_TIMEOUT_MS, toolInput: true })
             .then(result => { this.toolNameHints.remember(result.data.tools.map(tool => tool.name), credential); return result; });
     }
     searchMetaTools(input) {
@@ -471,6 +472,18 @@ export class PlatformClient {
             query.set("connectionId", parsed.connectionId);
         return this.request(`${route(PLATFORM_ROUTES.triggerTypes)}?${query}`, z.object({ data: platformTriggerTypesSchema }));
     }
+    addMonitorDestination(id, destination) {
+        if (!PLATFORM_MONITOR_ID.test(id))
+            throw new Error("Provide a valid monitor ID.");
+        return this.request(route(PLATFORM_ROUTES.monitorDestinations, { id }), z.object({ data: z.object({ monitor: platformMonitorSchema }) }), { method: "POST", body: platformMonitorDestinationInputSchema.parse(destination) });
+    }
+    removeMonitorDestination(id, destinationId) {
+        if (!PLATFORM_MONITOR_ID.test(id))
+            throw new Error("Provide a valid monitor ID.");
+        if (!/^dst_[A-Za-z0-9_-]{1,100}$/.test(destinationId))
+            throw new Error("Provide a destination ID such as dst_….");
+        return this.request(route(PLATFORM_ROUTES.monitorDestinationDelete, { id, destinationId }), z.object({ data: z.object({ monitor: platformMonitorSchema }) }), { method: "POST", body: {} });
+    }
     addTriggerDestination(id, destination) {
         return this.request(route(PLATFORM_ROUTES.triggerDestinations, { id: triggerId(id) }), triggerResult, { method: "POST", body: platformTriggerDestinationInputSchema.parse(destination) });
     }
@@ -483,10 +496,10 @@ export class PlatformClient {
     customTools() { return this.request(route(PLATFORM_ROUTES.customTools), z.object({ data: z.object({ tools: z.array(platformCustomToolSummarySchema) }) })); }
     customTool(name) { return this.request(route(PLATFORM_ROUTES.customTool, { name: customToolName(name) }), customToolResult); }
     createCustomTool(input) {
-        return this.request(route(PLATFORM_ROUTES.customTools), customToolResult, { method: "POST", body: platformCustomToolCreateSchema.parse(input) });
+        return this.request(route(PLATFORM_ROUTES.customTools), customToolResult, { method: "POST", body: platformCustomToolCreateSchema.parse(input), toolInput: true });
     }
     updateCustomTool(name, input) {
-        return this.request(route(PLATFORM_ROUTES.customToolUpdate, { name: customToolName(name) }), customToolResult, { method: "POST", body: platformCustomToolUpdateSchema.parse(input) });
+        return this.request(route(PLATFORM_ROUTES.customToolUpdate, { name: customToolName(name) }), customToolResult, { method: "POST", body: platformCustomToolUpdateSchema.parse(input), toolInput: true });
     }
     deleteCustomTool(name) {
         return this.request(route(PLATFORM_ROUTES.customToolDelete, { name: customToolName(name) }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
@@ -498,12 +511,12 @@ export class PlatformClient {
         return this.request(route(PLATFORM_ROUTES.customToolRestore, { name: customToolName(name) }), customToolResult, { method: "POST", body: platformCustomToolRestoreSchema.parse(input) });
     }
     teamSkills() { return this.request(route(PLATFORM_ROUTES.teamSkills), z.object({ data: z.object({ skills: z.array(platformTeamSkillSummarySchema) }) })); }
-    teamSkill(slug) { return this.request(route(PLATFORM_ROUTES.teamSkill, { slug: teamSkillSlug(slug) }), teamSkillResult); }
+    teamSkill(slug) { return this.request(route(PLATFORM_ROUTES.teamSkill, { slug: teamSkillSlug(slug) }), teamSkillResult, { maximumResponseBytes: PLATFORM_TEAM_SKILL_LIMITS.requestBytes }); }
     createTeamSkill(input) {
-        return this.request(route(PLATFORM_ROUTES.teamSkills), teamSkillResult, { method: "POST", body: platformTeamSkillCreateSchema.parse(input) });
+        return this.request(route(PLATFORM_ROUTES.teamSkills), teamSkillResult, { method: "POST", body: platformTeamSkillCreateSchema.parse(input), maximumRequestBytes: PLATFORM_TEAM_SKILL_LIMITS.requestBytes, maximumResponseBytes: PLATFORM_TEAM_SKILL_LIMITS.requestBytes });
     }
     updateTeamSkill(slug, input) {
-        return this.request(route(PLATFORM_ROUTES.teamSkillUpdate, { slug: teamSkillSlug(slug) }), teamSkillResult, { method: "POST", body: platformTeamSkillUpdateSchema.parse(input) });
+        return this.request(route(PLATFORM_ROUTES.teamSkillUpdate, { slug: teamSkillSlug(slug) }), teamSkillResult, { method: "POST", body: platformTeamSkillUpdateSchema.parse(input), maximumRequestBytes: PLATFORM_TEAM_SKILL_LIMITS.requestBytes, maximumResponseBytes: PLATFORM_TEAM_SKILL_LIMITS.requestBytes });
     }
     deleteTeamSkill(slug) {
         return this.request(route(PLATFORM_ROUTES.teamSkillDelete, { slug: teamSkillSlug(slug) }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
@@ -512,7 +525,7 @@ export class PlatformClient {
         return this.request(route(PLATFORM_ROUTES.teamSkillVersions, { slug: teamSkillSlug(slug) }), z.object({ data: z.object({ versions: z.array(platformTeamSkillVersionSchema) }) }));
     }
     restoreTeamSkill(slug, input) {
-        return this.request(route(PLATFORM_ROUTES.teamSkillRestore, { slug: teamSkillSlug(slug) }), teamSkillResult, { method: "POST", body: platformTeamSkillRestoreSchema.parse(input) });
+        return this.request(route(PLATFORM_ROUTES.teamSkillRestore, { slug: teamSkillSlug(slug) }), teamSkillResult, { method: "POST", body: platformTeamSkillRestoreSchema.parse(input), maximumResponseBytes: PLATFORM_TEAM_SKILL_LIMITS.requestBytes });
     }
     suggestions() { return this.request(route(PLATFORM_ROUTES.suggestions), z.object({ data: platformSuggestionsSchema })); }
     access() { return this.request(route(PLATFORM_ROUTES.access), z.object({ data: platformTeamAccessSchema })); }
@@ -536,7 +549,7 @@ export class PlatformClient {
         return this.request(route(PLATFORM_ROUTES.workflowVersions, { slug: workflowSlug(slug) }), z.object({ data: z.object({ versions: z.array(platformWorkflowVersionSchema) }) }));
     }
     runWorkflow(slug, input, idempotencyKey) {
-        if (!idempotencySchema.safeParse(idempotencyKey).success)
+        if (!platformIdempotencyKeySchema.safeParse(idempotencyKey).success)
             throw new Error("Keep an idempotency key of 8–128 letters, digits, periods, underscores, colons or hyphens for this run.");
         return this.request(route(PLATFORM_ROUTES.workflowRuns, { slug: workflowSlug(slug) }), workflowRunResult, { method: "POST", body: platformWorkflowRunCreateSchema.parse(input), idempotencyKey });
     }
@@ -553,7 +566,7 @@ export class PlatformClient {
         const parsed = platformQuoteRequestSchema.safeParse(input);
         if (!parsed.success)
             throw new Error("Provide a tool name, a JSON object of arguments and an optional valid provider identifier.");
-        return this.request(route(PLATFORM_ROUTES.quote), quoteResultSchema, { method: "POST", body: parsed.data }).then(value => {
+        return this.request(route(PLATFORM_ROUTES.quote), quoteResultSchema, { method: "POST", body: parsed.data, toolInput: true }).then(value => {
             const receivedAt = Date.now(), expiresAt = Date.parse(value.data.expiresAt);
             return { ...value, timing: { receivedAtUtc: new Date(receivedAt).toISOString(),
                     expiresInSeconds: Number.isFinite(expiresAt) ? Math.max(0, Math.floor((expiresAt - receivedAt) / 1000)) : null } };
@@ -563,9 +576,9 @@ export class PlatformClient {
         const parsed = platformCreateExecutionSchema.safeParse(input);
         if (!parsed.success)
             throw new Error("Provide a tool, arguments, the quote's priceVersion and maximumChargeMicros, and an optional valid provider identifier.");
-        if (!idempotencySchema.safeParse(idempotencyKey).success)
+        if (!platformIdempotencyKeySchema.safeParse(idempotencyKey).success)
             throw new Error("Keep an idempotency key of 8–128 letters, digits, periods, underscores, colons or hyphens for this execution.");
-        return this.request(route(PLATFORM_ROUTES.tool, { tool: parsed.data.tool }), executionResultSchema, { method: "POST", body: parsed.data, idempotencyKey });
+        return this.request(route(PLATFORM_ROUTES.tool, { tool: parsed.data.tool }), executionResultSchema, { method: "POST", body: parsed.data, idempotencyKey, toolInput: true });
     }
     recoverExecution(input) {
         return this.request(route(PLATFORM_ROUTES.executionRecovery), z.object({ data: z.object({ execution: platformExecutionSchema.nullable() }) }), { method: "POST", body: platformRecoverExecutionSchema.parse(input) });

package/dist/client/local-input.js

@@ -1,7 +1,21 @@
 import { open } from "node:fs/promises";
 import { constants } from "node:fs";
-import { extname } from "node:path";
+import { basename, extname } from "node:path";
 import { platformInputMimeSchema, platformInputFileMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "./index.js";
+const sensitiveDirectories = new Set([
+    ".ssh", ".aws", ".gcloud", ".kube", ".config", ".git", ".docker", ".gnupg", ".azure", ".password-store",
+    ".claude", ".agents", ".codex", ".cursor", "_sessions",
+]);
+const sensitiveNames = new Set([
+    ".env", ".npmrc", ".netrc", ".git-credentials", ".pgpass", ".pypirc",
+    "credentials.json", "application_default_credentials.json", "id_rsa", "id_ed25519", "logins.json", "secrets.json",
+]);
+const sensitiveExtensions = new Set([".key", ".pem", ".p12", ".pfx", ".kdbx", ".db"]);
+export function isSensitiveLocalPath(path) {
+    const name = basename(path).toLowerCase();
+    return path.split(/[\\/]/).some((part) => sensitiveDirectories.has(part.toLowerCase()))
+        || sensitiveNames.has(name) || name.startsWith(".env") || sensitiveExtensions.has(extname(name));
+}
 const extensions = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".mp4": "video/mp4", ".mov": "video/quicktime", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp",
     ".gif": "image/gif", ".bmp": "image/bmp", ".pdf": "application/pdf", ".csv": "text/csv", ".tsv": "text/tab-separated-values", ".txt": "text/plain", ".json": "application/json", ".xml": "application/xml",
     ".zip": "application/zip", ".gz": "application/gzip", ".glb": "model/gltf-binary", ".gltf": "model/gltf+json", ".srt": "application/x-subrip", ".vtt": "text/vtt", ".bin": "application/octet-stream" };

package/dist/client/local-profile.js

@@ -49,27 +49,28 @@ export async function profileDirectory(path = localProfilePath(), create = false
     await safeDirectory(dirname(path), create, true);
     return dirname(path);
 }
-export async function readPrivateText(path, maximumBytes = 65536) {
+export async function readPrivateBytes(path, maximumBytes = 65536) {
     const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
         const info = await handle.stat();
         owned(info.mode, info.uid, true);
         if (!info.isFile() || info.size > maximumBytes || info.nlink !== 1)
             throw new Error("Relvo private file is invalid.");
-        return await handle.readFile("utf8");
+        return await handle.readFile();
     }
     finally {
         await handle.close();
     }
 }
+export async function readPrivateText(path, maximumBytes = 65536) { return (await readPrivateBytes(path, maximumBytes)).toString("utf8"); }
 export async function readPrivateJson(path, maximumBytes = 65536) { return JSON.parse(await readPrivateText(path, maximumBytes)); }
-export async function writePrivateText(path, value, privateParent = true, maximumBytes = 65536) {
+export async function writePrivateBytes(path, value, privateParent = true, maximumBytes = 65536) {
     const directory = dirname(path);
     await safeDirectory(directory, false, privateParent);
-    if (Buffer.byteLength(value, "utf8") > maximumBytes)
+    if (value.byteLength > maximumBytes)
         throw new Error("Relvo private file exceeds its size limit.");
     try {
-        await readPrivateText(path, maximumBytes);
+        await readPrivateBytes(path, maximumBytes);
     }
     catch (error) {
         if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
@@ -101,18 +102,44 @@ export async function writePrivateText(path, value, privateParent = true, maximu
             await handle.close();
     }
 }
+export async function writePrivateText(path, value, privateParent = true, maximumBytes = 65536) { await writePrivateBytes(path, Buffer.from(value, "utf8"), privateParent, maximumBytes); }
 export async function writePrivateJson(path, value, privateParent = true, maximumBytes = 65536) { await writePrivateText(path, JSON.stringify(value) + "\n", privateParent, maximumBytes); }
+export class LocalProfileError extends Error {
+    reason;
+    name = "LocalProfileError";
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+export const windowsLocalSetupRefusal = "Relvo's saved login and automatic setup need macOS or Linux. On Windows, connect your agent to the MCP URL shown under Getting started in the Relvo console.";
 export async function readLocalProfile(path = localProfilePath()) {
     try {
         await profileDirectory(path);
-        return localProfileSchema.parse(await readPrivateJson(path));
+        const raw = await readPrivateJson(path), parsed = localProfileSchema.safeParse(raw);
+        if (parsed.success)
+            return parsed.data;
+        if (raw === null || typeof raw !== "object" || !("managedBy" in raw) || raw.managedBy !== "relvo-cli")
+            throw new Error("Foreign profile");
+        throw new SyntaxError("Invalid profile");
     }
     catch (error) {
         if (error instanceof Error && "code" in error && error.code === "ENOENT")
             return null;
-        throw new Error("Relvo local profile is unsafe or invalid. No credentials were changed.");
+        if (process.platform === "win32")
+            throw new LocalProfileError("unsupported", windowsLocalSetupRefusal);
+        if (error instanceof SyntaxError)
+            throw new LocalProfileError("unreadable", `Relvo's saved login at ${path} is unreadable. Run relvo logout to remove it, then relvo setup. No credentials were changed.`);
+        throw new LocalProfileError("unsafe", `Relvo's saved login at ${path} is unsafe to use: it or a folder above it is a link, belongs to another user, is writable by others, or is not Relvo's file. Keep your home and .config folders writable only by you, then run chmod 700 ${dirname(path)} and chmod 600 ${path}. No credentials were changed.`);
     }
 }
+export async function removeUnreadableProfile(path) {
+    await profileDirectory(path);
+    const info = await lstat(path);
+    if (!info.isFile() || info.isSymbolicLink())
+        throw new LocalProfileError("unsafe", `Relvo's saved login at ${path} is not a regular file, so it was left in place.`);
+    await unlink(path);
+}
 export async function writeLocalProfile(path, profile) {
     await profileDirectory(path, true);
     await readLocalProfile(path);
@@ -147,7 +174,7 @@ export async function runtimeConfig(env, source, profile, requireProfileMatch =
         return environment;
     const saved = await readLocalProfile(profile);
     if (!saved || saved.state !== "ready" || saved.pendingAck || Date.parse(saved.grant.expiresAt) <= Date.now())
-        throw new Error("Relvo login is missing, incomplete or expired. Run relvo setup to resume.");
+        throw new LocalProfileError("missing", "Relvo login is missing, incomplete or expired. Run npx --yes @relvo/cli setup to resume.");
     if (environment && (environment.apiUrl.replace(/\/$/, "") !== saved.apiUrl || environment.apiKey !== saved.grant.apiKey || Boolean(environment.local) !== saved.local))
         throw new Error("Ambient Relvo credentials conflict with the explicitly selected managed profile. No project was selected.");
     return { apiUrl: saved.apiUrl, apiKey: saved.grant.apiKey, local: saved.local, source };