@composio/client 2.0.0-rc.8 → 2.0.0

package/dist/effect/schemas/session-configs/retrieve.mjs

@@ -0,0 +1,103 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/session-configs/retrieve.ts
+/** The 200 response of `GET /api/v3.1/session_configs/{session_config_id}`, which `client.sessionConfigs.retrieve` answers with. */
+const SessionConfigsRetrieveResponse = Schema.StructWithRest(Schema.Struct({
+	"id": Schema.String.annotate({
+		"description": "Stable public identifier of the Session config.",
+		"format": "sessionConfigId"
+	}),
+	"name": Schema.String.annotate({ "description": "Project-unique display name." }),
+	"description": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Optional description of when the config should be used." }),
+	"archived": Schema.Boolean.annotate({ "description": "Whether the config is archived." }),
+	"config": Schema.Struct({
+		"toolkits": Schema.optionalKey(Schema.Union([
+			Schema.Struct({
+				"enable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({
+				"disable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({ "require_approval": Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }) })
+		])),
+		"tools": Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([
+			Schema.Struct({
+				"enable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({
+				"disable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({
+				"tags": Schema.Struct({
+					"enable": Schema.optionalKey(Schema.Array(Schema.Literals([
+						"readOnlyHint",
+						"createHint",
+						"updateHint",
+						"destructiveHint",
+						"idempotentHint",
+						"openWorldHint"
+					]))),
+					"disable": Schema.optionalKey(Schema.Array(Schema.Literals([
+						"readOnlyHint",
+						"createHint",
+						"updateHint",
+						"destructiveHint",
+						"idempotentHint",
+						"openWorldHint"
+					]))),
+					"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+						"readOnlyHint",
+						"createHint",
+						"updateHint",
+						"destructiveHint",
+						"idempotentHint",
+						"openWorldHint"
+					])).annotate({ "description": "Tags whose tools need the user's approval before they run." }))
+				}),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({ "require_approval": Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }) })
+		]))),
+		"tags": Schema.optionalKey(Schema.Struct({
+			"enable": Schema.optionalKey(Schema.Array(Schema.Literals([
+				"readOnlyHint",
+				"createHint",
+				"updateHint",
+				"destructiveHint",
+				"idempotentHint",
+				"openWorldHint"
+			]))),
+			"disable": Schema.optionalKey(Schema.Array(Schema.Literals([
+				"readOnlyHint",
+				"createHint",
+				"updateHint",
+				"destructiveHint",
+				"idempotentHint",
+				"openWorldHint"
+			]))),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+				"readOnlyHint",
+				"createHint",
+				"updateHint",
+				"destructiveHint",
+				"idempotentHint",
+				"openWorldHint"
+			])).annotate({ "description": "Tags whose tools need the user's approval before they run." }))
+		}))
+	}).annotate({ "description": "Stored Session access policy using the same enable/disable wire shape accepted on create and update, with any require_approval lists." }),
+	"created_at": Schema.String.annotate({
+		"description": "Creation time in ISO 8601.",
+		"format": "date-time"
+	}),
+	"updated_at": Schema.String.annotate({
+		"description": "Last update time in ISO 8601.",
+		"format": "date-time"
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { SessionConfigsRetrieveResponse };

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

@@ -0,0 +1,157 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/attach.d.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/attach`, which `client.toolRouter.session.attach` answers with. */
+declare const SessionAttachResponse: 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 return_prices_in_search: 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", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly disabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "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", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      readonly disabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "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 hooks: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"before_execute">;
+      readonly id: Schema.String;
+      readonly name: Schema.optionalKey<Schema.String>;
+      readonly applies_to: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+        readonly toolkits: Schema.$Array<Schema.String>;
+      }>]>;
+      readonly handler: Schema.Struct<{
+        readonly type: Schema.Literal<"condition_check">;
+        readonly condition: Schema.String;
+        readonly action: Schema.Literal<"block">;
+      }>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"after_execute">;
+      readonly id: Schema.String;
+      readonly name: Schema.optionalKey<Schema.String>;
+      readonly applies_to: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+        readonly toolkits: Schema.$Array<Schema.String>;
+      }>]>;
+      readonly handler: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"condition_check">;
+        readonly condition: Schema.String;
+        readonly action: Schema.Literal<"block">;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"prompt_injection_check">;
+        readonly action: Schema.Literal<"block">;
+      }>]>;
+    }>]>>>;
+    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 { SessionAttachResponse };

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

@@ -0,0 +1,30 @@
+import { SessionCreateResponseConfig } from "../../components/session-create-response-config.mjs";
+import { SessionCreateResponseWarnings } from "../../components/session-create-response-warnings.mjs";
+import { SessionRetrieveResponseExperimental } from "../../components/session-retrieve-response-experimental.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/attach.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/attach`, which `client.toolRouter.session.attach` answers with. */
+const SessionAttachResponse = 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(SessionRetrieveResponseExperimental),
+	"warnings": Schema.optionalKey(SessionCreateResponseWarnings)
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { SessionAttachResponse };

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

@@ -0,0 +1,122 @@
+//#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 return_prices_in_search: 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", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+          readonly disabled: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+          readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "createHint", "updateHint", "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", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly disabled: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly require_approval: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["readOnlyHint", "createHint", "updateHint", "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 hooks: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").Literal<"before_execute">;
+        readonly id: import("effect/Schema").String;
+        readonly name: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly applies_to: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"all">, import("effect/Schema").Struct<{
+          readonly toolkits: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>]>;
+        readonly handler: import("effect/Schema").Struct<{
+          readonly type: import("effect/Schema").Literal<"condition_check">;
+          readonly condition: import("effect/Schema").String;
+          readonly action: import("effect/Schema").Literal<"block">;
+        }>;
+      }>, import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").Literal<"after_execute">;
+        readonly id: import("effect/Schema").String;
+        readonly name: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly applies_to: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"all">, import("effect/Schema").Struct<{
+          readonly toolkits: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>]>;
+        readonly handler: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+          readonly type: import("effect/Schema").Literal<"condition_check">;
+          readonly condition: import("effect/Schema").String;
+          readonly action: import("effect/Schema").Literal<"block">;
+        }>, import("effect/Schema").Struct<{
+          readonly type: import("effect/Schema").Literal<"prompt_injection_check">;
+          readonly action: import("effect/Schema").Literal<"block">;
+        }>]>;
+      }>]>>>;
+      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").Finite;
+  readonly current_page: import("effect/Schema").Finite;
+  readonly total_items: import("effect/Schema").Finite;
+}>, 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,157 @@
+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 return_prices_in_search: 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", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly disabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+        readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "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", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      readonly disabled: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "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 hooks: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"before_execute">;
+      readonly id: Schema.String;
+      readonly name: Schema.optionalKey<Schema.String>;
+      readonly applies_to: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+        readonly toolkits: Schema.$Array<Schema.String>;
+      }>]>;
+      readonly handler: Schema.Struct<{
+        readonly type: Schema.Literal<"condition_check">;
+        readonly condition: Schema.String;
+        readonly action: Schema.Literal<"block">;
+      }>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"after_execute">;
+      readonly id: Schema.String;
+      readonly name: Schema.optionalKey<Schema.String>;
+      readonly applies_to: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+        readonly toolkits: Schema.$Array<Schema.String>;
+      }>]>;
+      readonly handler: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"condition_check">;
+        readonly condition: Schema.String;
+        readonly action: Schema.Literal<"block">;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"prompt_injection_check">;
+        readonly action: Schema.Literal<"block">;
+      }>]>;
+    }>]>>>;
+    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 };