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

package/dist/index.cjs

@@ -1,2 +1,1475 @@
-var e=require("@lowerdeck/error"),t=require("@slates/proto"),r=require("@slates/provider");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var o=/*#__PURE__*/n(require("zod"));function i(e,t){if(!{}.hasOwnProperty.call(e,t))throw new TypeError("attempted to use private field on non-instance");return e}var a=0;function u(e){return"__private_"+a+++"_"+e}function s(){return s=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var n in r)({}).hasOwnProperty.call(r,n)&&(e[n]=r[n])}return e},s.apply(null,arguments)}function c(e){var t=function(e){if("object"!=typeof e||!e)return e;var t=e[Symbol.toPrimitive];if(void 0!==t){var r=t.call(e,"string");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(e);return"symbol"==typeof t?t:t+""}var l=function(t,r,n,o){var i=t.safeParse(r);if(!i.success)throw new e.ServiceError(function(t,r,n){return e.validationError({message:r,entity:t,errors:n.issues.map(function(e){return s({},e,{path:e.path.map(function(e){return String(e)})})})})}(n,o,i.error));return i.data},p=function(e){return e.toJSONSchema({unrepresentable:"any",override:function(e){var t=e.zodSchema._zod.def;"date"===t.type&&(e.jsonSchema.type="string",e.jsonSchema.format="date-time"),"bigint"===t.type&&(e.jsonSchema.type="number")}})},h=function(t,r){var n=t.spec.auth.authStack.find(function(e){return e.key==r});if(!n)throw new e.ServiceError(e.badRequestError({message:"Invalid authentication method ID: "+r}));return n},d=function(e,t){var r;return{id:t.key,name:t.name,type:t.type,scopes:"scopes"in t?t.scopes.map(function(e){return{id:e.scope,title:e.title,description:e.description}}):void 0,inputSchema:p(null!=(r=t.inputSchema)?r:o.default.object({})),outputSchema:p(e.spec.auth.outputSchema),capabilities:{getDefaultInput:{enabled:!(!("getDefaultInput"in t)||!t.getDefaultInput)},handleTokenRefresh:{enabled:!(!("handleTokenRefresh"in t)||!t.handleTokenRefresh)},handleChangedInput:{enabled:!!t.onInputChanged},getProfile:{enabled:!!t.getProfile}}}},f=function(t,r){var n=t.actions.find(function(e){return e.key==r});if(!n)throw new e.ServiceError(e.notFoundError("action",r));return n},v=function(t,r,n){var o=f(t,n);if(o.type!=r)throw new e.ServiceError(e.badRequestError({message:"Action with ID "+n+" is not of type "+r}));return o},m=function(e,t){var n;return s({},{id:t.key,name:t.name,description:t.description,instructions:t.instructions,constraints:t.constraints,tags:t.tags,metadata:t.metadata,inputSchema:p(t.inputSchema),outputSchema:p(t.outputSchema)},"tool"==t.type?{type:"action.tool",capabilities:{}}:{type:"action.trigger",capabilities:{},invocation:"polling"==t.source?{type:"polling",intervalSeconds:null!=(n=t.polling.intervalInSeconds)?n:r.SlateDefaultPollingIntervalSeconds}:{type:"webhook",autoRegistration:!!t.autoRegisterWebhook,autoUnregistration:!!t.autoUnregisterWebhook}})},g=/*#__PURE__*/u("value"),P=/*#__PURE__*/function(){function e(e){Object.defineProperty(this,g,{writable:!0,value:void 0}),i(this,g)[g]=e}var t,r,n=e.prototype;return n.get=function(){return i(this,g)[g]},n.set=function(e){i(this,g)[g]=e},t=e,(r=[{key:"value",get:function(){return i(this,g)[g]}}])&&function(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,c(n.key),n)}}(t.prototype,r),Object.defineProperty(t,"prototype",{writable:!1}),t}();exports.createProviderHandler=function(n,o){return t.createSlatesProviderProtoHandler(function(t){try{var i=new P(null),a=new P(null),u=new P(null),c=new P(null),g=new P(null),y=new r.SlateLogger(o),w=function(){var t=i.get(),r=a.get();if(!t||!r)throw new e.ServiceError(e.preconditionFailedError({message:"Connection context has not been initialized"}));return{protocol:t,participants:r}},I=function(){var t=w(),r=c.get(),o=g.get(),i=u.get();if(!r||!o||!i&&n.spec.auth.authStack.length>0)throw new e.ServiceError(e.preconditionFailedError({message:"Session context has not been initialized"}));return s({},t,{config:r.value,session:o,auth:i})};return t.onNotification("slates/hello",function(e){var t=e.params;try{return i.set(t.protocol),Promise.resolve()}catch(e){return Promise.reject(e)}}),t.onNotification("slates/participant.set",function(t){var r=t.params;try{if(!i.get())throw new e.ServiceError(e.preconditionFailedError({message:"Connection protocol has not been initialized"}));return a.set(r.participants),Promise.resolve()}catch(e){return Promise.reject(e)}}),t.onNotification("slates/auth.set",function(e){var t=e.params;try{w(),h(n,t.authenticationMethodId);var r=l(n.spec.authSchema,t.output,"auth","Invalid authentication output for method ID: "+t.authenticationMethodId);return u.set({authenticationMethodId:t.authenticationMethodId,output:r}),Promise.resolve()}catch(e){return Promise.reject(e)}}),t.onNotification("slates/config.set",function(e){var t=e.params;try{w();var r=l(n.spec.configSchema,t.config,"config","Invalid configuration");return c.set({value:r}),Promise.resolve()}catch(e){return Promise.reject(e)}}),t.onNotification("slates/session.start",function(e){var t=e.params;try{return w(),g.set({id:t.sessionId,state:t.state}),Promise.resolve()}catch(e){return Promise.reject(e)}}),t.onRequest("slates/config.changed",function(e){var t=e.params;try{w();var r=l(n.spec.config.configSchema,t.newConfig,"config","Invalid configuration"),o=n.spec.config.handlers.configChanged;return o?Promise.resolve(o({previousConfig:t.previousConfig,newConfig:r})).then(function(e){var t;return{success:!0,config:null!=(t=null==e?void 0:e.config)?t:r}}):Promise.resolve({success:!0,config:r})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/config.get_default",function(e){try{w();var t=n.spec.config.handlers.getDefaultConfig;return t?Promise.resolve(t()).then(function(e){return{config:e}}):Promise.resolve({config:null})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/config.schema.get",function(e){try{return w(),Promise.resolve({schema:p(n.spec.configSchema)})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/provider.identify",function(e){try{return w(),Promise.resolve({protocol:"slates@2026-01-01",provider:{type:"provider",id:n.spec.key,name:n.spec.name,description:n.spec.description,metadata:n.spec.parameters.metadata}})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.methods.list",function(e){try{return w(),Promise.resolve({authenticationMethods:n.spec.auth.authStack.map(function(e){return d(n,e)})})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.method.get",function(e){var t=e.params;try{w();var r=h(n,t.authenticationMethodId);return Promise.resolve({authenticationMethod:d(n,r)})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.input.get_default",function(e){var t=e.params;try{w();var r=h(n,t.authenticationMethodId);return r.getDefaultInput?Promise.resolve(r.getDefaultInput()).then(function(e){return{input:e}}):Promise.resolve({input:null})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.input.changed",function(e){var t=e.params;try{w();var r=h(n,t.authenticationMethodId);return r.onInputChanged?Promise.resolve(r.onInputChanged({previousInput:t.previousInput,newInput:t.newInput})).then(function(e){var r;return{success:!0,input:null!=(r=null==e?void 0:e.input)?r:t.newInput}}):Promise.resolve({success:!0,input:t.newInput})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.output.get",function(e){var t=e.params;try{var r,o=function(e){return r?e:{output:a}};w();var i=h(n,t.authenticationMethodId),a=t.input;i.inputSchema&&(a=l(i.inputSchema,a,"auth","Invalid authentication input for method ID: "+t.authenticationMethodId));var u=function(){if("getOutput"in i)return Promise.resolve(i.getOutput({input:a})).then(function(e){return r=1,{output:e.output}})}();return Promise.resolve(u&&u.then?u.then(o):o(u))}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.authorization_callback.handle",function(t){var r=t.params;try{var o,i=function(t){if(o)return t;throw new e.ServiceError(e.preconditionFailedError({message:"Authentication method does not support authorization callback handling: "+r.authenticationMethodId}))};w();var a=h(n,r.authenticationMethodId),u=function(){if("handleCallback"in a)return Promise.resolve(a.handleCallback({code:r.code,state:r.state,redirectUri:r.redirectUri,input:r.input,clientId:r.clientId,clientSecret:r.clientSecret,scopes:r.scopes})).then(function(e){return o=1,{output:e.output,input:e.input}})}();return Promise.resolve(u&&u.then?u.then(i):i(u))}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.authorization_url.get",function(t){var r=t.params;try{var o,i=function(t){if(o)return t;throw new e.ServiceError(e.preconditionFailedError({message:"Authentication method does not support authorization URL retrieval: "+r.authenticationMethodId}))};w();var a=h(n,r.authenticationMethodId),u=function(){if("getAuthorizationUrl"in a)return Promise.resolve(a.getAuthorizationUrl({redirectUri:r.redirectUri,state:r.state,input:r.input,clientId:r.clientId,clientSecret:r.clientSecret,scopes:r.scopes})).then(function(e){return o=1,{authorizationUrl:e.url,input:e.input}})}();return Promise.resolve(u&&u.then?u.then(i):i(u))}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.profile.get",function(t){var r=t.params;try{var o,i=function(t){if(o)return t;throw new e.ServiceError(e.preconditionFailedError({message:"Authentication method does not support profile retrieval: "+r.authenticationMethodId}))};w();var a=h(n,r.authenticationMethodId),u=function(){if(a.getProfile)return Promise.resolve(a.getProfile({output:r.output,input:r.input,scopes:r.scopes})).then(function(e){return o=1,{profile:e.profile}})}();return Promise.resolve(u&&u.then?u.then(i):i(u))}catch(e){return Promise.reject(e)}}),t.onRequest("slates/auth.token_refresh.handle",function(t){var r=t.params;try{var o,i=function(t){if(o)return t;throw new e.ServiceError(e.preconditionFailedError({message:"Authentication method does not support token refresh handling: "+r.authenticationMethodId}))};w();var a=h(n,r.authenticationMethodId),u=function(){if("handleTokenRefresh"in a&&a.handleTokenRefresh)return Promise.resolve(a.handleTokenRefresh({output:r.output,input:r.input,clientId:r.clientId,clientSecret:r.clientSecret,scopes:r.scopes})).then(function(e){return o=1,{output:e.output,input:e.input}})}();return Promise.resolve(u&&u.then?u.then(i):i(u))}catch(e){return Promise.reject(e)}}),t.onRequest("slates/actions.list",function(e){try{return w(),Promise.resolve({actions:n.actions.map(function(e){return m(0,e)})})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.get",function(e){var t=e.params;try{w();var r=f(n,t.actionId);return Promise.resolve({action:m(0,r)})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.tool.invoke",function(e){var t=e.params;try{var o,i=I(),a=v(n,"tool",t.actionId),u=l(a.inputSchema,t.input,"input","Invalid input for tool ID: "+t.actionId);return Promise.resolve(a.handleInvocation(new r.SlateContext(i.config,u,null==(o=i.auth)?void 0:o.output,n.spec,y))).then(function(e){return{output:e.output,message:e.message}})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.trigger.map_event",function(e){var t=e.params;try{var o,i=I(),a=v(n,"trigger",t.actionId),u=l(a.inputSchema,t.input,"input","Invalid event for trigger ID: "+t.actionId);return Promise.resolve(a.handleEvent(new r.SlateContext(i.config,u,null==(o=i.auth)?void 0:o.output,n.spec,y))).then(function(e){return{id:e.id,type:e.type,output:e.output}})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.trigger.poll_events",function(t){var o=t.params;try{var i,a=I(),u=v(n,"trigger",o.actionId);if(!u.pollEvents)throw new e.ServiceError(e.badRequestError({message:"Trigger action does not support polling: "+o.actionId}));return Promise.resolve(u.pollEvents(new r.SlateContext(a.config,{state:o.state},null==(i=a.auth)?void 0:i.output,n.spec,y))).then(function(e){return{inputs:e.inputs,updatedState:e.updatedState}})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.trigger.webhook_handle",function(t){var o=t.params;try{var i,a=I(),u=v(n,"trigger",o.actionId);if(!u.handleRequest)throw new e.ServiceError(e.badRequestError({message:"Trigger action does not support webhook requests: "+o.actionId}));var s=new Request(o.url,{method:o.method,headers:o.headers,body:o.body?Uint8Array.from(atob(o.body.content),function(e){return e.charCodeAt(0)}):null});return Promise.resolve(u.handleRequest(new r.SlateContext(a.config,{request:s,state:o.state},null==(i=a.auth)?void 0:i.output,n.spec,y))).then(function(e){return{inputs:e.inputs,updatedState:e.updatedState}})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.trigger.webhook_register",function(t){var o=t.params;try{var i,a=I(),u=v(n,"trigger",o.actionId);if(!u.autoRegisterWebhook)throw new e.ServiceError(e.badRequestError({message:"Trigger action does not support webhook auto-registration: "+o.actionId}));return Promise.resolve(u.autoRegisterWebhook(new r.SlateContext(a.config,{webhookBaseUrl:o.webhookBaseUrl},null==(i=a.auth)?void 0:i.output,n.spec,y))).then(function(e){return{registrationDetails:e.registrationDetails,state:e.state}})}catch(e){return Promise.reject(e)}}),t.onRequest("slates/action.trigger.webhook_unregister",function(t){var o=t.params;try{var i,a=I(),u=v(n,"trigger",o.actionId);if(!u.autoUnregisterWebhook)throw new e.ServiceError(e.badRequestError({message:"Trigger action does not support webhook auto-unregistration: "+o.actionId}));return Promise.resolve(u.autoUnregisterWebhook(new r.SlateContext(a.config,{webhookBaseUrl:o.webhookBaseUrl,registrationDetails:o.registrationDetails,state:o.state},null==(i=a.auth)?void 0:i.output,n.spec,y))).then(function(){return{}})}catch(e){return Promise.reject(e)}}),Promise.resolve()}catch(e){return Promise.reject(e)}})};
-//# sourceMappingURL=index.cjs.map
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createProviderHandler: () => createProviderHandler
+});
+module.exports = __toCommonJS(index_exports);
+var import_error4 = require("@lowerdeck/error");
+var import_proto = require("@slates/proto");
+var import_provider2 = require("@slates/provider");
+
+// src/pQueue.ts
+var import_p_queue = __toESM(require("p-queue"), 1);
+var resolveDefaultExport = (value) => {
+  let current = value;
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === "function") return current;
+    if (current && typeof current === "object" && "default" in current) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  throw new TypeError("Module export is not a constructor");
+};
+var PQueue = resolveDefaultExport(import_p_queue.default);
+
+// src/spec.ts
+var import_error2 = require("@lowerdeck/error");
+var import_provider = require("@slates/provider");
+var import_zod = __toESM(require("zod"), 1);
+
+// src/validation.ts
+var import_error = require("@lowerdeck/error");
+var zodToValidationError = (entity, message, e) => {
+  return (0, import_error.validationError)({
+    message,
+    entity,
+    errors: e.issues.map((i) => ({
+      ...i,
+      path: i.path.map((p) => String(p))
+    }))
+  });
+};
+var validate = (schema, data, entity, message) => {
+  let result = schema.safeParse(data);
+  if (!result.success) {
+    throw new import_error.ServiceError(zodToValidationError(entity, message, result.error));
+  }
+  return result.data;
+};
+var toJsonSchema = (schema) => schema.toJSONSchema({
+  unrepresentable: "any",
+  override: (ctx) => {
+    let def = ctx.zodSchema._zod.def;
+    if (def.type === "date") {
+      ctx.jsonSchema.type = "string";
+      ctx.jsonSchema.format = "date-time";
+    }
+    if (def.type === "bigint") {
+      ctx.jsonSchema.type = "number";
+    }
+  }
+});
+
+// src/spec.ts
+var getAuthMethod = (slate, authenticationMethodId) => {
+  let authMethod = slate.spec.auth.authStack.find((m) => m.key === authenticationMethodId);
+  if (!authMethod) {
+    throw new import_error2.ServiceError(
+      (0, import_error2.badRequestError)({
+        message: `Invalid authentication method ID: ${authenticationMethodId}`
+      })
+    );
+  }
+  return authMethod;
+};
+var mapAuthMethod = (slate, m) => ({
+  id: m.key,
+  name: m.name,
+  type: m.type,
+  scopes: "scopes" in m ? m.scopes.map((s) => ({
+    id: s.scope,
+    title: s.title,
+    description: s.description
+  })) : void 0,
+  inputSchema: toJsonSchema(m.inputSchema ?? import_zod.default.object({})),
+  outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
+  capabilities: {
+    getDefaultInput: { enabled: !!("getDefaultInput" in m && m.getDefaultInput) },
+    handleTokenRefresh: {
+      enabled: !!("handleTokenRefresh" in m && m.handleTokenRefresh)
+    },
+    handleChangedInput: {
+      enabled: !!m.onInputChanged
+    },
+    getProfile: { enabled: !!m.getProfile }
+  },
+  docs: m.docs ?? []
+});
+var getAction = (slate, actionId) => {
+  let action = slate.actions.find((m) => m.key === actionId);
+  if (!action) {
+    throw new import_error2.ServiceError((0, import_error2.notFoundError)(`action`, actionId));
+  }
+  return action;
+};
+var getAdapter = (slate, adapterId) => {
+  let adapter = slate.adapters.find((m) => m.id === adapterId);
+  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) {
+    throw new import_error2.ServiceError(
+      (0, import_error2.badRequestError)({
+        message: `Action with ID ${actionId} is not of type ${type}`
+      })
+    );
+  }
+  return action;
+};
+var mapAction = (_slate, a) => {
+  let base = {
+    id: a.key,
+    name: a.name,
+    description: a.description,
+    instructions: a.instructions,
+    constraints: a.constraints,
+    tags: a.tags,
+    metadata: a.metadata,
+    scopes: a.scopes,
+    authMethods: a.authMethods,
+    docs: a.docs ?? [],
+    ...a.adapter ? { adapter: a.adapter } : {},
+    inputSchema: toJsonSchema(a.inputSchema),
+    outputSchema: toJsonSchema(a.outputSchema)
+  };
+  if (a.type === "tool") {
+    return {
+      ...base,
+      type: "action.tool",
+      capabilities: {},
+      isPublic: a.isPublic
+    };
+  }
+  return {
+    ...base,
+    type: "action.trigger",
+    capabilities: {},
+    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 getTriggerGroup = (slate, triggerGroupId) => {
+  let group = slate.triggerGroups.find((g) => g.key === triggerGroupId);
+  if (!group) {
+    throw new import_error2.ServiceError((0, import_error2.notFoundError)(`trigger_group`, triggerGroupId));
+  }
+  return group;
+};
+var getTriggersForGroup = (slate, triggerGroupId) => slate.actions.filter(
+  (action) => action.type === "trigger" && action.triggerGroup?.key === triggerGroupId
+);
+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) {
+    throw new import_error2.ServiceError(
+      (0, import_error2.badRequestError)({
+        message: `Trigger group does not support webhook auto-registration: ${group.key}`
+      })
+    );
+  }
+  return group.webhook.autoRegistration;
+};
+var getWebhookManualRegistration = (group) => {
+  if (group.source !== "webhook" || !group.webhook?.manualRegistration) {
+    throw new import_error2.ServiceError(
+      (0, import_error2.badRequestError)({
+        message: `Trigger group does not support manual webhook registration: ${group.key}`
+      })
+    );
+  }
+  return group.webhook.manualRegistration;
+};
+var mapTriggerGroup = (group) => ({
+  id: group.key,
+  name: group.name,
+  description: group.description,
+  metadata: group.metadata,
+  invocation: group.source === "polling" ? {
+    type: "polling",
+    intervalSeconds: group.polling?.intervalSeconds ?? import_provider.SlateDefaultPollingIntervalSeconds
+  } : {
+    type: "webhook",
+    registration: group.webhook?.manualRegistration ? {
+      mode: "manual",
+      userConfigSchema: toJsonSchema(
+        group.webhook.manualRegistration.userConfigSchema
+      ),
+      fullConfigSchema: toJsonSchema(
+        group.webhook.manualRegistration.fullConfigSchema
+      )
+    } : { mode: "auto" }
+  }
+});
+
+// src/state.ts
+var State = class {
+  #value;
+  get value() {
+    return this.#value;
+  }
+  get() {
+    return this.#value;
+  }
+  set(value) {
+    this.#value = value;
+  }
+  constructor(initialValue) {
+    this.#value = initialValue;
+  }
+};
+
+// src/webhook.ts
+var import_error3 = require("@lowerdeck/error");
+var SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES = 1024 * 1024;
+var serializeBody = (body) => {
+  if (body === null) return null;
+  if (body.byteLength > SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES) {
+    throw new import_error3.ServiceError(
+      (0, import_error3.badRequestError)({
+        message: `Webhook response body exceeds the ${SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES}-byte limit`
+      })
+    );
+  }
+  return {
+    encoding: "base64",
+    content: Buffer.from(body).toString("base64")
+  };
+};
+var headersToObject = (headers) => {
+  let result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+var validateStatus = (status) => {
+  if (!Number.isInteger(status) || status < 100 || status > 599) {
+    throw new import_error3.ServiceError(
+      (0, import_error3.badRequestError)({
+        message: "Webhook response status must be an integer between 100 and 599"
+      })
+    );
+  }
+};
+var serializeWebhookHttpResponse = async (response) => {
+  if (response instanceof Response) {
+    validateStatus(response.status);
+    return {
+      status: response.status,
+      headers: headersToObject(response.headers),
+      body: serializeBody(
+        response.body === null ? null : new Uint8Array(await response.arrayBuffer())
+      )
+    };
+  }
+  let status = response.status ?? 200;
+  validateStatus(status);
+  let body = typeof response.body === "string" ? new TextEncoder().encode(response.body) : response.body ?? null;
+  return {
+    status,
+    headers: response.headers ?? {},
+    body: serializeBody(body)
+  };
+};
+
+// src/index.ts
+var DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 1e8;
+var routeAttachmentsThroughDirectUpload = async (attachments, live) => {
+  if (!attachments || attachments.length === 0 || !live) return attachments;
+  let contentEntries = attachments.map((attachment, index) => ({ attachment, index })).filter((entry) => entry.attachment.content.type === "content");
+  if (contentEntries.length === 0) return attachments;
+  let queue = new PQueue({ concurrency: 10 });
+  let replacements = /* @__PURE__ */ new Map();
+  await Promise.all(
+    contentEntries.map(
+      (entry) => queue.add(async () => {
+        try {
+          let body = entry.attachment.content.type === "content" ? entry.attachment.content.encoding === "base64" ? Buffer.from(entry.attachment.content.content, "base64") : Buffer.from(entry.attachment.content.content, "utf-8") : Buffer.alloc(0);
+          replacements.set(
+            entry.index,
+            await (0, import_provider2.uploadAttachmentDirect)({
+              live,
+              mimeType: entry.attachment.mimeType,
+              body
+            })
+          );
+        } catch {
+          replacements.set(entry.index, null);
+        }
+      })
+    )
+  );
+  return attachments.map(
+    (attachment, index) => replacements.has(index) ? replacements.get(index) : attachment
+  ).filter((a) => a != null);
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var getObjectKeyCount = (value) => isRecord(value) ? Object.keys(value).length : void 0;
+var DOWNLOAD_ATTACHMENT_URL_KEYS = /* @__PURE__ */ new Set([
+  "downloadUrl",
+  "fileUrl",
+  "temporaryDownloadUrl",
+  "webContentLink"
+]);
+var isAttachmentUrl = (value) => /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+var collectOutputUrlAttachments = (value, seen = /* @__PURE__ */ new Set()) => {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => collectOutputUrlAttachments(item, seen));
+  }
+  if (!isRecord(value)) {
+    return [];
+  }
+  let attachments = [];
+  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;
+};
+var mergeAttachments = (explicitAttachments, output) => {
+  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 : void 0;
+};
+var toErrorMetadata = (error) => {
+  if (error instanceof Error) {
+    return {
+      errorName: error.name,
+      errorMessage: error.message,
+      errorStack: error.stack
+    };
+  }
+  return {
+    errorValue: String(error)
+  };
+};
+var formatEntityLabel = (name, key) => `"${name}" (${key})`;
+var resolveTraceMessage = (message, result) => typeof message === "function" ? message(result) : message;
+var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesProviderProtoHandler)(async (manager) => {
+  let protocol = new State(null);
+  let participants = new State(null);
+  let auth = new State(null);
+  let config = new State(null);
+  let session = new State(null);
+  let hubCapabilities = new State(null);
+  let liveInvocation = new State(
+    null
+  );
+  let getLiveInvocation = () => {
+    let directUpload = hubCapabilities.get()?.attachments?.directUpload;
+    let live = liveInvocation.get();
+    if (!directUpload?.enabled || !live) return null;
+    return {
+      ...live,
+      maxAttachmentSizeBytes: directUpload.maxAttachmentSizeBytes ?? DEFAULT_MAX_ATTACHMENT_SIZE_BYTES
+    };
+  };
+  let supportsTriggerGroups = () => !!hubCapabilities.get()?.triggers;
+  let logger = new import_provider2.SlateLogger(listeners);
+  let providerTrace = {
+    providerId: slate.spec.key,
+    providerName: slate.spec.name
+  };
+  let traceProviderCall = async (trace, handler) => {
+    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();
+    let currentParticipants = participants.get();
+    if (!currentProtocol || !currentParticipants) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.preconditionFailedError)({
+          message: "Connection context has not been initialized"
+        })
+      );
+    }
+    return {
+      protocol: currentProtocol,
+      participants: currentParticipants
+    };
+  };
+  let getContextFull = () => {
+    let basic = getContextBasic();
+    let currentConfig = config.get();
+    let currentSession = session.get();
+    let currentAuth = auth.get();
+    if (!currentConfig || !currentSession || !currentAuth && slate.spec.auth.authStack.length > 0) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.preconditionFailedError)({
+          message: "Session context has not been initialized"
+        })
+      );
+    }
+    return {
+      ...basic,
+      config: currentConfig.value,
+      session: currentSession,
+      auth: currentAuth
+    };
+  };
+  let getAuthConfig = () => config.get()?.value ?? {};
+  let getEmptyContext = () => new import_provider2.SlateContext({}, {}, {}, slate.spec, logger);
+  let getAuthContext = () => new import_provider2.SlateContext(getAuthConfig(), {}, {}, slate.spec, logger);
+  let withRequestTraces = (context, result) => {
+    let requestTraces = context.getHttpTraces();
+    return requestTraces.length > 0 ? { ...result, requestTraces } : result;
+  };
+  manager.onNotification("slates/hello", async ({ params }) => {
+    protocol.set(params.protocol);
+  });
+  manager.onNotification("slates/participant.set", async ({ params }) => {
+    if (!protocol.get()) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.preconditionFailedError)({ message: "Connection protocol has not been initialized" })
+      );
+    }
+    participants.set(params.participants);
+  });
+  manager.onNotification("slates/auth.set", async ({ params }) => {
+    getContextBasic();
+    getAuthMethod(slate, params.authenticationMethodId);
+    let valRes = validate(
+      slate.spec.authSchema,
+      params.output,
+      "auth",
+      `Invalid authentication output for method ID: ${params.authenticationMethodId}`
+    );
+    auth.set({
+      authenticationMethodId: params.authenticationMethodId,
+      output: valRes
+    });
+  });
+  manager.onNotification("slates/config.set", async ({ params }) => {
+    getContextBasic();
+    let value = validate(
+      slate.spec.configSchema,
+      params.config,
+      "config",
+      "Invalid configuration"
+    );
+    config.set({ value });
+  });
+  manager.onNotification("slates/session.start", async ({ params }) => {
+    getContextBasic();
+    session.set({
+      id: params.sessionId,
+      state: params.state
+    });
+  });
+  manager.onNotification("slates/hub.capabilities.set", async ({ params }) => {
+    hubCapabilities.set(params.capabilities);
+  });
+  manager.onNotification("slates/hub.live_invocation.set", async ({ params }) => {
+    liveInvocation.set({
+      token: params.token,
+      baseUrl: params.baseUrl
+    });
+  });
+  manager.onRequest("slates/provider.capabilities.get", async () => ({
+    capabilities: {
+      hub: {
+        capabilitiesNotification: true,
+        liveInvocation: true
+      },
+      provider: {
+        triggerGroups: (slate.triggerGroups?.length ?? 0) > 0 && (slate.actions ?? []).every(isMappableTrigger)
+      }
+    }
+  }));
+  manager.onRequest("slates/config.changed", async ({ params }) => {
+    getContextBasic();
+    let newConfig = validate(
+      slate.spec.config.configSchema,
+      params.newConfig,
+      "config",
+      "Invalid configuration"
+    );
+    let configChanged = slate.spec.config.handlers.configChanged;
+    if (!configChanged) {
+      return { success: true, config: newConfig };
+    }
+    let context = getEmptyContext();
+    let updatedConfig = await traceProviderCall(
+      {
+        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
+        })
+      },
+      () => (0, import_provider2.runWithContext)(
+        context,
+        async () => configChanged({
+          previousConfig: params.previousConfig,
+          newConfig
+        })
+      )
+    );
+    return withRequestTraces(context, {
+      success: true,
+      config: updatedConfig?.config ?? newConfig
+    });
+  });
+  manager.onRequest("slates/config.get_default", async () => {
+    getContextBasic();
+    let getDefaultConfig = slate.spec.config.handlers.getDefaultConfig;
+    if (!getDefaultConfig) {
+      return { config: null };
+    }
+    let context = getEmptyContext();
+    let defaultConfig = await traceProviderCall(
+      {
+        component: "config",
+        functionName: "getDefaultConfig",
+        message: "Getting default config",
+        successMessage: "Default config retrieved",
+        onSuccess: (result) => ({
+          configKeyCount: getObjectKeyCount(result)
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, async () => getDefaultConfig())
+    );
+    return withRequestTraces(context, {
+      config: defaultConfig ?? null
+    });
+  });
+  manager.onRequest("slates/config.schema.get", async () => {
+    getContextBasic();
+    return {
+      schema: toJsonSchema(slate.spec.configSchema),
+      docs: slate.spec.config.docsReferences ?? []
+    };
+  });
+  manager.onRequest("slates/provider.identify", async () => {
+    getContextBasic();
+    return {
+      protocol: import_proto.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 () => {
+    getContextBasic();
+    return {
+      authenticationMethods: slate.spec.auth.authStack.map((m) => mapAuthMethod(slate, m))
+    };
+  });
+  manager.onRequest("slates/auth.method.get", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    return {
+      authenticationMethod: mapAuthMethod(slate, authMethod)
+    };
+  });
+  manager.onRequest("slates/auth.input.get_default", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    if (!authMethod.getDefaultInput) {
+      return { input: null };
+    }
+    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)
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => authMethod.getDefaultInput())
+    );
+    return withRequestTraces(context, { input });
+  });
+  manager.onRequest("slates/auth.input.changed", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    if (!authMethod.onInputChanged) {
+      return { success: true, input: 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
+        })
+      },
+      () => (0, import_provider2.runWithContext)(
+        context,
+        () => authMethod.onInputChanged({
+          previousInput: params.previousInput,
+          newInput: params.newInput
+        })
+      )
+    );
+    return withRequestTraces(context, {
+      success: true,
+      input: updatedInput?.input ?? params.newInput
+    });
+  });
+  manager.onRequest("slates/auth.output.get", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    let input = params.input;
+    if (authMethod.inputSchema) {
+      input = validate(
+        authMethod.inputSchema,
+        input,
+        "auth",
+        `Invalid authentication input for method ID: ${params.authenticationMethodId}`
+      );
+    }
+    if ("getOutput" in authMethod) {
+      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
+          })
+        },
+        () => (0, import_provider2.runWithContext)(
+          context,
+          () => authMethod.getOutput({
+            input,
+            config: getAuthConfig()
+          })
+        )
+      );
+      return withRequestTraces(context, {
+        output: outputRes.output,
+        scopes: outputRes.scopes
+      });
+    }
+    return { output: input };
+  });
+  manager.onRequest("slates/auth.authorization_callback.handle", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    if ("handleCallback" in authMethod) {
+      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
+          })
+        },
+        () => (0, import_provider2.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 withRequestTraces(context, {
+        output: callbackRes.output,
+        input: callbackRes.input,
+        scopes: callbackRes.scopes
+      });
+    }
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
+        message: `Authentication method does not support authorization callback handling: ${params.authenticationMethodId}`
+      })
+    );
+  });
+  manager.onRequest("slates/auth.authorization_url.get", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    if ("getAuthorizationUrl" in authMethod) {
+      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
+          })
+        },
+        () => (0, import_provider2.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 withRequestTraces(context, {
+        authorizationUrl: urlRes.url,
+        input: urlRes.input,
+        callbackState: urlRes.callbackState
+      });
+    }
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
+        message: `Authentication method does not support authorization URL retrieval: ${params.authenticationMethodId}`
+      })
+    );
+  });
+  manager.onRequest("slates/auth.profile.get", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    if (authMethod.getProfile) {
+      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)
+          })
+        },
+        () => (0, import_provider2.runWithContext)(context, () => {
+          if (authMethod.type === "auth.oauth") {
+            return authMethod.getProfile({
+              output: params.output,
+              input: params.input,
+              scopes: params.scopes,
+              config: getAuthConfig()
+            });
+          }
+          return authMethod.getProfile({
+            output: params.output,
+            input: params.input,
+            scopes: params.scopes,
+            config: getAuthConfig()
+          });
+        })
+      );
+      return withRequestTraces(context, {
+        profile: profileRes.profile
+      });
+    }
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
+        message: `Authentication method does not support profile retrieval: ${params.authenticationMethodId}`
+      })
+    );
+  });
+  manager.onRequest("slates/auth.token_refresh.handle", async ({ params }) => {
+    getContextBasic();
+    let authMethod = getAuthMethod(slate, params.authenticationMethodId);
+    if ("handleTokenRefresh" in authMethod && authMethod.handleTokenRefresh) {
+      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
+          })
+        },
+        () => (0, import_provider2.runWithContext)(context, () => {
+          if (authMethod.type === "auth.oauth") {
+            return authMethod.handleTokenRefresh({
+              output: params.output,
+              input: params.input,
+              clientId: params.clientId,
+              clientSecret: params.clientSecret,
+              scopes: params.scopes,
+              config: getAuthConfig()
+            });
+          }
+          return authMethod.handleTokenRefresh({
+            output: params.output,
+            input: params.input,
+            clientId: params.clientId,
+            clientSecret: params.clientSecret,
+            scopes: params.scopes,
+            config: getAuthConfig()
+          });
+        })
+      );
+      return withRequestTraces(context, {
+        output: refreshRes.output,
+        input: refreshRes.input
+      });
+    }
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
+        message: `Authentication method does not support token refresh handling: ${params.authenticationMethodId}`
+      })
+    );
+  });
+  manager.onRequest("slates/actions.list", async ({ params }) => {
+    getContextBasic();
+    let actions = params.includeAdapterActions ? slate.actions : slate.actions.filter((action) => !action.adapter);
+    actions = actions.filter(isMappableTrigger);
+    if (!supportsTriggerGroups()) {
+      actions = actions.filter((action) => action.type !== "trigger");
+    }
+    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 {
+      adapter: mapAdapter(adapter)
+    };
+  });
+  manager.onRequest("slates/action.get", async ({ params }) => {
+    getContextBasic();
+    let action = getMappableAction(slate, params.actionId);
+    return {
+      action: mapAction(slate, action)
+    };
+  });
+  manager.onRequest("slates/trigger_groups.list", async () => {
+    getContextBasic();
+    return {
+      triggerGroups: slate.triggerGroups.map(mapTriggerGroup)
+    };
+  });
+  manager.onRequest("slates/trigger_group.get", async ({ params }) => {
+    getContextBasic();
+    let triggerGroup = getTriggerGroup(slate, params.triggerGroupId);
+    return {
+      triggerGroup: mapTriggerGroup(triggerGroup)
+    };
+  });
+  manager.onRequest("slates/action.tool.invoke", async ({ params }) => {
+    let action = getActionWithType(slate, "tool", params.actionId);
+    let input = validate(
+      action.inputSchema,
+      params.input,
+      "input",
+      `Invalid input for tool ID: ${params.actionId}`
+    );
+    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
+          })
+        },
+        () => (0, import_provider2.runWithContext)(context, () => action.handleInvocation(context))
+      );
+      let contextAttachments = await context._finalizeAttachments();
+      let merged = mergeAttachments(
+        [...res.attachments ?? [], ...contextAttachments],
+        res.output
+      );
+      let redacted = (0, import_provider2.redactUrlAttachmentSecrets)(
+        merged,
+        context._getAuthConfigForRedaction()
+      );
+      let finalAttachments = await routeAttachmentsThroughDirectUpload(
+        redacted,
+        getLiveInvocation()
+      );
+      return withRequestTraces(context, {
+        output: res.output,
+        message: res.message,
+        attachments: finalAttachments
+      });
+    };
+    if (action.isPublic) {
+      getContextBasic();
+      return invoke(new import_provider2.SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
+    }
+    let ctx = getContextFull();
+    return invoke(
+      new import_provider2.SlateContext(
+        ctx.config,
+        input,
+        ctx.auth?.output,
+        slate.spec,
+        logger,
+        getLiveInvocation()
+      )
+    );
+  });
+  manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {
+    let ctx = getContextFull();
+    let action = getActionWithType(slate, "trigger", params.actionId);
+    let input = validate(
+      action.inputSchema,
+      params.input,
+      "input",
+      `Invalid event for trigger 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: "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)
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => action.map(context))
+    );
+    return withRequestTraces(context, { id: res.id, type: res.type, output: res.output });
+  });
+  manager.onRequest("slates/action.trigger.poll_events", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Legacy trigger polling is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return { inputs: [], updatedState: params.state };
+  });
+  manager.onRequest("slates/action.trigger.webhook_handle", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Legacy trigger webhook handling is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return { inputs: [], updatedState: params.state, response: null };
+  });
+  manager.onRequest("slates/action.trigger.webhook_register", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Legacy trigger webhook registration is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return { registrationDetails: null };
+  });
+  manager.onRequest("slates/action.trigger.webhook_unregister", async ({ params }) => {
+    getContextBasic();
+    if (supportsTriggerGroups()) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Legacy trigger webhook unregistration is disabled once trigger_group support is announced: ${params.actionId}`
+        })
+      );
+    }
+    return {};
+  });
+  manager.onRequest("slates/trigger_group.webhook.targets_list", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let autoRegistration = getWebhookAutoRegistration(group);
+    let context = new import_provider2.SlateContext(
+      ctx.config,
+      { pageToken: params.pageToken ?? null },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookTargetList",
+        message: `Listing webhook targets for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Listed ${result.targets.length} webhook target(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while listing webhook targets`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
+        },
+        onSuccess: (result) => ({
+          targetCount: result.targets.length,
+          hasNextPageToken: result.nextPageToken !== null
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => autoRegistration.webhookTargetList(context))
+    );
+    return withRequestTraces(context, {
+      targets: res.targets,
+      nextPageToken: res.nextPageToken ?? null
+    });
+  });
+  manager.onRequest("slates/trigger_group.webhook.register", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let autoRegistration = getWebhookAutoRegistration(group);
+    let context = new import_provider2.SlateContext(
+      ctx.config,
+      {
+        webhookTargetIdentifier: params.webhookTargetIdentifier,
+        webhookTargetPayload: params.webhookTargetPayload,
+        webhookUrl: params.webhookUrl
+      },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookRegister",
+        message: `Registering webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Registered webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while registering a webhook`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          webhookTargetIdentifier: params.webhookTargetIdentifier
+        }
+      },
+      () => (0, import_provider2.runWithContext)(context, () => autoRegistration.webhookRegister(context))
+    );
+    return withRequestTraces(context, {
+      webhookRegistrationIdentifier: res.webhookRegistrationIdentifier,
+      webhookRegistrationPayload: res.webhookRegistrationPayload
+    });
+  });
+  manager.onRequest("slates/trigger_group.webhook.unregister", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let autoRegistration = getWebhookAutoRegistration(group);
+    let context = new import_provider2.SlateContext(
+      ctx.config,
+      {
+        webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
+        webhookRegistrationPayload: params.webhookRegistrationPayload
+      },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookUnregister",
+        message: `Unregistering webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Unregistered webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while unregistering a webhook`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          webhookRegistrationIdentifier: params.webhookRegistrationIdentifier
+        }
+      },
+      () => (0, import_provider2.runWithContext)(context, () => autoRegistration.webhookUnregister(context))
+    );
+    return withRequestTraces(context, {});
+  });
+  manager.onRequest("slates/trigger_group.webhook.manual_setup", async ({ params }) => {
+    getContextBasic();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let manualRegistration = getWebhookManualRegistration(group);
+    let context = new import_provider2.SlateContext(
+      {},
+      { webhookUrl: params.webhookUrl },
+      {},
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookManualSetup",
+        message: `Building manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Built manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while building a manual webhook setup`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
+        }
+      },
+      () => (0, import_provider2.runWithContext)(context, () => manualRegistration.setup(context))
+    );
+    return {
+      webhookSetupDocument: res.webhookSetupDocument,
+      partialWebhookRegistrationPayload: res.partialWebhookRegistrationPayload
+    };
+  });
+  manager.onRequest("slates/trigger_group.webhook.manual_finish", async ({ params }) => {
+    getContextBasic();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let manualRegistration = getWebhookManualRegistration(group);
+    if (!manualRegistration.finish) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Trigger group does not support manual webhook finish: ${params.triggerGroupId}`
+        })
+      );
+    }
+    let context = new import_provider2.SlateContext(
+      {},
+      {
+        webhookUrl: params.webhookUrl,
+        partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
+        userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
+      },
+      {},
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookManualFinish",
+        message: `Finishing manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: `Finished manual webhook setup for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while finishing a manual webhook setup`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
+        }
+      },
+      () => (0, import_provider2.runWithContext)(context, () => manualRegistration.finish(context))
+    );
+    return withRequestTraces(context, {
+      webhookRegistrationPayload: res.webhookRegistrationPayload
+    });
+  });
+  manager.onRequest("slates/trigger_group.webhook.process", async ({ params }) => {
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    if (group.source !== "webhook" || !group.webhook) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Trigger group does not support webhook processing: ${params.triggerGroupId}`
+        })
+      );
+    }
+    let req = new Request(params.url, {
+      method: params.method,
+      headers: params.headers,
+      body: params.body ? Uint8Array.from(atob(params.body.content), (c) => c.charCodeAt(0)) : null
+    });
+    let context = new import_provider2.SlateContext(
+      {},
+      {
+        request: req,
+        webhookRegistrationPayload: params.webhookRegistrationPayload
+      },
+      {},
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "webhookProcess",
+        message: `Processing webhook request for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Extracted ${result.events.length} event(s) from webhook request for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while processing a webhook request`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          requestMethod: params.method,
+          hasRequestBody: !!params.body
+        },
+        onSuccess: (result) => ({
+          eventCount: result.events.length,
+          hasResponse: result.response !== void 0
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => group.webhook.process(context))
+    );
+    for (let event of res.events) {
+      if (!event.matchers) {
+        throw new import_error4.ServiceError(
+          (0, import_error4.preconditionFailedError)({
+            message: `Trigger group "${group.key}" process handler must return matchers for every event (return [] if there is nothing to assert)`
+          })
+        );
+      }
+    }
+    let response = res.response === void 0 ? void 0 : await serializeWebhookHttpResponse(res.response);
+    return withRequestTraces(context, {
+      events: res.events.map((event) => ({
+        matchers: event.matchers,
+        payload: event.payload,
+        idempotencyKey: event.idempotencyKey,
+        triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+      })),
+      response
+    });
+  });
+  manager.onRequest("slates/trigger_group.routing_matchers.get", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    let context = new import_provider2.SlateContext(ctx.config, {}, ctx.auth?.output, slate.spec, logger);
+    let matchers = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "routingMatchers",
+        message: `Getting routing matchers for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Retrieved ${result.length} routing matcher(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while getting routing matchers`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name
+        },
+        onSuccess: (result) => ({
+          matcherCount: result.length
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => group.routingMatchers(context))
+    );
+    return withRequestTraces(context, { matchers });
+  });
+  manager.onRequest("slates/trigger_group.polling.poll", async ({ params }) => {
+    let ctx = getContextFull();
+    let group = getTriggerGroup(slate, params.triggerGroupId);
+    if (group.source !== "polling" || !group.polling) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Trigger group does not support polling: ${params.triggerGroupId}`
+        })
+      );
+    }
+    let context = new import_provider2.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 group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Polled ${result.events.length} event(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while polling events`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          hasPreviousState: params.state !== null
+        },
+        onSuccess: (result) => ({
+          eventCount: result.events.length,
+          hasUpdatedState: result.updatedState !== void 0
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => group.polling.pollEvents(context))
+    );
+    return withRequestTraces(context, {
+      updatedState: res.updatedState,
+      events: res.events.map((event) => ({
+        payload: event.payload,
+        idempotencyKey: event.idempotencyKey,
+        triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+      }))
+    });
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProviderHandler
+});