@hunt-labs/bytekit-sdk 0.2.2 → 0.4.0

package/dist/client.js

@@ -6,6 +6,8 @@ import { MonitorsResource } from './resources/monitors.js';
 import { SitemapResource } from './resources/sitemap.js';
 import { SearchResource } from './resources/search.js';
 import { AccountResource } from './resources/account.js';
+import { UsageResource } from './resources/usage.js';
+import { WebhooksResource } from './resources/webhooks.js';
 const DEFAULT_BASE_URL = 'https://api.bytekit.com';
 /**
  * Default client-side request timeout (2 minutes).
@@ -122,12 +124,59 @@ function composeSignals(caller, timeout) {
     }
     return { signal: controller.signal, cleanup };
 }
-/** Map a `fetch` rejection onto the connection-error taxonomy. Never leaks the API key. */
+/**
+ * Read a successful response body as text INSIDE the transport's abort-guarded region
+ * (#2546), short-circuiting a 204 to `undefined`. The `JSON.parse` step is deliberately
+ * kept OUT of the guard — see {@link parseJsonBody} — so a malformed body still surfaces
+ * its own SyntaxError rather than being remapped to a `ByteKitConnectionError`.
+ *
+ * Shared as the `readBody` continuation of `request()` and (wrapped) `requestWithResponse()`
+ * so empty-body/204 handling can never diverge between the two (#2547).
+ */
+async function readSuccessText(response) {
+    return response.status === 204 ? undefined : await response.text();
+}
+/**
+ * Parse an already-read success body (see {@link readSuccessText}) into its JSON value.
+ *
+ * A 204 or otherwise-empty body resolves to `undefined` — this is how a successful
+ * `revoke()` (DELETE → 204) resolves instead of throwing a JSON-parse error. Runs OUTSIDE
+ * the transport's abort-guarded region (#2546), so `JSON.parse` failures stay ordinary
+ * SyntaxErrors. Shared by `request()` and `requestWithResponse()` (#2547).
+ */
+function parseJsonBody(text) {
+    if (text === undefined || text.trim().length === 0) {
+        return undefined;
+    }
+    return JSON.parse(text);
+}
+/** The `name` of an error-shaped value, or `undefined` when it carries none. */
+const nameOf = (e) => typeof e === 'object' && e !== null && 'name' in e ? String(e.name) : undefined;
+/** The `cause` of an error-shaped value, or `undefined` when it carries none. */
+const causeOf = (e) => typeof e === 'object' && e !== null && 'cause' in e ? e.cause : undefined;
+/**
+ * The abort-taxonomy name of a rejection, seeing through undici's mid-body wrapper.
+ *
+ * When a request is aborted while its BODY is streaming, undici does not reject with the abort
+ * reason itself — it rejects with `TypeError: terminated` carrying the reason on `.cause` (#2546).
+ * A name-only check would read that as a plain connection failure. Nothing that reached this
+ * function before #2546 carried a `.cause`, so every previously-asserted classification is
+ * unchanged; a `.cause` whose own name is not abort-shaped still falls through to `'connection'`.
+ */
+function abortNameOf(err) {
+    const top = nameOf(err);
+    if (top === 'TimeoutError' || top === 'AbortError')
+        return top;
+    return nameOf(causeOf(err));
+}
+/**
+ * Map a `fetch` or body-read rejection onto the connection-error taxonomy. Never leaks the API key.
+ */
 function toConnectionError(err, method, url, timeoutSignal) {
     // undici rejects an aborted fetch with the signal's own reason, so the thrown value's
-    // `name` is the primary discriminator (`TimeoutError` / `AbortError`).
-    const rawName = typeof err === 'object' && err !== null && 'name' in err ? err.name : undefined;
-    const name = typeof rawName === 'string' ? rawName : '';
+    // `name` is the primary discriminator (`TimeoutError` / `AbortError`) — read through
+    // undici's mid-body `TypeError: terminated` wrapper when there is one.
+    const name = abortNameOf(err) ?? '';
     let code;
     if (name === 'TimeoutError') {
         code = 'timeout';
@@ -162,12 +211,18 @@ export class ByteKit {
     sitemap;
     search;
     account;
+    usage;
+    webhooks;
     constructor(options) {
         if (!options?.apiKey) {
             throw new TypeError('ByteKit: `apiKey` is required — got an empty value. Pass options.apiKey (e.g. from process.env.BYTEKIT_API_KEY).');
         }
         this.apiKey = options.apiKey;
-        this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+        // Normalize once: strip any trailing slash so `baseUrl + path` (path always
+        // starts with `/`) never yields a double-slash URL (#2481). Only the trailing
+        // slash is removed, so a path-carrying baseUrl (e.g. a reverse-proxy prefix
+        // `…/bytekit`) is preserved (E2).
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
         this.defaultTimeoutMs = validateTimeout(options.timeoutMs, '"timeoutMs"') ?? DEFAULT_TIMEOUT_MS;
         this.scrape = new ScrapeResource(this);
         this.screenshots = new ScreenshotsResource(this);
@@ -177,6 +232,8 @@ export class ByteKit {
         this.sitemap = new SitemapResource(this);
         this.search = new SearchResource(this);
         this.account = new AccountResource(this);
+        this.usage = new UsageResource(this);
+        this.webhooks = new WebhooksResource(this);
     }
     /**
      * Resolve the abort budget for one request from the caller's options and the
@@ -215,13 +272,30 @@ export class ByteKit {
         };
     }
     /**
-     * Make an authenticated JSON request to the ByteKit API.
+     * Perform the authenticated round-trip and return whatever the caller's `readBody`
+     * continuation makes of the successful response, having already thrown for the two
+     * non-body failure modes:
      *
-     * Throws `ByteKitError` on 4xx/5xx responses, and `ByteKitConnectionError`
-     * when no HTTP response was produced at all (DNS/socket/TLS failure, client-side
-     * timeout, or caller abort).
+     * - `ByteKitConnectionError` when no HTTP response was produced at all
+     *   (DNS/socket/TLS failure, client-side timeout, or caller abort) — including one
+     *   that fires while the body is streaming.
+     * - `ByteKitError` on any 4xx/5xx, carrying the API's `code`/`message`.
+     *
+     * The body is read through a continuation each caller supplies — JSON text for
+     * `request()`, raw bytes for `requestRaw()`. This is the single place that owns auth,
+     * the abort budget, and the error taxonomy; the two public transports differ only in
+     * how they read a successful body.
+     *
+     * The abort budget spans headers **and** body (#2546). Returning the `Response` used to
+     * end the guarded region at the headers boundary, leaving `response.text()` /
+     * `response.arrayBuffer()` — and the `!response.ok` branch's `response.json()` —
+     * unbounded: a server that sent headers and then stalled its body hung the caller
+     * forever. `readBody` must therefore ONLY consume the stream; `JSON.parse` and
+     * `TextDecoder` run in the callers, outside the guard, so a malformed body still
+     * surfaces its own parse error rather than being remapped to a connection error.
+     * `cleanup()` still runs exactly once per call, now after the body completes.
      */
-    async request(method, path, body, options) {
+    async send(method, path, body, options, readBody) {
         const url = `${this.baseUrl}${path}`;
         const { signal, timeoutSignal, cleanup } = this.resolveSignal(options);
         const init = {
@@ -238,55 +312,134 @@ export class ByteKit {
         if (signal !== undefined) {
             init.signal = signal;
         }
-        let response;
         try {
-            response = await fetch(url, init);
-        }
-        catch (err) {
-            throw toConnectionError(err, method, url, timeoutSignal);
-        }
-        finally {
-            // Runs on success, on HTTP error, and on abort alike — no dangling timer,
-            // no listener left behind on the caller's (long-lived) signal.
-            cleanup();
-        }
-        if (!response.ok) {
-            let code = 'internal_error';
-            let message = response.statusText;
+            let response;
             try {
-                const json = (await response.json());
-                code = json.error?.code ?? code;
-                message = json.error?.message ?? message;
+                response = await fetch(url, init);
             }
-            catch {
-                // leave defaults
+            catch (err) {
+                throw toConnectionError(err, method, url, timeoutSignal);
             }
-            throw new ByteKitError(response.status, code, message);
+            if (!response.ok) {
+                let code = 'internal_error';
+                let message = response.statusText;
+                try {
+                    const json = (await response.json());
+                    // Canonical unified envelope. Tested first, so it always wins: the flat
+                    // form below is strictly a fallback and can never override an envelope
+                    // (issue #2541). The explicit `!== null` guard matters — `typeof null`
+                    // is `'object'`.
+                    if (typeof json.error === 'object' && json.error !== null) {
+                        code = json.error.code ?? code;
+                        message = json.error.message ?? message;
+                    }
+                    else if (typeof json.error === 'string' && json.error.length > 0) {
+                        // Flat vendor-masked shape, e.g. /v1/search 502
+                        // {"error":"search_provider_error"} (docs/api/openapi.yaml §/v1/search
+                        // 502). The string IS the error code. `message` falls back to it only
+                        // when the response carried no statusText, so the thrown error is
+                        // never message-empty.
+                        code = json.error;
+                        message = message || json.error;
+                    }
+                }
+                catch {
+                    // leave defaults — including when the error body itself stalls and the
+                    // budget aborts the read (#2546), so a stuck 500 still surfaces its status.
+                }
+                throw new ByteKitError(response.status, code, message);
+            }
+            try {
+                return await readBody(response);
+            }
+            catch (err) {
+                // A body read that never completes is aborted by the same budget; the runtime
+                // then errors the stream (#2546). Map it into the same taxonomy the headers
+                // phase uses, so a mid-body timeout/abort is not a bare `TypeError: terminated`.
+                throw toConnectionError(err, method, url, timeoutSignal);
+            }
+        }
+        finally {
+            // Runs on success (body read included), on HTTP error, and on abort alike — no
+            // dangling timer, no listener left behind on the caller's (long-lived) signal.
+            cleanup();
         }
+    }
+    /**
+     * Make an authenticated JSON request to the ByteKit API.
+     *
+     * Throws `ByteKitError` on 4xx/5xx responses, and `ByteKitConnectionError`
+     * when no HTTP response was produced at all (DNS/socket/TLS failure, client-side
+     * timeout, or caller abort).
+     */
+    async request(method, path, body, options) {
         // A 204 No Content has an empty body, and a genuinely empty body can arrive on
         // other success codes too (defensive). Calling response.json() on an empty body
         // rejects with a SyntaxError — which is how a successful revoke() (DELETE → 204)
         // used to throw instead of resolving. Read the body once as text and short-circuit
         // to `undefined` when it is empty; a JSON-bearing response (scrape.create,
         // apiKeys.create/get, …) still parses and returns unchanged.
-        if (response.status === 204) {
-            return undefined;
-        }
-        const text = await response.text();
-        if (text.trim().length === 0) {
-            return undefined;
-        }
-        return JSON.parse(text);
+        //
+        // Only the read runs inside the transport's guarded region (#2546) — `JSON.parse`
+        // stays out here (in `parseJsonBody`), so a malformed body still throws its own
+        // SyntaxError rather than being remapped to a ByteKitConnectionError.
+        const text = await this.send(method, path, body, options, readSuccessText);
+        return parseJsonBody(text);
+    }
+    /**
+     * Make an authenticated request whose response body IS the content, not a JSON
+     * envelope — the `/v1/fetch` contract, where metadata rides in `X-Fetch-*`
+     * response headers.
+     *
+     * Returns BOTH a UTF-8-decoded string AND the raw, byte-for-byte body, plus the
+     * response `Headers` and status, WITHOUT ever calling `JSON.parse`. This is
+     * deliberately a separate transport from `request()`: the generic JSON parse
+     * there is shared by every other resource and must not change (#2466).
+     *
+     * `/v1/fetch` supports true binary passthrough (images, PDFs, etc.) as a
+     * first-class mode, and UTF-8 decoding a non-UTF-8 byte stream is lossy — any
+     * invalid byte sequence gets silently replaced with U+FFFD. Reading the body
+     * once via `arrayBuffer()` lets both forms be derived from the same bytes: `bytes`
+     * is always byte-exact, `body` is a best-effort string for callers who know the
+     * content is text.
+     */
+    async requestRaw(method, path, body, options) {
+        // As in `request()`: the continuation only drains the stream, so the abort budget
+        // covers the read (#2546); the UTF-8 decode happens outside the guarded region.
+        const { bytes, headers, status } = await this.send(method, path, body, options, async (response) => ({
+            bytes: new Uint8Array(await response.arrayBuffer()),
+            headers: response.headers,
+            status: response.status,
+        }));
+        const text = new TextDecoder('utf-8').decode(bytes);
+        return { body: text, bytes, headers, status };
+    }
+    /**
+     * Make an authenticated JSON request and return the parsed body TOGETHER WITH the
+     * response headers and status (#2547).
+     *
+     * Identical to {@link ByteKit.request} in every observable respect — same method, path,
+     * body, `RequestOptions` precedence, error taxonomy, and empty-body handling (both drain
+     * the body through {@link readSuccessText} and parse it through {@link parseJsonBody}). It
+     * differs only in what it returns, so nothing about an existing call changes by switching
+     * to it.
+     *
+     * Use it to read the documented `X-*` metadata the API emits alongside a JSON envelope —
+     * `X-Raw-Bytes`, `X-Billable-Bytes`, `X-Billing-Multiplier`, the `X-Screenshot-*` family
+     * — for any endpoint. `sitemap.getWithResponse`, `screenshots.createWithResponse` and
+     * `screenshots.getWithResponse` are typed shorthands over this for the endpoints whose
+     * headers are documented in the API reference.
+     */
+    async requestWithResponse(method, path, body, options) {
+        // Same continuation shape as request()/requestRaw() (#2546): the readBody continuation
+        // ONLY drains the stream (and captures headers/status) inside the abort-guarded region,
+        // so a mid-body stall counts against the budget. `JSON.parse` runs afterwards, outside
+        // the guard, in `parseJsonBody` — a malformed body stays a SyntaxError.
+        const { text, headers, status } = await this.send(method, path, body, options, async (response) => ({
+            text: await readSuccessText(response),
+            headers: response.headers,
+            status: response.status,
+        }));
+        return { data: parseJsonBody(text), headers, status };
     }
 }
-// ---------------------------------------------------------------------------
-// Deprecated RapidCrawl* aliases (#2421).
-//
-// The public surface renamed from RapidCrawl to ByteKit. These aliases point at
-// the SAME implementations (identity preserved: `RapidCrawl === ByteKit`), so an
-// existing consumer's `instanceof` / error-shape contract keeps holding for one
-// minor version. Exported here — not only from index.ts — so the SDK's own
-// resource files can keep importing the legacy type name from './client.js'
-// without churn. Re-exported (with @deprecated JSDoc) from index.ts.
-// ---------------------------------------------------------------------------
-export { ByteKit as RapidCrawl, ByteKitError as RapidCrawlError, ByteKitConnectionError as RapidCrawlConnectionError, };

package/dist/generated/api.d.ts

@@ -2021,9 +2021,13 @@ export interface components {
                 [key: string]: string;
             };
             /** @description Screenshot monitor options (device, viewport, format, etc.). */
-            options?: Record<string, never>;
+            options?: {
+                [key: string]: unknown;
+            };
             /** @description Scrape monitor options (formats, country, headers, etc.). Only for type=scrape. */
-            scrape_options?: Record<string, never>;
+            scrape_options?: {
+                [key: string]: unknown;
+            };
             metadata?: components["schemas"]["Metadata"];
         };
         MonitorUpdateRequest: {
@@ -2046,8 +2050,12 @@ export interface components {
             };
             /** @enum {string} */
             status?: "active" | "paused";
-            options?: Record<string, never>;
-            scrape_options?: Record<string, never>;
+            options?: {
+                [key: string]: unknown;
+            };
+            scrape_options?: {
+                [key: string]: unknown;
+            };
             metadata?: components["schemas"]["Metadata"];
         };
         MonitorResponse: {
@@ -2136,7 +2144,9 @@ export interface components {
             /** @default null */
             process: {
                 action?: string;
-                options?: Record<string, never>;
+                options?: {
+                    [key: string]: unknown;
+                };
             } | null;
             /**
              * Format: uri
@@ -3343,7 +3353,7 @@ export interface operations {
                         };
                         delay_ms?: number;
                         timeout_ms?: number;
-                        metadata?: Record<string, never>;
+                        metadata?: components["schemas"]["Metadata"];
                         /**
                          * @description Per-item override for LLM markdown cleaning. When
                          *     `true` and `markdown` is in `formats`, the converted
@@ -3737,7 +3747,7 @@ export interface operations {
                      */
                     webhook_url: string;
                     webhook_secret?: string;
-                    metadata?: Record<string, never>;
+                    metadata?: components["schemas"]["Metadata"];
                 };
             };
         };

package/dist/index.d.ts

@@ -1,12 +1,14 @@
 export { ByteKit, ByteKitError, ByteKitConnectionError } from './client.js';
-export type { ByteKitOptions, RequestOptions, ConnectionErrorCode } from './client.js';
-/** @deprecated Renamed to ByteKit / ByteKitError / ByteKitConnectionError — kept as aliases for one minor version. */
-export { RapidCrawl, RapidCrawlError, RapidCrawlConnectionError } from './client.js';
-/** @deprecated Renamed to ByteKitOptions — kept as an alias for one minor version. */
-export type { RapidCrawlOptions } from './client.js';
+export type { ByteKitOptions, RequestOptions, ApiResponse, ConnectionErrorCode } from './client.js';
 export { V01_METHODS } from './allowlist.js';
 export type { V01Method } from './allowlist.js';
-export type { ScrapeId, ScreenshotId, RecordingId, BulkId, MonitorId, SitemapId, ApiKeyId, SearchType, SearchDateRange, SearchOpts, SearchResult, SearchResultImage, SearchResponse, } from './types.js';
-export type { ScrapeCreateResponse, ScrapeGetResponse, ScrapeBulkCreateRequest, ScrapeBulkCreateResponse, ScrapeBulkGetResponse, } from './resources/scrape.js';
+export type { ScrapeId, ScreenshotId, BulkId, MonitorId, SitemapId, ApiKeyId, WebhookDeliveryId, SearchType, SearchDateRange, SearchOpts, SearchResult, SearchResultImage, SearchResponse, } from './types.js';
+export type { ScrapeCookie, ScrapeCreateResponse, ScrapeGetResponse, ScrapeBulkCreateRequest, ScrapeBulkCreateResponse, ScrapeBulkGetResponse, } from './resources/scrape.js';
 export type { ScreenshotCreateRequest, ScreenshotCreateResponse, ScreenshotGetResponse, } from './resources/screenshots.js';
+export type { FetchOpts, FetchGetOpts, FetchResult, FetchCacheStatus, FetchBulkCreateRequest, FetchBulkCreateResponse, FetchBulkGetResponse, } from './resources/fetch.js';
+export type { MonitorCreateRequest, MonitorCreateResponse, ListMonitorsParams, MonitorStatus, ListMonitorsResponse, MonitorResponse, MonitorUpdateRequest, UpdateMonitorResponse, ListMonitorCapturesResponse, } from './resources/monitors.js';
+export type { SitemapCreateRequest, SitemapCreateResponse, SitemapGetResponse, } from './resources/sitemap.js';
+export type { BulkCreateRequest, BulkCreateResponse, BulkGetResponse, BulkCancelResponse, ListBulkScreenshotsResponse, } from './resources/bulk.js';
 export type { GetAccountResponse, ListApiKeysResponse, CreateApiKeyRequest, CreateApiKeyResponse, GetApiKeyResponse, UpdateApiKeyRequest, UpdateApiKeyResponse, RevealApiKeyResponse, } from './resources/account.js';
+export type { GetUsageResponse, GetUsageDailyParams, GetUsageDailyResponse, GetUsageByEndpointParams, GetUsageByEndpointResponse, } from './resources/usage.js';
+export type { ListWebhookDeliveriesParams, ListWebhookDeliveriesResponse, RetryWebhookDeliveryResponse, } from './resources/webhooks.js';

package/dist/index.js

@@ -1,4 +1,2 @@
 export { ByteKit, ByteKitError, ByteKitConnectionError } from './client.js';
-/** @deprecated Renamed to ByteKit / ByteKitError / ByteKitConnectionError — kept as aliases for one minor version. */
-export { RapidCrawl, RapidCrawlError, RapidCrawlConnectionError } from './client.js';
 export { V01_METHODS } from './allowlist.js';

package/dist/resources/account.d.ts

@@ -1,4 +1,4 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit, RequestOptions } from '../client.js';
 import type { operations } from '../generated/api.js';
 import type { ApiKeyId } from '../types.js';
 /**
@@ -36,26 +36,31 @@ export type UpdateApiKeyResponse = operations['updateApiKey']['responses'][200][
 export declare class AccountResource {
     private readonly client;
     readonly apiKeys: ApiKeysResource;
-    constructor(client: RapidCrawl);
-    /** GET /v1/account — get the authenticated account */
-    get(): Promise<GetAccountResponse>;
+    constructor(client: ByteKit);
+    /**
+     * GET /v1/account — get the authenticated account.
+     *
+     * `requestOptions` carries the CLIENT-side abort budget (`requestTimeoutMs`) and an
+     * optional caller `signal`; both override the constructor's `timeoutMs` default.
+     */
+    get(requestOptions?: RequestOptions): Promise<GetAccountResponse>;
 }
 declare class ApiKeysResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /**
      * POST /v1/account/api-keys — create a new API key.
      *
      * `opts` is optional: the spec declares the request body itself as optional,
      * so `create()` with no arguments is valid and sends no body.
      */
-    create(opts?: CreateApiKeyRequest): Promise<CreateApiKeyResponse>;
+    create(opts?: CreateApiKeyRequest, requestOptions?: RequestOptions): Promise<CreateApiKeyResponse>;
     /** GET /v1/account/api-keys — list all API keys for the account */
-    list(): Promise<ListApiKeysResponse>;
+    list(requestOptions?: RequestOptions): Promise<ListApiKeysResponse>;
     /** GET /v1/account/api-keys/{id} — get an API key by ID */
-    get(id: ApiKeyId): Promise<GetApiKeyResponse>;
+    get(id: ApiKeyId, requestOptions?: RequestOptions): Promise<GetApiKeyResponse>;
     /** PATCH /v1/account/api-keys/{id} — update an API key */
-    update(id: ApiKeyId, opts: UpdateApiKeyRequest): Promise<UpdateApiKeyResponse>;
+    update(id: ApiKeyId, opts: UpdateApiKeyRequest, requestOptions?: RequestOptions): Promise<UpdateApiKeyResponse>;
     /**
      * DELETE /v1/account/api-keys/{id} — revoke an API key (idempotent).
      *
@@ -67,8 +72,8 @@ declare class ApiKeysResource {
      * to `undefined` before it would parse the body as JSON (#2450), so this
      * method resolves cleanly on the gateway's empty 204 body.
      */
-    revoke(id: ApiKeyId): Promise<void>;
+    revoke(id: ApiKeyId, requestOptions?: RequestOptions): Promise<void>;
     /** POST /v1/account/api-keys/{id}/reveal — reveal the plaintext API key value */
-    reveal(id: ApiKeyId): Promise<RevealApiKeyResponse>;
+    reveal(id: ApiKeyId, requestOptions?: RequestOptions): Promise<RevealApiKeyResponse>;
 }
 export {};

package/dist/resources/account.js

@@ -5,9 +5,14 @@ export class AccountResource {
         this.client = client;
         this.apiKeys = new ApiKeysResource(client);
     }
-    /** GET /v1/account — get the authenticated account */
-    get() {
-        return this.client.request('GET', '/v1/account');
+    /**
+     * GET /v1/account — get the authenticated account.
+     *
+     * `requestOptions` carries the CLIENT-side abort budget (`requestTimeoutMs`) and an
+     * optional caller `signal`; both override the constructor's `timeoutMs` default.
+     */
+    get(requestOptions) {
+        return this.client.request('GET', '/v1/account', undefined, requestOptions);
     }
 }
 class ApiKeysResource {
@@ -21,20 +26,20 @@ class ApiKeysResource {
      * `opts` is optional: the spec declares the request body itself as optional,
      * so `create()` with no arguments is valid and sends no body.
      */
-    create(opts) {
-        return this.client.request('POST', '/v1/account/api-keys', opts);
+    create(opts, requestOptions) {
+        return this.client.request('POST', '/v1/account/api-keys', opts, requestOptions);
     }
     /** GET /v1/account/api-keys — list all API keys for the account */
-    list() {
-        return this.client.request('GET', '/v1/account/api-keys');
+    list(requestOptions) {
+        return this.client.request('GET', '/v1/account/api-keys', undefined, requestOptions);
     }
     /** GET /v1/account/api-keys/{id} — get an API key by ID */
-    get(id) {
-        return this.client.request('GET', `/v1/account/api-keys/${id}`);
+    get(id, requestOptions) {
+        return this.client.request('GET', `/v1/account/api-keys/${id}`, undefined, requestOptions);
     }
     /** PATCH /v1/account/api-keys/{id} — update an API key */
-    update(id, opts) {
-        return this.client.request('PATCH', `/v1/account/api-keys/${id}`, opts);
+    update(id, opts, requestOptions) {
+        return this.client.request('PATCH', `/v1/account/api-keys/${id}`, opts, requestOptions);
     }
     /**
      * DELETE /v1/account/api-keys/{id} — revoke an API key (idempotent).
@@ -47,11 +52,11 @@ class ApiKeysResource {
      * to `undefined` before it would parse the body as JSON (#2450), so this
      * method resolves cleanly on the gateway's empty 204 body.
      */
-    revoke(id) {
-        return this.client.request('DELETE', `/v1/account/api-keys/${id}`);
+    revoke(id, requestOptions) {
+        return this.client.request('DELETE', `/v1/account/api-keys/${id}`, undefined, requestOptions);
     }
     /** POST /v1/account/api-keys/{id}/reveal — reveal the plaintext API key value */
-    reveal(id) {
-        return this.client.request('POST', `/v1/account/api-keys/${id}/reveal`);
+    reveal(id, requestOptions) {
+        return this.client.request('POST', `/v1/account/api-keys/${id}/reveal`, undefined, requestOptions);
     }
 }

package/dist/resources/bulk.d.ts

@@ -1,20 +1,36 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit, RequestOptions } from '../client.js';
+import type { operations } from '../generated/api.js';
 import type { BulkId } from '../types.js';
+/** Body of POST /v1/bulk. */
+export type BulkCreateRequest = operations['createBulk']['requestBody']['content']['application/json'];
+/** 202 payload of POST /v1/bulk — bulk jobs are always async. */
+export type BulkCreateResponse = operations['createBulk']['responses'][202]['content']['application/json'];
+/** 200 payload of GET /v1/bulk/{id}. */
+export type BulkGetResponse = operations['getBulk']['responses'][200]['content']['application/json'];
+/** 200 payload of DELETE /v1/bulk/{id} — cancels an in-flight job. */
+export type BulkCancelResponse = operations['deleteBulk']['responses'][200]['content']['application/json'];
+/** 200 payload of GET /v1/bulk/{id}/screenshots. */
+export type ListBulkScreenshotsResponse = operations['listBulkScreenshots']['responses'][200]['content']['application/json'];
 export declare class BulkResource {
     private readonly client;
     readonly screenshots: BulkScreenshotsResource;
-    constructor(client: RapidCrawl);
-    /** POST /v1/bulk — create a bulk screenshots job */
-    create(opts: Record<string, unknown>): Promise<unknown>;
+    constructor(client: ByteKit);
+    /**
+     * POST /v1/bulk — create a bulk screenshots job.
+     *
+     * `requestOptions` carries the CLIENT-side abort budget (`requestTimeoutMs`) and an
+     * optional caller `signal`; both override the constructor's `timeoutMs` default.
+     */
+    create(opts: BulkCreateRequest, requestOptions?: RequestOptions): Promise<BulkCreateResponse>;
     /** GET /v1/bulk/{id} — get a bulk job status */
-    get(id: BulkId): Promise<unknown>;
+    get(id: BulkId, requestOptions?: RequestOptions): Promise<BulkGetResponse>;
     /** DELETE /v1/bulk/{id} — cancel an in-flight bulk job */
-    cancel(id: BulkId): Promise<unknown>;
+    cancel(id: BulkId, requestOptions?: RequestOptions): Promise<BulkCancelResponse>;
 }
 declare class BulkScreenshotsResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** GET /v1/bulk/{id}/screenshots — list screenshots in a bulk job */
-    list(id: BulkId): Promise<unknown>;
+    list(id: BulkId, requestOptions?: RequestOptions): Promise<ListBulkScreenshotsResponse>;
 }
 export {};

package/dist/resources/bulk.js

@@ -5,17 +5,22 @@ export class BulkResource {
         this.client = client;
         this.screenshots = new BulkScreenshotsResource(client);
     }
-    /** POST /v1/bulk — create a bulk screenshots job */
-    create(opts) {
-        return this.client.request('POST', '/v1/bulk', opts);
+    /**
+     * POST /v1/bulk — create a bulk screenshots job.
+     *
+     * `requestOptions` carries the CLIENT-side abort budget (`requestTimeoutMs`) and an
+     * optional caller `signal`; both override the constructor's `timeoutMs` default.
+     */
+    create(opts, requestOptions) {
+        return this.client.request('POST', '/v1/bulk', opts, requestOptions);
     }
     /** GET /v1/bulk/{id} — get a bulk job status */
-    get(id) {
-        return this.client.request('GET', `/v1/bulk/${id}`);
+    get(id, requestOptions) {
+        return this.client.request('GET', `/v1/bulk/${id}`, undefined, requestOptions);
     }
     /** DELETE /v1/bulk/{id} — cancel an in-flight bulk job */
-    cancel(id) {
-        return this.client.request('DELETE', `/v1/bulk/${id}`);
+    cancel(id, requestOptions) {
+        return this.client.request('DELETE', `/v1/bulk/${id}`, undefined, requestOptions);
     }
 }
 class BulkScreenshotsResource {
@@ -24,7 +29,7 @@ class BulkScreenshotsResource {
         this.client = client;
     }
     /** GET /v1/bulk/{id}/screenshots — list screenshots in a bulk job */
-    list(id) {
-        return this.client.request('GET', `/v1/bulk/${id}/screenshots`);
+    list(id, requestOptions) {
+        return this.client.request('GET', `/v1/bulk/${id}/screenshots`, undefined, requestOptions);
     }
 }