@noimosai/platform-mcp 0.1.3 → 0.1.5

package/dist/client/realtime-voice.js

@@ -0,0 +1,184 @@
+import { z } from "zod";
+import { platformJsonObjectSchema } from "../schema/platformPublicExecution.js";
+const protocol = z.enum(["gemini-live", "openai-live", "openai-realtime"]);
+export const realtimeVoiceConfigSchema = z.object({
+    model: z.string().min(1).max(100), priceVersion: z.string().min(1).max(40),
+    maximumChargeMicros: z.number().int().safe().min(50000).max(10000000).optional(),
+    maxDurationSeconds: z.number().int().min(1).max(300).optional(), maxOutputTokens: z.number().int().min(1).max(2048).optional(),
+    instructions: z.string().max(8000).optional(), locale: z.string().max(40).optional(), voice: z.string().max(80).optional(),
+    tools: z.array(z.object({ name: z.string(), description: z.string().optional(), parameters: platformJsonObjectSchema }).strict()).max(16).optional(),
+    clientOrigin: z.string().max(300).optional(),
+}).strict();
+export const realtimeVoiceModelsSchema = z.object({
+    priceVersion: z.string(), executionEnabled: z.boolean(),
+    models: z.array(z.object({ id: z.string(), provider: z.string(), protocol, inputSampleRate: z.number().int().positive(),
+        outputSampleRate: z.number().int().positive(), tools: z.enum(["functions", "delegation"]), configured: z.boolean() })),
+});
+export const realtimeVoiceGrantSchema = z.object({
+    clientSecret: z.string().min(1).max(2048), expiresAt: z.number().int(), path: z.literal("/v1/realtime"), protocol: z.literal("relvo-realtime"),
+    config: realtimeVoiceConfigSchema,
+});
+const startedSchema = z.object({ type: z.literal("relvo.session.started"), executionId: z.string().uuid(), model: z.string(), protocol,
+    inputSampleRate: z.number().int().positive(), outputSampleRate: z.number().int().positive() });
+const closedSchema = z.object({ type: z.literal("relvo.session.closed"), executionId: z.string().uuid().nullable(), usageConfirmed: z.boolean(),
+    status: z.enum(["succeeded", "failed", "cancelled", "needs_review"]), providerCostMicros: z.number().int().nonnegative() });
+export class RealtimeVoiceError extends Error {
+    executionId;
+    constructor(message, executionId) {
+        super(message);
+        this.executionId = executionId;
+        this.name = "RealtimeVoiceError";
+    }
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export class RealtimeVoiceSession {
+    socket;
+    session;
+    requestClose;
+    closed;
+    constructor(socket, session, closed, requestClose) {
+        this.socket = socket;
+        this.session = session;
+        this.requestClose = requestClose;
+        this.closed = closed;
+    }
+    static async connect(apiUrl, rawGrant, options = {}) {
+        const grant = realtimeVoiceGrantSchema.parse(rawGrant), url = new URL(grant.path, apiUrl), base = new URL(apiUrl);
+        if (base.username || base.password || base.search || base.hash || !["http:", "https:"].includes(base.protocol)
+            || (base.protocol === "http:" && !["127.0.0.1", "localhost", "[::1]"].includes(base.hostname)))
+            throw new Error("Use an HTTPS voice API URL or loopback HTTP.");
+        if (grant.expiresAt <= Date.now() / 1000)
+            throw new Error("Voice connection token expired. Request a new one.");
+        options.signal?.throwIfAborted();
+        url.protocol = base.protocol === "https:" ? "wss:" : "ws:";
+        const socket = (options.createWebSocket ?? ((target, protocols) => new WebSocket(target, protocols)))(url.href, [grant.protocol, `relvo-session.${grant.clientSecret}`]);
+        let complete = false, ready = false, opened = false, closing = false, executionId = null, closeTimer, rejectReady = () => { };
+        let resolveClosed = () => { }, rejectClosed = () => { };
+        const closed = new Promise((resolve, reject) => { resolveClosed = resolve; rejectClosed = reject; });
+        void closed.catch(() => { });
+        const failure = (message) => { const error = new RealtimeVoiceError(message, executionId); rejectReady(error); rejectClosed(error); socket.close(); };
+        const cancelled = () => {
+            if (closing || complete)
+                return;
+            closing = true;
+            if (socket.readyState === 1)
+                socket.send(JSON.stringify({ type: "relvo.session.close" }));
+            else
+                socket.close();
+            closeTimer = setTimeout(() => failure("Voice finalization timed out. Read the execution receipt before retrying."), 25000);
+        };
+        options.signal?.addEventListener("abort", cancelled, { once: true });
+        socket.addEventListener("close", () => {
+            clearTimeout(timer);
+            clearTimeout(closeTimer);
+            options.signal?.removeEventListener("abort", cancelled);
+            if (!complete)
+                failure(opened ? "Voice disconnected before final usage was confirmed. Read the execution receipt before retrying." : "The voice connection closed before it opened, so no session started.");
+        }, { once: true });
+        socket.addEventListener("error", () => failure("The Relvo voice connection failed."), { once: true });
+        const timer = setTimeout(() => failure("Voice session setup timed out."), 25000);
+        return new Promise((resolve, reject) => {
+            rejectReady = reject;
+            socket.addEventListener("open", () => { opened = true; socket.send(JSON.stringify({ type: "relvo.session.configure", config: grant.config })); }, { once: true });
+            socket.addEventListener("message", event => {
+                let value;
+                try {
+                    if (typeof event.data !== "string" || event.data.length > 1500000)
+                        throw new Error("Invalid voice event");
+                    value = JSON.parse(event.data);
+                }
+                catch {
+                    failure("Invalid Relvo voice event.");
+                    return;
+                }
+                if (!isRecord(value)) {
+                    failure("Invalid Relvo voice event.");
+                    return;
+                }
+                if (typeof value.executionId === "string" && z.string().uuid().safeParse(value.executionId).success)
+                    executionId = value.executionId;
+                const started = startedSchema.safeParse(value), ended = closedSchema.safeParse(value);
+                if (started.success && !ready) {
+                    ready = true;
+                    clearTimeout(timer);
+                    resolve(new RealtimeVoiceSession(socket, started.data, closed, cancelled));
+                }
+                if (ended.success) {
+                    complete = true;
+                    clearTimeout(closeTimer);
+                    resolveClosed(ended.data);
+                    if (!ready)
+                        reject(new RealtimeVoiceError(`Voice session ended during setup with status ${ended.data.status}.${executionId ? " Read the execution receipt before retrying." : ""}`, executionId));
+                    socket.close();
+                }
+                if (value.type === "relvo.error" && !ready)
+                    reject(new RealtimeVoiceError(`Voice session rejected: ${typeof value.code === "string" ? value.code : "unknown"}`, executionId));
+                try {
+                    if (typeof value.delta === "string" && ["session.output_audio.delta", "response.output_audio.delta", "response.audio.delta"].includes(String(value.type)))
+                        options.onAudio?.(value.delta, 24000);
+                    if (isRecord(value.serverContent) && isRecord(value.serverContent.modelTurn) && Array.isArray(value.serverContent.modelTurn.parts)) {
+                        for (const part of value.serverContent.modelTurn.parts)
+                            if (isRecord(part) && isRecord(part.inlineData)
+                                && typeof part.inlineData.data === "string" && typeof part.inlineData.mimeType === "string" && part.inlineData.mimeType.startsWith("audio/pcm"))
+                                options.onAudio?.(part.inlineData.data, 24000);
+                    }
+                    options.onEvent?.(value);
+                }
+                catch {
+                    failure("The voice event handler failed. Read the execution receipt before retrying.");
+                }
+            });
+            if (options.signal?.aborted)
+                cancelled();
+        });
+    }
+    send(event) {
+        if (this.socket.readyState !== 1 || this.socket.bufferedAmount > 1024 * 1024)
+            throw new Error("Voice is closed or its send buffer is full.");
+        const data = JSON.stringify(event);
+        if (new TextEncoder().encode(data).length > 65536)
+            throw new Error("Voice frame exceeds 64 KiB.");
+        this.socket.send(data);
+    }
+    sendAudio(audio) {
+        if (!audio || audio.length > 64000 || audio.length % 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(audio))
+            throw new Error("Provide a bounded base64 PCM16 frame.");
+        if (this.session.protocol === "gemini-live")
+            this.send({ realtimeInput: { audio: { data: audio, mimeType: `audio/pcm;rate=${this.session.inputSampleRate}` } } });
+        else
+            this.send({ type: this.session.protocol === "openai-live" ? "session.input_audio.append" : "input_audio_buffer.append", audio });
+    }
+    sendText(text) {
+        if (this.session.protocol === "gemini-live")
+            this.send({ clientContent: { turns: [{ role: "user", parts: [{ text }] }], turnComplete: true } });
+        else if (this.session.protocol === "openai-live")
+            this.sendDelegationResult(null, text);
+        else {
+            this.send({ type: "conversation.item.create", item: { type: "message", role: "user", content: [{ type: "input_text", text }] } });
+            this.send({ type: "response.create" });
+        }
+    }
+    sendToolResult(call) {
+        this.sendToolResults([call]);
+    }
+    sendToolResults(calls) {
+        if (!calls.length || calls.length > 16)
+            throw new Error("Return between one and sixteen tool results.");
+        if (this.session.protocol === "openai-live")
+            throw new Error("GPT-Live uses sendDelegationResult instead of function calls.");
+        if (this.session.protocol === "gemini-live")
+            this.send({ toolResponse: { functionResponses: calls.map(call => ({ id: call.id, name: call.name, response: call.output })) } });
+        else {
+            for (const call of calls)
+                this.send({ type: "conversation.item.create", item: { type: "function_call_output", call_id: call.id, output: JSON.stringify(call.output) } });
+            this.send({ type: "response.create" });
+        }
+    }
+    sendDelegationResult(delegationId, content) {
+        if (this.session.protocol !== "openai-live")
+            throw new Error("This model uses function calls instead of client delegation.");
+        this.send({ type: "session.commentary.append", delegation_id: delegationId, content });
+    }
+    close() { this.requestClose(); return this.closed; }
+}
+export const connectRealtimeVoice = RealtimeVoiceSession.connect;

package/dist/client/tool-name-hints.js

@@ -0,0 +1,48 @@
+const MAX_REMEMBERED_NAMES = 64, MAX_SUGGESTIONS = 3;
+const normalized = (name) => name.split("_").map(word => word.length > 4 ? word.replace(/ies$/, "y").replace(/s$/, "") : word).join("_");
+function oneEditApart(left, right) {
+    if (Math.abs(left.length - right.length) > 1)
+        return false;
+    let a = 0, b = 0, edits = 0;
+    while (a < left.length && b < right.length) {
+        if (left[a] === right[b]) {
+            a++;
+            b++;
+            continue;
+        }
+        if (++edits > 1)
+            return false;
+        if (left.length <= right.length)
+            b++;
+        if (left.length >= right.length)
+            a++;
+    }
+    return edits + Number(a < left.length || b < right.length) <= 1;
+}
+export class ToolNameHints {
+    names = new Set();
+    credential;
+    remember(names, credential) {
+        if (this.credential !== credential) {
+            this.names.clear();
+            this.credential = credential;
+        }
+        for (const name of names) {
+            this.names.delete(name);
+            this.names.add(name);
+            if (this.names.size > MAX_REMEMBERED_NAMES) {
+                const oldest = this.names.values().next().value;
+                if (oldest !== undefined)
+                    this.names.delete(oldest);
+            }
+        }
+    }
+    hint(requested, credential) {
+        if (credential !== this.credential)
+            return undefined;
+        const query = normalized(requested), prefix = requested.split("_")[0];
+        const found = [...this.names].filter(name => name !== requested && name.split("_")[0] === prefix && oneEditApart(query, normalized(name)))
+            .sort((a, b) => Number(normalized(a) !== query) - Number(normalized(b) !== query) || a.localeCompare(b)).slice(0, MAX_SUGGESTIONS);
+        return found.length ? `Loaded tool names: ${found.join(", ")}. Inspect the intended definition before quoting.` : undefined;
+    }
+}

package/dist/client/wallet-access.js

@@ -0,0 +1,214 @@
+import { randomBytes } from "node:crypto";
+import { z } from "zod";
+import { PLATFORM_WALLET_ROUTES } from "../schema/platformRoutes.js";
+import { PLATFORM_WALLET_TOP_UP_MIN_CENTS } from "../schema/platformFunding.js";
+import { checksumAddress, loadEvmWallet } from "./evm-wallet.js";
+import { relvoApiUrl } from "./local-setup.js";
+import { PLATFORM_DISTRIBUTION } from "./distribution.js";
+const MICROS_PER_CENT = 10_000;
+const REQUEST_TIMEOUT_MS = 60_000;
+const SIGN_IN_HEADER = "SIGN-IN-WITH-X";
+const PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+const PAYMENT_SIGNATURE_HEADER = "PAYMENT-SIGNATURE";
+const NETWORKS = {
+    "eip155:8453": { chainId: 8453, usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" },
+    "eip155:84532": { chainId: 84532, usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e" },
+};
+const isNetwork = (value) => Object.hasOwn(NETWORKS, value);
+export class WalletAccessError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "WalletAccessError";
+    }
+}
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+const resourceSchema = z.object({ url: z.string(), description: z.string().optional(), mimeType: z.string().optional() }).passthrough();
+const requirementSchema = z.object({
+    scheme: z.string(), network: z.string(), amount: z.string().regex(/^\d+$/), asset: z.string(), payTo: z.string(),
+    maxTimeoutSeconds: z.number().int().positive(), extra: z.record(z.string(), z.unknown()).optional(),
+}).passthrough();
+const paymentRequiredSchema = z.object({
+    x402Version: z.literal(2), error: z.string().optional(), resource: resourceSchema, accepts: z.array(requirementSchema),
+    extensions: z.record(z.string(), z.unknown()).optional(),
+}).passthrough();
+const signInInfoSchema = z.object({
+    domain: z.string().min(1), uri: z.string().min(1), version: z.literal("1"), nonce: z.string().min(1), issuedAt: z.string().min(1),
+    expirationTime: z.string().optional(), notBefore: z.string().optional(), statement: z.string().optional(),
+    resources: z.array(z.string()).optional(), requestId: z.string().optional(),
+}).passthrough();
+const signInExtensionSchema = z.object({
+    info: signInInfoSchema, supportedChains: z.array(z.object({ chainId: z.string(), type: z.string() }).passthrough()),
+}).passthrough();
+const signInResultSchema = z.object({ data: z.object({
+        apiKey: z.string(), expiresAt: z.string(), address: z.string(), organizationId: z.string(), projectId: z.string(), created: z.boolean(),
+    }) });
+const topUpResultSchema = z.object({ data: z.object({
+        creditedCents: z.number().int().positive(), transaction: z.string().nullable(), network: z.string(), payer: z.string(),
+    }) });
+const base64Json = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+function api(apiUrl, local) {
+    const url = new URL(relvoApiUrl(apiUrl, local));
+    return { url, base: url.href.replace(/\/$/, "") };
+}
+async function serverMessage(response) {
+    try {
+        const body = z.object({ error: z.object({ message: z.string().regex(/^[a-z0-9_]{1,80}$/) }) }).safeParse(await response.json());
+        return body.success ? body.data.error.message : "no error code";
+    }
+    catch {
+        return "no error code";
+    }
+}
+async function send(fetchImpl, url, init, what) {
+    try {
+        return await fetchImpl(url, { ...init, redirect: "error", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+    }
+    catch {
+        throw new WalletAccessError(`The Relvo API could not be reached for ${what}.`);
+    }
+}
+async function readPaymentRequired(response) {
+    const header = response.headers.get(PAYMENT_REQUIRED_HEADER);
+    let json;
+    try {
+        json = header ? JSON.parse(Buffer.from(header, "base64").toString("utf8")) : (await response.json()).paymentRequired;
+    }
+    catch {
+        throw new WalletAccessError("The Relvo API returned an unreadable payment requirement.", response.status);
+    }
+    const parsed = paymentRequiredSchema.safeParse(json);
+    if (!parsed.success)
+        throw new WalletAccessError("The Relvo API returned an unexpected payment requirement.", response.status);
+    return parsed.data;
+}
+function siweMessage(fields) {
+    const lines = [`${fields.domain} wants you to sign in with your Ethereum account:`, checksumAddress(fields.address), ""];
+    if (fields.statement)
+        lines.push(fields.statement, "");
+    lines.push(`URI: ${fields.uri}`, `Version: ${fields.version}`, `Chain ID: ${fields.chainId.replace(/^eip155:/, "")}`, `Nonce: ${fields.nonce}`, `Issued At: ${fields.issuedAt}`);
+    if (fields.expirationTime)
+        lines.push(`Expiration Time: ${fields.expirationTime}`);
+    if (fields.notBefore)
+        lines.push(`Not Before: ${fields.notBefore}`);
+    if (fields.requestId)
+        lines.push(`Request ID: ${fields.requestId}`);
+    if (fields.resources?.length)
+        lines.push("Resources:", ...fields.resources.map((resource) => `- ${resource}`));
+    return lines.join("\n");
+}
+export async function walletSignIn({ apiUrl, wallet, local, fetch: fetchImpl = fetch }) {
+    const { url, base } = api(apiUrl, local), endpoint = `${base}${PLATFORM_WALLET_ROUTES.signIn}`;
+    const challenge = await send(fetchImpl, endpoint, { method: "POST" }, "sign-in");
+    if (challenge.status !== 402)
+        throw new WalletAccessError(`Wallet sign-in is unavailable (${await serverMessage(challenge)}).`, challenge.status);
+    const extension = signInExtensionSchema.safeParse((await readPaymentRequired(challenge)).extensions?.["sign-in-with-x"]);
+    if (!extension.success)
+        throw new WalletAccessError("The Relvo API did not offer wallet sign-in.", 402);
+    const { info, supportedChains } = extension.data;
+    let uriOrigin;
+    try {
+        uriOrigin = new URL(info.uri).origin;
+    }
+    catch {
+        uriOrigin = undefined;
+    }
+    if (info.domain !== url.host || uriOrigin !== url.origin)
+        throw new WalletAccessError("The sign-in challenge names a different site than the API URL; nothing was signed.");
+    if (info.expirationTime && Date.parse(info.expirationTime) <= Date.now())
+        throw new WalletAccessError("The sign-in challenge has already expired; nothing was signed.");
+    const chain = supportedChains.find((candidate) => candidate.type === "eip191" && isNetwork(candidate.chainId));
+    if (!chain)
+        throw new WalletAccessError("The sign-in challenge offers no supported chain.");
+    const fields = { ...info, address: wallet.address, chainId: chain.chainId };
+    const proof = { domain: info.domain, address: wallet.address, uri: info.uri, version: info.version, chainId: chain.chainId, type: "eip191", nonce: info.nonce,
+        issuedAt: info.issuedAt, ...(info.statement ? { statement: info.statement } : {}), ...(info.expirationTime ? { expirationTime: info.expirationTime } : {}),
+        ...(info.notBefore ? { notBefore: info.notBefore } : {}), ...(info.requestId ? { requestId: info.requestId } : {}),
+        ...(info.resources ? { resources: info.resources } : {}), signature: wallet.signPersonalMessage(siweMessage(fields)) };
+    const response = await send(fetchImpl, endpoint, { method: "POST", headers: { [SIGN_IN_HEADER]: base64Json(proof) } }, "sign-in");
+    if (!response.ok)
+        throw new WalletAccessError(`Wallet sign-in was rejected (${await serverMessage(response)}).`, response.status);
+    const parsed = signInResultSchema.safeParse(await response.json().catch(() => null));
+    if (!parsed.success)
+        throw new WalletAccessError("The Relvo API returned an unexpected sign-in response.", response.status);
+    return parsed.data.data;
+}
+export function walletAutoTopUp(options) {
+    let committedCents = 0;
+    return async (shortfall) => {
+        if (shortfall.reason !== "balance")
+            return null;
+        const deficit = BigInt(shortfall.requiredMicros) - BigInt(shortfall.availableMicros);
+        if (deficit <= 0n)
+            return null;
+        const amountCents = Math.max(PLATFORM_WALLET_TOP_UP_MIN_CENTS, Number((deficit + BigInt(MICROS_PER_CENT) - 1n) / BigInt(MICROS_PER_CENT)));
+        if (committedCents + amountCents > options.maximumTotalCents)
+            return null;
+        committedCents += amountCents;
+        return walletTopUp({ ...options, amountCents, maximumCents: amountCents });
+    };
+}
+export function walletAutoTopUpFromEnvironment(env, api) {
+    if (PLATFORM_DISTRIBUTION.product !== "relvo")
+        return undefined;
+    const key = env.RELVO_WALLET_PRIVATE_KEY?.trim(), cap = env.RELVO_WALLET_AUTO_TOP_UP_USD?.trim();
+    if (!key || !cap)
+        return undefined;
+    if (!/^\d{1,6}(?:\.\d{1,2})?$/.test(cap))
+        throw new WalletAccessError("RELVO_WALLET_AUTO_TOP_UP_USD must be a USD amount such as 5 or 5.00.");
+    const [dollars, cents = ""] = cap.split("."), maximumTotalCents = Number(dollars) * 100 + Number(cents.padEnd(2, "0"));
+    if (maximumTotalCents === 0)
+        return undefined;
+    if (maximumTotalCents < PLATFORM_WALLET_TOP_UP_MIN_CENTS)
+        throw new WalletAccessError(`RELVO_WALLET_AUTO_TOP_UP_USD must be at least ${(PLATFORM_WALLET_TOP_UP_MIN_CENTS / 100).toFixed(2)}, the smallest top-up.`);
+    return walletAutoTopUp({ ...api, wallet: loadEvmWallet(key), maximumTotalCents });
+}
+export async function walletTopUp({ apiUrl, wallet, local, fetch: fetchImpl = fetch, apiKey, amountCents, maximumCents }) {
+    if (!Number.isSafeInteger(amountCents) || amountCents <= 0 || !Number.isSafeInteger(maximumCents) || maximumCents < amountCents)
+        throw new WalletAccessError("Use a positive whole-cent amount that does not exceed the maximum.");
+    const { base } = api(apiUrl, local), endpoint = `${base}${PLATFORM_WALLET_ROUTES.topUp}`;
+    const headers = { authorization: `Bearer ${apiKey}`, "content-type": "application/json" };
+    const body = JSON.stringify({ amountCents });
+    const quote = await send(fetchImpl, endpoint, { method: "POST", headers, body }, "top-up");
+    if (quote.status !== 402)
+        throw new WalletAccessError(`Top-up is unavailable (${await serverMessage(quote)}).`, quote.status);
+    const required = await readPaymentRequired(quote), accepted = required.accepts[0];
+    if (!accepted)
+        throw new WalletAccessError("The Relvo API offered no payment requirement.", 402);
+    if (accepted.scheme !== "exact")
+        throw new WalletAccessError("The payment requirement is not the exact scheme; nothing was signed.");
+    if (!isNetwork(accepted.network) || accepted.asset.toLowerCase() !== NETWORKS[accepted.network].usdc.toLowerCase())
+        throw new WalletAccessError("The payment requirement names an unknown network or token; nothing was signed.");
+    const micros = BigInt(accepted.amount);
+    if (micros > BigInt(maximumCents) * BigInt(MICROS_PER_CENT) || micros !== BigInt(amountCents) * BigInt(MICROS_PER_CENT))
+        throw new WalletAccessError("The payment requirement differs from the requested amount or exceeds the maximum; nothing was signed.");
+    if (!address.safeParse(accepted.payTo).success)
+        throw new WalletAccessError("The payment requirement has an invalid recipient; nothing was signed.");
+    const { name, version } = accepted.extra ?? {};
+    if (typeof name !== "string" || typeof version !== "string")
+        throw new WalletAccessError("The payment requirement lacks the token's signing domain; nothing was signed.");
+    const nonce = `0x${randomBytes(32).toString("hex")}`;
+    const authorization = { from: wallet.address, to: accepted.payTo, value: accepted.amount, validAfter: "0",
+        validBefore: String(Math.floor(Date.now() / 1000) + accepted.maxTimeoutSeconds), nonce };
+    const signature = wallet.signTypedData({ name, version, chainId: NETWORKS[accepted.network].chainId, verifyingContract: accepted.asset }, { TransferWithAuthorization: [
+            { name: "from", type: "address" }, { name: "to", type: "address" }, { name: "value", type: "uint256" },
+            { name: "validAfter", type: "uint256" }, { name: "validBefore", type: "uint256" }, { name: "nonce", type: "bytes32" },
+        ] }, "TransferWithAuthorization", authorization);
+    const payment = { x402Version: 2, resource: required.resource, accepted, payload: { signature, authorization } };
+    let response;
+    try {
+        response = await send(fetchImpl, endpoint, { method: "POST", headers: { ...headers, [PAYMENT_SIGNATURE_HEADER]: base64Json(payment) }, body }, "top-up");
+    }
+    catch {
+        throw new WalletAccessError("The payment was signed but the reply was lost; it may have been settled. Check the balance with relvo usage before paying again.");
+    }
+    if (response.status === 402)
+        throw new WalletAccessError(`The payment was rejected (${(await readPaymentRequired(response)).error ?? "no reason given"}).`, 402);
+    if (!response.ok)
+        throw new WalletAccessError(`Top-up failed (${await serverMessage(response)}); the payment may be pending, so check the balance before paying again.`, response.status);
+    const parsed = topUpResultSchema.safeParse(await response.json().catch(() => null));
+    if (!parsed.success)
+        throw new WalletAccessError("The Relvo API returned an unexpected top-up response; check the balance before paying again.", response.status);
+    return parsed.data.data;
+}