@composio/client 2.0.0-rc.9 → 2.0.0

package/dist/environments-BFGXNbF0.mjs

@@ -0,0 +1,230 @@
+import { r as APIError } from "./error-Bw7_G2NZ.mjs";
+import { _ as safeJSON, l as castToError } from "./generated-operations-DXMQK5w5.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
+		},
+		{
+			wire: "shared_credentials",
+			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-cVbMu7FC.d.mts

@@ -0,0 +1,19 @@
+//#region src/version.d.ts
+declare const VERSION = "2.0.0";
+//#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-DLB1uKM3.mjs → error-Bw7_G2NZ.mjs}

@@ -25,6 +25,19 @@ const errorDetails = (body) => {
 		...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;
@@ -38,7 +51,7 @@ var APIError = class APIError extends ComposioError {
 	* `errors[]` and `suggested_fix` are reachable without casting `error`.
 	*
 	* Not part of the Stainless surface: a sanctioned superset, like
-	* `ClientOptions.userApiKey`.
+	* `ClientOptions.identity`.
 	*/
 	details;
 	/**
@@ -56,12 +69,7 @@ var APIError = class APIError extends ComposioError {
 		this.requestId = headers?.get?.("x-request-id") || this.details?.request_id;
 	}
 	static makeMessage(status, error, message) {
-		const errorMessage = error?.message;
-		const msg = errorMessage ? typeof errorMessage === "string" ? errorMessage : JSON.stringify(errorMessage) : error ? JSON.stringify(error) : message;
-		if (status && msg) return `${status} ${msg}`;
-		if (status) return `${status} status code (no body)`;
-		if (msg) return msg;
-		return "(no status code or body)";
+		return makeAPIErrorMessage(status, error, message);
 	}
 	static generate(status, errorResponse, message, headers) {
 		if (!status || !headers) return new APIConnectionError({
@@ -106,4 +114,4 @@ var RateLimitError = class extends APIError {};
 var InternalServerError = class extends APIError {};
 
 //#endregion
-export { AuthenticationError as a, ConflictError as c, PermissionDeniedError as d, RateLimitError as f, APIUserAbortError as i, InternalServerError as l, APIConnectionTimeoutError as n, BadRequestError as o, UnprocessableEntityError as p, APIError as r, ComposioError as s, APIConnectionError as t, NotFoundError as u };
+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 };