@relvo/mcp 0.1.2 → 0.1.4

package/dist/client/evm-wallet.js

@@ -0,0 +1,214 @@
+import { createECDH, createHash, createPrivateKey, sign } from "node:crypto";
+const P = 2n ** 256n - 2n ** 32n - 977n;
+const N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+const G = {
+    x: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+    y: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n,
+};
+export function keccak256(data) {
+    return createHash("keccak-256").update(data).digest();
+}
+function mod(a, m = P) {
+    const r = a % m;
+    return r >= 0n ? r : r + m;
+}
+function modPow(base, exponent, m) {
+    let result = 1n, b = mod(base, m), e = exponent;
+    while (e > 0n) {
+        if (e & 1n)
+            result = (result * b) % m;
+        b = (b * b) % m;
+        e >>= 1n;
+    }
+    return result;
+}
+function invert(a, m) {
+    let [r0, r1, t0, t1] = [m, mod(a, m), 0n, 1n];
+    while (r1 !== 0n) {
+        const q = r0 / r1;
+        [r0, r1] = [r1, r0 - q * r1];
+        [t0, t1] = [t1, t0 - q * t1];
+    }
+    return mod(t0, m);
+}
+function addPoints(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    let slope;
+    if (a.x === b.x) {
+        if (mod(a.y + b.y) === 0n)
+            return null;
+        slope = mod(3n * a.x * a.x * invert(2n * a.y, P));
+    }
+    else {
+        slope = mod((b.y - a.y) * invert(b.x - a.x, P));
+    }
+    const x = mod(slope * slope - a.x - b.x);
+    return { x, y: mod(slope * (a.x - x) - a.y) };
+}
+function multiply(point, scalar) {
+    let result = null, addend = point, k = scalar;
+    while (k > 0n) {
+        if (k & 1n)
+            result = addPoints(result, addend);
+        addend = addPoints(addend, addend);
+        k >>= 1n;
+    }
+    return result;
+}
+const toBytes32 = (value) => Buffer.from(value.toString(16).padStart(64, "0"), "hex");
+const toBigInt = (bytes) => BigInt(`0x${Buffer.from(bytes).toString("hex") || "0"}`);
+const hex = (bytes) => `0x${Buffer.from(bytes).toString("hex")}`;
+function addressOf(publicKey) {
+    return checksumAddress(`0x${keccak256(Buffer.concat([toBytes32(publicKey.x), toBytes32(publicKey.y)])).subarray(12).toString("hex")}`);
+}
+export function checksumAddress(address) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address))
+        throw new Error("Not an EVM address");
+    const lower = address.slice(2).toLowerCase();
+    const hash = keccak256(lower).toString("hex");
+    let out = "0x";
+    for (let i = 0; i < lower.length; i += 1)
+        out += parseInt(hash[i], 16) >= 8 ? lower[i].toUpperCase() : lower[i];
+    return out;
+}
+function recoverPoint(digest, r, s, recovery) {
+    if (r <= 0n || r >= N || s <= 0n || s >= N)
+        return null;
+    const ySquared = mod(r ** 3n + 7n);
+    let y = modPow(ySquared, (P + 1n) / 4n, P);
+    if (mod(y * y) !== ySquared)
+        return null;
+    if (Number(y & 1n) !== recovery)
+        y = P - y;
+    const rInverse = invert(r, N);
+    const u1 = mod(-toBigInt(digest) * rInverse, N), u2 = mod(s * rInverse, N);
+    return addPoints(multiply(G, u1), multiply({ x: r, y }, u2));
+}
+export function recoverAddress(digest, signature) {
+    if (digest.length !== 32 || !/^0x[0-9a-fA-F]{130}$/.test(signature))
+        throw new Error("Expected a 32-byte digest and a 65-byte signature");
+    const bytes = Buffer.from(signature.slice(2), "hex"), v = bytes[64];
+    if (v !== 27 && v !== 28)
+        throw new Error("Signature recovery id must be 27 or 28");
+    const point = recoverPoint(Buffer.from(digest), toBigInt(bytes.subarray(0, 32)), toBigInt(bytes.subarray(32, 64)), v - 27);
+    if (!point)
+        throw new Error("Signature does not recover a public key");
+    return addressOf(point);
+}
+export function hashPersonalMessage(message) {
+    return keccak256(personalMessageBytes(message));
+}
+function personalMessageBytes(message) {
+    const body = Buffer.from(message, "utf8");
+    return Buffer.concat([Buffer.from(`\x19Ethereum Signed Message:\n${body.length}`, "utf8"), body]);
+}
+const ATOMIC = new Set(["address", "uint256", "bytes32", "string"]);
+const DOMAIN_FIELDS = [
+    { name: "name", type: "string" }, { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" }, { name: "verifyingContract", type: "address" },
+];
+function dependencies(primary, types, found = new Set()) {
+    if (found.has(primary))
+        return found;
+    const fields = types[primary];
+    if (!fields)
+        throw new Error(`Unknown EIP-712 type ${primary}`);
+    found.add(primary);
+    for (const { type } of fields)
+        if (!ATOMIC.has(type))
+            dependencies(type, types, found);
+    return found;
+}
+export function encodeType(primary, types) {
+    const others = [...dependencies(primary, types)].filter((name) => name !== primary).sort();
+    return [primary, ...others].map((name) => `${name}(${types[name].map((field) => `${field.type} ${field.name}`).join(",")})`).join("");
+}
+export const typeHash = (primary, types) => keccak256(encodeType(primary, types));
+function encodeAtomic(type, value) {
+    if (type === "string") {
+        if (typeof value !== "string")
+            throw new Error("EIP-712 string value must be a string");
+        return keccak256(Buffer.from(value, "utf8"));
+    }
+    if (type === "address") {
+        if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value))
+            throw new Error("EIP-712 address value is invalid");
+        return Buffer.concat([Buffer.alloc(12), Buffer.from(value.slice(2), "hex")]);
+    }
+    if (type === "bytes32") {
+        if (typeof value !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value))
+            throw new Error("EIP-712 bytes32 value is invalid");
+        return Buffer.from(value.slice(2), "hex");
+    }
+    if (typeof value === "object" || typeof value === "string" && !/^(?:0x[0-9a-fA-F]+|\d+)$/.test(value) || typeof value === "number" && !Number.isSafeInteger(value))
+        throw new Error("EIP-712 uint256 value is invalid");
+    const number = BigInt(value);
+    if (number < 0n || number >= 2n ** 256n)
+        throw new Error("EIP-712 uint256 value is out of range");
+    return toBytes32(number);
+}
+export function hashStruct(primary, types, data) {
+    const parts = [typeHash(primary, types)];
+    for (const { name, type } of types[primary] ?? []) {
+        const value = data[name];
+        if (value === undefined)
+            throw new Error(`EIP-712 value for ${name} is missing`);
+        if (ATOMIC.has(type))
+            parts.push(encodeAtomic(type, value));
+        else if (typeof value === "object")
+            parts.push(hashStruct(type, types, value));
+        else
+            throw new Error(`EIP-712 value for ${name} must be a ${type} object`);
+    }
+    return keccak256(Buffer.concat(parts));
+}
+export function domainSeparator(domain) {
+    const fields = DOMAIN_FIELDS.filter(({ name }) => domain[name] !== undefined);
+    const data = {};
+    for (const { name } of fields)
+        data[name] = domain[name];
+    return hashStruct("EIP712Domain", { EIP712Domain: fields }, data);
+}
+export function hashTypedData(domain, types, primaryType, message) {
+    if (Object.hasOwn(types, "EIP712Domain"))
+        throw new Error("Pass the domain separately; types must not define EIP712Domain");
+    return keccak256(Buffer.concat([Buffer.from("1901", "hex"), domainSeparator(domain), hashStruct(primaryType, types, message)]));
+}
+export function loadEvmWallet(privateKeyHex) {
+    if (!/^0x[0-9a-fA-F]{64}$/.test(privateKeyHex))
+        throw new Error("The wallet private key must be 0x followed by 64 hex characters.");
+    const d = Buffer.from(privateKeyHex.slice(2), "hex"), scalar = toBigInt(d);
+    if (scalar <= 0n || scalar >= N)
+        throw new Error("The wallet private key is out of range.");
+    const ecdh = createECDH("secp256k1");
+    ecdh.setPrivateKey(d);
+    const uncompressed = ecdh.getPublicKey();
+    const publicKey = { x: toBigInt(uncompressed.subarray(1, 33)), y: toBigInt(uncompressed.subarray(33, 65)) };
+    const address = addressOf(publicKey);
+    const key = createPrivateKey({ key: { kty: "EC", crv: "secp256k1", d: d.toString("base64url"),
+            x: toBytes32(publicKey.x).toString("base64url"), y: toBytes32(publicKey.y).toString("base64url") }, format: "jwk" });
+    const signPreimage = (preimage) => {
+        const raw = sign("keccak-256", preimage, { key, dsaEncoding: "ieee-p1363" });
+        const r = toBigInt(raw.subarray(0, 32)), rawS = toBigInt(raw.subarray(32));
+        const s = rawS > N >> 1n ? N - rawS : rawS;
+        const digest = keccak256(preimage), body = `${hex(toBytes32(r))}${toBytes32(s).toString("hex")}`;
+        for (const v of ["1b", "1c"]) {
+            const point = recoverPoint(digest, r, s, v === "1b" ? 0 : 1);
+            if (point && point.x === publicKey.x && point.y === publicKey.y)
+                return `${body}${v}`;
+        }
+        throw new Error("No recovery id reproduces the wallet address.");
+    };
+    return {
+        address,
+        signPersonalMessage: (message) => signPreimage(personalMessageBytes(message)),
+        signTypedData: (domain, types, primaryType, message) => {
+            if (Object.hasOwn(types, "EIP712Domain"))
+                throw new Error("Pass the domain separately; types must not define EIP712Domain");
+            return signPreimage(Buffer.concat([Buffer.from("1901", "hex"), domainSeparator(domain), hashStruct(primaryType, types, message)]));
+        },
+    };
+}

package/dist/client/index.js

@@ -1,360 +1,3 @@
-import { z } from "zod";
-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";
-import { toolDiscoveryInputSchema, toolDiscoveryResultSchema, TOOL_DISCOVERY_REQUEST_TIMEOUT_MS } from "../schema/toolDiscovery.js";
-export { toolDiscoveryInputSchema } from "../schema/toolDiscovery.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 { 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 { platformInputFileSchema, platformInputUploadSchema, PLATFORM_UPLOAD_MAX_BYTES } from "../schema/platformPublicExecution.js";
-export { platformInputFileSchema, platformInputMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "../schema/platformPublicExecution.js";
-import { PLATFORM_EXECUTION_MAX_WAIT_SECONDS, PLATFORM_EXECUTION_RESPONSE_MAX_BYTES, platformCatalogSchema, platformQuoteSchema, platformExecutionSchema, platformExecutionContextSchema, platformExecutionResultPageSchema, platformExecutionIdSchema, platformCreateExecutionSchema, platformToolInputSchema, 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, 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 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_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_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_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_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_invalid_json: "The request body is not valid JSON.",
-    platform_body_too_large: "The request body is too large.",
-};
-export class PlatformApiError extends Error {
-    status;
-    code;
-    constructor(status, code, productName = PLATFORM_PRODUCT_NAMES.relvo) {
-        super(`${productName} API request failed (${status}). ${code && Object.hasOwn(publicErrors, code) ? publicErrors[code] : "Check the developer key, project access and limits in the console."}`);
-        this.status = status;
-        this.code = code;
-        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 relvoEnvironmentValue(env, name) {
-    const legacy = name.replace(/^RELVO_/, "TOOLHUB_"), value = env[name], previous = env[legacy];
-    if (value && previous && value !== previous)
-        throw new Error(`Conflicting ${name} and ${legacy}. No credentials were selected.`);
-    return value === undefined ? previous : value;
-}
-export function hasRelvoEnvironment(env) {
-    return ["RELVO_API_URL", "RELVO_API_KEY", "TOOLHUB_API_URL", "TOOLHUB_API_KEY"].some(name => env[name] !== undefined);
-}
-export function configFromEnvironment(env, source) {
-    if (hasRelvoEnvironment(env)) {
-        const apiUrl = relvoEnvironmentValue(env, "RELVO_API_URL"), apiKey = relvoEnvironmentValue(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: relvoEnvironmentValue(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;
-    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;
-        try {
-            options?.signal?.throwIfAborted();
-            const timeout = AbortSignal.timeout(options?.timeoutMs ?? 20000);
-            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(`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);
-            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() }) }).safeParse(payload);
-            const code = parsed.success && Object.hasOwn(publicErrors, parsed.data.error.message) ? parsed.data.error.message : null;
-            throw new PlatformApiError(response.status, code, this.productName);
-        }
-        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); }
-    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 = {}) {
-        return this.request(PLATFORM_ROUTES.discover, z.object({ data: toolDiscoveryResultSchema }), { method: "POST", body: toolDiscoveryInputSchema.parse(options), timeoutMs: TOOL_DISCOVERY_REQUEST_TIMEOUT_MS });
-    }
-    searchMetaTools(input) { return this.request(PLATFORM_ROUTES.metaSearch, z.object({ data: platformMetaSearchResultSchema }), { method: "POST", body: platformMetaSearchSchema.parse(input), timeoutMs: PLATFORM_META_LIMITS.requestTimeoutMs }); }
-    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);
-        return this.request(route(PLATFORM_ROUTES.definition, { name: encodeURIComponent(name) }), z.object({ data: schema }));
-    }
-    async tool(name) {
-        try {
-            return await this.inspectTool(name);
-        }
-        catch (error) {
-            if (error instanceof PlatformApiError && error.code === "platform_tool_unavailable")
-                throw new Error(`Tool is unavailable in the ${this.productName} catalog. Run tools to discover supported operations.`);
-            throw error;
-        }
-    }
-    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 }));
-    }
-    quote(input) {
-        const parsed = platformToolInputSchema.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 });
-    }
-    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 }));
-    }
-}
+export * from "./browser.js";
+export { loadEvmWallet } from "./evm-wallet.js";
+export { walletSignIn, walletTopUp, walletAutoTopUp, walletAutoTopUpFromEnvironment, WalletAccessError } from "./wallet-access.js";

package/dist/client/local-input.js

@@ -1,28 +1,35 @@
 import { open } from "node:fs/promises";
 import { constants } from "node:fs";
 import { extname } from "node:path";
-import { platformInputMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "./index.js";
-const extensions = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".mp4": "video/mp4", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp" };
-export async function uploadLocalInput(client, path) {
-    const mimeType = platformInputMimeSchema.safeParse(extensions[extname(path).toLowerCase()]);
+import { platformInputMimeSchema, platformInputFileMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "./index.js";
+const extensions = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".mp4": "video/mp4", ".mov": "video/quicktime", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp",
+    ".gif": "image/gif", ".bmp": "image/bmp", ".pdf": "application/pdf", ".csv": "text/csv", ".tsv": "text/tab-separated-values", ".txt": "text/plain", ".json": "application/json", ".xml": "application/xml",
+    ".zip": "application/zip", ".gz": "application/gzip", ".glb": "model/gltf-binary", ".gltf": "model/gltf+json", ".srt": "application/x-subrip", ".vtt": "text/vtt", ".bin": "application/octet-stream" };
+export async function uploadLocalInput(client, path, options = {}) {
+    const mimeType = platformInputFileMimeSchema.safeParse(options.mimeType ?? extensions[extname(path).toLowerCase()]);
     if (!mimeType.success)
-        throw new Error("Supported input files: JPG, PNG, WebP, WAV, MP3, MP4.");
+        throw new Error("Supported input files include images, audio, video, documents, archives and models; other extensions require an explicit MIME type.");
+    const range = options.byteRange;
+    if (range && (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start || range.end - range.start >= PLATFORM_INPUT_MAX_BYTES))
+        throw new Error("Input byte range must be nonnegative and at most 12 MiB.");
+    const purpose = options.purpose ?? (range || !platformInputMimeSchema.safeParse(mimeType.data).success ? "file" : undefined);
     let data;
     try {
         const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
         try {
             const stat = await file.stat();
-            if (!stat.isFile() || stat.size < 1 || stat.size > PLATFORM_INPUT_MAX_BYTES)
+            if (!stat.isFile() || stat.size < 1 || (range ? range.end >= stat.size : stat.size > PLATFORM_INPUT_MAX_BYTES))
                 throw new Error("Invalid file");
-            const buffer = Buffer.alloc(stat.size + 1);
+            const size = range ? range.end - range.start + 1 : stat.size;
+            const buffer = Buffer.alloc(size + (range ? 0 : 1));
             let offset = 0;
             while (offset < buffer.length) {
-                const { bytesRead } = await file.read(buffer, offset, buffer.length - offset, null);
+                const { bytesRead } = await file.read(buffer, offset, buffer.length - offset, range ? range.start + offset : null);
                 if (!bytesRead)
                     break;
                 offset += bytesRead;
             }
-            if (offset !== stat.size)
+            if (offset !== size)
                 throw new Error("File changed");
             data = buffer.subarray(0, offset).toString("base64");
         }
@@ -31,7 +38,7 @@ export async function uploadLocalInput(client, path) {
         }
     }
     catch {
-        throw new Error("Input must be an existing regular file, at most 12 MiB. Symlinks are not accepted.");
+        throw new Error("Input must be an existing regular file or a selected chunk, at most 12 MiB. Symlinks are not accepted.");
     }
-    return client.uploadInput({ mimeType: mimeType.data, data });
+    return client.uploadInput({ mimeType: mimeType.data, data, ...(purpose ? { purpose } : {}) });
 }