@composio/client 2.0.0-rc.21 → 2.0.0-rc.22

package/README.md

@@ -54,7 +54,8 @@ anything is sent. A client that needs another credential or scope derives one:
 `composio.withOptions({ auth: Auth.project(key) })`. `withOptions` re-runs every construction check.
 
 Three operations declare a credential or scope id as a header parameter
-(`org.consumer.project.resolve`, `org.consumer.listConnectedToolkits`, `cli.createCodactFailure`).
+(`_internal.org.consumer.project.resolve`, `_internal.org.consumer.listConnectedToolkits`,
+`cli.createCodactFailure`).
 Their signatures are unchanged: the value replaces the configured credential for that call, and an
 `x-org-id` that disagrees with the configured `scope` fails the call.
 
@@ -137,6 +138,23 @@ polyfills and test interceptors keep working. A custom `fetch` or extra `Request
 through `createFetchTransport({ fetch, defaults })`; the former `fetch`, `fetchOptions` and
 `defaultQuery` constructor options are gone (see the upgrade section).
 
+### Internal operations
+
+The spec publishes some operations for Composio's own CLI and SDKs and tags them `x-internal`: CLI
+login sessions, realtime credentials, the execution and trigger logs, and the consumer-project
+routes. They are under `client._internal`, they carry no compatibility promise, and any release may
+change them. The property exists on every client, but the root types do not name it, so it stays
+out of autocompletion. A program that needs it imports the opt-in subpath once:
+
+```ts
+import type {} from '@composio/client/internal' // `@composio/client/effect/internal` for the Effect client
+
+const session = await composio._internal.cli.getSession({ id })
+```
+
+Their types are under `@composio/client/resources/_internal/*`. The previous-release gate does not
+pin them. In Python the same operations are `client._internal.cli.get_session(...)`.
+
 ## Effect
 
 `@composio/client/effect` is the same API surface for applications written with
@@ -542,6 +560,38 @@ The opt-in records the resolved scheme, hostname, and port. Mutating `baseURL` c
 and `withOptions({ baseURL: ... })` requires `allowInsecureHTTP: true` again when the origin
 changes. Redirects to another origin remain credential-free.
 
+### Moved in 2.0.0-rc.22
+
+The operations the spec tags `x-internal` moved under `client._internal`, which is typed only through
+`@composio/client/internal` (see [Internal operations](#internal-operations)). The wire is unchanged.
+The ledger declares each as a removal; `pnpm test:pack` holds the subpaths.
+
+| Moved | Now |
+| --- | --- |
+| `client.cli.createSession`, `getSession` | `client._internal.cli.createSession`, `getSession` |
+| `client.cli.realtime.*` | `client._internal.cli.realtime.*` |
+| `client.logs.tools.*`, `client.logs.triggers.*` | `client._internal.logs.tools.*`, `client._internal.logs.triggers.*` |
+| `client.org.consumer.*` | `client._internal.org.consumer.*` |
+| Their types, from `@composio/client/resources/cli`, `resources/cli/realtime`, `resources/logs`, `resources/logs/tools`, `resources/logs/triggers`, `resources/org/consumer*` | The same names from `@composio/client/resources/_internal/<same path>` |
+
+`client.cli.createCodactFailure`, `client.logs.createToolExecution` and
+`client.logs.retrieveToolExecution` are not tagged and stay where they were.
+
+### Changed in 2.0.0-rc.22
+
+| Change | Migration |
+| --- | --- |
+| `toolRouter.session.execute`, `executeMeta` and `proxyExecute` can return `result_type: 'blocked'` | Handle that branch before reading `data`, `error`, `status` or `headers`. Read `reason.type`, `reason.hook_id` and `message` instead. `request_blocked` means the tool did not run; `response_blocked` means it ran and its response was withheld. `log_id` is optional on blocked tool executions |
+| Execution outcomes may include `hook_results` | Treat it as optional. An entry with `status: 'evaluated'` has `outcome: 'continue' \| 'block'`; `status: 'unavailable'` has no outcome. Python callers must also handle the new `SessionExecuteBlockedResponse`, `SessionExecuteMetaBlockedResponse` and `SessionProxyExecuteBlockedResponse` members of each `*Result` union |
+| Trigger-type list items and retrieve responses require `types` | Add a non-empty `types` array of `'webhook'` and/or `'poll'` to typed fixtures and mocks. The older `type` field is deprecated |
+| `org.consumer.project.resolve` requires response `user_id` | Add the authenticated user's id to typed response fixtures and mocks; `consumer_user_id` remains a separate field |
+| Saved session configurations include `require_approval` lists | Handle toolkit/tool entries containing only `{ require_approval: [...] }`, as well as entries with `enable`, `disable` or tool tags. Session-wide and per-toolkit tags may also contain `require_approval` |
+| Project creation no longer declares `config.require_mcp_api_key` | Remove it from project-creation inputs. The upstream schema declares no replacement. `config.enable_instant` controls Instant Toolkits and is unrelated to MCP authentication |
+
+The removed project property has a `properties-removed` ledger entry. The previous-release gate
+checks named property paths as well as assignability, so removing an optional key cannot silently
+pass both structural checks.
+
 ### Removed in 2.0.0-rc.21
 
 The last members of the `Composio` class that existed only to look like the Stainless build. None is a

package/dist/_internal-7BQNRB9A.d.mts

@@ -0,0 +1,265 @@
+import { A as CliGetSessionResponse, C as TriggerRetrieveResponse, D as CliCreateSessionParams, F as RealtimeCredentialsResponse, N as RealtimeAuthParams, O as CliCreateSessionResponse, Oa as APIErrorBody, P as RealtimeAuthResponse, S as TriggerListResponse, Wa as HeadersLike, _ as ToolListResponse, d as ProjectResolveResponse, g as ToolListParams, h as ToolListFieldsResponse, k as CliGetSessionParams, o as ConsumerListConnectedToolkitsParams, s as ConsumerListConnectedToolkitsResponse, u as ProjectResolveParams, v as ToolRetrieveResponse, x as TriggerListParams, xa as AuthOf } from "./_internal-UUxDozdb.mjs";
+import { Effect, Redacted } from "effect";
+import "effect/http/HttpClient";
+import * as Schema from "effect/Schema";
+//#region src/effect/errors.d.ts
+/** The fields every error for a non-success HTTP response carries. */
+interface APIErrorFields {
+  /** The message the compat client builds for the same response. */
+  readonly message: string;
+  /** The request method, upper-cased. */
+  readonly method: string;
+  /** The origin plus the operation template, or `/<custom>` for an undeclared path. */
+  readonly url: string;
+  /** HTTP status of the response. */
+  readonly status: number;
+  /**
+   * The request id the API assigned: the `x-request-id` response header first,
+   * the envelope's `request_id` otherwise.
+   */
+  readonly requestId: string | undefined;
+  /** The body narrowed to the Composio error envelope, when it is one. */
+  readonly details: APIErrorBody['error'] | undefined;
+  /** The parsed JSON body, whatever its shape; `undefined` when it is not JSON. */
+  readonly body: unknown;
+}
+declare const BadRequestError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/BadRequestError";
+} & Readonly<A>;
+declare class BadRequestError extends BadRequestError_base<APIErrorFields> {}
+declare const AuthenticationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/AuthenticationError";
+} & Readonly<A>;
+declare class AuthenticationError extends AuthenticationError_base<APIErrorFields> {}
+declare const PermissionDeniedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/PermissionDeniedError";
+} & Readonly<A>;
+declare class PermissionDeniedError extends PermissionDeniedError_base<APIErrorFields> {}
+declare const NotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/NotFoundError";
+} & Readonly<A>;
+declare class NotFoundError extends NotFoundError_base<APIErrorFields> {}
+declare const ConflictError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/ConflictError";
+} & Readonly<A>;
+declare class ConflictError extends ConflictError_base<APIErrorFields> {}
+declare const UnprocessableEntityError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/UnprocessableEntityError";
+} & Readonly<A>;
+declare class UnprocessableEntityError extends UnprocessableEntityError_base<APIErrorFields> {}
+declare const RateLimitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/RateLimitError";
+} & Readonly<A>;
+declare class RateLimitError extends RateLimitError_base<APIErrorFields> {}
+declare const InternalServerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/InternalServerError";
+} & Readonly<A>;
+/** Any status of 500 and above. */
+declare class InternalServerError extends InternalServerError_base<APIErrorFields> {}
+declare const APIError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/APIError";
+} & Readonly<A>;
+/** A non-success status none of the other classes names. */
+declare class APIError extends APIError_base<APIErrorFields> {}
+declare const APIConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/APIConnectionError";
+} & Readonly<A>;
+/**
+ * The request never produced a response: the transport failed below HTTP.
+ *
+ * The transport's error is reduced to `reason` (which of its failure kinds it
+ * was) and `description` (its own text, or its cause's messages).
+ */
+declare class APIConnectionError extends APIConnectionError_base<{
+  readonly message: string;
+  readonly method: string;
+  readonly url: string;
+  readonly reason: string;
+  readonly description: string | undefined;
+}> {}
+declare const APIConnectionTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/APIConnectionTimeoutError";
+} & Readonly<A>;
+/** An attempt outlived its time budget. */
+declare class APIConnectionTimeoutError extends APIConnectionTimeoutError_base<{
+  readonly message: string;
+  readonly method: string;
+  readonly url: string;
+}> {}
+/** One thing wrong with a response body: where, and what kind of problem. */
+interface DecodeIssue {
+  readonly path: ReadonlyArray<string | number>;
+  readonly kind: string;
+}
+declare const DecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/DecodeError";
+} & Readonly<A>;
+/** A success response whose body is not what it claims to be. */
+declare class DecodeError extends DecodeError_base<{
+  readonly message: string;
+  readonly method: string;
+  readonly url: string;
+  readonly status: number;
+  readonly requestId: string | undefined;
+  /** The operation's public chain (`toolkits.list`), or `undefined` for an undeclared path. */
+  readonly operation: string | undefined;
+  readonly issues: ReadonlyArray<DecodeIssue>;
+}> {}
+declare const ConfigurationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/ConfigurationError";
+} & Readonly<A>;
+/**
+ * The client or the call is set up in a way no request can be made from: a
+ * credentialed origin that cannot carry a credential, a path parameter that
+ * would rewrite the path, a body that does not serialize. Retrying cannot
+ * change the answer.
+ */
+declare class ConfigurationError extends ConfigurationError_base<{
+  readonly message: string;
+}> {}
+/** An error for a non-success HTTP response, of whichever status class. */
+type APIStatusError = BadRequestError | AuthenticationError | PermissionDeniedError | NotFoundError | ConflictError | UnprocessableEntityError | RateLimitError | InternalServerError | APIError;
+/** Every failure an operation of the Effect surface can end with. */
+type ComposioError = APIStatusError | APIConnectionError | APIConnectionTimeoutError | DecodeError | ConfigurationError;
+/**
+ * Whether a value is an error for a non-success HTTP response, of any status
+ * class. Structural, so it holds across duplicated copies of this module.
+ */
+declare const isAPIError: (value: unknown) => value is APIStatusError;
+/** Whether a value is any error this surface produces. Structural, like {@link isAPIError}. */
+declare const isComposioError: (value: unknown) => value is ComposioError;
+//#endregion
+//#region src/effect/credentials.d.ts
+type Key = string | Redacted.Redacted<string>;
+type Provider = () => Key | PromiseLike<Key>;
+/** A string or `Redacted` key, or a function returning one, called once per call. */
+type Credential = Key | Provider;
+type Auth = AuthOf<Credential>;
+//#endregion
+//#region src/effect/decode.d.ts
+/**
+ * What a client decodes with: an operation's public chain (`toolkits.list`) →
+ * a function that loads its response schema. `schemaLoaders`, the export of
+ * `@composio/client/effect/schemas`, is the table for every operation.
+ */
+type SchemaLoaders = Readonly<Record<string, () => Promise<Schema.Codec<unknown>>>>;
+//#endregion
+//#region src/effect/request.d.ts
+/**
+ * What the client's own requests add to a trace:
+ *
+ * - `'off'` — nothing. No span is opened for a request and no trace header is
+ *   sent, so the client sends exactly the headers the Promise client sends.
+ * - `'span'` — Effect's `HttpClient` opens its client span around each request,
+ *   a child of the span the call runs in. Nothing about it goes on the wire.
+ * - `'propagate'` — the span, also sent to the API as `b3` and `traceparent`.
+ *
+ * Only this client's requests are affected, and only ever toward less: a
+ * span asked for here is still subject to the application's own
+ * `HttpClient.TracerDisabledWhen` and `HttpClient.TracerPropagationEnabled`.
+ */
+type Tracing = 'off' | 'span' | 'propagate';
+/** Per-call options: the last argument of every operation and raw method. */
+interface RequestOptions {
+  /** Headers for this call; they win over the client's defaults, and `null` removes one. */
+  readonly headers?: HeadersLike;
+  /**
+   * Maximum retries for temporary failures on this call. Without it, a call
+   * whose method is idempotent (`GET`, `HEAD`, `OPTIONS`, `PUT`, `DELETE`)
+   * takes the client's, which defaults to 2, and any other call is sent once.
+   */
+  readonly maxRetries?: number | undefined;
+  /**
+   * Time budget for each attempt of this call, in milliseconds; a redirect
+   * chain shares one. Defaults to the client's, which defaults to one minute.
+   */
+  readonly timeout?: number | undefined;
+  /**
+   * Validates the success body against the operation's response schema, and
+   * fails with a `DecodeError` naming where it does not match. The value
+   * returned is the body as parsed either way: validation removes nothing.
+   * Defaults to the client's, which defaults to `false`.
+   *
+   * The schema is loaded on first use, through the `schemas` the client was
+   * constructed with; asking a client that was given none fails the call with
+   * a `ConfigurationError`. A raw call is validated when its path is a
+   * declared operation's, and has no schema to be held to otherwise.
+   */
+  readonly decode?: boolean | undefined;
+}
+/** What a raw `get` accepts beside the per-call options. */
+interface RawRequestOptions extends RequestOptions {
+  readonly query?: Record<string, unknown> | null | undefined;
+}
+/** What a raw `post`, `put`, `patch` or `delete` accepts beside the per-call options. */
+interface RawBodyRequestOptions extends RawRequestOptions {
+  readonly body?: unknown;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/cli/realtime.d.ts
+/** `client._internal.cli.realtime` on the Effect surface. */
+interface Realtime {
+  readonly auth: (body: RealtimeAuthParams, options?: RequestOptions) => Effect.Effect<RealtimeAuthResponse, ComposioError>;
+  readonly credentials: (options?: RequestOptions) => Effect.Effect<RealtimeCredentialsResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/cli/cli.d.ts
+/** `client._internal.cli` on the Effect surface. */
+interface Cli {
+  readonly realtime: Realtime;
+  readonly createSession: (body?: CliCreateSessionParams | null | undefined, options?: RequestOptions) => Effect.Effect<CliCreateSessionResponse, ComposioError>;
+  readonly getSession: (query: CliGetSessionParams, options?: RequestOptions) => Effect.Effect<CliGetSessionResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/logs/triggers.d.ts
+/** `client._internal.logs.triggers` on the Effect surface. */
+interface Triggers {
+  /** @deprecated Deprecated in the input OpenAPI schema. */
+  readonly retrieve: (id: string, options?: RequestOptions) => Effect.Effect<TriggerRetrieveResponse, ComposioError>;
+  readonly list: (body?: TriggerListParams | null | undefined, options?: RequestOptions) => Effect.Effect<TriggerListResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/logs/tools.d.ts
+/** `client._internal.logs.tools` on the Effect surface. */
+interface Tools {
+  readonly retrieve: (id: string, options?: RequestOptions) => Effect.Effect<ToolRetrieveResponse, ComposioError>;
+  readonly list: (body: ToolListParams, options?: RequestOptions) => Effect.Effect<ToolListResponse, ComposioError>;
+  /** @deprecated Deprecated in the input OpenAPI schema. */
+  readonly listFields: (options?: RequestOptions) => Effect.Effect<ToolListFieldsResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/logs/logs.d.ts
+/** `client._internal.logs` on the Effect surface. */
+interface Logs {
+  readonly triggers: Triggers;
+  readonly tools: Tools;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/org/consumer/project.d.ts
+/** `client._internal.org.consumer.project` on the Effect surface. */
+interface Project {
+  readonly resolve: (params: ProjectResolveParams, options?: RequestOptions) => Effect.Effect<ProjectResolveResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/org/consumer/consumer.d.ts
+/** `client._internal.org.consumer` on the Effect surface. */
+interface Consumer {
+  readonly project: Project;
+  readonly listConnectedToolkits: (params: ConsumerListConnectedToolkitsParams, options?: RequestOptions) => Effect.Effect<ConsumerListConnectedToolkitsResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/org/org.d.ts
+/** `client._internal.org` on the Effect surface. */
+interface Org {
+  readonly consumer: Consumer;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/_internal.d.ts
+/** `client._internal` on the Effect surface. */
+interface Internal {
+  readonly cli: Cli;
+  readonly logs: Logs;
+  readonly org: Org;
+}
+//#endregion
+export { PermissionDeniedError as C, isComposioError as D, isAPIError as E, NotFoundError as S, UnprocessableEntityError as T, ConfigurationError as _, Tracing as a, DecodeIssue as b, Credential as c, APIError as d, APIErrorFields as f, ComposioError as g, BadRequestError as h, RequestOptions as i, APIConnectionError as l, AuthenticationError as m, RawBodyRequestOptions as n, SchemaLoaders as o, APIStatusError as p, RawRequestOptions as r, Auth as s, Internal as t, APIConnectionTimeoutError as u, ConflictError as v, RateLimitError as w, InternalServerError as x, DecodeError as y };