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

package/dist/index.d.ts

@@ -246,14 +246,22 @@ declare let getSlateContract: (client: SlatesTestClient) => Promise<{
             type: "webhook";
             registration: {
                 mode: "auto";
+                deliveryConfig?: {
+                    userConfigSchema: Record<string, any>;
+                    fullConfigSchema: Record<string, any>;
+                } | undefined;
             } | {
                 mode: "manual";
                 userConfigSchema: Record<string, any>;
                 fullConfigSchema: Record<string, any>;
             };
+            supportsExpansion?: boolean | undefined;
+            supportsRenewal?: boolean | undefined;
+            reconcileIntervalSeconds?: number | undefined;
         };
         description?: string | undefined;
         metadata?: Record<string, any> | undefined;
+        selectionSchema?: Record<string, any> | undefined;
     }[];
     authMethods: {
         id: string;
@@ -445,14 +453,22 @@ declare let expectSlateContract: (d: {
             type: "webhook";
             registration: {
                 mode: "auto";
+                deliveryConfig?: {
+                    userConfigSchema: Record<string, any>;
+                    fullConfigSchema: Record<string, any>;
+                } | undefined;
             } | {
                 mode: "manual";
                 userConfigSchema: Record<string, any>;
                 fullConfigSchema: Record<string, any>;
             };
+            supportsExpansion?: boolean | undefined;
+            supportsRenewal?: boolean | undefined;
+            reconcileIntervalSeconds?: number | undefined;
         };
         description?: string | undefined;
         metadata?: Record<string, any> | undefined;
+        selectionSchema?: Record<string, any> | undefined;
     }[];
     authMethods: {
         id: string;
@@ -495,13 +511,87 @@ declare let expectSlateContract: (d: {
 }>;
 declare let registerSlateTriggerGroupWebhook: (d: {
     client: SlatesTestClient;
-    triggerGroupId: string;
-    webhookTargetIdentifier: string;
-    webhookTargetPayload: any;
-    webhookUrl: string;
-}) => Promise<{
+} & Parameters<SlatesTestClient["registerTriggerGroupWebhook"]>[0]) => Promise<{
+    webhookRegistrationIdentifier: string;
+    webhookRegistrationPayload: any;
+    expiresAt?: string | null | undefined;
+    renewAfter?: string | null | undefined;
+    routingKeys?: string[] | undefined;
+    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 renewSlateTriggerGroupWebhook: (d: {
+    client: SlatesTestClient;
+} & Parameters<SlatesTestClient["renewTriggerGroupWebhook"]>[0]) => Promise<{
     webhookRegistrationIdentifier: string;
     webhookRegistrationPayload: any;
+    expiresAt?: string | null | undefined;
+    renewAfter?: string | null | undefined;
+    routingKeys?: string[] | undefined;
+    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 expandSlateTriggerGroupWebhook: (d: {
+    client: SlatesTestClient;
+} & Parameters<SlatesTestClient["expandTriggerGroupWebhook"]>[0]) => Promise<{
+    events: {
+        payload: Record<string, any>;
+        triggerIds: string[];
+        idempotencyKey?: string | undefined;
+    }[];
+    updatedState?: any;
     requestTraces?: {
         startedAt: string;
         durationMs: number;
@@ -535,6 +625,7 @@ declare let pollSlateTriggerGroupEvents: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
     state?: any;
+    selection?: Record<string, any>;
 }) => Promise<{
     events: {
         payload: Record<string, any>;
@@ -571,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;
@@ -678,6 +854,7 @@ declare let processSlateTriggerGroupWebhook: (d: {
         triggerIds: string[];
         idempotencyKey?: string | undefined;
     }[];
+    requiresExpansion?: boolean | undefined;
     response?: {
         status: number;
         headers: Record<string, string>;
@@ -718,6 +895,48 @@ declare let processSlateTriggerGroupWebhook: (d: {
         } | undefined;
     }[] | undefined;
 }>;
+declare let authenticateSlateTriggerGroupWebhookDelivery: (d: {
+    client: SlatesTestClient;
+    triggerGroupId: string;
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | null;
+    deliveryConfig: unknown;
+}) => Promise<{
+    routingKeys: string[];
+    rejected?: {
+        status: number;
+    } | null | undefined;
+    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 unregisterSlateTriggerGroupWebhook: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
@@ -763,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;
@@ -805,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, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, 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

@@ -223,19 +223,36 @@ var expectSlateContract = async (d) => {
   }
   return contract;
 };
-var registerSlateTriggerGroupWebhook = async (d) => d.client.registerTriggerGroupWebhook({
-  triggerGroupId: d.triggerGroupId,
-  webhookTargetIdentifier: d.webhookTargetIdentifier,
-  webhookTargetPayload: d.webhookTargetPayload,
-  webhookUrl: d.webhookUrl
-});
+var registerSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.registerTriggerGroupWebhook(input);
+};
+var renewSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.renewTriggerGroupWebhook(input);
+};
+var expandSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.expandTriggerGroupWebhook(input);
+};
 var pollSlateTriggerGroupEvents = async (d) => {
   d.client.ensureSession();
   return d.client.pollTriggerGroup({
     triggerGroupId: d.triggerGroupId,
-    state: d.state ?? null
+    state: d.state ?? null,
+    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({
@@ -260,6 +277,14 @@ var processSlateTriggerGroupWebhook = async (d) => d.client.processTriggerGroupW
   body: d.body,
   webhookRegistrationPayload: d.webhookRegistrationPayload ?? null
 });
+var authenticateSlateTriggerGroupWebhookDelivery = async (d) => d.client.authenticateTriggerGroupWebhookDelivery({
+  triggerGroupId: d.triggerGroupId,
+  url: d.url,
+  method: d.method ?? "POST",
+  headers: d.headers,
+  body: d.body,
+  deliveryConfig: d.deliveryConfig
+});
 var unregisterSlateTriggerGroupWebhook = async (d) => d.client.unregisterTriggerGroupWebhook({
   triggerGroupId: d.triggerGroupId,
   webhookRegistrationIdentifier: d.webhookRegistrationIdentifier,
@@ -14852,10 +14877,12 @@ var describeMcpCompatibleToolSchemas = (name, source) => {
   });
 };
 export {
+  authenticateSlateTriggerGroupWebhookDelivery,
   connectSlateTriggerGroupGateway,
   createLocalSlateTestClient,
   createSlatesTestClient,
   describeMcpCompatibleToolSchemas,
+  expandSlateTriggerGroupWebhook,
   expectMcpCompatibleToolSchema,
   expectSlateContract,
   expectSlateError,
@@ -14863,6 +14890,8 @@ export {
   getMcpCompatibleToolSchemaCases,
   getSlateContract,
   getVitestExpect,
+  listSlateOptionListOptions,
+  listSlateTriggerGroupSelectionOptions,
   loadSlatesProfile,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,
@@ -14870,6 +14899,7 @@ export {
   processSlateTriggerGroupWebhook,
   receiveSlateTriggerGroupGatewayFrames,
   registerSlateTriggerGroupWebhook,
+  renewSlateTriggerGroupWebhook,
   unregisterSlateTriggerGroupWebhook,
   withSlateProfile
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/test",
-  "version": "1.0.0-rc.27",
+  "version": "1.0.0-rc.29",
   "publishConfig": {
     "access": "public"
   },
@@ -40,11 +40,11 @@
   },
   "dependencies": {
     "@lowerdeck/testing-tools": "latest",
-    "@slates/client": "1.0.0-rc.32",
-    "@slates/profiles": "1.0.0-rc.28"
+    "@slates/client": "1.0.0-rc.34",
+    "@slates/profiles": "1.0.0-rc.30"
   },
   "devDependencies": {
-    "@slates/provider": "1.0.0-rc.33",
+    "@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');
+  });
+});