@slates/provider 1.0.0-rc.34 → 1.0.0-rc.35

package/src/action/optionList.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import type { SlateContext } from '../context';
+import { SlateDeclarationError } from '../error';
+import type { SlateSpecification } from '../specification/specification';
+
+export interface SlateOption {
+  value: string | number;
+  label: string;
+  description?: string;
+}
+
+export interface SlateOptionListPage {
+  options: SlateOption[];
+  nextPageToken?: any | null;
+}
+
+export type SlateOptionListHandler<
+  ConfigType extends {},
+  AuthType extends {},
+  ParamsType extends {} = {}
+> = (
+  context: SlateContext<
+    ConfigType,
+    AuthType,
+    { query: string | null; pageToken: any | null; params: ParamsType }
+  >
+) => Promise<SlateOptionListPage>;
+
+export interface SlateOptionListParameters<
+  ConfigType extends {},
+  AuthType extends {},
+  ParamsSchema extends z.ZodObject<any> = z.ZodObject<{}>
+> {
+  key: string;
+  /** Made strict when declared, so params with a key the schema does not name are rejected. */
+  paramsSchema?: ParamsSchema;
+  list: SlateOptionListHandler<ConfigType, AuthType, z.output<ParamsSchema>>;
+}
+
+/** A list of options other integrations can link their selection fields to. */
+export class SlateOptionList<
+  ConfigType extends {},
+  AuthType extends {},
+  ParamsSchema extends z.ZodObject<any> = z.ZodObject<{}>
+> {
+  private constructor(
+    private readonly _spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly _params: SlateOptionListParameters<ConfigType, AuthType, ParamsSchema>,
+    private readonly _paramsSchema: z.ZodObject<any>
+  ) {}
+
+  static create<
+    ConfigType extends {},
+    AuthType extends {},
+    ParamsSchema extends z.ZodObject<any> = z.ZodObject<{}>
+  >(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateOptionListParameters<ConfigType, AuthType, ParamsSchema>
+  ) {
+    let paramsSchema: z.ZodObject<any> = params.paramsSchema ?? z.object({});
+    if (paramsSchema?._zod?.def?.type !== 'object') {
+      throw new SlateDeclarationError(
+        `Option list "${params.key}" params schema must be a zod object`
+      );
+    }
+
+    return new SlateOptionList(spec, params, paramsSchema.strict());
+  }
+
+  get spec() {
+    return this._spec;
+  }
+
+  get key() {
+    return this._params.key;
+  }
+
+  get paramsSchema() {
+    return this._paramsSchema;
+  }
+
+  get list() {
+    return this._params.list;
+  }
+}
+
+export let optionList = <
+  ConfigType extends {},
+  AuthType extends {},
+  ParamsSchema extends z.ZodObject<any> = z.ZodObject<{}>
+>(
+  spec: SlateSpecification<ConfigType, AuthType>,
+  params: SlateOptionListParameters<ConfigType, AuthType, ParamsSchema>
+) => SlateOptionList.create(spec, params);

package/src/action/trigger.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { SlateAuth } from '../auth';
+import { SlateConfig } from '../config';
+import { SlateSpecification } from '../specification/specification';
+import { SlateTool } from './tool';
+import { SlateTrigger } from './trigger';
+import { triggerGroup } from './triggerGroup';
+
+let spec = SlateSpecification.create({
+  key: 'demo',
+  name: 'Demo',
+  config: SlateConfig.create(z.object({})),
+  auth: SlateAuth.create<{}>().output(z.object({}))
+});
+
+let group = triggerGroup(spec, { key: 'group', name: 'Group' })
+  .polling({ pollEvents: async () => ({ events: [] }) })
+  .routingMatchers(async () => [])
+  .build();
+
+let output = z.object({
+  fileId: z.string(),
+  parents: z.array(z.string()),
+  size: z.number().optional()
+});
+
+let create = () =>
+  SlateTrigger.create(spec, { key: 'changed', name: 'Changed' })
+    .input(z.object({}))
+    .triggerGroup(group)
+    .matches(() => true)
+    .map(async () => ({
+      type: 'file.changed',
+      id: '1',
+      output: { fileId: 'a', parents: [] }
+    }));
+
+describe('trigger event attributes', () => {
+  it('exposes the declared fields on the built trigger', () => {
+    let trigger = create().output(output).eventAttributes(['fileId', 'parents']).build();
+
+    expect(trigger.eventAttributes).toEqual(['fileId', 'parents']);
+  });
+
+  it('is empty when none are declared', () => {
+    expect(create().output(output).build().eventAttributes).toEqual([]);
+  });
+
+  it('checks the fields against an output schema set after the declaration', () => {
+    expect(
+      create()
+        .eventAttributes(['fileId'] as never[])
+        .output(output)
+        .build().eventAttributes
+    ).toEqual(['fileId']);
+
+    expect(() =>
+      create()
+        .eventAttributes(['folderId'] as never[])
+        .output(output)
+        .build()
+    ).toThrow('Event attribute "folderId" is not a top-level property of the output schema');
+  });
+
+  it('rejects fields that are not top-level output properties', () => {
+    expect(() =>
+      create()
+        .output(output)
+        .eventAttributes(['folderId' as any])
+    ).toThrow('Event attribute "folderId" is not a top-level property of the output schema');
+  });
+
+  it('requires the output schema to be a zod object', () => {
+    expect(() =>
+      create()
+        .output(z.record(z.string(), z.string()) as unknown as z.ZodType<{ fileId: string }>)
+        .eventAttributes(['fileId'])
+    ).toThrow('Event attributes require the output schema to be a zod object');
+
+    expect(() =>
+      create()
+        .eventAttributes(['fileId'] as never[])
+        .output(z.record(z.string(), z.string()) as unknown as z.ZodType<{ fileId: string }>)
+        .build()
+    ).toThrow('Event attributes require the output schema to be a zod object');
+  });
+
+  it('rejects names that do not match the key pattern', () => {
+    let schema = z.object({ _id: z.string(), '1st': z.string(), 'a-b': z.string() });
+    for (let field of ['_id', '1st', 'a-b']) {
+      expect(() =>
+        create()
+          .output(schema)
+          .eventAttributes([field as any])
+      ).toThrow(`Event attribute "${field}" must start with a letter`);
+    }
+
+    let long = 'a'.repeat(65);
+    expect(() => create().eventAttributes([long as never])).toThrow(
+      `Event attribute "${long}" must start with a letter`
+    );
+  });
+
+  it('rejects duplicates', () => {
+    expect(() => create().output(output).eventAttributes(['fileId', 'fileId'])).toThrow(
+      'Event attribute "fileId" is declared more than once'
+    );
+  });
+
+  it('allows at most eight fields', () => {
+    let fields = Array.from({ length: 9 }, (_, i) => `field${i}`);
+    let schema = z.object(Object.fromEntries(fields.map(field => [field, z.string()])));
+
+    expect(
+      create().output(schema).eventAttributes(fields.slice(0, 8)).build().eventAttributes
+    ).toHaveLength(8);
+    expect(() => create().output(schema).eventAttributes(fields)).toThrow(
+      'A trigger can declare at most 8 event attributes'
+    );
+  });
+
+  it('can only be declared on triggers', () => {
+    let tool = SlateTool.create(spec, { key: 'send', name: 'Send' })
+      .input(z.object({}))
+      .output(z.object({ id: z.string() }));
+
+    expect(() => tool.eventAttributes(['id'])).toThrow(
+      'eventAttributes can only be set for trigger actions'
+    );
+  });
+});

package/src/action/trigger.ts

@@ -21,6 +21,7 @@ export interface SlateTriggerParameters<
   triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
   matches: SlateTriggerMatchesHandler;
   map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+  eventAttributes?: string[];
 }
 
 export class SlateTrigger<
@@ -34,6 +35,7 @@ export class SlateTrigger<
   #triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
   #matches: SlateTriggerMatchesHandler;
   #map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+  #eventAttributes: string[];
 
   private constructor(
     spec: SlateSpecification<ConfigType, AuthType>,
@@ -46,6 +48,7 @@ export class SlateTrigger<
     this.#triggerGroup = params.triggerGroup;
     this.#matches = params.matches;
     this.#map = params.map;
+    this.#eventAttributes = params.eventAttributes ?? [];
   }
 
   static create<ConfigType extends {}, AuthType extends {}>(
@@ -69,6 +72,10 @@ export class SlateTrigger<
   get map() {
     return this.#map;
   }
+
+  get eventAttributes(): string[] {
+    return [...this.#eventAttributes];
+  }
 }
 
 export let trigger = <ConfigType extends {}, AuthType extends {}>(

package/src/action/triggerGroup.test.ts

@@ -88,3 +88,85 @@ describe('webhook trigger group declaration', () => {
     ).toThrow('A webhook delivery config requires an authenticate handler');
   });
 });
+
+describe('trigger group selection options', () => {
+  let polling = (
+    selectionSchema: z.ZodType<Record<string, any>> = z.object({
+      fileId: z.string(),
+      tab: z.string().optional(),
+      fileIds: z.array(z.string()),
+      folder: z.object({ id: z.string() })
+    })
+  ) =>
+    triggerGroup(spec, { key: 'group', name: 'Group', selectionSchema })
+      .polling({ pollEvents: async () => ({ events: [] }) })
+      .routingMatchers(async () => []);
+  let list = async () => ({ options: [{ value: 'a', label: 'A' }] });
+  let linked = { slate: 'acme/files', optionList: 'files', params: { kind: 'sheet' } };
+
+  it('rejects fields that are not top-level properties of the selection schema', () => {
+    for (let field of ['fileid', 'folder.id', 'id', 'constructor']) {
+      expect(() => polling().selectionOptions({ [field]: { list } })).toThrow(
+        `Selection field "${field}" is not a top-level property of the selection schema`
+      );
+    }
+  });
+
+  it('rejects a selection schema that is not a zod object', () => {
+    for (let selectionSchema of [
+      z.record(z.string(), z.string()),
+      z.object({ fileId: z.string() }).optional() as z.ZodType<Record<string, any>>
+    ]) {
+      expect(() => polling(selectionSchema).selectionOptions({ fileId: { list } })).toThrow(
+        'Selection options require the selection schema to be a zod object'
+      );
+    }
+    expect(() =>
+      triggerGroup(spec, { key: 'group', name: 'Group' }).selectionOptions({
+        fileId: { list }
+      })
+    ).toThrow('Selection options require a selection schema');
+  });
+
+  it('rejects a bare handler instead of { list, linked }', () => {
+    for (let declaration of [list, null]) {
+      expect(() => polling().selectionOptions({ fileId: declaration as any })).toThrow(
+        'Selection field "fileId" must be declared as { list, linked }'
+      );
+    }
+  });
+
+  it('accepts an own list, a linked list, or both per field', () => {
+    let group = polling()
+      .selectionOptions({ fileId: { list, linked } })
+      .selectionOptions({
+        tab: { linked: { slate: 'acme/files', optionList: 'tabs' } },
+        fileIds: { list }
+      })
+      .build();
+    expect(group.selectionOptions).toEqual({
+      fileId: { list, linked },
+      tab: { linked: { slate: 'acme/files', optionList: 'tabs' } },
+      fileIds: { list }
+    });
+  });
+
+  it('rejects a field without an own list or a linked list', () => {
+    expect(() => polling().selectionOptions({ fileId: {} })).toThrow(
+      'Selection field "fileId" needs its own options list, a linked option list, or both'
+    );
+  });
+
+  it('rejects linked lists that do not name a scoped slate and a list', () => {
+    expect(() =>
+      polling().selectionOptions({
+        fileId: { linked: { slate: 'files', optionList: 'files' } }
+      })
+    ).toThrow('must be written as <scope>/<name>');
+    expect(() =>
+      polling().selectionOptions({
+        fileId: { linked: { slate: 'acme/files', optionList: ' ' } }
+      })
+    ).toThrow('Selection field "fileId" must name the option list it links to');
+  });
+});

package/src/action/triggerGroup.ts

@@ -3,6 +3,7 @@ import type { SlateContext } from '../context';
 import { SlateDeclarationError } from '../error';
 import type { SlateSpecification } from '../specification/specification';
 import type { SlateWebhookHttpResponseInit } from './action';
+import type { SlateOptionListPage } from './optionList';
 
 export let SlateDefaultPollingIntervalSeconds = 60 * 10;
 
@@ -26,6 +27,80 @@ export type SlateTriggerGroupRoutingMatchersHandler<
   AuthType extends {}
 > = (context: SlateContext<ConfigType, AuthType, {}>) => Promise<SlateTriggerRoutingMatcher[]>;
 
+/** Lists the values an account can pick for one selection field. `selection` holds what is entered so far and may be incomplete. */
+export type SlateTriggerGroupSelectionOptionsHandler<
+  ConfigType extends {},
+  AuthType extends {}
+> = (
+  context: SlateContext<
+    ConfigType,
+    AuthType,
+    { query: string | null; pageToken: any | null; selection: SlateTriggerGroupSelection }
+  >
+) => Promise<SlateOptionListPage>;
+
+/** An option list exported by another integration, run with that integration's connection for the same account. */
+export interface SlateLinkedOptionList {
+  /** Registry name of the integration, as `<scope>/<name>`. */
+  slate: string;
+  optionList: string;
+  params?: Record<string, any>;
+}
+
+export interface SlateTriggerGroupSelectionOptionsSources<
+  ConfigType extends {},
+  AuthType extends {}
+> {
+  list?: SlateTriggerGroupSelectionOptionsHandler<ConfigType, AuthType>;
+  linked?: SlateLinkedOptionList;
+}
+
+let LINKED_SLATE_PATTERN = /^[^/\s]+\/[^/\s]+$/;
+
+let checkSelectionOptions = <ConfigType extends {}, AuthType extends {}>(
+  field: string,
+  sources: SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>,
+  shape: Record<string, unknown>
+): SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType> => {
+  if (!Object.hasOwn(shape, field)) {
+    throw new SlateDeclarationError(
+      `Selection field "${field}" is not a top-level property of the selection schema`
+    );
+  }
+  if (typeof sources !== 'object' || sources === null) {
+    throw new SlateDeclarationError(
+      `Selection field "${field}" must be declared as { list, linked }`
+    );
+  }
+
+  let { list, linked } = sources;
+  if (!list && !linked) {
+    throw new SlateDeclarationError(
+      `Selection field "${field}" needs its own options list, a linked option list, or both`
+    );
+  }
+  if (list !== undefined && typeof list !== 'function') {
+    throw new SlateDeclarationError(`Selection field "${field}" list must be a function`);
+  }
+  if (linked) {
+    if (typeof linked.slate !== 'string' || !LINKED_SLATE_PATTERN.test(linked.slate)) {
+      throw new SlateDeclarationError(
+        `Selection field "${field}" links to slate "${linked.slate}", which must be written as <scope>/<name>`
+      );
+    }
+    if (typeof linked.optionList !== 'string' || !linked.optionList.trim()) {
+      throw new SlateDeclarationError(
+        `Selection field "${field}" must name the option list it links to`
+      );
+    }
+  }
+
+  return {
+    ...(list ? { list } : {}),
+    ...(linked ? { linked } : {})
+  };
+};
+
 export type SlateTriggerGroupPollHandler<ConfigType extends {}, AuthType extends {}> = (
   context: SlateContext<
     ConfigType,
@@ -292,6 +367,10 @@ export interface SlateTriggerGroupParameters<
   webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
   gateway?: SlateTriggerGroupGatewayParameters<ConfigType, AuthType>;
   routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
+  selectionOptions?: Record<
+    string,
+    SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>
+  >;
 }
 
 export class SlateTriggerGroup<
@@ -362,6 +441,10 @@ export class SlateTriggerGroup<
   get routingMatchers() {
     return this._params.routingMatchers;
   }
+
+  get selectionOptions() {
+    return this._params.selectionOptions ?? {};
+  }
 }
 
 export class SlateTriggerGroupBuilder<
@@ -375,6 +458,10 @@ export class SlateTriggerGroupBuilder<
   #gateway: SlateTriggerGroupGatewayParameters<ConfigType, AuthType> | null = null;
   #routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType> | null =
     null;
+  #selectionOptions: Record<
+    string,
+    SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>
+  > = {};
 
   constructor(
     private readonly spec: SlateSpecification<ConfigType, AuthType>,
@@ -497,6 +584,34 @@ export class SlateTriggerGroupBuilder<
     return this;
   }
 
+  /**
+   * Lets the dashboard offer a list for these selection fields instead of a typed-in value.
+   * Each field must be a top-level property of the selection schema, which must be a zod object.
+   * For an array property the listed options are values for its items.
+   */
+  selectionOptions(
+    declarations: Record<
+      string,
+      SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>
+    >
+  ): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType> {
+    let schema = this.params.selectionSchema;
+    if (!schema) {
+      throw new SlateDeclarationError('Selection options require a selection schema');
+    }
+    if (schema._zod?.def?.type !== 'object') {
+      throw new SlateDeclarationError(
+        'Selection options require the selection schema to be a zod object'
+      );
+    }
+
+    let shape = (schema as z.ZodObject<any>).shape;
+    for (let [field, sources] of Object.entries(declarations)) {
+      this.#selectionOptions[field] = checkSelectionOptions(field, sources, shape);
+    }
+    return this;
+  }
+
   build(): SlateTriggerGroup<ConfigType, AuthType, InputType> {
     if (!this.#source) {
       throw new SlateDeclarationError(
@@ -513,7 +628,8 @@ export class SlateTriggerGroupBuilder<
       polling: this.#polling ?? undefined,
       webhook: this.#webhook ?? undefined,
       gateway: this.#gateway ?? undefined,
-      routingMatchers: this.#routingMatchers
+      routingMatchers: this.#routingMatchers,
+      selectionOptions: this.#selectionOptions
     });
   }
 }

package/src/specification/slate.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import { z } from 'zod';
-import { SlateTool, SlateTrigger, SlateTriggerGroup, toolCategory } from '../action';
+import {
+  optionList,
+  SlateTool,
+  SlateTrigger,
+  SlateTriggerGroup,
+  toolCategory
+} from '../action';
 import { SlateAuth } from '../auth';
 import { SlateConfig } from '../config';
 import { Slate } from './slate';
@@ -320,3 +326,66 @@ describe('Slate.create tool categories', () => {
     ).toThrow('Tool category "crm" lists tool "stray", which is not registered in this slate');
   });
 });
+
+describe('Slate.create option lists', () => {
+  it('keeps option lists in declared order with their params schema', () => {
+    let spec = createTestSpec();
+    let files = optionList(spec, {
+      key: 'files',
+      paramsSchema: z.object({ kind: z.string().optional() }),
+      list: async ctx => ({
+        options: [{ value: ctx.input.params.kind ?? 'any', label: 'Any' }]
+      })
+    });
+    let folders = optionList(spec, {
+      key: 'folders',
+      list: async () => ({ options: [] })
+    });
+
+    let slate = Slate.create({ spec, tools: [], triggers: [], optionLists: [files, folders] });
+
+    expect(slate.optionLists.map(list => list.key)).toEqual(['files', 'folders']);
+    expect(folders.paramsSchema.parse({})).toEqual({});
+    expect(files.paramsSchema.parse({ kind: 'sheet' })).toEqual({ kind: 'sheet' });
+    expect(Slate.create({ spec, tools: [], triggers: [] }).optionLists).toEqual([]);
+  });
+
+  it('rejects params with unknown keys for the default and custom params schemas', () => {
+    let spec = createTestSpec();
+    let list = async () => ({ options: [] });
+    let folders = optionList(spec, { key: 'folders', list });
+    let files = optionList(spec, {
+      key: 'files',
+      paramsSchema: z.object({ kind: z.string().optional() }),
+      list
+    });
+    let loose = optionList(spec, {
+      key: 'loose',
+      paramsSchema: z.object({ kind: z.string() }).passthrough(),
+      list
+    });
+
+    expect(folders.paramsSchema.safeParse({ kind: 'sheet' }).success).toBe(false);
+    expect(files.paramsSchema.safeParse({ knd: 'sheet' }).success).toBe(false);
+    expect(loose.paramsSchema.safeParse({ kind: 'sheet', extra: 1 }).success).toBe(false);
+  });
+
+  it('rejects a params schema that is not a zod object', () => {
+    expect(() =>
+      optionList(createTestSpec(), {
+        key: 'files',
+        paramsSchema: z.record(z.string(), z.string()) as any,
+        list: async () => ({ options: [] })
+      })
+    ).toThrow('Option list "files" params schema must be a zod object');
+  });
+
+  it('rejects duplicate option list keys', () => {
+    let spec = createTestSpec();
+    let list = () => optionList(spec, { key: 'files', list: async () => ({ options: [] }) });
+
+    expect(() =>
+      Slate.create({ spec, tools: [], triggers: [], optionLists: [list(), list()] })
+    ).toThrow('Option list "files" is registered more than once');
+  });
+});

package/src/specification/slate.ts

@@ -1,4 +1,10 @@
-import type { SlateTool, SlateToolCategory, SlateTrigger, SlateTriggerGroup } from '../action';
+import type {
+  SlateOptionList,
+  SlateTool,
+  SlateToolCategory,
+  SlateTrigger,
+  SlateTriggerGroup
+} from '../action';
 import type { SlateAdapter } from '../adapter';
 import { SlateDeclarationError } from '../error';
 import type { SlateSpecification } from './specification';
@@ -13,7 +19,8 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     private readonly _adapters: SlateAdapter<ConfigType, AuthType>[],
     private readonly _triggerGroups: SlateTriggerGroup<ConfigType, AuthType>[],
     private readonly _toolCategories: SlateToolCategory[],
-    private readonly _toolCategoryKeysByActionKey: Map<string, string[]>
+    private readonly _toolCategoryKeysByActionKey: Map<string, string[]>,
+    private readonly _optionLists: SlateOptionList<ConfigType, AuthType, any>[]
   ) {}
 
   static create<ConfigType extends {}, AuthType extends {}>(params: {
@@ -23,6 +30,7 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     adapters?: SlateAdapter<ConfigType, AuthType>[];
     triggerGroups?: SlateTriggerGroup<ConfigType, AuthType>[];
     toolCategories?: SlateToolCategory[];
+    optionLists?: SlateOptionList<ConfigType, AuthType, any>[];
   }) {
     let adapters = params.adapters ?? [];
     let actions = [...params.triggers, ...params.tools];
@@ -76,6 +84,17 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
       );
     }
 
+    let optionLists = params.optionLists ?? [];
+    let seenOptionListKeys = new Set<string>();
+    for (let list of optionLists) {
+      if (seenOptionListKeys.has(list.key)) {
+        throw new SlateDeclarationError(
+          `Option list "${list.key}" is registered more than once`
+        );
+      }
+      seenOptionListKeys.add(list.key);
+    }
+
     let toolCategories = params.toolCategories ?? [];
     let toolCategoryKeysByActionKey = resolveToolCategoryMembership(toolCategories, actions);
 
@@ -85,7 +104,8 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
       adapters,
       triggerGroups,
       toolCategories,
-      toolCategoryKeysByActionKey
+      toolCategoryKeysByActionKey,
+      optionLists
     );
   }
 
@@ -109,6 +129,10 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     return this._toolCategories ?? [];
   }
 
+  get optionLists() {
+    return this._optionLists ?? [];
+  }
+
   // Keys of the tool categories an action belongs to, in declared category order.
   getToolCategoryKeys(actionKey: string) {
     return [...(this._toolCategoryKeysByActionKey?.get(actionKey) ?? [])];