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

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { $r as SessionSearchParams, Ai as RateLimitError, Br as SessionCreateResponse, Ci as AuthenticationError, Di as InternalServerError, Ei as ConflictError, Fr as SessionAttachParams, Gr as SessionExecuteResponse, Hr as SessionExecuteMetaParams, Ir as SessionAttachResponse, Jr as SessionPatchParams, Kr as SessionLinkParams, Lr as SessionConfigHistoryParams, Mi as APIPromise, Nr as ToolRouter, Oi as NotFoundError, Pr as Session, Qr as SessionRetrieveResponse, Rr as SessionConfigHistoryResponse, Si as APIUserAbortError, Ti as ComposioError, Ur as SessionExecuteMetaResponse, Vr as SessionDeleteResponse, Wr as SessionExecuteParams, Xr as SessionProxyExecuteParams, Yr as SessionPatchResponse, Zr as SessionProxyExecuteResponse, _i as createFetchTransport, a as ClientOptions, ai as FileCreateDownloadURLParams, bi as APIError, c as LogLevel, ci as FileCreateUploadURLResponse, di as FileListParams, ei as SessionSearchResponse, fi as FileListResponse, gi as Transport, hi as FetchTransportDefaults, ii as SessionToolsResponse, ji as UnprocessableEntityError, ki as PermissionDeniedError, l as Logger, li as FileDeleteParams, mi as RequestOptions, ni as SessionToolkitsResponse, o as Composio, oi as FileCreateDownloadURLResponse, pi as Files, qr as SessionLinkResponse, ri as SessionToolsParams, s as EnvironmentMap, si as FileCreateUploadURLParams, ti as SessionToolkitsParams, ui as FileDeleteResponse, vi as APIConnectionError, wi as BadRequestError, xi as APIErrorBody, yi as APIConnectionTimeoutError, zr as SessionCreateParams } from "./session-configs-DBYUrVm-.mjs";
+//#region src/version.d.ts
+declare const VERSION = "2.0.0-rc.10";
+//#endregion
+export { APIConnectionError, APIConnectionTimeoutError, APIError, type APIErrorBody, APIPromise, APIUserAbortError, AuthenticationError, BadRequestError, type ClientOptions, Composio, Composio as default, ComposioError, ConflictError, 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, 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 };

package/dist/index.mjs

@@ -0,0 +1,576 @@
+import { a as AuthenticationError, c as ConflictError, d as PermissionDeniedError, f as RateLimitError, i as APIUserAbortError, l as InternalServerError, n as APIConnectionTimeoutError, o as BadRequestError, p as UnprocessableEntityError, r as APIError, s as ComposioError, t as APIConnectionError, u as NotFoundError } from "./error-DLB1uKM3.mjs";
+import { d as inspectDeprecation, f as assertCredentialTransport, i as makeRequest, l as VERSION, m as mergeHeaders, o as readOperation, p as parseHTTPURL, r as castToError, s as safeJSON, t as GENERATED_OPERATIONS, u as inspectDeprecatedInputs } from "./generated-operations-DpYfIPgx.mjs";
+import { t as Custom } from "./custom-CEy4IB_M.mjs";
+import { t as ApiKeyRevocation } from "./api-key-revocation-CMby8GRJ.mjs";
+import { t as AuthConfigs } from "./auth-configs-Dgujwvul.mjs";
+import { t as Auth } from "./auth-Cogku2no.mjs";
+import { t as Cli } from "./cli-Bx3dRctN.mjs";
+import { t as ConnectedAccounts } from "./connected-accounts-DNOWcz-A.mjs";
+import { t as Files$1 } from "./files-C74URe8c.mjs";
+import { t as Keyring } from "./keyring-DPTbHLph.mjs";
+import { t as Link } from "./link-HtoYUvao.mjs";
+import { t as Logs } from "./logs-B1kxIBDI.mjs";
+import { t as Mcp } from "./mcp-DPHzA1Gg.mjs";
+import { t as Migration } from "./migration-CBhnoN-Y.mjs";
+import { t as Org } from "./org-DfPJHXZ4.mjs";
+import { t as Project } from "./project-z2RqqvAR.mjs";
+import { SessionConfigs } from "./resources/session-configs.mjs";
+import { t as Files } from "./files-CxbSR_Qf.mjs";
+import { t as Session } from "./session-ZjgXXTor.mjs";
+import { t as ToolRouter } from "./tool-router-oEa6XLps.mjs";
+import { t as Toolkits } from "./toolkits-gnhAqP-a.mjs";
+import { t as Tools } from "./tools-CplwSMIX.mjs";
+import { t as TriggerInstances } from "./trigger-instances-BZyLCvgX.mjs";
+import { t as TriggersTypes } from "./triggers-types-BOXTcipZ.mjs";
+import { t as WebhookEndpoints } from "./webhook-endpoints-Cv2sK6HF.mjs";
+import { t as WebhookSubscriptions } from "./webhook-subscriptions-BxPEYH5X.mjs";
+
+//#region src/compat/api-promise.ts
+/**
+* Body parsing, strictly deferred: nothing here runs until the promise is
+* awaited (or `withResponse()` is called). Reads a clone so the `Response`
+* handed out by `asResponse()`/`withResponse()` stays readable. Maps HTTP
+* error statuses to the Stainless error hierarchy; mirrors Stainless
+* `defaultParseResponse` for success bodies (204 → null, JSON by
+* content-type, empty content-length → undefined, otherwise text).
+*/
+const defaultParseResponse = async (response) => {
+	if (!response.ok) {
+		const errText = await response.clone().text().catch((err) => castToError(err).message);
+		const errJSON = safeJSON(errText);
+		throw APIError.generate(response.status, errJSON, errJSON ? void 0 : errText, response.headers);
+	}
+	if (response.status === 204) return null;
+	const mediaType = response.headers.get("content-type")?.split(";")[0]?.trim();
+	if (mediaType?.includes("application/json") || mediaType?.endsWith("+json")) {
+		if (response.headers.get("content-length") === "0") return void 0;
+		return await response.clone().json();
+	}
+	return await response.clone().text();
+};
+/**
+* Stainless-compatible `APIPromise`.
+*
+* Mirrors composio-base-ts `src/core/api-promise.ts`: a `Promise` subclass
+* with a no-op executor whose `then`/`catch`/`finally` are overridden to
+* parse lazily. The laziness matters — `.asResponse()` must resolve with the
+* raw `Response` on HTTP error statuses without ever materializing (and thus
+* leaving unhandled) the rejected parsed promise.
+*/
+var APIPromise = class APIPromise extends Promise {
+	exchangePromise;
+	parseResponse;
+	parsedPromise;
+	constructor(exchangePromise, parseResponse = defaultParseResponse) {
+		super((resolve) => {
+			resolve(null);
+		});
+		this.exchangePromise = exchangePromise;
+		this.parseResponse = parseResponse;
+	}
+	_thenUnwrap(transform) {
+		return new APIPromise(this.exchangePromise, async (response) => transform(await this.parseResponse(response), response));
+	}
+	/**
+	* Gets the raw `Response` instead of parsing the body. Resolves (never
+	* throws an `APIError`) on HTTP error statuses; rejects only on
+	* connection/abort failures.
+	*/
+	asResponse() {
+		return this.exchangePromise.then((response) => response);
+	}
+	/** Gets the parsed data plus the raw `Response`. */
+	async withResponse() {
+		const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+		return {
+			data,
+			response
+		};
+	}
+	parse() {
+		this.parsedPromise ??= this.exchangePromise.then((response) => this.parseResponse(response));
+		return this.parsedPromise;
+	}
+	then(onfulfilled, onrejected) {
+		return this.parse().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		return this.parse().catch(onrejected);
+	}
+	finally(onfinally) {
+		return this.parse().finally(onfinally);
+	}
+};
+
+//#endregion
+//#region src/compat/generated-deprecated-inputs.ts
+const GENERATED_DEPRECATED_INPUTS = /* @__PURE__ */ new Map([
+	["authConfigs.list", [{
+		wire: "deprecated_app_id",
+		in: "query",
+		replacementWire: "toolkit_slug"
+	}, {
+		wire: "deprecated_status",
+		in: "query",
+		replacementWire: null
+	}]],
+	["authConfigs.update", [{
+		wire: "restrict_to_following_tools",
+		in: "body",
+		replacementWire: null
+	}, {
+		wire: "tool_access_config",
+		in: "body",
+		replacementWire: null
+	}]],
+	["toolRouter.session.proxyExecute", [{
+		wire: "custom_connection_data",
+		in: "body",
+		replacementWire: null
+	}]],
+	["toolkits.list", [{
+		wire: "managed_by",
+		in: "query",
+		replacementWire: null
+	}]],
+	["tools.execute", [{
+		wire: "entity_id",
+		in: "body",
+		replacementWire: "user_id"
+	}, {
+		wire: "allow_tracing",
+		in: "body",
+		replacementWire: null
+	}]],
+	["tools.list", [{
+		wire: "auth_config_ids",
+		in: "query",
+		replacementWire: null
+	}, {
+		wire: "search",
+		in: "query",
+		replacementWire: "query"
+	}]],
+	["tools.proxy", [{
+		wire: "custom_connection_data",
+		in: "body",
+		replacementWire: null
+	}]],
+	["triggerInstances.listActive", [
+		{
+			wire: "connectedAccountIds",
+			in: "query",
+			replacementWire: "connected_account_ids"
+		},
+		{
+			wire: "authConfigIds",
+			in: "query",
+			replacementWire: "auth_config_ids"
+		},
+		{
+			wire: "triggerIds",
+			in: "query",
+			replacementWire: "trigger_ids"
+		},
+		{
+			wire: "triggerNames",
+			in: "query",
+			replacementWire: "trigger_names"
+		},
+		{
+			wire: "showDisabled",
+			in: "query",
+			replacementWire: "show_disabled"
+		},
+		{
+			wire: "deprecatedConnectedAccountUuids",
+			in: "query",
+			replacementWire: "connected_account_ids"
+		},
+		{
+			wire: "deprecatedAuthConfigUuids",
+			in: "query",
+			replacementWire: "auth_config_ids"
+		}
+	]],
+	["triggerInstances.upsert", [
+		{
+			wire: "connectedAuthId",
+			in: "body",
+			replacementWire: "connected_account_id"
+		},
+		{
+			wire: "triggerConfig",
+			in: "body",
+			replacementWire: "trigger_config"
+		},
+		{
+			wire: "version",
+			in: "body",
+			replacementWire: "toolkit_versions"
+		}
+	]]
+]);
+
+//#endregion
+//#region src/compat/generated-resource-wiring.ts
+const createClientResources = (client) => ({
+	toolRouter: new ToolRouter(client),
+	tools: new Tools(client),
+	files: new Files$1(client),
+	connectedAccounts: new ConnectedAccounts(client),
+	link: new Link(client),
+	toolkits: new Toolkits(client),
+	authConfigs: new AuthConfigs(client),
+	triggersTypes: new TriggersTypes(client),
+	triggerInstances: new TriggerInstances(client),
+	mcp: new Mcp(client),
+	cli: new Cli(client),
+	logs: new Logs(client),
+	project: new Project(client),
+	migration: new Migration(),
+	webhookSubscriptions: new WebhookSubscriptions(client),
+	webhookEndpoints: new WebhookEndpoints(client),
+	org: new Org(client),
+	auth: new Auth(client),
+	apiKeyRevocation: new ApiKeyRevocation(client),
+	custom: new Custom(client),
+	keyring: new Keyring(client),
+	sessionConfigs: new SessionConfigs(client)
+});
+
+//#endregion
+//#region src/compat/client.ts
+const environments = {
+	production: "https://backend.composio.dev",
+	staging: "https://staging-backend.composio.dev",
+	local: "http://localhost:9900"
+};
+const environmentReader = Symbol("Composio.environmentReader");
+/** Read a trimmed environment value in Node or Deno without assuming either runtime exists. */
+const readEnv = (name) => {
+	const globals = globalThis;
+	try {
+		const fromProcess = globals.process?.env?.[name]?.trim();
+		if (fromProcess) return fromProcess;
+	} catch {}
+	try {
+		return globals.Deno?.env?.get?.(name)?.trim() || void 0;
+	} catch {}
+};
+const createEnvironmentReader = (environment) => (name) => environment[name]?.trim() || void 0;
+const emptyEnvironmentReader = () => void 0;
+const mergeEnvironmentHeaders = (raw, defaults) => {
+	if (!raw) return defaults;
+	const parsed = {};
+	for (const line of raw.split("\n")) {
+		const colon = line.indexOf(":");
+		if (colon >= 0) parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+	}
+	try {
+		return mergeHeaders([parsed, defaults]);
+	} catch (cause) {
+		throw new ComposioError(`COMPOSIO_CUSTOM_HEADERS contains an invalid header: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+};
+/** Severity order: a record at or below the configured level is emitted. */
+const LOG_LEVELS = {
+	off: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+/**
+* `logLevel` is a plain string on the public surface and may arrive from
+* `COMPOSIO_LOG_LEVEL`, so it can hold anything. An unrecognized value falls back to
+* the default rather than silencing the client or making it shout.
+*/
+const isLogLevel = (value) => value !== void 0 && Object.hasOwn(LOG_LEVELS, value);
+const resolveCredential = (explicit, readEnvironment, variable) => {
+	if (explicit !== void 0) return explicit;
+	return readEnvironment(variable) ?? null;
+};
+const resolveBaseURL = (options, readEnvironment, hasExplicitEnvironment) => {
+	if (options.baseURL !== void 0) return options.baseURL;
+	if (hasExplicitEnvironment && options.environment !== void 0) return null;
+	return readEnvironment("COMPOSIO_BASE_URL") ?? null;
+};
+const resolveClientOptions = (input) => {
+	if (input.transport !== void 0 && (input.fetch !== void 0 || input.fetchOptions !== void 0)) throw new ComposioError("The `transport` option cannot be combined with `fetch` or `fetchOptions`");
+	const hasExplicitEnvironment = input[environmentReader] !== void 0;
+	const readEnvironment = input[environmentReader] ?? readEnv;
+	const baseURL = resolveBaseURL(input, readEnvironment, hasExplicitEnvironment);
+	const apiKey = resolveCredential(input.apiKey, readEnvironment, "COMPOSIO_API_KEY");
+	const userApiKey = resolveCredential(input.userApiKey, readEnvironment, "COMPOSIO_USER_API_KEY");
+	const orgApiKey = resolveCredential(input.orgApiKey, readEnvironment, "COMPOSIO_ORG_API_KEY");
+	if (baseURL && input.environment) throw new ComposioError("Ambiguous URL; The `baseURL` option (or COMPOSIO_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null");
+	const options = {
+		...input,
+		apiKey,
+		userApiKey,
+		orgApiKey,
+		allowInsecureHTTP: input.allowInsecureHTTP ?? readEnvironment("COMPOSIO_ALLOW_INSECURE_HTTP") === "1",
+		allowedHTTPOrigin: input.allowedHTTPOrigin ?? null,
+		baseURL,
+		environment: input.environment ?? "production",
+		logLevel: input.logLevel ?? readEnvironment("COMPOSIO_LOG_LEVEL") ?? "warn"
+	};
+	options.defaultHeaders = mergeEnvironmentHeaders(readEnvironment("COMPOSIO_CUSTOM_HEADERS"), input.defaultHeaders);
+	if (hasExplicitEnvironment) options[environmentReader] = emptyEnvironmentReader;
+	return options;
+};
+var Composio = class Composio {
+	apiKey;
+	userApiKey;
+	orgApiKey;
+	baseURL;
+	maxRetries;
+	timeout;
+	logger;
+	logLevel;
+	fetchOptions;
+	#fetch;
+	#transport;
+	#options;
+	/**
+	* The (operation, notice) pairs, and separately the (operation, deprecated
+	* input set) pairs, this instance has already warned about — one Set shared
+	* by both triggers under distinct key prefixes (`inspectDeprecation` vs
+	* `inspectDeprecatedInputs`), so a deprecated endpoint or a deprecated
+	* parameter called in a loop announces itself once — while a *revised*
+	* notice from that same endpoint, say once a `Sunset` date is committed,
+	* still gets through.
+	*
+	* Per client *lineage*, not per process: a client built with `new Composio()`
+	* starts empty, and `withOptions()` shares this exact Set with the client it
+	* returns (see below). Not reassigned anywhere else — the mutability exists
+	* only so a derived client can join its parent's record.
+	*/
+	#deprecationSeen = /* @__PURE__ */ new Set();
+	constructor(input = {}) {
+		const options = resolveClientOptions(input);
+		this.baseURL = options.baseURL || environments[options.environment];
+		this.timeout = options.timeout ?? Composio.DEFAULT_TIMEOUT;
+		this.logger = options.logger ?? console;
+		this.logLevel = options.logLevel;
+		this.fetchOptions = options.fetchOptions;
+		this.maxRetries = options.maxRetries ?? 2;
+		this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+		this.#transport = options.transport;
+		options.allowedHTTPOrigin = options.allowInsecureHTTP ? options.allowedHTTPOrigin ?? parseHTTPURL(this.baseURL)?.origin ?? null : null;
+		this.#options = options;
+		this.apiKey = options.apiKey;
+		this.userApiKey = options.userApiKey;
+		this.orgApiKey = options.orgApiKey;
+		assertCredentialTransport(this.baseURL, this.#credentials(), options.allowedHTTPOrigin);
+		Object.assign(this, createClientResources(this));
+	}
+	/**
+	* Constructs a client from a caller-supplied environment snapshot.
+	*
+	* Unlike the compatibility constructor, this method never reads ambient
+	* process or Deno state. Explicit options replace values from `environment`;
+	* in particular, an explicit named environment replaces
+	* `COMPOSIO_BASE_URL`, and `apiKey: null` disables a mapped API key.
+	*/
+	static fromEnv(environment, options = {}) {
+		const input = {
+			...options,
+			[environmentReader]: createEnvironmentReader(environment)
+		};
+		return new this(input);
+	}
+	/** Returns a new client reusing the current options with `options` merged over them. */
+	withOptions(options) {
+		const hasFetch = Object.hasOwn(options, "fetch");
+		const hasFetchOptions = Object.hasOwn(options, "fetchOptions");
+		const replacesTransport = hasFetch || hasFetchOptions;
+		const transport = Object.hasOwn(options, "transport") ? options.transport : replacesTransport ? void 0 : this.#transport;
+		const fetch = transport === void 0 ? hasFetch ? options.fetch : this.#fetch : void 0;
+		const fetchOptions = transport === void 0 ? hasFetchOptions ? options.fetchOptions : this.fetchOptions : void 0;
+		const allowedHTTPOrigin = options.allowInsecureHTTP === true ? void 0 : this.#options.allowedHTTPOrigin;
+		const derivedOptions = {
+			...this.#options,
+			environment: options.environment ? options.environment : void 0,
+			baseURL: options.environment ? void 0 : this.baseURL,
+			maxRetries: this.maxRetries,
+			timeout: this.timeout,
+			logger: this.logger,
+			logLevel: this.logLevel,
+			apiKey: this.apiKey,
+			userApiKey: this.userApiKey,
+			orgApiKey: this.orgApiKey,
+			...options,
+			allowedHTTPOrigin,
+			transport,
+			fetch,
+			fetchOptions
+		};
+		const client = new this.constructor(derivedOptions);
+		client.#deprecationSeen = this.#deprecationSeen;
+		return client;
+	}
+	get(path, opts) {
+		return this.#methodRequest("get", path, opts);
+	}
+	post(path, opts) {
+		return this.#methodRequest("post", path, opts);
+	}
+	patch(path, opts) {
+		return this.#methodRequest("patch", path, opts);
+	}
+	put(path, opts) {
+		return this.#methodRequest("put", path, opts);
+	}
+	delete(path, opts) {
+		return this.#methodRequest("delete", path, opts);
+	}
+	#methodRequest(method, path, opts) {
+		return this.request({
+			method,
+			path,
+			...opts
+		});
+	}
+	request(options) {
+		return new APIPromise(makeRequest(this.#kernelConfig(), options));
+	}
+	/** Read at dispatch, never cached: all three fields are public and mutable. */
+	#credentials() {
+		return {
+			apiKey: this.apiKey,
+			userApiKey: this.userApiKey,
+			orgApiKey: this.orgApiKey
+		};
+	}
+	#onKernelLog = (level, message, metadata) => {
+		this.#emitLog(level, message, metadata);
+	};
+	#onKernelResponse = (response, options) => {
+		inspectDeprecation({
+			response,
+			method: options.method,
+			path: options.path,
+			operation: readOperation(options),
+			baseURL: this.baseURL,
+			operations: GENERATED_OPERATIONS,
+			seen: this.#deprecationSeen,
+			warn: (message) => {
+				this.#emitLog("warn", message);
+			}
+		});
+	};
+	#onKernelRequest = (operation, query, body, headers) => {
+		inspectDeprecatedInputs({
+			operation,
+			query,
+			body,
+			headers,
+			table: GENERATED_DEPRECATED_INPUTS,
+			seen: this.#deprecationSeen,
+			warn: (message) => {
+				this.#emitLog("warn", message);
+			}
+		});
+	};
+	#kernelConfig() {
+		const configuredLogLevel = isLogLevel(this.logLevel) ? this.logLevel : "warn";
+		const lifecycleLoggingEnabled = LOG_LEVELS[configuredLogLevel] >= LOG_LEVELS.info;
+		return {
+			baseURL: this.baseURL,
+			credentials: this.#credentials(),
+			allowedHTTPOrigin: this.#options.allowedHTTPOrigin,
+			operations: GENERATED_OPERATIONS,
+			maxRetries: this.maxRetries,
+			timeout: this.timeout,
+			userAgent: `${this.constructor.name}/JS ${VERSION}`,
+			fetch: this.#fetch,
+			transport: this.#transport,
+			defaultHeaders: this.#options.defaultHeaders,
+			defaultQuery: this.#options.defaultQuery,
+			fetchOptions: this.fetchOptions,
+			...lifecycleLoggingEnabled ? { onLog: this.#onKernelLog } : {},
+			onResponse: this.#onKernelResponse,
+			onRequest: this.#onKernelRequest
+		};
+	}
+	/**
+	* Writes one record through the configured `logger`, gated on `logLevel`.
+	*
+	* A private method by construction: emitting is the client's own business
+	* and the public surface is pinned against the Stainless client, which
+	* exposes no such method. The logger is caller-supplied, so a missing method
+	* or a throwing one is treated as no logger at all — the same rule the
+	* kernel applies to its advisory observer callbacks.
+	*/
+	#emitLog(level, message, ...details) {
+		const configured = isLogLevel(this.logLevel) ? this.logLevel : "warn";
+		if (LOG_LEVELS[configured] < LOG_LEVELS[level]) return;
+		try {
+			const sink = this.logger[level];
+			if (typeof sink !== "function") return;
+			sink.call(this.logger, message, ...details);
+		} catch {}
+	}
+	static Composio = this;
+	static DEFAULT_TIMEOUT = 6e4;
+	static ComposioError = ComposioError;
+	static APIError = APIError;
+	static APIConnectionError = APIConnectionError;
+	static APIConnectionTimeoutError = APIConnectionTimeoutError;
+	static APIUserAbortError = APIUserAbortError;
+	static NotFoundError = NotFoundError;
+	static ConflictError = ConflictError;
+	static RateLimitError = RateLimitError;
+	static BadRequestError = BadRequestError;
+	static AuthenticationError = AuthenticationError;
+	static InternalServerError = InternalServerError;
+	static PermissionDeniedError = PermissionDeniedError;
+	static UnprocessableEntityError = UnprocessableEntityError;
+};
+Composio.ToolRouter = ToolRouter;
+Composio.Tools = Tools;
+Composio.Files = Files$1;
+Composio.ConnectedAccounts = ConnectedAccounts;
+Composio.Link = Link;
+Composio.Toolkits = Toolkits;
+Composio.AuthConfigs = AuthConfigs;
+Composio.TriggersTypes = TriggersTypes;
+Composio.TriggerInstances = TriggerInstances;
+Composio.Mcp = Mcp;
+Composio.Cli = Cli;
+Composio.Logs = Logs;
+Composio.Project = Project;
+Composio.Migration = Migration;
+Composio.WebhookSubscriptions = WebhookSubscriptions;
+Composio.WebhookEndpoints = WebhookEndpoints;
+Composio.Org = Org;
+Composio.Auth = Auth;
+Composio.ApiKeyRevocation = ApiKeyRevocation;
+Composio.Custom = Custom;
+Composio.Keyring = Keyring;
+
+//#endregion
+//#region src/compat/transport.ts
+const KERNEL_OWNED_KEYS = [
+	"method",
+	"headers",
+	"body",
+	"signal",
+	"redirect"
+];
+const assertSafeDefaults = (defaults) => {
+	if (defaults === void 0) return;
+	const owned = KERNEL_OWNED_KEYS.find((key) => key in defaults);
+	if (owned !== void 0) throw new TypeError(`Fetch transport defaults cannot set kernel-owned '${owned}'`);
+};
+/** Creates a transport backed by the supplied or global fetch function. */
+const createFetchTransport = (options = {}) => {
+	assertSafeDefaults(options.defaults);
+	const fetchImplementation = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	return { send: (request) => fetchImplementation(request, options.defaults) };
+};
+
+//#endregion
+export { APIConnectionError, APIConnectionTimeoutError, APIError, APIPromise, APIUserAbortError, AuthenticationError, BadRequestError, Composio, Composio as default, ComposioError, ConflictError, Files, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, Session, ToolRouter, UnprocessableEntityError, VERSION, createFetchTransport };

package/dist/keyring-DPTbHLph.mjs

@@ -0,0 +1,17 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/keyring.ts
+const OP_LIST_TRANSFER_KEYS = generatedOperation("keyring.listTransferKeys");
+/** OpenAPI resource for `keyring`. */
+var Keyring = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	listTransferKeys(options) {
+		return this.#client.get("/api/v3.1/keyring/transfer_keys", withOperation(OP_LIST_TRANSFER_KEYS, { ...options }));
+	}
+};
+
+//#endregion
+export { Keyring as t };

package/dist/link-HtoYUvao.mjs

@@ -0,0 +1,23 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/link.ts
+const OP_CREATE = generatedOperation("link.create");
+/**
+* Stainless-shaped `client.link` resource: the 1-method connected-account
+* link surface of `@composio/client` (`POST /connected_accounts/link`).
+*/
+var Link = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	create(body, options) {
+		return this.#client.post("/api/v3.1/connected_accounts/link", withOperation(OP_CREATE, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Link as t };

package/dist/logs-B1kxIBDI.mjs

@@ -0,0 +1,38 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+import { t as Triggers } from "./triggers-tFRN45MV.mjs";
+import { t as Tools } from "./tools-B6EBv0kQ.mjs";
+
+//#region src/compat/resources/logs/logs.ts
+const OP_CREATE_TOOL_EXECUTION = generatedOperation("logs.createToolExecution");
+const OP_RETRIEVE_TOOL_EXECUTION = generatedOperation("logs.retrieveToolExecution");
+/**
+* Stainless-shaped `client.logs` resource: a method-less container in the
+* published Stainless client (the `triggers` and `tools` log sub-resources)
+* plus the spec-surface `createToolExecution`/`retrieveToolExecution`
+* (`/logs/tool_execution*`, never published by Stainless — wayfinder
+* ticket 29).
+*/
+var Logs = class {
+	triggers;
+	tools;
+	#client;
+	constructor(client) {
+		this.#client = client;
+		this.triggers = new Triggers(client);
+		this.tools = new Tools(client);
+	}
+	createToolExecution(body = {}, options) {
+		return this.#client.post("/api/v3.1/logs/tool_execution", withOperation(OP_CREATE_TOOL_EXECUTION, {
+			body,
+			...options
+		}));
+	}
+	retrieveToolExecution(id, options) {
+		return this.#client.get(path`/api/v3.1/logs/tool_execution/${id}`, withOperation(OP_RETRIEVE_TOOL_EXECUTION, { ...options }));
+	}
+};
+Logs.Triggers = Triggers;
+Logs.Tools = Tools;
+
+//#endregion
+export { Logs as t };

package/dist/manage-Cv_zl1Pa.mjs

@@ -0,0 +1,28 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/trigger-instances/manage.ts
+const OP_UPDATE = generatedOperation("triggerInstances.manage.update");
+const OP_DELETE = generatedOperation("triggerInstances.manage.delete");
+/**
+* Stainless-shaped `client.triggerInstances.manage` resource: the 2-method
+* trigger-instance management sub-surface of `@composio/client`
+* (update/delete on `/trigger_instances/manage/{triggerId}`).
+*/
+var Manage = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	update(triggerID, body = {}, options) {
+		return this.#client.patch(path`/api/v3.1/trigger_instances/manage/${triggerID}`, withOperation(OP_UPDATE, {
+			body,
+			...options
+		}));
+	}
+	delete(triggerID, options) {
+		return this.#client.delete(path`/api/v3.1/trigger_instances/manage/${triggerID}`, withOperation(OP_DELETE, { ...options }));
+	}
+};
+
+//#endregion
+export { Manage as t };