unbrowse 7.2.0-preview.0 → 8.0.0

package/bin/unbrowse-wrapper.mjs

@@ -24,7 +24,6 @@ const REQUIRED_FALLBACK_PACKAGES = [
   "tsx",
   "bs58",
   "@solana/kit",
-  "@cascade-fyi/splits-sdk",
 ];
 
 const KNOWN_BAD_FALLBACK_VERSIONS = new Set([

package/dist-sdk/client.d.ts

@@ -0,0 +1,43 @@
+import type { AccountMe, AccountCredits, ApiKeyCreateInput, ApiKeyCreateResponse, ApiKeyListResponse, ApiKeyRevokeResponse, ExecuteInput, ExecuteResponse, HealthResponse, RequestOptions, ResolveInput, ResolveResponse, SearchInput, SearchResponse, SponsorStatus, UnbrowseClientOptions } from "./types.js";
+import type { WorkerProxyCapabilities, WorkerProxyRequest, WorkerProxyResponse } from "./proxy-types.js";
+export declare class Unbrowse {
+    readonly apiKey: string | undefined;
+    readonly baseURL: string;
+    readonly timeout: number;
+    readonly maxRetries: number;
+    readonly logLevel: NonNullable<UnbrowseClientOptions["logLevel"]>;
+    private readonly _fetch;
+    private readonly defaultHeaders;
+    readonly account: AccountResource;
+    readonly keys: KeysResource;
+    readonly proxy: ProxyResource;
+    constructor(opts?: UnbrowseClientOptions);
+    resolve(input: ResolveInput, opts?: RequestOptions): Promise<ResolveResponse>;
+    execute(input: ExecuteInput, opts?: RequestOptions): Promise<ExecuteResponse>;
+    search(input: SearchInput, opts?: RequestOptions): Promise<SearchResponse>;
+    health(opts?: RequestOptions): Promise<HealthResponse>;
+    request<T>(method: string, path: string, body: unknown, opts: RequestOptions): Promise<T>;
+    private debug;
+}
+declare class AccountResource {
+    private readonly client;
+    constructor(client: Unbrowse);
+    me(opts?: RequestOptions): Promise<AccountMe>;
+    credits(opts?: RequestOptions): Promise<AccountCredits>;
+    sponsorStatus(opts?: RequestOptions): Promise<SponsorStatus>;
+}
+declare class KeysResource {
+    private readonly client;
+    constructor(client: Unbrowse);
+    list(opts?: RequestOptions): Promise<ApiKeyListResponse>;
+    create(input?: ApiKeyCreateInput, opts?: RequestOptions): Promise<ApiKeyCreateResponse>;
+    revoke(keyId: string, opts?: RequestOptions): Promise<ApiKeyRevokeResponse>;
+    rotate(keyId: string, opts?: RequestOptions): Promise<ApiKeyCreateResponse>;
+}
+declare class ProxyResource {
+    private readonly client;
+    constructor(client: Unbrowse);
+    fetch(req: WorkerProxyRequest, opts?: RequestOptions): Promise<WorkerProxyResponse>;
+    capabilities(opts?: RequestOptions): Promise<WorkerProxyCapabilities>;
+}
+export {};

package/dist-sdk/client.js

@@ -0,0 +1,256 @@
+import { errorFromStatus, UnbrowseConnectionError, UnbrowseError, UnbrowseTimeoutError, } from "./errors.js";
+const DEFAULT_BASE_URL = "https://beta-api.unbrowse.ai";
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_RETRIES = 2;
+const SDK_VERSION = "7.0.0-preview.1";
+export class Unbrowse {
+    apiKey;
+    baseURL;
+    timeout;
+    maxRetries;
+    logLevel;
+    _fetch;
+    defaultHeaders;
+    account;
+    keys;
+    proxy;
+    constructor(opts = {}) {
+        const env = readEnv();
+        this.apiKey = opts.apiKey ?? env.UNBROWSE_API_KEY;
+        this.baseURL = stripTrailingSlash(opts.baseURL ?? env.UNBROWSE_BASE_URL ?? DEFAULT_BASE_URL);
+        this.timeout = opts.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.logLevel = opts.logLevel ?? env.UNBROWSE_LOG ?? "off";
+        this.defaultHeaders = opts.defaultHeaders ?? {};
+        const f = opts.fetch ?? globalThis.fetch;
+        if (typeof f !== "function") {
+            throw new UnbrowseError("No fetch implementation available. Pass `fetch` in client options or run on Node 18+ / a modern browser.");
+        }
+        this._fetch = f.bind(globalThis);
+        this.account = new AccountResource(this);
+        this.keys = new KeysResource(this);
+        this.proxy = new ProxyResource(this);
+    }
+    resolve(input, opts = {}) {
+        return this.request("POST", "/v1/resolve", input, opts);
+    }
+    execute(input, opts = {}) {
+        // Auto-idempotency on execute so a network-retry never double-charges the agent.
+        const idempotencyKey = input.idempotency_key ?? opts.idempotencyKey ?? randomIdempotencyKey();
+        return this.request("POST", "/v1/execute", input, { ...opts, idempotencyKey });
+    }
+    search(input, opts = {}) {
+        return this.request("POST", "/v1/search", input, opts);
+    }
+    health(opts = {}) {
+        return this.request("GET", "/v1/health", undefined, opts);
+    }
+    // Internal request driver. Public so the resource classes can call it; not part
+    // of the documented surface.
+    async request(method, path, body, opts) {
+        const url = `${this.baseURL}${path}`;
+        const headers = {
+            "Accept": "application/json",
+            "User-Agent": `@unbrowse/sdk/${SDK_VERSION}`,
+            ...this.defaultHeaders,
+            ...(opts.headers ?? {}),
+        };
+        if (this.apiKey)
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        if (body !== undefined && method !== "GET")
+            headers["Content-Type"] = "application/json";
+        if (opts.idempotencyKey)
+            headers["Idempotency-Key"] = opts.idempotencyKey;
+        const maxRetries = opts.maxRetries ?? this.maxRetries;
+        const timeoutMs = opts.timeout ?? this.timeout;
+        let lastErr;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            const ctrl = new AbortController();
+            const t = setTimeout(() => ctrl.abort(), timeoutMs);
+            const signal = combineSignals(ctrl.signal, opts.signal);
+            try {
+                const response = await this._fetch(url, {
+                    method,
+                    headers,
+                    body: body !== undefined && method !== "GET" ? JSON.stringify(body) : undefined,
+                    signal,
+                });
+                clearTimeout(t);
+                const request_id = response.headers.get("x-request-id") ?? undefined;
+                const responseBody = await parseBody(response);
+                if (response.ok) {
+                    this.debug(`${method} ${path} ${response.status} req=${request_id ?? "-"} attempt=${attempt}`);
+                    if (responseBody && typeof responseBody === "object" && !Array.isArray(responseBody)) {
+                        responseBody._request_id = request_id;
+                    }
+                    return responseBody;
+                }
+                const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+                const err = errorFromStatus({
+                    status: response.status,
+                    body: responseBody,
+                    request_id,
+                    url,
+                    method,
+                    retry_after_ms: retryAfter,
+                });
+                if (shouldRetry(response.status, attempt, maxRetries)) {
+                    lastErr = err;
+                    const delay = retryAfter ?? backoffDelay(attempt);
+                    this.debug(`${method} ${path} ${response.status} retry-in=${delay}ms attempt=${attempt}`);
+                    await sleep(delay);
+                    continue;
+                }
+                throw err;
+            }
+            catch (e) {
+                clearTimeout(t);
+                if (e instanceof UnbrowseError)
+                    throw e;
+                const isAbort = e?.name === "AbortError";
+                const wrapped = isAbort
+                    ? new UnbrowseTimeoutError(`Request timed out after ${timeoutMs}ms`, e)
+                    : new UnbrowseConnectionError(`Network error: ${e?.message ?? String(e)}`, e);
+                if (attempt < maxRetries) {
+                    lastErr = wrapped;
+                    const delay = backoffDelay(attempt);
+                    this.debug(`${method} ${path} network-error retry-in=${delay}ms attempt=${attempt}`);
+                    await sleep(delay);
+                    continue;
+                }
+                throw wrapped;
+            }
+        }
+        throw lastErr ?? new UnbrowseError("Retries exhausted");
+    }
+    debug(line) {
+        if (this.logLevel === "debug" || this.logLevel === "info") {
+            // eslint-disable-next-line no-console
+            console.log(`[unbrowse] ${line}`);
+        }
+    }
+}
+class AccountResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    me(opts = {}) {
+        return this.client.request("GET", "/v1/account/me", undefined, opts);
+    }
+    credits(opts = {}) {
+        return this.client.request("GET", "/v1/account/credits", undefined, opts);
+    }
+    sponsorStatus(opts = {}) {
+        return this.client.request("GET", "/v1/account/sponsor-status", undefined, opts);
+    }
+}
+class KeysResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(opts = {}) {
+        return this.client.request("GET", "/v1/account/keys", undefined, opts);
+    }
+    create(input = {}, opts = {}) {
+        return this.client.request("POST", "/v1/account/keys", input, opts);
+    }
+    revoke(keyId, opts = {}) {
+        return this.client.request("DELETE", `/v1/account/keys/${encodeURIComponent(keyId)}`, undefined, opts);
+    }
+    rotate(keyId, opts = {}) {
+        return this.client.request("POST", `/v1/account/keys/${encodeURIComponent(keyId)}/rotate`, undefined, opts);
+    }
+}
+class ProxyResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    // POST /v1/proxy — worker fetches the target URL on behalf of the agent.
+    // Use this when the SDK runs in a browser/edge where direct outbound fetches
+    // would expose the user IP, get geo-fenced, or hit anti-bot. Pass
+    // proxy:"residential" to tunnel the worker's outbound fetch through a residential proxy.
+    fetch(req, opts = {}) {
+        return this.client.request("POST", "/v1/proxy", req, opts);
+    }
+    // GET /v1/proxy — capability check. Use to decide whether to request
+    // proxy:"residential" before committing to the call. Reports whether
+    // the worker's residential proxy credentials are configured.
+    capabilities(opts = {}) {
+        return this.client.request("GET", "/v1/proxy", undefined, opts);
+    }
+}
+// ---------- helpers ----------
+function readEnv() {
+    if (typeof process !== "undefined" && process.env)
+        return process.env;
+    return {};
+}
+function stripTrailingSlash(s) {
+    return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+async function parseBody(response) {
+    const ct = response.headers.get("content-type") ?? "";
+    if (ct.includes("application/json")) {
+        try {
+            return await response.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    const text = await response.text().catch(() => "");
+    return text || null;
+}
+function parseRetryAfter(h) {
+    if (!h)
+        return undefined;
+    const n = Number(h);
+    if (Number.isFinite(n))
+        return n * 1000;
+    const t = Date.parse(h);
+    if (Number.isFinite(t))
+        return Math.max(0, t - Date.now());
+    return undefined;
+}
+function shouldRetry(status, attempt, max) {
+    if (attempt >= max)
+        return false;
+    return status === 429 || status === 408 || status === 409 || status >= 500;
+}
+function backoffDelay(attempt) {
+    // exponential backoff with full jitter; 250ms, 500ms, 1s, 2s, ... capped at 8s
+    const base = Math.min(8_000, 250 * Math.pow(2, attempt));
+    return Math.floor(Math.random() * base);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function randomIdempotencyKey() {
+    // RFC 4122 v4-ish. Good enough for idempotency; not used for security.
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto)
+        return crypto.randomUUID();
+    const hex = "0123456789abcdef";
+    let out = "";
+    for (let i = 0; i < 32; i++) {
+        out += hex[Math.floor(Math.random() * 16)];
+        if (i === 7 || i === 11 || i === 15 || i === 19)
+            out += "-";
+    }
+    return out;
+}
+function combineSignals(a, b) {
+    if (!b)
+        return a;
+    if (a.aborted)
+        return a;
+    if (b.aborted)
+        return b;
+    const ctrl = new AbortController();
+    const onAbort = () => ctrl.abort();
+    a.addEventListener("abort", onAbort, { once: true });
+    b.addEventListener("abort", onAbort, { once: true });
+    return ctrl.signal;
+}

package/dist-sdk/errors.d.ts

@@ -0,0 +1,52 @@
+export declare class UnbrowseError extends Error {
+    constructor(message: string);
+}
+export interface UnbrowseAPIErrorOptions {
+    status: number;
+    body: unknown;
+    request_id?: string;
+    url: string;
+    method: string;
+}
+export declare class UnbrowseAPIError extends UnbrowseError {
+    readonly status: number;
+    readonly body: unknown;
+    readonly request_id: string | undefined;
+    readonly url: string;
+    readonly method: string;
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowseAuthenticationError extends UnbrowseAPIError {
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowsePaymentRequiredError extends UnbrowseAPIError {
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowsePermissionError extends UnbrowseAPIError {
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowseNotFoundError extends UnbrowseAPIError {
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowseBadRequestError extends UnbrowseAPIError {
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowseRateLimitError extends UnbrowseAPIError {
+    readonly retry_after_ms: number | undefined;
+    constructor(message: string, opts: UnbrowseAPIErrorOptions & {
+        retry_after_ms?: number;
+    });
+}
+export declare class UnbrowseServerError extends UnbrowseAPIError {
+    constructor(message: string, opts: UnbrowseAPIErrorOptions);
+}
+export declare class UnbrowseConnectionError extends UnbrowseError {
+    readonly cause: unknown;
+    constructor(message: string, cause: unknown);
+}
+export declare class UnbrowseTimeoutError extends UnbrowseConnectionError {
+    constructor(message: string, cause: unknown);
+}
+export declare function errorFromStatus(opts: UnbrowseAPIErrorOptions & {
+    retry_after_ms?: number;
+}): UnbrowseAPIError;

package/dist-sdk/errors.js

@@ -0,0 +1,116 @@
+// Typed error hierarchy. Mirrors OpenAI / Stripe conventions so `instanceof`
+// checks read naturally for calling agents. Every error carries the request_id
+// when the server returned one, so users can paste it into support.
+export class UnbrowseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnbrowseError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class UnbrowseAPIError extends UnbrowseError {
+    status;
+    body;
+    request_id;
+    url;
+    method;
+    constructor(message, opts) {
+        super(message);
+        this.name = "UnbrowseAPIError";
+        this.status = opts.status;
+        this.body = opts.body;
+        this.request_id = opts.request_id;
+        this.url = opts.url;
+        this.method = opts.method;
+    }
+}
+export class UnbrowseAuthenticationError extends UnbrowseAPIError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowseAuthenticationError";
+    }
+}
+export class UnbrowsePaymentRequiredError extends UnbrowseAPIError {
+    // 402 — surfaces x402 sponsor exhaustion / wallet top-up requirement.
+    // body is the x402 payment requirements object the server returned.
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowsePaymentRequiredError";
+    }
+}
+export class UnbrowsePermissionError extends UnbrowseAPIError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowsePermissionError";
+    }
+}
+export class UnbrowseNotFoundError extends UnbrowseAPIError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowseNotFoundError";
+    }
+}
+export class UnbrowseBadRequestError extends UnbrowseAPIError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowseBadRequestError";
+    }
+}
+export class UnbrowseRateLimitError extends UnbrowseAPIError {
+    retry_after_ms;
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowseRateLimitError";
+        this.retry_after_ms = opts.retry_after_ms;
+    }
+}
+export class UnbrowseServerError extends UnbrowseAPIError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "UnbrowseServerError";
+    }
+}
+export class UnbrowseConnectionError extends UnbrowseError {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "UnbrowseConnectionError";
+        this.cause = cause;
+    }
+}
+export class UnbrowseTimeoutError extends UnbrowseConnectionError {
+    constructor(message, cause) {
+        super(message, cause);
+        this.name = "UnbrowseTimeoutError";
+    }
+}
+export function errorFromStatus(opts) {
+    const msg = extractMessage(opts.body) ?? `HTTP ${opts.status} from ${opts.method} ${opts.url}`;
+    switch (opts.status) {
+        case 400: return new UnbrowseBadRequestError(msg, opts);
+        case 401: return new UnbrowseAuthenticationError(msg, opts);
+        case 402: return new UnbrowsePaymentRequiredError(msg, opts);
+        case 403: return new UnbrowsePermissionError(msg, opts);
+        case 404: return new UnbrowseNotFoundError(msg, opts);
+        case 429: return new UnbrowseRateLimitError(msg, opts);
+    }
+    if (opts.status >= 500)
+        return new UnbrowseServerError(msg, opts);
+    return new UnbrowseAPIError(msg, opts);
+}
+function extractMessage(body) {
+    if (!body || typeof body !== "object")
+        return undefined;
+    const b = body;
+    if (typeof b.error === "string")
+        return b.error;
+    if (typeof b.message === "string")
+        return b.message;
+    const inner = b.error;
+    if (inner && typeof inner === "object" && "message" in inner) {
+        const m = inner.message;
+        if (typeof m === "string")
+            return m;
+    }
+    return undefined;
+}

package/dist-sdk/fetch.d.ts

@@ -0,0 +1,68 @@
+/**
+ * A drop-in replacement for the global `fetch`, with optional, opt-in payment.
+ *
+ * Default behaviour is identical to native fetch — zero config, zero
+ * dependencies, no API key:
+ *
+ *   import { unfetch } from "@unbrowse/client";
+ *   const res = await unfetch("https://example.com");   // just works
+ *
+ * Opt-in payment: pass a `pay` handler to transparently satisfy an HTTP 402
+ * response. The handler is where any payment mechanism lives — a subscription /
+ * credit balance, an embedded-wallet signer, or an on-chain micropayment — and
+ * it is *injected*, never imported, so this module stays dependency-free. When
+ * no handler is configured a 402 is returned to the caller unchanged, exactly
+ * like native fetch.
+ *
+ * In other words: paying is a capability this client can use, not a path it
+ * forces. The 402 mechanism is an implementation detail behind the handler, not
+ * the front door.
+ */
+/** The standard fetch signature, re-exported as a type for handler authors. */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Context handed to a {@link PayHandler} when a request comes back `402 Payment
+ * Required`. The handler inspects it and decides whether (and how) to pay.
+ */
+export interface PaymentRequired {
+    /** The 402 response, unconsumed — read `.clone()` if you need the body. */
+    readonly response: Response;
+    /** The original request that triggered the 402, for re-issue after payment. */
+    readonly request: {
+        input: string | URL | Request;
+        init?: RequestInit;
+    };
+    /**
+     * Parsed payment terms when the server advertises them. We surface the common
+     * shapes (an `accepts` array, or `x402`/`flex` envelopes) without prescribing
+     * one — the handler owns the protocol. `null` when the body is not JSON.
+     */
+    readonly terms: Record<string, unknown> | null;
+}
+/**
+ * Resolves a 402. Return the headers to merge into a single retry of the
+ * original request (e.g. `{ "X-PAYMENT": "..." }` or an `Authorization` token),
+ * or `null` to decline — in which case the original 402 is returned unchanged.
+ */
+export type PayHandler = (ctx: PaymentRequired) => Promise<HeadersInit | null>;
+export interface CreateFetchOptions {
+    /** The transport to wrap. Defaults to the platform `fetch`. */
+    fetch?: FetchLike;
+    /**
+     * Optional payment handler. When omitted, the returned fetch is a pure
+     * pass-through and a 402 is never intercepted.
+     */
+    pay?: PayHandler;
+}
+/**
+ * Build a `fetch`-shaped function. With no options it is the platform fetch.
+ * With a `pay` handler it transparently retries a single 402 once the handler
+ * supplies payment headers.
+ */
+export declare function createFetch(options?: CreateFetchOptions): FetchLike;
+/**
+ * The keyless, dependency-free default: a `fetch` drop-in with no payment
+ * handler. Identical to the platform fetch; exported so callers can swap
+ * `fetch` → `unfetch` with no behavioural change and wire payment later.
+ */
+export declare const unfetch: FetchLike;

package/dist-sdk/fetch.js

@@ -0,0 +1,70 @@
+/**
+ * A drop-in replacement for the global `fetch`, with optional, opt-in payment.
+ *
+ * Default behaviour is identical to native fetch — zero config, zero
+ * dependencies, no API key:
+ *
+ *   import { unfetch } from "@unbrowse/client";
+ *   const res = await unfetch("https://example.com");   // just works
+ *
+ * Opt-in payment: pass a `pay` handler to transparently satisfy an HTTP 402
+ * response. The handler is where any payment mechanism lives — a subscription /
+ * credit balance, an embedded-wallet signer, or an on-chain micropayment — and
+ * it is *injected*, never imported, so this module stays dependency-free. When
+ * no handler is configured a 402 is returned to the caller unchanged, exactly
+ * like native fetch.
+ *
+ * In other words: paying is a capability this client can use, not a path it
+ * forces. The 402 mechanism is an implementation detail behind the handler, not
+ * the front door.
+ */
+/**
+ * Build a `fetch`-shaped function. With no options it is the platform fetch.
+ * With a `pay` handler it transparently retries a single 402 once the handler
+ * supplies payment headers.
+ */
+export function createFetch(options = {}) {
+    const base = options.fetch ?? globalThis.fetch;
+    if (typeof base !== "function") {
+        throw new Error("No fetch implementation available. Pass `fetch` in options or run on Node 18+ / a modern browser.");
+    }
+    const transport = base.bind(globalThis);
+    const pay = options.pay;
+    // No payment handler → an exact pass-through. This is the zero-config default.
+    if (!pay)
+        return transport;
+    return async function unbrowseFetch(input, init) {
+        const res = await transport(input, init);
+        if (res.status !== 402)
+            return res;
+        const terms = await readJsonSafe(res.clone());
+        const extra = await pay({ response: res, request: { input, init }, terms });
+        if (!extra)
+            return res; // handler declined — behave like native fetch.
+        // Single retry with the handler's payment headers merged in. One retry only:
+        // a payment that does not satisfy the route must surface, not loop.
+        const headers = new Headers(init?.headers);
+        new Headers(extra).forEach((value, key) => headers.set(key, value));
+        return transport(input, { ...init, headers });
+    };
+}
+/**
+ * The keyless, dependency-free default: a `fetch` drop-in with no payment
+ * handler. Identical to the platform fetch; exported so callers can swap
+ * `fetch` → `unfetch` with no behavioural change and wire payment later.
+ */
+export const unfetch = createFetch();
+async function readJsonSafe(res) {
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct.includes("json"))
+        return null;
+    try {
+        const body = await res.json();
+        return body && typeof body === "object" && !Array.isArray(body)
+            ? body
+            : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist-sdk/index.d.ts

@@ -0,0 +1,6 @@
+export { Unbrowse } from "./client.js";
+export { createFetch, unfetch } from "./fetch.js";
+export type { CreateFetchOptions, FetchLike, PayHandler, PaymentRequired, } from "./fetch.js";
+export { UnbrowseError, UnbrowseAPIError, UnbrowseAuthenticationError, UnbrowsePaymentRequiredError, UnbrowsePermissionError, UnbrowseNotFoundError, UnbrowseBadRequestError, UnbrowseRateLimitError, UnbrowseServerError, UnbrowseConnectionError, UnbrowseTimeoutError, } from "./errors.js";
+export type { AccountMe, AccountCredits, ApiKey, ApiKeyCreateInput, ApiKeyCreateResponse, ApiKeyFunding, ApiKeyListResponse, ApiKeyRevokeResponse, AvailableEndpoint, ExecuteInput, ExecuteResponse, HealthResponse, RequestOptions, ResolveInput, ResolveResponse, SearchHit, SearchInput, SearchResponse, SponsorStatus, UnbrowseClientOptions, } from "./types.js";
+export type { WorkerProxyCapabilities, WorkerProxyRequest, WorkerProxyResponse, } from "./proxy-types.js";

package/dist-sdk/index.js

@@ -0,0 +1,3 @@
+export { Unbrowse } from "./client.js";
+export { createFetch, unfetch } from "./fetch.js";
+export { UnbrowseError, UnbrowseAPIError, UnbrowseAuthenticationError, UnbrowsePaymentRequiredError, UnbrowsePermissionError, UnbrowseNotFoundError, UnbrowseBadRequestError, UnbrowseRateLimitError, UnbrowseServerError, UnbrowseConnectionError, UnbrowseTimeoutError, } from "./errors.js";

package/dist-sdk/proxy-types.d.ts

@@ -0,0 +1,24 @@
+export interface WorkerProxyResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+    proxy_used: "direct" | "residential";
+    duration_ms: number;
+    egress_ip?: string;
+    _request_id?: string;
+}
+export interface WorkerProxyRequest {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
+    proxy?: "direct" | "residential";
+    timeout_ms?: number;
+}
+export interface WorkerProxyCapabilities {
+    modes: Array<"direct" | "residential">;
+    residential_configured: boolean;
+    max_body_bytes: number;
+    default_timeout_ms: number;
+    _request_id?: string;
+}

package/dist-sdk/proxy-types.js

@@ -0,0 +1,2 @@
+// Shape of POST /v1/proxy responses on the worker.
+export {};

package/dist-sdk/types.d.ts

@@ -0,0 +1,146 @@
+export interface ResolveInput {
+    intent: string;
+    contextUrl?: string;
+    domain?: string;
+    limit?: number;
+}
+export interface AvailableEndpoint {
+    endpoint_id: string;
+    skill_id: string;
+    url: string;
+    method: string;
+    description?: string;
+    score?: number;
+    schema?: unknown;
+    requires?: string[];
+    yields?: string[];
+    action_kind?: string;
+    sample_values?: Record<string, unknown>;
+}
+export interface ResolveResponse {
+    status: "ok" | "empty" | "browse_session_open" | "auth_required" | "no_cached_match";
+    available_operations?: AvailableEndpoint[];
+    available_endpoints?: AvailableEndpoint[];
+    next_step?: string;
+    suggested_commands?: string[];
+    request_id?: string;
+    _request_id?: string;
+}
+export interface ExecuteInput {
+    endpoint_id?: string;
+    url?: string;
+    method?: string;
+    params?: Record<string, unknown>;
+    body?: unknown;
+    raw?: boolean;
+    extract?: string;
+    limit?: number;
+    idempotency_key?: string;
+    transport?: "worker-proxy" | "direct";
+    proxy?: "direct" | "residential";
+}
+export interface ExecuteResponse {
+    success: boolean;
+    status_code?: number;
+    data?: unknown;
+    raw?: unknown;
+    endpoint_id?: string;
+    trace?: unknown;
+    request_id?: string;
+    _request_id?: string;
+}
+export interface SearchInput {
+    intent: string;
+    domain?: string;
+    limit?: number;
+}
+export interface SearchHit {
+    endpoint_id: string;
+    skill_id: string;
+    url: string;
+    score: number;
+    snippet?: string;
+}
+export interface SearchResponse {
+    hits: SearchHit[];
+    _request_id?: string;
+}
+export interface HealthResponse {
+    status: "ok" | "degraded";
+    version?: string;
+    uptime_s?: number;
+    _request_id?: string;
+}
+export interface AccountMe {
+    user_id: string;
+    email: string;
+    email_verified: boolean;
+    created_at: string;
+    _request_id?: string;
+}
+export interface AccountCredits {
+    user_id: string;
+    balance_usd: number;
+    used_usd: number;
+    granted_usd: number;
+    _request_id?: string;
+}
+export interface SponsorStatus {
+    agent_id: string;
+    date: string;
+    agent_remaining_usd: number;
+    agent_cap_usd: number;
+    global_remaining_usd: number;
+    global_cap_usd: number;
+    _request_id?: string;
+}
+export interface ApiKey {
+    keyId: string;
+    name: string;
+    created_at: string | null;
+    revoked_at: string | null;
+    funding: ApiKeyFunding | null;
+}
+export interface ApiKeyFunding {
+    wallet_address?: string;
+    credit_budget_usd?: number;
+    bound_at?: string;
+}
+export interface ApiKeyCreateInput {
+    name?: string;
+}
+export interface ApiKeyCreateResponse {
+    keyId: string;
+    key: string;
+    name: string;
+    created_at: string;
+    message: string;
+    rotated_from?: string;
+    _request_id?: string;
+}
+export interface ApiKeyListResponse {
+    keys: ApiKey[];
+    _request_id?: string;
+}
+export interface ApiKeyRevokeResponse {
+    ok: true;
+    keyId: string;
+    revoked: true;
+    _request_id?: string;
+}
+export interface UnbrowseClientOptions {
+    apiKey?: string;
+    baseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    fetch?: typeof globalThis.fetch;
+    defaultHeaders?: Record<string, string>;
+    logLevel?: "off" | "error" | "warn" | "info" | "debug";
+}
+export interface RequestOptions {
+    timeout?: number;
+    maxRetries?: number;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}

package/dist-sdk/types.js

@@ -0,0 +1,5 @@
+// Minimal local types for sdk v7. Mirrors backend response shapes from
+// backend/src/routes/{resolve,execute,search,health,account}.ts. Kept local
+// (not re-exported from packages/sdk) so v7 can ship without depending on the
+// legacy package; the legacy package will be deprecated in favor of this one.
+export {};

package/dist-sdk/wallet-standard.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Wallet Standard (open-wallet-standard / `@wallet-standard`) bridge for the
+ * Unbrowse SDK — turns ANY Wallet Standard wallet (Phantom, Solflare, Backpack,
+ * a Privy embedded Solana wallet, lobster.cash, …) into a {@link PayHandler}
+ * that transparently satisfies an HTTP 402 over x402.
+ *
+ * Dependency-free by design: this module describes the *minimal* Wallet Standard
+ * shapes it consumes structurally — it does NOT import `@wallet-standard/*`, so
+ * the shipped SDK stays zero-dep and browser-safe. Pass any object that
+ * conforms (the real `@wallet-standard` `Wallet` does) and it just works.
+ *
+ * Delegation boundary: this bridge prepares the payment *intent* (the bytes to
+ * sign) and hands signing to the wallet. The wallet owns provisioning, approval,
+ * signing, and broadcast — we never touch keys. Web2 users who "just want to pay
+ * via API" can opt into {@link makeUnbrowseWallet}, an optional default wallet
+ * that delegates signing to the Unbrowse server via an API key.
+ */
+import type { PayHandler, PaymentRequired } from "./fetch.js";
+export type Bytes = Uint8Array;
+export interface WsAccount {
+    readonly address: string;
+    readonly publicKey: Bytes;
+    readonly chains: readonly string[];
+    readonly features: readonly string[];
+    readonly label?: string;
+}
+export interface WsConnectFeature {
+    connect(input?: {
+        silent?: boolean;
+    }): Promise<{
+        accounts: readonly WsAccount[];
+    }>;
+}
+export interface WsSignMessageFeature {
+    signMessage(input: {
+        account: WsAccount;
+        message: Bytes;
+    }): Promise<ReadonlyArray<{
+        signedMessage: Bytes;
+        signature: Bytes;
+    }>>;
+}
+/** The subset of a Wallet Standard `Wallet` this bridge uses. */
+export interface WsWallet {
+    readonly version: string;
+    readonly name: string;
+    readonly icon?: string;
+    readonly chains: readonly string[];
+    readonly accounts: readonly WsAccount[];
+    readonly features: Record<string, unknown> & {
+        "standard:connect"?: WsConnectFeature;
+        "solana:signMessage"?: WsSignMessageFeature;
+    };
+}
+/** Wallets that can connect + sign a Solana message (what x402 over Solana needs). */
+export declare function pickSolanaWallets(wallets: readonly WsWallet[]): WsWallet[];
+/**
+ * The bytes a wallet signs for an x402 payment. The server advertises the
+ * challenge in the 402 `terms` (an `accepts`/`flex`/`x402` envelope); we surface
+ * the common shapes and sign the canonical challenge string. The exact on-wire
+ * payload assembly is owned by the x402 facilitator the server names — this
+ * produces the message to authorize.
+ */
+export declare function paymentMessage(terms: PaymentRequired["terms"]): Bytes;
+export interface WalletStandardPayOptions {
+    /** Which account to pay from (defaults to the wallet's first account). */
+    account?: WsAccount;
+    /** Header name the server expects (default `X-PAYMENT`, the x402 standard). */
+    header?: string;
+}
+/**
+ * Build a {@link PayHandler} from any Wallet Standard wallet. On a 402 it asks
+ * the wallet to sign the payment challenge and returns the `X-PAYMENT` header
+ * for a single retry. Returns `null` (declines) if the wallet cannot sign — the
+ * caller then sees the original 402, never a thrown error.
+ *
+ *   import { Unbrowse } from "unbrowse/sdk";
+ *   import { walletStandardPay } from "unbrowse/sdk/wallet-standard";
+ *   const pay = walletStandardPay(myWallet);
+ *   const unbrowse = new Unbrowse({ apiKey, pay });
+ */
+export declare function walletStandardPay(wallet: WsWallet, opts?: WalletStandardPayOptions): PayHandler;
+export interface UnbrowseWalletOptions {
+    /** Required to opt in — signing is delegated to the Unbrowse server. */
+    apiKey: string;
+    /** The agent's Solana address (base58) the server signs for. */
+    address: string;
+    /** The agent's public key bytes. */
+    publicKey: Bytes;
+    /** Server base URL (defaults to the hosted Unbrowse API). */
+    baseUrl?: string;
+    /** Injected fetch (defaults to platform fetch); keeps this testable + zero-dep. */
+    fetch?: typeof fetch;
+}
+/**
+ * An OPTIONAL default wallet for users who don't want to run their own wallet —
+ * a Wallet Standard `Wallet` whose signing is delegated to the Unbrowse server
+ * (authorized by an API key). It is opt-in: you must pass an `apiKey`. Register
+ * it with `@wallet-standard/wallet`'s `registerWallet()` to expose it to any
+ * Wallet Standard consumer (including the Unbrowse frontend).
+ *
+ * Web2-native: the user "just wants to pay via API" — no seed phrase, no
+ * extension. The server (or lobster.cash, or any other wallet) remains the
+ * transaction-state authority; this is a thin convenience default, never forced.
+ */
+export declare function makeUnbrowseWallet(opts: UnbrowseWalletOptions): WsWallet;

package/dist-sdk/wallet-standard.js

@@ -0,0 +1,128 @@
+const SOLANA = "solana:";
+const F_CONNECT = "standard:connect";
+const F_SIGN_MESSAGE = "solana:signMessage";
+/** Wallets that can connect + sign a Solana message (what x402 over Solana needs). */
+export function pickSolanaWallets(wallets) {
+    return wallets.filter((w) => w.chains.some((c) => c.startsWith(SOLANA)) &&
+        F_SIGN_MESSAGE in w.features);
+}
+function toBase64(bytes) {
+    // browser + node, no deps
+    if (typeof btoa === "function") {
+        let s = "";
+        for (const b of bytes)
+            s += String.fromCharCode(b);
+        return btoa(s);
+    }
+    // @ts-ignore Buffer exists in node
+    return Buffer.from(bytes).toString("base64");
+}
+/**
+ * The bytes a wallet signs for an x402 payment. The server advertises the
+ * challenge in the 402 `terms` (an `accepts`/`flex`/`x402` envelope); we surface
+ * the common shapes and sign the canonical challenge string. The exact on-wire
+ * payload assembly is owned by the x402 facilitator the server names — this
+ * produces the message to authorize.
+ */
+export function paymentMessage(terms) {
+    let challenge = "";
+    if (terms && typeof terms === "object") {
+        const t = terms;
+        const accepts = Array.isArray(t.accepts) ? t.accepts[0] : undefined;
+        challenge =
+            (typeof t.challenge === "string" && t.challenge) ||
+                (typeof t.message === "string" && t.message) ||
+                (accepts && typeof accepts.challenge === "string" && accepts.challenge) ||
+                JSON.stringify(accepts ?? t);
+    }
+    return new TextEncoder().encode(challenge);
+}
+/**
+ * Build a {@link PayHandler} from any Wallet Standard wallet. On a 402 it asks
+ * the wallet to sign the payment challenge and returns the `X-PAYMENT` header
+ * for a single retry. Returns `null` (declines) if the wallet cannot sign — the
+ * caller then sees the original 402, never a thrown error.
+ *
+ *   import { Unbrowse } from "unbrowse/sdk";
+ *   import { walletStandardPay } from "unbrowse/sdk/wallet-standard";
+ *   const pay = walletStandardPay(myWallet);
+ *   const unbrowse = new Unbrowse({ apiKey, pay });
+ */
+export function walletStandardPay(wallet, opts = {}) {
+    const header = opts.header ?? "X-PAYMENT";
+    return async (ctx) => {
+        const sign = wallet.features[F_SIGN_MESSAGE];
+        if (!sign)
+            return null; // wallet can't sign Solana messages → decline cleanly
+        let account = opts.account ?? wallet.accounts[0];
+        if (!account) {
+            const connect = wallet.features[F_CONNECT];
+            if (!connect)
+                return null;
+            const { accounts } = await connect.connect();
+            account = accounts[0];
+            if (!account)
+                return null;
+        }
+        const message = paymentMessage(ctx.terms);
+        const [result] = await sign.signMessage({ account, message });
+        if (!result)
+            return null;
+        return { [header]: toBase64(result.signature) };
+    };
+}
+const DEFAULT_BASE = "https://beta-api.unbrowse.ai";
+/**
+ * An OPTIONAL default wallet for users who don't want to run their own wallet —
+ * a Wallet Standard `Wallet` whose signing is delegated to the Unbrowse server
+ * (authorized by an API key). It is opt-in: you must pass an `apiKey`. Register
+ * it with `@wallet-standard/wallet`'s `registerWallet()` to expose it to any
+ * Wallet Standard consumer (including the Unbrowse frontend).
+ *
+ * Web2-native: the user "just wants to pay via API" — no seed phrase, no
+ * extension. The server (or lobster.cash, or any other wallet) remains the
+ * transaction-state authority; this is a thin convenience default, never forced.
+ */
+export function makeUnbrowseWallet(opts) {
+    if (!opts.apiKey) {
+        throw new Error("makeUnbrowseWallet is opt-in: pass { apiKey } to delegate signing to the Unbrowse server.");
+    }
+    const base = (opts.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
+    const doFetch = opts.fetch ?? globalThis.fetch;
+    const account = {
+        address: opts.address,
+        publicKey: opts.publicKey,
+        chains: ["solana:mainnet"],
+        features: [F_SIGN_MESSAGE],
+    };
+    const signMessage = async ({ message }) => {
+        const res = await doFetch(`${base}/v1/wallet/sign`, {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${opts.apiKey}` },
+            body: JSON.stringify({ address: opts.address, message: toBase64(message) }),
+        });
+        if (!res.ok)
+            throw new Error(`unbrowse wallet sign failed: ${res.status}`);
+        const data = (await res.json());
+        const sig = Uint8Array.from(atobBytes(data.signature));
+        return [{ signedMessage: message, signature: sig }];
+    };
+    return {
+        version: "1.0.0",
+        name: "Unbrowse",
+        chains: ["solana:mainnet"],
+        accounts: [account],
+        features: {
+            [F_CONNECT]: { connect: async () => ({ accounts: [account] }) },
+            [F_SIGN_MESSAGE]: { signMessage },
+        },
+    };
+}
+function atobBytes(b64) {
+    const bin = typeof atob === "function" ? atob(b64) : // @ts-ignore
+        Buffer.from(b64, "base64").toString("binary");
+    const out = [];
+    for (let i = 0; i < bin.length; i++)
+        out.push(bin.charCodeAt(i));
+    return out;
+}

package/package.json

@@ -1,13 +1,25 @@
 {
   "name": "unbrowse",
-  "version": "7.2.0-preview.0",
+  "version": "8.0.0",
   "description": "Reverse-engineer any website into reusable API skills. Zero-dep single binary with embedded browser engine.",
+  "mcpName": "io.github.unbrowse-ai/unbrowse",
   "type": "module",
   "bin": {
     "unbrowse": "bin/unbrowse-wrapper.mjs"
   },
+  "exports": {
+    "./sdk": {
+      "types": "./dist-sdk/index.d.ts",
+      "import": "./dist-sdk/index.js"
+    },
+    "./sdk/wallet-standard": {
+      "types": "./dist-sdk/wallet-standard.d.ts",
+      "import": "./dist-sdk/wallet-standard.js"
+    }
+  },
   "files": [
     "bin",
+    "dist-sdk",
     "vendor/kuri",
     "vendor/utls-proxy",
     "scripts/release-assets.mjs",
@@ -20,7 +32,8 @@
   ],
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
-    "prepack": "node scripts/prepare-pack.mjs && node scripts/assert-kuri-vendor.mjs && node scripts/assert-utls-vendor.mjs",
+    "build:sdk": "tsc -p tsconfig.sdk.json",
+    "prepack": "npm run build:sdk && node scripts/prepare-pack.mjs && node scripts/assert-kuri-vendor.mjs && node scripts/assert-utls-vendor.mjs",
     "prepublishOnly": "node scripts/assert-release-flow.mjs && node scripts/verify-release-assets.mjs",
     "start": "bun src/index.ts",
     "dev": "bun --watch src/index.ts"
@@ -28,7 +41,6 @@
   "dependencies": {
     "@fastify/cors": "^11.2.0",
     "@fastify/rate-limit": "^10.3.0",
-    "@cascade-fyi/splits-sdk": "^0.11.1",
     "@solana/kit": "^6.6.0",
     "@x402/fetch": "^2.9.0",
     "bs58": "^6.0.0",

package/vendor/kuri/manifest.json

@@ -2,7 +2,7 @@
   "repo_url": "https://github.com/justrach/kuri.git",
   "branch": "adding-extensions",
   "source_sha": "8938f89f3d0c032bd19c59db0de4eadca18a1800",
-  "built_at": "2026-05-31T07:22:18.500Z",
+  "built_at": "2026-06-03T23:17:01.192Z",
   "binaries": {
     "darwin-arm64": {
       "zig_target": "aarch64-macos",
@@ -21,33 +21,33 @@
     },
     "linux-x64": {
       "zig_target": "x86_64-linux",
-      "sha256": "fa91a78820effff9db8465fa66567ac7fe22f42ea89522ef7b6f482e6678ad0d"
+      "sha256": "0c51e54e535d7992a39eb5e2c71caee07ade770a257b4a0467f54c2c3477e190"
     },
     "win-x64": {
       "zig_target": "x86_64-windows-gnu",
-      "sha256": "0919906d9b1512166dd6af207782949cd1ace6babec1817f94e4efdf3beb26db"
+      "sha256": "a9e9e048b9c37f462a5e8ed33c66e9d07631f4d1390008074d3bc7bb234a7103"
     }
   },
   "ffi": {
     "darwin-arm64": {
       "zig_target": "aarch64-macos",
       "lib": "libkuri_ffi.dylib",
-      "sha256": "ec87c92ed59368e674266ce47aa42c9c6496313953e2747d01b28e116f5a21f4"
+      "sha256": "7e1c9505a1b10dcec1f22d9ca24c72a9a99ddf024e8a216779a5bbb03f6d65f4"
     },
     "darwin-x64": {
       "zig_target": "x86_64-macos",
       "lib": "libkuri_ffi.dylib",
-      "sha256": "905e7e6bb67fb9791e4a3585e1802042a65d7fcb2d5d064651f2cfc48e97cb0d"
+      "sha256": "919513fc1f35ae2be0d457d827f7440c2f1fed165bce3ef5abcb42a20cc37d53"
     },
     "linux-arm64": {
       "zig_target": "aarch64-linux",
       "lib": "libkuri_ffi.so",
-      "sha256": "9dbdf3b4e4588ee30295715a74afb3c1e01059cf5a3c451f6ab21d63036caa44"
+      "sha256": "926376c2f27394c3141edfa75df52640583d0efec4ea378e8e1f516098dc1ad7"
     },
     "linux-x64": {
       "zig_target": "x86_64-linux",
       "lib": "libkuri_ffi.so",
-      "sha256": "7685b4b81338f5ade4d72839b85f341ca32f4711964d3becfc9970785240cdb2"
+      "sha256": "89f303f8d20bcaa30ed3b10280e9d018d51e29cc65728a56763e05be0bfc03a6"
     }
   }
 }