@composio/client 2.0.0-rc.20 → 2.0.0-rc.22

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

@@ -69,6 +69,34 @@ declare const SessionCreateResponseConfig: Schema.StructWithRest<Schema.Struct<{
   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">]>;
   }>;

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

@@ -130,6 +130,30 @@ const SessionCreateResponseConfig = Schema.StructWithRest(Schema.Struct({
 		"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(/* @__PURE__ */ new 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(/* @__PURE__ */ new 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" }),

package/dist/effect/schemas/components/tool-router-session-v31-config-history-list-response.d.mts

@@ -73,6 +73,34 @@ declare const ToolRouterSessionV31ConfigHistoryListResponse: Schema.StructWithRe
       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">]>;
       }>;

package/dist/effect/schemas/components/tool-router-session-v31-config-history-list-response.mjs

@@ -137,6 +137,30 @@ const ToolRouterSessionV31ConfigHistoryListResponse = Schema.StructWithRest(Sche
 				"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(/* @__PURE__ */ new 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(/* @__PURE__ */ new 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" }),

package/dist/effect/schemas/session-configs/retrieve.d.mts

@@ -9,22 +9,33 @@ declare const SessionConfigsRetrieveResponse: Schema.StructWithRest<Schema.Struc
   readonly config: Schema.Struct<{
     readonly toolkits: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
       readonly enable: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
     }>, Schema.Struct<{
       readonly disable: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly require_approval: Schema.$Array<Schema.String>;
     }>]>>;
     readonly tools: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
       readonly enable: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
     }>, Schema.Struct<{
       readonly disable: Schema.$Array<Schema.String>;
+      readonly require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
     }>, Schema.Struct<{
       readonly tags: Schema.Struct<{
         readonly enable: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
         readonly disable: 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 require_approval: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly require_approval: Schema.$Array<Schema.String>;
     }>]>>>;
     readonly tags: Schema.optionalKey<Schema.Struct<{
       readonly enable: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["readOnlyHint", "createHint", "updateHint", "destructiveHint", "idempotentHint", "openWorldHint"]>>>;
       readonly disable: 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 created_at: Schema.String;

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

@@ -11,28 +11,56 @@ const SessionConfigsRetrieveResponse = Schema.StructWithRest(Schema.Struct({
 	"description": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Optional description of when the config should be used." }),
 	"archived": Schema.Boolean.annotate({ "description": "Whether the config is archived." }),
 	"config": Schema.Struct({
-		"toolkits": Schema.optionalKey(Schema.Union([Schema.Struct({ "enable": Schema.Array(Schema.String) }), Schema.Struct({ "disable": Schema.Array(Schema.String) })])),
+		"toolkits": Schema.optionalKey(Schema.Union([
+			Schema.Struct({
+				"enable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({
+				"disable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({ "require_approval": Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }) })
+		])),
 		"tools": Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([
-			Schema.Struct({ "enable": Schema.Array(Schema.String) }),
-			Schema.Struct({ "disable": Schema.Array(Schema.String) }),
-			Schema.Struct({ "tags": Schema.Struct({
-				"enable": Schema.optionalKey(Schema.Array(Schema.Literals([
-					"readOnlyHint",
-					"createHint",
-					"updateHint",
-					"destructiveHint",
-					"idempotentHint",
-					"openWorldHint"
-				]))),
-				"disable": Schema.optionalKey(Schema.Array(Schema.Literals([
-					"readOnlyHint",
-					"createHint",
-					"updateHint",
-					"destructiveHint",
-					"idempotentHint",
-					"openWorldHint"
-				])))
-			}) })
+			Schema.Struct({
+				"enable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({
+				"disable": Schema.Array(Schema.String),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({
+				"tags": Schema.Struct({
+					"enable": Schema.optionalKey(Schema.Array(Schema.Literals([
+						"readOnlyHint",
+						"createHint",
+						"updateHint",
+						"destructiveHint",
+						"idempotentHint",
+						"openWorldHint"
+					]))),
+					"disable": Schema.optionalKey(Schema.Array(Schema.Literals([
+						"readOnlyHint",
+						"createHint",
+						"updateHint",
+						"destructiveHint",
+						"idempotentHint",
+						"openWorldHint"
+					]))),
+					"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+						"readOnlyHint",
+						"createHint",
+						"updateHint",
+						"destructiveHint",
+						"idempotentHint",
+						"openWorldHint"
+					])).annotate({ "description": "Tags whose tools need the user's approval before they run." }))
+				}),
+				"require_approval": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }))
+			}),
+			Schema.Struct({ "require_approval": Schema.Array(Schema.String).annotate({ "description": "What in this entry needs the user's approval before it runs." }) })
 		]))),
 		"tags": Schema.optionalKey(Schema.Struct({
 			"enable": Schema.optionalKey(Schema.Array(Schema.Literals([
@@ -50,9 +78,17 @@ const SessionConfigsRetrieveResponse = Schema.StructWithRest(Schema.Struct({
 				"destructiveHint",
 				"idempotentHint",
 				"openWorldHint"
-			])))
+			]))),
+			"require_approval": Schema.optionalKey(Schema.Array(Schema.Literals([
+				"readOnlyHint",
+				"createHint",
+				"updateHint",
+				"destructiveHint",
+				"idempotentHint",
+				"openWorldHint"
+			])).annotate({ "description": "Tags whose tools need the user's approval before they run." }))
 		}))
-	}).annotate({ "description": "Stored Session access policy using the same enable/disable wire shape accepted on create and update." }),
+	}).annotate({ "description": "Stored Session access policy using the same enable/disable wire shape accepted on create and update, with any require_approval lists." }),
 	"created_at": Schema.String.annotate({
 		"description": "Creation time in ISO 8601.",
 		"format": "date-time"

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

@@ -76,6 +76,34 @@ declare const SessionAttachResponse: Schema.StructWithRest<Schema.Struct<{
     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">]>;
     }>;

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

@@ -72,6 +72,34 @@ declare const SessionConfigHistoryResponse: import("effect/Schema").StructWithRe
       readonly proxy_execute: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
         readonly enable: import("effect/Schema").Boolean;
       }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+      readonly hooks: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").Literal<"before_execute">;
+        readonly id: import("effect/Schema").String;
+        readonly name: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly applies_to: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"all">, import("effect/Schema").Struct<{
+          readonly toolkits: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>]>;
+        readonly handler: import("effect/Schema").Struct<{
+          readonly type: import("effect/Schema").Literal<"condition_check">;
+          readonly condition: import("effect/Schema").String;
+          readonly action: import("effect/Schema").Literal<"block">;
+        }>;
+      }>, import("effect/Schema").Struct<{
+        readonly type: import("effect/Schema").Literal<"after_execute">;
+        readonly id: import("effect/Schema").String;
+        readonly name: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly applies_to: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"all">, import("effect/Schema").Struct<{
+          readonly toolkits: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>]>;
+        readonly handler: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+          readonly type: import("effect/Schema").Literal<"condition_check">;
+          readonly condition: import("effect/Schema").String;
+          readonly action: import("effect/Schema").Literal<"block">;
+        }>, import("effect/Schema").Struct<{
+          readonly type: import("effect/Schema").Literal<"prompt_injection_check">;
+          readonly action: import("effect/Schema").Literal<"block">;
+        }>]>;
+      }>]>>>;
       readonly preload: import("effect/Schema").Struct<{
         readonly tools: import("effect/Schema").Union<readonly [import("effect/Schema").$Array<import("effect/Schema").String>, import("effect/Schema").Literal<"all">]>;
       }>;

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

@@ -76,6 +76,34 @@ declare const SessionCreateResponse: Schema.StructWithRest<Schema.Struct<{
     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">]>;
     }>;

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

@@ -11,6 +11,14 @@ declare const SessionExecuteMetaResponse: Schema.Union<readonly [Schema.StructWi
   readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
   readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
   readonly log_id: Schema.String;
+  readonly 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>>]>, Schema.StructWithRest<Schema.Struct<{
   readonly result_type: Schema.Literal<"failed">;
   readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
@@ -21,6 +29,38 @@ declare const SessionExecuteMetaResponse: Schema.Union<readonly [Schema.StructWi
   readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
   readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
   readonly log_id: Schema.String;
+  readonly 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>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"blocked">;
+  readonly reason: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"request_blocked">;
+    readonly hook_id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"response_blocked">;
+    readonly hook_id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
+  readonly message: Schema.String;
+  readonly log_id: Schema.optionalKey<Schema.String>;
+  readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly amount: Schema.String;
+    readonly currency: Schema.Literal<"USD">;
+    readonly charged_by: Schema.Literal<"composio">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly 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>>]>, Schema.StructWithRest<Schema.Struct<{
   readonly result_type: Schema.Literal<"input_required">;
   readonly input_requests: Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{

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

@@ -1,3 +1,4 @@
+import { ExecuteBlocked } from "../../components/execute-blocked.mjs";
 import { ExecuteCompleted } from "../../components/execute-completed.mjs";
 import { ExecuteFailed } from "../../components/execute-failed.mjs";
 import { ExecuteRequiresUserInput } from "../../components/execute-requires-user-input.mjs";
@@ -8,6 +9,7 @@ import * as Schema from "effect/Schema";
 const SessionExecuteMetaResponse = Schema.Union([
 	ExecuteCompleted,
 	ExecuteFailed,
+	ExecuteBlocked,
 	ExecuteRequiresUserInput
 ], { mode: "oneOf" });
 

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

@@ -11,6 +11,14 @@ declare const SessionExecuteResponse: Schema.Union<readonly [Schema.StructWithRe
   readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
   readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
   readonly log_id: Schema.String;
+  readonly 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>>]>, Schema.StructWithRest<Schema.Struct<{
   readonly result_type: Schema.Literal<"failed">;
   readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
@@ -21,6 +29,38 @@ declare const SessionExecuteResponse: Schema.Union<readonly [Schema.StructWithRe
   readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
   readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
   readonly log_id: Schema.String;
+  readonly 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>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"blocked">;
+  readonly reason: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"request_blocked">;
+    readonly hook_id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"response_blocked">;
+    readonly hook_id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
+  readonly message: Schema.String;
+  readonly log_id: Schema.optionalKey<Schema.String>;
+  readonly instant_charge: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly amount: Schema.String;
+    readonly currency: Schema.Literal<"USD">;
+    readonly charged_by: Schema.Literal<"composio">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly 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>>]>, Schema.StructWithRest<Schema.Struct<{
   readonly result_type: Schema.Literal<"input_required">;
   readonly input_requests: Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{

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

@@ -1,3 +1,4 @@
+import { ExecuteBlocked } from "../../components/execute-blocked.mjs";
 import { ExecuteCompleted } from "../../components/execute-completed.mjs";
 import { ExecuteFailed } from "../../components/execute-failed.mjs";
 import { ExecuteRequiresUserInput } from "../../components/execute-requires-user-input.mjs";
@@ -8,6 +9,7 @@ import * as Schema from "effect/Schema";
 const SessionExecuteResponse = Schema.Union([
 	ExecuteCompleted,
 	ExecuteFailed,
+	ExecuteBlocked,
 	ExecuteRequiresUserInput
 ], { mode: "oneOf" });
 

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

@@ -76,6 +76,34 @@ declare const SessionPatchResponse: Schema.StructWithRest<Schema.Struct<{
     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">]>;
     }>;

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

@@ -12,6 +12,32 @@ declare const SessionProxyExecuteResponse: Schema.Union<readonly [Schema.StructW
   }>, 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>>]>, Schema.StructWithRest<Schema.Struct<{
+  readonly result_type: Schema.Literal<"blocked">;
+  readonly reason: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"request_blocked">;
+    readonly hook_id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.Literal<"response_blocked">;
+    readonly hook_id: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
+  readonly message: 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>>]>, Schema.StructWithRest<Schema.Struct<{
   readonly result_type: Schema.Literal<"input_required">;
   readonly input_requests: Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{

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

@@ -1,10 +1,15 @@
 import { ExecuteRequiresUserInput } from "../../components/execute-requires-user-input.mjs";
+import { ProxyExecuteBlocked } from "../../components/proxy-execute-blocked.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" });
+const SessionProxyExecuteResponse = Schema.Union([
+	ProxyExecuteCompleted,
+	ProxyExecuteBlocked,
+	ExecuteRequiresUserInput
+], { mode: "oneOf" });
 
 //#endregion
 export { SessionProxyExecuteResponse };