@composio/client 2.0.0-rc.1 → 2.0.0-rc.11

package/README.md

@@ -17,6 +17,106 @@ const session = await composio.toolRouter.session.create({ user_id: 'user_123' }
 console.log(session.session_id, session.mcp.url)
 ```
 
+### Pagination
+
+Use the `@composio/client/pagination` subpath to traverse list operations that return the standard
+`items` and `next_cursor` fields:
+
+```ts
+import { paginate } from '@composio/client/pagination'
+
+const toolkits = paginate(({ cursor }) =>
+  composio.toolkits.list({ cursor, limit: 100 }),
+)
+
+for await (const toolkit of toolkits) {
+  console.log(toolkit.slug)
+}
+```
+
+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.
+
+```ts
+for await (const page of toolkits.iterPages()) {
+  console.log(page.items.length)
+}
+
+const allToolkits = await toolkits.toArray()
+```
+
+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:
+
+```ts
+const results = paginate(
+  ({ cursor }) => loadPage(cursor),
+  {
+    items: page => page.data,
+    nextCursor: page => page.nextCursor,
+  },
+)
+```
+
+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.
+
+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
+const composio = Composio.fromEnv(config, { environment: 'staging' })
+```
+
+`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.
+
+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, { createFetchTransport } from '@composio/client'
+
+const transport = createFetchTransport({ fetch: instrumentedFetch })
+const composio = new Composio({ apiKey, transport })
+```
+
+Existing `fetch` and `fetchOptions` constructor options remain supported. They cannot be combined
+with `transport` because a request can have only one HTTP dispatcher.
+
+## Upgrade from Stainless 0.1.x to 2.0
+
+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
+const composio = new Composio({
+  apiKey,
+  baseURL: 'http://host.docker.internal:9900',
+  allowInsecureHTTP: true,
+})
+```
+
+The equivalent environment configuration is:
+
+```sh
+COMPOSIO_BASE_URL=http://host.docker.internal:9900 \
+COMPOSIO_ALLOW_INSECURE_HTTP=1
+```
+
+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.
+
 ## Development
 
 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).
@@ -24,13 +124,15 @@ Toolchain is pinned via [mise](https://mise.jdx.dev) (`mise install`): Node 24,
 ```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, packages/codegen
-pnpm typecheck      # tsgo (TS native) over src+test, incl. type tests
+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
 ```
@@ -49,3 +151,7 @@ uv run ruff check
 uv run mypy src scripts
 uv run pytest
 ```
+
+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-BZL5FAx7.mjs → api-key-revocation-Dh-KSokR.mjs}

@@ -1,6 +1,7 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
+import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.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
@@ -13,10 +14,10 @@ var ApiKeyRevocation = class {
 		this.#client = client;
 	}
 	create(body, options) {
-		return this.#client.post(path`/api/v3.1/api_key_revocation`, {
+		return this.#client.post("/api/v3.1/api_key_revocation", withOperation(OP_CREATE, {
 			body,
 			...options
-		});
+		}));
 	}
 };
 

package/dist/{auth-CEq4JqWm.mjs → auth-Drov-jN8.mjs}

@@ -1,4 +1,4 @@
-import { t as Session } from "./session-DNm4GFO-.mjs";
+import { t as Session } from "./session-DfISYrbs.mjs";
 
 //#region src/compat/resources/auth/auth.ts
 /**

package/dist/{auth-configs-CyksMqNB.mjs → auth-configs-yM05-r6r.mjs}

@@ -1,6 +1,12 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.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),
@@ -12,35 +18,36 @@ var AuthConfigs = class {
 		this.#client = client;
 	}
 	create(body, options) {
-		return this.#client.post(path`/api/v3.1/auth_configs`, {
+		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}`, { ...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}`, {
+		return this.#client.patch(path`/api/v3.1/auth_configs/${nanoid}`, withOperation(OP_UPDATE, {
 			body,
 			...options
-		});
+		}));
 	}
 	list(query = {}, options) {
-		return this.#client.get(path`/api/v3.1/auth_configs`, {
+		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}`, {
+		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}`, { ...options });
+		return this.#client.patch(path`/api/v3.1/auth_configs/${nanoid}/${status}`, withOperation(OP_UPDATE_STATUS, { ...options }));
 	}
 };
 

package/dist/{clanker-4wByThQJ.mjs → clanker-BYmc69WC.mjs}

@@ -1,6 +1,7 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
+import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.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
@@ -12,10 +13,10 @@ var Clanker = class {
 		this.#client = client;
 	}
 	createClaim(body, options) {
-		return this.#client.post(path`/api/v3.1/org/clanker/create_claim`, {
+		return this.#client.post("/api/v3.1/org/clanker/create_claim", withOperation(OP_CREATE_CLAIM, {
 			body,
 			...options
-		});
+		}));
 	}
 };
 

package/dist/cli-Ce8RT7yp.mjs

@@ -0,0 +1,45 @@
+import { c as withOperation, m as mergeHeaders, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { t as Realtime } from "./realtime-Dsk1QGAl.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/{connected-accounts-B-qN_yLT.mjs → connected-accounts-D__sOoNZ.mjs}

@@ -1,6 +1,15 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
 
 //#region src/compat/resources/connected-accounts.ts
+const OP_CREATE = generatedOperation("connectedAccounts.create");
+const OP_RETRIEVE = generatedOperation("connectedAccounts.retrieve");
+const OP_LIST = generatedOperation("connectedAccounts.list");
+const OP_DELETE = generatedOperation("connectedAccounts.delete");
+const OP_COMPLETE_AUTH = generatedOperation("connectedAccounts.completeAuth");
+const OP_PATCH = generatedOperation("connectedAccounts.patch");
+const OP_REFRESH = generatedOperation("connectedAccounts.refresh");
+const OP_REVOKE = generatedOperation("connectedAccounts.revoke");
+const OP_UPDATE_STATUS = generatedOperation("connectedAccounts.updateStatus");
 /**
 * Stainless-shaped `client.connectedAccounts` resource: the 7-method published
 * surface of `@composio/client` (create/retrieve/list/delete/patch/refresh/
@@ -14,52 +23,59 @@ var ConnectedAccounts = class {
 		this.#client = client;
 	}
 	create(body, options) {
-		return this.#client.post(path`/api/v3.1/connected_accounts`, {
+		return this.#client.post("/api/v3.1/connected_accounts", withOperation(OP_CREATE, {
 			body,
 			...options
-		});
+		}));
 	}
 	retrieve(nanoid, options) {
-		return this.#client.get(path`/api/v3.1/connected_accounts/${nanoid}`, { ...options });
+		return this.#client.get(path`/api/v3.1/connected_accounts/${nanoid}`, withOperation(OP_RETRIEVE, { ...options }));
 	}
 	list(query = {}, options) {
-		return this.#client.get(path`/api/v3.1/connected_accounts`, {
+		return this.#client.get("/api/v3.1/connected_accounts", withOperation(OP_LIST, {
 			query,
 			...options
-		});
+		}));
 	}
 	delete(nanoid, query = {}, options) {
-		return this.#client.delete(path`/api/v3.1/connected_accounts/${nanoid}`, {
+		return this.#client.delete(path`/api/v3.1/connected_accounts/${nanoid}`, withOperation(OP_DELETE, {
 			query,
 			...options
-		});
+		}));
+	}
+	completeAuth(body, options) {
+		return this.#client.post("/api/v3.1/connected_accounts/complete_auth", withOperation(OP_COMPLETE_AUTH, {
+			body,
+			...options
+		}));
 	}
 	patch(nanoid, body = {}, options) {
-		return this.#client.patch(path`/api/v3.1/connected_accounts/${nanoid}`, {
+		return this.#client.patch(path`/api/v3.1/connected_accounts/${nanoid}`, withOperation(OP_PATCH, {
 			body,
 			...options
-		});
+		}));
 	}
 	/** @deprecated Deprecated in the input OpenAPI schema. */
 	refresh(nanoid, params = {}, options) {
 		const { query_redirect_url, body_redirect_url, ...body } = params ?? {};
-		return this.#client.post(path`/api/v3.1/connected_accounts/${nanoid}/refresh`, {
+		return this.#client.post(path`/api/v3.1/connected_accounts/${nanoid}/refresh`, withOperation(OP_REFRESH, {
 			query: { redirect_url: query_redirect_url },
 			body: {
 				...body,
 				redirect_url: body_redirect_url
 			},
 			...options
-		});
+		}));
 	}
 	revoke(nanoid, options) {
-		return this.#client.post(path`/api/v3.1/connected_accounts/${nanoid}/revoke`, { ...options });
+		return this.#client.post(path`/api/v3.1/connected_accounts/${nanoid}/revoke`, withOperation(OP_REVOKE, { ...options }));
 	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
 	updateStatus(nanoID, body, options) {
-		return this.#client.patch(path`/api/v3.1/connected_accounts/${nanoID}/status`, {
+		return this.#client.patch(path`/api/v3.1/connected_accounts/${nanoID}/status`, withOperation(OP_UPDATE_STATUS, {
 			body,
 			...options
-		});
+		}));
 	}
 };
 

package/dist/{consumer-DWlaGBmh.mjs → consumer-DTh50Hih.mjs}

@@ -1,7 +1,8 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
-import { t as Project } from "./project-_s0fWHut.mjs";
+import { c as withOperation, m as mergeHeaders, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { t as Project } from "./project-D-_r3H1_.mjs";
 
 //#region src/compat/resources/org/consumer/consumer.ts
+const OP_LIST_CONNECTED_TOOLKITS = generatedOperation("org.consumer.listConnectedToolkits");
 /**
 * Spec-surface `client.org.consumer` resource: the 1-method consumer surface
 * of the v3.1 spec (listConnectedToolkits over
@@ -17,15 +18,14 @@ var Consumer = class {
 	}
 	listConnectedToolkits(params, options) {
 		const { "x-user-api-key": xUserApiKey, "x-org-id": xOrgId, ...query } = params;
-		return this.#client.get(path`/api/v3.1/org/consumer/connected_toolkits`, {
+		return this.#client.get("/api/v3.1/org/consumer/connected_toolkits", withOperation(OP_LIST_CONNECTED_TOOLKITS, {
 			query,
 			...options,
-			headers: {
+			headers: mergeHeaders([{
 				...xUserApiKey != null ? { "x-user-api-key": xUserApiKey } : void 0,
-				...xOrgId != null ? { "x-org-id": xOrgId } : void 0,
-				...options?.headers
-			}
-		});
+				...xOrgId != null ? { "x-org-id": xOrgId } : void 0
+			}, options?.headers])
+		}));
 	}
 };
 Consumer.Project = Project;

package/dist/{custom-BQWoONFY.mjs → custom-CdC-6Y_i.mjs}

@@ -1,6 +1,7 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
+import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
 
 //#region src/compat/resources/mcp/custom.ts
+const OP_CREATE = generatedOperation("mcp.custom.create");
 /**
 * Stainless-shaped `client.mcp.custom` resource: the 1-method custom MCP
 * server sub-surface of `@composio/client` (`POST /mcp/servers/custom`).
@@ -10,11 +11,12 @@ var Custom = class {
 	constructor(client) {
 		this.#client = client;
 	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
 	create(body, options) {
-		return this.#client.post(path`/api/v3.1/mcp/servers/custom`, {
+		return this.#client.post("/api/v3.1/mcp/servers/custom", withOperation(OP_CREATE, {
 			body,
 			...options
-		});
+		}));
 	}
 };
 

package/dist/custom-nlGufiDz.mjs

@@ -0,0 +1,88 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+
+//#region src/compat/legacy-options.ts
+/**
+* Recognizing a request-options bag passed where a params object now goes.
+*
+* TODO(#66): a migration guardrail, to be removed before stable 2.0 —
+* https://github.com/ComposioHQ/composio-client/issues/66.
+*
+* A method that gains its first optional parameter moves from
+* `method(id, options?)` to `method(id, params?, options?)`. A caller written
+* against the released two-position form then hands its options to the params
+* position, where `headers` is serialized into the URL and `timeout`/`signal`
+* are dropped. The generator emits a check for exactly the methods its ledger
+* declares (`LEGACY_OPTIONS_POSITIONS` in `packages/codegen`), and every one of
+* them asks this module — the key set lives here once, not in generated files.
+*
+* This file imports nothing on purpose: the generator reads
+* `REQUEST_OPTIONS_KEYS` to refuse a ledger entry whose parameter names collide
+* with it, and must be able to load the list without the rest of the kernel.
+* `test/types/legacy-options.test-d.ts` pins the list to `keyof RequestOptions`
+* in both directions, so a key added to that interface cannot be forgotten here.
+*/
+/** Every key of `RequestOptions` (`request.ts`). */
+const REQUEST_OPTIONS_KEYS = [
+	"headers",
+	"maxRetries",
+	"timeout",
+	"signal",
+	"fetchOptions",
+	"idempotencyKey"
+];
+/**
+* Whether `value`, received in a params position, is really a request-options
+* bag from a call written against the released two-position signature.
+*
+* `declaredKeys` are the operation's own parameter names. An object carrying
+* any of them is params, whatever else it carries: a mixed object is ambiguous,
+* and reading it as options would silently discard a parameter the caller set.
+* Otherwise it is options only on positive evidence — at least one
+* `RequestOptions` key — so `{}`, `null` and `undefined` stay params.
+*
+* The generator guarantees the two key sets are disjoint, which is what makes
+* the answer unambiguous for every object that is not mixed.
+*/
+const isLegacyRequestOptions = (value, declaredKeys) => {
+	if (typeof value !== "object" || value === null) return false;
+	if (declaredKeys.some((key) => Object.hasOwn(value, key))) return false;
+	return REQUEST_OPTIONS_KEYS.some((key) => Object.hasOwn(value, key));
+};
+
+//#endregion
+//#region src/compat/resources/custom.ts
+const OP_DELETE_TOOLKIT = generatedOperation("custom.deleteToolkit");
+const OP_SYNC = generatedOperation("custom.sync");
+const OP_UPSERT = generatedOperation("custom.upsert");
+const LEGACY_PARAM_KEYS_DELETE_TOOLKIT = ["revoke_on_delete"];
+/** OpenAPI resource for `custom`. */
+var Custom = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	deleteToolkit(slug, queryOrOptions = {}, trailingOptions) {
+		const optionsSecond = trailingOptions === void 0 && isLegacyRequestOptions(queryOrOptions, LEGACY_PARAM_KEYS_DELETE_TOOLKIT);
+		const query = optionsSecond ? {} : queryOrOptions;
+		const options = optionsSecond ? queryOrOptions : trailingOptions;
+		return this.#client.delete(path`/api/v3.1/custom/toolkits/${slug}`, withOperation(OP_DELETE_TOOLKIT, {
+			query,
+			...options
+		}));
+	}
+	sync(body, options) {
+		return this.#client.post("/api/v3.1/custom/toolkits/sync", withOperation(OP_SYNC, {
+			body,
+			...options
+		}));
+	}
+	upsert(body, options) {
+		return this.#client.post("/api/v3.1/custom/toolkits/upsert", withOperation(OP_UPSERT, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Custom as t };

package/dist/error-DLB1uKM3.mjs

@@ -0,0 +1,109 @@
+//#region src/compat/error.ts
+var ComposioError = class extends Error {};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+/**
+* Narrow a parsed error body to the envelope's inner object. Checks exactly
+* the fields the schema requires plus the optional ones' types; anything
+* else (text bodies, foreign JSON, a 502 from a proxy) is `undefined`.
+*/
+const errorDetails = (body) => {
+	if (!isRecord(body) || !isRecord(body.error)) return void 0;
+	const { message, code, slug, status, request_id, suggested_fix, errors } = body.error;
+	if (typeof message !== "string" || typeof slug !== "string") return void 0;
+	if (typeof code !== "number" || typeof status !== "number") return void 0;
+	if (request_id !== void 0 && typeof request_id !== "string") return void 0;
+	if (suggested_fix !== void 0 && typeof suggested_fix !== "string") return void 0;
+	if (errors !== void 0 && !isStringArray(errors)) return void 0;
+	return {
+		message,
+		code,
+		slug,
+		status,
+		...request_id !== void 0 ? { request_id } : void 0,
+		...suggested_fix !== void 0 ? { suggested_fix } : void 0,
+		...errors !== void 0 ? { errors } : void 0
+	};
+};
+var APIError = class APIError extends ComposioError {
+	/** HTTP status for the response that caused the error. */
+	status;
+	/** HTTP headers of the response that caused the error. */
+	headers;
+	/** JSON body of the response that caused the error. */
+	error;
+	/**
+	* The body narrowed to the Composio error envelope (`APIErrorBody['error']`),
+	* or `undefined` when the body is not one — so a validation failure's
+	* `errors[]` and `suggested_fix` are reachable without casting `error`.
+	*
+	* Not part of the Stainless surface: a sanctioned superset, like
+	* `ClientOptions.userApiKey`.
+	*/
+	details;
+	/**
+	* The request id the API assigned, from the `x-request-id` response header
+	* first and the envelope's `request_id` otherwise; `undefined` when neither
+	* is present (connection errors, aborts). Same superset status as `details`.
+	*/
+	requestId;
+	constructor(status, error, message, headers) {
+		super(APIError.makeMessage(status, error, message));
+		this.status = status;
+		this.headers = headers;
+		this.error = error;
+		this.details = errorDetails(error);
+		this.requestId = headers?.get?.("x-request-id") || this.details?.request_id;
+	}
+	static makeMessage(status, error, message) {
+		const errorMessage = error?.message;
+		const msg = errorMessage ? typeof errorMessage === "string" ? errorMessage : JSON.stringify(errorMessage) : error ? JSON.stringify(error) : message;
+		if (status && msg) return `${status} ${msg}`;
+		if (status) return `${status} status code (no body)`;
+		if (msg) return msg;
+		return "(no status code or body)";
+	}
+	static generate(status, errorResponse, message, headers) {
+		if (!status || !headers) return new APIConnectionError({
+			message,
+			cause: errorResponse
+		});
+		const error = errorResponse;
+		if (status === 400) return new BadRequestError(status, error, message, headers);
+		if (status === 401) return new AuthenticationError(status, error, message, headers);
+		if (status === 403) return new PermissionDeniedError(status, error, message, headers);
+		if (status === 404) return new NotFoundError(status, error, message, headers);
+		if (status === 409) return new ConflictError(status, error, message, headers);
+		if (status === 422) return new UnprocessableEntityError(status, error, message, headers);
+		if (status === 429) return new RateLimitError(status, error, message, headers);
+		if (status >= 500) return new InternalServerError(status, error, message, headers);
+		return new APIError(status, error, message, headers);
+	}
+};
+var APIUserAbortError = class extends APIError {
+	constructor({ message } = {}) {
+		super(void 0, void 0, message ?? "Request was aborted.", void 0);
+	}
+};
+var APIConnectionError = class extends APIError {
+	constructor({ message, cause }) {
+		super(void 0, void 0, message ?? "Connection error.", void 0);
+		if (cause) this.cause = cause;
+	}
+};
+var APIConnectionTimeoutError = class extends APIConnectionError {
+	constructor({ message } = {}) {
+		super({ message: message ?? "Request timed out." });
+	}
+};
+var BadRequestError = class extends APIError {};
+var AuthenticationError = class extends APIError {};
+var PermissionDeniedError = class extends APIError {};
+var NotFoundError = class extends APIError {};
+var ConflictError = class extends APIError {};
+var UnprocessableEntityError = class extends APIError {};
+var RateLimitError = class extends APIError {};
+var InternalServerError = class extends APIError {};
+
+//#endregion
+export { AuthenticationError as a, ConflictError as c, PermissionDeniedError as d, RateLimitError as f, APIUserAbortError as i, InternalServerError as l, APIConnectionTimeoutError as n, BadRequestError as o, UnprocessableEntityError as p, APIError as r, ComposioError as s, APIConnectionError as t, NotFoundError as u };

package/dist/{files-B-UnEejx.mjs → files-DROCPzLP.mjs}

@@ -1,6 +1,8 @@
-import { r as path } from "./request-DwPfYYNF.mjs";
+import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
 
 //#region src/compat/resources/files.ts
+const OP_LIST = generatedOperation("files.list");
+const OP_CREATE_PRESIGNED_URL = generatedOperation("files.createPresignedURL");
 /**
 * Stainless-shaped `client.files` resource: the 2-method project file surface
 * of `@composio/client` (list, createPresignedURL).
@@ -12,16 +14,16 @@ var Files = class {
 	}
 	/** @deprecated Deprecated in the input OpenAPI schema. */
 	list(query = {}, options) {
-		return this.#client.get(path`/api/v3.1/files/list`, {
+		return this.#client.get("/api/v3.1/files/list", withOperation(OP_LIST, {
 			query,
 			...options
-		});
+		}));
 	}
 	createPresignedURL(body, options) {
-		return this.#client.post(path`/api/v3.1/files/upload/request`, {
+		return this.#client.post("/api/v3.1/files/upload/request", withOperation(OP_CREATE_PRESIGNED_URL, {
 			body,
 			...options
-		});
+		}));
 	}
 };