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

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

@@ -0,0 +1,128 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/patch.d.ts
+/** The 200 response of `PATCH /api/v3.1/tool_router/session/{session_id}`, which `client.toolRouter.session.patch` answers with. */
+declare const SessionPatchResponse: 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 { SessionPatchResponse };

package/dist/effect/schemas/tool-router/session/patch.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/patch.ts
+/** The 200 response of `PATCH /api/v3.1/tool_router/session/{session_id}`, which `client.toolRouter.session.patch` answers with. */
+const SessionPatchResponse = 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 { SessionPatchResponse };

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

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/proxy-execute.d.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/proxy_execute`, which `client.toolRouter.session.proxyExecute` answers with. */
+declare const SessionProxyExecuteResponse: Schema.Union<readonly [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 [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 { SessionProxyExecuteResponse };

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

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

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

@@ -0,0 +1,128 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/retrieve.d.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}`, which `client.toolRouter.session.retrieve` answers with. */
+declare const SessionRetrieveResponse: 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 { SessionRetrieveResponse };

package/dist/effect/schemas/tool-router/session/retrieve.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/retrieve.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}`, which `client.toolRouter.session.retrieve` answers with. */
+const SessionRetrieveResponse = 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 { SessionRetrieveResponse };

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

@@ -0,0 +1,76 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tool-router/session/search.d.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/search`, which `client.toolRouter.session.search` answers with. */
+declare const SessionSearchResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly success: Schema.Boolean;
+  readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly results: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly index: Schema.Number;
+    readonly use_case: Schema.String;
+    readonly execution_guidance: Schema.optionalKey<Schema.String>;
+    readonly difficulty: Schema.optionalKey<Schema.String>;
+    readonly recommended_plan_steps: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly known_pitfalls: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly reference_workbench_snippets: Schema.optionalKey<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+      readonly description: Schema.String;
+      readonly code: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+    readonly primary_tool_slugs: Schema.$Array<Schema.String>;
+    readonly related_tool_slugs: Schema.$Array<Schema.String>;
+    readonly toolkits: Schema.$Array<Schema.String>;
+    readonly plan_id: Schema.optionalKey<Schema.String>;
+    readonly cached_plan_usecase: Schema.optionalKey<Schema.String>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly memory: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly toolkit_connection_statuses: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly toolkit: Schema.String;
+    readonly description: Schema.String;
+    readonly has_active_connection: Schema.Boolean;
+    readonly connection_details: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly current_user_info: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly account_type: Schema.optionalKey<Schema.Literals<readonly ["PRIVATE", "SHARED"]>>;
+    readonly accounts: Schema.optionalKey<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly alias: Schema.optionalKey<Schema.String>;
+      readonly user_info: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+      readonly status: Schema.String;
+      readonly created_at: Schema.String;
+      readonly is_default: Schema.Boolean;
+      readonly account_type: Schema.optionalKey<Schema.Literals<readonly ["PRIVATE", "SHARED"]>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>;
+    readonly account_selection: Schema.optionalKey<Schema.Literal<"required">>;
+    readonly instant_account: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly allowed_tool_slugs: Schema.$Array<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly status_message: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly tool_schemas: Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+    readonly toolkit: Schema.String;
+    readonly tool_slug: Schema.String;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly input_schema: Schema.optionalKey<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 hasFullSchema: Schema.optionalKey<Schema.Boolean>;
+    readonly schemaRef: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly tool: Schema.Literal<"COMPOSIO_GET_TOOL_SCHEMAS">;
+      readonly args: Schema.StructWithRest<Schema.Struct<{
+        readonly tool_slugs: Schema.$Array<Schema.String>;
+      }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+      readonly message: Schema.optionalKey<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 time_info: Schema.StructWithRest<Schema.Struct<{
+    readonly current_time_utc: Schema.String;
+    readonly current_time_utc_epoch_seconds: Schema.Number;
+    readonly message: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly session: Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly generate_id: Schema.Boolean;
+    readonly instructions: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly next_steps_guidance: Schema.$Array<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionSearchResponse };

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

@@ -0,0 +1,74 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tool-router/session/search.ts
+/** The 200 response of `POST /api/v3.1/tool_router/session/{session_id}/search`, which `client.toolRouter.session.search` answers with. */
+const SessionSearchResponse = Schema.StructWithRest(Schema.Struct({
+	"success": Schema.Boolean.annotate({ "description": "Whether all searches completed successfully. False if any query failed." }),
+	"error": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Error message if any searches failed, null if all succeeded. Format: \"X out of Y searches failed, reasons: <details>\"" }),
+	"results": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"index": Schema.Number.annotate({ "description": "1-based index of the query in the request" }).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"use_case": Schema.String.annotate({ "description": "The use case that was searched" }),
+		"execution_guidance": Schema.optionalKey(Schema.String.annotate({ "description": "Guidance message about the search results, particularly when a cached plan is available" })),
+		"difficulty": Schema.optionalKey(Schema.String.annotate({ "description": "Task difficulty assessment (e.g., \"easy - Simple single-tool operation with known parameters\")" })),
+		"recommended_plan_steps": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Workflow steps from cached plan (only present when cached plan is available)" })),
+		"known_pitfalls": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "Common pitfalls and considerations (only present when cached plan is available)" })),
+		"reference_workbench_snippets": Schema.optionalKey(Schema.Array(Schema.StructWithRest(Schema.Struct({
+			"description": Schema.String.annotate({ "description": "Description of what the code snippet does" }),
+			"code": Schema.String.annotate({ "description": "Python code snippet for the workbench" })
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Reference Python code snippets for processing tool responses in the workbench (only present when cached plan is available)" })),
+		"primary_tool_slugs": Schema.Array(Schema.String).annotate({ "description": "List of main tool slugs matching the search criteria" }),
+		"related_tool_slugs": Schema.Array(Schema.String).annotate({ "description": "List of related tool slugs that might be useful" }),
+		"toolkits": Schema.Array(Schema.String).annotate({ "description": "List of unique toolkit slugs used by tools in this query" }),
+		"plan_id": Schema.optionalKey(Schema.String.annotate({ "description": "ID of cached plan if available" })),
+		"cached_plan_usecase": Schema.optionalKey(Schema.String.annotate({ "description": "Use case the cached plan was originally built for, if a cached plan is available. May differ from `use_case` when the cached plan was matched from a similar query." })),
+		"error": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Error message if the search for this query failed, null otherwise. Always present for failed queries." })),
+		"memory": Schema.optionalKey(Schema.Record(Schema.String, Schema.Array(Schema.String)).annotate({ "description": "Memory data relevant to this query, grouped by app. Only present for non-cached search results." }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Per-query search results with tools, reasoning, and memory. One entry per query in request order." }),
+	"toolkit_connection_statuses": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"toolkit": Schema.String.annotate({ "description": "The toolkit slug identifier (e.g., \"gmail\", \"slack\")" }),
+		"description": Schema.String.annotate({ "description": "Description of what the toolkit does and its capabilities" }),
+		"has_active_connection": Schema.Boolean.annotate({ "description": "Whether an active connection exists for this toolkit" }),
+		"connection_details": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Connection details including auth config and connected account IDs. Only present when has_active_connection is true." })),
+		"current_user_info": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Information about the currently connected user (email, name, etc.)" })),
+		"account_type": Schema.optionalKey(Schema.Literals(["PRIVATE", "SHARED"]).annotate({ "description": "Sharing model for the connected account when has_active_connection is true. PRIVATE is owner-only; SHARED is reachable only when explicitly pinned to the session." })),
+		"accounts": Schema.optionalKey(Schema.Array(Schema.StructWithRest(Schema.Struct({
+			"id": Schema.String.annotate({ "description": "Unique identifier for this account" }),
+			"alias": Schema.optionalKey(Schema.String.annotate({ "description": "User-assigned alias for this account" })),
+			"user_info": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Information about the connected user (email, name, etc.)" })),
+			"status": Schema.String.annotate({ "description": "Connection status (e.g., \"active\")" }),
+			"created_at": Schema.String.annotate({ "description": "ISO 8601 timestamp of when the account was connected" }),
+			"is_default": Schema.Boolean.annotate({ "description": "Whether this is the default account for the toolkit" }),
+			"account_type": Schema.optionalKey(Schema.Literals(["PRIVATE", "SHARED"]).annotate({ "description": "Sharing model for this connected account. PRIVATE is owner-only; SHARED is reachable from a tool-router session only when explicitly pinned." }))
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "List of connected accounts for this toolkit. Present when multi-account is enabled." })),
+		"account_selection": Schema.optionalKey(Schema.Literal("required").annotate({ "description": "When \"required\", the agent must specify which account to use. Present only when multiple accounts exist." })),
+		"instant_account": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "allowed_tool_slugs": Schema.Array(Schema.String).annotate({ "description": "Tools of this toolkit that run on the Composio instant account" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Present when the toolkit is connected through the Composio instant account rather than a connected account of the user." })),
+		"status_message": Schema.String.annotate({ "description": "Human-readable message about the connection status and next steps" })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Connection status for all toolkits mentioned across all queries, with descriptions merged in." }),
+	"tool_schemas": Schema.Record(Schema.String, Schema.StructWithRest(Schema.Struct({
+		"toolkit": Schema.String.annotate({ "description": "The slug of the toolkit that provides this tool" }),
+		"tool_slug": Schema.String.annotate({ "description": "The slug of the tool" }),
+		"description": Schema.optionalKey(Schema.String.annotate({ "description": "Description of the tool" })),
+		"input_schema": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Input schema for the tool (only present when hasFullSchema is true)" })),
+		"output_schema": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Output/response schema for the tool. Only included when include_output_schemas is true." })),
+		"hasFullSchema": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether the full input_schema is included in this response" })),
+		"schemaRef": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+			"tool": Schema.Literal("COMPOSIO_GET_TOOL_SCHEMAS").annotate({ "description": "Tool to call" }),
+			"args": Schema.StructWithRest(Schema.Struct({ "tool_slugs": Schema.Array(Schema.String).annotate({ "description": "Tool slugs to fetch schemas for" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Arguments to pass to the tool" }),
+			"message": Schema.optionalKey(Schema.String.annotate({ "description": "Instruction message for the LLM" }))
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Reference to fetch full schema when hasFullSchema is false" }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Deduplicated tool definitions keyed by tool_slug for O(1) lookup. Each tool appears once even if used in multiple queries." }),
+	"time_info": Schema.StructWithRest(Schema.Struct({
+		"current_time_utc": Schema.String.annotate({ "description": "Current time in ISO format (UTC)" }),
+		"current_time_utc_epoch_seconds": Schema.Number.annotate({ "description": "Current time as Unix epoch timestamp in seconds" }).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"message": Schema.String.annotate({ "description": "Important message about time handling and timezone considerations" })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Time information for the query" }),
+	"session": Schema.StructWithRest(Schema.Struct({
+		"id": Schema.String.annotate({ "description": "Session identifier to be passed to subsequent meta tool calls as session_id." }),
+		"generate_id": Schema.Boolean.annotate({ "description": "Whether a fresh session id was generated in this call." }),
+		"instructions": Schema.String.annotate({ "description": "LLM-facing guidance on how to reuse this session id" })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Session info for correlating meta tool calls" }),
+	"next_steps_guidance": Schema.Array(Schema.String).annotate({ "description": "Combined workflow guidance covering connections, planner, and memory usage. Each element is a step instruction." })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { SessionSearchResponse };

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

@@ -0,0 +1,33 @@
+//#region src/effect/generated/schemas/tool-router/session/toolkits.d.ts
+/** The 200 response of `GET /api/v3.1/tool_router/session/{session_id}/toolkits`, which `client.toolRouter.session.toolkits` answers with. */
+declare const SessionToolkitsResponse: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+  readonly items: import("effect/Schema").$Array<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly name: import("effect/Schema").String;
+    readonly slug: import("effect/Schema").String;
+    readonly enabled: import("effect/Schema").Boolean;
+    readonly is_no_auth: import("effect/Schema").Boolean;
+    readonly composio_managed_auth_schemes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly meta: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly logo: import("effect/Schema").String;
+      readonly description: import("effect/Schema").String;
+      readonly isNoAuth: 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 connected_account: import("effect/Schema").Union<readonly [import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly id: import("effect/Schema").String;
+      readonly user_id: import("effect/Schema").String;
+      readonly status: import("effect/Schema").String;
+      readonly created_at: import("effect/Schema").String;
+      readonly auth_config: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").String;
+        readonly auth_scheme: import("effect/Schema").String;
+        readonly is_composio_managed: 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>>]>, import("effect/Schema").Null]>;
+  }>, 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 { SessionToolkitsResponse };

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

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