@alfe.ai/openclaw-identity 0.0.10 → 0.0.12

package/dist/plugin2.cjs

@@ -2,102 +2,123 @@ let _alfe_ai_config = require("@alfe.ai/config");
 let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
 let _sinclair_typebox = require("@sinclair/typebox");
 let node_module = require("node:module");
-//#region src/policy-cache.ts
-const CACHE_TTL_MS = 6e4;
-function createPolicyCache() {
-	const sessionCache = /* @__PURE__ */ new Map();
-	let lastResolvedPolicy = null;
-	function getCached(key) {
-		const entry = sessionCache.get(key);
-		if (!entry) return null;
-		if (Date.now() > entry.expiresAt) {
-			sessionCache.delete(key);
-			return null;
-		}
-		return entry.value;
-	}
-	function setCached(key, value) {
-		sessionCache.set(key, {
-			value,
-			expiresAt: Date.now() + CACHE_TTL_MS
-		});
-	}
-	function setLastResolved(value) {
-		lastResolvedPolicy = {
-			value,
-			expiresAt: Date.now() + CACHE_TTL_MS
-		};
-	}
-	function getLastResolved() {
-		if (!lastResolvedPolicy) return null;
-		if (Date.now() > lastResolvedPolicy.expiresAt) {
-			lastResolvedPolicy = null;
-			return null;
-		}
-		return lastResolvedPolicy.value;
-	}
-	function getPerms(sessionKey) {
-		return getCached(sessionKey) ?? getLastResolved();
-	}
-	function clear() {
-		sessionCache.clear();
-		lastResolvedPolicy = null;
-	}
-	return {
-		getCached,
-		setCached,
-		setLastResolved,
-		getLastResolved,
-		getPerms,
-		clear
+let _auriclabs_roles = require("@auriclabs/roles");
+//#region src/agent-exec-gate.ts
+/**
+* Phase 1 Stage E — `agent:exec` gate evaluation.
+*
+* Round 6 strict-namespacing gate context (`{tool, args}`): the gate
+* passes the tool name as a sift CONTEXT field, not as the action.
+* Permissions narrow which tools an identity may exec via sift
+* conditions on the `tool` field. `args` is its own field — never
+* spread — so a tool whose args legitimately include a `tool` key
+* can't override the gate's value (closes the round-5 toolArgs.tool
+* collision).
+*
+* The function is a thin wrapper around `createAbility(...).has(...)`
+* that asserts the architecture-invariant "exactly one ability.has
+* call per gate" rule from the verify-roles-architecture script. Any
+* caller that loops over multiple scopes and OR-aggregates the result
+* silently loses `cannot` semantics — the wrapper makes the contract
+* explicit and testable.
+*
+* Today this function is wired into `before_tool_call` only for the
+* TOKEN path (B.0.7 atomic flip carries the token's `Permission[]` in
+* `ctx.tokenPermissions`). The JWT path still falls back to permissive
+* because the agent runtime can't yet fetch the resolved permission
+* set for `ctx.actingIdentityId` (needs an AgentApiClient endpoint
+* that doesn't exist yet — landing alongside Stage D's full rollout).
+*/
+/**
+* Evaluate the round-6 strict-namespacing gate. Single
+* `ability.has({...}, {tool, args})` call per invocation — never
+* fan out across multiple permission shapes.
+*
+* `permissions` is whatever the caller already has on hand (a token's
+* `Permission[]`, a session-cached resolved set, etc.). The function
+* doesn't fetch, doesn't cache, doesn't memoize — those concerns live
+* one layer up.
+*/
+function evaluateAgentExec(permissions, args) {
+	if (!args.agentId) return { allowed: false };
+	const ability = (0, _auriclabs_roles.createAbility)(permissions);
+	const gatePermission = {
+		subject: "agent",
+		action: "exec",
+		scope: `agent:${args.agentId}`
 	};
+	return { allowed: ability.has(gatePermission, {
+		tool: args.toolName,
+		args: args.toolArgs
+	}) };
 }
 /**
-* Evaluate whether a tool call should be blocked based on the cached policy
-* and failure mode.
+* Translate the gate decision into the before_tool_call hook's return
+* shape. `undefined` means "no opinion — allow"; `{ block: true, ... }`
+* means deny.
+*
+* - `allowed === true` → undefined (allow regardless of mode).
+* - `allowed === false` + mode === "fail-closed" → block.
+* - `allowed === false` + mode === "fail-open" → undefined (warn-only;
+*   caller should log the would-deny but let it through). Returning
+*   undefined here is what makes the rollout safe — Stage H flips the
+*   env to fail-closed once the deny-rate metric stabilizes.
 */
-function evaluateToolAccess(perms, toolName, failureMode) {
-	if (!perms) {
-		if (failureMode === "permissive") return void 0;
-		return {
-			block: true,
-			blockReason: "Identity: no identity context established — tool access denied"
-		};
-	}
-	if (!perms.identified) {
-		if (failureMode === "permissive") return void 0;
-		return {
-			block: true,
-			blockReason: "Identity: unknown sender identity — tool access denied"
-		};
-	}
-	if (perms.deniedTools.includes("*") || perms.deniedTools.includes(toolName)) return {
-		block: true,
-		blockReason: `Identity: tool '${toolName}' is denied for your role`
-	};
-	if (perms.allowedTools.length > 0 && !perms.allowedTools.includes(toolName)) return {
+function applyGateMode(decision, mode, toolName) {
+	if (decision.allowed) return void 0;
+	if (mode === "fail-open") return void 0;
+	return {
 		block: true,
-		blockReason: `Identity: tool '${toolName}' is not in your allowed tools`
+		blockReason: `Permissions: tool '${toolName}' not allowed for this identity`
 	};
 }
+/**
+* Resolve the kill-switch from process.env. Defaults to "fail-closed"
+* in production and "fail-open" elsewhere — Stage H flips production
+* to fail-closed once metrics confirm a stable deny rate.
+*/
+function resolveToolGatingMode() {
+	const raw = process.env.OPENCLAW_TOOL_GATING;
+	if (raw === "fail-open" || raw === "fail-closed") return raw;
+	return "fail-open";
+}
 //#endregion
 //#region src/plugin.ts
 /**
 * @alfe.ai/openclaw-identity — OpenClaw native plugin
 *
-* HTTP-based identity resolution, permission enforcement, and CRM tools.
-* Installed as part of the core alfe integration on every agent.
+* HTTP-based identity resolution + AccessConfig admission gate. Installed as
+* part of the core alfe integration on every agent.
 *
 * Hooks:
-*   - message_received  → resolve sender identity via HTTP, cache, gate access
-*   - before_tool_call  → enforce permissions from cached policy
-*   - after_tool_call   → log tool execution audit
+*   - message_received  → always resolves the sender, gates on accessAllowed,
+*                         blocks unknown senders (read-only resolve).
+*   - before_tool_call  → typed `(event: ToolCallEvent, ctx: ToolCallContext)`
+*                         hook (Phase 1 Stage A.0). Today: permissive no-op
+*                         stub. Phase 1 Stage E swaps the stub for the
+*                         `agent:exec` + sift gate (Decision 17).
 *
-* All data access via AgentApiClient (/agent/identity/* routes).
-* Uses the agent's own API key (from ~/.alfe/config.toml) for authentication.
+* `after_tool_call` is intentionally absent — tool-call audit lives in a
+* future dedicated audit service, not in identity.
 */
 const pkg = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
-const { getCached, setCached, setLastResolved, getPerms } = createPolicyCache();
+const RESOLVE_CACHE_TTL_MS = 6e4;
+const resolveCache = /* @__PURE__ */ new Map();
+function getCachedResolve(key) {
+	const entry = resolveCache.get(key);
+	if (!entry) return null;
+	if (Date.now() > entry.expiresAt) {
+		resolveCache.delete(key);
+		return null;
+	}
+	return entry;
+}
+function setCachedResolve(key, value) {
+	resolveCache.set(key, {
+		...value,
+		expiresAt: Date.now() + RESOLVE_CACHE_TTL_MS
+	});
+}
 function ok(data) {
 	return {
 		content: [{
@@ -134,7 +155,7 @@ function defineTool(def) {
 const plugin = {
 	id: "@alfe.ai/openclaw-identity",
 	name: "Alfe Identity",
-	description: "Identity resolution, access gating, and permission enforcement",
+	description: "Identity resolution and access gating for inbound messages",
 	version: pkg.version,
 	activate(api) {
 		const log = api.logger;
@@ -150,26 +171,17 @@ const plugin = {
 			log.error(`Identity plugin: failed to resolve config — ${err instanceof Error ? err.message : String(err)}`);
 			return;
 		}
-		let failureMode = "open";
-		const configReady = client.getIntegrationConfig("alfe").then((alfeConfig) => {
-			const mode = alfeConfig.config.identity_failure_mode;
-			if (mode === "open" || mode === "closed" || mode === "permissive") failureMode = mode;
-			log.info(`Identity failure mode: ${failureMode}`);
-		}).catch(() => {
-			log.info(`Identity failure mode: ${failureMode} (default — config fetch failed)`);
-		});
-		const identityToolNames = /* @__PURE__ */ new Set();
 		const tools = [
 			defineTool({
 				name: "who_is_this",
-				description: "Look up full identity context by platform and ID — returns profile, notes, tags, platforms, and recent changelog",
+				description: "Look up an identity by provider + platformId — returns full identity context (profile, contacts, platforms, notes, tags, recent changelog). Returns `{found:false}` for unknown senders. This tool DOES NOT create new identities.",
 				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String({ description: "Platform name (discord, slack, chat, sms, whatsapp, etc.)" }),
-					platformId: _sinclair_typebox.Type.String({ description: "Platform-specific user identifier" })
+					provider: _sinclair_typebox.Type.String({ description: "Provider name (discord, slack, chat, google-chat, clerk, etc.)" }),
+					platformId: _sinclair_typebox.Type.String({ description: "Provider-specific user identifier" })
 				}),
 				handler: async (params) => {
 					const result = await client.resolveIdentity({
-						platform: params.platform,
+						provider: params.provider,
 						platformId: params.platformId
 					});
 					if (!result.identityId) return { found: false };
@@ -178,37 +190,19 @@ const plugin = {
 			}),
 			defineTool({
 				name: "lookup_identity",
-				description: "Search identities by name, email, phone, tag, or platform. Returns multiple matches.",
+				description: "Search identities by name. Returns multiple matches.",
 				parameters: _sinclair_typebox.Type.Object({
 					query: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Text search query" })),
-					status: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
-					tag: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
-					platform: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
+					status: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
 				}),
 				handler: (params) => client.searchIdentities({
 					q: params.query,
-					status: params.status,
-					tag: params.tag,
-					platform: params.platform
-				})
-			}),
-			defineTool({
-				name: "create_identity",
-				description: "Create a new identity record with profile fields",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					platformId: _sinclair_typebox.Type.String(),
-					displayName: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId,
-					displayName: params.displayName
+					status: params.status
 				})
 			}),
 			defineTool({
 				name: "merge_identities",
-				description: "Merge two identity records — transfers notes, tags, aliases, platforms to survivor",
+				description: "Merge two identity records — transfers contacts, platforms, notes, tags, aliases to the survivor. Hard-move, transactional.",
 				parameters: _sinclair_typebox.Type.Object({
 					survivorId: _sinclair_typebox.Type.String({ description: "Identity to keep" }),
 					mergedId: _sinclair_typebox.Type.String({ description: "Identity to merge into survivor" })
@@ -223,29 +217,16 @@ const plugin = {
 			}),
 			defineTool({
 				name: "unmerge_identities",
-				description: "Reverse a merge — restore previously merged identity",
+				description: "Reverse a merge — restore previously merged identity.",
 				parameters: _sinclair_typebox.Type.Object({ mergedId: _sinclair_typebox.Type.String({ description: "Identity that was merged (has mergedInto pointer)" }) }),
 				handler: (params) => client.unmergeIdentity(params.mergedId, { changedBy: {
 					type: "agent",
 					id: "plugin"
 				} })
 			}),
-			defineTool({
-				name: "link_platform",
-				description: "Link a platform identity to an existing identity record",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					platform: _sinclair_typebox.Type.String(),
-					platformId: _sinclair_typebox.Type.String()
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId
-				})
-			}),
 			defineTool({
 				name: "add_identity_note",
-				description: "Add an observation or note about a contact",
+				description: "Add an observation or note about an identity. Use category 'context' for unverified affiliation claims (self-reported title/company) — those do NOT belong on the identity row directly.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
 					content: _sinclair_typebox.Type.String(),
@@ -262,7 +243,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "tag_identity",
-				description: "Add or remove a tag on an identity",
+				description: "Add or remove a tag on an identity.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
 					tag: _sinclair_typebox.Type.String(),
@@ -279,7 +260,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "get_identity_changelog",
-				description: "Get full changelog for an identity — all versions, diffs, who changed what",
+				description: "Get the changelog for an identity — versions, diffs, who changed what.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
 					limit: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Number())
@@ -288,7 +269,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "rollback_identity",
-				description: "Revert an identity to a previous version",
+				description: "Revert an identity to a previous version.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
 					targetVersion: _sinclair_typebox.Type.Number()
@@ -302,79 +283,83 @@ const plugin = {
 				})
 			}),
 			defineTool({
-				name: "enforce_policy",
-				description: "Resolve sender identity and return their tool policy",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					senderId: _sinclair_typebox.Type.String(),
-					channelId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.enforcePolicy({
-					platform: params.platform,
-					senderId: params.senderId,
-					channelId: params.channelId
-				})
-			}),
-			defineTool({
-				name: "check_permission",
-				description: "Check if a specific tool call is allowed for a sender",
+				name: "update_identity",
+				description: "Update display-shape fields on an identity: name / avatarUrl / timezone / locale. Contact mutations go through the verify flow — this tool will NOT accept email or mobile. Title and company live on org membership rows, not here.",
 				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					senderId: _sinclair_typebox.Type.String(),
-					toolName: _sinclair_typebox.Type.String()
+					identityId: _sinclair_typebox.Type.String(),
+					name: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
+					avatarUrl: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
+					timezone: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
+					locale: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
 				}),
-				handler: (params) => client.checkToolPermission({
-					platform: params.platform,
-					senderId: params.senderId,
-					toolName: params.toolName
-				})
+				handler: (params) => {
+					const { identityId, ...rest } = params;
+					return client.updateIdentity(identityId, rest);
+				}
 			}),
 			defineTool({
 				name: "request_identity_verification",
-				description: "Send a verification phrase to the claimed identity's phone (SMS) or email. The person must relay the phrase back to confirm they own that identity.",
+				description: "Send a verification phrase to verify the user controls an email or mobile endpoint. Use this when the user has just told you their email or mobile number and you want them to confirm it. Pass exactly one of `contactEmail` or `contactMobile`. The person must relay the phrase back via `confirm_identity_verification`.",
 				parameters: _sinclair_typebox.Type.Object({
 					claimedIdentityId: _sinclair_typebox.Type.String({ description: "Identity being claimed" }),
 					requestingIdentityId: _sinclair_typebox.Type.String({ description: "Identity of the person making the claim" }),
-					requestingPlatform: _sinclair_typebox.Type.String({ description: "Platform the requester is on (discord, slack, chat, etc.)" }),
-					requestingPlatformId: _sinclair_typebox.Type.String({ description: "Requester's platform-specific user ID" }),
-					preferredChannel: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "'sms' or 'email'" }))
+					requestingProvider: _sinclair_typebox.Type.String({ description: "Provider the requester is on (discord, slack, chat, etc.)" }),
+					requestingPlatformId: _sinclair_typebox.Type.String({ description: "Requester's provider-specific user ID" }),
+					contactEmail: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Email to verify (mutually exclusive with contactMobile)" })),
+					contactMobile: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "E.164 mobile to verify (mutually exclusive with contactEmail)" })),
+					preferredChannel: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "When neither contactEmail nor contactMobile is provided, pick which existing verified contact to deliver to: 'mobile' or 'email'" }))
 				}),
-				handler: (params) => client.requestIdentityVerification({
-					claimedIdentityId: params.claimedIdentityId,
-					requestingIdentityId: params.requestingIdentityId,
-					requestingPlatform: params.requestingPlatform,
-					requestingPlatformId: params.requestingPlatformId,
-					preferredChannel: params.preferredChannel
-				})
+				handler: (params) => {
+					const contactEmail = params.contactEmail;
+					const contactMobile = params.contactMobile;
+					if (contactEmail && contactMobile) return Promise.resolve({ error: "Specify exactly one of contactEmail or contactMobile, not both" });
+					const contact = contactEmail ? {
+						channel: "email",
+						value: contactEmail
+					} : contactMobile ? {
+						channel: "mobile",
+						value: contactMobile
+					} : void 0;
+					return client.requestIdentityVerification({
+						claimedIdentityId: params.claimedIdentityId,
+						requestingIdentityId: params.requestingIdentityId,
+						requestingProvider: params.requestingProvider,
+						requestingPlatformId: params.requestingPlatformId,
+						preferredChannel: params.preferredChannel,
+						contact
+					});
+				}
 			}),
 			defineTool({
 				name: "confirm_identity_verification",
-				description: "Confirm a verification by providing the three-word phrase. On success, the requesting identity is merged into the claimed identity.",
+				description: "Confirm a verification by submitting the phrase the user received. Returns `{ verified, identityId, action }` where `action` is 'merged' (the verified contact already lived on another identity, which is now the survivor) or 'contact_verified' (the contact was attached to the claimed identity).",
 				parameters: _sinclair_typebox.Type.Object({
+					claimedIdentityId: _sinclair_typebox.Type.String({ description: "Identity being claimed (matches request)" }),
 					verificationId: _sinclair_typebox.Type.String({ description: "Verification ID returned from request_identity_verification" }),
-					phrase: _sinclair_typebox.Type.String({ description: "Three-word phrase the person received via SMS or email" })
+					phrase: _sinclair_typebox.Type.String({ description: "Three-word phrase the person received via mobile or email" })
 				}),
 				handler: (params) => client.confirmIdentityVerification({
+					claimedIdentityId: params.claimedIdentityId,
 					verificationId: params.verificationId,
 					phrase: params.phrase
 				})
 			})
 		];
-		for (const tool of tools) {
-			api.registerTool(tool);
-			identityToolNames.add(tool.name);
-		}
+		for (const tool of tools) api.registerTool(tool);
 		log.info(`Registered ${String(tools.length)} identity tools`);
 		api.on("message_received", async (...args) => {
 			const event = args[0];
 			const ctx = args[1];
-			const platform = ctx.channelId ?? "unknown";
-			const preResolvedIdentityId = event.metadata?.IdentityId;
+			const provider = ctx.channelId ?? "unknown";
 			const senderId = event.metadata?.UserId ?? event.from;
 			if (!senderId) return;
-			const cacheKey = ctx.conversationId ?? `${platform}:${senderId}`;
-			const cached = getCached(cacheKey);
+			const cacheKey = ctx.conversationId ?? `${provider}:${senderId}`;
+			const cached = getCachedResolve(cacheKey);
 			if (cached) {
+				if (cached.identityId == null) return {
+					block: true,
+					blockReason: "Identity: identity not provisioned for this channel"
+				};
 				if (!cached.accessAllowed) return {
 					block: true,
 					blockReason: "Identity: access denied for this sender"
@@ -382,63 +367,47 @@ const plugin = {
 				return;
 			}
 			try {
-				let resolveResult;
-				if (preResolvedIdentityId) resolveResult = {
-					identityId: preResolvedIdentityId,
-					accessAllowed: true,
-					status: "pre-resolved"
-				};
-				else resolveResult = await client.resolveIdentity({
-					platform,
+				const r = await client.resolveIdentity({
+					provider,
 					platformId: senderId
 				});
-				const entry = {
-					...await client.enforcePolicy({
-						platform,
-						senderId
-					}),
-					accessAllowed: resolveResult.accessAllowed
-				};
-				setCached(cacheKey, entry);
-				setLastResolved(entry);
-				if (!resolveResult.accessAllowed) return {
+				setCachedResolve(cacheKey, {
+					identityId: r.identityId,
+					accessAllowed: r.accessAllowed,
+					status: r.status
+				});
+				if (r.identityId == null) {
+					log.warn(`Identity not provisioned for ${provider}:${senderId} — blocking inbound message`);
+					return {
+						block: true,
+						blockReason: "Identity: identity not provisioned for this channel"
+					};
+				}
+				if (!r.accessAllowed) return {
 					block: true,
 					blockReason: "Identity: access denied for this sender"
 				};
-				log.info(`Identity resolved: ${senderId} → ${resolveResult.identityId ?? "unknown"} (${resolveResult.status})`);
+				log.info(`Identity resolved: ${senderId} → ${r.identityId} (${r.status})`);
 			} catch (e) {
 				log.error(`Identity resolution failed for ${senderId}: ${e.message}`);
-				if (failureMode === "closed") return {
+				return {
 					block: true,
-					blockReason: "Identity: identity service unavailable — access denied (closed mode)"
+					blockReason: "Identity: identity service unavailable — access denied (fail-closed)"
 				};
 			}
 		}, { priority: 100 });
-		api.on("before_tool_call", async (...args) => {
-			const event = args[0];
-			const ctx = args[1];
-			if (identityToolNames.has(event.toolName)) return;
-			const sessionKey = ctx.sessionKey;
-			if (!sessionKey) return;
-			await configReady;
-			return evaluateToolAccess(getPerms(sessionKey), event.toolName, failureMode);
-		}, { priority: 100 });
-		api.on("after_tool_call", async (...args) => {
-			const event = args[0];
-			const sessionKey = args[1].sessionKey;
-			if (!sessionKey) return;
-			const perms = getPerms(sessionKey);
-			if (!perms?.identityId) return;
-			try {
-				await client.checkToolPermission({
-					platform: "tool_audit",
-					senderId: perms.identityId,
-					toolName: event.toolName
-				});
-			} catch (e) {
-				log.error(`Audit logging failed: ${e.message}`);
+		const beforeToolCallStub = (event, ctx) => {
+			if (ctx.authMethod === "token" && ctx.tokenPermissions !== void 0) {
+				const blocked = applyGateMode(evaluateAgentExec(ctx.tokenPermissions, {
+					agentId: ctx.agentId,
+					toolName: event.toolName,
+					toolArgs: event.toolArgs
+				}), resolveToolGatingMode(), event.toolName);
+				return Promise.resolve(blocked);
 			}
-		});
+			return Promise.resolve(void 0);
+		};
+		api.on("before_tool_call", (...args) => beforeToolCallStub(args[0], args[1]), { priority: 100 });
 		log.info("Alfe Identity plugin activated");
 	}
 };