@relvo/mcp 0.0.0-stage → 0.1.2

package/dist/mcp/runtime.js

@@ -0,0 +1,28 @@
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { configFromEnvironment, PlatformClient } from "../client/index.js";
+import { createPlatformMcp } from "./server.js";
+import { runtimeConfig } from "../client/local-profile.js";
+export async function startPlatformMcp(version = "0.1.2", profile) {
+    let handle;
+    try {
+        const client = new PlatformClient(profile ? await runtimeConfig(process.env, "mcp", profile, true) : configFromEnvironment(process.env, "mcp"));
+        handle = serveStdio(() => createPlatformMcp(client, version, true, Boolean(profile)), {
+            onerror: () => {
+                process.stderr.write(JSON.stringify({ severity: "ERROR", message: "Relvo MCP protocol error." }) + "\n");
+            },
+        });
+        const shutdown = async () => {
+            await handle?.close();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    catch {
+        process.stderr.write(JSON.stringify({
+            severity: "ERROR",
+            message: "Relvo MCP could not start. Check RELVO_API_URL and RELVO_API_KEY.",
+        }) + "\n");
+        process.exitCode = 1;
+    }
+}

package/dist/mcp/server.js

@@ -0,0 +1,179 @@
+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 { 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 { RELVO_MCP_INSTRUCTIONS } from "./instructions.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;
+};
+export function createPlatformMcp(client, version = "0.1.2", 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 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 } })) } });
+        for (let rank = 0; rank < Math.max(...value.data.results.map(result => result.tools.length)); rank++) {
+            for (const [index, result] of results.entries()) {
+                const tool = value.data.results[index].tools[rank];
+                if (!tool)
+                    continue;
+                result.tools.push(summary(tool));
+                if (!fits(response()))
+                    result.tools.pop();
+            }
+        }
+        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) => {
+        const data = { ...value.data, tools: [...value.data.tools], remaining: [...value.data.remaining] };
+        while (data.tools.length && !fits({ data })) {
+            const tool = data.tools.pop();
+            if (tool)
+                data.remaining.unshift(tool.name);
+        }
+        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) => {
+        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) => {
+        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),
+                requestFieldsOmitted: ["tool", "idempotencyKey"],
+                instruction: "Match each index to the saved original request for its tool/key. Wait/read accepted IDs for status and charges. Recover unknown admission with the identical request and keys; never replace accepted work." };
+            if (fits({ data }))
+                return { data };
+            return { data: { ...data, results: data.results.map(({ index, admission, executionId, errorCode }) => ({ index, admission, executionId, errorCode })),
+                    executionFieldsOmitted: ["status", "reservedMicros"] } };
+        });
+        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,
+            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,
+            execution: executionReceiptContext({ data: value.data.execution }, projectionOptions).data } })));
+    const respond = async (operation, untrustedTool, compact) => {
+        try {
+            return boundedMcpResult(await operation(), untrustedTool, compact);
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : "Relvo request failed." }] };
+        }
+    };
+    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(),
+            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 () => {
+            return respond(async () => operation());
+        });
+    }
+    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,
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false, idempotentHint: true },
+    }, ({ provider, offset, limit }) => respond(async () => {
+        const catalog = (await client.connections({ provider, offset, limit })).data;
+        return { data: catalog };
+    }, undefined, (value, fits) => {
+        const connections = [...value.data.connections];
+        const page = () => ({ data: { ...value.data, connections, nextOffset: offset + connections.length } });
+        while (connections.length && !fits(page()))
+            connections.pop();
+        if (!connections.length && value.data.connections.length)
+            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_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)));
+    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}$/) }),
+        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(),
+        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(),
+        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(),
+        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(),
+        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(),
+        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,
+        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 } });
+        while (executions.length && !fits(page()))
+            executions.pop();
+        if (!executions.length && value.data.executions.length)
+            throw new Error("Execution list metadata exceeds the context budget. Inspect a known execution ID.");
+        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(),
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true } }, async ({ id, timeoutSeconds }, { mcpReq }) => {
+        let failed = false;
+        const result = await respond(async () => {
+            const outcome = await client.waitExecutionContext(id, timeoutSeconds * 1000, mcpReq.signal);
+            failed = !outcome.timedOut && outcome.data?.status !== "succeeded";
+            return outcome;
+        }, "platform_wait", value => ({ ...value, data: value.data ? executionReceiptContext({ data: value.data }, projectionOptions).data : null }));
+        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" } })));
+    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 () => {
+        const value = await client.skill(name);
+        return inspectJsonContext(name, jsonObject.parse(value.data), selection, mcpContextFits);
+    }));
+    return server;
+}

package/dist/schema/amazonAds.js

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

package/dist/schema/boundedBody.js

@@ -0,0 +1,30 @@
+export async function readBoundedBody(message, maximumBytes) {
+    const reader = message.body?.getReader();
+    if (!reader)
+        return { status: "missing" };
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > maximumBytes) {
+                await reader.cancel();
+                return { status: "too_large" };
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { status: "ok", bytes };
+}

package/dist/schema/oauth2.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+export const oauth2ProviderSchema = z.enum(["google", "x", "github", "notion", "slack", "linear", "linkedin", "pinterest", "tiktok", "microsoft", "amazon"]);
+export const AMAZON_OAUTH_AUTHORIZATION_URLS = { na: "https://www.amazon.com/ap/oa", eu: "https://eu.account.amazon.com/ap/oa", fe: "https://apac.account.amazon.com/ap/oa" };
+export const oauth2TokenResponseSchema = z.object({
+    access_token: z.string().min(1),
+    refresh_token: z.string().min(1).optional(),
+    expires_in: z.number().positive().finite().optional(),
+    scope: z.string().optional(),
+    token_type: z.string().optional(),
+    error: z.never().optional(),
+});
+export const oauth2ExpiringTokenResponseSchema = oauth2TokenResponseSchema.extend({
+    expires_in: oauth2TokenResponseSchema.shape.expires_in.unwrap(),
+});
+export const oauth2ErrorResponseSchema = z.object({
+    error: z.string().min(1), error_description: z.string().optional(), log_id: z.string().optional(),
+});
+export const OAUTH2_PROVIDERS = {
+    google: { name: "Google", authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth", tokenUrl: "https://oauth2.googleapis.com/token", clientAuth: "body", encoding: "form", scopeSeparator: " ", pkce: true,
+        documentation: "https://developers.google.com/identity/protocols/oauth2/web-server" },
+    x: { name: "X", authorizeUrl: "https://x.com/i/oauth2/authorize", tokenUrl: "https://api.x.com/2/oauth2/token", clientAuth: "basic", encoding: "form", scopeSeparator: " ", pkce: true,
+        documentation: "https://docs.x.com/fundamentals/authentication/oauth-2-0/authorization-code" },
+    github: { name: "GitHub", authorizeUrl: "https://github.com/login/oauth/authorize", tokenUrl: "https://github.com/login/oauth/access_token", clientAuth: "body", encoding: "json", scopeSeparator: " ", pkce: true,
+        documentation: "https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authorizing-oauth-apps" },
+    notion: { name: "Notion", authorizeUrl: "https://api.notion.com/v1/oauth/authorize", tokenUrl: "https://api.notion.com/v1/oauth/token", clientAuth: "basic", encoding: "json", scopeSeparator: " ", pkce: false,
+        documentation: "https://developers.notion.com/guides/get-started/authorization" },
+    slack: { name: "Slack", authorizeUrl: "https://slack.com/oauth/v2/authorize", tokenUrl: "https://slack.com/api/oauth.v2.access", clientAuth: "basic", encoding: "form", scopeSeparator: ",", pkce: false,
+        documentation: "https://docs.slack.dev/authentication/installing-with-oauth/" },
+    linear: { name: "Linear", authorizeUrl: "https://linear.app/oauth/authorize", tokenUrl: "https://api.linear.app/oauth/token", clientAuth: "body", encoding: "form", scopeSeparator: ",", pkce: true,
+        documentation: "https://linear.app/developers/oauth-2-0-authentication" },
+    linkedin: { name: "LinkedIn", authorizeUrl: "https://www.linkedin.com/oauth/v2/authorization", tokenUrl: "https://www.linkedin.com/oauth/v2/accessToken", clientAuth: "body", encoding: "form", scopeSeparator: " ", pkce: false,
+        documentation: "https://learn.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow" },
+    pinterest: { name: "Pinterest", authorizeUrl: "https://www.pinterest.com/oauth/", tokenUrl: "https://api.pinterest.com/v5/oauth/token", clientAuth: "basic", encoding: "form", scopeSeparator: ",", pkce: false,
+        documentation: "https://developers.pinterest.com/docs/getting-started/set-up-authentication-and-authorization/" },
+    tiktok: { name: "TikTok", authorizeUrl: "https://www.tiktok.com/v2/auth/authorize/", tokenUrl: "https://open.tiktokapis.com/v2/oauth/token/", clientAuth: "body", encoding: "form", scopeSeparator: ",", pkce: false,
+        documentation: "https://developers.tiktok.com/docs/en/oauth-user-access-token-management" },
+    microsoft: { name: "Microsoft Advertising", authorizeUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize", tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token", clientAuth: "body", encoding: "form", scopeSeparator: " ", pkce: true,
+        documentation: "https://learn.microsoft.com/en-us/advertising/guides/authentication-oauth-consent?view=bingads-13" },
+    amazon: { name: "Amazon Advertising", authorizeUrl: AMAZON_OAUTH_AUTHORIZATION_URLS.na, tokenUrl: "https://api.amazon.com/auth/o2/token", clientAuth: "body", encoding: "form", scopeSeparator: " ", pkce: true,
+        documentation: "https://developer.amazon.com/docs/login-with-amazon/authorization-code-grant.html" },
+};
+export const OAUTH2_TOKEN_PROTOCOLS = {
+    ...OAUTH2_PROVIDERS,
+    wix: { tokenUrl: "https://www.wixapis.com/oauth2/token", clientAuth: "body", encoding: "json",
+        documentation: "https://dev.wix.com/docs/build-apps/develop-your-app/auth/authenticate-using-oauth" },
+    wordpress: { tokenUrl: "https://public-api.wordpress.com/oauth2/token", clientAuth: "body", encoding: "form",
+        documentation: "https://developer.wordpress.com/docs/api/oauth2/" },
+    snapchatMarketing: { tokenUrl: "https://accounts.snapchat.com/login/oauth2/access_token", clientAuth: "body", encoding: "form",
+        documentation: "https://developers.snap.com/marketing-api/Ads-API/authentication" },
+    hubspot: { tokenUrl: "https://api.hubapi.com/oauth/2026-03/token", clientAuth: "body", encoding: "form",
+        documentation: "https://developers.hubspot.com/docs/api-reference/legacy/authentication/oauth-tokens/v1/migration-guide" },
+    attio: { tokenUrl: "https://app.attio.com/oauth/token", clientAuth: "body", encoding: "form",
+        documentation: "https://docs.attio.com/docs/oauth/token" },
+    pipedrive: { tokenUrl: "https://oauth.pipedrive.com/oauth/token", clientAuth: "basic", encoding: "form",
+        documentation: "https://pipedrive.readme.io/docs/marketplace-oauth-authorization" },
+};
+export function isOAuth2AuthorizationUrl(provider, candidate) {
+    const actual = new URL(candidate);
+    const allowed = provider === "amazon" ? Object.values(AMAZON_OAUTH_AUTHORIZATION_URLS) : [OAUTH2_PROVIDERS[provider].authorizeUrl];
+    return !actual.username && !actual.password && !actual.hash && allowed.some(value => {
+        const expected = new URL(value);
+        return actual.origin === expected.origin && actual.pathname === expected.pathname;
+    });
+}

package/dist/schema/platformApiKey.js

@@ -0,0 +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_PRODUCT_NAMES = { noimos: "NoimosAI Platform", relvo: "Relvo" };
+export function isRelvoProduct(product) {
+    return product === "relvo" || product === "toolhub";
+}
+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 null;
+}

package/dist/schema/platformConnectionCatalog.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { TOOL_RESULT_CONTEXT_MAX_BYTES } from "./toolResultContext.js";
+export const platformConnectionProviderSchema = z.enum(["x", "gsc", "ga", "google", "github", "notion", "slack", "linear", "linkedin", "pinterest", "tiktok", "microsoftAds", "amazonAds"]);
+export function platformConnectionOAuthProvider(provider) {
+    return provider === "gsc" || provider === "ga" ? "google" : provider === "microsoftAds" ? "microsoft" : provider === "amazonAds" ? "amazon" : provider;
+}
+export const PLATFORM_CONNECTION_CATALOG_LIMITS = { maxRows: 20, responseBytes: 65_536, metadataBytes: 60_000, contextBytes: TOOL_RESULT_CONTEXT_MAX_BYTES };
+export const PLATFORM_CONNECTION_PAGE_MAX = PLATFORM_CONNECTION_CATALOG_LIMITS.maxRows;
+export const platformConnectionCatalogQuerySchema = z.object({
+    provider: platformConnectionProviderSchema.optional(),
+    offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+    limit: z.number().int().min(1).max(PLATFORM_CONNECTION_PAGE_MAX).default(10),
+}).strict();
+export const platformConnectionCatalogSchema = z.object({
+    connections: z.array(z.object({
+        id: z.string(), provider: platformConnectionProviderSchema, label: z.string(),
+        status: z.enum(["connected", "reauth_required"]), scopes: z.array(z.string()),
+    })).max(PLATFORM_CONNECTION_PAGE_MAX),
+    total: z.number().int().nonnegative(), nextOffset: z.number().int().nonnegative().nullable(),
+});

package/dist/schema/platformLocalSetup.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { developerKeyScopeSchema } from "./platformPublicExecution.js";
+import { PLATFORM_API_KEY_PATTERN } from "./platformApiKey.js";
+export const PLATFORM_LOCAL_SETUP_TTL_SECONDS = 600;
+export const PLATFORM_LOCAL_SETUP_INTERVAL_SECONDS = 5;
+export const platformLocalSetupClientSchema = z.enum(["claude", "codex", "agents", "terminal"]);
+export const platformLocalSetupAuthorizationSchema = z.string().min(1).max(4096);
+export const platformLocalSetupStartInputSchema = z.object({ client: platformLocalSetupClientSchema }).strict();
+export const platformLocalSetupProofSchema = z.object({ authorizationRequest: platformLocalSetupAuthorizationSchema,
+    deviceCode: z.string().regex(/^[A-Za-z0-9_-]{43}$/) }).strict();
+export const platformLocalSetupStartSchema = z.object({ authorizationRequest: platformLocalSetupAuthorizationSchema,
+    deviceCode: platformLocalSetupProofSchema.shape.deviceCode, userCode: z.string().regex(/^[A-Z2-9]{4}-[A-Z2-9]{4}$/),
+    verificationUri: z.url(), expiresAt: z.iso.datetime(), intervalSeconds: z.literal(PLATFORM_LOCAL_SETUP_INTERVAL_SECONDS) }).strict();
+const grantMetadata = { apiKeyId: z.string(), developerOrganizationId: z.string(), developerProjectId: z.string(),
+    scopes: z.array(developerKeyScopeSchema).min(1).max(5), expiresAt: z.iso.datetime(), approvedExpiresAt: z.iso.datetime() };
+export const platformLocalSetupAcknowledgedSchema = z.object({ status: z.literal("acknowledged"), ...grantMetadata }).strict();
+export const platformLocalSetupPollSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("pending"), expiresAt: z.iso.datetime(), intervalSeconds: z.literal(PLATFORM_LOCAL_SETUP_INTERVAL_SECONDS) }).strict(),
+    z.object({ status: z.literal("approved"), apiKey: z.string().regex(PLATFORM_API_KEY_PATTERN), ...grantMetadata }).strict(),
+    platformLocalSetupAcknowledgedSchema,
+]);
+export const platformLocalSetupMetadataSchema = z.object({ client: platformLocalSetupClientSchema,
+    expiresAt: z.iso.datetime(), status: z.enum(["pending", "approved", "acknowledged"]),
+    apiKeyId: z.string().optional(), developerOrganizationId: z.string().optional(), developerProjectId: z.string().optional(),
+    scopes: z.array(developerKeyScopeSchema).optional(), approvedExpiresAt: z.iso.datetime().optional() }).strict();

package/dist/schema/platformMetaTools.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { platformCatalogSchema, platformCreateExecutionSchema, platformExecutionIdSchema, platformExecutionStatusSchema, platformMicrosSchema, platformQuoteSchema, platformToolNameSchema, platformToolSessionIdSchema, platformOptionalToolSessionIdSchema, PLATFORM_SANDBOX_LIMITS, platformExecutionSchema, platformExecutionContextSchema, platformRequestIntentSchema } from "./platformPublicExecution.js";
+import { platformConnectionCatalogSchema, platformConnectionProviderSchema } from "./platformConnectionCatalog.js";
+import { toolDiscoveryInputSchema, toolDiscoveryResultSchema } from "./toolDiscovery.js";
+export const PLATFORM_META_LIMITS = { queries: 4, schemas: 12, batch: 50, concurrency: 4, contextBytes: 24_000,
+    requestBytes: 1_048_576, requestTimeoutMs: 90_000, sessionLifetimeMs: 86_400_000, activeSessions: 100,
+    codeChars: PLATFORM_SANDBOX_LIMITS.code, commandChars: 16_000, sourceExecutions: PLATFORM_SANDBOX_LIMITS.sourceExecutions, timeoutMs: PLATFORM_SANDBOX_LIMITS.timeoutMs };
+export const isSessionSandboxTool = (name) => name === "remote_workbench" || name === "remote_bash";
+export const platformToolSessionSchema = z.object({ id: platformToolSessionIdSchema, expiresAt: z.iso.datetime(),
+    sandbox: z.enum(["new", "ready", "busy", "needs_review", "state_lost"]), activeExecutionId: platformExecutionIdSchema.nullable() });
+const sessionInput = { sessionId: platformToolSessionIdSchema };
+export const platformMetaSearchSchema = z.object({ sessionId: platformOptionalToolSessionIdSchema.describe("Continue a returned session. Omit or use an empty string to open a new session."),
+    intent: platformRequestIntentSchema,
+    queries: z.array(toolDiscoveryInputSchema).min(1).max(PLATFORM_META_LIMITS.queries)
+        .describe("Independent capability queries, one action per query. Use exact app names when known; omit private account data.") }).strict();
+export const platformMetaSearchResultSchema = z.object({ session: platformToolSessionSchema,
+    results: z.array(z.object({ query: z.string().optional(), ...toolDiscoveryResultSchema.shape })),
+    nextSteps: z.array(z.enum(["inspect_schemas", "check_connections", "quote", "execute_independent", "process_results"])) });
+export const platformMetaSchemasSchema = z.object({ ...sessionInput,
+    tools: z.array(platformToolNameSchema).min(1).max(PLATFORM_META_LIMITS.schemas).refine(names => new Set(names).size === names.length, "Tool names must be unique") }).strict();
+export const platformMetaSchemasResultSchema = z.object({ session: platformToolSessionSchema,
+    tools: platformCatalogSchema.shape.tools, remaining: z.array(platformToolNameSchema) });
+export const platformMetaConnectionsSchema = z.object({ ...sessionInput,
+    providers: z.array(platformConnectionProviderSchema).max(platformConnectionProviderSchema.options.length).default([])
+        .describe("OAuth providers to inspect. Empty means all supported providers. Data-provider API keys are managed by Relvo.") }).strict();
+export const platformMetaConnectionsResultSchema = z.object({ session: platformToolSessionSchema,
+    developerOrganizationId: z.string(), developerProjectId: z.string(),
+    manageUrl: z.url(), connections: platformConnectionCatalogSchema.shape.connections,
+    total: z.number().int().nonnegative(), providers: z.array(z.object({ provider: platformConnectionProviderSchema,
+        status: z.enum(["connected", "reauth_required", "not_connected"]) })),
+    instruction: z.string() });
+const item = platformCreateExecutionSchema.omit({ sessionId: true }).extend({ idempotencyKey: z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/) }).strict();
+export const platformMetaExecuteSchema = z.object({ ...sessionInput,
+    maximumChargeMicros: platformMicrosSchema.describe("Accepted total reservation ceiling across this batch, in addition to each accepted quote."),
+    tools: z.array(item).min(1).max(PLATFORM_META_LIMITS.batch)
+        .describe("Logically independent, quoted calls only. Dependent calls must wait for their inputs in a later batch.") }).strict().superRefine((value, ctx) => {
+    if (new Set(value.tools.map(tool => tool.idempotencyKey)).size !== value.tools.length)
+        ctx.addIssue({ code: "custom", path: ["tools"], message: "Each call needs its own retained idempotency key" });
+    if (value.tools.reduce((total, tool) => total + tool.maximumChargeMicros, 0) > value.maximumChargeMicros)
+        ctx.addIssue({ code: "custom", path: ["maximumChargeMicros"], message: "Batch exceeds the accepted reservation ceiling" });
+});
+export const platformMetaExecuteResultSchema = z.object({ session: platformToolSessionSchema,
+    allAccepted: z.boolean(),
+    results: z.array(z.object({ index: z.number().int().nonnegative(), tool: platformToolNameSchema, idempotencyKey: z.string(),
+        admission: z.enum(["accepted", "rejected", "unknown"]), executionId: platformExecutionIdSchema.optional(),
+        status: platformExecutionStatusSchema.optional(), reservedMicros: platformMicrosSchema.optional(),
+        errorCode: z.string().optional() })),
+    instruction: z.string() });
+const remote = { ...sessionInput, timeoutMs: z.number().int().min(1000).max(PLATFORM_META_LIMITS.timeoutMs).default(30_000),
+    intent: platformRequestIntentSchema,
+    sourceExecutionIds: z.array(platformExecutionIdSchema).max(PLATFORM_META_LIMITS.sourceExecutions).default([])
+        .refine(ids => new Set(ids).size === ids.length, "Source execution IDs must be unique"),
+    quote: platformQuoteSchema,
+    idempotencyKey: item.shape.idempotencyKey };
+export const platformMetaWorkbenchSchema = z.object({ ...remote,
+    code: z.string().min(1).max(PLATFORM_META_LIMITS.codeChars).describe("Python cell in this session's remote sandbox. Variables and files persist. Process prior outputs via sourceExecutionIds; no provider credentials or direct tool proxy are present.") }).strict();
+export const platformMetaBashSchema = z.object({ ...remote,
+    command: z.string().min(1).max(PLATFORM_META_LIMITS.commandChars).describe("Bash command in this session's remote sandbox, never on the user's machine. Shares files with Python. No provider credentials are present.") }).strict();
+export const platformMetaRemoteResultSchema = z.object({ session: platformToolSessionSchema,
+    execution: z.union([platformExecutionContextSchema, platformExecutionSchema]) });

package/dist/schema/platformPublicExecution.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { fitToolResultPage, TOOL_RESULT_CONTEXT_MAX_BYTES, toolResultContextSchema, toolResultPageSchema } from "./toolResultContext.js";
+export const PLATFORM_EXECUTION_MAX_STEPS = 20;
+export const PLATFORM_EXECUTION_MAX_WAIT_SECONDS = 25;
+export const PLATFORM_STEP_OUTPUT_MAX_BYTES = 1_048_576;
+export const PLATFORM_EXECUTION_RESPONSE_MAX_BYTES = PLATFORM_EXECUTION_MAX_STEPS * PLATFORM_STEP_OUTPUT_MAX_BYTES + 65_536;
+export const platformJsonObjectSchema = z.record(z.string(), z.json());
+export const developerKeyScopeSchema = z.enum(["project:read", "usage:read", "tools:read", "tools:execute", "executions:read"]);
+export const PLATFORM_INPUT_MAX_BYTES = 12 * 1024 * 1024;
+export const PLATFORM_UPLOAD_MAX_BYTES = 16 * 1024 * 1024 + 4096;
+export const platformInputFileIdSchema = z.string().regex(/^f_[a-f0-9]{64}$/);
+export const platformInputMimeSchema = z.enum(["image/jpeg", "image/png", "image/webp", "audio/wav", "audio/mpeg", "video/mp4", "video/quicktime"]);
+export const platformInputUploadSchema = z.object({ mimeType: platformInputMimeSchema, data: z.string().min(4).max(16 * 1024 * 1024) }).strict();
+export const platformInputFileSchema = z.object({ id: platformInputFileIdSchema, mimeType: platformInputMimeSchema,
+    sizeBytes: z.number().int().positive().max(PLATFORM_INPUT_MAX_BYTES), sha256: z.string().regex(/^[a-f0-9]{64}$/), expiresAt: z.iso.datetime() });
+export const platformMicrosSchema = z.number().int().min(0).max(1_000_000_000_000);
+export const platformToolNameSchema = z.string().regex(/^[a-z][a-z0-9_]{1,63}$/);
+export const platformExecutionIdSchema = z.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
+export const platformToolSessionIdSchema = z.uuid();
+export const platformOptionalToolSessionIdSchema = z.union([platformToolSessionIdSchema, z.literal("")]).transform(value => value || undefined).optional();
+export const PLATFORM_SANDBOX_LIMITS = { code: 64000, sourceExecutions: 10, timeoutMs: 60000, sourceBytes: 32 * 1024 * 1024 };
+export const platformProviderChoiceSchema = z.string().trim().regex(/^(?:[a-z][a-z0-9_]{0,63})?$/)
+    .transform(value => value === "" || value === "auto" ? undefined : value).optional()
+    .describe("Omit, use auto, or use an empty string for automatic routing. A catalog provider ID strictly selects that compatible provider; no other provider is substituted.");
+export const PLATFORM_REQUEST_INTENT_MAX_CHARS = 1000;
+export const platformRequestIntentSchema = z.string().trim().max(PLATFORM_REQUEST_INTENT_MAX_CHARS).transform(value => value || undefined).optional()
+    .describe("Brief user goal without secrets or private content. Empty means omitted.");
+export const platformExecutionStatusSchema = z.enum(["queued", "running", "waiting", "succeeded", "failed", "cancelled", "needs_review"]);
+export const platformFundingSchema = z.enum(["relvo", "toolhub", "provider", "mixed"])
+    .transform(value => value === "toolhub" ? "relvo" : value);
+const platformModelFundingSchema = z.enum(["relvo", "toolhub", "provider"])
+    .transform(value => value === "toolhub" ? "relvo" : value);
+const workspaceArgumentNames = new Set(["workspaceid", "workspaceids", "teamid", "provideraccountid", "provideraccountids", "datasetid", "datasetids", "knowledgebaseid", "sessionid", "skillid"]);
+const standaloneArgumentsSchema = z.record(z.string(), z.unknown()).pipe(platformJsonObjectSchema).superRefine((value, context) => {
+    for (const key of Object.keys(value))
+        if (workspaceArgumentNames.has(key.replaceAll("_", "").toLowerCase())) {
+            context.addIssue({ code: "custom", path: [key], message: "Workspace-owned data is unavailable on the standalone Platform." });
+        }
+}).describe("Self-contained tool arguments: prompts, public URLs or public account identifiers. Web workspace identifiers are not supported.");
+export const platformToolInputSchema = z.object({ tool: platformToolNameSchema.describe("Tool name from the standalone Platform catalog."), arguments: standaloneArgumentsSchema,
+    provider: platformProviderChoiceSchema,
+    intent: platformRequestIntentSchema,
+    sessionId: platformOptionalToolSessionIdSchema.describe("Relvo tool session returned by platform_search_tools. Omit or use an empty string for standalone executions.") }).strict();
+export const platformCreateExecutionSchema = platformToolInputSchema.extend({
+    maximumChargeMicros: platformMicrosSchema,
+    priceVersion: z.string().min(1).max(100),
+}).strict();
+export const platformQuoteSchema = z.object({
+    tool: platformToolNameSchema, priceVersion: z.string(), currency: z.literal("usd"),
+    minimumChargeMicros: platformMicrosSchema, maximumChargeMicros: platformMicrosSchema,
+    expiresAt: z.string(),
+    funding: platformFundingSchema.optional(), externalBillingProviders: z.array(z.string()).optional(),
+});
+export const platformExecutionSchema = z.object({
+    id: platformExecutionIdSchema, tool: platformToolNameSchema, status: platformExecutionStatusSchema, cancelRequested: z.boolean(),
+    priceVersion: z.string(), currency: z.literal("usd"), reservedMicros: platformMicrosSchema, chargedMicros: platformMicrosSchema,
+    funding: platformFundingSchema.optional(), externalBillingProviders: z.array(z.string()).optional(),
+    output: platformJsonObjectSchema.nullable(), errorCode: z.string().nullable(),
+    createdAt: z.string(), updatedAt: z.string(), completedAt: z.string().nullable(),
+});
+export const platformExecutionContextSchema = platformExecutionSchema.extend({ resultContext: toolResultContextSchema.omit({ preview: true }) });
+export const platformExecutionResultPageSchema = z.object({ executionId: platformExecutionIdSchema, page: toolResultPageSchema });
+export const PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR = "platform_execution_context_budget_exceeded";
+export class PlatformExecutionContextBudgetError extends Error {
+    executionId;
+    kind;
+    code = PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR;
+    constructor(executionId, kind = "execution") {
+        super(kind === "page"
+            ? `Execution ${executionId} selected result page metadata exceeds the context budget. Read a narrower path or use a smaller limit/maxChars; the full result remains retained.`
+            : `Execution ${executionId} metadata exceeds the context budget. Recover it by this ID or the retained idempotency key.`);
+        this.executionId = executionId;
+        this.kind = kind;
+        this.name = "PlatformExecutionContextBudgetError";
+    }
+}
+const executionContextBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+export function platformExecutionReceiptContext(result, options) {
+    const maximumBytes = options.maximumBytes ?? TOOL_RESULT_CONTEXT_MAX_BYTES;
+    if (executionContextBytes(result) <= maximumBytes)
+        return result;
+    const existing = platformExecutionContextSchema.safeParse(result.data);
+    const compact = { data: platformExecutionContextSchema.parse({ ...result.data, output: null,
+            resultContext: { offloaded: true, totalBytes: existing.success ? existing.data.resultContext.totalBytes : executionContextBytes(result.data.output),
+                reference: { ...(existing.success ? existing.data.resultContext.reference : {}), executionId: result.data.id, readWith: options.readWith } },
+        }) };
+    if (executionContextBytes(compact) > maximumBytes)
+        throw new PlatformExecutionContextBudgetError(result.data.id);
+    return compact;
+}
+export function platformExecutionResultPageContext(result, options) {
+    const maximumBytes = options.maximumBytes ?? TOOL_RESULT_CONTEXT_MAX_BYTES;
+    if (executionContextBytes(result) <= maximumBytes)
+        return result;
+    const { executionId, page } = result.data;
+    const fitted = { data: { executionId, page: fitToolResultPage(page, candidate => executionContextBytes({ data: { executionId, page: candidate } }) <= maximumBytes) } };
+    if (executionContextBytes(fitted) <= maximumBytes)
+        return fitted;
+    const compact = { data: platformExecutionResultPageSchema.parse({ executionId, page: { ...page,
+                context: { ...page.context, offloaded: true, preview: null, reference: { ...page.context.reference,
+                        executionId, readWith: options.readWith, path: page.path, offset: page.offset } },
+            } }) };
+    if (executionContextBytes(compact) > maximumBytes)
+        throw new PlatformExecutionContextBudgetError(executionId, "page");
+    return compact;
+}
+export const platformExecutionListQuerySchema = z.object({
+    limit: z.number().int().min(1).max(100).default(20).describe("Page size, 1–100."),
+    before: platformExecutionIdSchema.optional().describe("nextBefore from the previous page."),
+    status: platformExecutionStatusSchema.optional().describe("Only executions with this status."),
+    tool: platformToolNameSchema.optional().describe("Only executions of this catalog tool."),
+}).strict();
+export const platformExecutionSummarySchema = platformExecutionSchema.omit({ output: true });
+export const platformExecutionListSchema = z.object({
+    executions: z.array(platformExecutionSummarySchema).max(100), nextBefore: z.string().nullable(),
+});
+export const platformArtifactIdSchema = z.string().regex(/^a_[A-Za-z0-9_-]{1,100}$/);
+export const platformArtifactSchema = z.object({
+    id: platformArtifactIdSchema, mimeType: z.enum(["image/jpeg", "image/png", "image/webp", "image/svg+xml", "audio/wav", "audio/mpeg", "audio/flac", "audio/l16", "audio/mulaw", "audio/alaw", "video/mp4", "video/quicktime", "model/gltf-binary", "application/zip"]),
+    sizeBytes: z.number().int().positive().max(64 * 1024 * 1024), sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    generation: z.string().regex(/^\d{1,30}$/), expiresAt: z.iso.datetime(),
+});
+export const platformArtifactDownloadSchema = z.object({ url: z.url().refine((value) => { const url = new URL(value); return url.protocol === "https:" && !url.username && !url.password; }), expiresAt: z.iso.datetime() });
+export const platformCatalogToolSchema = z.object({
+    name: platformToolNameSchema, title: z.string().optional(), description: z.string(), category: z.enum(["research", "seo", "social", "generation", "enrichment", "finance", "news"]),
+    available: z.boolean(), inputSchema: platformJsonObjectSchema, example: platformJsonObjectSchema,
+    providers: z.array(z.object({ id: z.string(), name: z.string(), available: z.boolean(),
+        role: z.enum(["primary", "fallback", "alternative"]), condition: z.string().optional() })).optional(),
+    models: z.array(z.object({ id: z.string(), available: z.boolean(), example: platformJsonObjectSchema, priceDescription: z.string(), funding: platformModelFundingSchema.optional() })).optional(),
+    price: z.object({ minimumChargeMicros: platformMicrosSchema, unit: z.string(), unitPriceMicros: platformMicrosSchema.nullable(), unitPriceCeilingMicros: platformMicrosSchema.optional(), description: z.string(),
+        funding: platformFundingSchema.optional(), externalBillingProviders: z.array(z.string()).optional() }),
+});
+const platformCatalogHeader = { priceVersion: z.string(), currency: z.literal("usd"), executionEnabled: z.boolean() };
+export const platformCatalogSchema = z.object({ ...platformCatalogHeader, tools: z.array(platformCatalogToolSchema) });
+export const platformCatalogSummarySchema = z.object({ ...platformCatalogHeader, tools: z.array(platformCatalogToolSchema.omit({ inputSchema: true })) });
+export const platformCatalogToolDetailSchema = z.object({ ...platformCatalogHeader, tool: platformCatalogToolSchema });