@composio/client 2.0.0-rc.11 → 2.0.0-rc.12

package/dist/effect/schemas/components/session-create-response-config.mjs

@@ -0,0 +1,130 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/session-create-response-config.ts
+/** The `SessionCreateResponseConfig` component schema. */
+const SessionCreateResponseConfig = Schema.StructWithRest(Schema.Struct({
+	"user_id": Schema.String.annotate({ "description": "User identifier for this session" }),
+	"toolkits": Schema.optionalKey(Schema.Union([
+		Schema.Struct({
+			"enabled": Schema.Array(Schema.String),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+		}),
+		Schema.Struct({
+			"disabled": Schema.Array(Schema.String),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+		}),
+		Schema.Struct({ "require_approval": Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }) })
+	]).annotate({ "description": "Toolkit configuration - either enabled list or disabled list, or toolkits whose tools need approval" })),
+	"auth_configs": Schema.optionalKey(Schema.Record(Schema.String, Schema.String.annotate({ "format": "authConfigId" })).annotate({ "description": "Auth config overrides per toolkit" })),
+	"instant": Schema.Union([Schema.Literal(false), Schema.Struct({
+		"toolkits": Schema.optionalKey(Schema.Union([Schema.Struct({ "enabled": Schema.Array(Schema.String) }), Schema.Struct({ "disabled": Schema.Array(Schema.String) })]).annotate({ "description": "Toolkits eligible for instant usage, as an enabled or disabled list. If absent, no additional toolkit restriction applies." })),
+		"tools": Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([Schema.Struct({ "enabled": Schema.Array(Schema.String) }), Schema.Struct({ "disabled": Schema.Array(Schema.String) })])).annotate({ "description": "Per-toolkit enabled or disabled lists that restrict instant usage. Toolkits absent from this map have no additional tool restriction." })),
+		"return_instant_charge": Schema.Boolean.annotate({ "description": "Whether session tool responses return a top-level instant_charge when a charge is available. Defaults to false; controls response visibility only." })
+	})]).annotate({ "description": "Instant usage settings. False disables instant usage; an object permits it subject to project permission and session toolkit and tool restrictions." }),
+	"manage_connections": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"enabled": Schema.optionalKey(Schema.Boolean.annotate({
+			"description": "Whether to enable the connection manager for automatic connection handling",
+			"default": true
+		})),
+		"callback_url": Schema.optionalKey(Schema.String.annotate({
+			"description": "Custom callback URL for connected account auth flows",
+			"format": "uri"
+		})),
+		"enable_wait_for_connections": Schema.optionalKey(Schema.Boolean.annotate({
+			"description": "Enable the COMPOSIO_WAIT_FOR_CONNECTIONS tool for polling connection status. Default false. May not work reliably with GPT models.",
+			"default": false
+		})),
+		"enable_connection_removal": Schema.optionalKey(Schema.Boolean.annotate({
+			"description": "Enable the \"remove\" action in COMPOSIO_MANAGE_CONNECTIONS. Default true.",
+			"default": true
+		}))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Manage connections configuration" })),
+	"tools": Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([
+		Schema.Struct({
+			"enabled": Schema.Array(Schema.String),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+		}),
+		Schema.Struct({
+			"disabled": Schema.Array(Schema.String),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+		}),
+		Schema.Struct({
+			"tags": Schema.StructWithRest(Schema.Struct({
+				"enabled": Schema.optionalKey(Schema.Array(Schema.Literals([
+					"readOnlyHint",
+					"destructiveHint",
+					"idempotentHint",
+					"openWorldHint"
+				])).annotate({ "description": "Tags that the tool must have at least one of" })),
+				"disabled": Schema.optionalKey(Schema.Array(Schema.Literals([
+					"readOnlyHint",
+					"destructiveHint",
+					"idempotentHint",
+					"openWorldHint"
+				])).annotate({ "description": "Tags that the tool must NOT have any of" })),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+					"readOnlyHint",
+					"destructiveHint",
+					"idempotentHint",
+					"openWorldHint"
+				])).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+			}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+		}),
+		Schema.Struct({ "require_approval": Schema.Array(Schema.String).annotate({ "description": "Tool calls matched here pause until the user approves them." }) })
+	])).annotate({ "description": "Tool-level configuration per toolkit: tools to enable or disable, or tools that need approval" })),
+	"tags": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"enabled": Schema.optionalKey(Schema.Array(Schema.Literals([
+			"readOnlyHint",
+			"destructiveHint",
+			"idempotentHint",
+			"openWorldHint"
+		])).annotate({ "description": "Tags that the tool must have at least one of" })),
+		"disabled": Schema.optionalKey(Schema.Array(Schema.Literals([
+			"readOnlyHint",
+			"destructiveHint",
+			"idempotentHint",
+			"openWorldHint"
+		])).annotate({ "description": "Tags that the tool must NOT have any of" })),
+		"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+			"readOnlyHint",
+			"destructiveHint",
+			"idempotentHint",
+			"openWorldHint"
+		])).annotate({ "description": "Tool calls matched here pause until the user approves them." }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "MCP tool annotation hints for filtering tools with enabled/disabled support, and experimentally the tags whose tools need approval. enabled: tags that the tool must have at least one of. disabled: tags that the tool must NOT have any of. Both conditions must be satisfied." })),
+	"workbench": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"enable": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether the workbench (code execution sandbox) is enabled. When false, COMPOSIO_REMOTE_WORKBENCH and COMPOSIO_REMOTE_BASH_TOOL are not exposed." })),
+		"tool_execution_enabled": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether tool execution is enabled in the workbench" })),
+		"proxy_execution_enabled": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether proxy execution is enabled in the workbench" })),
+		"auto_offload_threshold": Schema.optionalKey(Schema.Number.annotate({ "description": "Character threshold after which tool execution response are saved to a file in workbench. Default is 20k." }).check(Schema.isFinite().annotate({ "expected": "a finite number" })).check(Schema.isGreaterThan(0).annotate({ "expected": "a value greater than 0" }))),
+		"sandbox_size": Schema.optionalKey(Schema.Literals([
+			"standard",
+			"medium",
+			"large",
+			"xlarge"
+		]).annotate({ "description": "Sandbox compute tier: standard (1 vCPU / 1 GB), medium (2 vCPU / 2 GB), large (4 vCPU / 4 GB), xlarge (8 vCPU / 8 GB). Defaults to standard." }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({
+		"description": "Workbench configuration",
+		"default": {
+			"enable": true,
+			"proxy_execution_enabled": true
+		}
+	})),
+	"multi_account": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"enable": Schema.optionalKey(Schema.Boolean.annotate({ "description": "When true, enables multi-account mode for this session. When not set, falls back to org/project-level configuration." })),
+		"max_accounts_per_toolkit": Schema.optionalKey(Schema.Number.annotate({ "description": "Maximum number of connected accounts allowed per toolkit. Defaults to 5 when multi-account is enabled." }).check(Schema.isInt().annotate({ "expected": "an integer" }))),
+		"require_explicit_selection": Schema.optionalKey(Schema.Boolean.annotate({ "description": "When true, require explicit account selection when multiple accounts are connected. When false (default), use the first/default account." }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Multi-account configuration for this session." })),
+	"proxy_execute": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "enable": Schema.Boolean.annotate({ "description": "When true, enables proxy execute outside the workbench. When false, also disables proxy execution inside the workbench." }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Proxy execute configuration for this session. Omitted when not set." })),
+	"preload": Schema.Struct({ "tools": Schema.Union([Schema.Array(Schema.String), Schema.Literal("all")]).annotate({ "description": "Explicit preloaded tool slugs, or \"all\" when the session dynamically exposes all app tools allowed by its filters." }) }).annotate({ "description": "Preload configuration. Explicit slugs are returned as an array; dynamic preload is returned as \"all\"." }),
+	"connected_accounts": Schema.optionalKey(Schema.Record(Schema.String, Schema.Array(Schema.String.annotate({ "format": "connectedAccountId" })).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).annotate({ "description": "Per-toolkit connected account overrides (array of nano-IDs). Multi-account sessions can pin more than one account per toolkit; otherwise length is 1." })),
+	"search": Schema.StructWithRest(Schema.Struct({ "enable": Schema.optionalKey(Schema.Boolean.annotate({ "default": true })) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Search helper configuration" }),
+	"execute": Schema.StructWithRest(Schema.Struct({ "enable_multi_execute": Schema.optionalKey(Schema.Boolean.annotate({ "default": true })) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Execute helper configuration" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"description": "The configuration used to create this session",
+	"identifier": "SessionCreateResponseConfig"
+});
+
+//#endregion
+export { SessionCreateResponseConfig };

package/dist/effect/schemas/components/session-create-response-experimental-custom-toolkits.d.mts

@@ -0,0 +1,20 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/session-create-response-experimental-custom-toolkits.d.ts
+/** The `SessionCreateResponseExperimentalCustomToolkits` component schema. */
+declare const SessionCreateResponseExperimentalCustomToolkits: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+  readonly slug: Schema.String;
+  readonly name: Schema.String;
+  readonly description: Schema.String;
+  readonly tools: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly input_schema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly output_schema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly original_slug: Schema.String;
+    readonly preload: Schema.optionalKey<Schema.Boolean>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly preload: Schema.optionalKey<Schema.Boolean>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+//#endregion
+export { SessionCreateResponseExperimentalCustomToolkits };

package/dist/effect/schemas/components/session-create-response-experimental-custom-toolkits.mjs

@@ -0,0 +1,25 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/session-create-response-experimental-custom-toolkits.ts
+/** The `SessionCreateResponseExperimentalCustomToolkits` component schema. */
+const SessionCreateResponseExperimentalCustomToolkits = Schema.Array(Schema.StructWithRest(Schema.Struct({
+	"slug": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-zA-Z0-9_-]+$", "u")).annotate({ "expected": "a string matching the RegExp ^[a-zA-Z0-9_-]+$" })),
+	"name": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ "expected": "a string with at most 128 code points" })),
+	"description": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(2048).annotate({ "expected": "a string with at most 2048 code points" })),
+	"tools": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"slug": Schema.String.annotate({ "description": "Prefixed tool slug (e.g. LOCAL_CRM_FIND_CUSTOMER)" }),
+		"name": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ "expected": "a string with at most 128 code points" })),
+		"description": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(5120).annotate({ "expected": "a string with at most 5120 code points" })),
+		"input_schema": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })),
+		"output_schema": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))),
+		"original_slug": Schema.String.annotate({ "description": "Original tool slug as provided by the user" }),
+		"preload": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Echoes the SDK-local preload hint provided for this tool" }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+	"preload": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Echoes the SDK-local preload hint provided for this toolkit" }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({
+	"description": "User-defined custom toolkits with grouped tools (no-auth)",
+	"identifier": "SessionCreateResponseExperimentalCustomToolkits"
+});
+
+//#endregion
+export { SessionCreateResponseExperimentalCustomToolkits };

package/dist/effect/schemas/components/session-create-response-warnings.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/session-create-response-warnings.d.ts
+/** The `SessionCreateResponseWarnings` component schema. */
+declare const SessionCreateResponseWarnings: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+  readonly code: Schema.Literal<"PRELOAD_TOOLS_HIGH_CONTEXT_USAGE">;
+  readonly message: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+//#endregion
+export { SessionCreateResponseWarnings };

package/dist/effect/schemas/components/session-create-response-warnings.mjs

@@ -0,0 +1,25 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/session-create-response-warnings.ts
+/** The `SessionCreateResponseWarnings` component schema. */
+const SessionCreateResponseWarnings = Schema.Array(Schema.StructWithRest(Schema.Struct({
+	"code": Schema.Literal("PRELOAD_TOOLS_HIGH_CONTEXT_USAGE").annotate({
+		"description": "Stable machine code identifying the advisory. Safe to switch on in client code.",
+		"examples": ["PRELOAD_TOOLS_HIGH_CONTEXT_USAGE"]
+	}),
+	"message": Schema.String.annotate({
+		"description": "Human-readable description of the advisory. Suitable for logging or surfacing to end users.",
+		"examples": ["Session preloads 25 tools; each preloaded tool adds to the agent context window. Consider keeping the list at or under ~20 tools."]
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({
+	"description": "Advisory list — the session exists and is usable, but the listed issues may warrant attention.",
+	"default": [],
+	"examples": [[{
+		"code": "PRELOAD_TOOLS_HIGH_CONTEXT_USAGE",
+		"message": "Session preloads 25 tools; each preloaded tool adds to the agent context window. Consider keeping the list at or under ~20 tools."
+	}]],
+	"identifier": "SessionCreateResponseWarnings"
+});
+
+//#endregion
+export { SessionCreateResponseWarnings };

package/dist/effect/schemas/components/session-link-response-experimental.d.mts

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/session-link-response-experimental.d.ts
+/** The `SessionLinkResponseExperimental` component schema. */
+declare const SessionLinkResponseExperimental: Schema.StructWithRest<Schema.Struct<{
+  readonly account_type: Schema.Literals<readonly ["PRIVATE", "SHARED"]>;
+  readonly acl_config_for_shared: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly allow_all_users: Schema.Boolean;
+    readonly allowed_user_ids: Schema.$Array<Schema.String>;
+    readonly not_allowed_user_ids: Schema.$Array<Schema.String>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionLinkResponseExperimental };

package/dist/effect/schemas/components/session-link-response-experimental.mjs

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/session-link-response-experimental.ts
+/** The `SessionLinkResponseExperimental` component schema. */
+const SessionLinkResponseExperimental = Schema.StructWithRest(Schema.Struct({
+	"account_type": Schema.Literals(["PRIVATE", "SHARED"]).annotate({ "description": "Sharing model for this connected account. PRIVATE is usable only by the owning user_id. SHARED is reachable from a tool-router session only when explicitly pinned in the session config." }),
+	"acl_config_for_shared": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"allow_all_users": Schema.Boolean,
+		"allowed_user_ids": Schema.Array(Schema.String),
+		"not_allowed_user_ids": Schema.Array(Schema.String)
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Access control for SHARED connections. Visible only to the connection creator and project/org API key callers; non-creator cookie callers receive the response without this block." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"description": "Experimental features - not stable, may be modified or removed in future versions.",
+	"identifier": "SessionLinkResponseExperimental"
+});
+
+//#endregion
+export { SessionLinkResponseExperimental };

package/dist/effect/schemas/components/session-retrieve-response-experimental.d.mts

@@ -0,0 +1,37 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/session-retrieve-response-experimental.d.ts
+/** The `SessionRetrieveResponseExperimental` component schema. */
+declare const SessionRetrieveResponseExperimental: Schema.StructWithRest<Schema.Struct<{
+  readonly assistive_prompt: Schema.optionalKey<Schema.String>;
+  readonly custom_toolkits: Schema.optionalKey<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly tools: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+      readonly slug: Schema.String;
+      readonly name: Schema.String;
+      readonly description: Schema.String;
+      readonly input_schema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+      readonly output_schema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+      readonly original_slug: Schema.String;
+      readonly preload: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly preload: Schema.optionalKey<Schema.Boolean>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+  readonly custom_tools: Schema.optionalKey<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly input_schema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly output_schema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly extends_toolkit: Schema.optionalKey<Schema.String>;
+    readonly original_slug: Schema.String;
+    readonly preload: Schema.optionalKey<Schema.Boolean>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+  readonly no_elicitation_support_fallback: Schema.optionalKey<Schema.Literals<readonly ["deny", "allow"]>>;
+  readonly source_session_config: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionRetrieveResponseExperimental };

package/dist/effect/schemas/components/session-retrieve-response-experimental.mjs

@@ -0,0 +1,27 @@
+import { SessionCreateResponseExperimentalCustomToolkits } from "./session-create-response-experimental-custom-toolkits.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/session-retrieve-response-experimental.ts
+/** The `SessionRetrieveResponseExperimental` component schema. */
+const SessionRetrieveResponseExperimental = Schema.StructWithRest(Schema.Struct({
+	"assistive_prompt": Schema.optionalKey(Schema.String.annotate({ "description": "The assistive system prompt for the tool router session" })),
+	"custom_toolkits": Schema.optionalKey(SessionCreateResponseExperimentalCustomToolkits),
+	"custom_tools": Schema.optionalKey(Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"slug": Schema.String.annotate({ "description": "Prefixed tool slug (e.g. LOCAL_GMAIL_GET_IMPORTANT_EMAILS)" }),
+		"name": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ "expected": "a string with at most 128 code points" })),
+		"description": Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(5120).annotate({ "expected": "a string with at most 5120 code points" })),
+		"input_schema": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })),
+		"output_schema": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))),
+		"extends_toolkit": Schema.optionalKey(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))),
+		"original_slug": Schema.String.annotate({ "description": "Original tool slug as provided by the user" }),
+		"preload": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Echoes the SDK-local preload hint provided for this tool" }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Custom tools — standalone or extending Composio toolkits" })),
+	"no_elicitation_support_fallback": Schema.optionalKey(Schema.Literals(["deny", "allow"]).annotate({ "description": "What session MCP does with a tool call that needs approval when the MCP client can't ask the user. Omitted when not set, which means deny." })),
+	"source_session_config": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "id": Schema.String.annotate({ "format": "sessionConfigId" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Experimental provenance for the reusable Session config most recently applied to this Session." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({
+	"description": "Experimental v3.1 features",
+	"identifier": "SessionRetrieveResponseExperimental"
+});
+
+//#endregion
+export { SessionRetrieveResponseExperimental };

package/dist/effect/schemas/components/tool-details.d.mts

@@ -0,0 +1,51 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/tool-details.d.ts
+/** The `ToolDetails` component schema. */
+declare const ToolDetails: Schema.StructWithRest<Schema.Struct<{
+  readonly slug: Schema.String;
+  readonly name: Schema.String;
+  readonly description: Schema.String;
+  readonly toolkit: Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly logo: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly input_parameters: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly no_auth: Schema.Boolean;
+  readonly available_versions: Schema.$Array<Schema.String>;
+  readonly version: Schema.String;
+  readonly instant: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly supported: Schema.Literal<true>;
+    readonly price: Schema.optionalKey<Schema.Struct<{
+      readonly description: Schema.optionalKey<Schema.String>;
+      readonly discount: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly output_parameters: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly scopes: Schema.$Array<Schema.String>;
+  readonly scope_requirements: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly all_of: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.StructWithRest<Schema.Struct<{
+      readonly any_of: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.StructWithRest<Schema.Struct<{
+        readonly all_of: Schema.$Array<Schema.String>;
+        readonly source: Schema.optionalKey<Schema.$Array<Schema.String>>;
+      }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>>;
+      readonly when: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+      readonly source: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>>;
+    readonly source: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.Null]>;
+  readonly tags: Schema.$Array<Schema.String>;
+  readonly human_description: Schema.optionalKey<Schema.String>;
+  readonly is_deprecated: Schema.Boolean;
+  readonly deprecated: Schema.StructWithRest<Schema.Struct<{
+    readonly displayName: Schema.String;
+    readonly version: Schema.String;
+    readonly available_versions: Schema.$Array<Schema.String>;
+    readonly is_deprecated: Schema.Boolean;
+    readonly toolkit: Schema.StructWithRest<Schema.Struct<{
+      readonly logo: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolDetails };

package/dist/effect/schemas/components/tool-details.mjs

@@ -0,0 +1,144 @@
+import { InstantAccount } from "./instant-account.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/tool-details.ts
+/** The `ToolDetails` component schema. */
+const ToolDetails = Schema.StructWithRest(Schema.Struct({
+	"slug": Schema.String.annotate({
+		"description": "Unique identifier for the tool",
+		"examples": ["GITHUB_CREATE_A_WORKFLOW_DISPATCH_EVENT"]
+	}),
+	"name": Schema.String.annotate({
+		"description": "Human-readable display name of the tool",
+		"examples": ["GitHub Actions"]
+	}),
+	"description": Schema.String.annotate({
+		"description": "Detailed explanation of the tool's functionality and purpose",
+		"examples": ["Automate GitHub workflows including CI/CD, issue management, and release processes"]
+	}),
+	"toolkit": Schema.StructWithRest(Schema.Struct({
+		"slug": Schema.String.annotate({
+			"description": "Unique identifier of the parent toolkit",
+			"examples": ["github"]
+		}),
+		"name": Schema.String.annotate({
+			"description": "Human-readable name of the parent toolkit",
+			"examples": ["GitHub"]
+		}),
+		"logo": Schema.String.annotate({
+			"description": "URL to the toolkit logo image",
+			"examples": ["https://github.githubassets.com/assets/GitHub-Mark-ea2971cee799.png"]
+		})
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]),
+	"input_parameters": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({
+		"description": "Schema definition of required input parameters for the tool",
+		"examples": [{
+			"repo_name": {
+				"type": "string",
+				"description": "GitHub repository name in owner/repo format",
+				"required": true,
+				"example": "octocat/Hello-World"
+			},
+			"workflow_id": {
+				"type": "string",
+				"description": "ID or filename of the workflow to trigger",
+				"required": true,
+				"example": "main.yml"
+			}
+		}]
+	}),
+	"no_auth": Schema.Boolean.annotate({
+		"description": "Indicates if the tool can be used without authentication",
+		"examples": [false]
+	}),
+	"available_versions": Schema.Array(Schema.String).annotate({
+		"description": "List of all available versions for this tool",
+		"examples": [["20250905_00", "20250906_00"]]
+	}),
+	"version": Schema.String.annotate({
+		"description": "Current version of the tool",
+		"examples": ["20250905_00"]
+	}),
+	"instant": Schema.optionalKey(InstantAccount),
+	"output_parameters": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({
+		"description": "Schema definition of return values from the tool",
+		"examples": [{
+			"run_id": {
+				"type": "number",
+				"description": "ID of the workflow run that was triggered",
+				"example": 12345678
+			},
+			"status": {
+				"type": "string",
+				"description": "Status of the workflow run",
+				"example": "completed",
+				"enum": [
+					"queued",
+					"in_progress",
+					"completed",
+					"failed"
+				]
+			}
+		}]
+	}),
+	"scopes": Schema.Array(Schema.String).annotate({
+		"description": "List of scopes associated with the tool",
+		"examples": [["https://www.googleapis.com/auth/gmail.modify"]]
+	}),
+	"scope_requirements": Schema.Union([Schema.StructWithRest(Schema.Struct({
+		"all_of": Schema.Array(Schema.Union([Schema.String, Schema.StructWithRest(Schema.Struct({
+			"any_of": Schema.Array(Schema.Union([Schema.String, Schema.StructWithRest(Schema.Struct({
+				"all_of": Schema.Array(Schema.String).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+				"source": Schema.optionalKey(Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))
+			}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])])).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+			"when": Schema.optionalKey(Schema.Record(Schema.String, Schema.Array(Schema.String).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))),
+			"source": Schema.optionalKey(Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])])),
+		"source": Schema.optionalKey(Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]), Schema.Null]).annotate({
+		"description": "Structured scope requirements for the tool. Null means the tool is legacy and only exposes flat scopes.",
+		"examples": [{ "all_of": ["read:user", { "any_of": ["repo", "public_repo"] }] }]
+	}),
+	"tags": Schema.Array(Schema.String).annotate({
+		"description": "List of tags associated with the tool for categorization and filtering",
+		"examples": [[
+			"ci-cd",
+			"github",
+			"automation",
+			"devops"
+		]]
+	}),
+	"human_description": Schema.optionalKey(Schema.String.annotate({
+		"description": "Human-friendly description of the tool, if available",
+		"examples": ["Create a new issue in a GitHub repository"]
+	})),
+	"is_deprecated": Schema.Boolean.annotate({
+		"description": "Indicates if this tool is deprecated and may be removed in the future",
+		"examples": [false]
+	}),
+	"deprecated": Schema.StructWithRest(Schema.Struct({
+		"displayName": Schema.String.annotate({
+			"description": "The display name of the tool",
+			"examples": ["GitHub Actions"]
+		}),
+		"version": Schema.String.annotate({
+			"description": "Current version identifier of the tool",
+			"examples": ["20250905_00"]
+		}),
+		"available_versions": Schema.Array(Schema.String).annotate({
+			"description": "List of all available versions for this tool",
+			"examples": [["20250905_00", "20250906_00"]]
+		}),
+		"is_deprecated": Schema.Boolean.annotate({
+			"description": "Indicates if this tool is deprecated and may be removed in the future",
+			"examples": [false]
+		}),
+		"toolkit": Schema.StructWithRest(Schema.Struct({ "logo": Schema.String.annotate({
+			"description": "URL to the toolkit logo image",
+			"examples": ["https://github.githubassets.com/assets/GitHub-Mark-ea2971cee799.png"]
+		}) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ToolDetails" });
+
+//#endregion
+export { ToolDetails };

package/dist/effect/schemas/components/tool-pricing.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/tool-pricing.d.ts
+/** The `ToolPricing` component schema. */
+declare const ToolPricing: Schema.Struct<{
+  readonly description: Schema.optionalKey<Schema.String>;
+  readonly discount: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+//#endregion
+export { ToolPricing };

package/dist/effect/schemas/components/tool-pricing.mjs

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/tool-pricing.ts
+/** The `ToolPricing` component schema. */
+const ToolPricing = Schema.Struct({
+	"description": Schema.optionalKey(Schema.String.annotate({ "description": "Human-readable pricing description." })),
+	"discount": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Discount on top of provider charges." }))
+}).annotate({
+	"description": "Published pricing for the tool",
+	"identifier": "ToolPricing"
+});
+
+//#endregion
+export { ToolPricing };