@slates/test 1.0.0-rc.28 → 1.0.0-rc.29

package/dist/index.cjs

@@ -33,6 +33,8 @@ __export(index_exports, {
   getMcpCompatibleToolSchemaCases: () => getMcpCompatibleToolSchemaCases,
   getSlateContract: () => getSlateContract,
   getVitestExpect: () => getVitestExpect,
+  listSlateOptionListOptions: () => listSlateOptionListOptions,
+  listSlateTriggerGroupSelectionOptions: () => listSlateTriggerGroupSelectionOptions,
   loadSlatesProfile: () => loadSlatesProfile,
   loadSlatesRuntimeContext: () => loadSlatesRuntimeContext,
   mapSlateTriggerEvent: () => mapSlateTriggerEvent,
@@ -278,6 +280,16 @@ var pollSlateTriggerGroupEvents = async (d) => {
     selection: d.selection
   });
 };
+var listSlateTriggerGroupSelectionOptions = async (d) => {
+  let { client, ...input } = d;
+  client.ensureSession();
+  return client.listTriggerGroupSelectionOptions(input);
+};
+var listSlateOptionListOptions = async (d) => {
+  let { client, ...input } = d;
+  client.ensureSession();
+  return client.listOptionListOptions(input);
+};
 var connectSlateTriggerGroupGateway = async (d) => {
   d.client.ensureSession();
   return d.client.connectTriggerGroupGateway({
@@ -14916,6 +14928,8 @@ var describeMcpCompatibleToolSchemas = (name, source) => {
   getMcpCompatibleToolSchemaCases,
   getSlateContract,
   getVitestExpect,
+  listSlateOptionListOptions,
+  listSlateTriggerGroupSelectionOptions,
   loadSlatesProfile,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,

package/dist/index.d.cts

@@ -662,6 +662,91 @@ declare let pollSlateTriggerGroupEvents: (d: {
         } | undefined;
     }[] | undefined;
 }>;
+declare let listSlateTriggerGroupSelectionOptions: (d: {
+    client: SlatesTestClient;
+    triggerGroupId: string;
+    field: string;
+    query?: string | null;
+    pageToken?: any;
+    selection?: Record<string, any>;
+}) => Promise<{
+    options: {
+        value: string | number;
+        label: string;
+        description?: string | undefined;
+    }[];
+    nextPageToken: any;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+declare let listSlateOptionListOptions: (d: {
+    client: SlatesTestClient;
+    optionListId: string;
+    query?: string | null;
+    pageToken?: any;
+    params?: Record<string, any>;
+}) => Promise<{
+    options: {
+        value: string | number;
+        label: string;
+        description?: string | undefined;
+    }[];
+    nextPageToken: any;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
 declare let connectSlateTriggerGroupGateway: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
@@ -897,6 +982,7 @@ declare let mapSlateTriggerEvent: (d: {
     type: string;
     id: string;
     output: Record<string, any>;
+    attributes?: Record<string, string[]> | undefined;
     requestTraces?: {
         startedAt: string;
         durationMs: number;
@@ -939,4 +1025,4 @@ declare let getMcpCompatibleToolSchemaCases: (source: ToolSchemaSource) => Reado
 declare let expectMcpCompatibleToolSchema: (tool: ToolSchemaTarget) => void;
 declare let describeMcpCompatibleToolSchemas: (name: string, source: ToolSchemaSource) => void;
 
-export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, authenticateSlateTriggerGroupWebhookDelivery, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expandSlateTriggerGroupWebhook, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, renewSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };
+export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, authenticateSlateTriggerGroupWebhookDelivery, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expandSlateTriggerGroupWebhook, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, listSlateOptionListOptions, listSlateTriggerGroupSelectionOptions, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, renewSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };

package/dist/index.d.ts

@@ -662,6 +662,91 @@ declare let pollSlateTriggerGroupEvents: (d: {
         } | undefined;
     }[] | undefined;
 }>;
+declare let listSlateTriggerGroupSelectionOptions: (d: {
+    client: SlatesTestClient;
+    triggerGroupId: string;
+    field: string;
+    query?: string | null;
+    pageToken?: any;
+    selection?: Record<string, any>;
+}) => Promise<{
+    options: {
+        value: string | number;
+        label: string;
+        description?: string | undefined;
+    }[];
+    nextPageToken: any;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+declare let listSlateOptionListOptions: (d: {
+    client: SlatesTestClient;
+    optionListId: string;
+    query?: string | null;
+    pageToken?: any;
+    params?: Record<string, any>;
+}) => Promise<{
+    options: {
+        value: string | number;
+        label: string;
+        description?: string | undefined;
+    }[];
+    nextPageToken: any;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
 declare let connectSlateTriggerGroupGateway: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
@@ -897,6 +982,7 @@ declare let mapSlateTriggerEvent: (d: {
     type: string;
     id: string;
     output: Record<string, any>;
+    attributes?: Record<string, string[]> | undefined;
     requestTraces?: {
         startedAt: string;
         durationMs: number;
@@ -939,4 +1025,4 @@ declare let getMcpCompatibleToolSchemaCases: (source: ToolSchemaSource) => Reado
 declare let expectMcpCompatibleToolSchema: (tool: ToolSchemaTarget) => void;
 declare let describeMcpCompatibleToolSchemas: (name: string, source: ToolSchemaSource) => void;
 
-export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, authenticateSlateTriggerGroupWebhookDelivery, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expandSlateTriggerGroupWebhook, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, renewSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };
+export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, authenticateSlateTriggerGroupWebhookDelivery, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expandSlateTriggerGroupWebhook, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, listSlateOptionListOptions, listSlateTriggerGroupSelectionOptions, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, renewSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };

package/dist/index.module.js

@@ -243,6 +243,16 @@ var pollSlateTriggerGroupEvents = async (d) => {
     selection: d.selection
   });
 };
+var listSlateTriggerGroupSelectionOptions = async (d) => {
+  let { client, ...input } = d;
+  client.ensureSession();
+  return client.listTriggerGroupSelectionOptions(input);
+};
+var listSlateOptionListOptions = async (d) => {
+  let { client, ...input } = d;
+  client.ensureSession();
+  return client.listOptionListOptions(input);
+};
 var connectSlateTriggerGroupGateway = async (d) => {
   d.client.ensureSession();
   return d.client.connectTriggerGroupGateway({
@@ -14880,6 +14890,8 @@ export {
   getMcpCompatibleToolSchemaCases,
   getSlateContract,
   getVitestExpect,
+  listSlateOptionListOptions,
+  listSlateTriggerGroupSelectionOptions,
   loadSlatesProfile,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/test",
-  "version": "1.0.0-rc.28",
+  "version": "1.0.0-rc.29",
   "publishConfig": {
     "access": "public"
   },
@@ -40,11 +40,11 @@
   },
   "dependencies": {
     "@lowerdeck/testing-tools": "latest",
-    "@slates/client": "1.0.0-rc.33",
-    "@slates/profiles": "1.0.0-rc.29"
+    "@slates/client": "1.0.0-rc.34",
+    "@slates/profiles": "1.0.0-rc.30"
   },
   "devDependencies": {
-    "@slates/provider": "1.0.0-rc.34",
+    "@slates/provider": "1.0.0-rc.35",
     "@slates/tsconfig": "1.0.0-rc.1",
     "typescript": "5.8.2",
     "vitest": "^3.1.2",

package/src/optionList.test.ts

@@ -0,0 +1,194 @@
+import {
+  optionList,
+  Slate,
+  SlateAuth,
+  SlateConfig,
+  SlateSpecification,
+  triggerGroup
+} from '@slates/provider';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import {
+  createLocalSlateTestClient,
+  listSlateOptionListOptions,
+  listSlateTriggerGroupSelectionOptions
+} from './index';
+
+let fixture = () => {
+  let calls: { auth: unknown; config: unknown; input: any }[] = [];
+  let auth = SlateAuth.create<{ token: string }>()
+    .output(z.object({ token: z.string() }))
+    .addTokenAuth({
+      type: 'auth.token',
+      key: 'token',
+      name: 'Token',
+      inputSchema: z.object({ token: z.string() }),
+      getOutput: async ctx => ({ output: ctx.input })
+    });
+  let spec = SlateSpecification.create({
+    key: 'files',
+    name: 'Files',
+    description: 'Option list contract',
+    auth,
+    config: SlateConfig.create(z.object({ tenant: z.string() }))
+  });
+  let files = optionList(spec, {
+    key: 'files',
+    paramsSchema: z.object({
+      kind: z.enum(['sheet', 'doc']),
+      limit: z.number().int().default(10)
+    }),
+    list: async ctx => {
+      calls.push({ auth: ctx.auth, config: ctx.config, input: ctx.input });
+      return {
+        options: [
+          {
+            value: `${ctx.input.params.kind}-1`,
+            label: `${ctx.auth.token} ${ctx.config.tenant}`
+          }
+        ],
+        nextPageToken: ctx.input.pageToken ? undefined : { offset: 1 }
+      };
+    }
+  });
+  let folders = optionList(spec, {
+    key: 'folders',
+    list: async ctx => {
+      calls.push({ auth: ctx.auth, config: ctx.config, input: ctx.input });
+      return { options: [] };
+    }
+  });
+  let watch = triggerGroup(spec, {
+    key: 'watch',
+    name: 'Watch',
+    selectionSchema: z.object({ fileId: z.string(), folderId: z.string() })
+  })
+    .polling({ pollEvents: async () => ({ events: [] }) })
+    .routingMatchers(async () => [])
+    .selectionOptions({
+      fileId: {
+        list: async () => ({ options: [{ value: 'own', label: 'Own' }] }),
+        linked: { slate: 'acme/drive', optionList: 'files', params: { kind: 'sheet' } }
+      },
+      folderId: { linked: { slate: 'acme/drive', optionList: 'folders' } }
+    })
+    .build();
+  let slate = Slate.create({
+    spec,
+    tools: [],
+    triggers: [],
+    triggerGroups: [watch],
+    optionLists: [files, folders]
+  });
+  let client = createLocalSlateTestClient({
+    slate,
+    state: {
+      config: { tenant: 'tenant' },
+      auth: { authenticationMethodId: 'token', output: { token: 'credential' } }
+    }
+  });
+
+  return { client, calls };
+};
+
+describe('option list protocol helpers', () => {
+  it('lists an exported option list with parsed params, auth and config', async () => {
+    let { client, calls } = fixture();
+
+    let first = await listSlateOptionListOptions({
+      client,
+      optionListId: 'files',
+      query: '  budget ',
+      params: { kind: 'sheet' }
+    });
+    expect(first).toEqual({
+      options: [{ value: 'sheet-1', label: 'credential tenant' }],
+      nextPageToken: { offset: 1 }
+    });
+    expect(calls.at(-1)).toEqual({
+      auth: { token: 'credential' },
+      config: { tenant: 'tenant' },
+      input: { query: 'budget', pageToken: null, params: { kind: 'sheet', limit: 10 } }
+    });
+
+    let last = await listSlateOptionListOptions({
+      client,
+      optionListId: 'files',
+      query: '   ',
+      pageToken: { offset: 1 },
+      params: { kind: 'doc', limit: 5 }
+    });
+    expect(last.nextPageToken).toBeNull();
+    expect(calls.at(-1)?.input).toEqual({
+      query: null,
+      pageToken: { offset: 1 },
+      params: { kind: 'doc', limit: 5 }
+    });
+
+    await listSlateOptionListOptions({ client, optionListId: 'folders' });
+    expect(calls.at(-1)?.input).toEqual({ query: null, pageToken: null, params: {} });
+  });
+
+  it('rejects unknown option lists, invalid params and unknown param keys', async () => {
+    let { client, calls } = fixture();
+
+    await expect(
+      listSlateOptionListOptions({ client, optionListId: 'missing' })
+    ).rejects.toThrow('Invalid option list ID: missing');
+    await expect(
+      listSlateOptionListOptions({ client, optionListId: 'files', params: { kind: 'pdf' } })
+    ).rejects.toThrow('Invalid params for option list "files"');
+    await expect(
+      listSlateOptionListOptions({ client, optionListId: 'files' })
+    ).rejects.toThrow('Invalid params for option list "files"');
+    await expect(
+      listSlateOptionListOptions({
+        client,
+        optionListId: 'files',
+        params: { kind: 'sheet', mimeType: 'sheet' }
+      })
+    ).rejects.toThrow('Invalid params for option list "files"');
+    await expect(
+      listSlateOptionListOptions({
+        client,
+        optionListId: 'folders',
+        params: { kind: 'sheet' }
+      })
+    ).rejects.toThrow('Invalid params for option list "folders"');
+    expect(calls).toEqual([]);
+  });
+
+  it('advertises linked sources and only lists fields with their own list', async () => {
+    let { client } = fixture();
+    let schema = (await client.getTriggerGroup('watch')).triggerGroup.selectionSchema;
+
+    expect(schema?.properties.fileId).toMatchObject({
+      'x-slates-options': true,
+      'x-slates-options-linked': {
+        slate: 'acme/drive',
+        optionList: 'files',
+        params: { kind: 'sheet' }
+      }
+    });
+    expect(schema?.properties.folderId).not.toHaveProperty('x-slates-options');
+    expect(schema?.properties.folderId['x-slates-options-linked']).toEqual({
+      slate: 'acme/drive',
+      optionList: 'folders',
+      params: {}
+    });
+
+    let own = await listSlateTriggerGroupSelectionOptions({
+      client,
+      triggerGroupId: 'watch',
+      field: 'fileId'
+    });
+    expect(own.options).toEqual([{ value: 'own', label: 'Own' }]);
+    await expect(
+      listSlateTriggerGroupSelectionOptions({
+        client,
+        triggerGroupId: 'watch',
+        field: 'folderId'
+      })
+    ).rejects.toThrow('has no options for selection field: folderId');
+  });
+});

package/src/runtime.ts

@@ -391,6 +391,31 @@ export let pollSlateTriggerGroupEvents = async (d: {
   });
 };
 
+export let listSlateTriggerGroupSelectionOptions = async (d: {
+  client: SlatesTestClient;
+  triggerGroupId: string;
+  field: string;
+  query?: string | null;
+  pageToken?: any;
+  selection?: Record<string, any>;
+}) => {
+  let { client, ...input } = d;
+  client.ensureSession();
+  return client.listTriggerGroupSelectionOptions(input);
+};
+
+export let listSlateOptionListOptions = async (d: {
+  client: SlatesTestClient;
+  optionListId: string;
+  query?: string | null;
+  pageToken?: any;
+  params?: Record<string, any>;
+}) => {
+  let { client, ...input } = d;
+  client.ensureSession();
+  return client.listOptionListOptions(input);
+};
+
 export let connectSlateTriggerGroupGateway = async (d: {
   client: SlatesTestClient;
   triggerGroupId: string;

package/src/triggerLifecycle.test.ts

@@ -12,6 +12,7 @@ import {
   authenticateSlateTriggerGroupWebhookDelivery,
   createLocalSlateTestClient,
   expandSlateTriggerGroupWebhook,
+  listSlateTriggerGroupSelectionOptions,
   pollSlateTriggerGroupEvents,
   processSlateTriggerGroupWebhook,
   registerSlateTriggerGroupWebhook,
@@ -149,15 +150,28 @@ let fixture = (
     })
     .routingMatchers(async () => [{ tenant: 'tenant' }])
     .build();
-  let poll = triggerGroup(spec, { key: 'poll', name: 'Poll', selectionSchema })
+  let pollBuilder = triggerGroup(spec, { key: 'poll', name: 'Poll', selectionSchema })
     .polling({
       pollEvents: async ctx => {
         record('poll', ctx);
         return { events: [], updatedState: ctx.input.state };
       }
     })
-    .routingMatchers(async () => [])
-    .build();
+    .routingMatchers(async () => []);
+  if (selectionSchema) {
+    pollBuilder.selectionOptions({
+      resource: {
+        list: async ctx => {
+          record('options', ctx);
+          return {
+            options: [{ value: 'a', label: 'Resource A' }],
+            nextPageToken: ctx.input.pageToken ? null : 'next'
+          };
+        }
+      }
+    });
+  }
+  let poll = pollBuilder.build();
   let matches = 0;
   let selectedInput = z.object({
     kind: z.string().optional(),
@@ -473,6 +487,49 @@ describe('trigger lifecycle protocol helpers', () => {
     expect(defaults.contexts.at(-1)?.input.selection).toEqual({ resource: 'explicit' });
   });
 
+  it('lists options for a marked selection field from an incomplete selection', async () => {
+    let { client, contexts } = fixture({ selection: 'required' });
+    let marked = (await client.getTriggerGroup('poll')).triggerGroup.selectionSchema;
+    let unmarked = (await client.getTriggerGroup('webhook')).triggerGroup.selectionSchema;
+    expect(marked?.properties.resource['x-slates-options']).toBe(true);
+    expect(unmarked?.properties.resource).not.toHaveProperty('x-slates-options');
+
+    let first = await listSlateTriggerGroupSelectionOptions({
+      client,
+      triggerGroupId: 'poll',
+      field: 'resource',
+      query: '  res ',
+      selection: { other: 'entered' }
+    });
+    expect(first).toMatchObject({
+      options: [{ value: 'a', label: 'Resource A' }],
+      nextPageToken: 'next'
+    });
+    expect(contexts.at(-1)).toMatchObject({
+      operation: 'options',
+      input: { query: 'res', pageToken: null, selection: { other: 'entered' } }
+    });
+
+    let last = await listSlateTriggerGroupSelectionOptions({
+      client,
+      triggerGroupId: 'poll',
+      field: 'resource',
+      pageToken: 'next'
+    });
+    expect(last.nextPageToken).toBeNull();
+    expect(contexts.at(-1)?.input).toMatchObject({ query: null, selection: {} });
+
+    for (let target of [
+      { triggerGroupId: 'poll', field: 'missing' },
+      { triggerGroupId: 'poll', field: 'constructor' },
+      { triggerGroupId: 'webhook', field: 'resource' }
+    ]) {
+      await expect(
+        listSlateTriggerGroupSelectionOptions({ client, ...target })
+      ).rejects.toThrow('has no options');
+    }
+  });
+
   it('keeps groups without selection, expansion, or renewal backward compatible', async () => {
     let { client, contexts } = fixture({ legacy: true });
     await registerSlateTriggerGroupWebhook({ client, ...registrationInput });