@composio/client 2.0.0-rc.21 → 2.0.0-rc.23

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 };

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

@@ -76,6 +76,34 @@ declare const SessionRetrieveResponse: 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/triggers-types/list.d.mts

@@ -8,6 +8,7 @@ declare const TriggersTypeListResponse: Schema.StructWithRest<Schema.Struct<{
     readonly description: Schema.String;
     readonly instructions: Schema.String;
     readonly type: Schema.Literals<readonly ["webhook", "poll"]>;
+    readonly types: Schema.$Array<Schema.Literals<readonly ["webhook", "poll"]>>;
     readonly toolkit: Schema.StructWithRest<Schema.Struct<{
       readonly slug: Schema.String;
       readonly name: Schema.String;

package/dist/effect/schemas/triggers-types/list.mjs

@@ -18,9 +18,13 @@ const TriggersTypeListResponse = Schema.StructWithRest(Schema.Struct({
 		}),
 		"instructions": Schema.String.annotate({ "description": "Step-by-step instructions on how to set up and use this trigger" }),
 		"type": Schema.Literals(["webhook", "poll"]).annotate({
-			"description": "The trigger mechanism - either webhook (event-based) or poll (scheduled check)",
+			"description": "Deprecated: use types. poll for any trigger that polls, even one a webhook wakes; otherwise webhook.",
 			"examples": ["webhook"]
 		}),
+		"types": Schema.Array(Schema.Literals(["webhook", "poll"])).annotate({
+			"description": "The trigger mechanisms this trigger supports, in order of preference: webhook (event-based) before poll (scheduled check).",
+			"examples": [["webhook", "poll"]]
+		}).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
 		"toolkit": Schema.StructWithRest(Schema.Struct({
 			"slug": Schema.String.annotate({
 				"description": "Unique identifier for the parent toolkit",

package/dist/effect/schemas/triggers-types/retrieve.d.mts

@@ -7,6 +7,7 @@ declare const TriggersTypeRetrieveResponse: Schema.StructWithRest<Schema.Struct<
   readonly description: Schema.String;
   readonly instructions: Schema.String;
   readonly type: Schema.Literals<readonly ["webhook", "poll"]>;
+  readonly types: Schema.$Array<Schema.Literals<readonly ["webhook", "poll"]>>;
   readonly toolkit: Schema.StructWithRest<Schema.Struct<{
     readonly slug: Schema.String;
     readonly name: Schema.String;

package/dist/effect/schemas/triggers-types/retrieve.mjs

@@ -17,9 +17,13 @@ const TriggersTypeRetrieveResponse = Schema.StructWithRest(Schema.Struct({
 	}),
 	"instructions": Schema.String.annotate({ "description": "Step-by-step instructions on how to set up and use this trigger" }),
 	"type": Schema.Literals(["webhook", "poll"]).annotate({
-		"description": "The trigger mechanism - either webhook (event-based) or poll (scheduled check)",
+		"description": "Deprecated: use types. poll for any trigger that polls, even one a webhook wakes; otherwise webhook.",
 		"examples": ["webhook"]
 	}),
+	"types": Schema.Array(Schema.Literals(["webhook", "poll"])).annotate({
+		"description": "The trigger mechanisms this trigger supports, in order of preference: webhook (event-based) before poll (scheduled check).",
+		"examples": [["webhook", "poll"]]
+	}).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
 	"toolkit": Schema.StructWithRest(Schema.Struct({
 		"slug": Schema.String.annotate({
 			"description": "Unique identifier for the parent toolkit",