@steerpane/sdk 0.1.0 → 0.2.0

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { APIError } from "./errors.js";
-import type { AgentRun, Capture, Credential, CrawlJob, EmbedLink, FetchResult, HelpRequest, HumanResult, Json, Page, Profile, SearchResponse, Session, StoredFile, UploadUrl, Webhook } from "./types.js";
+import type { ActionGuard, ActionGuardRule, ActionGuardUnlock, AgentRun, CaptchaSolveResult, Capture, Credential, CrawlJob, Device, DevicePairingCode, EmbedLink, EndUser, FetchResult, HelpRequest, HumanResult, Json, Page, Profile, SearchResponse, SecretFillResult, Session, StoredFile, UploadUrl, WaitForCodeOptions, WaitForCodeResult, Webhook, WebhookDelivery } from "./types.js";
 export declare const DEFAULT_BASE_URL = "https://api.steerpane.app";
 export interface SteerpaneOptions {
     /** Falls back to `STEERPANE_API_TOKEN`. */
@@ -12,6 +12,9 @@ export interface SteerpaneOptions {
     allowInsecureHttp?: boolean;
     /** Replace `fetch`, for tests. */
     fetch?: typeof fetch;
+    /** Who your program is, e.g. "Acme support bot" (falls back to `STEERPANE_AGENT_NAME`). The dashboard shows it on the sessions it
+     *  drives, their activity and the agent cursor (sent as `X-Steerpane-Agent`). Without it the token's name is shown. */
+    agentName?: string;
 }
 interface RequestOptions {
     json?: unknown;
@@ -53,6 +56,24 @@ declare class Actions {
     extract(sessionId: string, instruction: string, args?: Json): Promise<Json>;
     download(sessionId: string, args?: Json): Promise<Json>;
     uploadFile(sessionId: string, args?: Json): Promise<Json>;
+    /** Type a value you hold (a password, an access code) into ONE field of the page, on the site you name. `POST /v1/sessions/{id}/secret-fill`; needs the `vault:use` scope.
+     * The runtime checks the origin of the frame holding the field against `site` in the same step that types (`exact: true`: the host must match exactly, no subdomains).
+     * `kind` is `password` (default; the field must be a password input) or `code`. `submit` and `exact` must be real booleans.
+     *
+     * The value is never logged, recorded, queued or returned (the result shows `value: "••••••"`). The SDK doesn't echo it either, and this call is NEVER retried: no
+     * automatic retry, no Idempotency-Key (the API refuses one). Treat every failure that isn't a definitive refusal before typing (`origin_mismatch`, `insecure_origin`,
+     * `field_type_mismatch`, `element_not_found`, ...) as "maybe typed": look at the page before you send it again.
+     * **`typed: true` in the result, or a 409 with `details.typed`, means the value is already in the page: do not send it again.** A human in control or a paused agent
+     * answers 409 `human_in_control` with nothing typed; a secret is never queued. */
+    secretFill(sessionId: string, input: {
+        site: string;
+        selector: string;
+        value: string;
+        kind?: "password" | "code";
+        submit?: boolean;
+        exact?: boolean;
+        frame?: string;
+    }): Promise<SecretFillResult>;
     /** Type a stored credential into the page. The secret never comes back. Refused off the credential's site. */
     vaultFill(sessionId: string, credentialId: string, args?: Json): Promise<Json>;
 }
@@ -64,15 +85,18 @@ declare class Sessions {
         profile_id?: string;
         q?: string;
         project_id?: string;
+        end_user_id?: string;
         limit?: number;
         cursor?: string | null;
     }): Promise<Page<Session>>;
-    /** Start a browser. `config` takes the session fields in the API docs, such as `initial_url`, `profile_id`, `auto_close`, `timeout_min`. */
+    /** Start a browser. `config` takes the session fields in the API docs, such as `initial_url`, `profile_id`, `end_user_id`, `auto_close`, `timeout_min`.
+     * `profile_wait: { timeout_s: 300 }` queues behind the profile's current writer instead of failing with 409 `profile_locked`: the session comes back with
+     * `status: "queued"` and `queue_position`; stop it to cancel. Without `profile_id` you get a throwaway browser that saves nothing. */
     create(config?: Json, options?: {
         idempotencyKey?: string;
     }): Promise<Session>;
     get(sessionId: string): Promise<Session>;
-    /** Wait for the browser to leave `starting`. Throws if it ends instead, or doesn't start in time. */
+    /** Wait for the browser to leave `starting` (and `queued`, for a session created with `profile_wait`: raise `timeoutS` to cover the wait). Throws if it ends instead, or doesn't start in time. */
     waitUntilReady(sessionId: string, options?: {
         timeoutS?: number;
         pollS?: number;
@@ -86,6 +110,28 @@ declare class Sessions {
         outcome?: "done" | "not_done";
         note?: string;
     }): Promise<Session>;
+    /** Name what the agent may not click or submit without approval. `rules` replaces the current ones; `[]` removes the guard. A blocked action fails with the
+     * `action_guard_blocked` error code until `unlockAction` is called. The service ships no rules of its own. */
+    setActionGuard(sessionId: string, rules: ActionGuardRule[]): Promise<ActionGuard>;
+    getActionGuard(sessionId: string): Promise<ActionGuard>;
+    removeActionGuard(sessionId: string): Promise<void>;
+    /** Approve ONE blocked gesture (the next matching click, Enter-submit or form submit, optionally only for `ruleId`) within `ttlS` seconds (1 to 120, default 30). Needs the `takeover` scope.
+     * The result's `late_targets` counts frames where a page script may have registered a listener ahead of the guard; if you need certainty, decline to rely on the guard when it is above 0.
+     * An action that spends the unlock returns `unlock_spent: true`, and an error it ends with carries `details.unlock_spent: true` (read it from `APIError.details`/`ToolError.details`): the act may have happened, so never click again, whatever the error.
+     * A session whose guard can't be installed refuses guarded actions with `action_guard_unavailable`. */
+    unlockAction(sessionId: string, options?: {
+        ruleId?: string;
+        ttlS?: number;
+    }): Promise<ActionGuardUnlock>;
+    /** Run the CAPTCHA solver on the session's page. One call waits about 45 s: while `status` is `in_progress`, call again (the worker keeps running, it never restarts).
+     * `onFailure` is `wait_for_human` (default), `request_help` or `return`. Needs a CAPTCHA model on the organization. */
+    solveCaptcha(sessionId: string, options?: {
+        onFailure?: "wait_for_human" | "request_help" | "return";
+        maxReloads?: number;
+        model?: string;
+        captchaImageSelector?: string;
+        captchaInputSelector?: string;
+    }): Promise<CaptchaSolveResult>;
     /** Ask a person for help. The agent goes on hold, and `agent.human_help_requested` fires. */
     requestHelp(sessionId: string, input: {
         reason: string;
@@ -110,10 +156,12 @@ declare class Profiles {
     list(params?: {
         tag?: string;
         q?: string;
+        end_user_id?: string;
         limit?: number;
         cursor?: string | null;
     }): Promise<Page<Profile>>;
     get(profileId: string): Promise<Profile>;
+    /** `fields` include `end_user_id` to give the profile to one of your end users. */
     create(name: string, fields?: Json): Promise<Profile>;
     update(profileId: string, fields: Json): Promise<Profile>;
     delete(profileId: string): Promise<void>;
@@ -127,6 +175,46 @@ declare class Profiles {
         imported: number;
     }>;
 }
+/** Your own customers. Profiles and sessions can belong to one; a session only uses profiles of its own end user. */
+declare class EndUsers {
+    private readonly c;
+    constructor(c: Steerpane);
+    /** Idempotent on `external_id`: calling it again returns the existing end user unchanged. */
+    create(externalId: string, fields?: {
+        name?: string;
+        metadata?: Record<string, string>;
+    }): Promise<EndUser>;
+    list(params?: {
+        external_id?: string;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<Page<EndUser>>;
+    get(endUserId: string): Promise<EndUser>;
+    update(endUserId: string, fields: {
+        name?: string;
+        metadata?: Record<string, string>;
+        disabled?: boolean;
+    }): Promise<EndUser>;
+    /** 409 while it owns profiles or live sessions; `cascade: true` deletes its profiles too (never while a session is live). */
+    delete(endUserId: string, options?: {
+        cascade?: boolean;
+    }): Promise<void>;
+    /** A single-use code (valid a few minutes) to hand to this end user so they can pair their own computer. Answers 404 while devices are off for the service. */
+    createDevicePairingCode(endUserId: string): Promise<DevicePairingCode>;
+}
+/** Computers that run sessions: yours, shared ones, and your end users'. Answers 404 while devices are off for the service. */
+declare class Devices {
+    private readonly c;
+    constructor(c: Steerpane);
+    /** `scope` is `user`, `org` or `end_user`; `end_user_id` narrows to one end user's devices. Capped at 200, no cursor. */
+    list(params?: {
+        scope?: "user" | "org" | "end_user";
+        end_user_id?: string;
+    }): Promise<{
+        data: Device[];
+    }>;
+    get(deviceId: string): Promise<Device>;
+}
 /** Hosted agent runs. These use your organization's own model key. */
 declare class Runs {
     private readonly c;
@@ -212,7 +300,7 @@ declare class Webhooks {
     delete(webhookId: string): Promise<void>;
     sendTest(webhookId: string, input?: {
         event?: string;
-    }): Promise<Json>;
+    }): Promise<WebhookDelivery>;
 }
 /** Stored logins. Passwords and TOTP secrets go in and never come back to an API token. */
 declare class Vault {
@@ -260,18 +348,27 @@ declare class Mcp {
     call<T = Json>(tool: string, args?: Json, options?: {
         timeoutS?: number;
     }): Promise<T>;
+    /** Wait for an email or SMS verification code (the MCP tool `wait_for_code`). With `sessionId` the code is typed into the page and never reaches you
+     * (`status: "entered"`); with `returnCode: true` you get it back (`status: "received"`). The server answers in rounds of about 45 s with `status: "waiting"`:
+     * this keeps calling, with the `started_at` it was given, until the code arrives or `timeoutS` runs out (`status: "timeout"`), so the result is always final.
+     * Needs the `vault:use` scope and a code source set up on the organization. */
+    waitForCode(options?: WaitForCodeOptions): Promise<WaitForCodeResult>;
 }
 /** Client for the Steerpane API. */
 export declare class Steerpane {
     readonly baseUrl: string;
     readonly timeoutMs: number;
     readonly maxRetries: number;
+    /** Sent as X-Steerpane-Agent: the name the dashboard shows for this program. */
+    readonly agentName: string | undefined;
     /** The token, for helpers that need it. Not enumerable, so logging the client doesn't print it. */
     readonly token: string;
     private readonly fetchImpl;
     readonly sessions: Sessions;
     readonly actions: Actions;
     readonly profiles: Profiles;
+    readonly endUsers: EndUsers;
+    readonly devices: Devices;
     readonly runs: Runs;
     readonly files: Files;
     readonly embeds: Embeds;

package/dist/client.js

@@ -51,6 +51,18 @@ class Actions {
     extract(sessionId, instruction, args = {}) { return this.run(sessionId, "extract", { instruction, ...args }); }
     download(sessionId, args = {}) { return this.run(sessionId, "download", args); }
     uploadFile(sessionId, args = {}) { return this.run(sessionId, "upload_file", args); }
+    /** Type a value you hold (a password, an access code) into ONE field of the page, on the site you name. `POST /v1/sessions/{id}/secret-fill`; needs the `vault:use` scope.
+     * The runtime checks the origin of the frame holding the field against `site` in the same step that types (`exact: true`: the host must match exactly, no subdomains).
+     * `kind` is `password` (default; the field must be a password input) or `code`. `submit` and `exact` must be real booleans.
+     *
+     * The value is never logged, recorded, queued or returned (the result shows `value: "••••••"`). The SDK doesn't echo it either, and this call is NEVER retried: no
+     * automatic retry, no Idempotency-Key (the API refuses one). Treat every failure that isn't a definitive refusal before typing (`origin_mismatch`, `insecure_origin`,
+     * `field_type_mismatch`, `element_not_found`, ...) as "maybe typed": look at the page before you send it again.
+     * **`typed: true` in the result, or a 409 with `details.typed`, means the value is already in the page: do not send it again.** A human in control or a paused agent
+     * answers 409 `human_in_control` with nothing typed; a secret is never queued. */
+    secretFill(sessionId, input) {
+        return this.c.request("POST", `/v1/sessions/${seg(sessionId)}/secret-fill`, { json: clean(input) });
+    }
     /** Type a stored credential into the page. The secret never comes back. Refused off the credential's site. */
     vaultFill(sessionId, credentialId, args = {}) { return this.run(sessionId, "vault_fill", { credential_id: credentialId, ...args }); }
 }
@@ -62,12 +74,14 @@ class Sessions {
     list(params = {}) {
         return this.c.request("GET", "/v1/sessions", { params });
     }
-    /** Start a browser. `config` takes the session fields in the API docs, such as `initial_url`, `profile_id`, `auto_close`, `timeout_min`. */
+    /** Start a browser. `config` takes the session fields in the API docs, such as `initial_url`, `profile_id`, `end_user_id`, `auto_close`, `timeout_min`.
+     * `profile_wait: { timeout_s: 300 }` queues behind the profile's current writer instead of failing with 409 `profile_locked`: the session comes back with
+     * `status: "queued"` and `queue_position`; stop it to cancel. Without `profile_id` you get a throwaway browser that saves nothing. */
     create(config = {}, options = {}) {
         return this.c.request("POST", "/v1/sessions", { json: clean(config), headers: { "Idempotency-Key": options.idempotencyKey ?? crypto.randomUUID() } });
     }
     get(sessionId) { return this.c.request("GET", `/v1/sessions/${seg(sessionId)}`); }
-    /** Wait for the browser to leave `starting`. Throws if it ends instead, or doesn't start in time. */
+    /** Wait for the browser to leave `starting` (and `queued`, for a session created with `profile_wait`: raise `timeoutS` to cover the wait). Throws if it ends instead, or doesn't start in time. */
     async waitUntilReady(sessionId, options = {}) {
         const timeoutS = options.timeoutS ?? 90;
         const deadline = Date.now() + timeoutS * 1000;
@@ -75,10 +89,10 @@ class Sessions {
             const session = await this.get(sessionId);
             if (session.status === "stopped" || session.status === "error")
                 throw new SteerpaneError(`Session ${sessionId} ended before it was ready: ${session.error_message ?? session.status}`);
-            if (session.status !== "starting")
+            if (session.status !== "starting" && session.status !== "queued")
                 return session;
             if (Date.now() >= deadline)
-                throw new SteerpaneError(`Session ${sessionId} was still starting after ${timeoutS} s`);
+                throw new SteerpaneError(`Session ${sessionId} was still ${session.status} after ${timeoutS} s`);
             await sleep((options.pollS ?? 0.5) * 1000);
         }
     }
@@ -90,6 +104,26 @@ class Sessions {
     handback(sessionId, input = {}) {
         return this.c.request("POST", `/v1/sessions/${seg(sessionId)}/handback`, { json: clean(input) });
     }
+    /** Name what the agent may not click or submit without approval. `rules` replaces the current ones; `[]` removes the guard. A blocked action fails with the
+     * `action_guard_blocked` error code until `unlockAction` is called. The service ships no rules of its own. */
+    setActionGuard(sessionId, rules) { return this.c.request("PUT", `/v1/sessions/${seg(sessionId)}/action-guard`, { json: { rules } }); }
+    getActionGuard(sessionId) { return this.c.request("GET", `/v1/sessions/${seg(sessionId)}/action-guard`); }
+    async removeActionGuard(sessionId) { await this.c.request("DELETE", `/v1/sessions/${seg(sessionId)}/action-guard`); }
+    /** Approve ONE blocked gesture (the next matching click, Enter-submit or form submit, optionally only for `ruleId`) within `ttlS` seconds (1 to 120, default 30). Needs the `takeover` scope.
+     * The result's `late_targets` counts frames where a page script may have registered a listener ahead of the guard; if you need certainty, decline to rely on the guard when it is above 0.
+     * An action that spends the unlock returns `unlock_spent: true`, and an error it ends with carries `details.unlock_spent: true` (read it from `APIError.details`/`ToolError.details`): the act may have happened, so never click again, whatever the error.
+     * A session whose guard can't be installed refuses guarded actions with `action_guard_unavailable`. */
+    unlockAction(sessionId, options = {}) {
+        return this.c.request("POST", `/v1/sessions/${seg(sessionId)}/action-guard/unlock`, { json: clean({ rule_id: options.ruleId, ttl_s: options.ttlS }) });
+    }
+    /** Run the CAPTCHA solver on the session's page. One call waits about 45 s: while `status` is `in_progress`, call again (the worker keeps running, it never restarts).
+     * `onFailure` is `wait_for_human` (default), `request_help` or `return`. Needs a CAPTCHA model on the organization. */
+    solveCaptcha(sessionId, options = {}) {
+        return this.c.request("POST", `/v1/sessions/${seg(sessionId)}/captcha/solve`, {
+            json: clean({ on_failure: options.onFailure, max_reloads: options.maxReloads, model: options.model, captcha_image_selector: options.captchaImageSelector, captcha_input_selector: options.captchaInputSelector }),
+            timeoutMs: Math.max(this.c.timeoutMs, 90_000),
+        });
+    }
     /** Ask a person for help. The agent goes on hold, and `agent.human_help_requested` fires. */
     requestHelp(sessionId, input) {
         return this.c.request("POST", `/v1/sessions/${seg(sessionId)}/help-requests`, { json: { message: "", ...input } });
@@ -113,6 +147,7 @@ class Profiles {
     }
     list(params = {}) { return this.c.request("GET", "/v1/profiles", { params }); }
     get(profileId) { return this.c.request("GET", `/v1/profiles/${seg(profileId)}`); }
+    /** `fields` include `end_user_id` to give the profile to one of your end users. */
     create(name, fields = {}) { return this.c.request("POST", "/v1/profiles", { json: { name, ...clean(fields) } }); }
     update(profileId, fields) { return this.c.request("PATCH", `/v1/profiles/${seg(profileId)}`, { json: fields }); }
     async delete(profileId) { await this.c.request("DELETE", `/v1/profiles/${seg(profileId)}`); }
@@ -122,6 +157,38 @@ class Profiles {
     lock(profileId) { return this.c.request("GET", `/v1/profiles/${seg(profileId)}/lock`); }
     importCookies(profileId, cookies) { return this.c.request("POST", `/v1/profiles/${seg(profileId)}/cookies/import`, { json: { cookies } }); }
 }
+/** Your own customers. Profiles and sessions can belong to one; a session only uses profiles of its own end user. */
+class EndUsers {
+    c;
+    constructor(c) {
+        this.c = c;
+    }
+    /** Idempotent on `external_id`: calling it again returns the existing end user unchanged. */
+    create(externalId, fields = {}) {
+        return this.c.request("POST", "/v1/end-users", { json: clean({ external_id: externalId, ...fields }) });
+    }
+    list(params = {}) { return this.c.request("GET", "/v1/end-users", { params }); }
+    get(endUserId) { return this.c.request("GET", `/v1/end-users/${seg(endUserId)}`); }
+    update(endUserId, fields) {
+        return this.c.request("PATCH", `/v1/end-users/${seg(endUserId)}`, { json: clean(fields) });
+    }
+    /** 409 while it owns profiles or live sessions; `cascade: true` deletes its profiles too (never while a session is live). */
+    async delete(endUserId, options = {}) {
+        await this.c.request("DELETE", `/v1/end-users/${seg(endUserId)}`, { params: options.cascade ? { cascade: "true" } : {} });
+    }
+    /** A single-use code (valid a few minutes) to hand to this end user so they can pair their own computer. Answers 404 while devices are off for the service. */
+    createDevicePairingCode(endUserId) { return this.c.request("POST", `/v1/end-users/${seg(endUserId)}/device-pairing-codes`); }
+}
+/** Computers that run sessions: yours, shared ones, and your end users'. Answers 404 while devices are off for the service. */
+class Devices {
+    c;
+    constructor(c) {
+        this.c = c;
+    }
+    /** `scope` is `user`, `org` or `end_user`; `end_user_id` narrows to one end user's devices. Capped at 200, no cursor. */
+    list(params = {}) { return this.c.request("GET", "/v1/devices", { params }); }
+    get(deviceId) { return this.c.request("GET", `/v1/devices/${seg(deviceId)}`); }
+}
 /** Hosted agent runs. These use your organization's own model key. */
 class Runs {
     c;
@@ -301,16 +368,39 @@ class Mcp {
         }
         return payload;
     }
+    /** Wait for an email or SMS verification code (the MCP tool `wait_for_code`). With `sessionId` the code is typed into the page and never reaches you
+     * (`status: "entered"`); with `returnCode: true` you get it back (`status: "received"`). The server answers in rounds of about 45 s with `status: "waiting"`:
+     * this keeps calling, with the `started_at` it was given, until the code arrives or `timeoutS` runs out (`status: "timeout"`), so the result is always final.
+     * Needs the `vault:use` scope and a code source set up on the organization. */
+    async waitForCode(options = {}) {
+        const args = {
+            session_id: options.sessionId, profile_id: options.profileId, credential_id: options.credentialId, site: options.site, sender: options.sender, subject: options.subject,
+            timeout_s: options.timeoutS, max_age_s: options.maxAgeS, selector: options.selector, frame: options.frame, submit: options.submit, return_code: options.returnCode, code_id: options.codeId,
+        };
+        const timeoutS = options.timeoutS ?? 120;
+        for (let round = 0;; round++) {
+            const result = await this.call("wait_for_code", args, { timeoutS: 90 });
+            if (result.status !== "waiting")
+                return result;
+            if (round > timeoutS)
+                throw new SteerpaneError("wait_for_code kept answering 'waiting' past its own timeout");
+            args["started_at"] = result["started_at"];
+        }
+    }
 }
 /** Client for the Steerpane API. */
 export class Steerpane {
     baseUrl;
     timeoutMs;
     maxRetries;
+    /** Sent as X-Steerpane-Agent: the name the dashboard shows for this program. */
+    agentName;
     fetchImpl;
     sessions = new Sessions(this);
     actions = new Actions(this);
     profiles = new Profiles(this);
+    endUsers = new EndUsers(this);
+    devices = new Devices(this);
     runs = new Runs(this);
     files = new Files(this);
     embeds = new Embeds(this);
@@ -339,6 +429,7 @@ export class Steerpane {
         this.timeoutMs = options.timeoutMs ?? 60_000;
         this.maxRetries = options.maxRetries ?? 2;
         this.fetchImpl = options.fetch ?? fetch;
+        this.agentName = (options.agentName ?? process.env["STEERPANE_AGENT_NAME"] ?? "").trim().slice(0, 80) || undefined;
     }
     /** One HTTP call with your token and the retry rules. Doesn't throw on an error status. */
     async rawRequest(method, path, options = {}) {
@@ -347,25 +438,29 @@ export class Steerpane {
             if (v !== undefined && v !== null)
                 query.set(k, String(v));
         const url = this.baseUrl + path + (query.size ? `?${query}` : "");
-        const headers = { Authorization: `Bearer ${this.token}`, "User-Agent": `steerpane-sdk-node/${VERSION}`, ...options.headers };
+        const headers = {
+            Authorization: `Bearer ${this.token}`, "User-Agent": `steerpane-sdk-node/${VERSION}`,
+            ...(this.agentName ? { "X-Steerpane-Agent": this.agentName } : {}), ...options.headers,
+        };
         if (options.json !== undefined)
             headers["Content-Type"] = "application/json";
         const body = options.body ?? (options.json !== undefined ? JSON.stringify(options.json) : undefined);
         const keyed = "Idempotency-Key" in headers;
+        const noRetry = path.split("?")[0].replace(/\/+$/, "").endsWith("/secret-fill"); // typing a secret twice can't be undone: never retried, whatever the error
         const idempotent = method === "GET" || method === "HEAD" || method === "DELETE" || keyed;
         for (let attempt = 0;; attempt++) {
             let delay;
             try {
                 const res = await this.fetchImpl(url, { method, headers, body, signal: AbortSignal.timeout(options.timeoutMs ?? this.timeoutMs) });
                 // A stored 429 replays under an Idempotency-Key, so a keyed POST isn't retried on it. A rate-limited request never ran.
-                const rateLimited = res.status === 429 && !keyed && (await isRateLimited(res));
-                if (!((idempotent && RETRY_STATUSES.has(res.status)) || rateLimited) || attempt >= this.maxRetries)
+                const rateLimited = !noRetry && res.status === 429 && !keyed && (await isRateLimited(res));
+                if (!((!noRetry && idempotent && RETRY_STATUSES.has(res.status)) || rateLimited) || attempt >= this.maxRetries)
                     return res;
                 delay = retryAfterOf(res) ?? 0.5 * 2 ** attempt;
             }
             catch (e) {
                 const timedOut = e instanceof Error && e.name === "TimeoutError";
-                if (!idempotent || timedOut || attempt >= this.maxRetries)
+                if (noRetry || !idempotent || timedOut || attempt >= this.maxRetries)
                     throw e;
                 delay = 0.5 * 2 ** attempt;
             }