@composio/client 0.1.0-alpha.9 → 2.0.0-rc.10

package/README.md

@@ -1,373 +1,157 @@
-# Composio TypeScript API Library
+# composio-client
 
-[![NPM version](https://img.shields.io/npm/v/@composio/client.svg)](https://npmjs.org/package/@composio/client) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/@composio/client)
+Composio API client for TypeScript, generated from the [v3.1 OpenAPI spec](https://staging-backend.composio.dev/api/v3.1/openapi.json) with [hey-api](https://heyapi.dev).
 
-This library provides convenient access to the Composio REST API from server-side TypeScript or JavaScript.
-
-The REST API documentation can be found on [docs.composio.com](https://docs.composio.com). The full API of this library can be found in [api.md](api.md).
-
-It is generated with [Stainless](https://www.stainless.com/).
-
-## Installation
-
-```sh
-npm install @composio/client
-```
+This repo is the successor to the Stainless-generated [`@composio/client`](https://www.npmjs.com/package/@composio/client) (Stainless is sunsetting). Current scope: the full `/api/v3.1` surface — all 104 released operations — in **both** languages: TypeScript at the package root, and Python in [`python/`](./python/README.md) (PyPI takeover pending). Migration is tracked on the wayfinder map [UXE-152](https://linear.app/composio/issue/UXE-152).
 
 ## Usage
 
-The full API of this library can be found in [api.md](api.md).
+The package root is the Stainless-compatible drop-in surface: `new Composio({ apiKey })`, the Stainless type names, and throwing `APIPromise` semantics (shipped via UXE-163/UXE-164).
 
-<!-- prettier-ignore -->
-```js
-import Composio from '@composio/client';
-
-const client = new Composio({
-  apiKey: process.env['COMPOSIO_API_KEY'], // This is the default and can be omitted
-  environment: 'staging', // or 'production' | 'local'; defaults to 'production'
-});
-
-async function main() {
-  const response = await client.tools.execute('action');
+```ts
+import Composio from '@composio/client'
 
-  console.log(response.log_id);
-}
+const composio = new Composio({ apiKey: process.env.COMPOSIO_API_KEY })
 
-main();
+const session = await composio.toolRouter.session.create({ user_id: 'user_123' })
+console.log(session.session_id, session.mcp.url)
 ```
 
-### Request & Response types
+### Pagination
 
-This library includes TypeScript definitions for all request params and response fields. You may import and use them like so:
+Use the `@composio/client/pagination` subpath to traverse list operations that return the standard
+`items` and `next_cursor` fields:
 
-<!-- prettier-ignore -->
 ```ts
-import Composio from '@composio/client';
+import { paginate } from '@composio/client/pagination'
 
-const client = new Composio({
-  apiKey: process.env['COMPOSIO_API_KEY'], // This is the default and can be omitted
-  environment: 'staging', // or 'production' | 'local'; defaults to 'production'
-});
+const toolkits = paginate(({ cursor }) =>
+  composio.toolkits.list({ cursor, limit: 100 }),
+)
 
-async function main() {
-  const response: Composio.ToolExecuteResponse = await client.tools.execute('action');
+for await (const toolkit of toolkits) {
+  console.log(toolkit.slug)
 }
-
-main();
 ```
 
-Documentation for each method, request param, and response field are available in docstrings and will appear on hover in most modern editors.
-
-## Handling errors
+Item iteration is lazy. Each traversal starts from the first page, and breaking early stops fetching
+more pages. Use `iterPages()` when page metadata matters, or `toArray()` to collect every item; avoid
+`toArray()` when the full result may not fit comfortably in memory.
 
-When the library is unable to connect to the API,
-or if the API returns a non-success status code (i.e., 4xx or 5xx response),
-a subclass of `APIError` will be thrown:
-
-<!-- prettier-ignore -->
 ```ts
-async function main() {
-  const response = await client.tools.execute('action').catch(async (err) => {
-    if (err instanceof Composio.APIError) {
-      console.log(err.status); // 400
-      console.log(err.name); // BadRequestError
-      console.log(err.headers); // {server: 'nginx', ...}
-    } else {
-      throw err;
-    }
-  });
+for await (const page of toolkits.iterPages()) {
+  console.log(page.items.length)
 }
 
-main();
-```
-
-Error codes are as followed:
-
-| Status Code | Error Type                 |
-| ----------- | -------------------------- |
-| 400         | `BadRequestError`          |
-| 401         | `AuthenticationError`      |
-| 403         | `PermissionDeniedError`    |
-| 404         | `NotFoundError`            |
-| 422         | `UnprocessableEntityError` |
-| 429         | `RateLimitError`           |
-| >=500       | `InternalServerError`      |
-| N/A         | `APIConnectionError`       |
-
-### Retries
-
-Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
-Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
-429 Rate Limit, and >=500 Internal errors will all be retried by default.
-
-You can use the `maxRetries` option to configure or disable this:
-
-<!-- prettier-ignore -->
-```js
-// Configure the default for all requests:
-const client = new Composio({
-  maxRetries: 0, // default is 2
-});
-
-// Or, configure per-request:
-await client.tools.execute('action', {
-  maxRetries: 5,
-});
+const allToolkits = await toolkits.toArray()
 ```
 
-### Timeouts
+For another response shape, provide an adapter. Custom cursors must be strings or numbers so repeated
+values can be detected reliably across independently decoded pages:
 
-Requests time out after 1 minute by default. You can configure this with a `timeout` option:
-
-<!-- prettier-ignore -->
 ```ts
-// Configure the default for all requests:
-const client = new Composio({
-  timeout: 20 * 1000, // 20 seconds (default is 1 minute)
-});
-
-// Override per-request:
-await client.tools.execute('action', {
-  timeout: 5 * 1000,
-});
-```
-
-On timeout, an `APIConnectionTimeoutError` is thrown.
-
-Note that requests which time out will be [retried twice by default](#retries).
-
-## Advanced Usage
-
-### Accessing raw Response data (e.g., headers)
-
-The "raw" `Response` returned by `fetch()` can be accessed through the `.asResponse()` method on the `APIPromise` type that all methods return.
-This method returns as soon as the headers for a successful response are received and does not consume the response body, so you are free to write custom parsing or streaming logic.
-
-You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
-Unlike `.asResponse()` this method consumes the body, returning once it is parsed.
-
-<!-- prettier-ignore -->
-```ts
-const client = new Composio();
-
-const response = await client.tools.execute('action').asResponse();
-console.log(response.headers.get('X-My-Header'));
-console.log(response.statusText); // access the underlying Response object
-
-const { data: response, response: raw } = await client.tools.execute('action').withResponse();
-console.log(raw.headers.get('X-My-Header'));
-console.log(response.log_id);
+const results = paginate(
+  ({ cursor }) => loadPage(cursor),
+  {
+    items: page => page.data,
+    nextCursor: page => page.nextCursor,
+  },
+)
 ```
 
-### Logging
-
-> [!IMPORTANT]
-> All log messages are intended for debugging only. The format and content of log messages
-> may change between releases.
+A repeated cursor cycle throws `ComposioError` instead of requesting pages indefinitely. An empty
+cursor ends traversal. When a response omits `next_cursor` but numeric `current_page` and
+`total_pages` metadata shows that more pages exist, the default adapter fails instead of silently
+returning partial results; provide a custom adapter for that response shape. Requests are sequential
+and inherit the normal client retry/backoff path, but this is not proactive/shared rate-limit pacing.
 
-#### Log levels
-
-The log level can be configured in two ways:
-
-1. Via the `COMPOSIO_LOG` environment variable
-2. Using the `logLevel` client option (overrides the environment variable if set)
+Use `fromEnv` when configuration must come from a specific environment snapshot instead of the
+host process. Explicit options replace mapped values, so this is safe for tests, workers, and
+applications that load configuration themselves:
 
 ```ts
-import Composio from '@composio/client';
-
-const client = new Composio({
-  logLevel: 'debug', // Show all log messages
-});
+const composio = Composio.fromEnv(config, { environment: 'staging' })
 ```
 
-Available log levels, from most to least verbose:
-
-- `'debug'` - Show debug messages, info, warnings, and errors
-- `'info'` - Show info messages, warnings, and errors
-- `'warn'` - Show warnings and errors (default)
-- `'error'` - Show only errors
-- `'off'` - Disable all logging
-
-At the `'debug'` level, all HTTP requests and responses are logged, including headers and bodies.
-Some authentication-related headers are redacted, but sensitive data in request and response bodies
-may still be visible.
+`fromEnv` recognizes `COMPOSIO_API_KEY`, `COMPOSIO_USER_API_KEY`, `COMPOSIO_ORG_API_KEY`,
+`COMPOSIO_BASE_URL`, `COMPOSIO_ALLOW_INSECURE_HTTP`, `COMPOSIO_CUSTOM_HEADERS`, and
+`COMPOSIO_LOG_LEVEL`. Derived clients created with `withOptions()` keep using the resolved snapshot and do
+not fall back to ambient values.
 
-#### Custom logger
-
-By default, this library logs to `globalThis.console`. You can also provide a custom logger.
-Most logging libraries are supported, including [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale), and [@std/log](https://jsr.io/@std/log). If your logger doesn't work, please open an issue.
-
-When providing a custom logger, the `logLevel` option still controls which messages are emitted, messages
-below the configured level will not be sent to your logger.
+Inject a `Transport` when an application or test needs to own HTTP dispatch. The transport receives
+a complete `Request`; retries, credential-safe redirects, timeouts, and response parsing stay in the
+client:
 
 ```ts
-import Composio from '@composio/client';
-import pino from 'pino';
-
-const logger = pino();
+import Composio, { createFetchTransport } from '@composio/client'
 
-const client = new Composio({
-  logger: logger.child({ name: 'Composio' }),
-  logLevel: 'debug', // Send all messages to pino, allowing it to filter
-});
+const transport = createFetchTransport({ fetch: instrumentedFetch })
+const composio = new Composio({ apiKey, transport })
 ```
 
-### Making custom/undocumented requests
+Existing `fetch` and `fetchOptions` constructor options remain supported. They cannot be combined
+with `transport` because a request can have only one HTTP dispatcher.
 
-This library is typed for convenient access to the documented API. If you need to access undocumented
-endpoints, params, or response properties, the library can still be used.
+## Upgrade from Stainless 0.1.x to 2.0
 
-#### Undocumented endpoints
-
-To make requests to undocumented endpoints, you can use `client.get`, `client.post`, and other HTTP verbs.
-Options on the client, such as retries, will be respected when making these requests.
+By default, the 2.0 client refuses to send credentials over plain HTTP unless the hostname is
+loopback. For a trusted development backend such as Docker's host gateway, opt in to the exact
+configured origin:
 
 ```ts
-await client.post('/some/path', {
-  body: { some_prop: 'foo' },
-  query: { some_query_arg: 'bar' },
-});
+const composio = new Composio({
+  apiKey,
+  baseURL: 'http://host.docker.internal:9900',
+  allowInsecureHTTP: true,
+})
 ```
 
-#### Undocumented request params
-
-To make requests using undocumented parameters, you may use `// @ts-expect-error` on the undocumented
-parameter. This library doesn't validate at runtime that the request matches the type, so any extra values you
-send will be sent as-is.
-
-```ts
-client.foo.create({
-  foo: 'my_param',
-  bar: 12,
-  // @ts-expect-error baz is not yet public
-  baz: 'undocumented option',
-});
-```
-
-For requests with the `GET` verb, any extra params will be in the query, all other requests will send the
-extra param in the body.
-
-If you want to explicitly send an extra argument, you can do so with the `query`, `body`, and `headers` request
-options.
-
-#### Undocumented response properties
+The equivalent environment configuration is:
 
-To access undocumented response properties, you may access the response object with `// @ts-expect-error` on
-the response object, or cast the response object to the requisite type. Like the request params, we do not
-validate or strip extra properties from the response from the API.
-
-### Customizing the fetch client
-
-By default, this library expects a global `fetch` function is defined.
-
-If you want to use a different `fetch` function, you can either polyfill the global:
-
-```ts
-import fetch from 'my-fetch';
-
-globalThis.fetch = fetch;
-```
-
-Or pass it to the client:
-
-```ts
-import Composio from '@composio/client';
-import fetch from 'my-fetch';
-
-const client = new Composio({ fetch });
-```
-
-### Fetch options
-
-If you want to set custom `fetch` options without overriding the `fetch` function, you can provide a `fetchOptions` object when instantiating the client or making a request. (Request-specific options override client options.)
-
-```ts
-import Composio from '@composio/client';
-
-const client = new Composio({
-  fetchOptions: {
-    // `RequestInit` options
-  },
-});
+```sh
+COMPOSIO_BASE_URL=http://host.docker.internal:9900 \
+COMPOSIO_ALLOW_INSECURE_HTTP=1
 ```
 
-#### Configuring proxies
+The opt-in records the resolved scheme, hostname, and port. Mutating `baseURL` cannot broaden it,
+and `withOptions({ baseURL: ... })` requires `allowInsecureHTTP: true` again when the origin
+changes. Redirects to another origin remain credential-free.
 
-To modify proxy behavior, you can provide custom `fetchOptions` that add runtime-specific proxy
-options to requests:
+## Development
 
-<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/node.svg" align="top" width="18" height="21"> **Node** <sup>[[docs](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md#example---proxyagent-with-fetch)]</sup>
+Toolchain is pinned via [mise](https://mise.jdx.dev) (`mise install`): Node 24, pnpm 11, Python 3.13, uv. ESM-only, TypeScript 7 (native compiler for typechecking, `typescript@6` retained for tooling until 7.1 restores the compiler API).
 
-```ts
-import Composio from '@composio/client';
-import * as undici from 'undici';
-
-const proxyAgent = new undici.ProxyAgent('http://localhost:8888');
-const client = new Composio({
-  fetchOptions: {
-    dispatcher: proxyAgent,
-  },
-});
+```sh
+pnpm install
+pnpm generate       # hey-api + compat codegen: spec/openapi.json → src/generated + src/compat/resources (do not edit)
+pnpm lint           # eslint over src, test, codegen, parity, and demo
+pnpm typecheck      # tsgo (TS native), including type tests and demo
+pnpm typecheck:tsc  # same programs under tsc — both compilers must pass
+pnpm codegen:check  # verify committed src/compat/resources matches the generator
+pnpm test           # unit tests (MSW mocks) + codegen tests
+pnpm build          # tsdown → dist/ (runs publint + arethetypeswrong)
+pnpm test:pack      # pack the real tarball, typecheck + import every drop-in subpath
+pnpm benchmark:baseline # capture the dist/ a benchmark run compares against
+pnpm benchmark      # score SDK overhead against that baseline and against Stainless
+pnpm test:contract  # live API tests; requires COMPOSIO_API_KEY (copy .env.example to .env)
+pnpm refresh-spec   # re-fetch spec/openapi.json from the live backend
 ```
 
-<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/bun.svg" align="top" width="18" height="21"> **Bun** <sup>[[docs](https://bun.sh/guides/http/proxy)]</sup>
-
-```ts
-import Composio from '@composio/client';
+`src/generated/` and `src/compat/resources/` are regenerated output — never edit them by hand; CI fails if they drift from `spec/openapi.json`.
 
-const client = new Composio({
-  fetchOptions: {
-    proxy: 'http://localhost:8888',
-  },
-});
-```
+### Python lane
 
-<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/deno.svg" align="top" width="18" height="21"> **Deno** <sup>[[docs](https://docs.deno.com/api/deno/~/Deno.createHttpClient)]</sup>
+The Python client lives in the [`python/`](./python/README.md) workspace (uv-managed):
 
-```ts
-import Composio from 'npm:@composio/client';
-
-const httpClient = Deno.createHttpClient({ proxy: { url: 'http://localhost:8888' } });
-const client = new Composio({
-  fetchOptions: {
-    client: httpClient,
-  },
-});
+```sh
+pnpm generate:python   # from the repo root: spec snapshot → python/src/composio_client/_generated
+cd python
+uv sync
+uv run ruff check
+uv run mypy src scripts
+uv run pytest
 ```
 
-## Frequently Asked Questions
-
-## Semantic versioning
-
-This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
-
-1. Changes that only affect static types, without breaking runtime behavior.
-2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
-3. Changes that we do not expect to impact the vast majority of users in practice.
-
-We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
-
-We are keen for your feedback; please open an [issue](https://www.github.com/ComposioHQ/composio-base-ts/issues) with questions, bugs, or suggestions.
-
-## Requirements
-
-TypeScript >= 4.9 is supported.
-
-The following runtimes are supported:
-
-- Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
-- Node.js 18 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
-- Deno v1.28.0 or higher.
-- Bun 1.0 or later.
-- Cloudflare Workers.
-- Vercel Edge Runtime.
-- Jest 28 or greater with the `"node"` environment (`"jsdom"` is not supported at this time).
-- Nitro v2.6 or greater.
-
-Note that React Native is not supported at this time.
-
-If you are interested in other runtime environments, please open or upvote an issue on GitHub.
-
-## Contributing
-
-See [the contributing documentation](./CONTRIBUTING.md).
+Client-overhead measurements use a deterministic in-memory transport and are documented in
+[`docs/benchmarks/client-overhead.md`](./docs/benchmarks/client-overhead.md). They do not measure API
+latency.

package/dist/api-key-revocation-CMby8GRJ.mjs

@@ -0,0 +1,25 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/api-key-revocation.ts
+const OP_CREATE = generatedOperation("apiKeyRevocation.create");
+/**
+* Spec-surface `client.apiKeyRevocation` resource: the 1-method public
+* leaked-key revocation surface of the v3.1 spec
+* (`POST /api_key_revocation` — POST-on-collection stays `create`), never
+* published by Stainless — wayfinder ticket 32.
+*/
+var ApiKeyRevocation = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	create(body, options) {
+		return this.#client.post("/api/v3.1/api_key_revocation", withOperation(OP_CREATE, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { ApiKeyRevocation as t };

package/dist/auth-Cogku2no.mjs

@@ -0,0 +1,17 @@
+import { t as Session } from "./session-DN52ZBZa.mjs";
+
+//#region src/compat/resources/auth/auth.ts
+/**
+* Spec-surface `client.auth` resource: a method-less container for the
+* `session` sub-resource — wayfinder ticket 32.
+*/
+var Auth = class {
+	session;
+	constructor(client) {
+		this.session = new Session(client);
+	}
+};
+Auth.Session = Session;
+
+//#endregion
+export { Auth as t };

package/dist/auth-configs-Dgujwvul.mjs

@@ -0,0 +1,55 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/auth-configs.ts
+const OP_CREATE = generatedOperation("authConfigs.create");
+const OP_RETRIEVE = generatedOperation("authConfigs.retrieve");
+const OP_UPDATE = generatedOperation("authConfigs.update");
+const OP_LIST = generatedOperation("authConfigs.list");
+const OP_DELETE = generatedOperation("authConfigs.delete");
+const OP_UPDATE_STATUS = generatedOperation("authConfigs.updateStatus");
+/**
+* Stainless-shaped `client.authConfigs` resource: the exact 6-method surface of
+* `@composio/client` (create/retrieve/update/list/delete/updateStatus),
+* dispatched through the handwritten kernel.
+*/
+var AuthConfigs = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	create(body, options) {
+		return this.#client.post("/api/v3.1/auth_configs", withOperation(OP_CREATE, {
+			body,
+			...options
+		}));
+	}
+	retrieve(nanoid, options) {
+		return this.#client.get(path`/api/v3.1/auth_configs/${nanoid}`, withOperation(OP_RETRIEVE, { ...options }));
+	}
+	update(nanoid, body, options) {
+		return this.#client.patch(path`/api/v3.1/auth_configs/${nanoid}`, withOperation(OP_UPDATE, {
+			body,
+			...options
+		}));
+	}
+	list(query = {}, options) {
+		return this.#client.get("/api/v3.1/auth_configs", withOperation(OP_LIST, {
+			query,
+			...options
+		}));
+	}
+	delete(nanoid, query = {}, options) {
+		return this.#client.delete(path`/api/v3.1/auth_configs/${nanoid}`, withOperation(OP_DELETE, {
+			query,
+			...options
+		}));
+	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
+	updateStatus(status, params, options) {
+		const { nanoid } = params;
+		return this.#client.patch(path`/api/v3.1/auth_configs/${nanoid}/${status}`, withOperation(OP_UPDATE_STATUS, { ...options }));
+	}
+};
+
+//#endregion
+export { AuthConfigs as t };

package/dist/clanker-Ddf6to-5.mjs

@@ -0,0 +1,24 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/org/clanker.ts
+const OP_CREATE_CLAIM = generatedOperation("org.clanker.createClaim");
+/**
+* Spec-surface `client.org.clanker` resource: the 1-method claim surface of
+* the v3.1 spec (`POST /org/clanker/create_claim`), never published by
+* Stainless — wayfinder ticket 31.
+*/
+var Clanker = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	createClaim(body, options) {
+		return this.#client.post("/api/v3.1/org/clanker/create_claim", withOperation(OP_CREATE_CLAIM, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Clanker as t };

package/dist/cli-Bx3dRctN.mjs

@@ -0,0 +1,45 @@
+import { c as withOperation, m as mergeHeaders, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+import { t as Realtime } from "./realtime-AhDHHK8s.mjs";
+
+//#region src/compat/resources/cli/cli.ts
+const OP_CREATE_CODACT_FAILURE = generatedOperation("cli.createCodactFailure");
+const OP_CREATE_SESSION = generatedOperation("cli.createSession");
+const OP_GET_SESSION = generatedOperation("cli.getSession");
+/**
+* Stainless-shaped `client.cli` resource: the 2-method published CLI
+* authentication surface of `@composio/client` (createSession/getSession)
+* plus the spec-surface `createCodactFailure` (`POST /cli/codact_failures`,
+* never published by Stainless — wayfinder ticket 29).
+*/
+var Cli = class {
+	realtime;
+	#client;
+	constructor(client) {
+		this.#client = client;
+		this.realtime = new Realtime(client);
+	}
+	createCodactFailure(params, options) {
+		const { "x-user-api-key": xUserApiKey, ...body } = params;
+		return this.#client.post("/api/v3.1/cli/codact_failures", withOperation(OP_CREATE_CODACT_FAILURE, {
+			body,
+			...options,
+			headers: mergeHeaders([{ ...xUserApiKey != null ? { "x-user-api-key": xUserApiKey } : void 0 }, options?.headers])
+		}));
+	}
+	createSession(body = {}, options) {
+		return this.#client.post("/api/v3.1/cli/create-session", withOperation(OP_CREATE_SESSION, {
+			body,
+			...options
+		}));
+	}
+	getSession(query, options) {
+		return this.#client.get("/api/v3.1/cli/get-session", withOperation(OP_GET_SESSION, {
+			query,
+			...options
+		}));
+	}
+};
+Cli.Realtime = Realtime;
+
+//#endregion
+export { Cli as t };

package/dist/config-BLBbhLe1.mjs

@@ -0,0 +1,10 @@
+//#region src/compat/resources/project/config.ts
+/**
+* Stainless-shaped `client.project.config` resource: an empty resource class
+* (Stainless declares it with no methods), shipped for import/`instanceof`/
+* namespace parity.
+*/
+var Config = class {};
+
+//#endregion
+export { Config as t };