@relvo/mcp 0.1.2 → 0.1.3

package/dist/client/browser.js

@@ -0,0 +1,650 @@
+import { z } from "zod";
+import { ToolNameHints } from "./tool-name-hints.js";
+import { realtimeVoiceConfigSchema, realtimeVoiceGrantSchema, realtimeVoiceModelsSchema, connectRealtimeVoice } from "./realtime-voice.js";
+export { connectRealtimeVoice, RealtimeVoiceSession, RealtimeVoiceError } from "./realtime-voice.js";
+import { PLATFORM_CONNECTION_CATALOG_LIMITS, platformConnectionCatalogSchema, platformConnectionCatalogQuerySchema } from "../schema/platformConnectionCatalog.js";
+export { PLATFORM_CONNECTION_CATALOG_LIMITS, platformConnectionProviderSchema, platformConnectionCatalogQuerySchema } from "../schema/platformConnectionCatalog.js";
+import { TOOL_RESULT_CONTEXT_MAX_BYTES, toolResultSelectionSchema } from "../schema/toolResultContext.js";
+import { executionReceiptContext } from "./execution-context.js";
+export { executionReceiptContext, executionPageContext } from "./execution-context.js";
+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";
+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";
+import { isRelvoProduct, PLATFORM_API_KEY_PATTERN, PLATFORM_CLIENT_HEADERS, PLATFORM_KEY_PREFIXES, PLATFORM_PRODUCT_NAMES, platformKeyProduct } from "../schema/platformApiKey.js";
+import { readBoundedBody } from "../schema/boundedBody.js";
+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 { 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 { 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";
+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";
+import { PLATFORM_META_LIMITS, platformMetaSearchSchema, platformMetaSearchResultSchema, platformMetaSchemasSchema, platformMetaSchemasResultSchema, platformMetaConnectionsSchema, platformMetaConnectionsResultSchema, platformMetaExecuteSchema, platformMetaExecuteResultSchema, platformMetaWorkbenchSchema, platformMetaBashSchema, platformMetaRemoteResultSchema } from "../schema/platformMetaTools.js";
+export { PLATFORM_META_LIMITS, platformMetaSearchSchema, platformMetaSchemasSchema, platformMetaConnectionsSchema, platformMetaExecuteSchema, platformMetaWorkbenchSchema, platformMetaBashSchema } from "../schema/platformMetaTools.js";
+export { platformCreateExecutionSchema, platformToolInputSchema, platformQuoteRequestSchema, platformExecutionSchema, platformExecutionIdSchema, platformExecutionContextSchema, platformExecutionResultPageSchema, platformArtifactIdSchema, platformArtifactSchema, platformExecutionListQuerySchema } from "../schema/platformPublicExecution.js";
+export const projectResultSchema = z.object({ data: z.object({ developerOrganizationId: z.string(), developerProjectId: z.string(), name: z.string() }), requestId: z.string() });
+export const usageResultSchema = z.object({ data: z.object({ month: z.string(), requests: z.number().int().nonnegative(), amountCents: z.number().nonnegative(), currency: z.literal("usd") }), requestId: z.string() });
+export const executionResultSchema = z.object({ data: platformExecutionSchema });
+const executionContextResultSchema = z.object({ data: platformExecutionContextSchema });
+const catalogResultSchema = z.object({ data: platformCatalogSchema });
+export const platformToolDiscoverySchema = z.object({
+    query: z.string().trim().min(1).max(200).optional().describe("Substring of a tool's name, title, description, provider names or model IDs, ignoring case, whitespace, hyphens and underscores."),
+    category: platformCatalogSchema.shape.tools.element.shape.category.optional(),
+    provider: z.string().regex(/^[a-z][a-z0-9_]{1,63}$/).optional().describe("Filter discovery by a provider identifier from catalog metadata, such as anyapi or tikhub. Does not pin execution routing."),
+    availableOnly: z.boolean().optional().describe("Only tools with a configured provider; check executionEnabled separately."),
+    summary: z.boolean().optional().describe("Omit input schemas and examples; inspect a selected tool for those details."),
+}).strict();
+const quoteResultSchema = z.object({ data: platformQuoteSchema });
+const customToolResult = z.object({ data: z.object({ tool: platformCustomToolSchema }) });
+function customToolName(name) {
+    const parsed = platformCustomToolNameSchema.safeParse(name.startsWith(PLATFORM_CUSTOM_TOOL_PREFIX) ? name : `${PLATFORM_CUSTOM_TOOL_PREFIX}${name}`);
+    if (!parsed.success)
+        throw new Error("Provide a custom tool name such as custom__weekly_report.");
+    return parsed.data;
+}
+const teamSkillResult = z.object({ data: z.object({ skill: platformTeamSkillSchema }) });
+function teamSkillSlug(slug) {
+    if (!PLATFORM_TEAM_SKILL_SLUG.test(slug))
+        throw new Error("Provide a team skill slug such as competitor_pricing.");
+    return slug;
+}
+const workflowResult = z.object({ data: z.object({ workflow: platformWorkflowSchema }) });
+const workflowRunResult = z.object({ data: z.object({ run: platformWorkflowRunSchema }) });
+function workflowSlug(slug) {
+    if (!PLATFORM_WORKFLOW_SLUG.test(slug))
+        throw new Error("Provide a workflow slug such as company_people.");
+    return slug;
+}
+function workflowRunId(id) {
+    if (!platformWorkflowRunIdSchema.safeParse(id).success)
+        throw new Error("Provide a workflow run ID such as wfr_….");
+    return id;
+}
+const triggerResult = z.object({ data: z.object({ trigger: platformTriggerSchema }) });
+function triggerId(id) {
+    if (!platformTriggerIdSchema.safeParse(id).success)
+        throw new Error("Provide a trigger ID such as trg_….");
+    return id;
+}
+const idempotencySchema = 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.",
+    platform_idempotency_key_used_for_another_request: "This idempotency key was already used for another request. Keep the original body to retrieve its result.",
+    platform_executions_disabled: "Paid executions are paused.",
+    platform_provider_not_configured: "This tool's provider is unavailable.",
+    platform_provider_own_key_required: "This call runs only on the project's own provider API key, which the project has not added. A person adds it on the console's Connections page; retrying without it fails the same way.",
+    platform_provider_not_supported: "This provider does not support the selected tool and arguments. Choose Auto or a compatible provider from the catalog.",
+    platform_insufficient_balance_or_spending_limit_reached: "The prepaid balance or monthly spending limit is insufficient.",
+    platform_upload_requires_purchase: "Uploading files needs a purchased balance or your own provider key; the free signup credit does not cover it. Add funds in the console, then retry.",
+    platform_request_rate_exceeded: "The API key's request limit was reached. Wait before retrying.",
+    platform_api_key_suspended: "This API key is suspended for ignoring request limits. Wait for the suspension to end.",
+    platform_organization_suspended: "This organization's API access is suspended for ignoring request limits. Wait for the suspension to end.",
+    platform_authentication_unavailable: "Account verification is temporarily unavailable. Retry the same request shortly; the key does not need to change.",
+    platform_api_key_scope_required: "The API key is missing the required scope.",
+    platform_artifact_unavailable: "This output file is unavailable or its retention period has ended.",
+    platform_artifact_download_limit_reached: "This output file reached its limit of download URLs for the past 24 hours. Reuse a URL issued in the last five minutes, or try again later.",
+    platform_meta_tools_unavailable: "Session meta tools are unavailable on this API deployment.",
+    platform_tool_session_required: "Start a tool session with searchMetaTools and retain its session ID.",
+    platform_tool_session_unavailable: "This session is expired or unavailable to this project key. Preserve any uncertain purchases for reconciliation.",
+    platform_tool_session_limit_reached: "This key has reached its active tool session limit. Reuse an existing session or wait for expiry.",
+    platform_tool_session_busy: "This sandbox session has an active execution. Wait on that existing execution; needs_review requires reconciliation.",
+    platform_tool_session_state_lost: "This sandbox session has no reusable checkpoint. Preserve uncertain purchases and do not claim earlier state survives.",
+    [PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR]: "Execution metadata exceeds the context budget. Retain the execution ID to recover the raw result or select a narrower path.",
+    platform_tool_result_selection_invalid: "This result has no such path or fields. Read it with a shorter path, or without path and fields, to see its shape.",
+    platform_invalid_tool_request: "The request does not match the quote/execution contract. Check tool, arguments, provider, sessionId, priceVersion and maximumChargeMicros.",
+    platform_invalid_tool_arguments: "The arguments do not match this tool's input schema. Inspect the tool's schema and quote again.",
+    platform_tool_unavailable: "This tool is not in this project's catalog. Search the catalog again for an available tool.",
+    platform_idempotency_key_required: "Paid submissions need an idempotency key of 8-128 letters, digits, '.', '_', ':' or '-'. Retain it for retries.",
+    platform_invalid_media_input: "A media input is invalid for this tool. Check its type, size and duration against the tool's schema.",
+    platform_media_type_mismatch: "The file content does not match its declared media type.",
+    platform_image_reference_required: "This tool needs a reference image as documented in its schema.",
+    platform_audio_duration_exceeds_quote: "The audio is longer than the quoted duration. Quote again with the actual duration.",
+    platform_input_file_unavailable: "The uploaded input file is unavailable or expired. Upload it again and use the new file ID.",
+    platform_upload_quota_exceeded: "This project's daily input upload allowance is used up. Wait before uploading more files.",
+    platform_media_source_unavailable: "A referenced media source could not be read. Use a public URL, a current project file or a project artifact.",
+    platform_model_tariff_unavailable: "This model has no current price and cannot be quoted. Choose another model.",
+    platform_connection_not_configured: "This tool needs a project account connection. Connect the account in the console, then retry.",
+    platform_connection_reauthorize: "The connected account must be authorized again in the console before this tool can use it.",
+    platform_connection_scope_required: "The connected account lacks a permission this operation needs. Reconnect it with that permission in the console.",
+    platform_connection_policy_denied: "This connection's policy does not allow this operation or data range. A connection owner or project admin can change the policy in the console; retrying unchanged fails the same way.",
+    platform_approval_required: "This operation needs a team admin's approval on the console's Connections page. After approval, retry the same request.",
+    platform_connection_access_denied: "This key or member may not use this connection, or this operation on it. Use a connection from /tools/connections with a tool the tool list shows, or ask a team admin to grant it.",
+    platform_tool_access_denied: "This key or member may not use this tool. Add it to the key's tools in the console, ask a team admin to grant it, or use another key.",
+    platform_connection_authority_removed: "This key or member no longer has permission to use this connection.",
+    platform_connection_required: "No connection this key can use fits this tool. Connect an account in the console, or ask for access to a shared one.",
+    platform_connection_choice_required: "More than one connection fits this tool. Pass the connectionId of one from /tools/connections.",
+    platform_connection_provider_mismatch: "The selected connection is for a different service than this tool. Choose a connection of the tool's service.",
+    platform_connection_resource_mismatch: "The selected resource does not belong to this connected account. Use an ID listed for this connection.",
+    platform_connection_priced_operation_required: "X requests run only through X's separately priced tools. Use those instead of the generic request.",
+    platform_connection_provider_unavailable: "The connected account's service is temporarily unavailable. Retry later.",
+    platform_invalid_json: "The request body is not valid JSON.",
+    platform_body_too_large: "The request body is too large.",
+    platform_custom_tool_not_found: "No custom tool of that name exists in this project, or this key's member may not use it. List custom tools first.",
+    platform_custom_tool_exists: "This project already has a custom tool with that slug. Read it and update it instead, or choose another slug.",
+    platform_custom_tool_invalid: "The custom tool definition is invalid. Fix the fields named in details.fields.",
+    platform_custom_tool_schema_invalid: "The input schema cannot be used: it must be a JSON Schema object with properties, must compile, and cannot define sourceExecutionIds.",
+    platform_custom_tool_version_conflict: "The custom tool changed since it was read. Read it again and apply the edit to its current version (details.version).",
+    platform_custom_tool_not_editable: "Only the tool's creator or an organization admin may change this custom tool.",
+    platform_custom_tool_endpoints_unavailable: "API endpoints are not available in this deployment.",
+    platform_custom_tool_kind_immutable: "A custom tool keeps its kind: a Python tool cannot become an API endpoint or the reverse. Create a new tool instead.",
+    platform_custom_tool_endpoint_secrets_required: "Send the secret again for every binding: the base URL moved to another origin, or a binding's saved secret is gone. Saved secrets never travel to a new host.",
+    platform_custom_tool_restore_secret_missing: "That version names a binding whose secret is no longer saved. Add the binding again with its secret instead of restoring.",
+    platform_custom_tool_secret_ref_forbidden: "Only a team admin or the member who saved that secret may bind it to an endpoint. Use an inline secret, or ask an admin.",
+    platform_custom_tool_secret_ref_console_only: "A saved team secret can only be bound from the console, never with an API key. Send an inline secret instead.",
+    platform_custom_tool_limit_reached: "This project has reached its custom tool limit. Delete an unused tool first.",
+    platform_custom_tool_version_not_found: "That version of the custom tool is not kept. List its versions first.",
+    platform_team_skill_not_found: "No team skill with that slug exists in this project. List team skills first.",
+    platform_team_skill_exists: "This project already has a team skill with that slug. Read it and update it instead.",
+    platform_team_skill_invalid: "The team skill is invalid. Fix the fields named in details.fields.",
+    platform_team_skill_version_conflict: "The team skill changed since it was read. Read it again and apply the edit to its current version (details.version).",
+    platform_team_skill_not_deletable: "Only the skill's creator or an organization admin may delete this team skill. Update it instead.",
+    platform_team_skill_limit_reached: "This project has reached its team skill limit. Merge or delete skills first.",
+    platform_team_skill_version_not_found: "That version of the team skill is not kept. List its versions first.",
+    platform_workflow_not_found: "No workflow with that slug exists in this project. List workflows first.",
+    platform_workflow_exists: "This project already has a workflow with that slug. Read it and update it instead, or choose another slug.",
+    platform_workflow_invalid: "The workflow definition is invalid. Fix what details.fields or details.reason names: every tool must be in the project's catalog, and a reference names a declared input or an earlier step.",
+    platform_workflow_version_conflict: "The workflow changed since it was read. Read it again and apply the edit to its current version (details.version).",
+    platform_workflow_not_editable: "Only the workflow's creator or an organization admin may change this workflow.",
+    platform_workflow_limit_reached: "This project has reached its workflow limit. Delete an unused workflow first.",
+    platform_workflow_version_not_found: "That version of the workflow is not kept. List its versions first.",
+    platform_workflow_inputs_invalid: "The run inputs do not match the workflow's input schema. Fix the inputs named in details.fields.",
+    platform_workflow_run_limit_reached: "This project already has the most workflow runs in progress. Wait for one to finish or cancel one.",
+    platform_workflow_run_not_found: "No workflow run with that ID exists in this project.",
+    platform_workflow_run_owner_required: "Only the member who started the run or an admin may cancel it.",
+    platform_workflow_budget_exceeded: "The run stopped before a step whose price no longer fit what was left of maximumChargeMicros. Steps before it were charged; run again with a larger budget.",
+    platform_workflow_reference_missing: "The run stopped before a step whose $input or $step reference had no value. Check the earlier step's output and the reference path.",
+    platform_workflow_run_cancelled: "The run was cancelled; no later step was bought.",
+    platform_workflow_unavailable: "The run could not continue after repeated failures. Start it again.",
+    platform_triggers_unavailable: "Triggers are not available in this deployment.",
+    platform_trigger_invalid: "The trigger request is invalid. Fix the fields named in details.fields.",
+    platform_trigger_not_found: "No trigger with that ID exists in this project. List triggers first.",
+    platform_trigger_not_editable: "Only the trigger's creator or an organization admin may change this trigger.",
+    platform_trigger_limit_reached: "This project has reached its trigger limit. Delete an unused trigger first.",
+    platform_trigger_key_invalid: "The API key the trigger runs as is no longer valid. Create the trigger again with a key that may execute tools.",
+    platform_trigger_connection_app_mismatch: "The connection belongs to another app than the tool or trigger type. Use a connection of the same app.",
+    platform_trigger_operation_unknown: "That tool is not a read operation of the app. List trigger types for the app and choose one of its operations.",
+    platform_trigger_arguments_invalid: "The poll arguments do not match the operation's input schema. Fix the arguments named in details.fields.",
+    platform_trigger_items_path_not_found: "itemsPath points at nothing in the operation's response. Fix it or omit it to use the largest list.",
+    platform_trigger_type_unknown: "No trigger type with that name exists. List trigger types for the app first.",
+    platform_trigger_type_unavailable: "This trigger type cannot be received in this environment yet.",
+    platform_trigger_config_invalid: "The config does not match the trigger type's configSchema. Fix the fields named in details.fields.",
+    platform_trigger_destination_limit_reached: "This trigger has the most destinations allowed. Remove one first.",
+    platform_trigger_destination_not_found: "No destination with that ID exists on this trigger. Read the trigger first.",
+    platform_trigger_poll_price_above_maximum: "A poll now costs more than maximumChargeMicrosPerPoll, so the trigger stopped. Raise it or delete the trigger.",
+    platform_trigger_poll_failed: "The app's read operation failed, so the trigger stopped. Check the connection and enable the trigger again.",
+    platform_trigger_poll_unavailable: "The app's read operation is unavailable, so the trigger stopped. Enable the trigger again later.",
+    platform_trigger_registering: "Relvo is still registering the webhook with the app. Read the trigger again shortly.",
+};
+const usd = (micros) => `$${(Number(micros) / 1_000_000).toFixed(micros.length > 4 ? 2 : 4)}`;
+function shortfallText({ reason, requiredMicros, availableMicros }) {
+    if (reason === "balance")
+        return ` It needs ${usd(requiredMicros)} and the balance has ${usd(availableMicros)}. Top up the balance (relvo wallet top-up, or the console), then retry with the same idempotency key.`;
+    const scope = reason === "project_monthly_limit" ? "project's monthly" : reason === "api_key_daily_limit" ? "API key's daily" : reason === "organization_daily_limit" ? "organization's daily" : "organization's monthly";
+    const reset = reason.endsWith("_daily_limit") ? " The daily count starts again at 00:00 UTC." : "";
+    return ` It needs ${usd(requiredMicros)} and ${usd(availableMicros)} remains of the ${scope} spending limit.${reset} Topping up does not help; a person must raise the limit in the console.`;
+}
+export class PlatformApiError extends Error {
+    status;
+    code;
+    fields;
+    shortfall;
+    provider;
+    scope;
+    constructor(status, code, productName = PLATFORM_PRODUCT_NAMES.relvo, fields = [], shortfall, provider, scope) {
+        super(`${productName} API request failed (${status}). ${code && Object.hasOwn(publicErrors, code) ? publicErrors[code] : "Check the developer key, project access and limits in the console."}${fields.length ? ` Invalid fields: ${fields.join(", ")}.` : ""}${shortfall ? shortfallText(shortfall) : ""}${provider ? ` Provider key needed: ${provider}.` : ""}${scope ? ` Missing scope: ${scope}; create a key that includes it in the console.` : ""}`);
+        this.status = status;
+        this.code = code;
+        this.fields = fields;
+        this.shortfall = shortfall;
+        this.provider = provider;
+        this.scope = scope;
+        this.name = "PlatformApiError";
+    }
+}
+function contextBudgetFailure(error, id, kind) {
+    if (error instanceof PlatformApiError && error.code === PLATFORM_EXECUTION_CONTEXT_BUDGET_ERROR)
+        throw new PlatformExecutionContextBudgetError(id, kind);
+    throw error;
+}
+async function responseJson(response, maximumBytes, productName) {
+    const body = await readBoundedBody(response, maximumBytes);
+    if (body.status === "missing")
+        throw new Error(`The ${productName} API returned an empty response.`);
+    if (body.status === "too_large")
+        throw new Error(`The ${productName} API response is too large.`);
+    try {
+        return JSON.parse(new TextDecoder().decode(body.bytes));
+    }
+    catch {
+        throw new Error(`The ${productName} API returned an invalid response.`);
+    }
+}
+export function hasRelvoEnvironment(env) {
+    return env.RELVO_API_URL !== undefined || env.RELVO_API_KEY !== undefined;
+}
+export function configFromEnvironment(env, source) {
+    if (hasRelvoEnvironment(env)) {
+        const apiUrl = env.RELVO_API_URL, apiKey = env.RELVO_API_KEY;
+        if (!apiUrl || !apiKey)
+            throw new Error("Set RELVO_API_URL and RELVO_API_KEY from the Relvo console.");
+        return { apiUrl, apiKey, source, product: "relvo", local: env.RELVO_ENV === "local" };
+    }
+    if (!env.NOIMOS_PLATFORM_API_URL || !env.NOIMOS_PLATFORM_API_KEY) {
+        throw new Error(env.NOIMOS_PLATFORM_API_URL !== undefined || env.NOIMOS_PLATFORM_API_KEY !== undefined
+            ? "Set NOIMOS_PLATFORM_API_URL and NOIMOS_PLATFORM_API_KEY from the developer console."
+            : "Set RELVO_API_URL and RELVO_API_KEY from the Relvo console.");
+    }
+    return { apiUrl: env.NOIMOS_PLATFORM_API_URL, apiKey: env.NOIMOS_PLATFORM_API_KEY, source, product: "noimos", local: env.NOIMOS_PLATFORM_ENV === "local" };
+}
+export class PlatformClient {
+    config;
+    transport;
+    toolNameHints = new ToolNameHints();
+    async requestJournalScope() {
+        const bytes = new TextEncoder().encode(JSON.stringify([this.baseUrl, this.config.apiKey]));
+        return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)), value => value.toString(16).padStart(2, "0")).join("");
+    }
+    baseUrl;
+    productName;
+    holdsReads;
+    constructor(config, transport = (input, init) => fetch(input, init)) {
+        this.config = config;
+        this.transport = transport;
+        const product = config.product ?? platformKeyProduct(config.apiKey);
+        this.productName = PLATFORM_PRODUCT_NAMES[product === null || isRelvoProduct(product) ? "relvo" : "noimos"];
+        this.holdsReads = product !== null && isRelvoProduct(product);
+        const url = new URL(config.apiUrl);
+        if (url.username || url.password || url.search || url.hash || (url.protocol !== "https:" && !(config.local && url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))))
+            throw new Error(`The ${this.productName} API URL must use HTTPS. Explicit local mode permits loopback HTTP.`);
+        if (!PLATFORM_API_KEY_PATTERN.test(config.apiKey) || config.product && platformKeyProduct(config.apiKey) !== config.product)
+            throw new Error(`A dedicated ${PLATFORM_KEY_PREFIXES[config.product ?? "relvo"]} developer API key is required.`);
+        this.baseUrl = url.href.replace(/\/$/, "");
+    }
+    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.");
+        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.`;
+        let timeout;
+        try {
+            options?.signal?.throwIfAborted();
+            timeout = AbortSignal.timeout(timeoutMs);
+            response = await this.transport(`${this.baseUrl}${path}`, { method: options?.method ?? "GET", redirect: "error", signal: options?.signal ? AbortSignal.any([timeout, options.signal]) : timeout,
+                headers: { authorization: `Bearer ${this.config.apiKey}`, [PLATFORM_CLIENT_HEADERS[this.config.product ?? platformKeyProduct(this.config.apiKey) ?? "relvo"]]: this.config.source, "idempotency-key": options?.idempotencyKey ?? crypto.randomUUID(),
+                    ...(body === undefined ? {} : { "content-type": "application/json" }), ...(options?.prefer ? { prefer: options.prefer } : {}) }, ...(body === undefined ? {} : { body }) });
+        }
+        catch {
+            options?.signal?.throwIfAborted();
+            throw new Error(timeout?.aborted
+                ? timeoutMessage
+                : `The ${this.productName} API could not be reached. If submitting an execution, retry with the same body and idempotency key.`);
+        }
+        const maximumBytes = options?.maximumResponseBytes ?? (meta ? PLATFORM_META_LIMITS.contextBytes : PLATFORM_EXECUTION_RESPONSE_MAX_BYTES);
+        const payload = await responseJson(response, maximumBytes, this.productName).catch(() => {
+            options?.signal?.throwIfAborted();
+            if (!response.ok)
+                throw new PlatformApiError(response.status, null, this.productName);
+            if (timeout?.aborted)
+                throw new Error(timeoutMessage);
+            throw new Error(`The ${this.productName} API returned an invalid response. If submitting an execution, retain the same body and idempotency key.`);
+        });
+        if (!response.ok) {
+            const parsed = z.object({ error: z.object({ message: z.string(), details: z.unknown().optional() }) }).safeParse(payload);
+            const named = parsed.success ? [parsed.data.error.message, z.object({ code: z.string() }).safeParse(parsed.data.error.details).data?.code] : [];
+            const code = named.find(value => value !== undefined && Object.hasOwn(publicErrors, value)) ?? null;
+            const details = parsed.success ? parsed.data.error.details : undefined;
+            const fields = code === "platform_invalid_tool_arguments" ? z.object({ fields: platformInvalidArgumentFieldsSchema }).safeParse(details).data?.fields ?? [] : [];
+            const shortfall = code === "platform_insufficient_balance_or_spending_limit_reached" ? platformFundingShortfallSchema.safeParse(details).data : undefined;
+            const provider = code === "platform_provider_own_key_required" ? z.object({ provider: z.string().regex(/^[a-z0-9]{1,40}$/) }).safeParse(details).data?.provider : undefined;
+            const scope = code === "platform_api_key_scope_required" ? z.object({ scope: z.string().regex(/^[a-z]{1,20}:[a-z]{1,20}$/) }).safeParse(details).data?.scope : undefined;
+            throw new PlatformApiError(response.status, code, this.productName, fields, shortfall, provider, scope);
+        }
+        const parsed = schema.safeParse(payload);
+        if (!parsed.success)
+            throw new Error(`The ${this.productName} API returned an unexpected response. If submitting an execution, retain the same body and idempotency key.`);
+        return parsed.data;
+    }
+    project() { return this.request(route(PLATFORM_ROUTES.project), projectResultSchema); }
+    usage() { return this.request(route(PLATFORM_ROUTES.usage), usageResultSchema); }
+    connections(input = {}) {
+        const { provider, offset, limit } = platformConnectionCatalogQuerySchema.parse(input);
+        const query = new URLSearchParams({ offset: String(offset), limit: String(limit) });
+        if (provider)
+            query.set("provider", provider);
+        return this.request(`${route(PLATFORM_ROUTES.connections)}?${query}`, z.object({ data: platformConnectionCatalogSchema }), { maximumResponseBytes: PLATFORM_CONNECTION_CATALOG_LIMITS.responseBytes });
+    }
+    tools() { return this.request(route(PLATFORM_ROUTES.tools), catalogResultSchema); }
+    toolsPage(input = {}) {
+        const { offset, limit } = platformCatalogPageQuerySchema.parse(input);
+        return this.request(`${route(PLATFORM_ROUTES.tools)}?${new URLSearchParams({ offset: String(offset), limit: String(limit) })}`, z.object({ data: platformCatalogPageSchema }));
+    }
+    realtimeModels() { return this.request("/tools/realtime/models", z.object({ data: realtimeVoiceModelsSchema })); }
+    createRealtimeSession(input, signal) {
+        return this.request("/tools/realtime/sessions", z.object({ data: realtimeVoiceGrantSchema }), { method: "POST", body: realtimeVoiceConfigSchema.parse(input), signal });
+    }
+    async connectVoice(input, options = {}) {
+        const { data } = await this.createRealtimeSession(input, options.signal);
+        return connectRealtimeVoice(this.baseUrl, data, options);
+    }
+    async audioTools() {
+        const { data } = await this.tools();
+        return { data: { ...data, tools: data.tools.filter(tool => /(?:audio|speech|voice|music|sound)/.test(tool.name) || tool.name.startsWith("elevenlabs_")) } };
+    }
+    generateSpeech(input, idempotencyKey) { return this.createExecution({ ...input, tool: "generate_speech" }, idempotencyKey); }
+    transcribeAudio(input, idempotencyKey) { return this.createExecution({ ...input, tool: "transcribe_audio" }, idempotencyKey); }
+    translateAudio(input, idempotencyKey) { return this.createExecution({ ...input, tool: "translate_audio" }, idempotencyKey); }
+    generateAudioResponse(input, idempotencyKey) { return this.createExecution({ ...input, tool: "generate_audio_response" }, idempotencyKey); }
+    skills() { return this.request(PLATFORM_ROUTES.skills, z.object({ data: platformSkillsBundleSchema }), { maximumResponseBytes: 1048640 }); }
+    async skill(name) {
+        platformSkillSchema.shape.name.parse(name);
+        const { data } = await this.skills();
+        const skill = data.skills.find((entry) => entry.name === name);
+        if (!skill)
+            throw new Error(`The requested ${this.productName} guide is unavailable. Use platform_skills to discover current guides.`);
+        return { data: { version: data.version, ...skill } };
+    }
+    uploadInput(input) {
+        return this.request(PLATFORM_ROUTES.upload, z.object({ data: platformInputFileSchema }), { method: "POST", body: platformInputUploadSchema.parse(input) });
+    }
+    async discoverTools(options = {}) {
+        const { query, category, provider, availableOnly, summary } = platformToolDiscoverySchema.parse(options);
+        const { data } = await this.tools();
+        const search = query && normalizeToolSearch(query);
+        const tools = data.tools.filter((tool) => (!search || normalizeToolSearch(`${tool.name} ${tool.title ?? ""} ${tool.description} ${(tool.providers ?? []).map(row => row.name).join(" ")} ${(tool.models ?? []).map(row => row.id).join(" ")}`).includes(search)) &&
+            (!category || tool.category === category) && (!provider || tool.providers?.some(row => row.id === provider)) && (!availableOnly || tool.available));
+        return { data: { ...data, tools: summary ? tools.map(({ inputSchema, example, ...tool }) => tool) : tools } };
+    }
+    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 })
+            .then(result => { this.toolNameHints.remember(result.data.tools.map(tool => tool.name), credential); return result; });
+    }
+    searchMetaTools(input) {
+        const credential = this.config.apiKey;
+        return this.request(PLATFORM_ROUTES.metaSearch, z.object({ data: platformMetaSearchResultSchema }), { method: "POST", body: platformMetaSearchSchema.parse(input), timeoutMs: PLATFORM_META_LIMITS.requestTimeoutMs })
+            .then(result => { this.toolNameHints.remember(result.data.results.flatMap(group => group.tools.map(tool => tool.name)), credential); return result; });
+    }
+    getToolSchemas(input) { return this.request(PLATFORM_ROUTES.metaSchemas, z.object({ data: platformMetaSchemasResultSchema }), { method: "POST", body: platformMetaSchemasSchema.parse(input), timeoutMs: PLATFORM_META_LIMITS.requestTimeoutMs }); }
+    manageConnections(input) { return this.request(PLATFORM_ROUTES.metaConnections, z.object({ data: platformMetaConnectionsResultSchema }), { method: "POST", body: platformMetaConnectionsSchema.parse(input) }); }
+    multiExecute(input) { return this.request(PLATFORM_ROUTES.metaExecute, z.object({ data: platformMetaExecuteResultSchema }), { method: "POST", body: platformMetaExecuteSchema.parse(input), timeoutMs: PLATFORM_META_LIMITS.requestTimeoutMs }); }
+    remoteWorkbench(input) { return this.request(PLATFORM_ROUTES.metaWorkbench, z.object({ data: platformMetaRemoteResultSchema }), { method: "POST", body: platformMetaWorkbenchSchema.parse(input), timeoutMs: PLATFORM_META_LIMITS.requestTimeoutMs }); }
+    remoteBash(input) { return this.request(PLATFORM_ROUTES.metaBash, z.object({ data: platformMetaRemoteResultSchema }), { method: "POST", body: platformMetaBashSchema.parse(input), timeoutMs: PLATFORM_META_LIMITS.requestTimeoutMs }); }
+    inspectTool(name) {
+        platformToolNameSchema.parse(name);
+        const schema = platformCatalogSchema.shape.tools.element.extend(platformCatalogSchema.omit({ tools: true }).shape);
+        const credential = this.config.apiKey;
+        return this.request(route(PLATFORM_ROUTES.definition, { name: encodeURIComponent(name) }), z.object({ data: schema })).catch(error => {
+            if (error instanceof PlatformApiError && error.status === 404 && error.code === "platform_tool_unavailable")
+                error.message = `Tool is unavailable in the ${this.productName} catalog. ${this.toolNameHints.hint(name, credential) ?? "Run tools to discover supported operations."}`;
+            throw error;
+        });
+    }
+    async tool(name) { return this.inspectTool(name); }
+    executions(input = {}) {
+        const parsed = platformExecutionListQuerySchema.parse(input);
+        const query = new URLSearchParams({ limit: String(parsed.limit) });
+        if (parsed.before)
+            query.set("before", parsed.before);
+        if (parsed.status)
+            query.set("status", parsed.status);
+        if (parsed.tool)
+            query.set("tool", parsed.tool);
+        return this.request(`${route(PLATFORM_ROUTES.executions)}?${query}`, z.object({ data: platformExecutionListSchema }));
+    }
+    monitors() { return this.request(route(PLATFORM_ROUTES.monitors), z.object({ data: z.object({ monitors: z.array(platformMonitorSchema) }) })); }
+    createMonitor(input) {
+        return this.request(route(PLATFORM_ROUTES.monitors), z.object({ data: z.object({ monitor: platformMonitorSchema }) }), { method: "POST", body: platformMonitorCreateSchema.parse(input) });
+    }
+    deleteMonitor(id) {
+        if (!PLATFORM_MONITOR_ID.test(id))
+            throw new Error("Provide a valid monitor ID.");
+        return this.request(route(PLATFORM_ROUTES.monitorDelete, { id }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
+    }
+    monitorEvents(input = {}) {
+        const { monitorId, ...rest } = input;
+        if (monitorId !== undefined && !PLATFORM_MONITOR_ID.test(monitorId))
+            throw new Error("Provide a valid monitor ID.");
+        const parsed = platformMonitorEventsQuerySchema.parse(rest);
+        const query = new URLSearchParams({ limit: String(parsed.limit) });
+        if (parsed.after)
+            query.set("after", parsed.after);
+        const path = monitorId ? route(PLATFORM_ROUTES.monitorEvents, { id: monitorId }) : route(PLATFORM_ROUTES.monitorFeed);
+        return this.request(`${path}?${query}`, z.object({ data: platformMonitorEventsSchema }));
+    }
+    quoteMonitor(input) {
+        return this.request(route(PLATFORM_ROUTES.monitorQuote), z.object({ data: z.object({ quote: platformMonitorQuoteResultSchema }) }), { method: "POST", body: platformMonitorQuoteSchema.parse(input) });
+    }
+    resumeMonitor(id, input = {}) {
+        if (!PLATFORM_MONITOR_ID.test(id))
+            throw new Error("Provide a valid monitor ID.");
+        return this.request(route(PLATFORM_ROUTES.monitorResume, { id }), z.object({ data: z.object({ monitor: platformMonitorSchema }) }), { method: "POST", body: platformMonitorResumeSchema.parse(input) });
+    }
+    triggers() { return this.request(route(PLATFORM_ROUTES.triggers), z.object({ data: z.object({ triggers: z.array(platformTriggerSchema) }) })); }
+    trigger(id) { return this.request(route(PLATFORM_ROUTES.trigger, { id: triggerId(id) }), triggerResult); }
+    createTrigger(input) {
+        return this.request(route(PLATFORM_ROUTES.triggers), triggerResult, { method: "POST", body: platformTriggerCreateSchema.parse(input) });
+    }
+    updateTrigger(id, input) {
+        return this.request(route(PLATFORM_ROUTES.triggerUpdate, { id: triggerId(id) }), triggerResult, { method: "POST", body: platformTriggerUpdateSchema.parse(input) });
+    }
+    deleteTrigger(id) {
+        return this.request(route(PLATFORM_ROUTES.triggerDelete, { id: triggerId(id) }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
+    }
+    triggerEvents(input = {}) {
+        const { triggerId: id, ...rest } = input;
+        const parsed = platformTriggerEventsQuerySchema.parse(rest);
+        const query = new URLSearchParams({ limit: String(parsed.limit) });
+        if (parsed.after)
+            query.set("after", parsed.after);
+        const path = id === undefined ? route(PLATFORM_ROUTES.triggerFeed) : route(PLATFORM_ROUTES.triggerEvents, { id: triggerId(id) });
+        return this.request(`${path}?${query}`, z.object({ data: platformTriggerEventsSchema }));
+    }
+    triggerTypes(input) {
+        const parsed = platformTriggerTypesQuerySchema.parse(input);
+        const query = new URLSearchParams({ app: parsed.app, offset: String(parsed.offset), limit: String(parsed.limit) });
+        if (parsed.query)
+            query.set("query", parsed.query);
+        if (parsed.connectionId)
+            query.set("connectionId", parsed.connectionId);
+        return this.request(`${route(PLATFORM_ROUTES.triggerTypes)}?${query}`, z.object({ data: platformTriggerTypesSchema }));
+    }
+    addTriggerDestination(id, destination) {
+        return this.request(route(PLATFORM_ROUTES.triggerDestinations, { id: triggerId(id) }), triggerResult, { method: "POST", body: platformTriggerDestinationInputSchema.parse(destination) });
+    }
+    removeTriggerDestination(id, destinationId) {
+        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.triggerDestinationDelete, { id: triggerId(id), destinationId }), triggerResult, { method: "POST", body: {} });
+    }
+    popularMonitors() { return this.request(route(PLATFORM_ROUTES.monitorsPopular), z.object({ data: z.object({ monitors: z.array(platformPopularMonitorSchema) }) })); }
+    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) });
+    }
+    updateCustomTool(name, input) {
+        return this.request(route(PLATFORM_ROUTES.customToolUpdate, { name: customToolName(name) }), customToolResult, { method: "POST", body: platformCustomToolUpdateSchema.parse(input) });
+    }
+    deleteCustomTool(name) {
+        return this.request(route(PLATFORM_ROUTES.customToolDelete, { name: customToolName(name) }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
+    }
+    customToolVersions(name) {
+        return this.request(route(PLATFORM_ROUTES.customToolVersions, { name: customToolName(name) }), z.object({ data: z.object({ versions: z.array(platformCustomToolVersionSchema) }) }));
+    }
+    restoreCustomTool(name, input) {
+        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); }
+    createTeamSkill(input) {
+        return this.request(route(PLATFORM_ROUTES.teamSkills), teamSkillResult, { method: "POST", body: platformTeamSkillCreateSchema.parse(input) });
+    }
+    updateTeamSkill(slug, input) {
+        return this.request(route(PLATFORM_ROUTES.teamSkillUpdate, { slug: teamSkillSlug(slug) }), teamSkillResult, { method: "POST", body: platformTeamSkillUpdateSchema.parse(input) });
+    }
+    deleteTeamSkill(slug) {
+        return this.request(route(PLATFORM_ROUTES.teamSkillDelete, { slug: teamSkillSlug(slug) }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
+    }
+    teamSkillVersions(slug) {
+        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) });
+    }
+    suggestions() { return this.request(route(PLATFORM_ROUTES.suggestions), z.object({ data: platformSuggestionsSchema })); }
+    access() { return this.request(route(PLATFORM_ROUTES.access), z.object({ data: platformTeamAccessSchema })); }
+    updateMemberAccess(id, input) {
+        if (!/^[A-Za-z0-9-]{1,128}$/.test(id))
+            throw new Error("Provide a member ID as `access` lists it.");
+        return this.request(route(PLATFORM_ROUTES.memberAccess, { id }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: platformMemberAccessUpdateSchema.parse(input) });
+    }
+    workflows() { return this.request(route(PLATFORM_ROUTES.workflows), z.object({ data: z.object({ workflows: z.array(platformWorkflowSummarySchema) }) })); }
+    workflow(slug) { return this.request(route(PLATFORM_ROUTES.workflow, { slug: workflowSlug(slug) }), workflowResult); }
+    createWorkflow(input) {
+        return this.request(route(PLATFORM_ROUTES.workflows), workflowResult, { method: "POST", body: platformWorkflowCreateSchema.parse(input) });
+    }
+    updateWorkflow(slug, input) {
+        return this.request(route(PLATFORM_ROUTES.workflowUpdate, { slug: workflowSlug(slug) }), workflowResult, { method: "POST", body: platformWorkflowUpdateSchema.parse(input) });
+    }
+    deleteWorkflow(slug) {
+        return this.request(route(PLATFORM_ROUTES.workflowDelete, { slug: workflowSlug(slug) }), z.object({ data: z.object({ success: z.literal(true) }) }), { method: "POST", body: {} });
+    }
+    workflowVersions(slug) {
+        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)
+            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 });
+    }
+    workflowRuns(slug, query = {}) {
+        const parsed = platformWorkflowRunListQuerySchema.parse(query), search = new URLSearchParams({ limit: String(parsed.limit), ...(parsed.before ? { before: parsed.before } : {}) });
+        return this.request(`${route(PLATFORM_ROUTES.workflowRuns, { slug: workflowSlug(slug) })}?${search}`, z.object({ data: platformWorkflowRunListSchema }));
+    }
+    workflowRun(id) { return this.request(route(PLATFORM_ROUTES.workflowRun, { id: workflowRunId(id) }), workflowRunResult); }
+    cancelWorkflowRun(id) {
+        return this.request(route(PLATFORM_ROUTES.workflowRunCancel, { id: workflowRunId(id) }), workflowRunResult, { method: "POST", body: {} });
+    }
+    monitorableTools() { return this.request(route(PLATFORM_ROUTES.monitorTools), z.object({ data: z.object({ tools: z.array(platformMonitorableToolSchema) }) })); }
+    quote(input) {
+        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 => {
+            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 } };
+        });
+    }
+    createExecution(input, idempotencyKey) {
+        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)
+            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 });
+    }
+    recoverExecution(input) {
+        return this.request(route(PLATFORM_ROUTES.executionRecovery), z.object({ data: z.object({ execution: platformExecutionSchema.nullable() }) }), { method: "POST", body: platformRecoverExecutionSchema.parse(input) });
+    }
+    execution(id, signal, waitMs = 0) {
+        if (!platformExecutionIdSchema.safeParse(id).success)
+            throw new Error("Provide a valid execution ID.");
+        return this.request(route(PLATFORM_ROUTES.execution, { id }), executionResultSchema, { signal, ...this.heldRead(waitMs) });
+    }
+    executionContext(id, signal, waitMs = 0) {
+        platformExecutionIdSchema.parse(id);
+        return this.request(route(PLATFORM_ROUTES.executionContext, { id }), executionContextResultSchema, { signal, maximumResponseBytes: TOOL_RESULT_CONTEXT_MAX_BYTES + 65536, ...this.heldRead(waitMs) })
+            .then(result => executionReceiptContext(result)).catch(error => contextBudgetFailure(error, id, "execution"));
+    }
+    heldRead(waitMs) {
+        const seconds = this.holdsReads ? Math.min(PLATFORM_EXECUTION_MAX_WAIT_SECONDS, Math.floor(waitMs / 1000)) : 0;
+        return seconds > 0 ? { prefer: `wait=${seconds}`, timeoutMs: seconds * 1000 + 20000 } : {};
+    }
+    readExecutionResult(id, selection = {}) {
+        platformExecutionIdSchema.parse(id);
+        const body = toolResultSelectionSchema.parse(selection);
+        return this.request(route(PLATFORM_ROUTES.executionResult, { id }), z.object({ data: platformExecutionResultPageSchema }), { method: "POST", body, maximumResponseBytes: TOOL_RESULT_CONTEXT_MAX_BYTES + 65536 })
+            .then(result => platformExecutionResultPageContext(result, { readWith: "readExecutionResult" }))
+            .catch(error => contextBudgetFailure(error, id, "page"));
+    }
+    waitExecution(id, timeoutMs = 20000, signal) {
+        return this.waitForExecution(id, timeoutMs, signal, (executionId, abort, waitMs) => this.execution(executionId, abort, waitMs));
+    }
+    waitExecutionContext(id, timeoutMs = 20000, signal) {
+        return this.waitForExecution(id, timeoutMs, signal, (executionId, abort, waitMs) => this.executionContext(executionId, abort, waitMs));
+    }
+    async waitForExecution(id, timeoutMs, signal, read) {
+        platformExecutionIdSchema.parse(id);
+        if (!Number.isInteger(timeoutMs) || timeoutMs < 1000 || timeoutMs > 900000)
+            throw new Error("Wait must be between 1 and 900 seconds.");
+        const controller = new AbortController();
+        const timeout = new Error("Execution wait timed out; use the same execution ID to continue reading.");
+        const timer = setTimeout(() => controller.abort(timeout), timeoutMs);
+        const abort = () => controller.abort(signal?.reason);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        let latest = null;
+        const until = Date.now() + timeoutMs;
+        try {
+            for (;;) {
+                controller.signal.throwIfAborted();
+                const asked = Date.now();
+                latest = (await read(id, controller.signal, Math.max(0, until - asked - 1000))).data;
+                if (!["queued", "running", "waiting"].includes(latest.status))
+                    return { data: latest, id, timedOut: false };
+                const pauseMs = this.holdsReads ? Math.max(0, 5000 - (Date.now() - asked)) : 5000;
+                if (pauseMs > 0)
+                    await new Promise((resolve, reject) => {
+                        const done = () => { controller.signal.removeEventListener("abort", cancelled); resolve(); };
+                        const pause = setTimeout(done, pauseMs);
+                        const cancelled = () => { clearTimeout(pause); controller.signal.removeEventListener("abort", cancelled); reject(controller.signal.reason); };
+                        controller.signal.addEventListener("abort", cancelled, { once: true });
+                        if (controller.signal.aborted)
+                            cancelled();
+                    });
+            }
+        }
+        catch (error) {
+            if (error !== timeout)
+                throw error;
+            return { data: latest, id, timedOut: true };
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+        }
+    }
+    cancelExecution(id) {
+        if (!platformExecutionIdSchema.safeParse(id).success)
+            throw new Error("Provide a valid execution ID.");
+        return this.request(route(PLATFORM_ROUTES.executionCancel, { id }), executionResultSchema, { method: "POST" });
+    }
+    artifactDownload(id, artifactId) {
+        if (!platformExecutionIdSchema.safeParse(id).success || !platformArtifactIdSchema.safeParse(artifactId).success)
+            throw new Error("Provide valid execution and artifact IDs.");
+        return this.request(route(PLATFORM_ROUTES.artifactDownload, { id, artifact: artifactId }), z.object({ data: platformArtifactDownloadSchema }));
+    }
+}