@slates/provider 1.0.0-rc.28 → 1.0.0-rc.30

package/src/error/utils.ts

@@ -1,3 +1,11 @@
+import { AuthConfigSecretRedactor } from '../auth/redact';
+import {
+  isSecretFieldName,
+  redactAuthConfigSecretsInText,
+  sanitizeSecretValuesInText,
+  splitKeyParts
+} from '../axios/trace';
+import { getCurrentContext } from '../context/hook';
 import { DEFAULT_CODE, DEFAULT_MESSAGES } from './defaults';
 import type {
   SlateErrorInput,
@@ -112,26 +120,273 @@ export let mergeSlateErrorData = (
   };
 };
 
-export let sanitizeForBaggage = (value: unknown, depth = 0): unknown => {
-  if (value == null) return value;
-  if (depth >= 4) return '[truncated]';
-  if (typeof value === 'string') {
-    return value.length > 2_000 ? `${value.slice(0, 2_000)}...[truncated]` : value;
+export let BAGGAGE_TRUNCATED_VALUE = '[truncated]';
+export let BAGGAGE_REDACTED_VALUE = '[redacted]';
+export let BAGGAGE_UNSERIALIZABLE_VALUE = '[unserializable]';
+
+// Values nested this deep (root = depth 0) are replaced with the truncated placeholder.
+export let BAGGAGE_DEFAULT_MAX_DEPTH = 4;
+// Upstream response bodies keep deeper structure so nested provider error details
+// (GraphQL errors[].extensions.*, QuickBooks Fault.Error[].Detail, validation error
+// lists) reach message extractors and telemetry.
+export let BAGGAGE_RESPONSE_MAX_DEPTH = 8;
+export let BAGGAGE_MAX_STRING_LENGTH = 2_000;
+export let BAGGAGE_MAX_ARRAY_ITEMS = 20;
+export let BAGGAGE_MAX_OBJECT_KEYS = 30;
+// Upper bound for the JSON-serialized size of one sanitized value. Entries past
+// the budget are dropped (and a string that crosses it is cut), so a single call
+// serializes to at most this many characters plus a small fixed overhead.
+export let BAGGAGE_MAX_SERIALIZED_SIZE = 16_384;
+
+let BAGGAGE_STRING_TRUNCATION_SUFFIX = '...[truncated]';
+// Keep budget cuts from producing near-empty strings.
+let BAGGAGE_MIN_STRING_SLICE = 32;
+
+// Free-text patterns are scanned over at most this many characters (the kept
+// string length plus a margin), which bounds their cost on adversarial input.
+let BAGGAGE_SCAN_LENGTH = BAGGAGE_MAX_STRING_LENGTH + 100;
+// Literal auth-config secrets are matched over a longer prefix so a long token that
+// straddles the scan boundary is still replaced before the string is cut.
+let BAGGAGE_REDACTOR_SCAN_LENGTH = BAGGAGE_MAX_STRING_LENGTH * 4;
+// Once fewer characters than the smallest entry (`"k":0,`) remain, stop walking keys.
+let BAGGAGE_MIN_ENTRY_COST = 6;
+
+export type SanitizeForBaggageOptions = {
+  maxDepth?: number;
+  maxSerializedSize?: number;
+  // Replaces literal auth-config values. Defaults to the current Slate context's auth
+  // config when one is available; `null` disables it.
+  redactor?: AuthConfigSecretRedactor | null;
+};
+
+// Returns a redactor for the current Slate context's auth config, or undefined when
+// no context is active (or it cannot be read).
+export let getCurrentAuthConfigRedactor = (): AuthConfigSecretRedactor | undefined => {
+  try {
+    let authConfig = getCurrentContext()._getAuthConfigForRedaction();
+    return authConfig ? new AuthConfigSecretRedactor(authConfig) : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+// sanitizeErrorText keeps at most this many characters. It scans a small margin past
+// the cut so a credential straddling it is still recognized before the text is cut.
+export let ERROR_TEXT_MAX_LENGTH = BAGGAGE_MAX_STRING_LENGTH * 4;
+let ERROR_TEXT_SCAN_MARGIN = 512;
+
+// Free-text scrub for human-readable error text (messages, details): literal
+// auth-config secrets first, then known credential formats and secret-named pairs.
+// Input past ERROR_TEXT_MAX_LENGTH is cut, which also bounds the pattern cost.
+// `redactor`: undefined uses the current Slate context's auth config, null skips it.
+// Never throws; a failing redactor falls back to the pattern scrub alone.
+export let sanitizeErrorText = (
+  text: string,
+  redactor?: AuthConfigSecretRedactor | null
+): string => {
+  let activeRedactor = redactor === undefined ? getCurrentAuthConfigRedactor() : redactor;
+  let truncated = text.length > ERROR_TEXT_MAX_LENGTH;
+  let scanned = truncated
+    ? text.slice(0, ERROR_TEXT_MAX_LENGTH + ERROR_TEXT_SCAN_MARGIN)
+    : text;
+
+  let result = scanned;
+  if (activeRedactor) {
+    try {
+      result = redactAuthConfigSecretsInText(result, activeRedactor);
+    } catch {
+      result = scanned;
+    }
+  }
+  result = sanitizeSecretValuesInText(result);
+
+  return truncated
+    ? `${result.slice(0, ERROR_TEXT_MAX_LENGTH)}${BAGGAGE_STRING_TRUNCATION_SUFFIX}`
+    : result;
+};
+
+// Numbers under these keys are themselves secrets (PINs, card data, numeric
+// verification codes, numeric keys and secrets); other numeric and boolean values under
+// secret-named keys (`token: true`, `session: 3`) are flags or counts and are kept.
+let NUMERIC_SECRET_KEY_PATTERN =
+  /(?:^|_)(?:pin|passcode|password|passwd|pwd|otp|totp|cvv|cvc|ccv|pan|ssn|card_number|card_code|cc_num(?:ber)?)(?:_|$)|(?:^|_)(?:code|secret|key)$/;
+
+// Validation messages under secret-named fields (`{password: "is too short"}`,
+// `{token: ["This field is required."]}`) are kept when they are clearly prose:
+// three or more short words, no token-like word (20+ characters, or letters mixed
+// with digits), bounded length, and validation vocabulary. Multi-word passphrases rarely use that vocabulary, so a string that is
+// merely several words is still redacted.
+let VALIDATION_VOCABULARY_PATTERN =
+  /\b(?:required|invalid|must|blank|empty|missing|too (?:short|long|weak|common|simple)|characters?|(?:does not|doesn't|do not|don't) match|cannot be|can't be|not allowed|not valid|at least|at most|incorrect|already (?:taken|used|exists|in use)|has expired|is expired)\b/i;
+
+let isValidationProse = (value: string) => {
+  let text = value.trim();
+  if (text.length > 300) return false;
+  let words = text.split(/\s+/);
+  if (words.length < 3) return false;
+  if (words.some(word => word.length > 20 || (/[a-z]/i.test(word) && /\d/.test(word)))) {
+    return false;
+  }
+  return VALIDATION_VOCABULARY_PATTERN.test(text);
+};
+
+let isKeptUnderSecretKey = (key: string, value: unknown) => {
+  if (typeof value === 'boolean') return true;
+  if (typeof value === 'number')
+    return !NUMERIC_SECRET_KEY_PATTERN.test(splitKeyParts(key).join('_'));
+  if (typeof value === 'string') return isValidationProse(value);
+  if (Array.isArray(value)) {
+    return (
+      value.length > 0 &&
+      value.length <= BAGGAGE_MAX_ARRAY_ITEMS &&
+      value.every(item => typeof item === 'string' && isValidationProse(item))
+    );
+  }
+  return false;
+};
+
+let jsonLength = (value: string) => JSON.stringify(value).length;
+
+type BaggageState = {
+  remaining: number;
+  redactor?: AuthConfigSecretRedactor;
+};
+
+let redactLiteralSecrets = (value: string, redactor?: AuthConfigSecretRedactor) => {
+  if (!redactor) return value;
+  try {
+    return redactAuthConfigSecretsInText(
+      value.slice(0, BAGGAGE_REDACTOR_SCAN_LENGTH),
+      redactor
+    );
+  } catch {
+    return value;
+  }
+};
+
+let sanitizeBaggageString = (value: string, state: BaggageState) => {
+  // Redact literal auth-config secrets and known secret formats before cutting, so a
+  // cut cannot split a token into a fragment the value patterns no longer recognize.
+  let literalRedacted = redactLiteralSecrets(value, state.redactor);
+  let text = sanitizeSecretValuesInText(literalRedacted.slice(0, BAGGAGE_SCAN_LENGTH));
+  if (
+    value.length > BAGGAGE_MAX_STRING_LENGTH ||
+    literalRedacted.length > BAGGAGE_MAX_STRING_LENGTH ||
+    text.length > BAGGAGE_MAX_STRING_LENGTH
+  ) {
+    text = `${text.slice(0, BAGGAGE_MAX_STRING_LENGTH)}${BAGGAGE_STRING_TRUNCATION_SUFFIX}`;
+  }
+
+  let cost = jsonLength(text);
+  if (cost > state.remaining) {
+    let sliceLength =
+      state.remaining - BAGGAGE_STRING_TRUNCATION_SUFFIX.length - 2 - (cost - text.length);
+    text =
+      sliceLength >= BAGGAGE_MIN_STRING_SLICE
+        ? `${text.slice(0, sliceLength)}${BAGGAGE_STRING_TRUNCATION_SUFFIX}`
+        : BAGGAGE_TRUNCATED_VALUE;
+    cost = jsonLength(text);
+    if (cost > state.remaining && text !== BAGGAGE_TRUNCATED_VALUE) {
+      text = BAGGAGE_TRUNCATED_VALUE;
+      cost = jsonLength(text);
+    }
+  }
+
+  state.remaining -= cost;
+  return text;
+};
+
+let sanitizeBaggageValue = (
+  value: unknown,
+  depth: number,
+  maxDepth: number,
+  state: BaggageState
+): unknown => {
+  if (value === undefined) return value;
+  if (value === null) {
+    state.remaining -= 4;
+    return value;
+  }
+  if (depth >= maxDepth) {
+    state.remaining -= jsonLength(BAGGAGE_TRUNCATED_VALUE);
+    return BAGGAGE_TRUNCATED_VALUE;
   }
-  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+  if (typeof value === 'string') return sanitizeBaggageString(value, state);
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    state.remaining -= String(value).length;
     return value;
   }
+  // JSON.stringify throws on bigint, so it is stored as a string.
+  if (typeof value === 'bigint') return sanitizeBaggageString(value.toString(), state);
   if (Array.isArray(value)) {
-    return value.slice(0, 20).map(item => sanitizeForBaggage(item, depth + 1));
+    state.remaining -= 2;
+    let items: unknown[] = [];
+    for (let item of value.slice(0, BAGGAGE_MAX_ARRAY_ITEMS)) {
+      if (state.remaining <= 0) break;
+      state.remaining -= 1;
+      if (item === undefined) {
+        // Serialized as `null` inside arrays.
+        state.remaining -= 4;
+        items.push(null);
+        continue;
+      }
+      items.push(sanitizeBaggageValue(item, depth + 1, maxDepth, state));
+    }
+    return items;
   }
   if (isRecord(value)) {
-    return Object.fromEntries(
-      Object.entries(value)
-        .slice(0, 30)
-        .map(([key, entry]) => [key, sanitizeForBaggage(entry, depth + 1)])
-    );
+    state.remaining -= 2;
+    let entries: [string, unknown][] = [];
+    for (let key of Object.keys(value).slice(0, BAGGAGE_MAX_OBJECT_KEYS)) {
+      if (state.remaining < BAGGAGE_MIN_ENTRY_COST) break;
+      // Key, colon, and separator are charged up front; an entry whose key does not
+      // fit is skipped so shorter later keys can still be kept.
+      let keyCost = jsonLength(key) + 2;
+      if (state.remaining - keyCost <= 0) continue;
+      state.remaining -= keyCost;
+
+      try {
+        // Property access is per entry so one throwing getter only loses that entry.
+        let entry = value[key];
+
+        if (entry != null && isSecretFieldName(key) && !isKeptUnderSecretKey(key, entry)) {
+          state.remaining -= jsonLength(BAGGAGE_REDACTED_VALUE);
+          entries.push([key, BAGGAGE_REDACTED_VALUE]);
+          continue;
+        }
+
+        entries.push([key, sanitizeBaggageValue(entry, depth + 1, maxDepth, state)]);
+      } catch {
+        state.remaining -= jsonLength(BAGGAGE_UNSERIALIZABLE_VALUE);
+        entries.push([key, BAGGAGE_UNSERIALIZABLE_VALUE]);
+      }
+    }
+    return Object.fromEntries(entries);
+  }
+  return sanitizeBaggageString(String(value), state);
+};
+
+// Bounds and redacts arbitrary values (upstream response bodies, service error data,
+// thrown non-Error values) before they are stored in SlateError baggage, which is
+// serialized to the platform. Secret-named keys are redacted at every depth, strings
+// are scrubbed for credential values and (inside a Slate context) literal auth-config
+// secrets; other personal data is left to platform-side redaction.
+export let sanitizeForBaggage = (
+  value: unknown,
+  options: SanitizeForBaggageOptions = {}
+): unknown => {
+  try {
+    return sanitizeBaggageValue(value, 0, options.maxDepth ?? BAGGAGE_DEFAULT_MAX_DEPTH, {
+      remaining: options.maxSerializedSize ?? BAGGAGE_MAX_SERIALIZED_SIZE,
+      redactor:
+        options.redactor === null
+          ? undefined
+          : (options.redactor ?? getCurrentAuthConfigRedactor())
+    });
+  } catch {
+    // Throwing getters or Proxy traps must not mask the error being mapped.
+    return BAGGAGE_UNSERIALIZABLE_VALUE;
   }
-  return String(value);
 };
 
 export let normalizeSlateErrorInput = (input: SlateErrorInput): SlateErrorResponse => {

package/src/specification/slate.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { z } from 'zod';
-import { SlateTrigger, SlateTriggerGroup } from '../action';
+import { SlateTool, SlateTrigger, SlateTriggerGroup, toolCategory } from '../action';
 import { SlateAuth } from '../auth';
 import { SlateConfig } from '../config';
 import { Slate } from './slate';
@@ -117,3 +117,155 @@ describe('Slate.create', () => {
     expect(slate.triggerGroups).toEqual([]);
   });
 });
+
+let createTestTool = (spec: ReturnType<typeof createTestSpec>, key: string) =>
+  SlateTool.create(spec, { key, name: key })
+    .input(z.object({}))
+    .output(z.object({}))
+    .handleInvocation(async () => ({ output: {}, message: 'ok' }))
+    .build();
+
+describe('Slate.create tool categories', () => {
+  it('resolves membership in declared category order', () => {
+    let spec = createTestSpec();
+    let records = createTestTool(spec, 'records');
+    let report = createTestTool(spec, 'report');
+    let other = createTestTool(spec, 'other');
+
+    let slate = Slate.create({
+      spec,
+      tools: [records, report, other],
+      triggers: [],
+      toolCategories: [
+        toolCategory({ key: 'crm', name: 'CRM', tools: [records, report] }),
+        toolCategory({ key: 'reporting', name: 'Reporting', tools: [report] })
+      ]
+    });
+
+    expect(slate.toolCategories.map(category => category.key)).toEqual(['crm', 'reporting']);
+    expect(slate.getToolCategoryKeys('records')).toEqual(['crm']);
+    expect(slate.getToolCategoryKeys('report')).toEqual(['crm', 'reporting']);
+    expect(slate.getToolCategoryKeys('other')).toEqual([]);
+  });
+
+  it('ignores a shadowed duplicate tool listed in a category', () => {
+    let spec = createTestSpec();
+    let writer = createTestTool(spec, 'dup');
+    let reader = createTestTool(spec, 'dup');
+
+    let slate = Slate.create({
+      spec,
+      tools: [writer, reader],
+      triggers: [],
+      toolCategories: [toolCategory({ key: 'read', name: 'Read', tools: [reader] })]
+    });
+
+    expect(slate.getToolCategoryKeys('dup')).toEqual([]);
+  });
+
+  it('returns a copy of the membership list', () => {
+    let spec = createTestSpec();
+    let tool = createTestTool(spec, 'a');
+    let slate = Slate.create({
+      spec,
+      tools: [tool],
+      triggers: [],
+      toolCategories: [toolCategory({ key: 'crm', name: 'CRM', tools: [tool] })]
+    });
+
+    slate.getToolCategoryKeys('a').push('mutated');
+    expect(slate.getToolCategoryKeys('a')).toEqual(['crm']);
+  });
+
+  it('defaults to no categories', () => {
+    let spec = createTestSpec();
+    let slate = Slate.create({ spec, tools: [createTestTool(spec, 'a')], triggers: [] });
+
+    expect(slate.toolCategories).toEqual([]);
+    expect(slate.getToolCategoryKeys('a')).toEqual([]);
+  });
+
+  it('rejects duplicate and malformed category keys', () => {
+    let spec = createTestSpec();
+    let tool = createTestTool(spec, 'a');
+
+    expect(() =>
+      Slate.create({
+        spec,
+        tools: [tool],
+        triggers: [],
+        toolCategories: [
+          toolCategory({ key: 'crm', name: 'CRM', tools: [tool] }),
+          toolCategory({ key: 'crm', name: 'CRM again', tools: [tool] })
+        ]
+      })
+    ).toThrow('Tool category "crm" is registered more than once');
+
+    expect(() =>
+      Slate.create({
+        spec,
+        tools: [tool],
+        triggers: [],
+        toolCategories: [toolCategory({ key: 'Zoho CRM', name: 'CRM', tools: [tool] })]
+      })
+    ).toThrow('Tool category key "Zoho CRM" must match');
+  });
+
+  it('accepts http(s) category images and rejects anything else', () => {
+    let spec = createTestSpec();
+    let tool = createTestTool(spec, 'a');
+    let slate = Slate.create({
+      spec,
+      tools: [tool],
+      triggers: [],
+      toolCategories: [
+        toolCategory({
+          key: 'crm',
+          name: 'CRM',
+          imageUrl: 'https://cdn.test/crm.svg',
+          tools: [tool]
+        })
+      ]
+    });
+    expect(slate.toolCategories[0]?.imageUrl).toBe('https://cdn.test/crm.svg');
+
+    expect(() =>
+      Slate.create({
+        spec,
+        tools: [tool],
+        triggers: [],
+        toolCategories: [
+          toolCategory({ key: 'crm', name: 'CRM', imageUrl: 'crm.svg', tools: [tool] })
+        ]
+      })
+    ).toThrow('Tool category "crm" imageUrl must be an absolute http(s) URL');
+  });
+
+  it('rejects a category without tools', () => {
+    let spec = createTestSpec();
+
+    expect(() =>
+      Slate.create({
+        spec,
+        tools: [createTestTool(spec, 'a')],
+        triggers: [],
+        toolCategories: [toolCategory({ key: 'crm', name: 'CRM', tools: [] })]
+      })
+    ).toThrow('Tool category "crm" must list at least one tool');
+  });
+
+  it('rejects unregistered member tools', () => {
+    let spec = createTestSpec();
+
+    expect(() =>
+      Slate.create({
+        spec,
+        tools: [],
+        triggers: [],
+        toolCategories: [
+          toolCategory({ key: 'crm', name: 'CRM', tools: [createTestTool(spec, 'stray')] })
+        ]
+      })
+    ).toThrow('Tool category "crm" lists tool "stray", which is not registered in this slate');
+  });
+});

package/src/specification/slate.ts

@@ -1,4 +1,4 @@
-import type { SlateTool, SlateTrigger, SlateTriggerGroup } from '../action';
+import type { SlateTool, SlateToolCategory, SlateTrigger, SlateTriggerGroup } from '../action';
 import type { SlateAdapter } from '../adapter';
 import { SlateDeclarationError } from '../error';
 import type { SlateSpecification } from './specification';
@@ -11,7 +11,9 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
       | SlateTool<ConfigType, AuthType, any, any>
     )[],
     private readonly _adapters: SlateAdapter<ConfigType, AuthType>[],
-    private readonly _triggerGroups: SlateTriggerGroup<ConfigType, AuthType>[]
+    private readonly _triggerGroups: SlateTriggerGroup<ConfigType, AuthType>[],
+    private readonly _toolCategories: SlateToolCategory[],
+    private readonly _toolCategoryKeysByActionKey: Map<string, string[]>
   ) {}
 
   static create<ConfigType extends {}, AuthType extends {}>(params: {
@@ -20,6 +22,7 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     tools: SlateTool<ConfigType, AuthType, any, any>[];
     adapters?: SlateAdapter<ConfigType, AuthType>[];
     triggerGroups?: SlateTriggerGroup<ConfigType, AuthType>[];
+    toolCategories?: SlateToolCategory[];
   }) {
     let adapters = params.adapters ?? [];
     let actions = [...params.triggers, ...params.tools];
@@ -71,7 +74,17 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
       );
     }
 
-    return new Slate(params.spec, actions, adapters, triggerGroups);
+    let toolCategories = params.toolCategories ?? [];
+    let toolCategoryKeysByActionKey = resolveToolCategoryMembership(toolCategories, actions);
+
+    return new Slate(
+      params.spec,
+      actions,
+      adapters,
+      triggerGroups,
+      toolCategories,
+      toolCategoryKeysByActionKey
+    );
   }
 
   get spec() {
@@ -89,4 +102,93 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
   get triggerGroups() {
     return this._triggerGroups ?? [];
   }
+
+  get toolCategories() {
+    return this._toolCategories ?? [];
+  }
+
+  // Keys of the tool categories an action belongs to, in declared category order.
+  getToolCategoryKeys(actionKey: string) {
+    return [...(this._toolCategoryKeysByActionKey?.get(actionKey) ?? [])];
+  }
 }
+
+let TOOL_CATEGORY_KEY_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+
+let isHttpUrl = (value: string) => {
+  try {
+    let url = new URL(value);
+    return url.protocol === 'https:' || url.protocol === 'http:';
+  } catch {
+    return false;
+  }
+};
+
+type SlateActionAny = SlateTool<any, any, any, any> | SlateTrigger<any, any, any, any>;
+
+let resolveToolCategoryMembership = (
+  toolCategories: SlateToolCategory[],
+  actions: SlateActionAny[]
+) => {
+  // Actions resolve by key and the first registered one wins, so a shadowed duplicate must
+  // not lend its categories to the action that actually runs.
+  let effectiveActions = new Map<string, SlateActionAny>();
+  for (let action of actions) {
+    if (!effectiveActions.has(action.key)) effectiveActions.set(action.key, action);
+  }
+  let registeredActions = new Set(actions);
+  let membersByCategoryKey = new Map<string, Set<string>>();
+
+  for (let category of toolCategories) {
+    if (!TOOL_CATEGORY_KEY_PATTERN.test(category.key)) {
+      throw new SlateDeclarationError(
+        `Tool category key "${category.key}" must match ${TOOL_CATEGORY_KEY_PATTERN}`
+      );
+    }
+    if (membersByCategoryKey.has(category.key)) {
+      throw new SlateDeclarationError(
+        `Tool category "${category.key}" is registered more than once`
+      );
+    }
+    if (!category.name?.trim()) {
+      throw new SlateDeclarationError(`Tool category "${category.key}" must have a name`);
+    }
+    if (category.imageUrl !== undefined && !isHttpUrl(category.imageUrl)) {
+      throw new SlateDeclarationError(
+        `Tool category "${category.key}" imageUrl must be an absolute http(s) URL`
+      );
+    }
+    if (!category.tools?.length) {
+      throw new SlateDeclarationError(
+        `Tool category "${category.key}" must list at least one tool`
+      );
+    }
+
+    let members = new Set<string>();
+    for (let tool of category.tools) {
+      if (!registeredActions.has(tool)) {
+        throw new SlateDeclarationError(
+          `Tool category "${category.key}" lists tool "${tool.key}", which is not registered in this slate`
+        );
+      }
+      if (tool.type !== 'tool') {
+        throw new SlateDeclarationError(
+          `Tool category "${category.key}" lists trigger "${tool.key}", but only tools can belong to a tool category`
+        );
+      }
+      if (effectiveActions.get(tool.key) === tool) members.add(tool.key);
+    }
+    membersByCategoryKey.set(category.key, members);
+  }
+
+  let keysByActionKey = new Map<string, string[]>();
+  for (let category of toolCategories) {
+    for (let actionKey of membersByCategoryKey.get(category.key) ?? []) {
+      let keys = keysByActionKey.get(actionKey) ?? [];
+      keys.push(category.key);
+      keysByActionKey.set(actionKey, keys);
+    }
+  }
+
+  return keysByActionKey;
+};