@slates/provider-handler 1.0.0-rc.19 → 1.0.0-rc.20

package/dist/index.cjs

@@ -118,6 +118,18 @@ var getAction = (slate, actionId) => {
   }
   return action;
 };
+var getAdapter = (slate, adapterId) => {
+  let adapter = slate.adapters.find((m) => m.id === adapterId);
+  if (!adapter) {
+    throw new import_error2.ServiceError((0, import_error2.notFoundError)(`adapter`, adapterId));
+  }
+  return adapter;
+};
+var mapAdapter = (adapter) => ({
+  id: adapter.id,
+  name: adapter.name,
+  capabilities: adapter.capabilities
+});
 var getActionWithType = (slate, type, actionId) => {
   let action = getAction(slate, actionId);
   if (action.type !== type) {
@@ -141,6 +153,7 @@ var mapAction = (_slate, a) => {
     scopes: a.scopes,
     authMethods: a.authMethods,
     docs: a.docs ?? [],
+    ...a.adapter ? { adapter: a.adapter } : {},
     inputSchema: toJsonSchema(a.inputSchema),
     outputSchema: toJsonSchema(a.outputSchema)
   };
@@ -148,7 +161,8 @@ var mapAction = (_slate, a) => {
     return {
       ...base,
       type: "action.tool",
-      capabilities: {}
+      capabilities: {},
+      isPublic: a.isPublic
     };
   }
   return {
@@ -833,10 +847,24 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       })
     );
   });
-  manager.onRequest("slates/actions.list", async () => {
+  manager.onRequest("slates/actions.list", async ({ params }) => {
+    getContextBasic();
+    let actions = params.includeAdapterActions ? slate.actions : slate.actions.filter((action) => !action.adapter);
+    return {
+      actions: actions.map((a) => mapAction(slate, a))
+    };
+  });
+  manager.onRequest("slates/adapters.list", async () => {
+    getContextBasic();
+    return {
+      adapters: slate.adapters.map(mapAdapter)
+    };
+  });
+  manager.onRequest("slates/adapter.get", async ({ params }) => {
     getContextBasic();
+    let adapter = getAdapter(slate, params.adapterId);
     return {
-      actions: slate.actions.map((a) => mapAction(slate, a))
+      adapter: mapAdapter(adapter)
     };
   });
   manager.onRequest("slates/action.get", async ({ params }) => {
@@ -847,7 +875,6 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     };
   });
   manager.onRequest("slates/action.tool.invoke", async ({ params }) => {
-    let ctx = getContextFull();
     let action = getActionWithType(slate, "tool", params.actionId);
     let input = validate(
       action.inputSchema,
@@ -855,34 +882,44 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       "input",
       `Invalid input for tool ID: ${params.actionId}`
     );
-    let context = new import_provider2.SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger);
-    let res = await traceProviderCall(
-      {
-        component: "action",
-        functionName: "handleInvocation",
-        message: `Starting tool ${formatEntityLabel(action.name, action.key)}`,
-        successMessage: `Completed tool ${formatEntityLabel(action.name, action.key)}`,
-        errorMessage: `Tool ${formatEntityLabel(action.name, action.key)} failed`,
-        metadata: {
-          actionId: action.key,
-          actionName: action.name,
-          actionType: action.type,
-          inputKeyCount: getObjectKeyCount(input)
+    let invoke = async (context) => {
+      let res = await traceProviderCall(
+        {
+          component: "action",
+          functionName: "handleInvocation",
+          message: `Starting tool ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: `Completed tool ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Tool ${formatEntityLabel(action.name, action.key)} failed`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type,
+            isPublic: action.isPublic,
+            inputKeyCount: getObjectKeyCount(input)
+          },
+          onSuccess: (result) => ({
+            hasMessage: !!result.message,
+            actionResultMessage: result.message,
+            outputKeyCount: getObjectKeyCount(result.output),
+            attachmentCount: result.attachments?.length
+          })
         },
-        onSuccess: (result) => ({
-          hasMessage: !!result.message,
-          actionResultMessage: result.message,
-          outputKeyCount: getObjectKeyCount(result.output),
-          attachmentCount: result.attachments?.length
-        })
-      },
-      () => (0, import_provider2.runWithContext)(context, () => action.handleInvocation(context))
+        () => (0, import_provider2.runWithContext)(context, () => action.handleInvocation(context))
+      );
+      return withRequestTraces(context, {
+        output: res.output,
+        message: res.message,
+        attachments: mergeAttachments(res.attachments, res.output)
+      });
+    };
+    if (action.isPublic) {
+      getContextBasic();
+      return invoke(new import_provider2.SlatePublicContext(input, slate.spec, logger));
+    }
+    let ctx = getContextFull();
+    return invoke(
+      new import_provider2.SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger)
     );
-    return withRequestTraces(context, {
-      output: res.output,
-      message: res.message,
-      attachments: mergeAttachments(res.attachments, res.output)
-    });
   });
   manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {
     let ctx = getContextFull();

package/dist/index.module.js

@@ -7,12 +7,15 @@ import {
 import {
   runWithContext,
   SlateContext,
-  SlateLogger
+  SlateLogger,
+  SlatePublicContext
 } from "@slates/provider";
 
 // src/spec.ts
 import { badRequestError, notFoundError, ServiceError as ServiceError2 } from "@lowerdeck/error";
-import { SlateDefaultPollingIntervalSeconds } from "@slates/provider";
+import {
+  SlateDefaultPollingIntervalSeconds
+} from "@slates/provider";
 import z from "zod";
 
 // src/validation.ts
@@ -91,6 +94,18 @@ var getAction = (slate, actionId) => {
   }
   return action;
 };
+var getAdapter = (slate, adapterId) => {
+  let adapter = slate.adapters.find((m) => m.id === adapterId);
+  if (!adapter) {
+    throw new ServiceError2(notFoundError(`adapter`, adapterId));
+  }
+  return adapter;
+};
+var mapAdapter = (adapter) => ({
+  id: adapter.id,
+  name: adapter.name,
+  capabilities: adapter.capabilities
+});
 var getActionWithType = (slate, type, actionId) => {
   let action = getAction(slate, actionId);
   if (action.type !== type) {
@@ -114,6 +129,7 @@ var mapAction = (_slate, a) => {
     scopes: a.scopes,
     authMethods: a.authMethods,
     docs: a.docs ?? [],
+    ...a.adapter ? { adapter: a.adapter } : {},
     inputSchema: toJsonSchema(a.inputSchema),
     outputSchema: toJsonSchema(a.outputSchema)
   };
@@ -121,7 +137,8 @@ var mapAction = (_slate, a) => {
     return {
       ...base,
       type: "action.tool",
-      capabilities: {}
+      capabilities: {},
+      isPublic: a.isPublic
     };
   }
   return {
@@ -806,10 +823,24 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       })
     );
   });
-  manager.onRequest("slates/actions.list", async () => {
+  manager.onRequest("slates/actions.list", async ({ params }) => {
     getContextBasic();
+    let actions = params.includeAdapterActions ? slate.actions : slate.actions.filter((action) => !action.adapter);
     return {
-      actions: slate.actions.map((a) => mapAction(slate, a))
+      actions: actions.map((a) => mapAction(slate, a))
+    };
+  });
+  manager.onRequest("slates/adapters.list", async () => {
+    getContextBasic();
+    return {
+      adapters: slate.adapters.map(mapAdapter)
+    };
+  });
+  manager.onRequest("slates/adapter.get", async ({ params }) => {
+    getContextBasic();
+    let adapter = getAdapter(slate, params.adapterId);
+    return {
+      adapter: mapAdapter(adapter)
     };
   });
   manager.onRequest("slates/action.get", async ({ params }) => {
@@ -820,7 +851,6 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     };
   });
   manager.onRequest("slates/action.tool.invoke", async ({ params }) => {
-    let ctx = getContextFull();
     let action = getActionWithType(slate, "tool", params.actionId);
     let input = validate(
       action.inputSchema,
@@ -828,34 +858,44 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       "input",
       `Invalid input for tool ID: ${params.actionId}`
     );
-    let context = new SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger);
-    let res = await traceProviderCall(
-      {
-        component: "action",
-        functionName: "handleInvocation",
-        message: `Starting tool ${formatEntityLabel(action.name, action.key)}`,
-        successMessage: `Completed tool ${formatEntityLabel(action.name, action.key)}`,
-        errorMessage: `Tool ${formatEntityLabel(action.name, action.key)} failed`,
-        metadata: {
-          actionId: action.key,
-          actionName: action.name,
-          actionType: action.type,
-          inputKeyCount: getObjectKeyCount(input)
+    let invoke = async (context) => {
+      let res = await traceProviderCall(
+        {
+          component: "action",
+          functionName: "handleInvocation",
+          message: `Starting tool ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: `Completed tool ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Tool ${formatEntityLabel(action.name, action.key)} failed`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type,
+            isPublic: action.isPublic,
+            inputKeyCount: getObjectKeyCount(input)
+          },
+          onSuccess: (result) => ({
+            hasMessage: !!result.message,
+            actionResultMessage: result.message,
+            outputKeyCount: getObjectKeyCount(result.output),
+            attachmentCount: result.attachments?.length
+          })
         },
-        onSuccess: (result) => ({
-          hasMessage: !!result.message,
-          actionResultMessage: result.message,
-          outputKeyCount: getObjectKeyCount(result.output),
-          attachmentCount: result.attachments?.length
-        })
-      },
-      () => runWithContext(context, () => action.handleInvocation(context))
+        () => runWithContext(context, () => action.handleInvocation(context))
+      );
+      return withRequestTraces(context, {
+        output: res.output,
+        message: res.message,
+        attachments: mergeAttachments(res.attachments, res.output)
+      });
+    };
+    if (action.isPublic) {
+      getContextBasic();
+      return invoke(new SlatePublicContext(input, slate.spec, logger));
+    }
+    let ctx = getContextFull();
+    return invoke(
+      new SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger)
     );
-    return withRequestTraces(context, {
-      output: res.output,
-      message: res.message,
-      attachments: mergeAttachments(res.attachments, res.output)
-    });
   });
   manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {
     let ctx = getContextFull();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.19",
+  "version": "1.0.0-rc.20",
   "publishConfig": {
     "access": "public"
   },
@@ -33,7 +33,7 @@
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
     "@slates/proto": "1.0.0-rc.13",
-    "@slates/provider": "1.0.0-rc.17",
+    "@slates/provider": "1.0.0-rc.18",
     "zod": "^4.2.1"
   },
   "devDependencies": {

package/src/index.ts

@@ -10,9 +10,18 @@ import {
   type SlateAttachment,
   SlateContext,
   SlateLogger,
-  type SlateLogListener
+  type SlateLogListener,
+  SlatePublicContext
 } from '@slates/provider';
-import { getAction, getActionWithType, getAuthMethod, mapAction, mapAuthMethod } from './spec';
+import {
+  getAction,
+  getActionWithType,
+  getAdapter,
+  getAuthMethod,
+  mapAction,
+  mapAdapter,
+  mapAuthMethod
+} from './spec';
 import { State } from './state';
 import { toJsonSchema, validate } from './validation';
 import { serializeWebhookHttpResponse } from './webhook';
@@ -232,7 +241,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     let getAuthContext = () =>
       new SlateContext(getAuthConfig(), {}, {}, slate.spec as any, logger);
     let withRequestTraces = <Result extends Record<string, any>>(
-      context: SlateContext<any, any, any>,
+      context: SlatePublicContext<any>,
       result: Result
     ) => {
       let requestTraces = context.getHttpTraces();
@@ -746,11 +755,32 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       );
     });
 
-    manager.onRequest('slates/actions.list', async () => {
+    manager.onRequest('slates/actions.list', async ({ params }) => {
+      getContextBasic();
+
+      let actions = params.includeAdapterActions
+        ? slate.actions
+        : slate.actions.filter(action => !action.adapter);
+
+      return {
+        actions: actions.map(a => mapAction(slate, a))
+      };
+    });
+
+    manager.onRequest('slates/adapters.list', async () => {
       getContextBasic();
 
       return {
-        actions: slate.actions.map(a => mapAction(slate, a))
+        adapters: slate.adapters.map(mapAdapter)
+      };
+    });
+
+    manager.onRequest('slates/adapter.get', async ({ params }) => {
+      getContextBasic();
+      let adapter = getAdapter(slate, params.adapterId);
+
+      return {
+        adapter: mapAdapter(adapter)
       };
     });
 
@@ -764,7 +794,6 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     });
 
     manager.onRequest('slates/action.tool.invoke', async ({ params }) => {
-      let ctx = getContextFull();
       let action = getActionWithType(slate, 'tool', params.actionId);
 
       let input = validate(
@@ -774,35 +803,47 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         `Invalid input for tool ID: ${params.actionId}`
       );
 
-      let context = new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger);
-      let res = await traceProviderCall(
-        {
-          component: 'action',
-          functionName: 'handleInvocation',
-          message: `Starting tool ${formatEntityLabel(action.name, action.key)}`,
-          successMessage: `Completed tool ${formatEntityLabel(action.name, action.key)}`,
-          errorMessage: `Tool ${formatEntityLabel(action.name, action.key)} failed`,
-          metadata: {
-            actionId: action.key,
-            actionName: action.name,
-            actionType: action.type,
-            inputKeyCount: getObjectKeyCount(input)
+      let invoke = async (context: SlatePublicContext<any>) => {
+        let res = await traceProviderCall(
+          {
+            component: 'action',
+            functionName: 'handleInvocation',
+            message: `Starting tool ${formatEntityLabel(action.name, action.key)}`,
+            successMessage: `Completed tool ${formatEntityLabel(action.name, action.key)}`,
+            errorMessage: `Tool ${formatEntityLabel(action.name, action.key)} failed`,
+            metadata: {
+              actionId: action.key,
+              actionName: action.name,
+              actionType: action.type,
+              isPublic: action.isPublic,
+              inputKeyCount: getObjectKeyCount(input)
+            },
+            onSuccess: result => ({
+              hasMessage: !!result.message,
+              actionResultMessage: result.message,
+              outputKeyCount: getObjectKeyCount(result.output),
+              attachmentCount: result.attachments?.length
+            })
           },
-          onSuccess: result => ({
-            hasMessage: !!result.message,
-            actionResultMessage: result.message,
-            outputKeyCount: getObjectKeyCount(result.output),
-            attachmentCount: result.attachments?.length
-          })
-        },
-        () => runWithContext(context, () => action.handleInvocation(context))
-      );
+          () => runWithContext(context, () => action.handleInvocation(context as any))
+        );
 
-      return withRequestTraces(context, {
-        output: res.output,
-        message: res.message,
-        attachments: mergeAttachments(res.attachments, res.output)
-      });
+        return withRequestTraces(context, {
+          output: res.output,
+          message: res.message,
+          attachments: mergeAttachments(res.attachments, res.output)
+        });
+      };
+
+      if (action.isPublic) {
+        getContextBasic();
+        return invoke(new SlatePublicContext(input, slate.spec, logger));
+      }
+
+      let ctx = getContextFull();
+      return invoke(
+        new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger)
+      );
     });
 
     manager.onRequest('slates/action.trigger.map_event', async ({ params }) => {

package/src/spec.ts

@@ -1,6 +1,14 @@
 import { badRequestError, notFoundError, ServiceError } from '@lowerdeck/error';
-import type { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
-import { type Slate, SlateDefaultPollingIntervalSeconds } from '@slates/provider';
+import type {
+  SlateAuthenticationMethod,
+  SlatesAction,
+  SlateAdapter as SlatesAdapter
+} from '@slates/proto';
+import {
+  type Slate,
+  type SlateAdapter,
+  SlateDefaultPollingIntervalSeconds
+} from '@slates/provider';
 import z from 'zod';
 import { toJsonSchema } from './validation';
 
@@ -67,6 +75,26 @@ export let getAction = <ConfigType extends {}, AuthType extends {}>(
   return action;
 };
 
+export let getAdapter = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  adapterId: string
+) => {
+  let adapter = slate.adapters.find(m => m.id === adapterId);
+  if (!adapter) {
+    throw new ServiceError(notFoundError(`adapter`, adapterId));
+  }
+
+  return adapter;
+};
+
+export let mapAdapter = <ConfigType extends {}, AuthType extends {}>(
+  adapter: SlateAdapter<ConfigType, AuthType>
+): SlatesAdapter => ({
+  id: adapter.id,
+  name: adapter.name,
+  capabilities: adapter.capabilities
+});
+
 export let getActionWithType = <
   Type extends 'tool' | 'trigger',
   ConfigType extends {},
@@ -103,6 +131,7 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
     scopes: a.scopes,
     authMethods: a.authMethods,
     docs: a.docs ?? [],
+    ...(a.adapter ? { adapter: a.adapter } : {}),
 
     inputSchema: toJsonSchema(a.inputSchema),
     outputSchema: toJsonSchema(a.outputSchema)
@@ -112,7 +141,8 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
     return {
       ...base,
       type: 'action.tool',
-      capabilities: {}
+      capabilities: {},
+      isPublic: a.isPublic
     };
   }