@composio/client 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/environments-BGA2C5nZ.mjs

@@ -0,0 +1,222 @@
+import { r as APIError } from "./error-Bw7_G2NZ.mjs";
+import { g as safeJSON, l as castToError } from "./generated-operations-DhZryVXy.mjs";
+
+//#region src/compat/api-promise.ts
+/**
+* Stainless `defaultParseResponse`'s rule for a success body, from the three
+* facts it reads: 204 → `null`, a JSON media type → parsed JSON (or
+* `undefined` when `content-length` is `0`), anything else → text.
+*/
+const classifySuccessBody = (status, contentType, contentLength) => {
+	if (status === 204) return "null";
+	const mediaType = contentType?.split(";")[0]?.trim();
+	if (!(mediaType?.includes("application/json") || mediaType?.endsWith("+json"))) return "text";
+	return contentLength === "0" ? "undefined" : "json";
+};
+/**
+* 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);
+	}
+	const kind = classifySuccessBody(response.status, response.headers.get("content-type"), response.headers.get("content-length"));
+	if (kind === "null") return null;
+	if (kind === "undefined") return void 0;
+	if (kind === "json") 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
+	}]],
+	["mcp.generate.url", [{
+		wire: "managed_auth_by_composio",
+		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/environments.ts
+/**
+* The built-in API origins, keyed as the `environment` option the 0.1.x
+* client took. The migration target for `environment: 'staging'` is
+* `baseURL: ENVIRONMENTS.staging`.
+*
+* A module of its own so `./effect` can import it without loading the Promise
+* client and its resource tree.
+*/
+const ENVIRONMENTS = Object.freeze({
+	production: "https://backend.composio.dev",
+	staging: "https://staging-backend.composio.dev",
+	local: "http://localhost:9900"
+});
+
+//#endregion
+export { classifySuccessBody as i, GENERATED_DEPRECATED_INPUTS as n, APIPromise as r, ENVIRONMENTS as t };

package/dist/environments-xPjIJ-r7.d.mts

@@ -0,0 +1,19 @@
+//#region src/version.d.ts
+declare const VERSION = "2.0.0-rc.20";
+//#endregion
+//#region src/compat/environments.d.ts
+/**
+ * The built-in API origins, keyed as the `environment` option the 0.1.x
+ * client took. The migration target for `environment: 'staging'` is
+ * `baseURL: ENVIRONMENTS.staging`.
+ *
+ * A module of its own so `./effect` can import it without loading the Promise
+ * client and its resource tree.
+ */
+declare const ENVIRONMENTS: Readonly<{
+  readonly production: "https://backend.composio.dev";
+  readonly staging: "https://staging-backend.composio.dev";
+  readonly local: "http://localhost:9900";
+}>;
+//#endregion
+export { VERSION as n, ENVIRONMENTS as t };

package/dist/error-Bw7_G2NZ.mjs

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