@slates/provider-handler 1.0.0-rc.31 → 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: {
@@ -187,6 +188,24 @@ var mapAction = (_slate, a) => {
     triggerGroupId: a.triggerGroup.key
   };
 };
+var isMappableTrigger = (action) => action.type !== "trigger" || !!action.triggerGroup;
+var getMappableAction = (slate, actionId) => {
+  let action = getAction(slate, actionId);
+  if (!isMappableTrigger(action)) {
+    throw new import_error2.ServiceError((0, import_error2.notFoundError)(`action`, 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) {
@@ -195,8 +214,16 @@ var getTriggerGroup = (slate, triggerGroupId) => {
   return group;
 };
 var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
-  (action) => action.type === "trigger" && action.triggerGroup.key === triggerGroupId
+  (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) {
@@ -230,8 +257,12 @@ var mapTriggerGroup = (group) => ({
     type: "webhook",
     registration: group.webhook?.manualRegistration ? {
       mode: "manual",
-      userConfigSchema: toJsonSchema(group.webhook.manualRegistration.userConfigSchema),
-      fullConfigSchema: toJsonSchema(group.webhook.manualRegistration.fullConfigSchema)
+      userConfigSchema: toJsonSchema(
+        group.webhook.manualRegistration.userConfigSchema
+      ),
+      fullConfigSchema: toJsonSchema(
+        group.webhook.manualRegistration.fullConfigSchema
+      )
     } : { mode: "auto" }
   }
 });
@@ -415,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,
@@ -557,7 +589,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         liveInvocation: true
       },
       provider: {
-        triggerGroups: true
+        triggerGroups: (slate.triggerGroups?.length ?? 0) > 0 && (slate.actions ?? []).every(isMappableTrigger)
       }
     }
   }));
@@ -968,7 +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);
+    let actions = getExposedActions(
+      slate,
+      !!params.includeAdapterActions && supportsAdapters()
+    );
     if (!supportsTriggerGroups()) {
       actions = actions.filter((action) => action.type !== "trigger");
     }
@@ -979,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)
@@ -991,7 +1029,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   });
   manager.onRequest("slates/action.get", async ({ params }) => {
     getContextBasic();
-    let action = getAction(slate, params.actionId);
+    let action = getExposedAction(slate, params.actionId, supportsAdapters());
     return {
       action: mapAction(slate, action)
     };
@@ -999,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: {
@@ -165,6 +171,24 @@ var mapAction = (_slate, a) => {
     triggerGroupId: a.triggerGroup.key
   };
 };
+var isMappableTrigger = (action) => action.type !== "trigger" || !!action.triggerGroup;
+var getMappableAction = (slate, actionId) => {
+  let action = getAction(slate, actionId);
+  if (!isMappableTrigger(action)) {
+    throw new ServiceError2(notFoundError(`action`, 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) {
@@ -173,8 +197,16 @@ var getTriggerGroup = (slate, triggerGroupId) => {
   return group;
 };
 var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
-  (action) => action.type === "trigger" && action.triggerGroup.key === triggerGroupId
+  (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) {
@@ -208,8 +240,12 @@ var mapTriggerGroup = (group) => ({
     type: "webhook",
     registration: group.webhook?.manualRegistration ? {
       mode: "manual",
-      userConfigSchema: toJsonSchema(group.webhook.manualRegistration.userConfigSchema),
-      fullConfigSchema: toJsonSchema(group.webhook.manualRegistration.fullConfigSchema)
+      userConfigSchema: toJsonSchema(
+        group.webhook.manualRegistration.userConfigSchema
+      ),
+      fullConfigSchema: toJsonSchema(
+        group.webhook.manualRegistration.fullConfigSchema
+      )
     } : { mode: "auto" }
   }
 });
@@ -393,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,
@@ -535,7 +572,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         liveInvocation: true
       },
       provider: {
-        triggerGroups: true
+        triggerGroups: (slate.triggerGroups?.length ?? 0) > 0 && (slate.actions ?? []).every(isMappableTrigger)
       }
     }
   }));
@@ -946,7 +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);
+    let actions = getExposedActions(
+      slate,
+      !!params.includeAdapterActions && supportsAdapters()
+    );
     if (!supportsTriggerGroups()) {
       actions = actions.filter((action) => action.type !== "trigger");
     }
@@ -957,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)
@@ -969,7 +1012,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   });
   manager.onRequest("slates/action.get", async ({ params }) => {
     getContextBasic();
-    let action = getAction(slate, params.actionId);
+    let action = getExposedAction(slate, params.actionId, supportsAdapters());
     return {
       action: mapAction(slate, action)
     };
@@ -977,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.31",
+  "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"
   },

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,
@@ -19,13 +24,16 @@ import {
 import { PQueue } from './pQueue';
 import {
   evaluateTriggerMatches,
-  getAction,
   getActionWithType,
   getAdapter,
   getAuthMethod,
+  getExposedAction,
+  getExposedActions,
+  getExposedTriggerGroups,
   getTriggerGroup,
   getWebhookAutoRegistration,
   getWebhookManualRegistration,
+  isMappableTrigger,
   mapAction,
   mapAdapter,
   mapAuthMethod,
@@ -190,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>(
@@ -210,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 = {
@@ -402,7 +412,9 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           liveInvocation: true
         },
         provider: {
-          triggerGroups: true
+          triggerGroups:
+            (slate.triggerGroups?.length ?? 0) > 0 &&
+            (slate.actions ?? []).every(isMappableTrigger)
         }
       }
     }));
@@ -864,9 +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);
+      let actions = getExposedActions(
+        slate,
+        !!params.includeAdapterActions && supportsAdapters()
+      );
 
       if (!supportsTriggerGroups()) {
         actions = actions.filter(action => action.type !== 'trigger');
@@ -881,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 {
@@ -896,7 +912,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
     manager.onRequest('slates/action.get', async ({ params }) => {
       getContextBasic();
-      let action = getAction(slate, params.actionId);
+      let action = getExposedAction(slate, params.actionId, supportsAdapters());
 
       return {
         action: mapAction(slate, action)
@@ -907,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

@@ -0,0 +1,134 @@
+import { isServiceError } from '@lowerdeck/error';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import {
+  getExposedAction,
+  getExposedActions,
+  getExposedTriggerGroups,
+  getMappableAction,
+  getTriggersForGroup,
+  isMappableTrigger,
+  mapAction
+} from './spec';
+
+let baseAction = {
+  key: 'do_thing',
+  name: 'Do Thing',
+  description: 'desc',
+  instructions: undefined,
+  constraints: undefined,
+  tags: [],
+  metadata: {},
+  scopes: [],
+  authMethods: [],
+  docs: [],
+  adapter: undefined,
+  inputSchema: z.object({}),
+  outputSchema: z.object({})
+};
+
+let toolAction: any = { ...baseAction, type: 'tool', isPublic: false };
+
+let validTriggerGroup = { key: 'my_group', name: 'My Group' };
+let validTrigger: any = {
+  ...baseAction,
+  type: 'trigger',
+  triggerGroup: validTriggerGroup,
+  matches: () => true,
+  map: () => ({})
+};
+
+let incompatibleTrigger: any = { ...baseAction, type: 'trigger', triggerGroup: undefined };
+
+describe('isMappableTrigger', () => {
+  it('is true for tool actions', () => {
+    expect(isMappableTrigger(toolAction)).toBe(true);
+  });
+
+  it('is true for triggers with a trigger group', () => {
+    expect(isMappableTrigger(validTrigger)).toBe(true);
+  });
+
+  it('is false for triggers missing a trigger group', () => {
+    expect(isMappableTrigger(incompatibleTrigger)).toBe(false);
+  });
+});
+
+describe('mapAction', () => {
+  it('maps a well-formed trigger', () => {
+    let mapped = mapAction({} as any, validTrigger);
+    expect(mapped).toMatchObject({ type: 'action.trigger', triggerGroupId: 'my_group' });
+  });
+});
+
+describe('getTriggersForGroup', () => {
+  it('filters out triggers missing a trigger group instead of throwing', () => {
+    let slate = { actions: [toolAction, validTrigger, incompatibleTrigger] } as any;
+
+    expect(getTriggersForGroup(slate, 'my_group')).toEqual([validTrigger]);
+    expect(getTriggersForGroup(slate, 'other_group')).toEqual([]);
+  });
+});
+
+describe('getMappableAction', () => {
+  it('returns tool and well-formed trigger actions', () => {
+    let slate = { actions: [toolAction, validTrigger] } as any;
+
+    expect(getMappableAction(slate, 'do_thing')).toBe(toolAction);
+  });
+
+  it('treats a trigger missing its group as not found instead of crashing', () => {
+    let slate = { actions: [incompatibleTrigger] } as any;
+
+    try {
+      getMappableAction(slate, 'do_thing');
+      expect.unreachable();
+    } catch (e) {
+      expect(isServiceError(e)).toBe(true);
+      expect((e as any).data.status).toBe(404);
+    }
+  });
+});
+
+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),
 
@@ -155,6 +157,43 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
   };
 };
 
+export let isMappableTrigger = <ConfigType extends {}, AuthType extends {}>(
+  action: Slate<ConfigType, AuthType>['actions'][number]
+): boolean => action.type !== 'trigger' || !!action.triggerGroup;
+
+export let getMappableAction = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  actionId: string
+) => {
+  let action = getAction(slate, actionId);
+  if (!isMappableTrigger(action)) {
+    throw new ServiceError(notFoundError(`action`, actionId));
+  }
+
+  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
@@ -173,9 +212,22 @@ export let getTriggersForGroup = <ConfigType extends {}, AuthType extends {}>(
 ): SlateTrigger<ConfigType, AuthType, any, any>[] =>
   slate.actions.filter(
     (action): action is SlateTrigger<ConfigType, AuthType, any, any> =>
-      action.type === 'trigger' && action.triggerGroup.key === triggerGroupId
+      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,
@@ -231,8 +283,12 @@ export let mapTriggerGroup = <ConfigType extends {}, AuthType extends {}>(
           registration: group.webhook?.manualRegistration
             ? {
                 mode: 'manual',
-                userConfigSchema: toJsonSchema(group.webhook.manualRegistration.userConfigSchema),
-                fullConfigSchema: toJsonSchema(group.webhook.manualRegistration.fullConfigSchema)
+                userConfigSchema: toJsonSchema(
+                  group.webhook.manualRegistration.userConfigSchema
+                ),
+                fullConfigSchema: toJsonSchema(
+                  group.webhook.manualRegistration.fullConfigSchema
+                )
               }
             : { mode: 'auto' }
         }