@solarisdk/browserbase-compat 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.3.0
+- **Every Browserbase resource and method now exists.** `secrets`, `webhooks`, `navigationPolicies`, `certificates`, `functions.secrets`, `sessions.recording.downloads` and the rest were `undefined` on the client, so calling them failed with "not a function". They now throw `SolariCompatUnsupported` naming the method (for example `secrets.create`), as do `.asResponse()` / `.withResponse()` and the raw `client.get` / `post` / `request` calls. The ones that map to Solari (sessions, contexts, live view, recording) work as before.
+- **`keepAlive` is reported correctly.** `sessions.retrieve` and `sessions.list` said `keepAlive: false` for every session. A session created with `keepAlive: true` now reports `true`. The gateway does not return it, so the package stores it in one reserved user metadata key, `solari_compat_keep_alive`, and hides that key from the `userMetadata` you get back. That key is reserved, and `keepAlive: true` with 50 metadata keys of your own now throws. A session created some other way, or by an older version, still reports `false`.
+- **Behaviour change: the session timeout is `api_timeout`, as in Browserbase's SDK.** `api_timeout` is sent to Solari as the session length. A lone `sessions.create({ timeout: 300 })` used to set the session length; Browserbase's SDK treats it as the request timeout (milliseconds), and so does this package now. `timeout` next to other params (`create({ timeout: 300, keepAlive: true })`) is still read as the session length, and giving it together with a different `api_timeout` throws. Change `timeout` to `api_timeout`.
+- **Options are no longer dropped.** The client takes `defaultHeaders` and `defaultQuery`. Every method takes Browserbase's second argument: `timeout`, `maxRetries`, `headers`, `query`, `signal` (an aborted request throws `APIUserAbortError`), and on create calls `body` and `idempotencyKey`. `httpAgent`, per-call `method` / `path` / `stream` and a header that sets `Authorization` throw.
+- **Unknown keys throw instead of vanishing.** An unknown option on the client, an unknown key in the `sessions.create` params, in `context`, `viewport`, a proxy entry, its `geolocation` or `proxySettings`, in the query of `list` / `update` / `debug`, and `browserSettings.riskPolicyId` all throw `SolariCompatUnsupported`. **If a call now throws for such a key, it never had any effect: remove it or fix the spelling.**
+- **`projectId` now warns once** (it was ignored silently). Solari keys belong to an organisation, so it selects nothing; `strict: true` throws instead.
+- **`sessions.list` returns every session.** It stopped after the gateway's first page of 100; it now follows the pages to the end.
+- **Wrong values removed.** `endedAt` was the time of your call for every finished session; it is now the expiry time for a timed-out session and absent for a released one (the gateway does not say when). `contexts.retrieve` of a missing context throws `NotFoundError`. `Context` gains `projectId` and `updatedAt`, and `ContextCreateResponse` gains `uploadUrl` (empty; see COMPAT.md).
+- The replay and saved-context downloads go through the `fetch` you gave the client, and never carry your key or default headers.
+
+## 0.2.1
+- **Security: the base URL check accepts only the Solari API hosts.** It used to accept any `*.getsolari.com` host, including sandbox preview hosts (`<label>-<port>.preview.getsolari.com`) that serve customer code, so a `baseURL` / `SOLARI_BASE_URL` pointed there would send your `slr_` key to code running in a sandbox. Now only the Solari API hosts and loopback are accepted.
+
 ## 0.2.0
 - `timeout`, `keepAlive` and `userMetadata` are sent to Solari (they were warned about and ignored in 0.1.0). `userMetadata` comes back on `create`, `retrieve` and `list`, and `sessions.list({ q })` filters on it.
 - **A base URL that does not point at Solari is now refused.** `baseURL` and `SOLARI_BASE_URL` must be `https` on `getsolari.com` (or a subdomain) or a loopback address; anything else throws `BrowserbaseError` ("Refusing to send a Solari API key to …"). In 0.1.0 such a URL was used as given, which could send your `slr_` key to another host.

package/COMPAT.md

@@ -22,20 +22,22 @@ Keep it private: the session id inside it is the credential.
 | | |
 |---|---|
 | Key | `apiKey` option, else `SOLARI_API_KEY`, else `BROWSERBASE_API_KEY`. **A key that does not start with `slr_` is never used or sent** (it is probably a Browserbase secret): it is skipped with a warning that does not print it, and if no `slr_` key remains the constructor throws. |
-| Endpoint | `baseURL` option or `SOLARI_BASE_URL`; default `https://api.getsolari.com`. Must be `https` on `getsolari.com` (or a subdomain) or loopback, otherwise the constructor throws `BrowserbaseError` ("Refusing to send a Solari API key to …"): the key is never sent to another host. |
-| `projectId` | Accepted and ignored: Solari keys belong to an organisation, there are no projects. |
+| Endpoint | `baseURL` option or `SOLARI_BASE_URL`; default `https://api.getsolari.com`. Must be `https` on a Solari API host or loopback (preview and other `*.getsolari.com` hosts are refused: they serve customer code), otherwise the constructor throws `BrowserbaseError` ("Refusing to send a Solari API key to …"): the key is never sent to another host. |
+| `projectId` | Accepted, ignored, and **warned about once per client** (`strict: true` throws instead): Solari keys belong to an organisation, there are no projects. |
+| Client options | `apiKey`, `baseURL`, `maxRetries` (default 2) and `timeout` (ms, default 60000) apply to every request. `defaultHeaders` and `defaultQuery` are added to every Solari request (never to presigned storage downloads); a `null` header value removes a header, and `Authorization` cannot be set. `fetch` replaces the global fetch (use it for a proxy or your own dispatcher). `maxRetries` and `timeout` read back. **`httpAgent` and any option this client does not have throw `SolariCompatUnsupported`** (they are never dropped). |
+| Per-call options | Every method takes Browserbase's second argument: `timeout` (ms), `maxRetries`, `headers`, `query` and `signal` apply to every request the call makes (an aborted `signal` throws `APIUserAbortError`). `body` (extra JSON fields) and `idempotencyKey` apply to the create calls only (`sessions.create`, `contexts.create`); on any other call they throw. `method`, `path`, `stream`, `httpAgent`, `defaultBaseURL` and `__binary*` throw. `Authorization` cannot be set in `headers`. |
 
 ## Works
 | Browserbase | Here |
 |---|---|
 | `sessions.create` | `POST /sessions`; returns `connectUrl` (CDP), `id`, `status: "RUNNING"`, `expiresAt`, `region`, `keepAlive`, `contextId`. A create is retried safely (idempotency key). |
-| `sessions.retrieve`, `sessions.list({ status })` | Solari `active/released/expired/unknown` map to `RUNNING/COMPLETED/TIMED_OUT/ERROR`. `proxyBytes` is `0`, `startedAt` is the create time. |
+| `sessions.retrieve`, `sessions.list({ status, q })` | Solari `active/released/expired/unknown` map to `RUNNING/COMPLETED/TIMED_OUT/ERROR`. `list` returns **every** matching session: it follows the gateway's pages to the end (it stops with a `BrowserbaseError` after 1000 pages, or if the gateway repeats a page cursor). See [Reported as unknown](#reported-as-unknown-or-empty) for the fields Solari does not have. |
 | `sessions.update(id, { status: "REQUEST_RELEASE" })` | Releases the session. |
 | `proxies: true`, `proxies: [{ type: "browserbase", geolocation }]` | A managed proxy; `geolocation.country/state/city` map across (a proxy needs the stealth browser, so `stealth` is switched on for you). `{ type: "none" }` means no proxy. |
 | `browserSettings.verified`, `advancedStealth` | Solari's stealth browser. |
 | `browserSettings.solveCaptchas: true` | Solari captcha solving (stealth browser, plan-gated). **Off unless you pass `true`**: Browserbase turns it on by default. |
 | `browserSettings.recordSession: true` | Session recording. **Off unless you pass `true`**: Browserbase records by default. Read it back with `sessions.recording.retrieve(id)` (rrweb events). |
-| `browserSettings.allowedDomains` | Egress allowlist (enterprise plan, stealth browser); a plan error comes back as an `APIError` with `code: "FeatureRequiresPlan"`. |
+| `browserSettings.allowedDomains` | Egress allowlist (Team or Enterprise plan, stealth browser); a plan error comes back as an `APIError` with `code: "FeatureRequiresPlan"`. |
 | `browserSettings.context: { id, persist }`, `contexts.create/retrieve/delete` | A Context is a Solari **profile**. See [Contexts](#contexts). |
 | `sessions.debug(id, { expiresIn })` | A view-only live-view link (`debuggerUrl` and `debuggerFullscreenUrl` are the same link; `pages` is empty; `wsUrl` is the CDP URL). |
 
@@ -43,9 +45,25 @@ Keep it private: the session id inside it is the credential.
 - **Recording is a DOM-event log, not video.** `sessions.recording.retrieve(id)` returns rrweb events once the replay has been uploaded (a few seconds after release; until then it throws `APIError` with `code: "ReplayPending"`). There is no HLS playlist and no MP4.
 - **Contexts store cookies and localStorage only** (Playwright `storageState`), not IndexedDB, service workers or autofill data.
 - **No choice of operating system or viewport at create time (known gap).** A `viewport` setting is accepted with a one-line warning and has no effect; set the viewport from your automation client (`page.setViewportSize`). `strict: true` makes it throw instead.
-- **`timeout`, `keepAlive` and `userMetadata` work as in Browserbase.** `timeout` (seconds, at least 60) ends the session at that time, capped at your plan's maximum session length. `keepAlive: true` keeps the session after your client disconnects, until its `timeout` (default 1 hour), the plan maximum, or `sessions.update(..., REQUEST_RELEASE)`. `userMetadata` (up to 50 keys, 8 KB) is stored, returned by `retrieve`/`list`, and filterable with `sessions.list({ q: "user_metadata['key']:'value'" })` (conditions joined with `AND`).
+- **`api_timeout`, `keepAlive` and `userMetadata` work as in Browserbase.** `api_timeout` (seconds, at least 60; Browserbase's name for the session timeout) ends the session at that time, capped at your plan's maximum session length. `keepAlive: true` keeps the session after your client disconnects, until its `api_timeout` (default 1 hour), the plan maximum, or `sessions.update(..., REQUEST_RELEASE)`. `userMetadata` (up to 50 keys, 8 KB) is stored, returned by `retrieve`/`list`, and filterable with `sessions.list({ q: "user_metadata['key']:'value'" })` (conditions joined with `AND`).
+- **The session timeout is `api_timeout`; `timeout` is the request timeout.** As in Browserbase's SDK, a lone `sessions.create({ timeout: 5000 })` is the *options* argument (a request timeout in ms), not a session setting. The older spelling `timeout` (seconds) is still read as the session timeout when it sits next to other params (`create({ timeout: 300, keepAlive: true })`); passing it together with a different `api_timeout` throws. Use `api_timeout`.
+- **`keepAlive` is remembered in the session's user metadata.** The Solari gateway does not return `keepAlive` when you retrieve or list a session. With `keepAlive: true`, `sessions.create` therefore also stores one reserved user metadata key, `solari_compat_keep_alive`, and `retrieve` / `list` read it back (and remove it from the `userMetadata` you see). Consequences: the key is reserved (using it yourself throws), `keepAlive: true` leaves room for 49 of your own metadata keys (50 throws), and **a session that was not created through this package (version 0.3.0 or later) reports `keepAlive: false` even if it was created with keep-alive**, because the gateway does not say.
 - **`viewport`, `blockAds: true`, `logSession: true`, `os`** are accepted with a one-line warning and have no effect. Pass `strict: true` to make them throw instead.
 
+## Reported as unknown or empty
+Solari has no equivalent for these fields of Browserbase's objects, so they carry a fixed value instead of a made-up one:
+
+| Field | Value |
+|---|---|
+| `Session.projectId`, `Context.projectId` | `""` (no projects) |
+| `Session.updatedAt`, `Session.startedAt` | the create time |
+| `Session.proxyBytes` | `0` |
+| `Session.region` | `us-west-2` (Solari's single region) |
+| `Session.endedAt` | the expiry time for a `TIMED_OUT` session; absent for a released one (the gateway does not say when), except in the answer to your own `sessions.update(..., REQUEST_RELEASE)`, where it is the time of that call |
+| `Context.updatedAt` | the profile's last update when the gateway reports one, else its creation time |
+| `ContextCreateResponse.publicKey`, `cipherAlgorithm`, `initializationVectorSize`, `uploadUrl` | `""` / `0` (Solari profiles are stored server-side, nothing is uploaded) |
+| `SessionCreateResponse.seleniumRemoteUrl`, `signingKey` | `""` |
+
 ## Contexts
 ```ts
 const ctx = await bb.contexts.create({ name: "shop-login" });
@@ -62,4 +80,11 @@ const page = await (await b2.newContext({ storageState: s2.storageState })).newP
 Two differences from Browserbase: a saved context's **cookies** are also present in the default browser context (`browser.contexts()[0]`), but localStorage is applied only to a browser context created *with* the state (use `newContext({ storageState })` to get both), and `persist: true` saves when you release **through the same client object** (it is remembered in memory).
 
 ## Raises `SolariCompatUnsupported`
-Extensions (`extensionId`), the Selenium endpoint (`seleniumRemoteUrl` is always empty), downloads (`sessions.downloads`) and uploads (`sessions.uploads`) APIs, video replays (`sessions.replays`), session logs (`sessions.logs`), external/bring-your-own proxies, per-domain proxy rules (`domainPattern`), custom CA certificates, `ignoreCertificateErrors: true`, custom captcha selectors, `os: "mobile" | "tablet"`, a `region` other than `us-west-2` (or `us-west`), `contexts.update`, and the separate `projects`, `extensions`, `agents`, `fetchAPI` and `search` resources.
+Every resource and method of Browserbase's Node SDK exists on the client; these throw, naming the method (for example `secrets.create`), and send nothing:
+
+- **Resources Solari has no equivalent of:** `extensions` (and `extensionId`), `projects` (`retrieve`, `list`, `usage`), `agents` and `agents.runs`, `fetchAPI`, `search`, `secrets` (`create`, `retrieve`, `update`, `list`, `delete`, `getPublicKey`), `webhooks` (`create`, `retrieve`, `update`, `list`, `delete`, `rotateSecret`), `navigationPolicies`, `certificates`, `functions.secrets` (`list`, `attach`, `detach`).
+- **Session sub-resources:** `sessions.downloads.list`, `sessions.uploads.create`, `sessions.logs.list`, `sessions.replays` (`retrieve`, `retrievePage`), `sessions.recording.downloads` (`create`, `list`). Recordings are DOM events: use `sessions.recording.retrieve`.
+- **`contexts.update`.**
+- **Raw responses and raw requests:** `.asResponse()` and `.withResponse()` on a returned promise; `client.get/post/put/patch/delete/getAPIList/request` (Browserbase API paths that Solari does not serve).
+- **Settings:** the Selenium endpoint (`seleniumRemoteUrl` is always empty), external/bring-your-own proxies, per-domain proxy rules (`domainPattern`), custom CA certificates, `ignoreCertificateErrors: true`, custom captcha selectors, `riskPolicyId`, `os: "mobile" | "tablet"`, a `region` other than `us-west-2` (or `us-west`).
+- **Any key Solari cannot map is refused, never dropped:** an unknown key in the `sessions.create` params, in `browserSettings`, in `context` (only `id`, `persist`), `viewport` (`width`, `height`), a `proxies` entry, its `geolocation` (`country`, `state`, `city`) or `proxySettings` (`caCertificates`); an unknown key in the query of `sessions.list` (`status`, `q`), `sessions.update` (`status`, `projectId`), `sessions.debug` (`expiresIn`) or `contexts.create` (`name`, `projectId`); an unknown client or per-call option.

package/README.md

@@ -19,8 +19,9 @@ await browser.close();
 await bb.sessions.update(session.id, { status: "REQUEST_RELEASE" });
 ```
 
-Sessions, contexts, live view and recording are supported; extensions, downloads/uploads APIs, video replays,
-bring-your-own proxies and Selenium raise `SolariCompatUnsupported`. See [docs.getsolari.com/browserbase](https://docs.getsolari.com/browserbase) (and `COMPAT.md` in this package) for the full list
+Sessions, contexts, live view and recording are supported. Every other Browserbase resource and method exists but throws
+`SolariCompatUnsupported` naming it (extensions, secrets, webhooks, projects, downloads/uploads APIs, video replays,
+bring-your-own proxies, Selenium, ...). See [docs.getsolari.com/browserbase](https://docs.getsolari.com/browserbase) (and `COMPAT.md` in this package) for the full list
 and every difference. Requires Node 20+. No Playwright version pin is needed: `connectUrl` is a plain CDP endpoint.
 
 Licence: MIT. See `NOTICE`.

package/dist/client.d.ts

@@ -1,3 +1,4 @@
+import type { Call, CompatPromise, RequestOptions } from "./options.js";
 import type { Context, ContextCreateResponse, Session, SessionCreateParams, SessionCreateResponse, SessionLiveURLs, SessionRetrieveResponse, SessionStatus } from "./types.js";
 export declare const DEFAULT_BASE_URL = "https://api.getsolari.com";
 export interface BrowserbaseOptions {
@@ -9,76 +10,107 @@ export interface BrowserbaseOptions {
     strict?: boolean;
     /** Called for each soft difference; default console.warn. */
     onWarning?: (message: string) => void;
+    /** Retries for a request that failed with a connection error or 502/503/504 (GET, DELETE and creates only). Default 2. */
     maxRetries?: number;
-    /** Per-request timeout in ms. */
+    /** Per-request timeout in ms. Default 60000. */
     timeout?: number;
-    /** Test hook. */
+    /** A fetch to use instead of the global one (for a proxy, a custom dispatcher, or a test). */
     fetch?: typeof fetch;
+    /** Headers sent on every request. A `null` or `undefined` value removes a header. `Authorization` cannot be set. */
+    defaultHeaders?: Record<string, string | null | undefined>;
+    /** Query parameters sent on every request. */
+    defaultQuery?: Record<string, string | undefined>;
+    /** Not supported: raises. Pass `fetch` with your own dispatcher instead. */
+    httpAgent?: unknown;
 }
-/** Whether a base URL may receive a Solari key: https on getsolari.com or a subdomain, or loopback. */
+/** Whether a base URL may receive a Solari key: https on a Solari API host, or loopback. */
 export declare function isSolariBaseUrl(raw: string): boolean;
 export declare class Browserbase {
     readonly sessions: Sessions;
     readonly contexts: Contexts;
-    readonly extensions: UnsupportedResource;
-    readonly projects: UnsupportedResource;
-    readonly agents: UnsupportedResource;
-    readonly fetchAPI: UnsupportedResource;
-    readonly search: UnsupportedResource;
+    readonly extensions: import("./unsupported.js").UnsupportedMethods<"create" | "retrieve" | "delete">;
+    readonly projects: import("./unsupported.js").UnsupportedMethods<"retrieve" | "list" | "usage">;
+    readonly agents: {
+        runs: import("./unsupported.js").UnsupportedMethods<"create" | "retrieve" | "list" | "listMessages">;
+        create: (...args: unknown[]) => never;
+        retrieve: (...args: unknown[]) => never;
+        delete: (...args: unknown[]) => never;
+        list: (...args: unknown[]) => never;
+        update: (...args: unknown[]) => never;
+    };
+    readonly fetchAPI: import("./unsupported.js").UnsupportedMethods<"create">;
+    readonly search: import("./unsupported.js").UnsupportedMethods<"web">;
+    readonly certificates: import("./unsupported.js").UnsupportedMethods<"create" | "retrieve" | "delete" | "list">;
+    readonly secrets: import("./unsupported.js").UnsupportedMethods<"create" | "retrieve" | "delete" | "list" | "update" | "getPublicKey">;
+    readonly functions: {
+        secrets: import("./unsupported.js").UnsupportedMethods<"list" | "attach" | "detach">;
+    };
+    readonly webhooks: import("./unsupported.js").UnsupportedMethods<"create" | "retrieve" | "delete" | "list" | "update" | "rotateSecret">;
+    readonly navigationPolicies: import("./unsupported.js").UnsupportedMethods<"create" | "retrieve" | "delete" | "list" | "update">;
     readonly apiKey: string;
     readonly baseURL: string;
+    /** Retries for a failed request (client default; a call can override it). */
+    readonly maxRetries: number;
+    /** Request timeout in ms (client default; a call can override it). */
+    readonly timeout: number;
     /** @internal */ readonly strict: boolean;
     /** @internal */ readonly warn: (m: string) => void;
     private readonly fetchImpl;
-    private readonly maxRetries;
-    private readonly timeoutMs;
+    private readonly defaultHeaders;
+    private readonly defaultQuery;
+    private projectIdWarned;
     /** session id -> profile to save on release (browserSettings.context.persist). In-process only. */
     /** @internal */ readonly persist: Map<string, string>;
     constructor(opts?: BrowserbaseOptions);
-    /** @internal  GET a presigned URL (no Solari auth header). */
-    fetchPublic(url: string): Promise<Response>;
+    get(..._a: unknown[]): never;
+    post(..._a: unknown[]): never;
+    put(..._a: unknown[]): never;
+    patch(..._a: unknown[]): never;
+    delete(..._a: unknown[]): never;
+    getAPIList(..._a: unknown[]): never;
+    request(..._a: unknown[]): never;
+    /** @internal  `projectId` has nothing to select on Solari: say so once per client (or refuse under `strict`). */
+    noteProjectId(where: string): void;
+    /** @internal  GET a presigned URL (no Solari auth header, no default headers). */
+    fetchPublic(url: string, call?: Call, defaultTimeoutMs?: number): Promise<Response>;
     /** @internal */
-    request(method: string, path: string, body?: unknown, opts?: {
-        idempotencyKey?: string;
-    }): Promise<Response>;
+    send(method: string, path: string, body?: unknown, call?: Call): Promise<Response>;
     /** @internal */
-    json<T>(method: string, path: string, body?: unknown, opts?: {
-        idempotencyKey?: string;
-    }): Promise<T>;
+    json<T>(method: string, path: string, body?: unknown, call?: Call): Promise<T>;
 }
-/** A resource whose every method throws SolariCompatUnsupported. */
-export type UnsupportedResource = {
-    [method: string]: (...args: unknown[]) => never;
-};
 declare class Sessions {
     private readonly c;
     readonly recording: Recording;
-    readonly replays: UnsupportedResource;
-    readonly logs: UnsupportedResource;
-    readonly downloads: UnsupportedResource;
-    readonly uploads: UnsupportedResource;
+    readonly replays: import("./unsupported.js").UnsupportedMethods<"retrieve" | "retrievePage">;
+    readonly logs: import("./unsupported.js").UnsupportedMethods<"list">;
+    readonly downloads: import("./unsupported.js").UnsupportedMethods<"list">;
+    readonly uploads: import("./unsupported.js").UnsupportedMethods<"create">;
     constructor(c: Browserbase);
-    create(params?: SessionCreateParams): Promise<SessionCreateResponse>;
-    retrieve(id: string): Promise<SessionRetrieveResponse>;
+    create(params?: SessionCreateParams, options?: RequestOptions): CompatPromise<SessionCreateResponse>;
+    create(options?: RequestOptions): CompatPromise<SessionCreateResponse>;
+    retrieve(id: string, options?: RequestOptions): CompatPromise<SessionRetrieveResponse>;
     list(query?: {
         status?: SessionStatus;
         q?: string;
-    }): Promise<Session[]>;
+    }, options?: RequestOptions): CompatPromise<Session[]>;
+    list(options?: RequestOptions): CompatPromise<Session[]>;
     /** `{ status: "REQUEST_RELEASE" }` releases the session (saving the context first when it was created with persist: true). */
     update(id: string, params: {
         status: "REQUEST_RELEASE";
         projectId?: string;
-    }): Promise<Session>;
+    }, options?: RequestOptions): CompatPromise<Session>;
     /** Live-view links. Both URLs are the same view-only share link; `pages` is empty. */
     debug(id: string, query?: {
         expiresIn?: number;
-    }): Promise<SessionLiveURLs>;
+    }, options?: RequestOptions): CompatPromise<SessionLiveURLs>;
+    debug(id: string, options?: RequestOptions): CompatPromise<SessionLiveURLs>;
 }
 declare class Recording {
     private readonly c;
+    readonly downloads: import("./unsupported.js").UnsupportedMethods<"create" | "list">;
     constructor(c: Browserbase);
     /** The session's DOM recording as an array of rrweb events. Needs `browserSettings: { recordSession: true }`; available a few seconds after release. */
-    retrieve(id: string): Promise<unknown[]>;
+    retrieve(id: string, options?: RequestOptions): CompatPromise<unknown[]>;
 }
 declare class Contexts {
     private readonly c;
@@ -87,9 +119,10 @@ declare class Contexts {
     create(params?: {
         projectId?: string;
         name?: string;
-    }): Promise<ContextCreateResponse>;
-    retrieve(id: string): Promise<Context>;
-    update(): never;
-    delete(id: string): Promise<void>;
+    }, options?: RequestOptions): CompatPromise<ContextCreateResponse>;
+    create(options?: RequestOptions): CompatPromise<ContextCreateResponse>;
+    retrieve(id: string, options?: RequestOptions): CompatPromise<Context>;
+    update(..._a: unknown[]): never;
+    delete(id: string, options?: RequestOptions): CompatPromise<void>;
 }
 export {};