@slates/provider-handler 1.0.0-rc.2 → 1.0.0-rc.21

package/src/index.ts

@@ -1,9 +1,120 @@
 import { badRequestError, preconditionFailedError, ServiceError } from '@lowerdeck/error';
-import { createSlatesProviderProtoHandler, SlatesParticipant } from '@slates/proto';
-import { Slate, SlateContext, SlateLogger, SlateLogListener } from '@slates/provider';
-import { getAction, getActionWithType, getAuthMethod, mapAction, mapAuthMethod } from './spec';
+import {
+  createSlatesProviderProtoHandler,
+  SLATES_PROTOCOL_VERSION,
+  type SlatesParticipant
+} from '@slates/proto';
+import {
+  runWithContext,
+  type Slate,
+  type SlateAttachment,
+  SlateContext,
+  SlateLogger,
+  type SlateLogListener,
+  SlatePublicContext
+} from '@slates/provider';
+import {
+  getAction,
+  getActionWithType,
+  getAdapter,
+  getAuthMethod,
+  mapAction,
+  mapAdapter,
+  mapAuthMethod
+} from './spec';
 import { State } from './state';
-import { validate } from './validation';
+import { toJsonSchema, validate } from './validation';
+import { serializeWebhookHttpResponse } from './webhook';
+
+let isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+let getObjectKeyCount = (value: unknown) =>
+  isRecord(value) ? Object.keys(value).length : undefined;
+
+let DOWNLOAD_ATTACHMENT_URL_KEYS = new Set([
+  'downloadUrl',
+  'fileUrl',
+  'temporaryDownloadUrl',
+  'webContentLink'
+]);
+
+let isAttachmentUrl = (value: string) => /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+
+let collectOutputUrlAttachments = (
+  value: unknown,
+  seen = new Set<string>()
+): SlateAttachment[] => {
+  if (Array.isArray(value)) {
+    return value.flatMap(item => collectOutputUrlAttachments(item, seen));
+  }
+
+  if (!isRecord(value)) {
+    return [];
+  }
+
+  let attachments: SlateAttachment[] = [];
+
+  for (let [key, nestedValue] of Object.entries(value)) {
+    if (
+      DOWNLOAD_ATTACHMENT_URL_KEYS.has(key) &&
+      typeof nestedValue === 'string' &&
+      nestedValue.length > 0 &&
+      isAttachmentUrl(nestedValue) &&
+      !seen.has(nestedValue)
+    ) {
+      seen.add(nestedValue);
+      attachments.push({
+        content: {
+          type: 'url',
+          url: nestedValue
+        }
+      });
+      continue;
+    }
+
+    attachments.push(...collectOutputUrlAttachments(nestedValue, seen));
+  }
+
+  return attachments;
+};
+
+let mergeAttachments = (
+  explicitAttachments: SlateAttachment[] | undefined,
+  output: unknown
+): SlateAttachment[] | undefined => {
+  let attachments = [...(explicitAttachments ?? [])];
+  let seen = new Set(attachments.map(attachment => JSON.stringify(attachment)));
+
+  for (let attachment of collectOutputUrlAttachments(output)) {
+    let key = JSON.stringify(attachment);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    attachments.push(attachment);
+  }
+
+  return attachments.length > 0 ? attachments : undefined;
+};
+
+let toErrorMetadata = (error: unknown) => {
+  if (error instanceof Error) {
+    return {
+      errorName: error.name,
+      errorMessage: error.message,
+      errorStack: error.stack
+    };
+  }
+
+  return {
+    errorValue: String(error)
+  };
+};
+
+let formatEntityLabel = (name: string, key: string) => `"${name}" (${key})`;
+let resolveTraceMessage = <ResultType>(
+  message: string | ((result: ResultType) => string),
+  result: ResultType
+) => (typeof message === 'function' ? message(result) : message);
 
 export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
@@ -15,10 +126,69 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
     let auth = new State<{ authenticationMethodId: string; output: AuthType } | null>(null);
     let config = new State<{ value: ConfigType } | null>(null);
-
     let session = new State<{ id: string; state: any } | null>(null);
 
     let logger = new SlateLogger(listeners);
+    let providerTrace = {
+      providerId: slate.spec.key,
+      providerName: slate.spec.name
+    };
+
+    let traceProviderCall = async <ResultType>(
+      trace: {
+        component: 'config' | 'auth' | 'action';
+        functionName: string;
+        message: string;
+        successMessage: string | ((result: ResultType) => string);
+        errorMessage?: string;
+        metadata?: Record<string, unknown>;
+        onSuccess?: (result: ResultType) => Record<string, unknown> | undefined;
+      },
+      handler: () => Promise<ResultType>
+    ): Promise<ResultType> => {
+      let startedAt = Date.now();
+
+      logger.info({
+        ...providerTrace,
+        ...trace.metadata,
+        component: trace.component,
+        functionName: trace.functionName,
+        phase: 'start',
+        message: trace.message
+      });
+
+      try {
+        let result = await handler();
+        let successMessage = resolveTraceMessage(trace.successMessage, result);
+
+        logger.info({
+          ...providerTrace,
+          ...trace.metadata,
+          ...(trace.onSuccess?.(result) ?? {}),
+          component: trace.component,
+          functionName: trace.functionName,
+          phase: 'success',
+          durationMs: Date.now() - startedAt,
+          message: successMessage
+        });
+
+        return result;
+      } catch (error) {
+        logger.error({
+          ...providerTrace,
+          ...trace.metadata,
+          ...toErrorMetadata(error),
+          component: trace.component,
+          functionName: trace.functionName,
+          phase: 'error',
+          durationMs: Date.now() - startedAt,
+          message:
+            trace.errorMessage ??
+            `${typeof trace.successMessage === 'string' ? trace.successMessage : trace.message} failed`
+        });
+        throw error;
+      }
+    };
 
     let getContextBasic = () => {
       let currentProtocol = protocol.get();
@@ -65,6 +235,19 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       };
     };
 
+    let getAuthConfig = (): Record<string, any> => config.get()?.value ?? {};
+
+    let getEmptyContext = () => new SlateContext({}, {}, {}, slate.spec as any, logger);
+    let getAuthContext = () =>
+      new SlateContext(getAuthConfig(), {}, {}, slate.spec as any, logger);
+    let withRequestTraces = <Result extends Record<string, any>>(
+      context: SlatePublicContext<any>,
+      result: Result
+    ) => {
+      let requestTraces = context.getHttpTraces();
+      return requestTraces.length > 0 ? { ...result, requestTraces } : result;
+    };
+
     manager.onNotification('slates/hello', async ({ params }) => {
       protocol.set(params.protocol);
     });
@@ -133,15 +316,37 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         return { success: true, config: newConfig };
       }
 
-      let updatedConfig = await configChanged({
-        previousConfig: params.previousConfig as ConfigType | null,
-        newConfig
-      });
+      let context = getEmptyContext();
+      let updatedConfig = await traceProviderCall<{ config?: ConfigType } | undefined>(
+        {
+          component: 'config',
+          functionName: 'configChanged',
+          message: 'Running config change handler',
+          successMessage: 'Config change handler completed',
+          metadata: {
+            hasPreviousConfig: params.previousConfig !== null,
+            newConfigKeyCount: getObjectKeyCount(newConfig)
+          },
+          onSuccess: result => ({
+            returnedConfig: !!result?.config
+          })
+        },
+        () =>
+          runWithContext(context, async () =>
+            configChanged({
+              previousConfig: params.previousConfig as ConfigType | null,
+              newConfig
+            })
+          )
+      );
 
-      return { success: true, config: updatedConfig?.config ?? newConfig };
+      return withRequestTraces(context, {
+        success: true,
+        config: (updatedConfig?.config ?? newConfig) as Record<string, any>
+      });
     });
 
-    manager.onRequest('slates/config.get_default', async ({ params }) => {
+    manager.onRequest('slates/config.get_default', async () => {
       getContextBasic();
 
       let getDefaultConfig = slate.spec.config.handlers.getDefaultConfig;
@@ -149,32 +354,50 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         return { config: null };
       }
 
-      let defaultConfig = await getDefaultConfig();
-      return { config: defaultConfig };
+      let context = getEmptyContext();
+      let defaultConfig = await traceProviderCall<ConfigType>(
+        {
+          component: 'config',
+          functionName: 'getDefaultConfig',
+          message: 'Getting default config',
+          successMessage: 'Default config retrieved',
+          onSuccess: result => ({
+            configKeyCount: getObjectKeyCount(result)
+          })
+        },
+        () => runWithContext(context, async () => getDefaultConfig())
+      );
+      return withRequestTraces(context, {
+        config: (defaultConfig ?? null) as Record<string, any> | null
+      });
     });
 
-    manager.onRequest('slates/config.schema.get', async ({ params }) => {
+    manager.onRequest('slates/config.schema.get', async () => {
       getContextBasic();
 
-      return { schema: slate.spec.configSchema.toJSONSchema() };
+      return {
+        schema: toJsonSchema(slate.spec.configSchema),
+        docs: slate.spec.config.docsReferences ?? []
+      };
     });
 
-    manager.onRequest('slates/provider.identify', async ({ params }) => {
+    manager.onRequest('slates/provider.identify', async () => {
       getContextBasic();
 
       return {
-        protocol: 'slates@2026-01-01',
+        protocol: SLATES_PROTOCOL_VERSION,
         provider: {
           type: 'provider',
           id: slate.spec.key,
           name: slate.spec.name,
           description: slate.spec.description,
           metadata: slate.spec.parameters.metadata
-        }
+        },
+        docs: slate.spec.docs ?? []
       };
     });
 
-    manager.onRequest('slates/auth.methods.list', async ({ params }) => {
+    manager.onRequest('slates/auth.methods.list', async () => {
       getContextBasic();
 
       return {
@@ -199,7 +422,25 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         return { input: null };
       }
 
-      return { input: await authMethod.getDefaultInput() };
+      let context = getEmptyContext();
+      let input = await traceProviderCall(
+        {
+          component: 'auth',
+          functionName: 'getDefaultInput',
+          message: 'Getting default authentication input',
+          successMessage: 'Default authentication input retrieved',
+          metadata: {
+            authenticationMethodId: params.authenticationMethodId,
+            authenticationMethodName: authMethod.name
+          },
+          onSuccess: result => ({
+            inputKeyCount: getObjectKeyCount(result)
+          })
+        },
+        () => runWithContext(context, () => authMethod.getDefaultInput!())
+      );
+
+      return withRequestTraces(context, { input });
     });
 
     manager.onRequest('slates/auth.input.changed', async ({ params }) => {
@@ -210,12 +451,36 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         return { success: true, input: params.newInput };
       }
 
-      let updatedInput = await authMethod.onInputChanged({
-        previousInput: params.previousInput as any | null,
-        newInput: params.newInput
-      });
+      let context = getEmptyContext();
+      let updatedInput = await traceProviderCall(
+        {
+          component: 'auth',
+          functionName: 'onInputChanged',
+          message: 'Running authentication input change handler',
+          successMessage: 'Authentication input change handler completed',
+          metadata: {
+            authenticationMethodId: params.authenticationMethodId,
+            authenticationMethodName: authMethod.name,
+            hasPreviousInput: params.previousInput !== null,
+            newInputKeyCount: getObjectKeyCount(params.newInput)
+          },
+          onSuccess: result => ({
+            returnedInput: !!result?.input
+          })
+        },
+        () =>
+          runWithContext(context, () =>
+            authMethod.onInputChanged!({
+              previousInput: params.previousInput as any | null,
+              newInput: params.newInput
+            })
+          )
+      );
 
-      return { success: true, input: updatedInput?.input ?? params.newInput };
+      return withRequestTraces(context, {
+        success: true,
+        input: updatedInput?.input ?? params.newInput
+      });
     });
 
     manager.onRequest('slates/auth.output.get', async ({ params }) => {
@@ -234,8 +499,35 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       }
 
       if ('getOutput' in authMethod) {
-        let outputRes = await authMethod.getOutput({ input });
-        return { output: outputRes.output };
+        let context = getAuthContext();
+        let outputRes = await traceProviderCall(
+          {
+            component: 'auth',
+            functionName: 'getOutput',
+            message: 'Getting authentication output',
+            successMessage: 'Authentication output retrieved',
+            metadata: {
+              authenticationMethodId: params.authenticationMethodId,
+              authenticationMethodName: authMethod.name,
+              inputKeyCount: getObjectKeyCount(input)
+            },
+            onSuccess: result => ({
+              outputKeyCount: getObjectKeyCount(result.output),
+              scopeCount: result.scopes?.length ?? 0
+            })
+          },
+          () =>
+            runWithContext(context, () =>
+              authMethod.getOutput({
+                input,
+                config: getAuthConfig()
+              })
+            )
+        );
+        return withRequestTraces(context, {
+          output: outputRes.output,
+          scopes: outputRes.scopes
+        });
       }
 
       return { output: input as any };
@@ -246,20 +538,47 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let authMethod = getAuthMethod(slate, params.authenticationMethodId);
 
       if ('handleCallback' in authMethod) {
-        let callbackRes = await authMethod.handleCallback({
-          code: params.code,
-          state: params.state,
-          redirectUri: params.redirectUri,
-          input: params.input,
-          clientId: params.clientId,
-          clientSecret: params.clientSecret,
-          scopes: params.scopes
-        });
+        let context = getEmptyContext();
+        let callbackRes = await traceProviderCall(
+          {
+            component: 'auth',
+            functionName: 'handleCallback',
+            message: 'Handling authentication callback',
+            successMessage: 'Authentication callback handled',
+            metadata: {
+              authenticationMethodId: params.authenticationMethodId,
+              authenticationMethodName: authMethod.name,
+              scopeCount: params.scopes.length,
+              hasCallbackState: !!params.callbackState
+            },
+            onSuccess: result => ({
+              outputKeyCount: getObjectKeyCount(result.output),
+              returnedInput: !!result.input,
+              returnedScopeCount: result.scopes?.length
+            })
+          },
+          () =>
+            runWithContext(context, () =>
+              authMethod.handleCallback({
+                code: params.code,
+                state: params.state,
+                redirectUri: params.redirectUri,
+                input: params.input,
+                clientId: params.clientId,
+                clientSecret: params.clientSecret,
+                scopes: params.scopes,
+                callbackParams: params.callbackParams || {},
+                callbackState: params.callbackState || {},
+                config: getAuthConfig()
+              })
+            )
+        );
 
-        return {
+        return withRequestTraces(context, {
           output: callbackRes.output,
-          input: callbackRes.input
-        };
+          input: callbackRes.input,
+          scopes: callbackRes.scopes
+        });
       }
 
       throw new ServiceError(
@@ -274,19 +593,43 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let authMethod = getAuthMethod(slate, params.authenticationMethodId);
 
       if ('getAuthorizationUrl' in authMethod) {
-        let urlRes = await authMethod.getAuthorizationUrl({
-          redirectUri: params.redirectUri,
-          state: params.state,
-          input: params.input,
-          clientId: params.clientId,
-          clientSecret: params.clientSecret,
-          scopes: params.scopes
-        });
+        let context = getEmptyContext();
+        let urlRes = await traceProviderCall(
+          {
+            component: 'auth',
+            functionName: 'getAuthorizationUrl',
+            message: 'Getting authentication authorization URL',
+            successMessage: 'Authentication authorization URL retrieved',
+            metadata: {
+              authenticationMethodId: params.authenticationMethodId,
+              authenticationMethodName: authMethod.name,
+              scopeCount: params.scopes.length,
+              inputKeyCount: getObjectKeyCount(params.input)
+            },
+            onSuccess: result => ({
+              returnedInput: !!result.input,
+              hasCallbackState: !!result.callbackState
+            })
+          },
+          () =>
+            runWithContext(context, () =>
+              authMethod.getAuthorizationUrl({
+                redirectUri: params.redirectUri,
+                state: params.state,
+                input: params.input,
+                clientId: params.clientId,
+                clientSecret: params.clientSecret,
+                scopes: params.scopes,
+                config: getAuthConfig()
+              })
+            )
+        );
 
-        return {
+        return withRequestTraces(context, {
           authorizationUrl: urlRes.url,
-          input: urlRes.input
-        };
+          input: urlRes.input,
+          callbackState: urlRes.callbackState
+        });
       }
 
       throw new ServiceError(
@@ -301,15 +644,47 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let authMethod = getAuthMethod(slate, params.authenticationMethodId);
 
       if (authMethod.getProfile) {
-        let profileRes = await authMethod.getProfile({
-          output: params.output as any,
-          input: params.input,
-          scopes: params.scopes
-        });
+        let context = getAuthContext();
+        let profileRes = await traceProviderCall(
+          {
+            component: 'auth',
+            functionName: 'getProfile',
+            message: 'Getting authentication profile',
+            successMessage: 'Authentication profile retrieved',
+            metadata: {
+              authenticationMethodId: params.authenticationMethodId,
+              authenticationMethodName: authMethod.name,
+              scopeCount: params.scopes.length,
+              inputKeyCount: getObjectKeyCount(params.input),
+              outputKeyCount: getObjectKeyCount(params.output)
+            },
+            onSuccess: result => ({
+              profileKeyCount: getObjectKeyCount(result.profile)
+            })
+          },
+          () =>
+            runWithContext(context, () => {
+              if (authMethod.type === 'auth.oauth') {
+                return authMethod.getProfile!({
+                  output: params.output as any,
+                  input: params.input,
+                  scopes: params.scopes,
+                  config: getAuthConfig()
+                });
+              }
+
+              return authMethod.getProfile!({
+                output: params.output as any,
+                input: params.input,
+                scopes: params.scopes,
+                config: getAuthConfig()
+              })!;
+            })
+        );
 
-        return {
+        return withRequestTraces(context, {
           profile: profileRes.profile
-        };
+        });
       }
 
       throw new ServiceError(
@@ -324,18 +699,53 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let authMethod = getAuthMethod(slate, params.authenticationMethodId);
 
       if ('handleTokenRefresh' in authMethod && authMethod.handleTokenRefresh) {
-        let refreshRes = await authMethod.handleTokenRefresh({
-          output: params.output as any,
-          input: params.input,
-          clientId: params.clientId,
-          clientSecret: params.clientSecret,
-          scopes: params.scopes
-        });
+        let context = getAuthContext();
+        let refreshRes = await traceProviderCall(
+          {
+            component: 'auth',
+            functionName: 'handleTokenRefresh',
+            message: 'Refreshing authentication token',
+            successMessage: 'Authentication token refreshed',
+            metadata: {
+              authenticationMethodId: params.authenticationMethodId,
+              authenticationMethodName: authMethod.name,
+              scopeCount: params.scopes.length,
+              inputKeyCount: getObjectKeyCount(params.input),
+              outputKeyCount: getObjectKeyCount(params.output)
+            },
+            onSuccess: result => ({
+              refreshedOutputKeyCount: getObjectKeyCount(result.output),
+              returnedInput: !!result.input
+            })
+          },
+          () =>
+            runWithContext(context, () => {
+              if (authMethod.type === 'auth.oauth') {
+                return authMethod.handleTokenRefresh!({
+                  output: params.output as any,
+                  input: params.input,
+                  clientId: params.clientId,
+                  clientSecret: params.clientSecret,
+                  scopes: params.scopes,
+                  config: getAuthConfig()
+                });
+              }
+
+              return authMethod.handleTokenRefresh!({
+                output: params.output as any,
+                input: params.input,
+                clientId: params.clientId,
+                clientSecret: params.clientSecret,
+                scopes: params.scopes,
+                config: getAuthConfig()
+              });
+            })
+        );
 
-        return {
+        return withRequestTraces(context, {
           output: refreshRes.output,
           input: refreshRes.input
-        };
+        });
       }
 
       throw new ServiceError(
@@ -348,8 +758,29 @@ 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);
+
       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)
       };
     });
 
@@ -363,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(
@@ -373,11 +803,47 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         `Invalid input for tool ID: ${params.actionId}`
       );
 
-      let res = await action.handleInvocation(
+      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
+            })
+          },
+          () => runWithContext(context, () => action.handleInvocation(context as any))
+        );
+
+        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 { output: res.output, message: res.message };
     });
 
     manager.onRequest('slates/action.trigger.map_event', async ({ params }) => {
@@ -391,11 +857,31 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         `Invalid event for trigger ID: ${params.actionId}`
       );
 
-      let res = await action.handleEvent(
-        new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger)
+      let context = new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger);
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'handleEvent',
+          message: `Mapping event for trigger ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: result =>
+            `Mapped trigger event "${result.type}" for ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while mapping an event`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type,
+            inputKeyCount: getObjectKeyCount(input)
+          },
+          onSuccess: result => ({
+            eventType: result.type,
+            hasEventId: !!result.id,
+            outputKeyCount: getObjectKeyCount(result.output)
+          })
+        },
+        () => runWithContext(context, () => action.handleEvent(context))
       );
 
-      return { id: res.id, type: res.type, output: res.output };
+      return withRequestTraces(context, { id: res.id, type: res.type, output: res.output });
     });
 
     manager.onRequest('slates/action.trigger.poll_events', async ({ params }) => {
@@ -410,17 +896,39 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let res = await action.pollEvents(
-        new SlateContext(
-          ctx.config,
-          { state: params.state },
-          ctx.auth?.output!,
-          slate.spec,
-          logger
-        )
+      let context = new SlateContext(
+        ctx.config,
+        { state: params.state },
+        ctx.auth?.output!,
+        slate.spec,
+        logger
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'pollEvents',
+          message: `Polling events for trigger ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: result =>
+            `Polled ${result.inputs.length} event(s) for trigger ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while polling events`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type,
+            hasPreviousState: params.state !== null
+          },
+          onSuccess: result => ({
+            inputCount: result.inputs.length,
+            hasUpdatedState: result.updatedState !== undefined
+          })
+        },
+        () => runWithContext(context, () => action.pollEvents!(context))
       );
 
-      return { inputs: res.inputs, updatedState: res.updatedState };
+      return withRequestTraces(context, {
+        inputs: res.inputs,
+        updatedState: res.updatedState
+      });
     });
 
     manager.onRequest('slates/action.trigger.webhook_handle', async ({ params }) => {
@@ -443,17 +951,52 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           : null
       });
 
-      let res = await action.handleRequest(
-        new SlateContext(
-          ctx.config,
-          { request: req, state: params.state },
-          ctx.auth?.output!,
-          slate.spec,
-          logger
-        )
+      let context = new SlateContext(
+        ctx.config,
+        {
+          request: req,
+          state: params.state,
+          registrationDetails: params.registrationDetails ?? null
+        },
+        ctx.auth?.output!,
+        slate.spec,
+        logger
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'handleRequest',
+          message: `Handling webhook request for trigger ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: result =>
+            `Received ${result.inputs.length} webhook event(s) for trigger ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while handling a webhook request`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type,
+            requestMethod: params.method,
+            hasRequestBody: !!params.body,
+            hasPreviousState: params.state !== null
+          },
+          onSuccess: result => ({
+            inputCount: result.inputs.length,
+            hasUpdatedState: result.updatedState !== undefined,
+            hasResponse: result.response !== undefined
+          })
+        },
+        () => runWithContext(context, () => action.handleRequest!(context))
       );
 
-      return { inputs: res.inputs, updatedState: res.updatedState };
+      let response =
+        res.response === undefined
+          ? undefined
+          : await serializeWebhookHttpResponse(res.response);
+
+      return withRequestTraces(context, {
+        inputs: res.inputs,
+        updatedState: res.updatedState,
+        response
+      });
     });
 
     manager.onRequest('slates/action.trigger.webhook_register', async ({ params }) => {
@@ -468,17 +1011,37 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let res = await action.autoRegisterWebhook(
-        new SlateContext(
-          ctx.config,
-          { webhookBaseUrl: params.webhookBaseUrl },
-          ctx.auth?.output!,
-          slate.spec,
-          logger
-        )
+      let context = new SlateContext(
+        ctx.config,
+        { webhookBaseUrl: params.webhookBaseUrl },
+        ctx.auth?.output!,
+        slate.spec,
+        logger
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'autoRegisterWebhook',
+          message: `Registering webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: `Registered webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while registering a webhook`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type
+          },
+          onSuccess: result => ({
+            hasRegistrationDetails: result.registrationDetails !== undefined,
+            hasState: result.state !== undefined
+          })
+        },
+        () => runWithContext(context, () => action.autoRegisterWebhook!(context))
       );
 
-      return { registrationDetails: res.registrationDetails, state: res.state };
+      return withRequestTraces(context, {
+        registrationDetails: res.registrationDetails,
+        state: res.state
+      });
     });
 
     manager.onRequest('slates/action.trigger.webhook_unregister', async ({ params }) => {
@@ -493,20 +1056,35 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      await action.autoUnregisterWebhook(
-        new SlateContext(
-          ctx.config,
-          {
-            webhookBaseUrl: params.webhookBaseUrl,
-            registrationDetails: params.registrationDetails,
-            state: params.state
-          },
-          ctx.auth?.output!,
-          slate.spec,
-          logger
-        )
+      let context = new SlateContext(
+        ctx.config,
+        {
+          webhookBaseUrl: params.webhookBaseUrl,
+          registrationDetails: params.registrationDetails,
+          state: params.state
+        },
+        ctx.auth?.output!,
+        slate.spec,
+        logger
+      );
+      await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'autoUnregisterWebhook',
+          message: `Unregistering webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
+          successMessage: `Unregistered webhook for trigger ${formatEntityLabel(action.name, action.key)}`,
+          errorMessage: `Trigger ${formatEntityLabel(action.name, action.key)} failed while unregistering a webhook`,
+          metadata: {
+            actionId: action.key,
+            actionName: action.name,
+            actionType: action.type,
+            hasRegistrationDetails: params.registrationDetails !== null,
+            hasPreviousState: params.state !== null
+          }
+        },
+        () => runWithContext(context, () => action.autoUnregisterWebhook!(context))
       );
 
-      return {};
+      return withRequestTraces(context, {});
     });
   });