@noimosai/platform-mcp 0.1.3 → 0.1.5

package/dist/client/distribution.js

@@ -0,0 +1,2 @@
+export const PLATFORM_DISTRIBUTIONS = {"noimos":{"product":"noimos","name":"NoimosAI Platform","cliCommand":"noimos-platform","mcpServerName":"noimos-platform","icon":{"src":"https://platform.noimosai.com/icon.svg","mimeType":"image/svg+xml","sizes":["any"]}}};
+export const PLATFORM_DISTRIBUTION = PLATFORM_DISTRIBUTIONS.noimos;

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/execution-context.js

@@ -0,0 +1,14 @@
+import { platformExecutionReceiptContext, platformExecutionResultPageContext } from "../schema/platformPublicExecution.js";
+import { TOOL_RESULT_CONTEXT_MAX_BYTES } from "../schema/toolResultContext.js";
+import { platformExecutionGuidance } from "./failure-recovery.js";
+const executionContextBudget = TOOL_RESULT_CONTEXT_MAX_BYTES - 256;
+export function executionReceiptContext(result, options = {}) {
+    const guidance = platformExecutionGuidance(result.data);
+    const recoveredBytes = guidance ? new TextEncoder().encode(JSON.stringify(guidance)).byteLength : 0;
+    const receipt = platformExecutionReceiptContext(result, { maximumBytes: (options.maximumBytes ?? executionContextBudget) - recoveredBytes,
+        readWith: options.readWith ?? "executionContext/readExecutionResult" });
+    return guidance ? { ...receipt, data: { ...receipt.data, ...guidance } } : receipt;
+}
+export function executionPageContext(result, options = {}) {
+    return platformExecutionResultPageContext(result, { maximumBytes: options.maximumBytes ?? executionContextBudget, readWith: options.readWith ?? "readExecutionResult" });
+}

package/dist/client/failure-recovery.js

@@ -0,0 +1,128 @@
+import { PLATFORM_DISTRIBUTION } from "./distribution.js";
+const CONNECT = "Ask user to connect via url or connect_app(apps). Never ask for a key in chat. Do not retry before confirmation.";
+const TRY_AGAIN = "This run ended without a usable answer. Run it once more with a new idempotency key, or use another tool for the same task. If it fails again, say this part could not be done.";
+const RATE_LIMITED = "The provider refused this request for its rate limit before running it. Use another tool for the same task now, or run this one again after about a minute; do not retry it at once.";
+const REFUSED_INPUTS = "The provider refused these inputs. Compare them with this tool's schema, change them, then run with a new idempotency key. Do not retry unchanged.";
+const UNREADABLE_PAGE = "The page itself answered with an error, so nothing was read. Check the URL or read a different page with a new idempotency key. Do not retry it unchanged or answer as if it had been read.";
+function providerHttpRecovery(code) {
+    const status = Number(/^platform_provider_http_(\d{3})$/.exec(code ?? "")?.[1]);
+    if (status === 429)
+        return { action: "select_provider", instruction: RATE_LIMITED };
+    if (status === 404 || status === 410)
+        return { action: "change_input", instruction: "The provider has no such record. A dated link or old ID may have expired: check it, or list current ones with a related tool, then run with a new idempotency key. Do not retry unchanged." };
+    if (status === 401 || status === 403)
+        return { action: "select_provider", instruction: "The provider refused access to this data, and retrying will not change that. Use another tool for the same task, or say this part could not be done." };
+    if (status === 408 || status >= 500)
+        return { action: "try_again", instruction: TRY_AGAIN };
+    if (status >= 400)
+        return { action: "change_input", instruction: REFUSED_INPUTS };
+    return undefined;
+}
+export function platformFailureGuidance(code, context = {}) {
+    let action, instruction;
+    switch (code) {
+        case "platform_provider_own_key_required":
+        case "platform_connection_required":
+            action = "connect";
+            instruction = CONNECT;
+            break;
+        case "platform_provider_credential_unavailable":
+            action = "request_access";
+            instruction = "Ask the project owner/admin to check this provider credential in project integrations and restore authorized access. Never collect keys in chat. Do not retry unchanged.";
+            break;
+        case "platform_connection_reauthorize":
+        case "platform_connection_scope_required":
+            action = "reconnect";
+            instruction = "Ask user to reauthorize with required permissions via url or connect_app. If the page does not list the permission, they need their own OAuth app there. Never collect credentials in chat. Do not retry before confirmation.";
+            break;
+        case "platform_connection_access_denied":
+        case "platform_connection_authority_removed":
+        case "platform_connection_policy_denied":
+        case "platform_tool_access_denied":
+        case "platform_api_key_scope_required":
+        case "platform_approval_required":
+            action = "request_access";
+            instruction = "Show url and request required permission/approval from owner/admin. Do not retry until granted or switch accounts automatically.";
+            break;
+        case "platform_connection_choice_required":
+        case "platform_connection_provider_mismatch":
+        case "platform_connection_auth_method_required":
+            action = "select_connection";
+            instruction = "Choose an authorized connection with platform_connections; ask user if ambiguous. Do not retry unchanged.";
+            break;
+        case "platform_provider_not_configured":
+        case "platform_connection_not_configured":
+            action = "configure";
+            instruction = "Ask an operator to finish server setup. Do not ask the user to reconnect. Do not retry before setup changes.";
+            break;
+        case "platform_no_compatible_provider":
+        case "platform_provider_not_supported":
+            action = "select_provider";
+            instruction = "No provider this project runs accepts these inputs together; sourceRefusals, when present, names the inputs each could not apply and the only ones it applies, and an empty inputs list means it did not say which: then drop optional filters. Run again without the provider pin or such an input the user did not ask for, with a new idempotency key; if a condition the user asked for cannot be applied, say which. Offer connecting a provider only if the user wants one. Do not retry unchanged or infer an outage.";
+            break;
+        case "platform_provider_rate_limited":
+            action = "select_provider";
+            instruction = RATE_LIMITED;
+            break;
+        case "platform_tool_failed":
+        case "platform_tool_timeout":
+        case "platform_provider_response_unknown":
+        case "platform_execution_unavailable":
+            action = "try_again";
+            instruction = TRY_AGAIN;
+            break;
+        case "platform_output_too_large":
+            action = "try_again";
+            instruction = "The answer was larger than a run can keep. Run it again with a new idempotency key and narrower inputs or a smaller limit.";
+            break;
+        case "platform_scrape_target_error":
+            action = "change_input";
+            instruction = UNREADABLE_PAGE;
+            break;
+        case "platform_provider_declared_error":
+        case "platform_scrape_not_a_web_page":
+        case "platform_crawl4ai_not_found":
+        case "platform_crawl4ai_page_too_large":
+        case "platform_video_not_playable":
+        case "platform_invalid_media_input":
+        case "platform_generation_filtered":
+            action = "change_input";
+            instruction = REFUSED_INPUTS;
+            break;
+        default: {
+            const recovery = providerHttpRecovery(code);
+            if (!recovery)
+                return undefined;
+            ({ action, instruction } = recovery);
+        }
+    }
+    const providers = context.providers ?? (context.provider ? [context.provider] : []);
+    const apps = [...new Set(providers.map(provider => provider.replace(/^app:/, "")))], url = context.reconnectUrl ?? context.actionUrl;
+    return { retryable: action === "try_again", recovery: { action, instruction, ...(url ? { url } : {}), ...(apps.length ? { apps } : {}) } };
+}
+export function platformUpstreamRefusalNext(refusal, reconnectUrl) {
+    const wait = refusal.retryAfterSeconds ?? 60;
+    if (refusal.kind === "rate_limited")
+        return `The app's rate limit refused this call, so result holds that refusal, not data. Run it again after ${wait} seconds with a new idempotency key, or get the same data in fewer calls, such as with the app's search. Do not send a burst of calls, and say what is missing if you stop here.`;
+    const scopes = refusal.neededScopes?.length ? ` (${refusal.neededScopes.join(", ")})` : "";
+    if (refusal.kind === "permission")
+        return `The app refused this call for a permission the connection lacks${scopes}, so result holds that refusal, not data. ${reconnectUrl
+            ? "Show the user reconnectUrl to grant it, then run this again." : "Tell the user which permission is missing; reconnecting the app may grant it."} Another operation may still work on this connection. Say this part is incomplete.`;
+    return "The app refused this call, so result holds its answer, not the requested data. Read the error there, then fix the input or say the request could not be done. Do not report it as done.";
+}
+export function unexecutedCallBilling() {
+    return { scope: "this_call", chargedMicros: 0, executionStarted: false,
+        note: "Tell user: this attempt was not executed and incurred no charge. Earlier calls may have charges." };
+}
+export function platformExecutionGuidance(execution) {
+    if (execution.status === "needs_review")
+        return { retryable: false, recovery: { action: "wait_for_review",
+                instruction: "The outcome is unknown until an operator settles it, so it may or may not have run and its charge is not final. Do not run it again or say it worked. Tell the user it is held for review and continue with what you have." } };
+    if (execution.status !== "failed")
+        return undefined;
+    const guidance = platformFailureGuidance(execution.errorCode, execution) ?? { retryable: true, recovery: { action: "try_again", instruction: TRY_AGAIN } };
+    const billing = typeof execution.chargedMicros === "number" ? { scope: "this_execution", chargedMicros: execution.chargedMicros,
+        note: execution.chargedMicros === 0 ? `Tell user: no ${PLATFORM_DISTRIBUTION.name} charge for this execution. Earlier calls may have charges.`
+            : `Report this execution's ${PLATFORM_DISTRIBUTION.name} charge; do not describe the failed attempt as free.` } : undefined;
+    return { ...guidance, ...(billing ? { billing } : {}) };
+}

package/dist/client/index.js

@@ -1,225 +1,4 @@
-import { z } from "zod";
-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_RESPONSE_MAX_BYTES, platformCatalogSchema, platformQuoteSchema, platformExecutionSchema, platformCreateExecutionSchema, platformToolInputSchema, platformToolNameSchema, platformArtifactIdSchema, platformArtifactDownloadSchema, platformExecutionListQuerySchema, platformExecutionListSchema } from "../schema/platformPublicExecution.js";
-export { platformCreateExecutionSchema, platformToolInputSchema, platformExecutionSchema, 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 catalogResultSchema = z.object({ data: platformCatalogSchema });
-export const platformToolDiscoverySchema = z.object({
-    query: z.string().trim().min(1).max(200).optional().describe("Case-insensitive substring of a tool's name or description."),
-    category: platformCatalogSchema.shape.tools.element.shape.category.optional(),
-    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 executionIdSchema = z.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
-const idempotencySchema = z.string().regex(/^[A-Za-z0-9._:-]{8,128}$/);
-const publicErrors = {
-    platform_quote_changed: "The quote changed. Request a new quote before submitting another execution.",
-    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_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_scope_required: "The API key is missing the required scope.",
-    platform_artifact_unavailable: "This output file is unavailable or its retention period has ended.",
-};
-export class PlatformApiError extends Error {
-    status;
-    code;
-    constructor(status, code) {
-        super(`Platform 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";
-    }
-}
-async function responseJson(response) {
-    const reader = response.body?.getReader();
-    if (!reader)
-        throw new Error("The Platform API returned an empty response.");
-    const chunks = [];
-    let size = 0;
-    try {
-        for (;;) {
-            const { value, done } = await reader.read();
-            if (done)
-                break;
-            size += value.byteLength;
-            if (size > PLATFORM_EXECUTION_RESPONSE_MAX_BYTES) {
-                await reader.cancel();
-                throw new Error("The Platform API response is too large.");
-            }
-            chunks.push(value);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const bytes = new Uint8Array(size);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.length;
-    }
-    try {
-        return JSON.parse(new TextDecoder().decode(bytes));
-    }
-    catch {
-        throw new Error("The Platform API returned an invalid response.");
-    }
-}
-export function configFromEnvironment(env, source) {
-    if (!env.NOIMOS_PLATFORM_API_URL || !env.NOIMOS_PLATFORM_API_KEY)
-        throw new Error("Set NOIMOS_PLATFORM_API_URL and NOIMOS_PLATFORM_API_KEY from the developer console.");
-    return { apiUrl: env.NOIMOS_PLATFORM_API_URL, apiKey: env.NOIMOS_PLATFORM_API_KEY, source, local: env.NOIMOS_PLATFORM_ENV === "local" };
-}
-export class PlatformClient {
-    config;
-    transport;
-    baseUrl;
-    constructor(config, transport = fetch) {
-        this.config = config;
-        this.transport = transport;
-        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 Platform API URL must use HTTPS. Explicit local mode permits loopback HTTP.");
-        if (!/^nmp_[A-Za-z0-9_-]{43}$/.test(config.apiKey))
-            throw new Error("A dedicated nmp_ 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);
-        if (body && new TextEncoder().encode(body).byteLength > (path === "/tools/upload" ? PLATFORM_UPLOAD_MAX_BYTES : 65536))
-            throw new Error(path === "/tools/upload" ? "The upload exceeds 12 MiB." : "The tool request exceeds 64 KiB.");
-        let response;
-        try {
-            options?.signal?.throwIfAborted();
-            const timeout = AbortSignal.timeout(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}`, "x-noimos-client": this.config.source, "idempotency-key": options?.idempotencyKey ?? crypto.randomUUID(),
-                    ...(body === undefined ? {} : { "content-type": "application/json" }) }, ...(body === undefined ? {} : { body }) });
-        }
-        catch {
-            options?.signal?.throwIfAborted();
-            throw new Error("The Platform API could not be reached. If submitting an execution, retry with the same body and idempotency key.");
-        }
-        const payload = await responseJson(response).catch(() => {
-            options?.signal?.throwIfAborted();
-            if (!response.ok)
-                throw new PlatformApiError(response.status, null);
-            throw new Error("The Platform 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);
-        }
-        const parsed = schema.safeParse(payload);
-        if (!parsed.success)
-            throw new Error("The Platform API returned an unexpected response. If submitting an execution, retain the same body and idempotency key.");
-        return parsed.data;
-    }
-    project() { return this.request("/tools/project", projectResultSchema); }
-    usage() { return this.request("/tools/usage", usageResultSchema); }
-    tools() { return this.request("/tools", catalogResultSchema); }
-    uploadInput(input) {
-        return this.request("/tools/upload", z.object({ data: platformInputFileSchema }), { method: "POST", body: platformInputUploadSchema.parse(input) });
-    }
-    async discoverTools(options = {}) {
-        const { query, category, availableOnly, summary } = platformToolDiscoverySchema.parse(options);
-        const { data } = await this.tools();
-        const search = query?.toLowerCase();
-        const tools = data.tools.filter((tool) => (!search || tool.name.toLowerCase().includes(search) || tool.description.toLowerCase().includes(search)) &&
-            (!category || tool.category === category) && (!availableOnly || tool.available));
-        return { data: { ...data, tools: summary ? tools.map(({ inputSchema, example, ...tool }) => tool) : tools } };
-    }
-    async tool(name) {
-        platformToolNameSchema.parse(name);
-        const { data } = await this.tools();
-        const tool = data.tools.find((entry) => entry.name === name);
-        if (!tool)
-            throw new Error("Tool is unavailable in the standalone Platform catalog. Run tools to discover supported operations.");
-        return { data: { ...tool, priceVersion: data.priceVersion, currency: data.currency, executionEnabled: data.executionEnabled } };
-    }
-    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(`/tools/executions?${query}`, z.object({ data: platformExecutionListSchema }));
-    }
-    quote(input) {
-        const parsed = platformToolInputSchema.safeParse(input);
-        if (!parsed.success)
-            throw new Error("Provide a tool name and a JSON object of arguments.");
-        return this.request("/tools/quote", quoteResultSchema, { method: "POST", body: parsed.data });
-    }
-    createExecution(input, idempotencyKey) {
-        const parsed = platformCreateExecutionSchema.safeParse(input);
-        if (!parsed.success)
-            throw new Error("Provide a tool, arguments, the quote's priceVersion and maximumChargeMicros.");
-        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(`/tools/${parsed.data.tool}`, executionResultSchema, { method: "POST", body: parsed.data, idempotencyKey });
-    }
-    execution(id, signal) {
-        if (!executionIdSchema.safeParse(id).success)
-            throw new Error("Provide a valid execution ID.");
-        return this.request(`/tools/executions/${id}`, executionResultSchema, { signal });
-    }
-    async waitExecution(id, timeoutMs = 20000, signal) {
-        executionIdSchema.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;
-        try {
-            for (;;) {
-                controller.signal.throwIfAborted();
-                latest = (await this.execution(id, controller.signal)).data;
-                if (!["queued", "running", "waiting"].includes(latest.status))
-                    return { data: latest, id, timedOut: false };
-                await new Promise((resolve, reject) => {
-                    const done = () => { controller.signal.removeEventListener("abort", cancelled); resolve(); };
-                    const pause = setTimeout(done, 5000);
-                    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 (!executionIdSchema.safeParse(id).success)
-            throw new Error("Provide a valid execution ID.");
-        return this.request(`/tools/executions/${id}/cancel`, executionResultSchema, { method: "POST" });
-    }
-    artifactDownload(id, artifactId) {
-        if (!executionIdSchema.safeParse(id).success || !platformArtifactIdSchema.safeParse(artifactId).success)
-            throw new Error("Provide valid execution and artifact IDs.");
-        return this.request(`/tools/executions/${id}/artifacts/${artifactId}/download`, z.object({ data: platformArtifactDownloadSchema }));
-    }
-}
+export * from "./browser.js";
+export { PLATFORM_DISTRIBUTION, PLATFORM_DISTRIBUTIONS } from "./distribution.js";
+export { loadEvmWallet } from "./evm-wallet.js";
+export { walletSignIn, walletTopUp, walletAutoTopUp, walletAutoTopUpFromEnvironment, WalletAccessError } from "./wallet-access.js";