@composio/client 2.0.0-rc.8 → 2.0.0

package/dist/effect/schemas/components/proxy-execute-blocked.mjs

@@ -0,0 +1,18 @@
+import { BlockReason } from "./block-reason.mjs";
+import { HookResult } from "./hook-result.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/proxy-execute-blocked.ts
+/** The `ProxyExecuteBlocked` component schema. */
+const ProxyExecuteBlocked = Schema.StructWithRest(Schema.Struct({
+	"result_type": Schema.Literal("blocked").annotate({ "description": "A session hook stopped the call" }),
+	"reason": BlockReason,
+	"message": Schema.String.annotate({
+		"description": "A message for the agent. It includes the hook's name, when it has one; the hook id is in `reason`.",
+		"examples": ["Blocked by session policy: No external email"]
+	}),
+	"hook_results": Schema.optionalKey(Schema.Array(HookResult).annotate({ "description": "Every session hook that applied to this call. Omitted when none applied." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ProxyExecuteBlocked" });
+
+//#endregion
+export { ProxyExecuteBlocked };

package/dist/effect/schemas/components/proxy-execute-completed.d.mts

@@ -0,0 +1,25 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/proxy-execute-completed.d.ts
+/** The `ProxyExecuteCompleted` component schema. */
+declare const ProxyExecuteCompleted: Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"completed">;
+  readonly data: Schema.optionalKey<Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>, Schema.Null]>>;
+  readonly binary_data: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly url: Schema.String;
+    readonly content_type: Schema.String;
+    readonly size: Schema.Number;
+    readonly expires_at: Schema.optionalKey<Schema.String>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly status: Schema.Number;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly hook_results: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly status: Schema.Literal<"evaluated">;
+    readonly outcome: Schema.Literals<readonly ["continue", "block"]>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly status: Schema.Literal<"unavailable">;
+  }>, 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 { ProxyExecuteCompleted };

package/dist/effect/schemas/components/proxy-execute-completed.mjs

@@ -0,0 +1,38 @@
+import { HookResult } from "./hook-result.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/proxy-execute-completed.ts
+/** The `ProxyExecuteCompleted` component schema. */
+const ProxyExecuteCompleted = Schema.StructWithRest(Schema.Struct({
+	"result_type": Schema.Literal("completed").annotate({ "description": "The request was sent and the proxied API responded" }),
+	"data": Schema.optionalKey(Schema.Union([Schema.Json.annotate({
+		"expected": "JSON value",
+		"description": "The response data returned from the proxied API",
+		"examples": [{
+			"id": "123",
+			"name": "Resource Name",
+			"created_at": "2023-01-01T00:00:00Z"
+		}]
+	}), Schema.Null])),
+	"binary_data": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"url": Schema.String.annotate({ "description": "URL to download binary content" }),
+		"content_type": Schema.String.annotate({ "description": "Content-Type of the binary data" }),
+		"size": Schema.Number.annotate({ "description": "File size in bytes" }).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"expires_at": Schema.optionalKey(Schema.String.annotate({ "description": "ISO 8601 timestamp when the URL expires" }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Binary body response data. Present when the response is a binary file." })),
+	"status": Schema.Number.annotate({
+		"description": "The HTTP status code returned from the proxied API",
+		"examples": [200]
+	}).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+	"headers": Schema.optionalKey(Schema.Record(Schema.String, Schema.String).annotate({
+		"description": "The HTTP headers returned from the proxied API",
+		"examples": [{
+			"content-type": "application/json",
+			"cache-control": "no-cache"
+		}]
+	})),
+	"hook_results": Schema.optionalKey(Schema.Array(HookResult).annotate({ "description": "Every session hook that applied to this request. Omitted when none applied." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ProxyExecuteCompleted" });
+
+//#endregion
+export { ProxyExecuteCompleted };

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

@@ -0,0 +1,112 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/session-create-response-config.d.ts
+/** The `SessionCreateResponseConfig` component schema. */
+declare const SessionCreateResponseConfig: 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>>]>;
+//#endregion
+export { SessionCreateResponseConfig };

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

@@ -0,0 +1,167 @@
+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." }),
+		"return_prices_in_search": Schema.Boolean.annotate({ "description": "Experimental. Whether tool search results show each instant tool's price, under instant_account.prices. Defaults to false." })
+	})]).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",
+					"createHint",
+					"updateHint",
+					"destructiveHint",
+					"idempotentHint",
+					"openWorldHint"
+				])).annotate({ "description": "Tags that the tool must have at least one of" })),
+				"disabled": Schema.optionalKey(Schema.Array(Schema.Literals([
+					"readOnlyHint",
+					"createHint",
+					"updateHint",
+					"destructiveHint",
+					"idempotentHint",
+					"openWorldHint"
+				])).annotate({ "description": "Tags that the tool must NOT have any of" })),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+					"readOnlyHint",
+					"createHint",
+					"updateHint",
+					"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",
+			"createHint",
+			"updateHint",
+			"destructiveHint",
+			"idempotentHint",
+			"openWorldHint"
+		])).annotate({ "description": "Tags that the tool must have at least one of" })),
+		"disabled": Schema.optionalKey(Schema.Array(Schema.Literals([
+			"readOnlyHint",
+			"createHint",
+			"updateHint",
+			"destructiveHint",
+			"idempotentHint",
+			"openWorldHint"
+		])).annotate({ "description": "Tags that the tool must NOT have any of" })),
+		"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+			"readOnlyHint",
+			"createHint",
+			"updateHint",
+			"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." })),
+	"hooks": Schema.optionalKey(Schema.Array(Schema.Union([Schema.Struct({
+		"type": Schema.Literal("before_execute"),
+		"id": Schema.String.annotate({ "description": "Unique within the session. Shows up in results and logs." }).check(Schema.isPattern(new globalThis.RegExp("^[a-z0-9_-]{1,64}$", "u")).annotate({ "expected": "a string matching the RegExp ^[a-z0-9_-]{1,64}$" })),
+		"name": Schema.optionalKey(Schema.String.annotate({ "description": "A readable name. The agent sees it when this hook blocks a call." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(120).annotate({ "expected": "a string with at most 120 code points" }))),
+		"applies_to": Schema.Union([Schema.Literal("all"), Schema.Struct({ "toolkits": Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).annotate({ "description": "Toolkit slugs" }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) })]).annotate({ "description": "Which tools the hook covers: \"all\" for all of them, or only the listed toolkits." }),
+		"handler": Schema.Struct({
+			"type": Schema.Literal("condition_check"),
+			"condition": Schema.String.annotate({ "description": "What to block, written as a plain sentence. For example: \"Sending email to anyone outside example.org\"." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(2e3).annotate({ "expected": "a string with at most 2000 code points" })),
+			"action": Schema.Literal("block")
+		})
+	}), Schema.Struct({
+		"type": Schema.Literal("after_execute"),
+		"id": Schema.String.annotate({ "description": "Unique within the session. Shows up in results and logs." }).check(Schema.isPattern(new globalThis.RegExp("^[a-z0-9_-]{1,64}$", "u")).annotate({ "expected": "a string matching the RegExp ^[a-z0-9_-]{1,64}$" })),
+		"name": Schema.optionalKey(Schema.String.annotate({ "description": "A readable name. The agent sees it when this hook blocks a call." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(120).annotate({ "expected": "a string with at most 120 code points" }))),
+		"applies_to": Schema.Union([Schema.Literal("all"), Schema.Struct({ "toolkits": Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).annotate({ "description": "Toolkit slugs" }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })) })]).annotate({ "description": "Which tools the hook covers: \"all\" for all of them, or only the listed toolkits." }),
+		"handler": Schema.Union([Schema.Struct({
+			"type": Schema.Literal("condition_check"),
+			"condition": Schema.String.annotate({ "description": "What to block, written as a plain sentence. For example: \"Sending email to anyone outside example.org\"." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(2e3).annotate({ "expected": "a string with at most 2000 code points" })),
+			"action": Schema.Literal("block")
+		}), Schema.Struct({
+			"type": Schema.Literal("prompt_injection_check"),
+			"action": Schema.Literal("block")
+		}).annotate({ "description": "Blocks a tool response that tries to manipulate the agent: override its instructions, change its role, or make it take actions the user didn't ask for." })], { mode: "oneOf" })
+	})], { mode: "oneOf" })).annotate({ "description": "Hooks that run on this session's tool calls." }).check(Schema.isMaxLength(20).annotate({ "expected": "a value with a length of at most 20" }))),
+	"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(new globalThis.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 };