@slates/provider-handler 1.0.0-rc.35 → 1.0.0-rc.37

package/dist/index.cjs

@@ -113,6 +113,7 @@ var mapAuthMethod = (slate, m) => ({
     description: s.description
   })) : void 0,
   adapters: "adapters" in m ? m.adapters : void 0,
+  ..."syncTokensAcrossConnections" in m && m.syncTokensAcrossConnections ? { syncTokensAcrossConnections: true } : {},
   inputSchema: toJsonSchema(m.inputSchema ?? import_zod.default.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
   capabilities: {
@@ -128,14 +129,14 @@ var mapAuthMethod = (slate, m) => ({
   docs: m.docs ?? []
 });
 var getAction = (slate, actionId) => {
-  let action = slate.actions.find((m) => m.key === actionId);
+  let action = (slate.actions ?? []).find((m) => m.key === actionId);
   if (!action) {
     throw new import_error2.ServiceError((0, import_error2.notFoundError)(`action`, actionId));
   }
   return action;
 };
 var getAdapter = (slate, adapterId) => {
-  let adapter = slate.adapters.find((m) => m.id === adapterId);
+  let adapter = (slate.adapters ?? []).find((m) => m.id === adapterId);
   if (!adapter) {
     throw new import_error2.ServiceError((0, import_error2.notFoundError)(`adapter`, adapterId));
   }
@@ -144,7 +145,7 @@ var getAdapter = (slate, adapterId) => {
 var mapAdapter = (adapter) => ({
   id: adapter.id,
   name: adapter.name,
-  capabilities: adapter.capabilities
+  capabilities: adapter.capabilities ?? []
 });
 var getActionWithType = (slate, type, actionId) => {
   let action = getAction(slate, actionId);
@@ -196,7 +197,7 @@ var getMappableAction = (slate, actionId) => {
   }
   return action;
 };
-var getExposedActions = (slate, includeAdapterActions) => slate.actions.filter(
+var getExposedActions = (slate, includeAdapterActions) => (slate.actions ?? []).filter(
   (action) => isMappableTrigger(action) && (includeAdapterActions || !action.adapter)
 );
 var getExposedAction = (slate, actionId, includeAdapterActions) => {
@@ -207,13 +208,13 @@ var getExposedAction = (slate, actionId, includeAdapterActions) => {
   return action;
 };
 var getTriggerGroup = (slate, triggerGroupId) => {
-  let group = slate.triggerGroups.find((g) => g.key === triggerGroupId);
+  let group = (slate.triggerGroups ?? []).find((g) => g.key === triggerGroupId);
   if (!group) {
     throw new import_error2.ServiceError((0, import_error2.notFoundError)(`trigger_group`, triggerGroupId));
   }
   return group;
 };
-var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
+var getTriggersForGroup = (slate, triggerGroupId) => (slate.actions ?? []).filter(
   (action) => action.type === "trigger" && action.triggerGroup?.key === triggerGroupId
 );
 var getExposedTriggerGroups = (slate, includeAdapterActions) => {
@@ -222,7 +223,7 @@ var getExposedTriggerGroups = (slate, includeAdapterActions) => {
       (action) => action.type === "trigger" && action.triggerGroup ? [action.triggerGroup.key] : []
     )
   );
-  return slate.triggerGroups.filter((group) => triggerGroupIds.has(group.key));
+  return (slate.triggerGroups ?? []).filter((group) => triggerGroupIds.has(group.key));
 };
 var evaluateTriggerMatches = (slate, triggerGroupId, payload) => getTriggersForGroup(slate, triggerGroupId).filter((trigger) => trigger.matches(payload)).map((trigger) => trigger.key);
 var getWebhookAutoRegistration = (group) => {
@@ -1014,7 +1015,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   manager.onRequest("slates/adapters.list", async () => {
     getContextBasic();
     return {
-      adapters: supportsAdapters() ? slate.adapters.map(mapAdapter) : []
+      adapters: supportsAdapters() ? (slate.adapters ?? []).map(mapAdapter) : []
     };
   });
   manager.onRequest("slates/adapter.get", async ({ params }) => {
@@ -1401,7 +1402,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         },
         onSuccess: (result) => ({
           eventCount: result.events.length,
-          hasResponse: result.response !== void 0
+          hasResponse: result.response !== void 0,
+          skipped: !!result.skipped
         })
       },
       () => (0, import_provider2.runWithContext)(context, () => group.webhook.process(context))
@@ -1423,7 +1425,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         idempotencyKey: event.idempotencyKey,
         triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
       })),
-      response
+      response,
+      skipped: res.skipped ?? null
     });
   });
   manager.onRequest("slates/trigger_group.routing_matchers.get", async ({ params }) => {

package/dist/index.module.js

@@ -96,6 +96,7 @@ var mapAuthMethod = (slate, m) => ({
     description: s.description
   })) : void 0,
   adapters: "adapters" in m ? m.adapters : void 0,
+  ..."syncTokensAcrossConnections" in m && m.syncTokensAcrossConnections ? { syncTokensAcrossConnections: true } : {},
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
   capabilities: {
@@ -111,14 +112,14 @@ var mapAuthMethod = (slate, m) => ({
   docs: m.docs ?? []
 });
 var getAction = (slate, actionId) => {
-  let action = slate.actions.find((m) => m.key === actionId);
+  let action = (slate.actions ?? []).find((m) => m.key === actionId);
   if (!action) {
     throw new ServiceError2(notFoundError(`action`, actionId));
   }
   return action;
 };
 var getAdapter = (slate, adapterId) => {
-  let adapter = slate.adapters.find((m) => m.id === adapterId);
+  let adapter = (slate.adapters ?? []).find((m) => m.id === adapterId);
   if (!adapter) {
     throw new ServiceError2(notFoundError(`adapter`, adapterId));
   }
@@ -127,7 +128,7 @@ var getAdapter = (slate, adapterId) => {
 var mapAdapter = (adapter) => ({
   id: adapter.id,
   name: adapter.name,
-  capabilities: adapter.capabilities
+  capabilities: adapter.capabilities ?? []
 });
 var getActionWithType = (slate, type, actionId) => {
   let action = getAction(slate, actionId);
@@ -179,7 +180,7 @@ var getMappableAction = (slate, actionId) => {
   }
   return action;
 };
-var getExposedActions = (slate, includeAdapterActions) => slate.actions.filter(
+var getExposedActions = (slate, includeAdapterActions) => (slate.actions ?? []).filter(
   (action) => isMappableTrigger(action) && (includeAdapterActions || !action.adapter)
 );
 var getExposedAction = (slate, actionId, includeAdapterActions) => {
@@ -190,13 +191,13 @@ var getExposedAction = (slate, actionId, includeAdapterActions) => {
   return action;
 };
 var getTriggerGroup = (slate, triggerGroupId) => {
-  let group = slate.triggerGroups.find((g) => g.key === triggerGroupId);
+  let group = (slate.triggerGroups ?? []).find((g) => g.key === triggerGroupId);
   if (!group) {
     throw new ServiceError2(notFoundError(`trigger_group`, triggerGroupId));
   }
   return group;
 };
-var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
+var getTriggersForGroup = (slate, triggerGroupId) => (slate.actions ?? []).filter(
   (action) => action.type === "trigger" && action.triggerGroup?.key === triggerGroupId
 );
 var getExposedTriggerGroups = (slate, includeAdapterActions) => {
@@ -205,7 +206,7 @@ var getExposedTriggerGroups = (slate, includeAdapterActions) => {
       (action) => action.type === "trigger" && action.triggerGroup ? [action.triggerGroup.key] : []
     )
   );
-  return slate.triggerGroups.filter((group) => triggerGroupIds.has(group.key));
+  return (slate.triggerGroups ?? []).filter((group) => triggerGroupIds.has(group.key));
 };
 var evaluateTriggerMatches = (slate, triggerGroupId, payload) => getTriggersForGroup(slate, triggerGroupId).filter((trigger) => trigger.matches(payload)).map((trigger) => trigger.key);
 var getWebhookAutoRegistration = (group) => {
@@ -997,7 +998,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/adapters.list", async () => {
     getContextBasic();
     return {
-      adapters: supportsAdapters() ? slate.adapters.map(mapAdapter) : []
+      adapters: supportsAdapters() ? (slate.adapters ?? []).map(mapAdapter) : []
     };
   });
   manager.onRequest("slates/adapter.get", async ({ params }) => {
@@ -1384,7 +1385,8 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         },
         onSuccess: (result) => ({
           eventCount: result.events.length,
-          hasResponse: result.response !== void 0
+          hasResponse: result.response !== void 0,
+          skipped: !!result.skipped
         })
       },
       () => runWithContext(context, () => group.webhook.process(context))
@@ -1406,7 +1408,8 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         idempotencyKey: event.idempotencyKey,
         triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
       })),
-      response
+      response,
+      skipped: res.skipped ?? null
     });
   });
   manager.onRequest("slates/trigger_group.routing_matchers.get", async ({ params }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.35",
+  "version": "1.0.0-rc.37",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.21",
-    "@slates/provider": "1.0.0-rc.25",
+    "@slates/proto": "1.0.0-rc.23",
+    "@slates/provider": "1.0.0-rc.27",
     "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },

package/src/exposure.test.ts

@@ -158,4 +158,59 @@ describe('adapter capability exposure', () => {
       }
     });
   });
+
+  it('returns empty adapter and trigger group lists for older slates that omit those collections', async () => {
+    let manager = await createProviderHandler(
+      {
+        spec: { key: 'legacy', name: 'Legacy' },
+        actions: [
+          {
+            key: 'provider_tool',
+            type: 'tool',
+            name: 'Action',
+            description: undefined,
+            instructions: undefined,
+            constraints: undefined,
+            tags: [],
+            metadata: {},
+            scopes: [],
+            authMethods: [],
+            docs: [],
+            inputSchema: z.object({}),
+            outputSchema: z.object({}),
+            isPublic: false
+          }
+        ]
+      } as any,
+      []
+    ).run();
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hello',
+      params: { protocol: SLATES_PROTOCOL_VERSION }
+    });
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/participant.set',
+      params: { participants: [] }
+    });
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { adapters: true, triggers: true } }
+    });
+
+    expect(await request(manager, 'slates/adapters.list')).toMatchObject({
+      result: { adapters: [] }
+    });
+    expect(await request(manager, 'slates/trigger_groups.list')).toMatchObject({
+      result: { triggerGroups: [] }
+    });
+    expect(
+      await request(manager, 'slates/actions.list', { includeAdapterActions: true })
+    ).toMatchObject({
+      result: { actions: [{ id: 'provider_tool' }] }
+    });
+  });
 });

package/src/index.ts

@@ -894,7 +894,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       getContextBasic();
 
       return {
-        adapters: supportsAdapters() ? slate.adapters.map(mapAdapter) : []
+        adapters: supportsAdapters() ? (slate.adapters ?? []).map(mapAdapter) : []
       };
     });
 
@@ -1337,7 +1337,8 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           },
           onSuccess: result => ({
             eventCount: result.events.length,
-            hasResponse: result.response !== undefined
+            hasResponse: result.response !== undefined,
+            skipped: !!result.skipped
           })
         },
         () => runWithContext(context, () => group.webhook!.process(context))
@@ -1365,7 +1366,8 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           idempotencyKey: event.idempotencyKey,
           triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
         })),
-        response
+        response,
+        skipped: res.skipped ?? null
       });
     });
 

package/src/spec.test.ts

@@ -8,7 +8,9 @@ import {
   getMappableAction,
   getTriggersForGroup,
   isMappableTrigger,
-  mapAction
+  mapAction,
+  mapAdapter,
+  mapAuthMethod
 } from './spec';
 
 let baseAction = {
@@ -131,4 +133,38 @@ describe('adapter exposure', () => {
     expect(getExposedTriggerGroups(slate, false)).toEqual([providerGroup]);
     expect(getExposedTriggerGroups(slate, true)).toEqual([providerGroup, adapterGroup]);
   });
+
+  it('treats missing adapters and trigger groups as empty collections', () => {
+    let legacySlate = { actions: [providerTool, providerTrigger] } as any;
+
+    expect(getExposedActions(legacySlate, true)).toEqual([providerTool, providerTrigger]);
+    expect(getExposedTriggerGroups(legacySlate, true)).toEqual([]);
+    expect(mapAdapter({ id: 'chat', name: 'Chat' } as any)).toEqual({
+      id: 'chat',
+      name: 'Chat',
+      capabilities: []
+    });
+  });
+});
+
+describe('mapAuthMethod', () => {
+  let slate: any = { spec: { auth: { outputSchema: z.object({ token: z.string() }) } } };
+  let oauthMethod: any = {
+    type: 'auth.oauth',
+    key: 'oauth',
+    name: 'OAuth',
+    scopes: [],
+    getAuthorizationUrl: async () => ({ url: '' }),
+    handleCallback: async () => ({ output: { token: '' } })
+  };
+
+  it('emits syncTokensAcrossConnections only when the method opts in', () => {
+    expect(
+      mapAuthMethod(slate, { ...oauthMethod, syncTokensAcrossConnections: true })
+    ).toMatchObject({ syncTokensAcrossConnections: true });
+
+    for (let method of [oauthMethod, { ...oauthMethod, syncTokensAcrossConnections: false }]) {
+      expect(mapAuthMethod(slate, method)).not.toHaveProperty('syncTokensAcrossConnections');
+    }
+  });
 });

package/src/spec.ts

@@ -49,6 +49,10 @@ export let mapAuthMethod = <ConfigType extends {}, AuthType extends {}>(
 
   adapters: 'adapters' in m ? m.adapters : undefined,
 
+  ...('syncTokensAcrossConnections' in m && m.syncTokensAcrossConnections
+    ? { syncTokensAcrossConnections: true }
+    : {}),
+
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
 
@@ -70,7 +74,7 @@ export let getAction = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   actionId: string
 ) => {
-  let action = slate.actions.find(m => m.key === actionId);
+  let action = (slate.actions ?? []).find(m => m.key === actionId);
   if (!action) {
     throw new ServiceError(notFoundError(`action`, actionId));
   }
@@ -82,7 +86,7 @@ export let getAdapter = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   adapterId: string
 ) => {
-  let adapter = slate.adapters.find(m => m.id === adapterId);
+  let adapter = (slate.adapters ?? []).find(m => m.id === adapterId);
   if (!adapter) {
     throw new ServiceError(notFoundError(`adapter`, adapterId));
   }
@@ -95,7 +99,7 @@ export let mapAdapter = <ConfigType extends {}, AuthType extends {}>(
 ): SlatesAdapter => ({
   id: adapter.id,
   name: adapter.name,
-  capabilities: adapter.capabilities
+  capabilities: adapter.capabilities ?? []
 });
 
 export let getActionWithType = <
@@ -177,7 +181,7 @@ export let getExposedActions = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   includeAdapterActions: boolean
 ) =>
-  slate.actions.filter(
+  (slate.actions ?? []).filter(
     action => isMappableTrigger(action) && (includeAdapterActions || !action.adapter)
   );
 
@@ -198,7 +202,7 @@ export let getTriggerGroup = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   triggerGroupId: string
 ) => {
-  let group = slate.triggerGroups.find(g => g.key === triggerGroupId);
+  let group = (slate.triggerGroups ?? []).find(g => g.key === triggerGroupId);
   if (!group) {
     throw new ServiceError(notFoundError(`trigger_group`, triggerGroupId));
   }
@@ -210,7 +214,7 @@ export let getTriggersForGroup = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   triggerGroupId: string
 ): SlateTrigger<ConfigType, AuthType, any, any>[] =>
-  slate.actions.filter(
+  (slate.actions ?? []).filter(
     (action): action is SlateTrigger<ConfigType, AuthType, any, any> =>
       action.type === 'trigger' && action.triggerGroup?.key === triggerGroupId
   );
@@ -225,7 +229,7 @@ export let getExposedTriggerGroups = <ConfigType extends {}, AuthType extends {}
     )
   );
 
-  return slate.triggerGroups.filter(group => triggerGroupIds.has(group.key));
+  return (slate.triggerGroups ?? []).filter(group => triggerGroupIds.has(group.key));
 };
 
 export let evaluateTriggerMatches = <ConfigType extends {}, AuthType extends {}>(

package/src/webhookProcess.test.ts

@@ -0,0 +1,99 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import { describe, expect, it } from 'vitest';
+import { createProviderHandler } from './index';
+
+let createManager = async (
+  process: () => Promise<{
+    events: any[];
+    response?: { status?: number; body?: string };
+    skipped?: { reason: string };
+  }>
+) => {
+  let webhookGroup = {
+    key: 'webhook_group',
+    name: 'Webhook Group',
+    description: undefined,
+    metadata: {},
+    source: 'webhook',
+    webhook: {
+      autoRegistration: {
+        webhookTargetList: async () => ({ targets: [], nextPageToken: null }),
+        webhookRegister: async () => ({
+          webhookRegistrationIdentifier: 'reg',
+          webhookRegistrationPayload: {}
+        }),
+        webhookUnregister: async () => {}
+      },
+      process
+    }
+  };
+  let slate = {
+    spec: { key: 'test', name: 'Test' },
+    adapters: [],
+    actions: [],
+    triggerGroups: [webhookGroup]
+  };
+  let manager = await createProviderHandler(slate as any, []).run();
+
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hello',
+    params: { protocol: SLATES_PROTOCOL_VERSION }
+  });
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/participant.set',
+    params: { participants: [] }
+  });
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hub.capabilities.set',
+    params: { capabilities: { triggers: true } }
+  });
+
+  return manager;
+};
+
+let processWebhook = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'process',
+    method: 'slates/trigger_group.webhook.process',
+    params: {
+      triggerGroupId: 'webhook_group',
+      url: 'https://hub.example/receive/key',
+      method: 'POST',
+      headers: {},
+      body: null,
+      webhookRegistrationPayload: {}
+    }
+  } as any);
+
+describe('slates/trigger_group.webhook.process', () => {
+  it('passes the skipped marker through to the hub', async () => {
+    let manager = await createManager(async () => ({
+      events: [],
+      response: { status: 401, body: 'Invalid webhook signature.' },
+      skipped: { reason: 'invalid_signature' }
+    }));
+
+    expect(await processWebhook(manager)).toMatchObject({
+      result: {
+        events: [],
+        response: { status: 401 },
+        skipped: { reason: 'invalid_signature' }
+      }
+    });
+  });
+
+  it('reports null skipped when the handler did not skip', async () => {
+    let manager = await createManager(async () => ({
+      events: [],
+      response: { status: 200, body: '' }
+    }));
+
+    expect(await processWebhook(manager)).toMatchObject({
+      result: { events: [], skipped: null }
+    });
+  });
+});