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

package/dist/request-zLX87M09.mjs

@@ -0,0 +1,1423 @@
+//#region src/compat/error.ts
+/**
+* Stainless-compatible error hierarchy.
+*
+* Downstream code does `instanceof` checks and reads `status` / `error` /
+* `headers` on these classes (see docs/research/drop-in-contract.md §4), so
+* both the class names and the inheritance chain are part of the drop-in
+* contract: `BadRequestError extends APIError extends ComposioError extends Error`.
+*/
+var ComposioError = class extends Error {};
+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;
+	constructor(status, error, message, headers) {
+		super(APIError.makeMessage(status, error, message));
+		this.status = status;
+		this.headers = headers;
+		this.error = error;
+	}
+	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
+//#region src/compat/headers.ts
+const hasEntries = (value) => typeof value === "object" && value !== null && "append" in value && typeof value.append === "function" && "delete" in value && typeof value.delete === "function" && "entries" in value && typeof value.entries === "function" && "get" in value && typeof value.get === "function";
+const isHeaders = (value) => value instanceof Headers || hasEntries(value);
+const isNullableHeadersLike = (headers) => {
+	if (!("values" in headers) || !isHeaders(headers.values) || !("nulls" in headers)) return false;
+	const nulls = headers.nulls;
+	return typeof nulls === "object" && nulls !== null && Symbol.iterator in nulls;
+};
+/**
+* Iterates every supported input while preserving explicit deletions. Plain
+* objects replace an older value for a key; tuple inputs append duplicate
+* values, matching the published client.
+*/
+function* iterateHeaders(headers) {
+	if (!headers) return;
+	if (isNullableHeadersLike(headers)) {
+		yield* headers.values.entries();
+		for (const name of headers.nulls) yield [name, null];
+		return;
+	}
+	const shouldReplace = !isHeaders(headers) && !Array.isArray(headers);
+	const entries = isHeaders(headers) ? headers.entries() : Array.isArray(headers) ? headers : Object.entries(headers);
+	for (const entry of entries) {
+		const name = entry[0];
+		if (typeof name !== "string") throw new TypeError("expected header name to be a string");
+		const rawValue = entry[1];
+		const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+		let replaced = false;
+		for (const value of values) {
+			if (value === void 0) continue;
+			if (shouldReplace && !replaced) {
+				replaced = true;
+				yield [name, null];
+			}
+			yield [name, value];
+		}
+	}
+}
+/** Merge sources while retaining names explicitly deleted by the last source. */
+const mergeHeaders = (sources) => {
+	const values = new Headers();
+	const nulls = /* @__PURE__ */ new Set();
+	for (const source of sources) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const [name, value] of iterateHeaders(source)) {
+			const lowerName = name.toLowerCase();
+			if (!seen.has(lowerName)) {
+				values.delete(name);
+				seen.add(lowerName);
+			}
+			if (value === null) {
+				values.delete(name);
+				nulls.add(lowerName);
+			} else {
+				values.append(name, value);
+				nulls.delete(lowerName);
+			}
+		}
+	}
+	return {
+		values,
+		nulls
+	};
+};
+/** Merge sources into the native header collection sent to fetch. */
+const buildHeaders = (sources) => mergeHeaders(sources).values;
+
+//#endregion
+//#region src/compat/credentials.ts
+/**
+* The credential transport boundary.
+*
+* The design record makes authentication part of the runtime contract in both
+* languages, with four rules. Three of them are enforced here and in
+* `request.ts`; the fourth is a property of what this client's messages are
+* built from, and is pinned by test rather than by code:
+*
+* 0. **A request carries exactly one credential header**, chosen from the
+*    operation's declared security schemes. Not a record rule — it is a
+*    measured property of the API (two credential headers on one request is a
+*    401, even where either alone is a 200), so the four rules below are all
+*    stated about *the* credential a request carries, and {@link selectScheme}
+*    decides which one that is. See wayfinder ticket 48 and §4 of
+*    `docs/research/drop-in-contract.md`.
+* 1. **A credentialed API origin must use HTTPS.** Plain `http:` is permitted
+*    only for loopback development endpoints — which is exactly what the
+*    sanctioned `environment: 'local'` default (`http://localhost:9900`) is.
+*    Enforced by {@link assertCredentialTransport} at construction and again
+*    by {@link credentialForRequest} at dispatch, because `apiKey` and
+*    `baseURL` are both public mutable fields on the client.
+* 2. **The credential is attached only to requests whose origin matches the
+*    configured API origin.** {@link credentialForRequest} returns `null`
+*    off-origin, and the header is simply not sent.
+* 3. **Credentials are never forwarded across an origin-changing redirect.**
+*    The kernel follows redirects itself (`request.ts`) rather than delegating
+*    to `fetch`, and every hop re-enters the header build — so the credential
+*    decision is re-derived from *that hop's* URL and rule 3 mostly falls out
+*    of rule 2. What does not fall out is the caller's own credential headers,
+*    which rule 2 deliberately leaves alone: {@link withdrawCredentials}
+*    removes those once a chain has changed origin.
+* 4. **Credential-bearing values are redacted from logs and error messages.**
+*    Nothing here to do: no message this client constructs ever reads a
+*    request header or a request URL. `APIError.makeMessage` is built from the
+*    status and the response *body*; the deprecation notice is built from the
+*    operation template and parsed public response-header values. Pinned in
+*    `test/unit/credential-boundary.test.ts` so it stays true.
+*
+* ### Failure modes, and why they differ
+*
+* Rule 1 **throws**. A plaintext credentialed origin is a configuration
+* mistake with no safe interpretation: dropping the key instead would turn it
+* into a stream of confusing 401s that never names the real cause, and sending
+* it is the thing being prevented. Throwing at construction puts the error on
+* the line that made the mistake.
+*
+* Rule 2 **drops the credential and continues**. The record states it as an
+* attachment rule, not an error, and the runtime genuinely cannot tell an
+* attack from a legitimate off-origin fetch — this API mints presigned upload
+* and download URLs (`files.createPresignedURL`,
+* `session.files.createDownloadURL`) that live on a storage origin, and a
+* caller reaching one through the escape hatch is doing something reasonable.
+* Dropping makes that safe; throwing would make it impossible.
+*
+* Rule 3 **follows the hop without the credential** rather than refusing to
+* hop. Refusing was the first spelling, and it was overruled on a parity
+* argument worth recording: Stainless followed redirects, no differential
+* fixture redirects, so a green suite would have been evidence that the
+* *tests* do not redirect — not that production does not. The rule itself is
+* unchanged; only the remedy is.
+*
+* ### Divergence from Stainless
+*
+* Deliberate, and sanctioned by the design record: the published Stainless
+* client enforces none of this. Redirect *following* is no longer part of the
+* divergence — both clients follow — but what rides along on the hop is. See
+* §4 of `docs/research/drop-in-contract.md` and wayfinder ticket 40.
+*/
+/**
+* The three credential classes this API accepts, and the header each one puts
+* on the wire.
+*
+* These are the `apiKey`-in-header schemes `spec/openapi.json` declares under
+* `components.securitySchemes`. The fourth declared one, `CookieAuth`, is
+* referenced by no operation and is not a thing a client library places.
+*/
+const SCHEME_HEADERS = {
+	ApiKeyAuth: "x-api-key",
+	UserApiKeyAuth: "x-user-api-key",
+	OrgApiKeyAuth: "x-org-api-key"
+};
+/** The scheme a request authenticates with when its operation names none. */
+const DEFAULT_SCHEME = "ApiKeyAuth";
+const valueFor = (scheme, credentials) => scheme === "ApiKeyAuth" ? credentials.apiKey : scheme === "UserApiKeyAuth" ? credentials.userApiKey : credentials.orgApiKey;
+/**
+* Whether anything beyond the project key is configured — the condition that
+* makes per-operation selection able to change an outcome at all.
+*
+* Load-bearing rather than an optimization. With only `apiKey` set, every
+* branch of {@link selectScheme} lands on `ApiKeyAuth`: it wins wherever it is
+* an accepted alternative, and where it is not, the alternative is unconfigured
+* and the fallback is `ApiKeyAuth` again. So the client that every existing
+* caller constructs never consults the operation table, and "an `apiKey`-only
+* client emits byte-identical requests on all 104 operations" is a property of
+* the code shape rather than a claim tests have to keep re-establishing.
+*/
+const hasAlternateCredential = (credentials) => credentials.userApiKey !== null || credentials.orgApiKey !== null;
+/**
+* Which credential a request declaring `schemes` should carry.
+*
+* **Exactly one, always** — and the API says so itself. Measured against
+* production on 2026-08-06, `GET /toolkits` answers 200 for `x-api-key` alone
+* and 200 for `x-user-api-key` alone, and answers both together with
+* `401 HTTP_Unauthorized`:
+*
+* > Multiple authentication modes were provided. Provide exactly one
+* > authentication mode per request. Provided: ApiKeyAuth via x-api-key,
+* > UserApiKeyAuth via x-user-api-key.
+*
+* The platform names the schemes by their OpenAPI names, so this is the same
+* vocabulary `security` is written in rather than a coincidence of headers. It
+* holds for `x-api-key` + `x-org-api-key` too, and on an operation that accepts
+* only one of them. There is therefore no additive "send the user key as well"
+* model available, and the choice has to be made per request rather than
+* accumulated.
+*
+* The precedence exists to make the change free where it must be free:
+*
+* 1. **`ApiKeyAuth` wins wherever the operation accepts it** and an `apiKey` is
+*    configured — 85 of the 104 operations, every wire byte preserved.
+* 2. Otherwise the first scheme the operation names that this client both
+*    recognizes *and* holds a credential for. That is what makes the 16
+*    `UserApiKeyAuth`-only and `OrgApiKeyAuth`-only operations reachable.
+* 3. Otherwise `ApiKeyAuth`, which is what this client did before any of this
+*    existed. A `UserApiKeyAuth`-only operation called by a client with no user
+*    key still sends `x-api-key` and still fails the same way — which is what
+*    keeps `cli.realtime.auth` and `cli.realtime.credentials` pinned against
+*    the Stainless oracle in `test/unit/differential-wire.test.ts`.
+*
+* Rule 3 is also where a scheme name this client does not know lands. Three of
+* them exist: `security` references `no_auth` (3 operations) and
+* `workbench_access_key` (1) and `components.securitySchemes` declares neither.
+* Those four operations receive `x-api-key` today and are differentially
+* pinned doing so, so resolving an unknown name to "no credential" would be a
+* wire change made on the strength of a spec defect. A later generator pass
+* must not "fix" that.
+*/
+const selectScheme = (schemes, credentials) => {
+	if (schemes === void 0 || schemes.length === 0) return DEFAULT_SCHEME;
+	if (schemes.includes(DEFAULT_SCHEME) && credentials.apiKey !== null) return DEFAULT_SCHEME;
+	for (const scheme of schemes) {
+		if (!Object.hasOwn(SCHEME_HEADERS, scheme)) continue;
+		const known = scheme;
+		if (valueFor(known, credentials) !== null) return known;
+	}
+	return DEFAULT_SCHEME;
+};
+/**
+* What counts as loopback, pinned rather than assumed. `localhost` is not the
+* whole set:
+*
+* - `localhost`, and any name under it (`api.localhost`). RFC 6761 §6.3
+*   reserves the whole `.localhost` TLD to resolve to the loopback interface,
+*   and container-era dev setups do use subdomains of it.
+* - The entire IPv4 loopback block `127.0.0.0/8`, not just `127.0.0.1`.
+* - The IPv6 loopback `::1`. `URL` hands hostnames back bracketed and in
+*   canonical compressed form, so `http://[0:0:0:0:0:0:0:1]/` arrives here as
+*   `[::1]`.
+*
+* Everything else is not loopback, deliberately. `0.0.0.0` in particular is the
+* unspecified address, not a loopback one; it happens to reach the local host
+* on some platforms and fails on others, and a rule that depends on the
+* platform is not a rule. The IPv4-mapped spelling `::ffff:127.0.0.1` is
+* refused for the same reason — Python's `ipaddress` answers it differently
+* across interpreter versions, and nobody configures a development endpoint
+* that way. The error message names the accepted set so a developer who typed
+* `0.0.0.0` sees the fix immediately.
+*/
+const LOOPBACK_IPV4 = /^127(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+const isLoopbackHostname = (hostname) => {
+	const host = hostname.trim().toLowerCase().replace(/^\[|\]$/g, "");
+	if (host === "localhost" || host.endsWith(".localhost")) return true;
+	if (host === "::1") return true;
+	return LOOPBACK_IPV4.test(host);
+};
+/** The URL, parsed, when it is absolute and http(s); `null` otherwise. */
+const parseHTTPURL = (value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:" ? url : null;
+	} catch {
+		return null;
+	}
+};
+/**
+* The URL `target` names, resolved against `base`, when it lands on http(s);
+* `null` when it cannot be parsed or names a scheme this client does not
+* speak. The one spelling of "resolve against a base, http(s) only" — the
+* redirect follower and the deprecation link resolver both need exactly this.
+*/
+const resolveHTTPURL = (target, base) => {
+	try {
+		return parseHTTPURL(new URL(target, base).href);
+	} catch {
+		return null;
+	}
+};
+/** Whether a credential may be sent to this origin at all. */
+const isCredentialSafeOrigin = (url) => url.protocol === "https:" || url.protocol === "http:" && isLoopbackHostname(url.hostname);
+const LOOPBACK_DESCRIPTION = "localhost, *.localhost, 127.0.0.0/8, [::1]";
+const insecureOriginMessage = (baseURL) => `Refusing to send a Composio API credential to ${baseURL}: a credentialed API origin must use HTTPS. Plain http:// is permitted only for loopback development endpoints (${LOOPBACK_DESCRIPTION}). Pass an https:// baseURL, use environment: 'local', or construct the client without credentials.`;
+/** Whether the client holds anything at all that rule 1 has to protect. */
+const anyCredential = (credentials) => credentials.apiKey !== null || hasAlternateCredential(credentials);
+/**
+* Rule 1 at construction time: a client that holds a credential must be
+* pointed at an origin that can carry one. Knowable before any request is
+* made, so it fails on the constructor call rather than on the first dispatch.
+*
+* A `baseURL` that is not an absolute http(s) URL fails the same way — a
+* credential cannot be sent over a scheme this client does not speak, and the
+* alternative is a `TypeError` from `new URL()` one layer down.
+*
+* Every configured credential counts, not just `apiKey`: which one a given
+* request carries is decided per operation, so a client holding *any* of them
+* is a client that can put one on the wire.
+*/
+const assertCredentialTransport = (baseURL, credentials) => {
+	if (!anyCredential(credentials)) return;
+	const url = parseHTTPURL(baseURL);
+	if (url === null || !isCredentialSafeOrigin(url)) throw new ComposioError(insecureOriginMessage(baseURL));
+};
+/**
+* The credential this request may carry, or `null` for none.
+*
+* Rules 1 and 2 at dispatch time. Both re-checks are load-bearing rather than
+* belt-and-braces: `apiKey` and `baseURL` are public mutable fields, so the
+* construction-time check can be invalidated by an assignment, and the request
+* URL is *not* guaranteed to sit on the configured origin. `buildURL`
+* concatenates `baseURL + path` and the escape hatch (`client.get(path)`)
+* takes an arbitrary path, so a path that does not begin with `/` extends the
+* *authority* rather than the path: `client.get('.evil.example/x')` against
+* `https://backend.composio.dev` resolves to
+* `https://backend.composio.dev.evil.example/x`, and `client.get(':8443/x')`
+* changes the port. Both were carrying `x-api-key` before this boundary
+* existed. (The userinfo spelling — `client.get('@evil.example/x')` — reaches
+* a third origin too, but `fetch` refuses to construct a `Request` from a URL
+* with credentials, so that one dies at the transport instead. httpx has no
+* such objection, which is why the Python port checks the same thing.)
+*/
+const credentialForRequest = (baseURL, scheme, credentials, requestURL) => {
+	const value = valueFor(scheme, credentials);
+	if (value === null) return null;
+	const base = parseHTTPURL(baseURL);
+	const target = parseHTTPURL(requestURL);
+	if (base === null || target === null) return null;
+	if (base.origin !== target.origin) return null;
+	if (!isCredentialSafeOrigin(target)) throw new ComposioError(insecureOriginMessage(baseURL));
+	return {
+		name: SCHEME_HEADERS[scheme],
+		value
+	};
+};
+/**
+* The credential headers a *caller* can place that are not the one this client
+* attaches — `x-api-key` is excluded because a caller setting it is overriding
+* the client's own value in the same slot, which is pinned Stainless behaviour,
+* not a second credential.
+*/
+const FOREIGN_CREDENTIAL_HEADERS = ["x-user-api-key", "x-org-api-key"];
+/**
+* Whether the caller has placed a credential of their own, in which case the
+* client must not add one beside it.
+*
+* Not a courtesy: this API answers a request carrying two credential headers
+* with `401 HTTP_Unauthorized`, so attaching `x-api-key` next to a caller's
+* `x-user-api-key` does not weaken the call, it *breaks* it. Three released
+* methods make that reachable without any `defaultHeaders` at all —
+* `cli.createCodactFailure`, `org.consumer.project.resolve` and
+* `org.consumer.listConnectedToolkits` declare `x-user-api-key` as a `required`
+* header parameter, which the generator folds into their params object. Calling
+* them the way their signature asks for returned 401 until this rule existed.
+*
+* Header merging is replayed rather than approximated, because a later source
+* may carry `null` to delete what an earlier one set (`buildHeaders`).
+*/
+const callerPlacedCredential = (sources) => {
+	const headers = buildHeaders(sources);
+	return FOREIGN_CREDENTIAL_HEADERS.some((name) => headers.has(name));
+};
+/**
+* Header names that carry a credential and must not survive an origin change.
+*
+* The first three are what `fetch` itself would have stripped had it been
+* following the redirect (Fetch §4.4 "HTTP-redirect fetch" deletes
+* `Authorization` cross-origin; `Cookie` and `Proxy-Authorization` are
+* forbidden header names a page cannot set and a server-side fetch does not
+* carry across origins). Following redirects by hand means taking that job on.
+* `x-api-key` joins them because it is *this* API's credential, and because the
+* Fetch spec would not have stripped it — a custom header rides along a
+* cross-origin redirect, which is the hole this whole module exists to close.
+*
+* `x-user-api-key` and `x-org-api-key` are the spec's other two credential
+* schemes (`UserApiKeyAuth`, `OrgApiKeyAuth`), and they belong here for the same
+* reason `x-api-key` does — the kernel attaches all three (wayfinder ticket 48)
+* and a caller can place the latter two directly besides. They were listed here
+* one ticket *before* the attachment work, because omitting them cost more than
+* a missed withdrawal: {@link carriesCredentials} answered `false` for a request
+* carrying only one of them, so `request.ts` classified it as credential-free
+* and handed the whole chain to `fetch` at `redirect: 'follow'` — the exact leak
+* rule 3 exists to close, arriving through a different header name.
+*
+* This list is the repo's answer to "which header names carry a credential",
+* and the live parity harness needs the same answer: it redacts these values
+* where it renders a captured request into a summary someone reads on a
+* terminal. It cannot import them — the harness runs under `node
+* --experimental-transform-types`, which does not resolve this module's `.js`
+* specifiers — so `packages/parity/src/core/compare.ts` mirrors the list and a
+* test there reads this file to hold the two in step, the same arrangement the
+* Python driver's protocol version already uses.
+*/
+const CREDENTIAL_HEADERS = [
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"x-api-key",
+	"x-user-api-key",
+	"x-org-api-key"
+];
+/**
+* Rule 3 for headers the caller placed, applied when a redirect chain changes
+* origin.
+*
+* Rule 2 deliberately leaves a caller's own `defaultHeaders` / per-request
+* headers alone on the *initial* request, even off-origin: the caller chose
+* that URL, and an escape-hatch call to a presigned storage URL carrying its
+* own `Authorization` is a legitimate thing to do. A redirect target is chosen
+* by the *server*, not the caller, so the same consent does not extend to it.
+*
+* Withdrawal is **sticky** for the rest of the chain: once a hop has left the
+* origin it started on, no later hop re-attaches a credential, not even one
+* that lands back on the configured API origin. A real API does not bounce a
+* caller off-site and back, and "no credential after the chain leaves" is one
+* sentence rather than a case analysis.
+*/
+const withdrawCredentials = (headers) => {
+	for (const name of CREDENTIAL_HEADERS) headers.delete(name);
+};
+/**
+* Whether these headers carry anything that must not cross an origin change —
+* the exact complement of {@link withdrawCredentials}, sharing its list so the
+* two cannot drift apart.
+*
+* `request.ts` asks this before the *first* dispatch of a chain. A request
+* carrying nothing credential-bearing has nothing to protect, so following it
+* by hand buys nothing the platform's own following does not already give:
+* `fetch` strips exactly these header names across a cross-origin hop, applies
+* the same method rewrite, and enforces the same 20-hop budget. Delegating is
+* therefore provably equivalent there — and it is the only way a *browser* can
+* follow a redirect at all.
+*/
+const carriesCredentials = (headers) => CREDENTIAL_HEADERS.some((name) => headers.has(name));
+
+//#endregion
+//#region src/compat/deprecation.ts
+/**
+* Runtime deprecation notices, read off the response.
+*
+* The server announces a deprecated operation with three standard fields:
+*
+* - `Deprecation` (RFC 9745) — an Item Structured Field whose value is a Date
+*   (RFC 9651 §3.3.7): an `@` followed by integer seconds since the Unix
+*   epoch, e.g. `Deprecation: @1688169599`.
+* - `Sunset` (RFC 8594) — an HTTP-date, e.g. `Sunset: Sat, 31 Dec 2018
+*   23:59:59 GMT`, naming the date the operation stops being served.
+* - `Link` (RFC 8288) — `rel="deprecation"` points at human-readable notes
+*   (RFC 9745 registers that relation); `rel="successor-version"` (RFC 5829)
+*   points at the replacement resource, which this module maps back to a
+*   public client chain when it can.
+*
+* The authoring-time half of the same contract already exists: an operation
+* the input schema marks `deprecated: true` reaches the generated method as a
+* `@deprecated` annotation. This is the runtime half, and the two are
+* independent — a notice fires because the *server* said so, never because the
+* committed snapshot did, so it stays correct between spec syncs.
+*
+* Everything here is defensive by construction. A deprecation notice is
+* advisory; it must never break a live call, so a field that is oversized,
+* carries control characters, or simply does not parse is dropped rather than
+* raised.
+*/
+/**
+* Field-size ceiling. A deprecation notice is decoration on a response that
+* has already been paid for, so an oversized field is dropped rather than
+* parsed — there is no message worth building out of 2 KiB of `Link`.
+*/
+const MAX_FIELD_LENGTH = 2048;
+/** No message this client emits may smuggle control characters into a log. */
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+/**
+* How many distinct (operation, notice) pairs one client instance will ever
+* warn about. Generated methods draw from a fixed table of ~100 and a server
+* revises a notice rarely, so the bound is unreachable in practice; it exists
+* because both halves of the key are ultimately server- or caller-controlled —
+* an escape-hatch caller (`client.get('/api/v3.1/…/{id}')`) keys on the
+* substituted path, and a server rotating `Sunset` or `Link` on every response
+* mints a fresh pair each time. Past the ceiling the client stops warning
+* rather than growing a set forever.
+*/
+const MAX_TRACKED_NOTICES = 1024;
+const readField = (headers, name) => {
+	const value = headers.get(name);
+	if (value === null) return null;
+	if (value.length > MAX_FIELD_LENGTH || CONTROL_CHARACTERS.test(value)) return null;
+	return value;
+};
+/**
+* RFC 9651 §3.3.7 sf-date: `@` then integer seconds since the epoch, possibly
+* negative. Anything else — including the pre-RFC `true` and bare HTTP-date
+* spellings the draft years produced — yields no date; the notice still fires,
+* because the server sending the field at all is the signal.
+*/
+const parseStructuredDate = (value) => {
+	const match = /^@(-?\d{1,15})$/.exec(value.trim());
+	if (match === null) return null;
+	const date = /* @__PURE__ */ new Date(Number(match[1]) * 1e3);
+	return Number.isNaN(date.getTime()) ? null : date;
+};
+const MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+const DAY = "(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)";
+const DAY_LONG = "(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)";
+const MONTH = `(${MONTHS.join("|")})`;
+const TIME = "(\\d{2}):(\\d{2}):(\\d{2})";
+/** `day-name "," SP 2DIGIT SP month SP 4DIGIT SP time-of-day SP GMT` */
+const IMF_FIXDATE = new RegExp(`^${DAY}, (\\d{2}) ${MONTH} (\\d{4}) ${TIME} GMT$`);
+/** `day-name-l "," SP 2DIGIT "-" month "-" 2DIGIT SP time-of-day SP GMT` */
+const RFC850_DATE = new RegExp(`^${DAY_LONG}, (\\d{2})-${MONTH}-(\\d{2}) ${TIME} GMT$`);
+/** `day-name SP month SP ( 2DIGIT / ( SP 1DIGIT ) ) SP time-of-day SP 4DIGIT` */
+const ASCTIME_DATE = new RegExp(`^${DAY} ${MONTH} (\\d{2}| \\d) ${TIME} (\\d{4})$`);
+const isLeapYear = (year) => year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+const daysInMonth = (year, month) => month === 2 ? isLeapYear(year) ? 29 : 28 : month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
+/**
+* RFC 8594 `Sunset`: an HTTP-date, which RFC 7231 §7.1.1.1 defines as exactly
+* three forms — IMF-fixdate (the only one a sender may generate), and the
+* obsolete rfc850-date and asctime-date a recipient must still accept. All
+* three denote UTC; only IMF-fixdate and rfc850-date spell the `GMT` literal,
+* and asctime-date carries no zone because it never means anything else.
+*
+* Written out by hand rather than delegated to `Date.parse`, which is not a
+* conformance bug but three:
+*
+* - It **fabricates dates.** `Sat, 31 Feb 2018 23:59:59 GMT` parsed as
+*   2018-03-03 — the client would have told a caller its endpoint disappears
+*   on a date the server never sent. The calendar is checked here instead of
+*   normalized, so an impossible day yields no date at all.
+* - It is **host-dependent.** For any input outside the ISO-8601 grammar,
+*   `Date.parse` is implementation-defined, and V8 falls back to a lenient
+*   reader that applies the *local* offset when a value carries no zone. Both
+*   `December 31, 2018` and a zone-less `Sat, 31 Dec 2018 23:59:59` therefore
+*   produced a different instant on a developer's laptop than in CI — a
+*   parsed field with no stable value.
+* - It **disagreed with the Python client**, whose RFC-5322 reader rejected
+*   every one of those inputs. The two clients are held to identical parses;
+*   `test/fixtures/http-date-vectors.json` is the table both suites read.
+*
+* Rejection is not a silencer: an unparseable `Sunset` leaves the removal date
+* out of the warning, and the notice still fires on the field's presence — the
+* same stance `parseStructuredDate` takes on `Deprecation`.
+*/
+const parseHttpDate = (value) => {
+	const trimmed = value.trim();
+	let fields = null;
+	const imf = IMF_FIXDATE.exec(trimmed);
+	if (imf !== null) fields = [
+		Number(imf[3]),
+		imf[2],
+		imf[1],
+		imf.slice(4, 7)
+	];
+	else {
+		const rfc850 = RFC850_DATE.exec(trimmed);
+		if (rfc850 !== null) {
+			const short = Number(rfc850[3]);
+			fields = [
+				short < 70 ? 2e3 + short : 1900 + short,
+				rfc850[2],
+				rfc850[1],
+				rfc850.slice(4, 7)
+			];
+		} else {
+			const asctime = ASCTIME_DATE.exec(trimmed);
+			if (asctime !== null) fields = [
+				Number(asctime[6]),
+				asctime[1],
+				asctime[2].trim(),
+				asctime.slice(3, 6)
+			];
+		}
+	}
+	if (fields === null) return null;
+	const [year, month, day, time] = fields;
+	const monthIndex = MONTHS.indexOf(month);
+	const dayNumber = Number(day);
+	const [hour, minute, second] = time.map(Number);
+	if (year < 1) return null;
+	if (dayNumber < 1 || dayNumber > daysInMonth(year, monthIndex + 1)) return null;
+	if (hour > 23 || minute > 59 || second > 59) return null;
+	const date = new Date(Date.UTC(year, monthIndex, dayNumber, hour, minute, second));
+	if (year < 100) date.setUTCFullYear(year);
+	return date;
+};
+/**
+* RFC 8288 `Link`, enough of it: a comma-separated list of `<target>` followed
+* by `;`-separated parameters, where a parameter value may be quoted (and may
+* therefore contain commas and semicolons). Only `rel` and the presence of
+* `anchor` are retained. Malformed input truncates the list instead of failing
+* — whatever parsed before the damage is still usable.
+*
+* Per RFC 8288 §3.3 only the *first* `rel` on a link counts; later occurrences
+* are ignored. Accumulating them instead would let `rel=alternate;
+* rel=deprecation` smuggle an arbitrary target into the relation this client
+* acts on.
+*/
+const parseLinkField = (value) => {
+	const links = [];
+	let index = 0;
+	const isSpace = (char) => char === " " || char === "	";
+	while (index < value.length) {
+		while (index < value.length && (value[index] === "," || isSpace(value[index]))) index++;
+		if (value[index] !== "<") break;
+		const close = value.indexOf(">", index);
+		if (close < 0) break;
+		const target = value.slice(index + 1, close).trim();
+		index = close + 1;
+		const rels = [];
+		let seenRel = false;
+		let anchored = false;
+		while (index < value.length) {
+			while (index < value.length && isSpace(value[index])) index++;
+			if (value[index] === ",") {
+				index++;
+				break;
+			}
+			if (value[index] !== ";") {
+				index++;
+				continue;
+			}
+			index++;
+			const nameStart = index;
+			while (index < value.length && !"=;,".includes(value[index] ?? "")) index++;
+			const name = value.slice(nameStart, index).trim().toLowerCase();
+			let parameter = "";
+			if (value[index] === "=") {
+				index++;
+				while (index < value.length && isSpace(value[index])) index++;
+				if (value[index] === "\"") {
+					index++;
+					while (index < value.length && value[index] !== "\"") {
+						if (value[index] === "\\" && index + 1 < value.length) {
+							parameter += value[index + 1];
+							index += 2;
+							continue;
+						}
+						parameter += value[index];
+						index++;
+					}
+					index++;
+				} else {
+					const start = index;
+					while (index < value.length && value[index] !== ";" && value[index] !== ",") index++;
+					parameter = value.slice(start, index).trim();
+				}
+			}
+			if (name === "rel" && !seenRel) {
+				seenRel = true;
+				for (const rel of parameter.split(/\s+/)) if (rel !== "") rels.push(rel.toLowerCase());
+			}
+			if (name === "anchor") anchored = true;
+		}
+		links.push({
+			target,
+			rels,
+			anchored
+		});
+	}
+	return links;
+};
+const httpURL = (target, baseURL) => resolveHTTPURL(target, baseURL);
+/**
+* A successor is only followed as far as *naming* it, and only when it lands
+* on the API this client is configured against.
+*
+* Two different URLs are in play and conflating them is a real exposure. The
+* *context* is the URL the response actually came from, which is what RFC 8288
+* §3.1 resolves a relative target against — and after a redirect that is not
+* the URL we asked for. The *origin allowlist* is the client's configured
+* `baseURL`, and it stays the allowlist precisely because a redirected
+* response must not be able to nominate itself: resolving against the context
+* but validating against `baseURL` is what stops a cross-origin hop from
+* emitting a relative link that lands back on our origin and passes the check.
+*/
+const sameOriginURL = (target, contextURL, baseURL) => {
+	const url = httpURL(target, contextURL);
+	if (url === null) return null;
+	const base = httpURL(baseURL, baseURL);
+	return base !== null && url.origin === base.origin ? url : null;
+};
+/**
+* The notice a response carries, or `null` when it carries none. The
+* `Deprecation` field's *presence* is what marks the operation deprecated;
+* `Sunset` and `Link` only enrich the message.
+*
+* `contextURL` is the response's own URL (post-redirect), the context RFC 8288
+* resolves relative link targets against; `baseURL` is the configured API
+* origin a successor must land on.
+*/
+const parseDeprecation = (headers, contextURL, baseURL) => {
+	const deprecation = readField(headers, "deprecation");
+	if (deprecation === null) return null;
+	const sunset = readField(headers, "sunset");
+	const link = readField(headers, "link");
+	const links = link === null ? [] : parseLinkField(link);
+	const targetFor = (rel) => links.find((candidate) => !candidate.anchored && candidate.rels.includes(rel))?.target ?? null;
+	const documentation = targetFor("deprecation");
+	const successor = targetFor("successor-version");
+	return {
+		deprecatedAt: parseStructuredDate(deprecation),
+		sunsetAt: sunset === null ? null : parseHttpDate(sunset),
+		documentation: documentation === null ? null : httpURL(documentation, contextURL)?.href ?? null,
+		successor: successor === null ? null : sameOriginURL(successor, contextURL, baseURL)
+	};
+};
+const pathSegments = (path) => (path.split(/[?#]/, 1)[0] ?? "").split("/").filter((segment) => segment !== "");
+/**
+* Template segments, keyed by descriptor so the cache holds only entries the
+* operations table (or a test's stand-in for it) is still keeping alive. The
+* table is module-level and immutable, so every logical call re-split the same
+* 104 templates for nothing once the match became unconditional.
+*/
+const templateSegments = /* @__PURE__ */ new WeakMap();
+const segmentsOf = (operation) => {
+	const cached = templateSegments.get(operation);
+	if (cached !== void 0) return cached;
+	const segments = pathSegments(operation.path);
+	templateSegments.set(operation, segments);
+	return segments;
+};
+const isTemplateParam = (segment) => segment.startsWith("{") && segment.endsWith("}");
+/**
+* The operation a dispatched request belongs to, recovered from the path it
+* went out on. Path parameters are percent-encoded on the way out
+* (`encodeURIPath`), which encodes `/` and leaves the unreserved characters
+* every literal template segment is made of — so a substituted path has the
+* same segment count as its template and its literal segments compare byte for
+* byte.
+*
+* Where a parameterized template and a literal one overlap
+* (`/toolkits/{slug}` against `/toolkits/categories`) the literal wins, which
+* is the same most-specific-first rule the server routes by.
+*
+* **Known limit of recovering identity from the path.** Two accessors can emit
+* byte-identical requests — `client.toolkits.retrieve('categories')` and
+* `client.toolkits.retrieveCategories()` both dispatch
+* `GET /api/v3.1/toolkits/categories` — so nothing observable distinguishes
+* them here and the literal sibling is always the one named. The warning text
+* can therefore name the sibling rather than the accessor the caller wrote,
+* and the warn-once record is charged to that same sibling. This is
+* inherent to reverse-matching, not a bug in the matcher: the only fix is to
+* thread operation identity through dispatch, which this design deliberately
+* declined (wayfinder ticket 34). The affected pairs are few and the
+* consequence is a misnamed advisory, never a wrong call.
+*/
+const matchOperation = (method, path, operations) => {
+	const segments = pathSegments(path);
+	let best = null;
+	let bestLiterals = -1;
+	for (const operation of operations) {
+		if (operation.method !== method) continue;
+		const template = segmentsOf(operation);
+		if (template.length !== segments.length) continue;
+		let literals = 0;
+		let matched = true;
+		for (const [index, part] of template.entries()) {
+			if (isTemplateParam(part)) continue;
+			if (part !== segments[index]) {
+				matched = false;
+				break;
+			}
+			literals++;
+		}
+		if (matched && literals > bestLiterals) {
+			best = operation;
+			bestLiterals = literals;
+		}
+	}
+	return best;
+};
+/**
+* The client chain a successor URL names, under the *same* HTTP method.
+*
+* RFC 5829's `successor-version` points at a resource, and an earlier revision
+* of this code fell back to any unambiguous match under a different method
+* when the same one missed. That was wrong in a way that matters: it could
+* answer a deprecated `GET` with "use `client.<resource>.create` instead", telling the
+* caller to replace a read with a write. A successor named under a different
+* method is not a successor for *this* operation, so it is left unnamed and
+* the raw URL is printed instead — accurate and unhelpful beats confident and
+* wrong.
+*/
+const matchSuccessorChain = (method, successor, operations) => matchOperation(method, successor.pathname, operations)?.chain ?? null;
+const chainLabel = (chain) => `\`client.${chain.join(".")}\``;
+const formatDeprecationWarning = (subject, notice, successorChain) => {
+	const parts = [`Composio: ${subject} is deprecated.`];
+	if (notice.deprecatedAt !== null) parts.push(`Announced ${notice.deprecatedAt.toISOString()}.`);
+	if (notice.sunsetAt !== null) parts.push(`Scheduled for removal on ${notice.sunsetAt.toISOString()}.`);
+	if (successorChain !== null) parts.push(`Use ${chainLabel(successorChain)} instead.`);
+	else if (notice.successor !== null) parts.push(`Successor: ${notice.successor.href}.`);
+	if (notice.documentation !== null) parts.push(`See ${notice.documentation}`);
+	return parts.join(" ");
+};
+/**
+* NUL joins the halves of a warn-once key. Neither a client chain nor a URL
+* the WHATWG parser produced can carry one, so no pair of distinct components
+* can collide by concatenation.
+*/
+const KEY_SEPARATOR = "\0";
+/**
+* What makes one notice *distinct* from another, for the warn-once record.
+*
+* Derived from the parsed fields rather than the raw header bytes on purpose:
+* a requoted `Link` or a stray space around `Deprecation` reads as the same
+* notice and must not warn a second time. The three fields here are the ones a
+* caller acts on — when the deprecation was announced, when the operation
+* stops being served, and what replaces it. `documentation` is deliberately
+* excluded: it points at prose *about* this notice, so the platform moving its
+* developer notes to another URL is not news worth repeating a warning for.
+*/
+const noticeKey = (notice) => [
+	notice.deprecatedAt?.getTime() ?? "",
+	notice.sunsetAt?.getTime() ?? "",
+	notice.successor?.href ?? ""
+].join(KEY_SEPARATOR);
+/**
+* The interceptor itself: at most one warning per distinct notice per
+* deprecated operation per client instance.
+*
+* It sits at the single response exit in `makeRequest`, after the retry
+* decision has settled, so a response that is about to be discarded and
+* retried never warns and a logical call warns at most once however the caller
+* consumes it — `APIPromise` awaits one `makeRequest` per call and hands the
+* same `Response` to `asResponse()`, `withResponse()` and the parsed path
+* alike.
+*/
+const inspectDeprecation = ({ response, method, path, baseURL, operations, seen, warn }) => {
+	const notice = parseDeprecation(response.headers, response.url || baseURL, baseURL);
+	if (notice === null) return;
+	const operation = matchOperation(method, path, operations);
+	const key = `${operation === null ? `${method} ${pathSegments(path).join("/")}` : operation.chain.join(".")}${KEY_SEPARATOR}${noticeKey(notice)}`;
+	if (seen.has(key)) return;
+	if (seen.size >= MAX_TRACKED_NOTICES) return;
+	seen.add(key);
+	const successorChain = notice.successor === null ? null : matchSuccessorChain(method, notice.successor, operations);
+	const subject = operation === null ? `${method.toUpperCase()} ${path}` : chainLabel(operation.chain);
+	warn(formatDeprecationWarning(subject, notice, successorChain));
+};
+/**
+* The keys a value map will actually carry on the wire. Both serializers drop
+* an entry whose value is `undefined` outright — `JSON.stringify` for a body
+* property, `stringifyQuery` for a query entry — while `null` is sent (JSON
+* `null`, or `key=`), so only `undefined` reads as "not sent". `bodyKeys`
+* relies on the same rule for its half of the surface.
+*/
+const presentKeys = (values) => new Set(Object.entries(values).filter(([, value]) => value !== void 0).map(([key]) => key));
+/**
+* The keys `body` will actually carry on the wire, at its top level, when it
+* is a plain object — `presentKeys` over it, narrowed to objects: a resource
+* method always passes an object (even an omitted optional body arrives as
+* `{}`), so this covers every real call; a non-object `body` (the raw escape
+* hatch dispatching something else entirely) has no top-level keys to check.
+*/
+const bodyKeys = (body) => typeof body === "object" && body !== null && !Array.isArray(body) ? presentKeys(body) : /* @__PURE__ */ new Set();
+/**
+* The static parameter-level warning: fires when the client sends an input
+* the committed spec marks `deprecated: true`, decided entirely from the
+* request the caller is about to send. Unlike `inspectDeprecation`, this
+* needs no response — it runs before dispatch, so a connection failure never
+* swallows it.
+*
+* One notice per (operation, sorted set of deprecated wire names present) per
+* client instance, but every input in that set is named in its own `warn`
+* call — the once-only key only suppresses an exact-repeat call, it does not
+* collapse several inputs on one call into a single message.
+*/
+const inspectDeprecatedInputs = ({ operation, query, body, headers, table, seen, warn }) => {
+	if (operation === null) return;
+	const declared = table.get(operation.chain.join("."));
+	if (declared === void 0 || declared.length === 0) return;
+	const queryKeys = presentKeys(query);
+	const bodyKeySet = bodyKeys(body);
+	const present = declared.filter((input) => {
+		if (input.in === "query") return queryKeys.has(input.wire);
+		if (input.in === "body") return bodyKeySet.has(input.wire);
+		return headers.has(input.wire);
+	});
+	if (present.length === 0) return;
+	const wireSet = [...new Set(present.map((input) => input.wire))].sort();
+	const key = `param${KEY_SEPARATOR}${operation.chain.join(".")}${KEY_SEPARATOR}${wireSet.join(",")}`;
+	if (seen.has(key)) return;
+	if (seen.size >= MAX_TRACKED_NOTICES) return;
+	seen.add(key);
+	const subject = chainLabel(operation.chain);
+	for (const input of present) {
+		const clause = input.replacementWire === null ? "" : ` Use \`${input.replacementWire}\` instead.`;
+		warn(`Composio: the \`${input.wire}\` parameter of ${subject} is deprecated.${clause}`);
+	}
+};
+
+//#endregion
+//#region src/compat/request.ts
+/** A request label safe to print: dynamic path values and URL secrets are excluded. */
+const printableURL = (url, operation) => `${new URL(url).origin}${operation?.path ?? "/<custom>"}`;
+const emitLog = (config, level, message, metadata) => {
+	try {
+		config.onLog?.(level, message, metadata);
+	} catch {}
+};
+const monotonicMillis = () => globalThis.performance?.now?.() ?? Date.now();
+const elapsedMillis = (startedAt) => Math.max(0, monotonicMillis() - startedAt);
+/**
+* Percent-encode everything that isn't a RFC-3986 pchar, leaving safe chars
+* (unreserved / sub-delims / ":" / "@") readable.
+*/
+const encodeURIPath = (str) => str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+/**
+* Template tag interpolating path params percent-encoded, rejecting values
+* that would introduce `.` / `..` (or percent-encoded variants) path segments.
+*/
+const path = (statics, ...params) => {
+	let result = statics[0] ?? "";
+	params.forEach((param, index) => {
+		result += encodeURIPath(String(param)) + (statics[index + 1] ?? "");
+	});
+	const pathOnly = result.split(/[?#]/, 1)[0] ?? "";
+	if (/(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/i.test(pathOnly)) throw new ComposioError(`Path parameters result in path with invalid segments: ${result}`);
+	return result;
+};
+/**
+* Stainless-flavored query serialization: `arrayFormat: 'comma'` (arrays become
+* one comma-joined param), `undefined` entries dropped, `null` entries kept as
+* empty values, and plain-object values expanded qs-style into bracket
+* notation (`toolkit_versions[github]=v1`, the whole key percent-encoded) —
+* pinned differentially against Stainless via `tools.retrieve`'s object
+* `toolkit_versions` param (wayfinder ticket 23).
+*/
+const stringifyQuery = (query) => {
+	const parts = [];
+	const append = (key, value) => {
+		if (value === void 0) return;
+		if (value === null) {
+			parts.push(`${encodeURIComponent(key)}=`);
+			return;
+		}
+		if (Array.isArray(value)) {
+			parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.join(","))}`);
+			return;
+		}
+		if (typeof value === "object") {
+			for (const [subKey, subValue] of Object.entries(value)) append(`${key}[${subKey}]`, subValue);
+			return;
+		}
+		parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+	};
+	for (const [key, value] of Object.entries(query)) append(key, value);
+	return parts.join("&");
+};
+const buildURL = (config, options) => {
+	const base = config.baseURL;
+	const joined = base.endsWith("/") && options.path.startsWith("/") ? options.path.slice(1) : options.path;
+	const url = new URL(base + joined);
+	const query = {
+		...Object.fromEntries(url.searchParams),
+		...config.defaultQuery,
+		...options.query
+	};
+	const search = stringifyQuery(query);
+	if (search) url.search = search;
+	return {
+		url: url.toString(),
+		query
+	};
+};
+/**
+* JSON body encoding. A resource method always passes the `body` key when its
+* operation defines a request body — even an omitted optional body arrives as
+* `{}` — so `Content-Type: application/json` is kept for those; operations
+* with no body at all (GET/DELETE) send neither body nor content-type.
+*/
+const buildBody = (options) => {
+	if (!("body" in options) || options.body === void 0) return {
+		body: void 0,
+		bodyHeaders: void 0
+	};
+	return {
+		body: JSON.stringify(options.body),
+		bodyHeaders: { "content-type": "application/json" }
+	};
+};
+const safeJSON = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+};
+const castToError = (err) => {
+	if (err instanceof Error) return err;
+	if (typeof err === "object" && err !== null) try {
+		return new Error(JSON.stringify(err));
+	} catch {}
+	return new Error(String(err));
+};
+const validatePositiveInteger = (name, value) => {
+	if (!Number.isInteger(value)) throw new ComposioError(`${name} must be an integer`);
+	if (value < 0) throw new ComposioError(`${name} must be a positive integer`);
+};
+const RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	409,
+	429
+]);
+const shouldRetryResponse = (response) => {
+	const explicit = response.headers.get("x-should-retry");
+	if (explicit === "true") return true;
+	if (explicit === "false") return false;
+	return RETRYABLE_STATUSES.has(response.status) || response.status >= 500;
+};
+/**
+* Ceiling for server-supplied retry delays. A `retry-after(-ms)` value is
+* honored only when `0 <= ms < 60_000`; anything negative, non-finite, or a
+* minute and beyond falls back to exponential backoff instead of collapsing
+* the backoff to zero or stalling the caller for the server's whim.
+*/
+const MAX_RETRY_AFTER_MILLIS = 6e4;
+/**
+* How long to wait before retry number `numRetries + 1`: `retry-after-ms`
+* (milliseconds), then `retry-after` (seconds or HTTP date), then exponential
+* backoff `min(0.5s · 2^n, 8s)` with up to 25% downward jitter. A
+* header-derived delay is used only when it is finite and within
+* `[0, MAX_RETRY_AFTER_MILLIS)`; out-of-range values fall through to the
+* backoff.
+*/
+const retryDelayMillis = (numRetries, headers) => {
+	let headerDelayMillis;
+	const retryAfterMs = parseFloat(headers?.get("retry-after-ms") ?? "");
+	if (!Number.isNaN(retryAfterMs)) headerDelayMillis = retryAfterMs;
+	else {
+		const retryAfter = headers?.get("retry-after");
+		if (retryAfter) {
+			const seconds = parseFloat(retryAfter);
+			if (!Number.isNaN(seconds)) headerDelayMillis = seconds * 1e3;
+			else {
+				const untilDate = Date.parse(retryAfter) - Date.now();
+				if (!Number.isNaN(untilDate)) headerDelayMillis = untilDate;
+			}
+		}
+	}
+	if (headerDelayMillis !== void 0 && headerDelayMillis >= 0 && headerDelayMillis < MAX_RETRY_AFTER_MILLIS) return headerDelayMillis;
+	return Math.min(.5 * 2 ** numRetries, 8) * (1 - Math.random() * .25) * 1e3;
+};
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+/**
+* How many hops one attempt will follow before giving up. Twenty is what the
+* Fetch spec budgets and what undici and every browser enforce, so a chain this
+* kernel refuses is one the platform would have refused too.
+*/
+const MAX_REDIRECTS = 20;
+const TOO_MANY_REDIRECTS = `The API redirected more than ${MAX_REDIRECTS} times; the chain was abandoned.`;
+/**
+* The one environment-dependent behavior in the kernel, stated rather than
+* degraded into — and narrowed to the case where safety cannot be proved.
+*
+* Following redirects by hand requires reading the `Location` off a 3xx, and
+* only a runtime that hands back the real response can offer that — Node,
+* Deno and Bun do. A **browser** answers `redirect: 'manual'` with a *filtered*
+* response (`type: 'opaqueredirect'`, status 0, no headers), so there is
+* nothing to read and manual following is not implementable there.
+*
+* Dispatching at `redirect: 'follow'` instead is exactly what this module
+* exists to prevent *when a credential is attached*: the Fetch spec deletes
+* only `Authorization` across a cross-origin redirect, so a custom `x-api-key`
+* rides along, and an attacker-controlled origin that answers the preflight
+* with a permissive `Access-Control-Allow-Headers` harvests it. (CORS bounds
+* that — any request carrying `x-api-key` is preflighted, so the third party
+* has to cooperate — but bounded is not prevented.)
+*
+* When *nothing* credential-bearing is going out that reasoning has no
+* premise, so the first dispatch of such a chain is delegated (see
+* `carriesCredentials`) and a browser follows it normally. That is where
+* real-world redirects on this API actually live: an escape-hatch fetch of a
+* presigned storage URL, which rule 2 has already stripped our key from, and
+* which S3 and GCS commonly answer with a 302.
+*
+* What is left is a *credentialed* request that redirects in a browser. It
+* gets a named error rather than a silent leak — and on this API that is very
+* nearly unreachable: the only redirects the platform serves are same-origin
+* edge normalizations (wayfinder ticket 40 records the recon), and `buildURL`
+* cannot construct a URL that triggers one.
+*/
+const OPAQUE_REDIRECT = "The API responded with a redirect that this runtime will not let the client read (an opaque redirect, in a browser). Redirects are followed only where the response can be inspected, because a credential must never cross an origin change.";
+const isOpaqueRedirect = (response) => response.type === "opaqueredirect";
+/**
+* The `Location` a hop points at, resolved against the URL it arrived on, or
+* `null` when there is nothing followable there — unparseable, or a scheme
+* this client does not speak (`data:`, `file:`, an app link). `null` hands the
+* 3xx back as the response it is, which is what `fetch` does with a `Location`
+* it cannot use.
+*/
+const resolveLocation = (location, from) => resolveHTTPURL(location, from);
+/**
+* Fetch's own method rewrite (§4.4 "HTTP-redirect fetch", step 13): a 303
+* turns any non-GET into a GET, and a 301/302 does the same to a POST — both
+* dropping the body. 307 and 308 preserve the method and the body, which is
+* what they exist for. Following by hand means reproducing this, or a caller's
+* POST silently becomes a POST to somewhere it was never sent before.
+*/
+const rewriteForRedirect = (status, method) => status === 303 && method !== "GET" && method !== "HEAD" || (status === 301 || status === 302) && method === "POST";
+const sleep = (ms, signal) => {
+	if (signal?.aborted) return Promise.reject(new APIUserAbortError());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new APIUserAbortError());
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+};
+/**
+* Indirection over `sleep` so kernel tests can capture retry delays instead
+* of waiting them out on the wall clock. Internal seam only — deliberately
+* not re-exported from `compat/index.ts`, so the public package surface is
+* unchanged.
+*/
+const kernelInternals = { sleep };
+/**
+* The headers for one hop, built fresh from the URL that hop is going to.
+*
+* This is where rule 3 mostly stops needing machinery of its own: the
+* credential is re-derived per hop from the *request* URL rather than carried
+* along from the last one, so a hop that leaves the configured API origin
+* simply does not get a key. `withdrawn` covers what that cannot — the
+* caller's own credential headers, which are legitimate on the URL the caller
+* chose and are dropped once the *server* has chosen one.
+*/
+const buildRequestHeaders = (config, options, requestURL, bodyHeaders, withdrawn, scheme, callerPlaced) => {
+	const credential = withdrawn || callerPlaced ? null : credentialForRequest(config.baseURL, scheme, config.credentials, requestURL);
+	const headers = buildHeaders([
+		{
+			accept: "application/json",
+			"user-agent": config.userAgent
+		},
+		credential === null ? void 0 : { [credential.name]: credential.value },
+		config.defaultHeaders,
+		bodyHeaders,
+		options.headers
+	]);
+	if (withdrawn) withdrawCredentials(headers);
+	return headers;
+};
+/**
+* The credential class this logical request authenticates with, decided once
+* from the operation the *caller* invoked.
+*
+* Deliberately not re-derived per redirect hop. A hop's URL was chosen by the
+* server, so matching it back to a template would let the server's choice
+* change which of the caller's credentials goes out; the operation the caller
+* asked for is the honest answer for the whole chain, and rule 3 already
+* withdraws everything once a hop leaves the origin.
+*
+* `operation` is the match `makeRequest` already computed for the static
+* deprecated-input check, threaded in rather than re-derived: the two
+* features need the same fact, so `matchOperation` runs once per logical call
+* regardless of which of them a given client configuration actually uses.
+* With only `apiKey` set the scheme answer is still `ApiKeyAuth` down every
+* branch of {@link selectScheme}, so an existing caller's requests stay
+* byte-identical by construction; what changed is that the match itself is no
+* longer skippable, because the deprecated-input warning needs it too.
+*/
+const schemeForRequest = (config, operation) => {
+	if (!hasAlternateCredential(config.credentials)) return "ApiKeyAuth";
+	return selectScheme(operation?.schemes, config.credentials);
+};
+/**
+* One attempt: the request, plus however many redirects it takes to land on a
+* non-3xx response.
+*
+* The whole chain sits **inside one attempt** — one entry in the retry budget,
+* one per-attempt timeout covering every hop. Both follow from what a redirect
+* is: the caller made one logical request, so a chain must not consume
+* `maxRetries` (a 3xx is not a failure to retry) and must not be able to
+* multiply the caller's time budget by the hop limit. A retry re-issues the
+* *original* request, chain and all.
+*
+* Everything the server chose is re-derived rather than carried: the headers
+* (see `buildRequestHeaders`), the method and body (fetch's own 301/302/303
+* rewrite), and the query, which is left to the `Location` URL because the
+* server picked it. `config.defaultQuery` is applied to the URL the caller
+* asked for, not to the one it was sent to.
+*/
+const dispatchWithRedirects = async (config, options, initialURL, initialBody, initialBodyHeaders, signal, scheme) => {
+	let url = initialURL;
+	let method = options.method.toUpperCase();
+	let body = initialBody;
+	let bodyHeaders = initialBodyHeaders;
+	let withdrawn = false;
+	const callerPlaced = callerPlacedCredential([config.defaultHeaders, options.headers]);
+	for (let hop = 0;; hop++) {
+		const headers = buildRequestHeaders(config, options, url, bodyHeaders, withdrawn, scheme, callerPlaced);
+		const delegated = hop === 0 && !carriesCredentials(headers);
+		const response = await config.fetch.call(void 0, url, {
+			method,
+			headers,
+			...body !== void 0 ? { body } : {},
+			...config.fetchOptions,
+			...options.fetchOptions,
+			redirect: delegated ? "follow" : "manual",
+			signal
+		});
+		if (delegated) return response;
+		if (isOpaqueRedirect(response)) throw new APIConnectionError({ message: OPAQUE_REDIRECT });
+		if (!REDIRECT_STATUSES.has(response.status)) return response;
+		const location = response.headers.get("location");
+		if (location === null) return response;
+		const target = resolveLocation(location, url);
+		if (target === null) return response;
+		if (hop >= MAX_REDIRECTS) throw new APIConnectionError({ message: TOO_MANY_REDIRECTS });
+		response.body?.cancel().catch(() => void 0);
+		if (target.origin !== new URL(url).origin) withdrawn = true;
+		if (rewriteForRedirect(response.status, method)) {
+			method = "GET";
+			body = void 0;
+			bodyHeaders = void 0;
+		}
+		url = target.href;
+	}
+};
+/**
+* The dispatch kernel: one attempt loop with Stainless runtime semantics —
+* per-attempt timeouts (timeouts and connection errors are retried, like
+* HTTP-level 408/409/429/5xx and `x-should-retry`), `retry-after(-ms)`
+* honored, abort → `APIUserAbortError`. Resolves with the raw un-consumed
+* `Response` regardless of HTTP status; body parsing and error mapping are
+* strictly deferred to `APIPromise`.
+*
+* Redirects are followed inside an attempt by `dispatchWithRedirects`, so the
+* single response exit below still fires `onResponse` **once per logical
+* call** rather than once per hop — the once-per-call guarantee ticket 34
+* built the deprecation interceptor on. The `Response` handed back is the
+* final hop's, so `response.url` is still "the URL this response came from",
+* which is what `deprecation.ts` resolves relative `Link` targets against.
+*/
+async function makeRequest(config, options) {
+	if (options.timeout !== void 0) validatePositiveInteger("timeout", options.timeout);
+	const maxRetries = options.maxRetries ?? config.maxRetries;
+	validatePositiveInteger("maxRetries", maxRetries);
+	const timeout = options.timeout ?? config.timeout;
+	const { url, query } = buildURL(config, options);
+	const { body, bodyHeaders } = buildBody(options);
+	const userSignal = options.signal ?? void 0;
+	const method = options.method.toUpperCase();
+	const operation = matchOperation(options.method, options.path, config.operations ?? []);
+	const requestLog = config.onLog === void 0 ? void 0 : {
+		method,
+		url: printableURL(url, operation),
+		maxAttempts: maxRetries + 1
+	};
+	const scheme = schemeForRequest(config, operation);
+	config.onRequest?.(operation, query, options.body, buildHeaders([config.defaultHeaders, options.headers]));
+	for (let numRetries = 0;; numRetries++) {
+		if (userSignal?.aborted) throw new APIUserAbortError();
+		const attempt = numRetries + 1;
+		const retriesRemaining = maxRetries - numRetries;
+		const startedAt = requestLog === void 0 ? 0 : monotonicMillis();
+		const attemptLog = requestLog === void 0 ? void 0 : {
+			...requestLog,
+			attempt
+		};
+		if (attemptLog !== void 0) emitLog(config, "debug", "Sending request", attemptLog);
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		userSignal?.addEventListener("abort", abort, { once: true });
+		const timer = setTimeout(abort, timeout);
+		let result;
+		try {
+			result = await dispatchWithRedirects(config, options, url, body, bodyHeaders, controller.signal, scheme);
+		} catch (cause) {
+			if (cause instanceof ComposioError) {
+				if (attemptLog !== void 0) emitLog(config, "info", "Request failed", {
+					...attemptLog,
+					durationMs: elapsedMillis(startedAt),
+					errorType: cause.constructor.name
+				});
+				throw cause;
+			}
+			result = castToError(cause);
+		} finally {
+			clearTimeout(timer);
+			userSignal?.removeEventListener("abort", abort);
+		}
+		if (result instanceof Error) {
+			if (userSignal?.aborted) {
+				if (attemptLog !== void 0) emitLog(config, "info", "Request failed", {
+					...attemptLog,
+					durationMs: elapsedMillis(startedAt),
+					errorType: APIUserAbortError.name
+				});
+				throw new APIUserAbortError();
+			}
+			const isTimeout = controller.signal.aborted || /timed? ?out/i.test(String(result) + ("cause" in result ? String(result.cause) : ""));
+			const errorType = isTimeout ? APIConnectionTimeoutError.name : APIConnectionError.name;
+			if (attemptLog !== void 0) emitLog(config, "info", "Request failed", {
+				...attemptLog,
+				durationMs: elapsedMillis(startedAt),
+				errorType
+			});
+			if (retriesRemaining > 0) {
+				const delayMs = retryDelayMillis(numRetries);
+				if (attemptLog !== void 0) emitLog(config, "info", "Retrying request", {
+					...attemptLog,
+					nextAttempt: attempt + 1,
+					retriesRemaining,
+					delayMs,
+					reason: isTimeout ? "timeout" : "transport"
+				});
+				await kernelInternals.sleep(delayMs, userSignal);
+				continue;
+			}
+			if (isTimeout) throw new APIConnectionTimeoutError();
+			throw new APIConnectionError({ cause: result });
+		}
+		if (attemptLog !== void 0) emitLog(config, "info", "Received response", {
+			...attemptLog,
+			status: result.status,
+			outcome: result.ok ? "success" : "http_error",
+			durationMs: elapsedMillis(startedAt)
+		});
+		if (!result.ok && retriesRemaining > 0 && shouldRetryResponse(result)) {
+			result.body?.cancel().catch(() => void 0);
+			const delayMs = retryDelayMillis(numRetries, result.headers);
+			if (attemptLog !== void 0) emitLog(config, "info", "Retrying request", {
+				...attemptLog,
+				nextAttempt: attempt + 1,
+				retriesRemaining,
+				delayMs,
+				reason: "response",
+				status: result.status
+			});
+			await kernelInternals.sleep(delayMs, userSignal);
+			continue;
+		}
+		if (config.onResponse !== void 0) try {
+			config.onResponse(result, options);
+		} catch {}
+		return result;
+	}
+}
+
+//#endregion
+export { InternalServerError as _, inspectDeprecatedInputs as a, RateLimitError as b, mergeHeaders as c, APIError as d, APIUserAbortError as f, ConflictError as g, ComposioError as h, safeJSON as i, APIConnectionError as l, BadRequestError as m, makeRequest as n, inspectDeprecation as o, AuthenticationError as p, path as r, assertCredentialTransport as s, castToError as t, APIConnectionTimeoutError as u, NotFoundError as v, UnprocessableEntityError as x, PermissionDeniedError as y };