@slates/test 1.0.0-rc.2 → 1.0.0-rc.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/test",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.21",
   "publishConfig": {
     "access": "public"
   },
@@ -15,10 +15,18 @@
   "type": "module",
   "source": "src/index.ts",
   "exports": {
-    "types": "./dist/index.d.ts",
-    "require": "./dist/index.cjs",
-    "import": "./dist/index.module.js",
-    "default": "./dist/index.module.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.module.js",
+      "default": "./dist/index.module.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "require": "./dist/config.cjs",
+      "import": "./dist/config.module.js",
+      "default": "./dist/config.module.js"
+    }
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.module.js",
@@ -26,20 +34,20 @@
   "unpkg": "./dist/index.module.js",
   "scripts": {
     "test": "vitest run --passWithNoTests",
-    "lint": "prettier src/**/*.ts --check",
-    "build": "tsup --config ../../tsup.packages.config.ts --external async_hooks",
-    "typecheck": "tsc --noEmit"
+    "build": "tsup --config tsup.config.ts",
+    "typecheck": "tsc --noEmit",
+    "biome:check": "biome check --write src"
   },
   "dependencies": {
     "@lowerdeck/testing-tools": "latest",
-    "@slates/client": "1.0.0-rc.2",
-    "@slates/profiles": "1.0.0-rc.2"
+    "@slates/client": "1.0.0-rc.24",
+    "@slates/profiles": "1.0.0-rc.22"
   },
   "devDependencies": {
-    "@slates/provider": "1.0.0-rc.8",
+    "@slates/provider": "1.0.0-rc.24",
     "@slates/tsconfig": "1.0.0-rc.1",
     "typescript": "5.8.2",
     "vitest": "^3.1.2",
     "zod": "^4.2"
   }
-}
+}

package/src/config.ts

@@ -0,0 +1,5 @@
+import { createVitestConfig } from '@lowerdeck/testing-tools';
+
+export let createSlatesVitestConfig = (
+  config: Parameters<typeof createVitestConfig>[0] = {}
+) => createVitestConfig(config);

package/src/index.test.ts

@@ -1,12 +1,14 @@
+import { openSlatesCliStore } from '@slates/profiles';
 import {
+  createTextAttachment,
   Slate,
   SlateAuth,
   SlateConfig,
   SlateSpecification,
   SlateTool,
-  SlateTrigger
+  SlateTrigger,
+  SlateTriggerGroup
 } from '@slates/provider';
-import { openSlatesCliStore } from '@slates/profiles';
 import { mkdtemp, rm, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import path from 'path';
@@ -17,11 +19,12 @@ import {
   expectSlateContract,
   expectSlateError,
   expectToolCall,
-  handleSlateTriggerWebhook,
   loadSlatesRuntimeContext,
   mapSlateTriggerEvent,
-  registerSlateTriggerWebhook,
-  unregisterSlateTriggerWebhook
+  pollSlateTriggerGroupEvents,
+  processSlateTriggerGroupWebhook,
+  registerSlateTriggerGroupWebhook,
+  unregisterSlateTriggerGroupWebhook
 } from './index';
 
 (globalThis as typeof globalThis & { expect?: typeof expect }).expect = expect;
@@ -38,6 +41,7 @@ afterEach(async () => {
   delete process.env.SLATES_INTEGRATION;
   delete process.env.SLATES_PROFILE_ID;
   delete process.env.SLATES_STORE_PATH;
+  delete process.env.SLATES_STORE_ROOT_DIR;
   delete process.env.SLATES_TEST_CONTEXT_PATH;
   await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
 });
@@ -121,65 +125,184 @@ let createDemoSlate = () => {
     })
     .build();
 
-  let webhookEcho = SlateTrigger.create(spec, {
-    key: 'webhook_echo',
-    name: 'Webhook Echo'
+  let attachmentEcho = SlateTool.create(spec, {
+    key: 'attachment_echo',
+    name: 'Attachment Echo',
+    tags: {
+      readOnly: true
+    }
   })
     .input(
       z.object({
-        value: z.string()
+        mimeType: z.string().optional()
       })
     )
     .output(
       z.object({
-        echoed: z.string()
+        size: z.number()
+      })
+    )
+    .handleInvocation(async ctx => ({
+      output: {
+        size: 5
+      },
+      message: 'attached',
+      attachments: [createTextAttachment('hello', ctx.input.mimeType)]
+    }))
+    .build();
+
+  let downloadLink = SlateTool.create(spec, {
+    key: 'download_link',
+    name: 'Download Link',
+    tags: {
+      readOnly: true
+    }
+  })
+    .input(z.object({}))
+    .output(
+      z.object({
+        downloadUrl: z.string()
       })
     )
+    .handleInvocation(async () => ({
+      output: {
+        downloadUrl: 'https://example.com/files/demo.txt'
+      },
+      message: 'linked'
+    }))
+    .build();
+
+  let webhookGroup = SlateTriggerGroup.create(spec, {
+    key: 'webhook_group',
+    name: 'Webhook Group'
+  })
     .webhook({
-      autoRegisterWebhook: async ctx => ({
-        registrationDetails: {
-          webhookBaseUrl: ctx.input.webhookBaseUrl,
-          channelId: 'channel-1'
-        },
-        state: {
-          registered: true
-        }
-      }),
-      autoUnregisterWebhook: async ctx => {
-        if (ctx.input.registrationDetails?.channelId !== 'channel-1') {
-          throw new Error('Unexpected channel');
+      autoRegistration: {
+        webhookTargetList: async () => ({
+          targets: [
+            {
+              webhookTargetIdentifier: 'default',
+              name: 'Default',
+              metadata: {},
+              webhookTargetPayload: {},
+              targetOwnership: 'single_user'
+            }
+          ],
+          nextPageToken: null
+        }),
+        webhookRegister: async ctx => ({
+          webhookRegistrationIdentifier: 'reg-1',
+          webhookRegistrationPayload: {
+            webhookBaseUrl: ctx.input.webhookUrl,
+            channelId: 'channel-1'
+          }
+        }),
+        webhookUnregister: async ctx => {
+          if (ctx.input.webhookRegistrationPayload?.channelId !== 'channel-1') {
+            throw new Error('Unexpected channel');
+          }
         }
       },
-      handleRequest: async ctx => {
-        if (ctx.request.headers.get('x-demo-event') === 'ignore') {
-          return { inputs: [] };
+      process: async ctx => {
+        if (ctx.input.request.headers.get('x-demo-event') === 'ignore') {
+          return { events: [] };
         }
 
         return {
-          inputs: [
+          events: [
             {
-              value: (await ctx.request.text()) || 'empty'
+              matchers: [],
+              payload: {
+                value: (await ctx.input.request.text()) || 'empty'
+              }
             }
           ],
-          updatedState: {
-            lastEvent: ctx.request.headers.get('x-demo-event') ?? 'unknown'
-          }
+          response: new Response(
+            ctx.input.webhookRegistrationPayload?.channelId ?? 'missing',
+            {
+              status: 201,
+              headers: {
+                'content-type': 'text/plain',
+                'x-demo-response': 'accepted'
+              }
+            }
+          )
         };
-      },
-      handleEvent: async ctx => ({
-        type: 'demo.webhook',
-        id: `webhook-${ctx.input.value}`,
-        output: {
-          echoed: ctx.input.value
+      }
+    })
+    .routingMatchers(async () => [])
+    .build();
+
+  let webhookEcho = SlateTrigger.create(spec, {
+    key: 'webhook_echo',
+    name: 'Webhook Echo'
+  })
+    .input(
+      z.object({
+        value: z.string()
+      })
+    )
+    .output(
+      z.object({
+        echoed: z.string()
+      })
+    )
+    .triggerGroup(webhookGroup)
+    .matches(() => true)
+    .map(async ctx => ({
+      type: 'demo.webhook',
+      id: `webhook-${ctx.input.value}`,
+      output: {
+        echoed: ctx.input.value
+      }
+    }))
+    .build();
+
+  let pollGroup = SlateTriggerGroup.create(spec, {
+    key: 'poll_group',
+    name: 'Poll Group'
+  })
+    .polling({
+      pollEvents: async ctx => ({
+        events: ctx.input.state?.seen ? [] : [{ payload: { value: 'poll-value' } }],
+        updatedState: {
+          seen: true
         }
       })
     })
+    .routingMatchers(async () => [])
+    .build();
+
+  let pollEcho = SlateTrigger.create(spec, {
+    key: 'poll_echo',
+    name: 'Poll Echo'
+  })
+    .input(
+      z.object({
+        value: z.string()
+      })
+    )
+    .output(
+      z.object({
+        echoed: z.string()
+      })
+    )
+    .triggerGroup(pollGroup)
+    .matches(() => true)
+    .map(async ctx => ({
+      type: 'demo.poll',
+      id: `poll-${ctx.input.value}`,
+      output: {
+        echoed: ctx.input.value
+      }
+    }))
     .build();
 
   return Slate.create({
     spec,
-    tools: [echo, fail],
-    triggers: [webhookEcho]
+    tools: [echo, fail, attachmentEcho, downloadLink],
+    triggers: [webhookEcho, pollEcho],
+    triggerGroups: [webhookGroup, pollGroup]
   });
 };
 
@@ -224,6 +347,66 @@ describe('@slates/test', () => {
     expect(context.storePath).toBe(store.storePath);
   });
 
+  it('loads only the selected auth method from the runtime context', async () => {
+    let cwd = await createTempDir();
+    let store = await openSlatesCliStore({
+      cwd,
+      scope: {
+        key: 'integrations/demo',
+        name: 'demo'
+      }
+    });
+    let profile = store.upsertProfile({
+      name: 'Demo',
+      target: {
+        type: 'local',
+        entry: './demo-slate.mjs',
+        exportName: 'provider'
+      }
+    });
+    store.upsertAuth(profile.id, {
+      authMethodId: 'oauth',
+      authMethodName: 'Bot OAuth',
+      authType: 'auth.oauth',
+      input: {},
+      output: {
+        token: 'bot-token'
+      },
+      scopes: ['chat:write']
+    });
+    store.upsertAuth(profile.id, {
+      authMethodId: 'user_oauth',
+      authMethodName: 'User OAuth',
+      authType: 'auth.oauth',
+      input: {},
+      output: {
+        token: 'user-token'
+      },
+      scopes: ['search:read']
+    });
+    await store.save();
+
+    let runtimeContextPath = path.join(cwd, 'runtime.json');
+    await writeFile(
+      runtimeContextPath,
+      JSON.stringify({
+        integration: 'integrations/demo',
+        profileId: profile.id,
+        authMethodId: 'user_oauth',
+        storePath: store.storePath,
+        cliDir: store.dirPath
+      }),
+      'utf-8'
+    );
+
+    process.env.SLATES_TEST_CONTEXT_PATH = runtimeContextPath;
+
+    let context = await loadSlatesRuntimeContext({ cwd });
+    expect(context.authMethodId).toBe('user_oauth');
+    expect(Object.keys(context.profile?.auth ?? {})).toEqual(['user_oauth']);
+    expect(context.profile?.auth.user_oauth?.output.token).toBe('user-token');
+  });
+
   it('creates local slate clients and asserts provider contracts', async () => {
     let client = createLocalSlateTestClient({
       slate: createDemoSlate(),
@@ -247,14 +430,21 @@ describe('@slates/test', () => {
         name: 'Demo Slate',
         description: 'A tiny test slate'
       },
-      toolIds: ['echo', 'fail'],
-      triggerIds: ['webhook_echo'],
+      toolIds: ['echo', 'fail', 'attachment_echo', 'download_link'],
+      triggerIds: ['webhook_echo', 'poll_echo'],
+      triggerGroupIds: ['webhook_group', 'poll_group'],
       authMethodIds: ['token_auth'],
       tools: [
         { id: 'echo', readOnly: false, destructive: false },
-        { id: 'fail', readOnly: false, destructive: false }
+        { id: 'fail', readOnly: false, destructive: false },
+        { id: 'attachment_echo', readOnly: true, destructive: false },
+        { id: 'download_link', readOnly: true, destructive: false }
       ],
-      triggers: [{ id: 'webhook_echo', invocationType: 'webhook' }]
+      triggers: [{ id: 'webhook_echo' }, { id: 'poll_echo' }],
+      triggerGroups: [
+        { id: 'webhook_group', invocationType: 'webhook' },
+        { id: 'poll_group', invocationType: 'polling' }
+      ]
     });
 
     expect(contract.configSchema.properties.prefix.type).toBe('string');
@@ -270,6 +460,30 @@ describe('@slates/test', () => {
         token: 'secret-token'
       }
     });
+
+    let attachmentResult = await client.invokeTool('attachment_echo', {
+      mimeType: 'text/plain'
+    });
+    expect(attachmentResult.attachments).toEqual([
+      {
+        mimeType: 'text/plain',
+        content: {
+          type: 'content',
+          encoding: 'utf-8',
+          content: 'hello'
+        }
+      }
+    ]);
+
+    let downloadResult = await client.invokeTool('download_link', {});
+    expect(downloadResult.attachments).toEqual([
+      {
+        content: {
+          type: 'url',
+          url: 'https://example.com/files/demo.txt'
+        }
+      }
+    ]);
   });
 
   it('wraps trigger webhook flows and error assertions', async () => {
@@ -288,44 +502,54 @@ describe('@slates/test', () => {
       }
     });
 
-    let registration = await registerSlateTriggerWebhook({
+    let registration = await registerSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
-      webhookBaseUrl: 'https://example.com/hooks/google-calendar'
+      triggerGroupId: 'webhook_group',
+      webhookTargetIdentifier: 'default',
+      webhookTargetPayload: {},
+      webhookUrl: 'https://example.com/hooks/google-calendar'
     });
     expect(registration).toMatchObject({
-      registrationDetails: {
+      webhookRegistrationIdentifier: 'reg-1',
+      webhookRegistrationPayload: {
         webhookBaseUrl: 'https://example.com/hooks/google-calendar',
         channelId: 'channel-1'
-      },
-      state: {
-        registered: true
       }
     });
 
-    let ignored = await handleSlateTriggerWebhook({
+    let ignored = await processSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
+      triggerGroupId: 'webhook_group',
       url: 'https://example.com/hooks/google-calendar',
       headers: {
         'x-demo-event': 'ignore'
-      }
+      },
+      webhookRegistrationPayload: registration.webhookRegistrationPayload
     });
-    expect(ignored.inputs).toEqual([]);
+    expect(ignored.events).toEqual([]);
 
-    let handled = await handleSlateTriggerWebhook({
+    let handled = await processSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
+      triggerGroupId: 'webhook_group',
       url: 'https://example.com/hooks/google-calendar',
       headers: {
         'x-demo-event': 'created'
       },
-      body: 'payload-value'
+      body: 'payload-value',
+      webhookRegistrationPayload: registration.webhookRegistrationPayload
     });
     expect(handled).toMatchObject({
-      inputs: [{ value: 'payload-value' }],
-      updatedState: {
-        lastEvent: 'created'
+      events: [{ matchers: [], payload: { value: 'payload-value' } }],
+      response: {
+        status: 201,
+        headers: {
+          'content-type': 'text/plain',
+          'x-demo-response': 'accepted'
+        },
+        body: {
+          encoding: 'base64',
+          content: Buffer.from('channel-1').toString('base64')
+        }
       }
     });
 
@@ -342,11 +566,11 @@ describe('@slates/test', () => {
     });
     expect(mapped.id).toBe('webhook-payload-value');
 
-    await unregisterSlateTriggerWebhook({
+    await unregisterSlateTriggerGroupWebhook({
       client,
-      triggerId: 'webhook_echo',
-      webhookBaseUrl: 'https://example.com/hooks/google-calendar',
-      registrationDetails: registration.registrationDetails
+      triggerGroupId: 'webhook_group',
+      webhookRegistrationIdentifier: registration.webhookRegistrationIdentifier,
+      webhookRegistrationPayload: registration.webhookRegistrationPayload
     });
 
     await expectSlateError(
@@ -357,4 +581,53 @@ describe('@slates/test', () => {
       { code: 'internal.unexpected', kind: 'internal', status: 500 }
     );
   });
+
+  it('wraps trigger polling flows', async () => {
+    let client = createLocalSlateTestClient({
+      slate: createDemoSlate(),
+      state: {
+        config: {
+          prefix: 'Hi'
+        },
+        auth: {
+          authenticationMethodId: 'token_auth',
+          output: {
+            token: 'secret-token'
+          }
+        }
+      }
+    });
+
+    let initialPoll = await pollSlateTriggerGroupEvents({
+      client,
+      triggerGroupId: 'poll_group'
+    });
+    expect(initialPoll).toMatchObject({
+      events: [{ payload: { value: 'poll-value' } }],
+      updatedState: {
+        seen: true
+      }
+    });
+
+    let mapped = await mapSlateTriggerEvent({
+      client,
+      triggerId: 'poll_echo',
+      input: initialPoll.events[0]!.payload,
+      type: 'demo.poll',
+      output: {
+        echoed: 'poll-value'
+      }
+    });
+    expect(mapped.id).toBe('poll-poll-value');
+
+    let repeatedPoll = await pollSlateTriggerGroupEvents({
+      client,
+      triggerGroupId: 'poll_group',
+      state: initialPoll.updatedState
+    });
+    expect(repeatedPoll.events).toEqual([]);
+    expect(repeatedPoll.updatedState).toEqual({
+      seen: true
+    });
+  });
 });