@composio/client 2.0.0-rc.18 → 2.0.0-rc.19

package/dist/{generated-operations-DKgGT6Dg.mjs → generated-operations-Dv7pAKDT.mjs}

@@ -86,43 +86,12 @@ const SCHEME_HEADERS = {
 /** The scheme a request authenticates with when its operation names none. */
 const DEFAULT_SCHEME = "ApiKeyAuth";
 /**
-* Which credential a request declaring `schemes` should carry, for a client in
-* `auto` mode holding the schemes `held` answers `true` for. A fixed mode never
-* asks: it always sends its own.
-*
-* **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 is the one every release before `rc.18` applied:
-*
-* 1. **`ApiKeyAuth` wins wherever the operation accepts it** and a project key
-*    is held.
-* 2. Otherwise the first scheme the operation names that this client both
-*    recognizes *and* holds a credential for. That is what makes the
-*    `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.
-*
-* 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`, 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.
+* `Auth.auto`'s choice for an operation declaring `schemes`: `ApiKeyAuth`
+* wherever the operation accepts it and a project key is held, else the first
+* declared scheme that is held, else `ApiKeyAuth`. An undeclared scheme name
+* (`no_auth`, `workbench_access_key`) falls through to `ApiKeyAuth`, as every
+* release before rc.18 sent. A request may carry only one credential: the API
+* answers two with a 401.
 */
 const selectScheme = (schemes, held) => {
 	if (schemes === void 0 || schemes.length === 0) return DEFAULT_SCHEME;
@@ -134,9 +103,6 @@ const selectScheme = (schemes, held) => {
 	}
 	return DEFAULT_SCHEME;
 };
-/** The header `scheme` is sent as. */
-const schemeHeader = (scheme) => SCHEME_HEADERS[scheme];
-/** The scheme a credential header name belongs to, or `undefined` for any other name. */
 const schemeOfHeader = (name) => Object.keys(SCHEME_HEADERS).find((scheme) => SCHEME_HEADERS[scheme] === name);
 /**
 * What counts as loopback, pinned rather than assumed. `localhost` is not the
@@ -191,7 +157,7 @@ const resolveHTTPURL = (target, base) => {
 /** Whether a credential may be sent to this origin at all. */
 const isCredentialSafeOrigin = (url, allowedHTTPOrigin = null) => url.protocol === "https:" || url.protocol === "http:" && (isLoopbackHostname(url.hostname) || allowedHTTPOrigin !== null && url.origin === allowedHTTPOrigin);
 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. By default, plain http:// is permitted only for loopback development endpoints (${LOOPBACK_DESCRIPTION}). Pass an https:// baseURL, use environment: 'local', set allowInsecureHTTP: true (or COMPOSIO_ALLOW_INSECURE_HTTP=1) for the configured development origin, or construct the client without credentials.`;
+const insecureOriginMessage = (baseURL) => `Refusing to send a Composio API credential to ${baseURL}: a credentialed API origin must use HTTPS. By default, plain http:// is permitted only for loopback development endpoints (${LOOPBACK_DESCRIPTION}). Pass an https:// or loopback baseURL, set allowInsecureHTTP: true (or COMPOSIO_ALLOW_INSECURE_HTTP=1) for the configured development origin, or construct the client without 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
@@ -317,18 +283,7 @@ const carriesCredentials = (headers) => CREDENTIAL_HEADERS.some((name) => header
 
 //#endregion
 //#region src/compat/auth.ts
-/**
-* Who a client authenticates as (`Auth`) and which organization or project it
-* addresses (`Scope`).
-*
-* A request carries zero or one Composio credential. A fixed mode sends that
-* credential class on every request to the API origin and never consults the
-* operation table; `auto` picks one configured credential from the operation's
-* declared schemes, which is how `rc.17` and earlier chose. `none` sends no
-* credential, and leaves the credential header names to the caller.
-*/
 const NONE = Object.freeze({ mode: "none" });
-/** The constructors, typed for one entry's credential. Every entry's behave the same. */
 const authConstructors = () => Object.freeze({
 	none: () => NONE,
 	project: (credential) => Object.freeze({
@@ -348,176 +303,164 @@ const authConstructors = () => Object.freeze({
 		credentials: Object.freeze({ ...credentials })
 	})
 });
-/** The constructors of {@link Auth}: `Auth.project(key)`, `Auth.user(key)`, `Auth.organization(key)`, `Auth.auto({ ... })`, `Auth.none()`. */
 const Auth = authConstructors();
-/**
-* The rule `fromEnv` and the Effect `layerConfig` share: one credential given
-* is that fixed mode, several is `auto` over them, none is `none`. Generic over
-* what a credential is, so the Effect entry keeps its `Redacted` values.
-*/
-const authFromCredentials = (credentials) => {
-	const given = [
-		"project",
-		"user",
-		"organization"
-	].filter((key) => credentials[key] !== void 0);
-	if (given.length === 0) return NONE;
-	if (given.length > 1) return authConstructors().auto(Object.fromEntries(given.map((key) => [key, credentials[key]])));
-	const [only] = given;
-	return authConstructors()[only](credentials[only]);
-};
-const MODE_SCHEME = {
+const FIXED_MODES = [
+	"project",
+	"user",
+	"organization"
+];
+const SCHEME_OF_MODE = {
 	project: "ApiKeyAuth",
 	user: "UserApiKeyAuth",
 	organization: "OrgApiKeyAuth"
 };
-/** The scheme each credential class authenticates with, keyed by mode. */
-const schemeOfMode = (mode) => MODE_SCHEME[mode];
+const isFixedMode = (mode) => FIXED_MODES.includes(mode);
+/** One credential is that fixed mode, several is `auto`, none is `none`. Shared by `fromEnv` and `layerConfig`. */
+const authFromCredentials = (credentials) => {
+	const auth = authConstructors();
+	const [first, ...rest] = FIXED_MODES.filter((mode) => credentials[mode] !== void 0);
+	if (first === void 0) return auth.none();
+	if (rest.length > 0) return auth.auto(credentials);
+	return auth[first](credentials[first]);
+};
+const isSendable = (value, name = "x-api-key") => {
+	try {
+		new globalThis.Headers().set(name, value);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const isUsableKey = (key) => typeof key === "string" && /\S/.test(key) && isSendable(key);
+const unusableKeyError = (source) => new ComposioError(`${source} is not a usable key: it must be a string with a non-whitespace character and no line break, NUL or character outside Latin-1.`);
+const holdCredential = (value, option, kind) => {
+	if (!kind.is(value)) throw new ComposioError(`\`${option}\` must be a key or a function that returns one.`);
+	const key = kind.keyOf(value);
+	if (key !== void 0 && !isUsableKey(key)) throw unusableKeyError(`\`${option}\``);
+	return value;
+};
+const holdAuto = (given, kind) => {
+	const credentials = {};
+	for (const mode of FIXED_MODES) {
+		const value = given?.[mode];
+		if (value !== void 0) credentials[SCHEME_OF_MODE[mode]] = holdCredential(value, `auth.credentials.${mode}`, kind);
+	}
+	if (Object.keys(credentials).length === 0) throw new ComposioError("`Auth.auto` needs at least one of `project`, `user` and `organization`.");
+	return credentials;
+};
 const MIGRATION = "Pass `auth`: `Auth.project(key)`, `Auth.user(key)`, `Auth.organization(key)`, `Auth.auto({ project, user, organization })` or `Auth.none()`.";
-/** The credential options `rc.18` removed, each with the `auth` that replaces it. */
+const resolveAuth = (auth, kind) => {
+	const value = auth;
+	const mode = value?.mode;
+	if (mode === void 0) throw new ComposioError(`\`auth\` is required. ${MIGRATION}`);
+	if (mode === "none") return {
+		mode,
+		credentials: {}
+	};
+	if (mode === "auto") return {
+		mode,
+		credentials: holdAuto(value?.credentials, kind)
+	};
+	if (!isFixedMode(mode)) throw new ComposioError(`\`auth.mode\` must be 'none', 'project', 'user', 'organization' or 'auto'. ${MIGRATION}`);
+	return {
+		mode,
+		credentials: { [SCHEME_OF_MODE[mode]]: holdCredential(value?.credential, "auth.credential", kind) }
+	};
+};
 const REMOVED_OPTIONS = {
 	apiKey: "Auth.project(key)",
 	userApiKey: "Auth.user(key)",
 	orgApiKey: "Auth.organization(key)"
 };
-/**
-* Refuses a removed credential option, which TypeScript already rejects, for
-* a caller it did not reach.
-*/
 const assertNoRemovedCredentialOptions = (options) => {
-	for (const [option, replacement] of Object.entries(REMOVED_OPTIONS)) if (Object.hasOwn(options, option)) throw new ComposioError(`The \`${option}\` option was removed in 2.0.0-rc.18. Pass \`auth: ${replacement}\` instead, or \`Auth.auto({ ... })\` for per-operation selection.`);
-};
-/**
-* Validates `auth` and lays it out by scheme. `isCredential` decides what a
-* credential may be on the calling entry; `checkKey` validates a key that is
-* already known, so a bad literal fails here rather than on the first request.
-*/
-const resolveAuth = (auth, isCredential, checkKey) => {
-	if (typeof auth !== "object" || auth === null || !("mode" in auth)) throw new ComposioError(`\`auth\` is required. ${MIGRATION}`);
-	const value = auth;
-	const held = (credential, option) => {
-		if (!isCredential(credential)) throw new ComposioError(`\`${option}\` must be a key or a function that returns one.`);
-		checkKey(credential, option);
-		return credential;
-	};
-	switch (value.mode) {
-		case "none": return {
-			mode: "none",
-			credentials: {}
-		};
-		case "project":
-		case "user":
-		case "organization": return {
-			mode: value.mode,
-			credentials: { [MODE_SCHEME[value.mode]]: held(value.credential, "auth.credential") }
-		};
-		case "auto": {
-			const given = value.credentials;
-			if (typeof given !== "object" || given === null) throw new ComposioError("`Auth.auto` needs at least one of `project`, `user` and `organization`.");
-			const credentials = {};
-			for (const [key, scheme] of Object.entries(MODE_SCHEME)) {
-				const credential = given[key];
-				if (credential !== void 0) credentials[scheme] = held(credential, `auth.credentials.${key}`);
-			}
-			if (Object.keys(credentials).length === 0) throw new ComposioError("`Auth.auto` needs at least one of `project`, `user` and `organization`.");
-			return {
-				mode: "auto",
-				credentials
-			};
-		}
-		default: throw new ComposioError(`\`auth.mode\` must be 'none', 'project', 'user', 'organization' or 'auto'. ${MIGRATION}`);
+	for (const [option, replacement] of Object.entries(REMOVED_OPTIONS)) {
+		if (!Object.hasOwn(options, option)) continue;
+		throw new ComposioError(`The \`${option}\` option was removed in 2.0.0-rc.18. Pass \`auth: ${replacement}\` instead, or \`Auth.auto({ ... })\` for per-operation selection.`);
 	}
 };
-/** Whether the platform's `Headers` takes `value` under `name`. Its refusal quotes the value, so it stays here. */
-const isSendable = (name, value) => {
-	try {
-		new globalThis.Headers().set(name, value);
-		return true;
-	} catch {
-		return false;
-	}
+const CREDENTIAL_HEADER_NAMES = Object.values(SCHEME_HEADERS);
+const SCOPE_HEADER_NAMES = ["x-org-id", "x-project-id"];
+const isScopeId = (value) => typeof value === "string" && value !== "" && value === value.trim() && isSendable(value, "x-org-id");
+const scopeId = (field, value) => {
+	if (value === void 0) return void 0;
+	if (!isScopeId(value)) throw new ComposioError(`\`scope.${field}\` must be a non-empty string with no surrounding whitespace.`);
+	return value;
 };
-/**
-* Whether `key` can be sent as `scheme`'s header: a string with a
-* non-whitespace character that the platform's `Headers` accepts. It is sent
-* as given.
-*/
-const isUsableKey = (scheme, key) => typeof key === "string" && /\S/.test(key) && isSendable(SCHEME_HEADERS[scheme], key);
-/** The error for a key that cannot be sent. It names where the key came from and never the key. */
-const unusableKeyError = (source) => new ComposioError(`${source} is not a usable key: it must be a string with a non-whitespace character and no line break, NUL or character outside Latin-1.`);
-const SCOPE_ID = /^\S(?:.*\S)?$/s;
-/** Validates `scope` (an id must be non-empty with no surrounding whitespace) and returns the headers it sends. */
 const resolveScope = (scope) => {
 	if (scope === void 0) return void 0;
 	if (typeof scope !== "object" || scope === null) throw new ComposioError("`scope` must be an object with an `organizationId`, a `projectId`, or both.");
 	const { organizationId, projectId } = scope;
-	if (organizationId === void 0 && projectId === void 0) throw new ComposioError("`scope` must name an `organizationId`, a `projectId`, or both.");
 	const headers = {};
-	for (const [field, header, value] of [[
-		"organizationId",
-		"x-org-id",
-		organizationId
-	], [
-		"projectId",
-		"x-project-id",
-		projectId
-	]]) {
-		if (value === void 0) continue;
-		if (typeof value !== "string" || !SCOPE_ID.test(value) || !isSendable(header, value)) throw new ComposioError(`\`scope.${field}\` must be a non-empty string with no surrounding whitespace.`);
-		headers[header] = value;
-	}
+	const org = scopeId("organizationId", organizationId);
+	const project = scopeId("projectId", projectId);
+	if (org !== void 0) headers["x-org-id"] = org;
+	if (project !== void 0) headers["x-project-id"] = project;
+	if (Object.keys(headers).length === 0) throw new ComposioError("`scope` must name an `organizationId`, a `projectId`, or both.");
 	return headers;
 };
-/** The header names `auth` owns while it is not `none`. */
-const CREDENTIAL_HEADER_NAMES = Object.values(SCHEME_HEADERS);
-/** The header names `scope` owns while it is set. */
-const SCOPE_HEADER_NAMES = ["x-org-id", "x-project-id"];
-/**
-* Fails a generated call whose operation requires an owned header parameter it
-* did not supply. It does not fall back to the configured `auth` or `scope`:
-* the operation asked for a value of its own.
-*/
 const assertRequiredOperationHeaders = (operation, supplied) => {
-	for (const name of operation?.requiredHeaders ?? []) if (supplied?.[name] == null) throw new ComposioError(`\`${operation?.chain.join(".")}\` requires the \`${name}\` parameter.`);
+	for (const name of operation?.requiredHeaders ?? []) {
+		if (supplied?.[name] != null) continue;
+		throw new ComposioError(`\`${operation?.chain.join(".")}\` requires the \`${name}\` parameter.`);
+	}
 };
-const chooseCredential = (auth, operation, supplied) => {
+const scopeForCall = (configured, supplied) => {
+	const merged = { ...configured };
+	for (const name of SCOPE_HEADER_NAMES) {
+		const value = supplied?.[name];
+		if (value == null) continue;
+		const current = configured?.[name];
+		if (current !== void 0 && current !== value) throw new ComposioError(`The \`${name}\` parameter disagrees with the client's \`scope\`. Derive a client with \`withOptions({ scope })\` to address another one.`);
+		merged[name] = value;
+	}
+	return merged;
+};
+const operationCredential = (supplied) => {
 	for (const [name, value] of Object.entries(supplied ?? {})) {
 		const scheme = schemeOfHeader(name);
-		if (scheme === void 0 || value == null) continue;
-		if (!isUsableKey(scheme, value)) throw unusableKeyError(`The \`${name}\` parameter`);
-		return {
-			kind: "operation",
+		if (scheme !== void 0 && value != null) return {
 			scheme,
-			key: value
+			credential: value
 		};
 	}
-	if (auth.mode === "none") return null;
-	const scheme = auth.mode === "auto" ? selectScheme(operation?.schemes, (candidate) => auth.credentials[candidate] !== void 0) : schemeOfMode(auth.mode);
+};
+const configuredScheme = (auth, operation) => {
+	if (auth.mode === "none") return void 0;
+	if (auth.mode === "auto") return selectScheme(operation?.schemes, (scheme) => auth.credentials[scheme] !== void 0);
+	return SCHEME_OF_MODE[auth.mode];
+};
+/**
+* The credential one call carries: an operation credential replaces `auth`,
+* and a fixed mode never reads the operation table. `null` off the API origin.
+*/
+const chooseCredential = (auth, baseURL, requestURL, operation, supplied) => {
+	if (!sameOrigin(baseURL, requestURL)) return null;
+	const own = operationCredential(supplied);
+	if (own !== void 0) return own;
+	const scheme = configuredScheme(auth, operation);
+	if (scheme === void 0) return null;
 	const credential = auth.credentials[scheme];
 	return credential === void 0 ? null : {
-		kind: "configured",
 		scheme,
 		credential
 	};
 };
-/**
-* The routing headers one call sends: the configured scope, with any operation
-* scope id the call supplied in its place. Where both name the same id they
-* must agree; a call that disagrees with its own client fails before dispatch.
-*/
-const scopeForCall = (configured, supplied) => {
-	let merged = configured;
-	for (const name of SCOPE_HEADER_NAMES) {
-		const value = supplied?.[name];
-		if (value == null) continue;
-		const current = configured?.[name];
-		if (current !== void 0 && current !== value) throw new ComposioError(`The \`${name}\` parameter disagrees with the client's \`scope\`. Derive a client with \`withOptions({ scope })\` to address another one.`);
-		merged = {
-			...merged,
-			[name]: value
-		};
-	}
-	return merged;
+const credentialHeader = (scheme, key) => {
+	const name = SCHEME_HEADERS[scheme];
+	if (!isUsableKey(key)) throw unusableKeyError(`The \`${name}\` credential`);
+	return {
+		name,
+		value: key
+	};
+};
+const providerFailed = (cause) => {
+	const error = new ComposioError("The `auth` credential provider failed.");
+	Object.defineProperty(error, "cause", {
+		value: cause,
+		configurable: true,
+		writable: true
+	});
+	return error;
 };
 
 //#endregion
@@ -1065,7 +1008,7 @@ function* headerNames(headers) {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "2.0.0-rc.18";
+const VERSION = "2.0.0-rc.19";
 
 //#endregion
 //#region src/compat/identity.ts
@@ -1217,13 +1160,7 @@ const resolveIdentity = (identity) => {
 		reserved: IDENTITY_RESERVED
 	};
 };
-/**
-* The reserved names, as a function of what is configured. The identity names
-* are rc.17's. The credential names are reserved while `auth` is not `none`,
-* and the routing ids while a `scope` is set; with neither configured they are
-* ordinary headers, which is how a client is used as a transport for schemes
-* it does not model.
-*/
+/** Credential names are reserved while `auth` is not `none`, routing ids while `scope` is set. */
 const reservedHeaders = (identity, configured) => {
 	const reserved = /* @__PURE__ */ new Map();
 	for (const name of identity.reserved) reserved.set(name, PACKAGE_RESERVED.has(name) ? "client" : "identity");
@@ -1318,17 +1255,11 @@ const createFetchTransport = (options = {}) => {
 * regression that measures fine and reports nothing.
 */
 const OPERATION = Symbol("composio.operation");
-/**
-* Beside the descriptor, the owned header parameters the call supplied
-* (`x-user-api-key`, `x-org-id`): the generated method takes them out of the
-* generic header bag and hands them over here, so the kernel can let an
-* operation credential replace `auth` and hold an operation scope id to the
-* configured `scope`. A raw call has no way to set it.
-*/
+/** The owned header parameters (`x-user-api-key`, `x-org-id`) a generated call supplied. */
 const OPERATION_HEADERS = Symbol("composio.operationHeaders");
 /**
-* Attach a generated call's operation, and the owned header parameters it
-* supplied, to the options bag it dispatches with.
+* Attach a generated call's operation, and its owned header parameters, to
+* the options bag it dispatches with.
 *
 * Called with the freshly built literal — never with the caller's own object —
 * and *after* the caller's options have been spread into it, so a caller
@@ -1342,7 +1273,6 @@ const withOperation = (operation, options, headers) => {
 };
 /** The operation a generated call recorded, or `undefined` for a raw one. */
 const readOperation = (options) => options[OPERATION];
-/** The owned header parameters a generated call supplied, or `undefined`. */
 const readOperationHeaders = (options) => options[OPERATION_HEADERS];
 /** 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>"}`;
@@ -1647,56 +1577,26 @@ const buildRequestHeaders = (config, options, requestURL, bodyHeaders, withdrawn
 	if (withdrawn) withdrawCredentials(headers);
 	return headers;
 };
-/** The error for a provider that failed; the provider's own error is its `cause`. */
-const providerFailed = (cause) => {
-	const error = new ComposioError("The `auth` credential provider failed.");
-	Object.defineProperty(error, "cause", {
-		value: cause,
-		configurable: true,
-		writable: true
-	});
-	return error;
-};
-/**
-* The credential one logical call carries, its provider asked at most once,
-* and before any network work.
-*
-* A configured credential is asked for only when the call starts on the API
-* origin: a call that starts anywhere else never carries it (rule 2), and a
-* redirect back onto the origin arrives after the chain has left it, so the
-* withdrawal holds. An operation credential is the call's own and is returned
-* as given; the origin rules still decide, per hop, whether it is sent.
-*/
-const resolveCallCredential = (config, operation, supplied, requestURL) => {
-	const choice = chooseCredential(config.auth, operation, supplied);
-	if (choice === null) return null;
-	const name = schemeHeader(choice.scheme);
-	if (choice.kind === "operation") return {
-		name,
-		value: choice.key
-	};
-	if (!sameOrigin(config.baseURL, requestURL)) return null;
-	if (typeof choice.credential === "string") return {
-		name,
-		value: choice.credential
-	};
-	const usable = (key) => {
-		if (!isUsableKey(choice.scheme, key)) throw unusableKeyError("The key the `auth` credential provider returned");
-		return {
-			name,
-			value: key
-		};
-	};
+const callProvider = (provider, header) => {
 	let key;
 	try {
-		key = choice.credential();
+		key = provider();
 	} catch (cause) {
 		throw providerFailed(cause);
 	}
-	return typeof key === "string" ? usable(key) : Promise.resolve(key).then(usable, (cause) => {
+	if (typeof key === "string") return header(key);
+	return Promise.resolve(key).then(header, (cause) => {
 		throw providerFailed(cause);
 	});
 };
+/** Synchronous unless a provider has to be awaited, so a string key goes out in the turn the call starts. */
+const resolveCallCredential = (config, requestURL, operation, supplied) => {
+	const choice = chooseCredential(config.auth, config.baseURL, requestURL, operation, supplied);
+	if (choice === null) return null;
+	const header = (key) => credentialHeader(choice.scheme, key);
+	if (typeof choice.credential === "string") return header(choice.credential);
+	return callProvider(choice.credential, header);
+};
 /**
 * One attempt: the request, plus however many redirects it takes to land on a
 * non-3xx response.
@@ -1784,10 +1684,10 @@ async function makeRequest(config, options) {
 	const supplied = readOperationHeaders(options);
 	assertRequiredOperationHeaders(threaded ?? null, supplied);
 	const scope = scopeForCall(config.scope, supplied);
-	const resolving = resolveCallCredential(config, operation, supplied, url);
+	const credential = resolveCallCredential(config, url, operation, supplied);
 	const call = {
 		scope,
-		credential: resolving instanceof Promise ? await resolving : resolving
+		credential: credential instanceof Promise ? await credential : credential
 	};
 	if (config.onRequest !== void 0 && (threaded === void 0 || threaded.hasDeprecatedInputs === true)) config.onRequest(operation, query, options.body, buildHeaders([config.defaultHeaders, options.headers]));
 	for (let numRetries = 0;; numRetries++) {
@@ -2706,4 +2606,4 @@ const generatedOperation = (chainKey) => {
 };
 
 //#endregion
-export { Auth as A, unusableKeyError as B, resolveIdentity as C, inspectDeprecatedInputs as D, mergeHeaders as E, chooseCredential as F, resolveHTTPURL as G, assertCredentialTransport as H, isUsableKey as I, sameOrigin as K, resolveAuth as L, assertRequiredOperationHeaders as M, authConstructors as N, inspectDeprecation as O, authFromCredentials as P, resolveScope as R, reservedHeaders as S, buildHeaders as T, carriesCredentials as U, SCHEME_HEADERS as V, parseHTTPURL as W, shouldRetryResponse as _, TOO_MANY_REDIRECTS as a, createFetchTransport as b, buildURL as c, path as d, printableURL as f, safeJSON as g, rewriteForRedirect as h, REDIRECT_STATUSES as i, assertNoRemovedCredentialOptions as j, matchOperation as k, castToError as l, retryDelayMillis as m, generatedOperation as n, buildBody as o, readOperation as p, schemeHeader as q, OPAQUE_REDIRECT as r, buildRequestHeaders as s, GENERATED_OPERATIONS as t, makeRequest as u, validatePositiveInteger as v, VERSION as w, assertNoReservedHeaders as x, withOperation as y, scopeForCall as z };
+export { Auth as A, SCHEME_HEADERS as B, resolveIdentity as C, inspectDeprecatedInputs as D, mergeHeaders as E, chooseCredential as F, carriesCredentials as H, credentialHeader as I, resolveAuth as L, assertRequiredOperationHeaders as M, authConstructors as N, inspectDeprecation as O, authFromCredentials as P, resolveScope as R, reservedHeaders as S, buildHeaders as T, parseHTTPURL as U, assertCredentialTransport as V, resolveHTTPURL as W, shouldRetryResponse as _, TOO_MANY_REDIRECTS as a, createFetchTransport as b, buildURL as c, path as d, printableURL as f, safeJSON as g, rewriteForRedirect as h, REDIRECT_STATUSES as i, assertNoRemovedCredentialOptions as j, matchOperation as k, castToError as l, retryDelayMillis as m, generatedOperation as n, buildBody as o, readOperation as p, OPAQUE_REDIRECT as r, buildRequestHeaders as s, GENERATED_OPERATIONS as t, makeRequest as u, validatePositiveInteger as v, VERSION as w, assertNoReservedHeaders as x, withOperation as y, scopeForCall as z };

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { $r as SessionCreateResponse, Bi as BadRequestError, Ci as FileDeleteResponse, Di as Auth, Ei as Files, Fi as APIConnectionTimeoutError, Gi as PermissionDeniedError, Hi as ConflictError, Ii as APIError, Ji as RequestOptions, Jr as SessionAttachParams, Ki as RateLimitError, Kr as ToolRouter, Li as APIErrorBody, Mi as Credential, Ni as Scope, Pi as APIConnectionError, Qi as ClientIdentity, Qr as SessionCreateParams, Ri as APIUserAbortError, Si as FileDeleteParams, Ti as FileListResponse, Ui as InternalServerError, Vi as ComposioError, Wi as NotFoundError, Xi as Transport, Xr as SessionConfigHistoryParams, Yi as FetchTransportDefaults, Yr as SessionAttachResponse, Zi as createFetchTransport, Zr as SessionConfigHistoryResponse, _i as SessionToolsResponse, a as ClientOptions, ai as SessionLinkParams, bi as FileCreateUploadURLParams, c as LogLevel, ci as SessionPatchResponse, di as SessionRetrieveResponse, ea as APIPromise, ei as SessionDeleteResponse, fi as SessionSearchParams, gi as SessionToolsParams, hi as SessionToolkitsResponse, ii as SessionExecuteResponse, ji as AutoCredentials, ki as AuthMode, l as Logger, li as SessionProxyExecuteParams, mi as SessionToolkitsParams, ni as SessionExecuteMetaResponse, o as Composio, oi as SessionLinkResponse, pi as SessionSearchResponse, qi as UnprocessableEntityError, qr as Session, ri as SessionExecuteParams, s as EnvironmentMap, si as SessionPatchParams, ti as SessionExecuteMetaParams, ui as SessionProxyExecuteResponse, vi as FileCreateDownloadURLParams, wi as FileListParams, xi as FileCreateUploadURLResponse, yi as FileCreateDownloadURLResponse, zi as AuthenticationError } from "./session-configs-x3OA4CSe.mjs";
-import { t as VERSION } from "./version-DEAhxVwC.mjs";
-export { APIConnectionError, APIConnectionTimeoutError, APIError, type APIErrorBody, APIPromise, APIUserAbortError, Auth, type AuthMode, AuthenticationError, type AutoCredentials, BadRequestError, type ClientIdentity, type ClientOptions, Composio, Composio as default, ComposioError, ConflictError, type Credential, type EnvironmentMap, type FetchTransportDefaults, type FileCreateDownloadURLParams, type FileCreateDownloadURLResponse, type FileCreateUploadURLParams, type FileCreateUploadURLResponse, type FileDeleteParams, type FileDeleteResponse, type FileListParams, type FileListResponse, Files, InternalServerError, type LogLevel, type Logger, NotFoundError, PermissionDeniedError, RateLimitError, type RequestOptions, type Scope, Session, type SessionAttachParams, type SessionAttachResponse, type SessionConfigHistoryParams, type SessionConfigHistoryResponse, type SessionCreateParams, type SessionCreateResponse, type SessionDeleteResponse, type SessionExecuteMetaParams, type SessionExecuteMetaResponse, type SessionExecuteParams, type SessionExecuteResponse, type SessionLinkParams, type SessionLinkResponse, type SessionPatchParams, type SessionPatchResponse, type SessionProxyExecuteParams, type SessionProxyExecuteResponse, type SessionRetrieveResponse, type SessionSearchParams, type SessionSearchResponse, type SessionToolkitsParams, type SessionToolkitsResponse, type SessionToolsParams, type SessionToolsResponse, ToolRouter, type Transport, UnprocessableEntityError, VERSION, createFetchTransport };
+import { $i as APIPromise, $r as SessionDeleteResponse, Ai as AutoCredentials, Bi as ComposioError, Ci as FileListParams, Ei as Auth, Fi as APIError, Gi as RateLimitError, Gr as ToolRouter, Hi as InternalServerError, Ii as APIErrorBody, Ji as FetchTransportDefaults, Jr as SessionAttachResponse, Ki as UnprocessableEntityError, Kr as Session, Li as APIUserAbortError, Mi as Scope, Ni as APIConnectionError, Oi as AuthMode, Pi as APIConnectionTimeoutError, Qr as SessionCreateResponse, Ri as AuthenticationError, Si as FileDeleteResponse, Ti as Files, Ui as NotFoundError, Vi as ConflictError, Wi as PermissionDeniedError, Xi as createFetchTransport, Xr as SessionConfigHistoryResponse, Yi as Transport, Yr as SessionConfigHistoryParams, Zi as ClientIdentity, Zr as SessionCreateParams, _i as FileCreateDownloadURLParams, a as ClientOptions, ai as SessionLinkResponse, bi as FileCreateUploadURLResponse, c as LogLevel, ci as SessionProxyExecuteParams, di as SessionSearchParams, ei as SessionExecuteMetaParams, fi as SessionSearchResponse, gi as SessionToolsResponse, hi as SessionToolsParams, ii as SessionLinkParams, ji as Credential, li as SessionProxyExecuteResponse, mi as SessionToolkitsResponse, ni as SessionExecuteParams, o as Composio, oi as SessionPatchParams, pi as SessionToolkitsParams, qi as RequestOptions, qr as SessionAttachParams, ri as SessionExecuteResponse, s as EnvironmentMap, si as SessionPatchResponse, ti as SessionExecuteMetaResponse, ui as SessionRetrieveResponse, vi as FileCreateDownloadURLResponse, wi as FileListResponse, xi as FileDeleteParams, yi as FileCreateUploadURLParams, zi as BadRequestError } from "./session-configs-BLy_O6bX.mjs";
+import { t as VERSION } from "./version-DB98yI2B.mjs";
+export { APIConnectionError, APIConnectionTimeoutError, APIError, type APIErrorBody, APIPromise, APIUserAbortError, Auth, type AuthMode, AuthenticationError, type AutoCredentials, BadRequestError, type ClientIdentity, type ClientOptions, Composio, Composio as default, ComposioError, ConflictError, type Credential, type EnvironmentMap, type FetchTransportDefaults, type FileCreateDownloadURLParams, type FileCreateDownloadURLResponse, type FileCreateUploadURLParams, type FileCreateUploadURLResponse, type FileDeleteParams, type FileDeleteResponse, type FileListParams, type FileListResponse, Files, InternalServerError, type LogLevel, NotFoundError, PermissionDeniedError, RateLimitError, type RequestOptions, type Scope, Session, type SessionAttachParams, type SessionAttachResponse, type SessionConfigHistoryParams, type SessionConfigHistoryResponse, type SessionCreateParams, type SessionCreateResponse, type SessionDeleteResponse, type SessionExecuteMetaParams, type SessionExecuteMetaResponse, type SessionExecuteParams, type SessionExecuteResponse, type SessionLinkParams, type SessionLinkResponse, type SessionPatchParams, type SessionPatchResponse, type SessionProxyExecuteParams, type SessionProxyExecuteResponse, type SessionRetrieveResponse, type SessionSearchParams, type SessionSearchResponse, type SessionToolkitsParams, type SessionToolkitsResponse, type SessionToolsParams, type SessionToolsResponse, ToolRouter, type Transport, UnprocessableEntityError, VERSION, createFetchTransport };