@oneshot-agent/sdk 0.26.0 → 0.28.1

package/dist/index.js

@@ -49,13 +49,22 @@ Object.defineProperty(exports, "getSwapQuote", { enumerable: true, get: function
 Object.defineProperty(exports, "executeSwap", { enumerable: true, get: function () { return swap_1.executeSwap; } });
 __exportStar(require("./errors"), exports);
 // Keep in sync with package.json `version`. Guarded by version.test.ts.
-const SDK_VERSION = '0.26.0';
+const SDK_VERSION = '0.28.1';
+/** HTTP poll cadence while push is unconfirmed: fast first checks, settling at 2s. */
+const HTTP_POLL_BACKOFF_MS = [300, 600, 1000, 2000];
+/** HTTP poll cadence once the WebSocket has delivered for this request. */
+const HTTP_POLL_RELAXED_MS = 5000;
 // ============================================================================
 // Environment Configuration
 // ============================================================================
 const BASE_URL = 'https://win.oneshotagent.com';
 const RPC_URL = 'https://mainnet.base.org';
 const CHAIN_ID = 8453;
+/** Chain id from an x402 network id such as `eip155:84532`; undefined when absent or malformed. */
+function chainIdFromNetwork(network) {
+    const m = /^eip155:(\d+)$/.exec(network ?? '');
+    return m ? Number(m[1]) : undefined;
+}
 const USDC_ADDRESS = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
 // ============================================================================
 // Public types — defined in ./types.ts. Re-exported below so existing
@@ -76,6 +85,39 @@ __exportStar(require("./types"), exports);
  * await agent.email({ to: 'user@example.com', subject: 'Hi', body: 'Hello' });
  * ```
  */
+/**
+ * Reject a budget config the server would reject, at construction rather than
+ * on the first paid call — a typo'd cap must not become "no cap".
+ */
+function validateBudgetConfig(budgets) {
+    if (!budgets)
+        return undefined;
+    // A typo'd key (`daliy`) from an untyped caller must not silently mean "no cap".
+    for (const key of Object.keys(budgets)) {
+        if (!['daily', 'perTransaction', 'alertAt', 'pauseAt'].includes(key)) {
+            throw new errors_1.ValidationError(`budgets.${key} is not a recognized field`, `budgets.${key}`);
+        }
+    }
+    const positive = (v, field) => {
+        if (v === undefined)
+            return;
+        if (typeof v !== 'number' || !Number.isFinite(v) || v <= 0) {
+            throw new errors_1.ValidationError(`budgets.${field} must be a positive number`, `budgets.${field}`);
+        }
+    };
+    const fraction = (v, field) => {
+        if (v === undefined)
+            return;
+        if (typeof v !== 'number' || !Number.isFinite(v) || v <= 0 || v > 1) {
+            throw new errors_1.ValidationError(`budgets.${field} must be a fraction in (0, 1]`, `budgets.${field}`);
+        }
+    };
+    positive(budgets.daily, 'daily');
+    positive(budgets.perTransaction, 'perTransaction');
+    fraction(budgets.alertAt, 'alertAt');
+    fraction(budgets.pauseAt, 'pauseAt');
+    return budgets;
+}
 class OneShot {
     /**
      * Async factory — required for CDP wallets (account creation is async).
@@ -117,6 +159,8 @@ class OneShot {
         this.logger = config.logger ?? console.log;
         this._currency = config.currency ?? 'USDC';
         this._slippage = config.slippage ?? 0.01;
+        this._budgets = validateBudgetConfig(config.budgets);
+        this._alertEmail = config.alerts?.email;
         this.rpcProvider = new ethers_1.ethers.JsonRpcProvider(config.rpcUrl ?? RPC_URL);
         if (walletProvider) {
             this.provider = walletProvider;
@@ -127,7 +171,6 @@ class OneShot {
         else {
             throw new errors_1.ValidationError('Provide privateKey or use OneShot.create() for CDP/custom wallets', 'config');
         }
-        // Validate ETH mode requirements
         if (this._currency === 'ETH' && !this.provider.sendTransaction) {
             throw new errors_1.ValidationError('ETH currency mode requires a wallet provider that supports sendTransaction', 'currency');
         }
@@ -153,6 +196,10 @@ class OneShot {
     get slippage() {
         return this._slippage;
     }
+    /** The budget config this instance was constructed with, if any. */
+    get budgetConfig() {
+        return this._budgets;
+    }
     // ---------------------------------------------------------------------------
     // Public methods
     // ---------------------------------------------------------------------------
@@ -412,7 +459,6 @@ class OneShot {
     async voice(options) {
         this.validate(options.objective, 'objective');
         this.validate(options.target_number, 'target_number');
-        // Check for empty arrays
         if (Array.isArray(options.target_number) && options.target_number.length === 0) {
             throw new errors_1.ValidationError('target_number array cannot be empty', 'target_number');
         }
@@ -476,7 +522,6 @@ class OneShot {
     async sms(options) {
         this.validate(options.message, 'message');
         this.validate(options.to_number, 'to_number');
-        // Check for empty arrays
         if (Array.isArray(options.to_number) && options.to_number.length === 0) {
             throw new errors_1.ValidationError('to_number array cannot be empty', 'to_number');
         }
@@ -1099,13 +1144,15 @@ class OneShot {
         }
         const path = `/v1/compute/${goalId}/fund`;
         const payload = { amount };
-        // First call: get quote (402)
+        await this.ensureBudgetsSynced();
         const quoteResp = await this.makeRequest(path, payload);
         if (quoteResp.status !== 402) {
-            throw new errors_1.ToolError('Expected 402 for compute fund quote', quoteResp.status, await quoteResp.text());
+            // A 403 here is the budget gate on the quote leg → BudgetExceededError.
+            await this.failFromResponse('Expected 402 for compute fund quote', quoteResp);
         }
         const quoteData = await quoteResp.json();
         this.log(`Compute fund quote: $${quoteData.payment_request.amount} to top up ${goalId}`);
+        this.assertWithinBudget(quoteData.payment_request.amount);
         const paymentInfo = {
             protocol: 'x402',
             network: `eip155:${quoteData.payment_request.chain_id}`,
@@ -1348,6 +1395,100 @@ class OneShot {
         }
         return qs.toString();
     }
+    /**
+     * Push `config.budgets` to the server once, before the first paid call.
+     *
+     * Lazy rather than in the constructor because the PUT is signed (async) and
+     * the constructor is sync. Idempotent per instance via the cached promise,
+     * which is only kept once the sync SUCCEEDS.
+     *
+     * FAILS CLOSED. If the server can't confirm the budget — network error,
+     * 5xx, 429, or a rejected config — this throws BudgetSyncError and the paid
+     * call is not made. Proceeding would silently drop the guardrail the
+     * developer configured, which is exactly the "empty wallet at 3am" the
+     * budget exists to prevent. The marker is cleared so the next paid call
+     * retries.
+     */
+    async ensureBudgetsSynced() {
+        if (!this._budgets && !this._alertEmail)
+            return;
+        if (this._budgetSync)
+            return this._budgetSync;
+        const attempt = (async () => {
+            const body = {};
+            if (this._budgets?.daily !== undefined)
+                body.daily = this._budgets.daily;
+            if (this._budgets?.perTransaction !== undefined)
+                body.per_transaction = this._budgets.perTransaction;
+            if (this._budgets?.alertAt !== undefined)
+                body.alert_at = this._budgets.alertAt;
+            if (this._budgets?.pauseAt !== undefined)
+                body.pause_at = this._budgets.pauseAt;
+            if (this._alertEmail !== undefined)
+                body.alert_email = this._alertEmail;
+            let response;
+            try {
+                response = await fetch(`${this.baseUrl}/v1/agents/me/budgets`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json', ...(await this.signedReadHeaders('write')) },
+                    body: JSON.stringify(body),
+                });
+            }
+            catch (err) {
+                throw new errors_1.BudgetSyncError(`Could not sync spend budget (network): ${err}`);
+            }
+            if (!response.ok) {
+                const text = await response.text();
+                throw new errors_1.BudgetSyncError(`Could not sync spend budget (${response.status}): ${text}`, response.status, text);
+            }
+            this.log('Budget synced');
+        })();
+        this._budgetSync = attempt;
+        try {
+            await attempt;
+        }
+        catch (err) {
+            // Not synced: clear the marker so the next paid call retries, then
+            // refuse this one rather than run it unguarded.
+            this._budgetSync = undefined;
+            this.log(`${err.message} — paid call refused until the budget is confirmed`);
+            throw err;
+        }
+    }
+    /**
+     * Local fast-fail on the per-transaction cap, so an oversized call fails
+     * without a network round-trip. The server enforces the same cap (and the
+     * daily one, which needs the ledger) regardless of which client calls —
+     * this is the same SDK-checks/server-enforces split as maxCost.
+     */
+    assertWithinBudget(total) {
+        const cap = this._budgets?.perTransaction;
+        if (!cap || cap <= 0)
+            return;
+        const amount = parseFloat(total);
+        if (Number.isFinite(amount) && amount > cap) {
+            throw new errors_1.BudgetExceededError(`Quote $${total} exceeds this agent's per-transaction budget of $${cap}`, 'per_transaction', cap, undefined, amount);
+        }
+    }
+    /**
+     * Current spend budget and today's utilization.
+     *
+     * @example
+     * ```typescript
+     * const b = await agent.budgets();
+     * console.log(`${b.spent_today_usdc} of ${b.daily_usdc} spent, resets ${b.resets_at}`);
+     * ```
+     */
+    async budgets() {
+        const response = await fetch(`${this.baseUrl}/v1/agents/me/budgets`, {
+            headers: await this.signedReadHeaders(),
+        });
+        if (!response.ok) {
+            throw new errors_1.ToolError('Failed to fetch budgets', response.status, await response.text());
+        }
+        const body = await response.json();
+        return (body.data ?? body);
+    }
     /** Local fast-fail guard: throw when a quote total exceeds the caller's cap. */
     assertWithinMaxCost(total, maxCost) {
         if (maxCost && parseFloat(total) > maxCost) {
@@ -1394,8 +1535,28 @@ class OneShot {
         const rejection = response.status === 402 ? this.parsePaymentRejection(text) : undefined;
         if (rejection)
             throw rejection;
+        const budget = response.status === 403 ? this.parseBudgetRejection(text) : undefined;
+        if (budget)
+            throw budget;
         throw new errors_1.ToolError(message, response.status, text);
     }
+    /**
+     * Map a 403 `budget_exceeded` body onto a typed error, so callers can catch
+     * "my own budget stopped this" separately from an auth failure or a payment
+     * rejection. Any other 403 falls through to ToolError.
+     */
+    parseBudgetRejection(text) {
+        try {
+            const body = JSON.parse(text);
+            if (body.error !== 'budget_exceeded')
+                return undefined;
+            const b = body.budget ?? {};
+            return new errors_1.BudgetExceededError(body.message ?? 'Agent spend budget exceeded', b.reason === 'per_transaction' ? 'per_transaction' : 'daily', b.cap !== undefined ? parseFloat(b.cap) : undefined, b.spent !== undefined ? parseFloat(b.spent) : undefined, b.charge !== undefined ? parseFloat(b.charge) : undefined, b.resets_at);
+        }
+        catch {
+            return undefined;
+        }
+    }
     parsePaymentRejection(text) {
         let data;
         try {
@@ -1455,7 +1616,6 @@ class OneShot {
             ...this.maxCostHeader(maxCost),
             ...this.idempotencyHeader(idempotencyKey),
         };
-        // Validate memo
         if (payload.memo !== undefined) {
             if (typeof payload.memo !== 'string' || payload.memo.trim().length === 0) {
                 delete payload.memo; // Drop invalid memo silently
@@ -1468,7 +1628,6 @@ class OneShot {
         else if (!endpoint.includes('/inbox') && !endpoint.includes('/notifications') && !endpoint.includes('/balance')) {
             this.log('No memo provided — consider adding a reason for audit trail');
         }
-        // Validate decisionContext
         if (payload.decisionContext !== undefined) {
             if (typeof payload.decisionContext !== 'object' || payload.decisionContext === null) {
                 delete payload.decisionContext;
@@ -1483,6 +1642,9 @@ class OneShot {
         if (signal?.aborted) {
             throw new errors_1.OneShotError('Operation cancelled');
         }
+        // One-time push of config.budgets before the first paid call, so the
+        // server-side gate knows about them on this very request.
+        await this.ensureBudgetsSynced();
         let response = await this.makeRequest(endpoint, payload, undefined, quoteId, signal, undefined, extraHeaders);
         // Handle 402 Payment Required
         if (response.status === 402) {
@@ -1501,6 +1663,7 @@ class OneShot {
                 token: { address: accepted.asset, symbol: 'USDC', decimals: 6 }
             };
             this.log(`Payment required: ${paymentInfo.amount} USDC`);
+            this.assertWithinBudget(paymentInfo.amount);
             this.checkAbortBeforePayment(signal);
             const auth = await this.signPaymentAuthorization(paymentInfo, accepted, resource, extensions);
             response = await this.makeRequest(endpoint, payload, auth, quoteId, signal, undefined, extraHeaders);
@@ -1527,16 +1690,20 @@ class OneShot {
      * body directly), since that differs per tool.
      */
     async runQuoteToPay(cfg) {
+        await this.ensureBudgetsSynced();
         const quoteResp = await this.makeRequest(cfg.endpoint, cfg.payload, undefined, undefined, cfg.signal, cfg.quoteTimeoutMs, this.maxCostHeader(cfg.maxCost));
         if (quoteResp.status === 400 && cfg.on400) {
             await cfg.on400(quoteResp);
         }
         if (quoteResp.status !== 402) {
-            throw new errors_1.ToolError(cfg.expectMsg, quoteResp.status, await quoteResp.text());
+            // Routes the budget gate on the quote leg (fixed-price ones) surface a
+            // 403 here; failFromResponse maps it to BudgetExceededError.
+            await this.failFromResponse(cfg.expectMsg, quoteResp);
         }
         const quoteData = await quoteResp.json();
         cfg.onQuote(quoteData.context);
         this.assertWithinMaxCost(cfg.totalOf(quoteData.context), cfg.maxCost);
+        this.assertWithinBudget(cfg.totalOf(quoteData.context));
         const paymentInfo = {
             protocol: 'x402',
             network: `eip155:${quoteData.payment_request.chain_id}`,
@@ -1553,23 +1720,62 @@ class OneShot {
         const execResp = await this.makeRequest(cfg.endpoint, cfg.payload, auth, quoteData.context.quote_id, cfg.signal, cfg.execTimeoutMs);
         return { context: quoteData.context, execResp };
     }
+    /**
+     * Wait for a previously dispatched job and return its result.
+     *
+     * Use this to resolve the `request_id` returned by a call made with
+     * `wait: false`, or to resume waiting after a client restart. Delivery is the
+     * same as for blocking calls: WebSocket push when the server offers it, HTTP
+     * polling of `GET /v1/requests/:id` as the source of truth.
+     */
+    async waitForResult(requestId, options = {}) {
+        this.validate(requestId, 'requestId');
+        return this.pollJob(requestId, options.timeout, options.signal, options.onStatusUpdate, options.waitForPhones ? { waitForPhones: true, phoneTimeoutSec: options.phoneTimeoutSec } : undefined);
+    }
     async pollJob(requestId, timeoutSec, signal, onStatusUpdate, phoneOpts) {
-        // Try WebSocket push first, fall back to HTTP polling. Both phases share a
-        // single deadline so the combined wait never exceeds the caller's timeout —
-        // previously the WS cap (≤180s) plus a fresh full HTTP timeout could total
-        // up to ~1.6× timeoutSec (e.g. ~480s for a 300s request).
-        const deadline = timeoutSec != null ? Date.now() + timeoutSec * 1000 : undefined;
+        // HTTP polling is the source of truth; the WebSocket is an accelerator.
+        // Both run concurrently from the start and the first terminal outcome wins,
+        // so a broken push channel (Redis down, worker unconfigured, proxy that
+        // swallows frames) costs nothing beyond the poll cadence. Previously the
+        // client waited 60% of its timeout on the socket before polling at all —
+        // in prod that was ~72s of dead air on every call while the push never came.
+        const inner = new AbortController();
+        const onOuterAbort = () => inner.abort();
+        if (signal?.aborted)
+            inner.abort();
+        else
+            signal?.addEventListener('abort', onOuterAbort, { once: true });
+        const wait = { pushConfirmed: false, lastStatus: undefined, via: undefined };
+        // Two sources now report status; only surface changes to the caller.
+        const emit = (status) => {
+            if (status === wait.lastStatus)
+                return;
+            wait.lastStatus = status;
+            onStatusUpdate?.(status, requestId);
+        };
+        const startedAt = Date.now();
+        const wsBranch = this.waitViaWebSocket(requestId, inner.signal, emit, wait).catch((err) => {
+            // A failed job or a cancellation is a real outcome. Anything else is a
+            // transport problem: never settle the race on it, HTTP carries on.
+            if (err instanceof errors_1.OneShotError)
+                throw err;
+            this.log(`WebSocket unavailable (${err instanceof Error ? err.message : String(err)}) — relying on HTTP polling`);
+            return new Promise(() => { });
+        });
+        const httpBranch = this.pollJobHttp(requestId, timeoutSec, inner.signal, emit, wait);
+        // The losing branch rejects on abort; mark both handled so it never
+        // surfaces as an unhandled rejection.
+        wsBranch.catch(() => { });
+        httpBranch.catch(() => { });
         let result;
         try {
-            result = await this.waitViaWebSocket(requestId, timeoutSec, signal, onStatusUpdate);
+            result = await Promise.race([wsBranch, httpBranch]);
         }
-        catch {
-            this.log('WebSocket unavailable, falling back to HTTP polling');
-            const remainingSec = deadline != null
-                ? Math.max(1, Math.ceil((deadline - Date.now()) / 1000))
-                : undefined;
-            result = await this.pollJobHttp(requestId, remainingSec, signal, onStatusUpdate);
+        finally {
+            inner.abort();
+            signal?.removeEventListener('abort', onOuterAbort);
         }
+        this.log(`Job ${requestId} ready after ${Date.now() - startedAt}ms via ${wait.via ?? 'unknown'}`);
         // Optional second phase: keep polling for the async phone-reveal webhook.
         // Only kicks in when the caller explicitly opts in AND the result still
         // has phones_pending=true (set by the worker when the upstream enrichment
@@ -1653,88 +1859,70 @@ class OneShot {
         // so the consumer knows phones never arrived.
         return lastResult;
     }
-    waitViaWebSocket(requestId, timeoutSec, signal, onStatusUpdate) {
+    /**
+     * WebSocket branch of a job wait. Resolves on a `completed` push for this
+     * request, rejects with `JobError` on `failed` and with `OneShotError` on
+     * abort. Every other failure (no WebSocket global, handshake refused, socket
+     * closed early) rejects with a plain `Error`, which `pollJob` treats as
+     * "no push available" rather than as an outcome. There is no timeout here:
+     * the HTTP branch owns the deadline and aborts this one when it settles.
+     */
+    waitViaWebSocket(requestId, signal, emit, wait) {
         return new Promise((resolve, reject) => {
-            const maxWaitMs = (timeoutSec ?? 120) * 1000;
-            // Cap WS timeout to 60% of caller timeout so HTTP fallback has real time to work.
-            // Floor at 10s (below that, skip WS entirely). This prevents the WS timeout
-            // from racing with Cloud Run / load balancer timeouts.
-            const wsTimeoutMs = Math.max(Math.floor(maxWaitMs * 0.6), 10000);
-            if (wsTimeoutMs >= maxWaitMs) {
-                // Timeout too short for WS + HTTP — reject immediately to force HTTP path
-                return reject(new Error('Timeout too short for WebSocket path'));
+            if (typeof WebSocket === 'undefined') {
+                return reject(new Error('WebSocket not available'));
+            }
+            if (signal.aborted) {
+                return reject(new errors_1.OneShotError('Operation cancelled'));
             }
             const wsUrl = this.baseUrl.replace(/^http/, 'ws') +
                 `/v1/requests/subscribe?wallet=${encodeURIComponent(this.provider.address)}`;
             let ws;
-            let settled = false;
-            let receivedAnyMessage = false;
             try {
                 ws = new WebSocket(wsUrl);
             }
             catch {
                 return reject(new Error('WebSocket not available'));
             }
+            let settled = false;
             const settle = (fn) => {
                 if (settled)
                     return;
                 settled = true;
                 fn();
             };
-            // Overall WS timeout — bail to HTTP fallback with time to spare
-            const timeout = setTimeout(() => {
-                settle(() => {
-                    ws.close();
-                    reject(new Error('WebSocket timeout — falling back to HTTP'));
-                });
-            }, wsTimeoutMs);
-            // First-message deadline: if no relevant message arrives within 15s of
-            // subscribing, the WS connection is likely silent (load balancer proxying
-            // without forwarding, scale-from-zero, etc). Bail fast to HTTP.
-            let firstMessageTimer = null;
             const cleanup = () => {
-                clearTimeout(timeout);
-                if (firstMessageTimer)
-                    clearTimeout(firstMessageTimer);
-                if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                signal.removeEventListener('abort', onAbort);
+                // 0 = CONNECTING, 1 = OPEN (avoid relying on static props of a fake global)
+                if (ws.readyState === 0 || ws.readyState === 1) {
                     ws.close();
                 }
             };
-            if (signal) {
-                signal.addEventListener('abort', () => {
-                    settle(() => {
-                        cleanup();
-                        reject(new errors_1.OneShotError('Operation cancelled'));
-                    });
-                }, { once: true });
-            }
+            const onAbort = () => {
+                settle(() => {
+                    cleanup();
+                    reject(new errors_1.OneShotError('Operation cancelled'));
+                });
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
             ws.onopen = () => {
                 ws.send(JSON.stringify({ subscribe: [requestId] }));
-                // Start first-message deadline after subscribing
-                firstMessageTimer = setTimeout(() => {
-                    if (!receivedAnyMessage) {
-                        settle(() => {
-                            this.log('WebSocket silent after subscribe — falling back to HTTP');
-                            cleanup();
-                            reject(new Error('WebSocket silent — no messages received'));
-                        });
-                    }
-                }, 15000);
             };
             ws.onmessage = (event) => {
-                receivedAnyMessage = true;
-                if (firstMessageTimer) {
-                    clearTimeout(firstMessageTimer);
-                    firstMessageTimer = null;
-                }
                 try {
                     const msg = JSON.parse(typeof event.data === 'string' ? event.data : event.data.toString());
+                    // The subscribe ack and other jobs' pushes are not request-scoped.
                     if (msg.request_id !== requestId)
                         return;
+                    if (!wait.pushConfirmed) {
+                        wait.pushConfirmed = true;
+                        this.log('WebSocket push confirmed — relaxing HTTP polling');
+                    }
                     if (msg.status === 'completed') {
                         this.log('Job completed (WebSocket)');
                         settle(() => {
                             cleanup();
+                            wait.via = 'ws';
                             const result = (msg.result ?? msg);
                             if (msg.request_id && typeof result === 'object' && result !== null && !('request_id' in result)) {
                                 result.request_id = msg.request_id;
@@ -1745,11 +1933,12 @@ class OneShot {
                     else if (msg.status === 'failed') {
                         settle(() => {
                             cleanup();
+                            wait.via = 'ws';
                             reject(new errors_1.JobError(`Job failed: ${msg.error ?? 'Unknown'}`, requestId, String(msg.error ?? 'Unknown'), msg.error_code));
                         });
                     }
                     else {
-                        onStatusUpdate?.(msg.status, requestId);
+                        emit(String(msg.status));
                     }
                 }
                 catch {
@@ -1763,9 +1952,7 @@ class OneShot {
                 });
             };
             ws.onclose = () => {
-                // Any close before we got a result — reject so HTTP fallback kicks in.
-                // Previously we only rejected on non-1000 codes, but a clean close
-                // without a result is equally fatal for the poll loop.
+                // Any close before we got a result means no push is coming.
                 settle(() => {
                     cleanup();
                     reject(new Error('WebSocket closed before result'));
@@ -1773,12 +1960,18 @@ class OneShot {
             };
         });
     }
-    async pollJobHttp(requestId, timeoutSec, signal, onStatusUpdate) {
+    /**
+     * HTTP branch of a job wait: polls `GET /v1/requests/:id` immediately, then
+     * on a short backoff (300ms → 2s). Once the WebSocket has proven it delivers
+     * for this request, polling relaxes to 5s and acts as a safety net only.
+     * Owns the caller's deadline (`JobTimeoutError`).
+     */
+    async pollJobHttp(requestId, timeoutSec, signal, emit, wait) {
         const maxWaitMs = (timeoutSec ?? 120) * 1000;
         const startTime = Date.now();
-        const pollInterval = 2000;
         let retries = 0;
         const maxRetries = 3;
+        let polls = 0;
         while (Date.now() - startTime < maxWaitMs) {
             if (signal?.aborted)
                 throw new errors_1.OneShotError('Operation cancelled');
@@ -1788,11 +1981,19 @@ class OneShot {
                     signal
                 });
                 if (!resp.ok) {
-                    throw new errors_1.ToolError('Failed to check job status', resp.status, await resp.text());
+                    const body = await resp.text();
+                    // 5xx / 429 from the poll endpoint are transient — keep polling.
+                    // Any other non-2xx (401/403/404) is a real answer about this job.
+                    if (resp.status >= 500 || resp.status === 429) {
+                        throw new Error(`Poll returned ${resp.status}: ${body.slice(0, 200)}`);
+                    }
+                    throw new errors_1.ToolError('Failed to check job status', resp.status, body);
                 }
                 const job = await resp.json();
                 if (job.status === 'completed') {
                     this.log('Job completed');
+                    if (wait)
+                        wait.via = 'http';
                     const result = (job.result ?? job);
                     // Propagate request_id into the result so callers always have it
                     if (job.request_id && typeof result === 'object' && result !== null && !('request_id' in result)) {
@@ -1801,11 +2002,20 @@ class OneShot {
                     return result;
                 }
                 if (job.status === 'failed') {
+                    if (wait)
+                        wait.via = 'http';
                     throw new errors_1.JobError(`Job failed: ${job.error ?? 'Unknown'}`, requestId, String(job.error ?? 'Unknown'), job.error_code);
                 }
-                onStatusUpdate?.(job.status, requestId);
+                emit?.(String(job.status));
                 retries = 0;
-                await this.sleep(pollInterval, signal);
+                const interval = wait?.pushConfirmed
+                    ? HTTP_POLL_RELAXED_MS
+                    : HTTP_POLL_BACKOFF_MS[Math.min(polls, HTTP_POLL_BACKOFF_MS.length - 1)];
+                polls++;
+                const remaining = maxWaitMs - (Date.now() - startTime);
+                if (remaining <= 0)
+                    break;
+                await this.sleep(Math.min(interval, remaining), signal);
             }
             catch (err) {
                 if (err instanceof errors_1.OneShotError)
@@ -1813,7 +2023,7 @@ class OneShot {
                 if (++retries > maxRetries) {
                     throw new errors_1.OneShotError(`Polling failed after ${maxRetries} retries: ${err}`);
                 }
-                const backoff = pollInterval * Math.pow(2, retries - 1);
+                const backoff = 2000 * Math.pow(2, retries - 1);
                 this.log(`Retry ${retries}/${maxRetries} in ${backoff}ms`);
                 await this.sleep(backoff, signal);
             }
@@ -1848,7 +2058,6 @@ class OneShot {
         }
         if (quoteId)
             headers['x-quote-id'] = quoteId;
-        // Create timeout signal if specified
         let fetchSignal = signal;
         let timeoutId;
         if (timeoutMs && !signal) {
@@ -1965,14 +2174,18 @@ class OneShot {
         const validAfter = now - 300; // Buffer for clock skew
         const validBefore = now + 3600;
         const nonceHex = ethers_1.ethers.hexlify(nonce);
-        // Use EIP-712 domain from the server's payment requirements
+        // Use the EIP-712 domain from the server's payment requirements — name,
+        // version AND chain. The chain used to be the mainnet constant, which made
+        // every signature invalid against Base Sepolia (the domain separator
+        // includes chainId), so the SDK could never pay on staging.
         const domainName = accepted.extra?.name || 'USD Coin';
         const domainVersion = accepted.extra?.version || '2';
+        const chainId = chainIdFromNetwork(accepted.network ?? paymentInfo.network) ?? CHAIN_ID;
         // Sign EIP-3009 TransferWithAuthorization
         const signature = await this.provider.signTypedData({
             name: domainName,
             version: domainVersion,
-            chainId: CHAIN_ID,
+            chainId,
             verifyingContract: paymentInfo.token.address
         }, {
             TransferWithAuthorization: [