@slates/provider-handler 1.0.0-rc.32 → 1.0.0-rc.34

package/dist/index.cjs

@@ -112,6 +112,7 @@ var mapAuthMethod = (slate, m) => ({
     title: s.title,
     description: s.description
   })) : void 0,
+  adapters: "adapters" in m ? m.adapters : void 0,
   inputSchema: toJsonSchema(m.inputSchema ?? import_zod.default.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
   capabilities: {
@@ -195,6 +196,16 @@ var getMappableAction = (slate, actionId) => {
   }
   return action;
 };
+var getExposedActions = (slate, includeAdapterActions) => slate.actions.filter(
+  (action) => isMappableTrigger(action) && (includeAdapterActions || !action.adapter)
+);
+var getExposedAction = (slate, actionId, includeAdapterActions) => {
+  let action = getMappableAction(slate, actionId);
+  if (action.adapter && !includeAdapterActions) {
+    throw new import_error2.ServiceError((0, import_error2.notFoundError)(`action`, actionId));
+  }
+  return action;
+};
 var getTriggerGroup = (slate, triggerGroupId) => {
   let group = slate.triggerGroups.find((g) => g.key === triggerGroupId);
   if (!group) {
@@ -205,6 +216,14 @@ var getTriggerGroup = (slate, triggerGroupId) => {
 var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
   (action) => action.type === "trigger" && action.triggerGroup?.key === triggerGroupId
 );
+var getExposedTriggerGroups = (slate, includeAdapterActions) => {
+  let triggerGroupIds = new Set(
+    getExposedActions(slate, includeAdapterActions).flatMap(
+      (action) => action.type === "trigger" && action.triggerGroup ? [action.triggerGroup.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) => {
   if (group.source !== "webhook" || !group.webhook?.autoRegistration) {
@@ -427,6 +446,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     };
   };
   let supportsTriggerGroups = () => !!hubCapabilities.get()?.triggers;
+  let supportsAdapters = () => !!hubCapabilities.get()?.adapters;
   let logger = new import_provider2.SlateLogger(listeners);
   let providerTrace = {
     providerId: slate.spec.key,
@@ -980,8 +1000,10 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   });
   manager.onRequest("slates/actions.list", async ({ params }) => {
     getContextBasic();
-    let actions = params.includeAdapterActions ? slate.actions : slate.actions.filter((action) => !action.adapter);
-    actions = actions.filter(isMappableTrigger);
+    let actions = getExposedActions(
+      slate,
+      !!params.includeAdapterActions && supportsAdapters()
+    );
     if (!supportsTriggerGroups()) {
       actions = actions.filter((action) => action.type !== "trigger");
     }
@@ -992,11 +1014,14 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   manager.onRequest("slates/adapters.list", async () => {
     getContextBasic();
     return {
-      adapters: slate.adapters.map(mapAdapter)
+      adapters: supportsAdapters() ? slate.adapters.map(mapAdapter) : []
     };
   });
   manager.onRequest("slates/adapter.get", async ({ params }) => {
     getContextBasic();
+    if (!supportsAdapters()) {
+      throw new import_error4.ServiceError((0, import_error4.notFoundError)(`adapter`, params.adapterId));
+    }
     let adapter = getAdapter(slate, params.adapterId);
     return {
       adapter: mapAdapter(adapter)
@@ -1004,7 +1029,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   });
   manager.onRequest("slates/action.get", async ({ params }) => {
     getContextBasic();
-    let action = getMappableAction(slate, params.actionId);
+    let action = getExposedAction(slate, params.actionId, supportsAdapters());
     return {
       action: mapAction(slate, action)
     };
@@ -1012,7 +1037,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   manager.onRequest("slates/trigger_groups.list", async () => {
     getContextBasic();
     return {
-      triggerGroups: slate.triggerGroups.map(mapTriggerGroup)
+      triggerGroups: getExposedTriggerGroups(slate, supportsAdapters()).map(mapTriggerGroup)
     };
   });
   manager.onRequest("slates/trigger_group.get", async ({ params }) => {

package/dist/index.module.js

@@ -1,5 +1,10 @@
 // src/index.ts
-import { badRequestError as badRequestError3, preconditionFailedError, ServiceError as ServiceError4 } from "@lowerdeck/error";
+import {
+  badRequestError as badRequestError3,
+  notFoundError as notFoundError2,
+  preconditionFailedError,
+  ServiceError as ServiceError4
+} from "@lowerdeck/error";
 import {
   createSlatesProviderProtoHandler,
   SLATES_PROTOCOL_VERSION
@@ -90,6 +95,7 @@ var mapAuthMethod = (slate, m) => ({
     title: s.title,
     description: s.description
   })) : void 0,
+  adapters: "adapters" in m ? m.adapters : void 0,
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
   capabilities: {
@@ -173,6 +179,16 @@ var getMappableAction = (slate, actionId) => {
   }
   return action;
 };
+var getExposedActions = (slate, includeAdapterActions) => slate.actions.filter(
+  (action) => isMappableTrigger(action) && (includeAdapterActions || !action.adapter)
+);
+var getExposedAction = (slate, actionId, includeAdapterActions) => {
+  let action = getMappableAction(slate, actionId);
+  if (action.adapter && !includeAdapterActions) {
+    throw new ServiceError2(notFoundError(`action`, actionId));
+  }
+  return action;
+};
 var getTriggerGroup = (slate, triggerGroupId) => {
   let group = slate.triggerGroups.find((g) => g.key === triggerGroupId);
   if (!group) {
@@ -183,6 +199,14 @@ var getTriggerGroup = (slate, triggerGroupId) => {
 var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
   (action) => action.type === "trigger" && action.triggerGroup?.key === triggerGroupId
 );
+var getExposedTriggerGroups = (slate, includeAdapterActions) => {
+  let triggerGroupIds = new Set(
+    getExposedActions(slate, includeAdapterActions).flatMap(
+      (action) => action.type === "trigger" && action.triggerGroup ? [action.triggerGroup.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) => {
   if (group.source !== "webhook" || !group.webhook?.autoRegistration) {
@@ -405,6 +429,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     };
   };
   let supportsTriggerGroups = () => !!hubCapabilities.get()?.triggers;
+  let supportsAdapters = () => !!hubCapabilities.get()?.adapters;
   let logger = new SlateLogger(listeners);
   let providerTrace = {
     providerId: slate.spec.key,
@@ -958,8 +983,10 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   });
   manager.onRequest("slates/actions.list", async ({ params }) => {
     getContextBasic();
-    let actions = params.includeAdapterActions ? slate.actions : slate.actions.filter((action) => !action.adapter);
-    actions = actions.filter(isMappableTrigger);
+    let actions = getExposedActions(
+      slate,
+      !!params.includeAdapterActions && supportsAdapters()
+    );
     if (!supportsTriggerGroups()) {
       actions = actions.filter((action) => action.type !== "trigger");
     }
@@ -970,11 +997,14 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/adapters.list", async () => {
     getContextBasic();
     return {
-      adapters: slate.adapters.map(mapAdapter)
+      adapters: supportsAdapters() ? slate.adapters.map(mapAdapter) : []
     };
   });
   manager.onRequest("slates/adapter.get", async ({ params }) => {
     getContextBasic();
+    if (!supportsAdapters()) {
+      throw new ServiceError4(notFoundError2(`adapter`, params.adapterId));
+    }
     let adapter = getAdapter(slate, params.adapterId);
     return {
       adapter: mapAdapter(adapter)
@@ -982,7 +1012,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   });
   manager.onRequest("slates/action.get", async ({ params }) => {
     getContextBasic();
-    let action = getMappableAction(slate, params.actionId);
+    let action = getExposedAction(slate, params.actionId, supportsAdapters());
     return {
       action: mapAction(slate, action)
     };
@@ -990,7 +1020,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/trigger_groups.list", async () => {
     getContextBasic();
     return {
-      triggerGroups: slate.triggerGroups.map(mapTriggerGroup)
+      triggerGroups: getExposedTriggerGroups(slate, supportsAdapters()).map(mapTriggerGroup)
     };
   });
   manager.onRequest("slates/trigger_group.get", async ({ params }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.32",
+  "version": "1.0.0-rc.34",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.19",
-    "@slates/provider": "1.0.0-rc.23",
+    "@slates/proto": "1.0.0-rc.20",
+    "@slates/provider": "1.0.0-rc.24",
     "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },
@@ -43,4 +43,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/exposure.test.ts

@@ -0,0 +1,161 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { createProviderHandler } from './index';
+
+let createManager = async () => {
+  let providerGroup = {
+    key: 'provider_group',
+    name: 'Provider Group',
+    description: undefined,
+    metadata: {},
+    source: 'polling',
+    polling: { intervalSeconds: 60 }
+  };
+  let adapterGroup = {
+    key: 'adapter_group',
+    name: 'Adapter Group',
+    description: undefined,
+    metadata: {},
+    source: 'polling',
+    polling: { intervalSeconds: 60 }
+  };
+  let emptyGroup = {
+    key: 'empty_group',
+    name: 'Empty Group',
+    description: undefined,
+    metadata: {},
+    source: 'polling',
+    polling: { intervalSeconds: 60 }
+  };
+  let action = {
+    name: 'Action',
+    description: undefined,
+    instructions: undefined,
+    constraints: undefined,
+    tags: [],
+    metadata: {},
+    scopes: [],
+    authMethods: [],
+    docs: [],
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+    matches: () => true,
+    map: async () => ({ type: 'event', output: {} })
+  };
+  let slate = {
+    spec: { key: 'test', name: 'Test' },
+    adapters: [{ id: 'chat', name: 'Chat', capabilities: [] }],
+    actions: [
+      { ...action, key: 'provider_tool', type: 'tool', isPublic: false },
+      {
+        ...action,
+        key: 'adapter_tool',
+        type: 'tool',
+        adapter: 'chat',
+        isPublic: false
+      },
+      { ...action, key: 'provider_trigger', type: 'trigger', triggerGroup: providerGroup },
+      {
+        ...action,
+        key: 'adapter_trigger',
+        type: 'trigger',
+        adapter: 'chat',
+        triggerGroup: adapterGroup
+      }
+    ],
+    triggerGroups: [providerGroup, adapterGroup, emptyGroup]
+  };
+  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: [] }
+  });
+
+  return manager;
+};
+
+let request = async (
+  manager: SlatesProviderProtoHandlerManager,
+  method:
+    | 'slates/actions.list'
+    | 'slates/action.get'
+    | 'slates/adapters.list'
+    | 'slates/adapter.get'
+    | 'slates/trigger_groups.list',
+  params: Record<string, unknown> = {}
+) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: method,
+    method,
+    params
+  } as any);
+
+describe('adapter capability exposure', () => {
+  it('hides adapter surfaces from a legacy hub that only supports triggers', async () => {
+    let manager = await createManager();
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { triggers: true } }
+    });
+
+    expect(await request(manager, 'slates/adapters.list')).toMatchObject({
+      result: { adapters: [] }
+    });
+    expect(
+      await request(manager, 'slates/actions.list', { includeAdapterActions: true })
+    ).toMatchObject({
+      result: { actions: [{ id: 'provider_tool' }, { id: 'provider_trigger' }] }
+    });
+    expect(await request(manager, 'slates/trigger_groups.list')).toMatchObject({
+      result: { triggerGroups: [{ id: 'provider_group' }] }
+    });
+    expect(await request(manager, 'slates/adapter.get', { adapterId: 'chat' })).toHaveProperty(
+      'error'
+    );
+    expect(
+      await request(manager, 'slates/action.get', { actionId: 'adapter_tool' })
+    ).toHaveProperty('error');
+  });
+
+  it('exposes adapters and their actions when the hub enables them', async () => {
+    let manager = await createManager();
+
+    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: [{ id: 'chat' }] }
+    });
+    expect(
+      await request(manager, 'slates/actions.list', { includeAdapterActions: true })
+    ).toMatchObject({
+      result: {
+        actions: [
+          { id: 'provider_tool' },
+          { id: 'adapter_tool' },
+          { id: 'provider_trigger' },
+          { id: 'adapter_trigger' }
+        ]
+      }
+    });
+    expect(await request(manager, 'slates/trigger_groups.list')).toMatchObject({
+      result: {
+        triggerGroups: [{ id: 'provider_group' }, { id: 'adapter_group' }]
+      }
+    });
+  });
+});

package/src/index.ts

@@ -1,4 +1,9 @@
-import { badRequestError, preconditionFailedError, ServiceError } from '@lowerdeck/error';
+import {
+  badRequestError,
+  notFoundError,
+  preconditionFailedError,
+  ServiceError
+} from '@lowerdeck/error';
 import {
   createSlatesProviderProtoHandler,
   SLATES_PROTOCOL_VERSION,
@@ -22,7 +27,9 @@ import {
   getActionWithType,
   getAdapter,
   getAuthMethod,
-  getMappableAction,
+  getExposedAction,
+  getExposedActions,
+  getExposedTriggerGroups,
   getTriggerGroup,
   getWebhookAutoRegistration,
   getWebhookManualRegistration,
@@ -191,6 +198,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
     let hubCapabilities = new State<{
       attachments?: { directUpload?: { enabled: boolean; maxAttachmentSizeBytes?: number } };
+      adapters?: boolean;
       triggers?: boolean;
     } | null>(null);
     let liveInvocation = new State<Pick<SlateLiveInvocationInfo, 'token' | 'baseUrl'> | null>(
@@ -211,6 +219,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     };
 
     let supportsTriggerGroups = () => !!hubCapabilities.get()?.triggers;
+    let supportsAdapters = () => !!hubCapabilities.get()?.adapters;
 
     let logger = new SlateLogger(listeners);
     let providerTrace = {
@@ -867,11 +876,10 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     manager.onRequest('slates/actions.list', async ({ params }) => {
       getContextBasic();
 
-      let actions = params.includeAdapterActions
-        ? slate.actions
-        : slate.actions.filter(action => !action.adapter);
-
-      actions = actions.filter(isMappableTrigger);
+      let actions = getExposedActions(
+        slate,
+        !!params.includeAdapterActions && supportsAdapters()
+      );
 
       if (!supportsTriggerGroups()) {
         actions = actions.filter(action => action.type !== 'trigger');
@@ -886,12 +894,15 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       getContextBasic();
 
       return {
-        adapters: slate.adapters.map(mapAdapter)
+        adapters: supportsAdapters() ? slate.adapters.map(mapAdapter) : []
       };
     });
 
     manager.onRequest('slates/adapter.get', async ({ params }) => {
       getContextBasic();
+      if (!supportsAdapters()) {
+        throw new ServiceError(notFoundError(`adapter`, params.adapterId));
+      }
       let adapter = getAdapter(slate, params.adapterId);
 
       return {
@@ -901,7 +912,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
     manager.onRequest('slates/action.get', async ({ params }) => {
       getContextBasic();
-      let action = getMappableAction(slate, params.actionId);
+      let action = getExposedAction(slate, params.actionId, supportsAdapters());
 
       return {
         action: mapAction(slate, action)
@@ -912,7 +923,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       getContextBasic();
 
       return {
-        triggerGroups: slate.triggerGroups.map(mapTriggerGroup)
+        triggerGroups: getExposedTriggerGroups(slate, supportsAdapters()).map(mapTriggerGroup)
       };
     });
 

package/src/spec.test.ts

@@ -1,7 +1,15 @@
 import { isServiceError } from '@lowerdeck/error';
 import { describe, expect, it } from 'vitest';
 import { z } from 'zod';
-import { getMappableAction, getTriggersForGroup, isMappableTrigger, mapAction } from './spec';
+import {
+  getExposedAction,
+  getExposedActions,
+  getExposedTriggerGroups,
+  getMappableAction,
+  getTriggersForGroup,
+  isMappableTrigger,
+  mapAction
+} from './spec';
 
 let baseAction = {
   key: 'do_thing',
@@ -81,3 +89,46 @@ describe('getMappableAction', () => {
     }
   });
 });
+
+describe('adapter exposure', () => {
+  let providerTool: any = { ...toolAction, key: 'provider_tool' };
+  let adapterTool: any = { ...toolAction, key: 'adapter_tool', adapter: 'chat' };
+  let providerGroup = { key: 'provider_group', name: 'Provider Group' };
+  let adapterGroup = { key: 'adapter_group', name: 'Adapter Group' };
+  let emptyGroup = { key: 'empty_group', name: 'Empty Group' };
+  let providerTrigger: any = {
+    ...validTrigger,
+    key: 'provider_trigger',
+    triggerGroup: providerGroup
+  };
+  let adapterTrigger: any = {
+    ...validTrigger,
+    key: 'adapter_trigger',
+    adapter: 'chat',
+    triggerGroup: adapterGroup
+  };
+  let slate = {
+    actions: [providerTool, adapterTool, providerTrigger, adapterTrigger],
+    triggerGroups: [providerGroup, adapterGroup, emptyGroup]
+  } as any;
+
+  it('only exposes adapter actions when adapters are enabled', () => {
+    expect(getExposedActions(slate, false)).toEqual([providerTool, providerTrigger]);
+    expect(getExposedActions(slate, true)).toEqual([
+      providerTool,
+      adapterTool,
+      providerTrigger,
+      adapterTrigger
+    ]);
+  });
+
+  it('does not expose an adapter action directly when adapters are disabled', () => {
+    expect(() => getExposedAction(slate, 'adapter_tool', false)).toThrow();
+    expect(getExposedAction(slate, 'adapter_tool', true)).toBe(adapterTool);
+  });
+
+  it('only exposes trigger groups that contain an exposed trigger', () => {
+    expect(getExposedTriggerGroups(slate, false)).toEqual([providerGroup]);
+    expect(getExposedTriggerGroups(slate, true)).toEqual([providerGroup, adapterGroup]);
+  });
+});

package/src/spec.ts

@@ -8,8 +8,8 @@ import type {
 import {
   type Slate,
   type SlateAdapter,
-  type SlateTrigger,
-  SlateDefaultPollingIntervalSeconds
+  SlateDefaultPollingIntervalSeconds,
+  type SlateTrigger
 } from '@slates/provider';
 import z from 'zod';
 import { toJsonSchema } from './validation';
@@ -47,6 +47,8 @@ export let mapAuthMethod = <ConfigType extends {}, AuthType extends {}>(
         }))
       : undefined,
 
+  adapters: 'adapters' in m ? m.adapters : undefined,
+
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
 
@@ -171,6 +173,27 @@ export let getMappableAction = <ConfigType extends {}, AuthType extends {}>(
   return action;
 };
 
+export let getExposedActions = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  includeAdapterActions: boolean
+) =>
+  slate.actions.filter(
+    action => isMappableTrigger(action) && (includeAdapterActions || !action.adapter)
+  );
+
+export let getExposedAction = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  actionId: string,
+  includeAdapterActions: boolean
+) => {
+  let action = getMappableAction(slate, actionId);
+  if (action.adapter && !includeAdapterActions) {
+    throw new ServiceError(notFoundError(`action`, actionId));
+  }
+
+  return action;
+};
+
 export let getTriggerGroup = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   triggerGroupId: string
@@ -192,6 +215,19 @@ export let getTriggersForGroup = <ConfigType extends {}, AuthType extends {}>(
       action.type === 'trigger' && action.triggerGroup?.key === triggerGroupId
   );
 
+export let getExposedTriggerGroups = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  includeAdapterActions: boolean
+) => {
+  let triggerGroupIds = new Set(
+    getExposedActions(slate, includeAdapterActions).flatMap(action =>
+      action.type === 'trigger' && action.triggerGroup ? [action.triggerGroup.key] : []
+    )
+  );
+
+  return slate.triggerGroups.filter(group => triggerGroupIds.has(group.key));
+};
+
 export let evaluateTriggerMatches = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   triggerGroupId: string,