@librechat/agents 3.2.32 → 3.2.34

package/dist/cjs/hooks/createToolPolicyHook.cjs

@@ -1,115 +1,85 @@
-'use strict';
-
-/**
- * Declarative `PreToolUse` hook factory. Lets hosts express common
- * permission policies (allow / deny / ask lists + a global mode) without
- * hand-rolling matching, precedence, and decision logic per-host.
- *
- * Maps directly to the Claude Code Agent SDK permission vocabulary
- * (`allowed_tools` / `disallowed_tools` / `permissionMode`) so users of
- * either SDK can think in the same terms. See the README's HITL section
- * for the cross-walk and `docs/hooks-design-report.md` for the broader
- * hook system context.
- */
+//#region src/hooks/createToolPolicyHook.ts
 /**
- * Compile a glob string with `*` wildcards into a single anchored
- * `RegExp`. Other regex metacharacters are escaped, so `read_file.md`
- * matches the literal dot. Patterns are short (tool names), so we do
- * not cache here — the registry's `matchesQuery` already caches its own
- * regex compilations and our patterns are evaluated once per ToolNode
- * batch, not once per stream chunk.
- */
+* Compile a glob string with `*` wildcards into a single anchored
+* `RegExp`. Other regex metacharacters are escaped, so `read_file.md`
+* matches the literal dot. Patterns are short (tool names), so we do
+* not cache here — the registry's `matchesQuery` already caches its own
+* regex compilations and our patterns are evaluated once per ToolNode
+* batch, not once per stream chunk.
+*/
 function globToRegex(pattern) {
-    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
+	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp("^" + escaped.replace(/\*/g, ".*") + "$");
 }
 /** Pre-compile a list of glob patterns into a single match function. */
 function compileMatchers(patterns) {
-    if (patterns == null || patterns.length === 0) {
-        return () => false;
-    }
-    const regexes = patterns.map(globToRegex);
-    return (toolName) => {
-        for (const regex of regexes) {
-            if (regex.test(toolName)) {
-                return true;
-            }
-        }
-        return false;
-    };
+	if (patterns == null || patterns.length === 0) return () => false;
+	const regexes = patterns.map(globToRegex);
+	return (toolName) => {
+		for (const regex of regexes) if (regex.test(toolName)) return true;
+		return false;
+	};
 }
 function formatReason(template, toolName) {
-    if (template == null) {
-        return undefined;
-    }
-    return template.replace(/\{tool\}/g, toolName);
+	if (template == null) return;
+	return template.replace(/\{tool\}/g, toolName);
 }
 /**
- * Build a `PreToolUse` hook callback that applies a declarative tool
- * permission policy. Register it with a `HookRegistry` and the SDK's
- * `humanInTheLoop` machinery handles the rest:
- *
- * ```ts
- * const policyHook = createToolPolicyHook({
- *   mode: 'default',
- *   allow: ['read_*', 'grep', 'glob'],
- *   deny:  ['delete_*'],
- *   ask:   ['execute_*', 'mcp:*'],
- * });
- * registry.register('PreToolUse', { hooks: [policyHook] });
- * ```
- *
- * Evaluation order matches Claude Code's permission flow:
- *
- *   1. `deny` rule match → `'deny'` (always wins, even in `bypass`).
- *   2. `mode === 'bypass'` → `'allow'`.
- *   3. `allow` rule match → `'allow'`.
- *   4. `ask` rule match → `'ask'`.
- *   5. `mode === 'dontAsk'` → `'deny'`.
- *   6. fallthrough → `'ask'`.
- *
- * The returned callback is a single `HookCallback`, not a `HookMatcher` —
- * register it under the matcher with the pattern you want (omit the
- * pattern to fire on every tool call, which is the typical case since
- * the policy itself does the filtering).
- */
+* Build a `PreToolUse` hook callback that applies a declarative tool
+* permission policy. Register it with a `HookRegistry` and the SDK's
+* `humanInTheLoop` machinery handles the rest:
+*
+* ```ts
+* const policyHook = createToolPolicyHook({
+*   mode: 'default',
+*   allow: ['read_*', 'grep', 'glob'],
+*   deny:  ['delete_*'],
+*   ask:   ['execute_*', 'mcp:*'],
+* });
+* registry.register('PreToolUse', { hooks: [policyHook] });
+* ```
+*
+* Evaluation order matches Claude Code's permission flow:
+*
+*   1. `deny` rule match → `'deny'` (always wins, even in `bypass`).
+*   2. `mode === 'bypass'` → `'allow'`.
+*   3. `allow` rule match → `'allow'`.
+*   4. `ask` rule match → `'ask'`.
+*   5. `mode === 'dontAsk'` → `'deny'`.
+*   6. fallthrough → `'ask'`.
+*
+* The returned callback is a single `HookCallback`, not a `HookMatcher` —
+* register it under the matcher with the pattern you want (omit the
+* pattern to fire on every tool call, which is the typical case since
+* the policy itself does the filtering).
+*/
 function createToolPolicyHook(config) {
-    const denyMatcher = compileMatchers(config.deny);
-    const allowMatcher = compileMatchers(config.allow);
-    const askMatcher = compileMatchers(config.ask);
-    const mode = config.mode ?? 'default';
-    const reasonTemplate = config.reason;
-    return async (input) => {
-        const toolName = input.toolName;
-        const decision = decide(toolName, mode, denyMatcher, allowMatcher, askMatcher);
-        if (decision === 'allow') {
-            return { decision };
-        }
-        const reason = formatReason(reasonTemplate, toolName);
-        if (reason != null) {
-            return { decision, reason };
-        }
-        return { decision };
-    };
+	const denyMatcher = compileMatchers(config.deny);
+	const allowMatcher = compileMatchers(config.allow);
+	const askMatcher = compileMatchers(config.ask);
+	const mode = config.mode ?? "default";
+	const reasonTemplate = config.reason;
+	return async (input) => {
+		const toolName = input.toolName;
+		const decision = decide(toolName, mode, denyMatcher, allowMatcher, askMatcher);
+		if (decision === "allow") return { decision };
+		const reason = formatReason(reasonTemplate, toolName);
+		if (reason != null) return {
+			decision,
+			reason
+		};
+		return { decision };
+	};
 }
 function decide(toolName, mode, denyMatch, allowMatch, askMatch) {
-    if (denyMatch(toolName)) {
-        return 'deny';
-    }
-    if (mode === 'bypass') {
-        return 'allow';
-    }
-    if (allowMatch(toolName)) {
-        return 'allow';
-    }
-    if (askMatch(toolName)) {
-        return 'ask';
-    }
-    if (mode === 'dontAsk') {
-        return 'deny';
-    }
-    return 'ask';
+	if (denyMatch(toolName)) return "deny";
+	if (mode === "bypass") return "allow";
+	if (allowMatch(toolName)) return "allow";
+	if (askMatch(toolName)) return "ask";
+	if (mode === "dontAsk") return "deny";
+	return "ask";
 }
-
+//#endregion
 exports.createToolPolicyHook = createToolPolicyHook;
-//# sourceMappingURL=createToolPolicyHook.cjs.map
+
+//# sourceMappingURL=createToolPolicyHook.cjs.map

package/dist/cjs/hooks/createToolPolicyHook.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createToolPolicyHook.cjs","sources":["../../../src/hooks/createToolPolicyHook.ts"],"sourcesContent":["/**\n * Declarative `PreToolUse` hook factory. Lets hosts express common\n * permission policies (allow / deny / ask lists + a global mode) without\n * hand-rolling matching, precedence, and decision logic per-host.\n *\n * Maps directly to the Claude Code Agent SDK permission vocabulary\n * (`allowed_tools` / `disallowed_tools` / `permissionMode`) so users of\n * either SDK can think in the same terms. See the README's HITL section\n * for the cross-walk and `docs/hooks-design-report.md` for the broader\n * hook system context.\n */\n\nimport type { HookCallback, PreToolUseHookOutput, ToolDecision } from './types';\n\n/**\n * Permission mode controlling how tool calls that match no rule are\n * resolved. Mirrors Claude Code's `permissionMode`.\n *\n *   - `default`  — unmatched tools fall through to `'ask'` (interrupt).\n *   - `dontAsk`  — unmatched tools are denied; the human is never\n *                  prompted. Useful for headless / API agents where a\n *                  silent denial is preferable to a hung interrupt.\n *   - `bypass`   — every tool is approved, except those matching `deny`\n *                  patterns. The kill switch you flip when you trust\n *                  the agent and want to stop being asked. Equivalent to\n *                  Claude Code's `bypassPermissions`.\n */\nexport type ToolPolicyMode = 'default' | 'dontAsk' | 'bypass';\n\nexport interface ToolPolicyConfig {\n  /**\n   * Global mode applied to tools that don't match any rule.\n   * Defaults to `'default'` (ask the human).\n   */\n  mode?: ToolPolicyMode;\n  /**\n   * Tool name patterns that are auto-approved without a prompt.\n   * Patterns support glob `*` wildcards: `read_file`, `mcp:github:*`,\n   * `*search*`. Match is anchored (`^pattern$`).\n   */\n  allow?: readonly string[];\n  /**\n   * Tool name patterns that are blocked outright. Wins over `allow`\n   * and `ask`, and overrides `mode: 'bypass'` — a deny rule always\n   * holds, matching Claude Code's \"deny rules are checked first\" guarantee.\n   */\n  deny?: readonly string[];\n  /**\n   * Tool name patterns that always trigger human approval, regardless\n   * of `mode: 'default'` vs `'dontAsk'`. In `mode: 'bypass'` these are\n   * still bypassed (because that's what bypass means).\n   */\n  ask?: readonly string[];\n  /**\n   * Optional reason attached to the resulting `ask` / `deny` hook\n   * decision so the host UI can render why approval is required.\n   * The literal token `{tool}` is replaced with the tool name.\n   */\n  reason?: string;\n}\n\n/**\n * Compile a glob string with `*` wildcards into a single anchored\n * `RegExp`. Other regex metacharacters are escaped, so `read_file.md`\n * matches the literal dot. Patterns are short (tool names), so we do\n * not cache here — the registry's `matchesQuery` already caches its own\n * regex compilations and our patterns are evaluated once per ToolNode\n * batch, not once per stream chunk.\n */\nfunction globToRegex(pattern: string): RegExp {\n  const escaped = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  return new RegExp('^' + escaped.replace(/\\*/g, '.*') + '$');\n}\n\n/** Pre-compile a list of glob patterns into a single match function. */\nfunction compileMatchers(\n  patterns: readonly string[] | undefined\n): (toolName: string) => boolean {\n  if (patterns == null || patterns.length === 0) {\n    return () => false;\n  }\n  const regexes = patterns.map(globToRegex);\n  return (toolName: string): boolean => {\n    for (const regex of regexes) {\n      if (regex.test(toolName)) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n\nfunction formatReason(\n  template: string | undefined,\n  toolName: string\n): string | undefined {\n  if (template == null) {\n    return undefined;\n  }\n  return template.replace(/\\{tool\\}/g, toolName);\n}\n\n/**\n * Build a `PreToolUse` hook callback that applies a declarative tool\n * permission policy. Register it with a `HookRegistry` and the SDK's\n * `humanInTheLoop` machinery handles the rest:\n *\n * ```ts\n * const policyHook = createToolPolicyHook({\n *   mode: 'default',\n *   allow: ['read_*', 'grep', 'glob'],\n *   deny:  ['delete_*'],\n *   ask:   ['execute_*', 'mcp:*'],\n * });\n * registry.register('PreToolUse', { hooks: [policyHook] });\n * ```\n *\n * Evaluation order matches Claude Code's permission flow:\n *\n *   1. `deny` rule match → `'deny'` (always wins, even in `bypass`).\n *   2. `mode === 'bypass'` → `'allow'`.\n *   3. `allow` rule match → `'allow'`.\n *   4. `ask` rule match → `'ask'`.\n *   5. `mode === 'dontAsk'` → `'deny'`.\n *   6. fallthrough → `'ask'`.\n *\n * The returned callback is a single `HookCallback`, not a `HookMatcher` —\n * register it under the matcher with the pattern you want (omit the\n * pattern to fire on every tool call, which is the typical case since\n * the policy itself does the filtering).\n */\nexport function createToolPolicyHook(\n  config: ToolPolicyConfig\n): HookCallback<'PreToolUse'> {\n  const denyMatcher = compileMatchers(config.deny);\n  const allowMatcher = compileMatchers(config.allow);\n  const askMatcher = compileMatchers(config.ask);\n  const mode: ToolPolicyMode = config.mode ?? 'default';\n  const reasonTemplate = config.reason;\n\n  return async (input): Promise<PreToolUseHookOutput> => {\n    const toolName = input.toolName;\n    const decision = decide(\n      toolName,\n      mode,\n      denyMatcher,\n      allowMatcher,\n      askMatcher\n    );\n    if (decision === 'allow') {\n      return { decision };\n    }\n    const reason = formatReason(reasonTemplate, toolName);\n    if (reason != null) {\n      return { decision, reason };\n    }\n    return { decision };\n  };\n}\n\nfunction decide(\n  toolName: string,\n  mode: ToolPolicyMode,\n  denyMatch: (n: string) => boolean,\n  allowMatch: (n: string) => boolean,\n  askMatch: (n: string) => boolean\n): ToolDecision {\n  if (denyMatch(toolName)) {\n    return 'deny';\n  }\n  if (mode === 'bypass') {\n    return 'allow';\n  }\n  if (allowMatch(toolName)) {\n    return 'allow';\n  }\n  if (askMatch(toolName)) {\n    return 'ask';\n  }\n  if (mode === 'dontAsk') {\n    return 'deny';\n  }\n  return 'ask';\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;AAUG;AAmDH;;;;;;;AAOG;AACH,SAAS,WAAW,CAAC,OAAe,EAAA;IAClC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE,MAAM,CAAC;AAC7D,IAAA,OAAO,IAAI,MAAM,CAAC,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC;AAC7D;AAEA;AACA,SAAS,eAAe,CACtB,QAAuC,EAAA;IAEvC,IAAI,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;AAC7C,QAAA,OAAO,MAAM,KAAK;IACpB;IACA,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC;IACzC,OAAO,CAAC,QAAgB,KAAa;AACnC,QAAA,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;AAC3B,YAAA,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AACxB,gBAAA,OAAO,IAAI;YACb;QACF;AACA,QAAA,OAAO,KAAK;AACd,IAAA,CAAC;AACH;AAEA,SAAS,YAAY,CACnB,QAA4B,EAC5B,QAAgB,EAAA;AAEhB,IAAA,IAAI,QAAQ,IAAI,IAAI,EAAE;AACpB,QAAA,OAAO,SAAS;IAClB;IACA,OAAO,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC;AAChD;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG,SAAU,oBAAoB,CAClC,MAAwB,EAAA;IAExB,MAAM,WAAW,GAAG,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC;IAChD,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC;IAClD,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC;AAC9C,IAAA,MAAM,IAAI,GAAmB,MAAM,CAAC,IAAI,IAAI,SAAS;AACrD,IAAA,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM;AAEpC,IAAA,OAAO,OAAO,KAAK,KAAmC;AACpD,QAAA,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ;AAC/B,QAAA,MAAM,QAAQ,GAAG,MAAM,CACrB,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,YAAY,EACZ,UAAU,CACX;AACD,QAAA,IAAI,QAAQ,KAAK,OAAO,EAAE;YACxB,OAAO,EAAE,QAAQ,EAAE;QACrB;QACA,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,EAAE,QAAQ,CAAC;AACrD,QAAA,IAAI,MAAM,IAAI,IAAI,EAAE;AAClB,YAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE;QAC7B;QACA,OAAO,EAAE,QAAQ,EAAE;AACrB,IAAA,CAAC;AACH;AAEA,SAAS,MAAM,CACb,QAAgB,EAChB,IAAoB,EACpB,SAAiC,EACjC,UAAkC,EAClC,QAAgC,EAAA;AAEhC,IAAA,IAAI,SAAS,CAAC,QAAQ,CAAC,EAAE;AACvB,QAAA,OAAO,MAAM;IACf;AACA,IAAA,IAAI,IAAI,KAAK,QAAQ,EAAE;AACrB,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE;AACxB,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,IAAI,QAAQ,CAAC,QAAQ,CAAC,EAAE;AACtB,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IAAI,IAAI,KAAK,SAAS,EAAE;AACtB,QAAA,OAAO,MAAM;IACf;AACA,IAAA,OAAO,KAAK;AACd;;;;"}
+{"version":3,"file":"createToolPolicyHook.cjs","names":[],"sources":["../../../src/hooks/createToolPolicyHook.ts"],"sourcesContent":["/**\n * Declarative `PreToolUse` hook factory. Lets hosts express common\n * permission policies (allow / deny / ask lists + a global mode) without\n * hand-rolling matching, precedence, and decision logic per-host.\n *\n * Maps directly to the Claude Code Agent SDK permission vocabulary\n * (`allowed_tools` / `disallowed_tools` / `permissionMode`) so users of\n * either SDK can think in the same terms. See the README's HITL section\n * for the cross-walk and `docs/hooks-design-report.md` for the broader\n * hook system context.\n */\n\nimport type { HookCallback, PreToolUseHookOutput, ToolDecision } from './types';\n\n/**\n * Permission mode controlling how tool calls that match no rule are\n * resolved. Mirrors Claude Code's `permissionMode`.\n *\n *   - `default`  — unmatched tools fall through to `'ask'` (interrupt).\n *   - `dontAsk`  — unmatched tools are denied; the human is never\n *                  prompted. Useful for headless / API agents where a\n *                  silent denial is preferable to a hung interrupt.\n *   - `bypass`   — every tool is approved, except those matching `deny`\n *                  patterns. The kill switch you flip when you trust\n *                  the agent and want to stop being asked. Equivalent to\n *                  Claude Code's `bypassPermissions`.\n */\nexport type ToolPolicyMode = 'default' | 'dontAsk' | 'bypass';\n\nexport interface ToolPolicyConfig {\n  /**\n   * Global mode applied to tools that don't match any rule.\n   * Defaults to `'default'` (ask the human).\n   */\n  mode?: ToolPolicyMode;\n  /**\n   * Tool name patterns that are auto-approved without a prompt.\n   * Patterns support glob `*` wildcards: `read_file`, `mcp:github:*`,\n   * `*search*`. Match is anchored (`^pattern$`).\n   */\n  allow?: readonly string[];\n  /**\n   * Tool name patterns that are blocked outright. Wins over `allow`\n   * and `ask`, and overrides `mode: 'bypass'` — a deny rule always\n   * holds, matching Claude Code's \"deny rules are checked first\" guarantee.\n   */\n  deny?: readonly string[];\n  /**\n   * Tool name patterns that always trigger human approval, regardless\n   * of `mode: 'default'` vs `'dontAsk'`. In `mode: 'bypass'` these are\n   * still bypassed (because that's what bypass means).\n   */\n  ask?: readonly string[];\n  /**\n   * Optional reason attached to the resulting `ask` / `deny` hook\n   * decision so the host UI can render why approval is required.\n   * The literal token `{tool}` is replaced with the tool name.\n   */\n  reason?: string;\n}\n\n/**\n * Compile a glob string with `*` wildcards into a single anchored\n * `RegExp`. Other regex metacharacters are escaped, so `read_file.md`\n * matches the literal dot. Patterns are short (tool names), so we do\n * not cache here — the registry's `matchesQuery` already caches its own\n * regex compilations and our patterns are evaluated once per ToolNode\n * batch, not once per stream chunk.\n */\nfunction globToRegex(pattern: string): RegExp {\n  const escaped = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  return new RegExp('^' + escaped.replace(/\\*/g, '.*') + '$');\n}\n\n/** Pre-compile a list of glob patterns into a single match function. */\nfunction compileMatchers(\n  patterns: readonly string[] | undefined\n): (toolName: string) => boolean {\n  if (patterns == null || patterns.length === 0) {\n    return () => false;\n  }\n  const regexes = patterns.map(globToRegex);\n  return (toolName: string): boolean => {\n    for (const regex of regexes) {\n      if (regex.test(toolName)) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n\nfunction formatReason(\n  template: string | undefined,\n  toolName: string\n): string | undefined {\n  if (template == null) {\n    return undefined;\n  }\n  return template.replace(/\\{tool\\}/g, toolName);\n}\n\n/**\n * Build a `PreToolUse` hook callback that applies a declarative tool\n * permission policy. Register it with a `HookRegistry` and the SDK's\n * `humanInTheLoop` machinery handles the rest:\n *\n * ```ts\n * const policyHook = createToolPolicyHook({\n *   mode: 'default',\n *   allow: ['read_*', 'grep', 'glob'],\n *   deny:  ['delete_*'],\n *   ask:   ['execute_*', 'mcp:*'],\n * });\n * registry.register('PreToolUse', { hooks: [policyHook] });\n * ```\n *\n * Evaluation order matches Claude Code's permission flow:\n *\n *   1. `deny` rule match → `'deny'` (always wins, even in `bypass`).\n *   2. `mode === 'bypass'` → `'allow'`.\n *   3. `allow` rule match → `'allow'`.\n *   4. `ask` rule match → `'ask'`.\n *   5. `mode === 'dontAsk'` → `'deny'`.\n *   6. fallthrough → `'ask'`.\n *\n * The returned callback is a single `HookCallback`, not a `HookMatcher` —\n * register it under the matcher with the pattern you want (omit the\n * pattern to fire on every tool call, which is the typical case since\n * the policy itself does the filtering).\n */\nexport function createToolPolicyHook(\n  config: ToolPolicyConfig\n): HookCallback<'PreToolUse'> {\n  const denyMatcher = compileMatchers(config.deny);\n  const allowMatcher = compileMatchers(config.allow);\n  const askMatcher = compileMatchers(config.ask);\n  const mode: ToolPolicyMode = config.mode ?? 'default';\n  const reasonTemplate = config.reason;\n\n  return async (input): Promise<PreToolUseHookOutput> => {\n    const toolName = input.toolName;\n    const decision = decide(\n      toolName,\n      mode,\n      denyMatcher,\n      allowMatcher,\n      askMatcher\n    );\n    if (decision === 'allow') {\n      return { decision };\n    }\n    const reason = formatReason(reasonTemplate, toolName);\n    if (reason != null) {\n      return { decision, reason };\n    }\n    return { decision };\n  };\n}\n\nfunction decide(\n  toolName: string,\n  mode: ToolPolicyMode,\n  denyMatch: (n: string) => boolean,\n  allowMatch: (n: string) => boolean,\n  askMatch: (n: string) => boolean\n): ToolDecision {\n  if (denyMatch(toolName)) {\n    return 'deny';\n  }\n  if (mode === 'bypass') {\n    return 'allow';\n  }\n  if (allowMatch(toolName)) {\n    return 'allow';\n  }\n  if (askMatch(toolName)) {\n    return 'ask';\n  }\n  if (mode === 'dontAsk') {\n    return 'deny';\n  }\n  return 'ask';\n}\n"],"mappings":";;;;;;;;;AAqEA,SAAS,YAAY,SAAyB;CAC5C,MAAM,UAAU,QAAQ,QAAQ,sBAAsB,MAAM;CAC5D,OAAO,IAAI,OAAO,MAAM,QAAQ,QAAQ,OAAO,IAAI,IAAI,GAAG;AAC5D;;AAGA,SAAS,gBACP,UAC+B;CAC/B,IAAI,YAAY,QAAQ,SAAS,WAAW,GAC1C,aAAa;CAEf,MAAM,UAAU,SAAS,IAAI,WAAW;CACxC,QAAQ,aAA8B;EACpC,KAAK,MAAM,SAAS,SAClB,IAAI,MAAM,KAAK,QAAQ,GACrB,OAAO;EAGX,OAAO;CACT;AACF;AAEA,SAAS,aACP,UACA,UACoB;CACpB,IAAI,YAAY,MACd;CAEF,OAAO,SAAS,QAAQ,aAAa,QAAQ;AAC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,qBACd,QAC4B;CAC5B,MAAM,cAAc,gBAAgB,OAAO,IAAI;CAC/C,MAAM,eAAe,gBAAgB,OAAO,KAAK;CACjD,MAAM,aAAa,gBAAgB,OAAO,GAAG;CAC7C,MAAM,OAAuB,OAAO,QAAQ;CAC5C,MAAM,iBAAiB,OAAO;CAE9B,OAAO,OAAO,UAAyC;EACrD,MAAM,WAAW,MAAM;EACvB,MAAM,WAAW,OACf,UACA,MACA,aACA,cACA,UACF;EACA,IAAI,aAAa,SACf,OAAO,EAAE,SAAS;EAEpB,MAAM,SAAS,aAAa,gBAAgB,QAAQ;EACpD,IAAI,UAAU,MACZ,OAAO;GAAE;GAAU;EAAO;EAE5B,OAAO,EAAE,SAAS;CACpB;AACF;AAEA,SAAS,OACP,UACA,MACA,WACA,YACA,UACc;CACd,IAAI,UAAU,QAAQ,GACpB,OAAO;CAET,IAAI,SAAS,UACX,OAAO;CAET,IAAI,WAAW,QAAQ,GACrB,OAAO;CAET,IAAI,SAAS,QAAQ,GACnB,OAAO;CAET,IAAI,SAAS,WACX,OAAO;CAET,OAAO;AACT"}