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

package/dist/effect/schemas/{org → _internal/org}/consumer/project/resolve.mjs

@@ -1,7 +1,7 @@
 import * as Schema from "effect/Schema";
 
-//#region src/effect/generated/schemas/org/consumer/project/resolve.ts
-/** The 200 response of `POST /api/v3.1/org/consumer/project/resolve`, which `client.org.consumer.project.resolve` answers with. */
+//#region src/effect/generated/schemas/_internal/org/consumer/project/resolve.ts
+/** The 200 response of `POST /api/v3.1/org/consumer/project/resolve`, which `client._internal.org.consumer.project.resolve` answers with. */
 const ProjectResolveResponse = Schema.StructWithRest(Schema.Struct({
 	"project_id": Schema.String.annotate({
 		"description": "UUID of the resolved consumer project.",
@@ -23,7 +23,8 @@ const ProjectResolveResponse = Schema.StructWithRest(Schema.Struct({
 		"enable_instant": Schema.Boolean.annotate({ "description": "Whether Instant Tools are enabled for this consumer project." }),
 		"clanker": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether org members share a single clanker bot identity for connected accounts." }))
 	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Consumer project configuration bag (consumer-experience and enhanced-controls flags, plus any provider-specific keys)." }),
-	"consumer_user_id": Schema.String.annotate({ "description": "Derived internal Composio user ID for the authenticated user in this consumer org context." })
+	"consumer_user_id": Schema.String.annotate({ "description": "Derived internal Composio user ID for the authenticated user in this consumer org context." }),
+	"user_id": Schema.String.annotate({ "description": "ID of the authenticated user the request was made as." })
 }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
 
 //#endregion

package/dist/effect/schemas/_internal/org/consumer/retrieve-config.d.mts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/org/consumer/retrieve-config.d.ts
+/** The 200 response of `GET /api/v3.1/org/consumer/config`, which `client._internal.org.consumer.retrieveConfig` answers with. */
+declare const ConsumerRetrieveConfigResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly org_id: Schema.String;
+  readonly consumer_experience_enabled: Schema.optionalKey<Schema.Boolean>;
+  readonly enhanced_controls: Schema.optionalKey<Schema.Boolean>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ConsumerRetrieveConfigResponse };

package/dist/effect/schemas/_internal/org/consumer/retrieve-config.mjs

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/org/consumer/retrieve-config.ts
+/** The 200 response of `GET /api/v3.1/org/consumer/config`, which `client._internal.org.consumer.retrieveConfig` answers with. */
+const ConsumerRetrieveConfigResponse = Schema.StructWithRest(Schema.Struct({
+	"org_id": Schema.String.annotate({ "description": "Organization nano ID." }),
+	"consumer_experience_enabled": Schema.optionalKey(Schema.Boolean.annotate({
+		"description": "Whether the consumer experience is enabled for this project.",
+		"default": true
+	})),
+	"enhanced_controls": Schema.optionalKey(Schema.Boolean.annotate({
+		"description": "Whether enhanced controls are enabled for this consumer project.",
+		"default": false
+	}))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ConsumerRetrieveConfigResponse };

package/dist/effect/schemas/auth-configs/list.d.mts

@@ -43,6 +43,7 @@ declare const AuthConfigListResponse: Schema.StructWithRest<Schema.Struct<{
       readonly tools_available_for_execution: Schema.optionalKey<Schema.$Array<Schema.String>>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
     readonly shared_credentials: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly shared_connection_fields: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly is_enabled_for_tool_router: Schema.optionalKey<Schema.Boolean>;
   }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
   readonly next_cursor: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;

package/dist/effect/schemas/auth-configs/list.mjs

@@ -53,7 +53,8 @@ const AuthConfigListResponse = Schema.StructWithRest(Schema.Struct({
 		"expected_input_fields": Schema.optionalKey(AuthConfigRetrieveResponseExpectedInputFields),
 		"restrict_to_following_tools": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "List of tool slugs this auth config is restricted to use with. DEPRECATED: use [Get required scopes](https://docs.composio.dev/reference/api-reference/toolkits/recommendToolkitScopes) to resolve the scopes for the tools you need, then pass those scopes in `credentials.scopes`." })),
 		"tool_access_config": AuthConfigRetrieveResponseToolAccessConfig,
-		"shared_credentials": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "[EXPERIMENTAL] Shared credentials that will be inherited by all connected accounts using this auth config" })),
+		"shared_credentials": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Shared credentials that will be inherited by all connected accounts using this auth config. DEPRECATED: use `shared_connection_fields` instead. It takes the same value and behaves the same way." })),
+		"shared_connection_fields": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Connection field values inherited by every connected account created under this auth config. Same value as shared_credentials; secret values are redacted." })),
 		"is_enabled_for_tool_router": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether this auth config is enabled for tool router" }))
 	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
 	"next_cursor": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),

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

@@ -42,6 +42,7 @@ declare const AuthConfigRetrieveResponse: Schema.StructWithRest<Schema.Struct<{
     readonly tools_available_for_execution: Schema.optionalKey<Schema.$Array<Schema.String>>;
   }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
   readonly shared_credentials: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly shared_connection_fields: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
   readonly is_enabled_for_tool_router: Schema.optionalKey<Schema.Boolean>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
 //#endregion

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

@@ -52,7 +52,8 @@ const AuthConfigRetrieveResponse = Schema.StructWithRest(Schema.Struct({
 	"expected_input_fields": Schema.optionalKey(AuthConfigRetrieveResponseExpectedInputFields),
 	"restrict_to_following_tools": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "List of tool slugs this auth config is restricted to use with. DEPRECATED: use [Get required scopes](https://docs.composio.dev/reference/api-reference/toolkits/recommendToolkitScopes) to resolve the scopes for the tools you need, then pass those scopes in `credentials.scopes`." })),
 	"tool_access_config": AuthConfigRetrieveResponseToolAccessConfig,
-	"shared_credentials": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "[EXPERIMENTAL] Shared credentials that will be inherited by all connected accounts using this auth config" })),
+	"shared_credentials": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Shared credentials that will be inherited by all connected accounts using this auth config. DEPRECATED: use `shared_connection_fields` instead. It takes the same value and behaves the same way." })),
+	"shared_connection_fields": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Connection field values inherited by every connected account created under this auth config. Same value as shared_credentials; secret values are redacted." })),
 	"is_enabled_for_tool_router": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether this auth config is enabled for tool router" }))
 }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
 

package/dist/effect/schemas/components/block-reason.d.mts

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

package/dist/effect/schemas/components/block-reason.mjs

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/block-reason.ts
+/** The `BlockReason` component schema. */
+const BlockReason = Schema.Union([Schema.StructWithRest(Schema.Struct({
+	"type": Schema.Literal("request_blocked").annotate({ "description": "A before_execute hook stopped the call. The tool did not run." }),
+	"hook_id": Schema.String
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]), Schema.StructWithRest(Schema.Struct({
+	"type": Schema.Literal("response_blocked").annotate({ "description": "An after_execute hook stopped the call. The tool ran; its response was withheld." }),
+	"hook_id": Schema.String
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])], { mode: "oneOf" }).annotate({ "identifier": "BlockReason" });
+
+//#endregion
+export { BlockReason };

package/dist/effect/schemas/components/execute-blocked.d.mts

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

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

@@ -0,0 +1,24 @@
+import { BlockReason } from "./block-reason.mjs";
+import { HookResult } from "./hook-result.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/execute-blocked.ts
+/** The `ExecuteBlocked` component schema. */
+const ExecuteBlocked = Schema.StructWithRest(Schema.Struct({
+	"result_type": Schema.Literal("blocked").annotate({ "description": "A session hook stopped the call" }),
+	"reason": BlockReason,
+	"message": Schema.String.annotate({
+		"description": "A message for the agent. It includes the hook's name, when it has one; the hook id is in `reason`.",
+		"examples": ["Blocked by session policy: No external email"]
+	}),
+	"log_id": Schema.optionalKey(Schema.String.annotate({ "description": "The execution log ID. Only set when the tool ran and its response was blocked." })),
+	"instant_charge": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"amount": Schema.String.annotate({ "description": "Instant charge in USD as an exact non-negative decimal string, with up to 12 fractional digits." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(0|[1-9]\\d*)(\\.\\d{1,12})?$", "u")).annotate({ "expected": "a string matching the RegExp ^(0|[1-9]\\d*)(\\.\\d{1,12})?$" })),
+		"currency": Schema.Literal("USD").annotate({ "description": "Currency of the instant charge. Always USD." }),
+		"charged_by": Schema.Literal("composio").annotate({ "description": "Entity charging for instant usage. Always composio." })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Returned only when the session enables instant.return_instant_charge and a charge is available. Only set when the tool ran and its response was blocked." })),
+	"hook_results": Schema.optionalKey(Schema.Array(HookResult).annotate({ "description": "Every session hook that applied to this call. Omitted when none applied." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ExecuteBlocked" });
+
+//#endregion
+export { ExecuteBlocked };

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

@@ -11,6 +11,14 @@ declare const ExecuteCompleted: Schema.StructWithRest<Schema.Struct<{
   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>>]>;
 //#endregion
 export { ExecuteCompleted };

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

@@ -1,3 +1,4 @@
+import { HookResult } from "./hook-result.mjs";
 import * as Schema from "effect/Schema";
 
 //#region src/effect/generated/schemas/components/execute-completed.ts
@@ -20,7 +21,8 @@ const ExecuteCompleted = Schema.StructWithRest(Schema.Struct({
 	"log_id": Schema.String.annotate({
 		"description": "Unique identifier for the execution log",
 		"examples": ["log_abc123xyz"]
-	})
+	}),
+	"hook_results": Schema.optionalKey(Schema.Array(HookResult).annotate({ "description": "Every session hook that applied to this call. Omitted when none applied." }))
 }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ExecuteCompleted" });
 
 //#endregion

package/dist/effect/schemas/components/execute-failed.d.mts

@@ -11,6 +11,14 @@ declare const ExecuteFailed: Schema.StructWithRest<Schema.Struct<{
   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>>]>;
 //#endregion
 export { ExecuteFailed };

package/dist/effect/schemas/components/execute-failed.mjs

@@ -1,3 +1,4 @@
+import { HookResult } from "./hook-result.mjs";
 import * as Schema from "effect/Schema";
 
 //#region src/effect/generated/schemas/components/execute-failed.ts
@@ -20,7 +21,8 @@ const ExecuteFailed = Schema.StructWithRest(Schema.Struct({
 	"log_id": Schema.String.annotate({
 		"description": "Unique identifier for the execution log",
 		"examples": ["log_abc123xyz"]
-	})
+	}),
+	"hook_results": Schema.optionalKey(Schema.Array(HookResult).annotate({ "description": "Every session hook that applied to this call. Omitted when none applied." }))
 }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ExecuteFailed" });
 
 //#endregion

package/dist/effect/schemas/components/hook-result.d.mts

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

package/dist/effect/schemas/components/hook-result.mjs

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/components/hook-result.ts
+/** The `HookResult` component schema. */
+const HookResult = Schema.Union([Schema.StructWithRest(Schema.Struct({
+	"id": Schema.String.annotate({ "description": "The hook id" }),
+	"status": Schema.Literal("evaluated"),
+	"outcome": Schema.Literals(["continue", "block"]).annotate({ "description": "What the hook decided" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]), Schema.StructWithRest(Schema.Struct({
+	"id": Schema.String.annotate({ "description": "The hook id" }),
+	"status": Schema.Literal("unavailable").annotate({ "description": "The hook could not be evaluated" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])], { mode: "oneOf" }).annotate({ "identifier": "HookResult" });
+
+//#endregion
+export { HookResult };

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

@@ -0,0 +1,24 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/components/proxy-execute-blocked.d.ts
+/** The `ProxyExecuteBlocked` component schema. */
+declare const ProxyExecuteBlocked: 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>>]>;
+//#endregion
+export { ProxyExecuteBlocked };

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

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

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

@@ -12,6 +12,14 @@ declare const ProxyExecuteCompleted: Schema.StructWithRest<Schema.Struct<{
   }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
   readonly status: Schema.Number;
   readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly hook_results: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly status: Schema.Literal<"evaluated">;
+    readonly outcome: Schema.Literals<readonly ["continue", "block"]>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly status: Schema.Literal<"unavailable">;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>>>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
 //#endregion
 export { ProxyExecuteCompleted };

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

@@ -1,3 +1,4 @@
+import { HookResult } from "./hook-result.mjs";
 import * as Schema from "effect/Schema";
 
 //#region src/effect/generated/schemas/components/proxy-execute-completed.ts
@@ -29,7 +30,8 @@ const ProxyExecuteCompleted = Schema.StructWithRest(Schema.Struct({
 			"content-type": "application/json",
 			"cache-control": "no-cache"
 		}]
-	}))
+	})),
+	"hook_results": Schema.optionalKey(Schema.Array(HookResult).annotate({ "description": "Every session hook that applied to this request. Omitted when none applied." }))
 }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "identifier": "ProxyExecuteCompleted" });
 
 //#endregion

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;