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

package/dist/config-DnyMhILW.d.mts

@@ -0,0 +1,9 @@
+//#region src/compat/resources/project/config.d.ts
+/**
+ * Stainless-shaped `client.project.config` resource: an empty resource class
+ * (Stainless declares it with no methods), shipped for import/`instanceof`/
+ * namespace parity.
+ */
+declare class Config {}
+//#endregion
+export { Config as t };

package/dist/connected-accounts-DNOWcz-A.mjs

@@ -0,0 +1,83 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/connected-accounts.ts
+const OP_CREATE = generatedOperation("connectedAccounts.create");
+const OP_RETRIEVE = generatedOperation("connectedAccounts.retrieve");
+const OP_LIST = generatedOperation("connectedAccounts.list");
+const OP_DELETE = generatedOperation("connectedAccounts.delete");
+const OP_COMPLETE_AUTH = generatedOperation("connectedAccounts.completeAuth");
+const OP_PATCH = generatedOperation("connectedAccounts.patch");
+const OP_REFRESH = generatedOperation("connectedAccounts.refresh");
+const OP_REVOKE = generatedOperation("connectedAccounts.revoke");
+const OP_UPDATE_STATUS = generatedOperation("connectedAccounts.updateStatus");
+/**
+* Stainless-shaped `client.connectedAccounts` resource: the 7-method published
+* surface of `@composio/client` (create/retrieve/list/delete/patch/refresh/
+* updateStatus) plus the spec-surface `revoke`
+* (`POST /connected_accounts/{nanoid}/revoke`, never published by Stainless —
+* wayfinder ticket 29), dispatched through the handwritten kernel.
+*/
+var ConnectedAccounts = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	create(body, options) {
+		return this.#client.post("/api/v3.1/connected_accounts", withOperation(OP_CREATE, {
+			body,
+			...options
+		}));
+	}
+	retrieve(nanoid, options) {
+		return this.#client.get(path`/api/v3.1/connected_accounts/${nanoid}`, withOperation(OP_RETRIEVE, { ...options }));
+	}
+	list(query = {}, options) {
+		return this.#client.get("/api/v3.1/connected_accounts", withOperation(OP_LIST, {
+			query,
+			...options
+		}));
+	}
+	delete(nanoid, query = {}, options) {
+		return this.#client.delete(path`/api/v3.1/connected_accounts/${nanoid}`, withOperation(OP_DELETE, {
+			query,
+			...options
+		}));
+	}
+	completeAuth(body, options) {
+		return this.#client.post("/api/v3.1/connected_accounts/complete_auth", withOperation(OP_COMPLETE_AUTH, {
+			body,
+			...options
+		}));
+	}
+	patch(nanoid, body = {}, options) {
+		return this.#client.patch(path`/api/v3.1/connected_accounts/${nanoid}`, withOperation(OP_PATCH, {
+			body,
+			...options
+		}));
+	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
+	refresh(nanoid, params = {}, options) {
+		const { query_redirect_url, body_redirect_url, ...body } = params ?? {};
+		return this.#client.post(path`/api/v3.1/connected_accounts/${nanoid}/refresh`, withOperation(OP_REFRESH, {
+			query: { redirect_url: query_redirect_url },
+			body: {
+				...body,
+				redirect_url: body_redirect_url
+			},
+			...options
+		}));
+	}
+	revoke(nanoid, options) {
+		return this.#client.post(path`/api/v3.1/connected_accounts/${nanoid}/revoke`, withOperation(OP_REVOKE, { ...options }));
+	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
+	updateStatus(nanoID, body, options) {
+		return this.#client.patch(path`/api/v3.1/connected_accounts/${nanoID}/status`, withOperation(OP_UPDATE_STATUS, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { ConnectedAccounts as t };

package/dist/consumer-B_ccSE7b.mjs

@@ -0,0 +1,34 @@
+import { c as withOperation, m as mergeHeaders, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+import { t as Project } from "./project-CBh3olOE.mjs";
+
+//#region src/compat/resources/org/consumer/consumer.ts
+const OP_LIST_CONNECTED_TOOLKITS = generatedOperation("org.consumer.listConnectedToolkits");
+/**
+* Spec-surface `client.org.consumer` resource: the 1-method consumer surface
+* of the v3.1 spec (listConnectedToolkits over
+* `/org/consumer/connected_toolkits`) plus the `project` sub-resource, never
+* published by Stainless — wayfinder ticket 31.
+*/
+var Consumer = class {
+	project;
+	#client;
+	constructor(client) {
+		this.#client = client;
+		this.project = new Project(client);
+	}
+	listConnectedToolkits(params, options) {
+		const { "x-user-api-key": xUserApiKey, "x-org-id": xOrgId, ...query } = params;
+		return this.#client.get("/api/v3.1/org/consumer/connected_toolkits", withOperation(OP_LIST_CONNECTED_TOOLKITS, {
+			query,
+			...options,
+			headers: mergeHeaders([{
+				...xUserApiKey != null ? { "x-user-api-key": xUserApiKey } : void 0,
+				...xOrgId != null ? { "x-org-id": xOrgId } : void 0
+			}, options?.headers])
+		}));
+	}
+};
+Consumer.Project = Project;
+
+//#endregion
+export { Consumer as t };

package/dist/custom-CEy4IB_M.mjs

@@ -0,0 +1,88 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/legacy-options.ts
+/**
+* Recognizing a request-options bag passed where a params object now goes.
+*
+* TODO(#66): a migration guardrail, to be removed before stable 2.0 —
+* https://github.com/ComposioHQ/composio-client/issues/66.
+*
+* A method that gains its first optional parameter moves from
+* `method(id, options?)` to `method(id, params?, options?)`. A caller written
+* against the released two-position form then hands its options to the params
+* position, where `headers` is serialized into the URL and `timeout`/`signal`
+* are dropped. The generator emits a check for exactly the methods its ledger
+* declares (`LEGACY_OPTIONS_POSITIONS` in `packages/codegen`), and every one of
+* them asks this module — the key set lives here once, not in generated files.
+*
+* This file imports nothing on purpose: the generator reads
+* `REQUEST_OPTIONS_KEYS` to refuse a ledger entry whose parameter names collide
+* with it, and must be able to load the list without the rest of the kernel.
+* `test/types/legacy-options.test-d.ts` pins the list to `keyof RequestOptions`
+* in both directions, so a key added to that interface cannot be forgotten here.
+*/
+/** Every key of `RequestOptions` (`request.ts`). */
+const REQUEST_OPTIONS_KEYS = [
+	"headers",
+	"maxRetries",
+	"timeout",
+	"signal",
+	"fetchOptions",
+	"idempotencyKey"
+];
+/**
+* Whether `value`, received in a params position, is really a request-options
+* bag from a call written against the released two-position signature.
+*
+* `declaredKeys` are the operation's own parameter names. An object carrying
+* any of them is params, whatever else it carries: a mixed object is ambiguous,
+* and reading it as options would silently discard a parameter the caller set.
+* Otherwise it is options only on positive evidence — at least one
+* `RequestOptions` key — so `{}`, `null` and `undefined` stay params.
+*
+* The generator guarantees the two key sets are disjoint, which is what makes
+* the answer unambiguous for every object that is not mixed.
+*/
+const isLegacyRequestOptions = (value, declaredKeys) => {
+	if (typeof value !== "object" || value === null) return false;
+	if (declaredKeys.some((key) => Object.hasOwn(value, key))) return false;
+	return REQUEST_OPTIONS_KEYS.some((key) => Object.hasOwn(value, key));
+};
+
+//#endregion
+//#region src/compat/resources/custom.ts
+const OP_DELETE_TOOLKIT = generatedOperation("custom.deleteToolkit");
+const OP_SYNC = generatedOperation("custom.sync");
+const OP_UPSERT = generatedOperation("custom.upsert");
+const LEGACY_PARAM_KEYS_DELETE_TOOLKIT = ["revoke_on_delete"];
+/** OpenAPI resource for `custom`. */
+var Custom = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	deleteToolkit(slug, queryOrOptions = {}, trailingOptions) {
+		const optionsSecond = trailingOptions === void 0 && isLegacyRequestOptions(queryOrOptions, LEGACY_PARAM_KEYS_DELETE_TOOLKIT);
+		const query = optionsSecond ? {} : queryOrOptions;
+		const options = optionsSecond ? queryOrOptions : trailingOptions;
+		return this.#client.delete(path`/api/v3.1/custom/toolkits/${slug}`, withOperation(OP_DELETE_TOOLKIT, {
+			query,
+			...options
+		}));
+	}
+	sync(body, options) {
+		return this.#client.post("/api/v3.1/custom/toolkits/sync", withOperation(OP_SYNC, {
+			body,
+			...options
+		}));
+	}
+	upsert(body, options) {
+		return this.#client.post("/api/v3.1/custom/toolkits/upsert", withOperation(OP_UPSERT, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Custom as t };

package/dist/custom-JHvAPJnl.mjs

@@ -0,0 +1,24 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/mcp/custom.ts
+const OP_CREATE = generatedOperation("mcp.custom.create");
+/**
+* Stainless-shaped `client.mcp.custom` resource: the 1-method custom MCP
+* server sub-surface of `@composio/client` (`POST /mcp/servers/custom`).
+*/
+var Custom = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
+	create(body, options) {
+		return this.#client.post("/api/v3.1/mcp/servers/custom", withOperation(OP_CREATE, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Custom as t };

package/dist/error-DLB1uKM3.mjs

@@ -0,0 +1,109 @@
+//#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
+	};
+};
+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.userApiKey`.
+	*/
+	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) {
+		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
+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 };

package/dist/files-C74URe8c.mjs

@@ -0,0 +1,31 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/files.ts
+const OP_LIST = generatedOperation("files.list");
+const OP_CREATE_PRESIGNED_URL = generatedOperation("files.createPresignedURL");
+/**
+* Stainless-shaped `client.files` resource: the 2-method project file surface
+* of `@composio/client` (list, createPresignedURL).
+*/
+var Files = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
+	list(query = {}, options) {
+		return this.#client.get("/api/v3.1/files/list", withOperation(OP_LIST, {
+			query,
+			...options
+		}));
+	}
+	createPresignedURL(body, options) {
+		return this.#client.post("/api/v3.1/files/upload/request", withOperation(OP_CREATE_PRESIGNED_URL, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Files as t };

package/dist/files-CxbSR_Qf.mjs

@@ -0,0 +1,49 @@
+import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/tool-router/session/files.ts
+const OP_LIST = generatedOperation("toolRouter.session.files.list");
+const OP_DELETE = generatedOperation("toolRouter.session.files.delete");
+const OP_CREATE_DOWNLOAD_URL = generatedOperation("toolRouter.session.files.createDownloadURL");
+const OP_CREATE_UPLOAD_URL = generatedOperation("toolRouter.session.files.createUploadURL");
+/**
+* Stainless-shaped `client.toolRouter.session.files` resource — the 4-method
+* mounts/files sub-surface, `(mountID, params, options?)` with `session_id`
+* inside `params`.
+*/
+var Files = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	list(mountID, params, options) {
+		const { session_id, ...query } = params;
+		return this.#client.get(path`/api/v3.1/tool_router/session/${session_id}/mounts/${mountID}/items`, withOperation(OP_LIST, {
+			query,
+			...options
+		}));
+	}
+	delete(mountID, params, options) {
+		const { session_id, ...body } = params;
+		return this.#client.post(path`/api/v3.1/tool_router/session/${session_id}/mounts/${mountID}/delete`, withOperation(OP_DELETE, {
+			body,
+			...options
+		}));
+	}
+	createDownloadURL(mountID, params, options) {
+		const { session_id, ...body } = params;
+		return this.#client.post(path`/api/v3.1/tool_router/session/${session_id}/mounts/${mountID}/download_url`, withOperation(OP_CREATE_DOWNLOAD_URL, {
+			body,
+			...options
+		}));
+	}
+	createUploadURL(mountID, params, options) {
+		const { session_id, ...body } = params;
+		return this.#client.post(path`/api/v3.1/tool_router/session/${session_id}/mounts/${mountID}/upload_url`, withOperation(OP_CREATE_UPLOAD_URL, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Files as t };

package/dist/generate-Cfcp7BDV.mjs

@@ -0,0 +1,24 @@
+import { c as withOperation, n as generatedOperation } from "./generated-operations-DpYfIPgx.mjs";
+
+//#region src/compat/resources/mcp/generate.ts
+const OP_URL = generatedOperation("mcp.generate.url");
+/**
+* Stainless-shaped `client.mcp.generate` resource: the 1-method MCP URL
+* generation sub-surface of `@composio/client` (`POST /mcp/servers/generate`).
+*/
+var Generate = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/** @deprecated Deprecated in the input OpenAPI schema. */
+	url(body, options) {
+		return this.#client.post("/api/v3.1/mcp/servers/generate", withOperation(OP_URL, {
+			body,
+			...options
+		}));
+	}
+};
+
+//#endregion
+export { Generate as t };