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

package/dist/effect/schemas/tool-router/session/config-history.d.mts

@@ -0,0 +1,93 @@
+//#region src/effect/generated/schemas/tool-router/session/config-history.d.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}/config_history`, which `client.toolRouter.session.configHistory` answers with. */
+declare const SessionConfigHistoryResponse: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+  readonly items: import("effect/Schema").$Array<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly version: import("effect/Schema").Number;
+    readonly created_at: import("effect/Schema").String;
+    readonly config: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly user_id: import("effect/Schema").String;
+      readonly toolkits: import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly enabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, import("effect/Schema").Struct<{
+        readonly disabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, import("effect/Schema").Struct<{
+        readonly require_approval: import("effect/Schema").$Array<import("effect/Schema").String>;
+      }>]>>;
+      readonly auth_configs: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+      readonly instant: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<false>, import("effect/Schema").Struct<{
+        readonly toolkits: import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+          readonly enabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+          readonly disabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>]>>;
+        readonly tools: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+          readonly enabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>, import("effect/Schema").Struct<{
+          readonly disabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>]>>>;
+        readonly return_instant_charge: import("effect/Schema").Boolean;
+      }>]>;
+      readonly manage_connections: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enabled: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+        readonly callback_url: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly enable_wait_for_connections: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+        readonly enable_connection_removal: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+      readonly tools: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly enabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, import("effect/Schema").Struct<{
+        readonly disabled: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, import("effect/Schema").Struct<{
+        readonly tags: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+          readonly enabled: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+          readonly disabled: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+          readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, import("effect/Schema").Struct<{
+        readonly require_approval: import("effect/Schema").$Array<import("effect/Schema").String>;
+      }>]>>>;
+      readonly tags: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enabled: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly disabled: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+      readonly workbench: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enable: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+        readonly tool_execution_enabled: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+        readonly proxy_execution_enabled: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+        readonly auto_offload_threshold: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+        readonly sandbox_size: import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["standard", "medium", "large", "xlarge"]>>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+      readonly multi_account: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enable: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+        readonly max_accounts_per_toolkit: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+        readonly require_explicit_selection: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+      readonly proxy_execute: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enable: import("effect/Schema").Boolean;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+      readonly preload: import("effect/Schema").Struct<{
+        readonly tools: import("effect/Schema").Union<readonly [import("effect/Schema").$Array<import("effect/Schema").String>, import("effect/Schema").Literal<"all">]>;
+      }>;
+      readonly connected_accounts: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>>>;
+      readonly search: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enable: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+      readonly execute: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly enable_multi_execute: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+    readonly is_current: import("effect/Schema").Boolean;
+  }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+  readonly next_cursor: import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Null]>>;
+  readonly total_pages: import("effect/Schema").Number;
+  readonly current_page: import("effect/Schema").Number;
+  readonly total_items: import("effect/Schema").Number;
+}>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+//#endregion
+export { SessionConfigHistoryResponse };

package/dist/effect/schemas/tool-router/session/config-history.mjs

@@ -0,0 +1,8 @@
+import { ToolRouterSessionV31ConfigHistoryListResponse } from "../../components/tool-router-session-v31-config-history-list-response.mjs";
+
+//#region src/effect/generated/schemas/tool-router/session/config-history.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}/config_history`, which `client.toolRouter.session.configHistory` answers with. */
+const SessionConfigHistoryResponse = ToolRouterSessionV31ConfigHistoryListResponse;
+
+//#endregion
+export { SessionConfigHistoryResponse };

package/dist/effect/schemas/tool-router/session/create.d.mts

@@ -0,0 +1,128 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/create.d.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session`, which `client.toolRouter.session.create` answers with. */
+declare const SessionCreateResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly session_id: Schema.String;
+  readonly mcp: Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"http">;
+    readonly url: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly tool_router_tools: Schema.$Array<Schema.String>;
+  readonly config: Schema.StructWithRest<Schema.Struct<{
+    readonly user_id: Schema.String;
+    readonly toolkits: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly enabled: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly disabled: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly require_approval: Schema.$Array<Schema.String>;
+    }>]>>;
+    readonly auth_configs: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly instant: Schema.Union<readonly [Schema.Literal<false>, Schema.Struct<{
+      readonly toolkits: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly enabled: Schema.$Array<Schema.String>;
+      }>, Schema.Struct<{
+        readonly disabled: Schema.$Array<Schema.String>;
+      }>]>>;
+      readonly tools: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly enabled: Schema.$Array<Schema.String>;
+      }>, Schema.Struct<{
+        readonly disabled: Schema.$Array<Schema.String>;
+      }>]>>>;
+      readonly return_instant_charge: Schema.Boolean;
+    }>]>;
+    readonly manage_connections: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly enabled: Schema.optionalKey<Schema.Boolean>;
+      readonly callback_url: Schema.optionalKey<Schema.String>;
+      readonly enable_wait_for_connections: Schema.optionalKey<Schema.Boolean>;
+      readonly enable_connection_removal: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly tools: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+      readonly enabled: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly disabled: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly tags: Schema.StructWithRest<Schema.Struct<{
+        readonly enabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly disabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly require_approval: Schema.$Array<Schema.String>;
+    }>]>>>;
+    readonly tags: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly enabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      readonly disabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly workbench: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly enable: Schema.optionalKey<Schema.Boolean>;
+      readonly tool_execution_enabled: Schema.optionalKey<Schema.Boolean>;
+      readonly proxy_execution_enabled: Schema.optionalKey<Schema.Boolean>;
+      readonly auto_offload_threshold: Schema.optionalKey<Schema.Number>;
+      readonly sandbox_size: Schema.optionalKey<Schema.Literals<readonly ["standard", "medium", "large", "xlarge"]>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly multi_account: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly enable: Schema.optionalKey<Schema.Boolean>;
+      readonly max_accounts_per_toolkit: Schema.optionalKey<Schema.Number>;
+      readonly require_explicit_selection: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly proxy_execute: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly enable: Schema.Boolean;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly preload: Schema.Struct<{
+      readonly tools: Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Literal<"all">]>;
+    }>;
+    readonly connected_accounts: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+    readonly search: Schema.StructWithRest<Schema.Struct<{
+      readonly enable: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly execute: Schema.StructWithRest<Schema.Struct<{
+      readonly enable_multi_execute: Schema.optionalKey<Schema.Boolean>;
+    }>, 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 config_version: Schema.Number;
+  readonly experimental: Schema.optionalKey<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>>]>>;
+  readonly warnings: Schema.optionalKey<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>>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionCreateResponse };

package/dist/effect/schemas/tool-router/session/create.mjs

@@ -0,0 +1,45 @@
+import { SessionCreateResponseConfig } from "../../components/session-create-response-config.mjs";
+import { SessionCreateResponseExperimentalCustomToolkits } from "../../components/session-create-response-experimental-custom-toolkits.mjs";
+import { SessionCreateResponseWarnings } from "../../components/session-create-response-warnings.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/create.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session`, which `client.toolRouter.session.create` answers with. */
+const SessionCreateResponse = Schema.StructWithRest(Schema.Struct({
+	"session_id": Schema.String.annotate({
+		"description": "The identifier of the session",
+		"examples": ["trs_1a2b3c4d5e6f"],
+		"format": "toolRouterSessionId"
+	}),
+	"mcp": Schema.StructWithRest(Schema.Struct({
+		"type": Schema.Literal("http").annotate({ "description": "The type of the MCP server. Can be http" }),
+		"url": Schema.String.annotate({
+			"description": "The URL of the MCP server",
+			"examples": ["https://app.composio.dev/tool_router/v3/trs_1a2b3c4d5e6f/mcp"],
+			"format": "uri"
+		})
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]),
+	"tool_router_tools": Schema.Array(Schema.String).annotate({ "description": "List of available tools in this session" }),
+	"config": SessionCreateResponseConfig,
+	"config_version": Schema.Number.annotate({ "description": "Monotonic version of the config. Incremented on each PATCH. Use for optimistic concurrency control." }).check(Schema.isInt().annotate({ "expected": "an integer" })),
+	"experimental": Schema.optionalKey(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 - may change without notice" })),
+	"warnings": Schema.optionalKey(SessionCreateResponseWarnings)
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { SessionCreateResponse };

package/dist/effect/schemas/tool-router/session/delete.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/delete.d.ts
+/** The 200 response of `DELETE /api/v3.1/tool_router/session/{session_id}`, which `client.toolRouter.session.delete` answers with. */
+declare const SessionDeleteResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly session_id: Schema.String;
+  readonly deleted: Schema.Literal<true>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionDeleteResponse };

package/dist/effect/schemas/tool-router/session/delete.mjs

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/delete.ts
+/** The 200 response of `DELETE /api/v3.1/tool_router/session/{session_id}`, which `client.toolRouter.session.delete` answers with. */
+const SessionDeleteResponse = Schema.StructWithRest(Schema.Struct({
+	"session_id": Schema.String.annotate({
+		"description": "The unique identifier of the deleted tool router session",
+		"examples": ["trs_1a2b3c4d5e6f"],
+		"format": "toolRouterSessionId"
+	}),
+	"deleted": Schema.Literal(true).annotate({
+		"description": "Always true — present to make the outcome explicit",
+		"examples": [true]
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { SessionDeleteResponse };

package/dist/effect/schemas/tool-router/session/execute-meta.d.mts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/execute-meta.d.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/execute_meta`, which `client.toolRouter.session.executeMeta` answers with. */
+declare const SessionExecuteMetaResponse: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"completed">;
+  readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly amount: Schema.String;
+    readonly currency: Schema.Literal<"USD">;
+    readonly charged_by: Schema.Literal<"composio">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly log_id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"failed">;
+  readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly amount: Schema.String;
+    readonly currency: Schema.Literal<"USD">;
+    readonly charged_by: Schema.Literal<"composio">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly log_id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"input_required">;
+  readonly input_requests: Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"elicitation">;
+    readonly mode: Schema.Literal<"form">;
+    readonly message: Schema.String;
+    readonly requested_schema: 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 request_state: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
+//#endregion
+export { SessionExecuteMetaResponse };

package/dist/effect/schemas/tool-router/session/execute-meta.mjs

@@ -0,0 +1,15 @@
+import { ExecuteCompleted } from "../../components/execute-completed.mjs";
+import { ExecuteFailed } from "../../components/execute-failed.mjs";
+import { ExecuteRequiresUserInput } from "../../components/execute-requires-user-input.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/execute-meta.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/execute_meta`, which `client.toolRouter.session.executeMeta` answers with. */
+const SessionExecuteMetaResponse = Schema.Union([
+	ExecuteCompleted,
+	ExecuteFailed,
+	ExecuteRequiresUserInput
+], { mode: "oneOf" });
+
+//#endregion
+export { SessionExecuteMetaResponse };

package/dist/effect/schemas/tool-router/session/execute.d.mts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/execute.d.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/execute`, which `client.toolRouter.session.execute` answers with. */
+declare const SessionExecuteResponse: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"completed">;
+  readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly amount: Schema.String;
+    readonly currency: Schema.Literal<"USD">;
+    readonly charged_by: Schema.Literal<"composio">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly log_id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"failed">;
+  readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly amount: Schema.String;
+    readonly currency: Schema.Literal<"USD">;
+    readonly charged_by: Schema.Literal<"composio">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly log_id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"input_required">;
+  readonly input_requests: Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"elicitation">;
+    readonly mode: Schema.Literal<"form">;
+    readonly message: Schema.String;
+    readonly requested_schema: 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 request_state: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
+//#endregion
+export { SessionExecuteResponse };

package/dist/effect/schemas/tool-router/session/execute.mjs

@@ -0,0 +1,15 @@
+import { ExecuteCompleted } from "../../components/execute-completed.mjs";
+import { ExecuteFailed } from "../../components/execute-failed.mjs";
+import { ExecuteRequiresUserInput } from "../../components/execute-requires-user-input.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/execute.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/execute`, which `client.toolRouter.session.execute` answers with. */
+const SessionExecuteResponse = Schema.Union([
+	ExecuteCompleted,
+	ExecuteFailed,
+	ExecuteRequiresUserInput
+], { mode: "oneOf" });
+
+//#endregion
+export { SessionExecuteResponse };

package/dist/effect/schemas/tool-router/session/files/create-download-url.d.mts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/files/create-download-url.d.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/download_url`, which `client.toolRouter.session.files.createDownloadURL` answers with. */
+declare const FileCreateDownloadURLResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly download_url: Schema.String;
+  readonly mount_relative_path: Schema.String;
+  readonly sandbox_mount_prefix: Schema.String;
+  readonly expires_at: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { FileCreateDownloadURLResponse };

package/dist/effect/schemas/tool-router/session/files/create-download-url.mjs

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/files/create-download-url.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/download_url`, which `client.toolRouter.session.files.createDownloadURL` answers with. */
+const FileCreateDownloadURLResponse = Schema.StructWithRest(Schema.Struct({
+	"download_url": Schema.String.annotate({ "description": "Presigned download URL for the file" }),
+	"mount_relative_path": Schema.String.annotate({ "description": "Relative file path within the mount (e.g. \"report.pdf\")" }),
+	"sandbox_mount_prefix": Schema.String.annotate({ "description": "Absolute mount path inside the sandbox (e.g. /mnt/files)" }),
+	"expires_at": Schema.String.annotate({ "description": "ISO 8601 timestamp when the download URL expires" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { FileCreateDownloadURLResponse };

package/dist/effect/schemas/tool-router/session/files/create-upload-url.d.mts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/files/create-upload-url.d.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/upload_url`, which `client.toolRouter.session.files.createUploadURL` answers with. */
+declare const FileCreateUploadURLResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly upload_url: Schema.String;
+  readonly mount_relative_path: Schema.String;
+  readonly sandbox_mount_prefix: Schema.String;
+  readonly expires_at: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { FileCreateUploadURLResponse };

package/dist/effect/schemas/tool-router/session/files/create-upload-url.mjs

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/files/create-upload-url.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/upload_url`, which `client.toolRouter.session.files.createUploadURL` answers with. */
+const FileCreateUploadURLResponse = Schema.StructWithRest(Schema.Struct({
+	"upload_url": Schema.String.annotate({ "description": "Presigned upload URL — PUT the file content here" }),
+	"mount_relative_path": Schema.String.annotate({ "description": "Relative file path within the mount (e.g. \"report.pdf\")" }),
+	"sandbox_mount_prefix": Schema.String.annotate({ "description": "Absolute mount path inside the sandbox (e.g. /mnt/files)" }),
+	"expires_at": Schema.String.annotate({ "description": "ISO 8601 timestamp when the upload URL expires" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { FileCreateUploadURLResponse };

package/dist/effect/schemas/tool-router/session/files/delete.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/files/delete.d.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/delete`, which `client.toolRouter.session.files.delete` answers with. */
+declare const FileDeleteResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly mount_relative_path: Schema.String;
+  readonly sandbox_mount_prefix: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { FileDeleteResponse };

package/dist/effect/schemas/tool-router/session/files/delete.mjs

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/files/delete.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/delete`, which `client.toolRouter.session.files.delete` answers with. */
+const FileDeleteResponse = Schema.StructWithRest(Schema.Struct({
+	"mount_relative_path": Schema.String.annotate({ "description": "Relative file path that was deleted" }),
+	"sandbox_mount_prefix": Schema.String.annotate({ "description": "Absolute mount path inside the sandbox (e.g. /mnt/files)" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { FileDeleteResponse };

package/dist/effect/schemas/tool-router/session/files/list.d.mts

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/files/list.d.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/items`, which `client.toolRouter.session.files.list` answers with. */
+declare const FileListResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly items: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly mount_relative_path: Schema.String;
+    readonly sandbox_mount_prefix: Schema.String;
+    readonly size: Schema.Number;
+    readonly last_modified: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly next_cursor: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { FileListResponse };

package/dist/effect/schemas/tool-router/session/files/list.mjs

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/files/list.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}/mounts/{mount_id}/items`, which `client.toolRouter.session.files.list` answers with. */
+const FileListResponse = Schema.StructWithRest(Schema.Struct({
+	"items": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"mount_relative_path": Schema.String.annotate({ "description": "Relative file path within the mount (e.g. \"report.pdf\")" }),
+		"sandbox_mount_prefix": Schema.String.annotate({ "description": "Absolute mount path inside the sandbox (e.g. /mnt/files)" }),
+		"size": Schema.Number.annotate({ "description": "File size in bytes" }).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"last_modified": Schema.String.annotate({ "description": "ISO 8601 timestamp of last modification" })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "List of files in the mount" }),
+	"next_cursor": Schema.optionalKey(Schema.String.annotate({ "description": "Cursor for the next page of results. If absent, there are no more pages." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { FileListResponse };

package/dist/effect/schemas/tool-router/session/link.d.mts

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/link.d.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session/{session_id}/link`, which `client.toolRouter.session.link` answers with. */
+declare const SessionLinkResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly link_token: Schema.String;
+  readonly redirect_url: Schema.String;
+  readonly connected_account_id: Schema.String;
+  readonly experimental: Schema.optionalKey<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>>]>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionLinkResponse };

package/dist/effect/schemas/tool-router/session/link.mjs

@@ -0,0 +1,25 @@
+import { SessionLinkResponseExperimental } from "../../components/session-link-response-experimental.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/link.ts
+/** The 201 response of `POST /api/v3.1/tool_router/session/{session_id}/link`, which `client.toolRouter.session.link` answers with. */
+const SessionLinkResponse = Schema.StructWithRest(Schema.Struct({
+	"link_token": Schema.String.annotate({
+		"description": "Token used to complete the authentication flow",
+		"examples": ["lt_abc123xyz"]
+	}),
+	"redirect_url": Schema.String.annotate({
+		"description": "The URL where users should be redirected to complete OAuth",
+		"examples": ["https://app.composio.dev/link/lt_abc123xyz"],
+		"format": "uri"
+	}),
+	"connected_account_id": Schema.String.annotate({
+		"description": "The unique identifier for the connected account",
+		"examples": ["ca_abc123xyz"],
+		"format": "connectedAccountId"
+	}),
+	"experimental": Schema.optionalKey(SessionLinkResponseExperimental)
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { SessionLinkResponse };