@slates/provider-handler 1.0.0-rc.42 → 1.0.0-rc.43

package/dist/index.cjs

@@ -454,6 +454,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   let liveInvocation = new State(
     null
   );
+  let runtimeInfo = new State(null);
   let getLiveInvocation = () => {
     let directUpload = hubCapabilities.get()?.attachments?.directUpload;
     let live = liveInvocation.get();
@@ -543,8 +544,17 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     };
   };
   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 createContext = (config2, input, auth2, liveInvocationInfo = null) => new import_provider2.SlateContext(
+    config2,
+    input,
+    auth2,
+    slate.spec,
+    logger,
+    liveInvocationInfo,
+    runtimeInfo.get()
+  );
+  let getEmptyContext = () => createContext({}, {}, {});
+  let getAuthContext = () => createContext(getAuthConfig(), {}, {});
   let withRequestTraces = (context, result) => {
     let requestTraces = context.getHttpTraces();
     return requestTraces.length > 0 ? { ...result, requestTraces } : result;
@@ -651,11 +661,15 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       baseUrl: params.baseUrl
     });
   });
+  manager.onNotification("slates/hub.runtime_info.set", async ({ params }) => {
+    runtimeInfo.set(params.runtimeInfo);
+  });
   manager.onRequest("slates/provider.capabilities.get", async () => ({
     capabilities: {
       hub: {
         capabilitiesNotification: true,
-        liveInvocation: true
+        liveInvocation: true,
+        runtimeInfo: true
       },
       provider: {
         triggerGroups: (slate.triggerGroups?.length ?? 0) > 0 && (slate.actions ?? []).every(isMappableTrigger),
@@ -1214,19 +1228,18 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     };
     if (action.isPublic) {
       getContextBasic();
-      return invoke(new import_provider2.SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
+      return invoke(
+        new import_provider2.SlatePublicContext(
+          input,
+          slate.spec,
+          logger,
+          getLiveInvocation(),
+          runtimeInfo.get()
+        )
+      );
     }
     let ctx = getContextFull();
-    return invoke(
-      new import_provider2.SlateContext(
-        ctx.config,
-        input,
-        ctx.auth?.output,
-        slate.spec,
-        logger,
-        getLiveInvocation()
-      )
-    );
+    return invoke(createContext(ctx.config, input, ctx.auth?.output, getLiveInvocation()));
   });
   manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {
     let ctx = getContextFull();
@@ -1237,7 +1250,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       "input",
       `Invalid event for trigger ID: ${params.actionId}`
     );
-    let context = new import_provider2.SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger);
+    let context = createContext(ctx.config, input, ctx.auth?.output);
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1309,12 +1322,10 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let autoRegistration = getWebhookAutoRegistration(group);
-    let context = new import_provider2.SlateContext(
+    let context = createContext(
       ctx.config,
       { pageToken: params.pageToken ?? null },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     let res = await traceProviderCall(
       {
@@ -1344,16 +1355,14 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let autoRegistration = getWebhookAutoRegistration(group);
-    let context = new import_provider2.SlateContext(
+    let context = createContext(
       ctx.config,
       {
         webhookTargetIdentifier: params.webhookTargetIdentifier,
         webhookTargetPayload: params.webhookTargetPayload,
         webhookUrl: params.webhookUrl
       },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     let res = await traceProviderCall(
       {
@@ -1379,15 +1388,13 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let autoRegistration = getWebhookAutoRegistration(group);
-    let context = new import_provider2.SlateContext(
+    let context = createContext(
       ctx.config,
       {
         webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
         webhookRegistrationPayload: params.webhookRegistrationPayload
       },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     await traceProviderCall(
       {
@@ -1410,13 +1417,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     getContextBasic();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let manualRegistration = getWebhookManualRegistration(group);
-    let context = new import_provider2.SlateContext(
-      {},
-      { webhookUrl: params.webhookUrl },
-      {},
-      slate.spec,
-      logger
-    );
+    let context = createContext({}, { webhookUrl: params.webhookUrl }, {});
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1447,16 +1448,14 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         })
       );
     }
-    let context = new import_provider2.SlateContext(
+    let context = createContext(
       {},
       {
         webhookUrl: params.webhookUrl,
         partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
         userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
       },
-      {},
-      slate.spec,
-      logger
+      {}
     );
     let res = await traceProviderCall(
       {
@@ -1490,15 +1489,13 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       headers: params.headers,
       body: params.body ? Uint8Array.from(atob(params.body.content), (c) => c.charCodeAt(0)) : null
     });
-    let context = new import_provider2.SlateContext(
+    let context = createContext(
       {},
       {
         request: req,
         webhookRegistrationPayload: params.webhookRegistrationPayload
       },
-      {},
-      slate.spec,
-      logger
+      {}
     );
     let res = await traceProviderCall(
       {
@@ -1545,7 +1542,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   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 context = createContext(ctx.config, {}, ctx.auth?.output);
     let matchers = await traceProviderCall(
       {
         component: "action",
@@ -1575,13 +1572,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         })
       );
     }
-    let context = new import_provider2.SlateContext(
-      ctx.config,
-      { state: params.state },
-      ctx.auth?.output,
-      slate.spec,
-      logger
-    );
+    let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output);
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1624,13 +1615,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   manager.onRequest("slates/trigger_group.gateway.connect", async ({ params }) => {
     let ctx = getContextFull();
     let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
-    let context = new import_provider2.SlateContext(
-      ctx.config,
-      { state: params.state },
-      ctx.auth?.output,
-      slate.spec,
-      logger
-    );
+    let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output);
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1651,12 +1636,10 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   manager.onRequest("slates/trigger_group.gateway.receive", async ({ params }) => {
     let ctx = getContextFull();
     let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
-    let context = new import_provider2.SlateContext(
+    let context = createContext(
       ctx.config,
       { state: params.state, frames: params.frames, closed: params.closed ?? null },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     let res = await traceProviderCall(
       {

package/dist/index.module.js

@@ -438,6 +438,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   let liveInvocation = new State(
     null
   );
+  let runtimeInfo = new State(null);
   let getLiveInvocation = () => {
     let directUpload = hubCapabilities.get()?.attachments?.directUpload;
     let live = liveInvocation.get();
@@ -527,8 +528,17 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     };
   };
   let getAuthConfig = () => config.get()?.value ?? {};
-  let getEmptyContext = () => new SlateContext({}, {}, {}, slate.spec, logger);
-  let getAuthContext = () => new SlateContext(getAuthConfig(), {}, {}, slate.spec, logger);
+  let createContext = (config2, input, auth2, liveInvocationInfo = null) => new SlateContext(
+    config2,
+    input,
+    auth2,
+    slate.spec,
+    logger,
+    liveInvocationInfo,
+    runtimeInfo.get()
+  );
+  let getEmptyContext = () => createContext({}, {}, {});
+  let getAuthContext = () => createContext(getAuthConfig(), {}, {});
   let withRequestTraces = (context, result) => {
     let requestTraces = context.getHttpTraces();
     return requestTraces.length > 0 ? { ...result, requestTraces } : result;
@@ -635,11 +645,15 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       baseUrl: params.baseUrl
     });
   });
+  manager.onNotification("slates/hub.runtime_info.set", async ({ params }) => {
+    runtimeInfo.set(params.runtimeInfo);
+  });
   manager.onRequest("slates/provider.capabilities.get", async () => ({
     capabilities: {
       hub: {
         capabilitiesNotification: true,
-        liveInvocation: true
+        liveInvocation: true,
+        runtimeInfo: true
       },
       provider: {
         triggerGroups: (slate.triggerGroups?.length ?? 0) > 0 && (slate.actions ?? []).every(isMappableTrigger),
@@ -1198,19 +1212,18 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     };
     if (action.isPublic) {
       getContextBasic();
-      return invoke(new SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
+      return invoke(
+        new SlatePublicContext(
+          input,
+          slate.spec,
+          logger,
+          getLiveInvocation(),
+          runtimeInfo.get()
+        )
+      );
     }
     let ctx = getContextFull();
-    return invoke(
-      new SlateContext(
-        ctx.config,
-        input,
-        ctx.auth?.output,
-        slate.spec,
-        logger,
-        getLiveInvocation()
-      )
-    );
+    return invoke(createContext(ctx.config, input, ctx.auth?.output, getLiveInvocation()));
   });
   manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {
     let ctx = getContextFull();
@@ -1221,7 +1234,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       "input",
       `Invalid event for trigger ID: ${params.actionId}`
     );
-    let context = new SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger);
+    let context = createContext(ctx.config, input, ctx.auth?.output);
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1293,12 +1306,10 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let autoRegistration = getWebhookAutoRegistration(group);
-    let context = new SlateContext(
+    let context = createContext(
       ctx.config,
       { pageToken: params.pageToken ?? null },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     let res = await traceProviderCall(
       {
@@ -1328,16 +1339,14 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let autoRegistration = getWebhookAutoRegistration(group);
-    let context = new SlateContext(
+    let context = createContext(
       ctx.config,
       {
         webhookTargetIdentifier: params.webhookTargetIdentifier,
         webhookTargetPayload: params.webhookTargetPayload,
         webhookUrl: params.webhookUrl
       },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     let res = await traceProviderCall(
       {
@@ -1363,15 +1372,13 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let autoRegistration = getWebhookAutoRegistration(group);
-    let context = new SlateContext(
+    let context = createContext(
       ctx.config,
       {
         webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
         webhookRegistrationPayload: params.webhookRegistrationPayload
       },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     await traceProviderCall(
       {
@@ -1394,13 +1401,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     getContextBasic();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let manualRegistration = getWebhookManualRegistration(group);
-    let context = new SlateContext(
-      {},
-      { webhookUrl: params.webhookUrl },
-      {},
-      slate.spec,
-      logger
-    );
+    let context = createContext({}, { webhookUrl: params.webhookUrl }, {});
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1431,16 +1432,14 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         })
       );
     }
-    let context = new SlateContext(
+    let context = createContext(
       {},
       {
         webhookUrl: params.webhookUrl,
         partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
         userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
       },
-      {},
-      slate.spec,
-      logger
+      {}
     );
     let res = await traceProviderCall(
       {
@@ -1474,15 +1473,13 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       headers: params.headers,
       body: params.body ? Uint8Array.from(atob(params.body.content), (c) => c.charCodeAt(0)) : null
     });
-    let context = new SlateContext(
+    let context = createContext(
       {},
       {
         request: req,
         webhookRegistrationPayload: params.webhookRegistrationPayload
       },
-      {},
-      slate.spec,
-      logger
+      {}
     );
     let res = await traceProviderCall(
       {
@@ -1529,7 +1526,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/trigger_group.routing_matchers.get", async ({ params }) => {
     let ctx = getContextFull();
     let group = getTriggerGroup(slate, params.triggerGroupId);
-    let context = new SlateContext(ctx.config, {}, ctx.auth?.output, slate.spec, logger);
+    let context = createContext(ctx.config, {}, ctx.auth?.output);
     let matchers = await traceProviderCall(
       {
         component: "action",
@@ -1559,13 +1556,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         })
       );
     }
-    let context = new SlateContext(
-      ctx.config,
-      { state: params.state },
-      ctx.auth?.output,
-      slate.spec,
-      logger
-    );
+    let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output);
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1608,13 +1599,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/trigger_group.gateway.connect", async ({ params }) => {
     let ctx = getContextFull();
     let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
-    let context = new SlateContext(
-      ctx.config,
-      { state: params.state },
-      ctx.auth?.output,
-      slate.spec,
-      logger
-    );
+    let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output);
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1635,12 +1620,10 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/trigger_group.gateway.receive", async ({ params }) => {
     let ctx = getContextFull();
     let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
-    let context = new SlateContext(
+    let context = createContext(
       ctx.config,
       { state: params.state, frames: params.frames, closed: params.closed ?? null },
-      ctx.auth?.output,
-      slate.spec,
-      logger
+      ctx.auth?.output
     );
     let res = await traceProviderCall(
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.42",
+  "version": "1.0.0-rc.43",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.27",
-    "@slates/provider": "1.0.0-rc.32",
+    "@slates/proto": "1.0.0-rc.28",
+    "@slates/provider": "1.0.0-rc.33",
     "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },

package/src/index.ts

@@ -9,7 +9,8 @@ import {
   SLATES_PROTOCOL_VERSION,
   type SlatesMessageAuthAdminCallbackHandleRequest,
   type SlatesMessageAuthAuthorizationUrlGetRequest,
-  type SlatesParticipant
+  type SlatesParticipant,
+  type SlatesRuntimeInfo
 } from '@slates/proto';
 import {
   AuthConfigSecretRedactor,
@@ -22,6 +23,7 @@ import {
   SlateLogger,
   type SlateLogListener,
   SlatePublicContext,
+  type SlateRuntimeInfo,
   uploadAttachmentDirect
 } from '@slates/provider';
 import { PQueue } from './pQueue';
@@ -189,6 +191,14 @@ let resolveTraceMessage = <ResultType>(
   result: ResultType
 ) => (typeof message === 'function' ? message(result) : message);
 
+// Build fails if SlateRuntimeInfo drifts from the proto schema.
+true satisfies [SlateRuntimeInfo, SlatesRuntimeInfo] extends [
+  SlatesRuntimeInfo,
+  SlateRuntimeInfo
+]
+  ? true
+  : false;
+
 export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   listeners: SlateLogListener[]
@@ -209,6 +219,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     let liveInvocation = new State<Pick<SlateLiveInvocationInfo, 'token' | 'baseUrl'> | null>(
       null
     );
+    let runtimeInfo = new State<SlateRuntimeInfo | null>(null);
 
     let getLiveInvocation = (): SlateLiveInvocationInfo | null => {
       let directUpload = hubCapabilities.get()?.attachments?.directUpload;
@@ -335,9 +346,24 @@ 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 createContext = <ConfigType extends {}, InputType extends {}, AuthType extends {}>(
+      config: ConfigType,
+      input: InputType,
+      auth: AuthType,
+      liveInvocationInfo: SlateLiveInvocationInfo | null = null
+    ) =>
+      new SlateContext(
+        config,
+        input,
+        auth,
+        slate.spec as any,
+        logger,
+        liveInvocationInfo,
+        runtimeInfo.get()
+      );
+
+    let getEmptyContext = () => createContext({}, {}, {});
+    let getAuthContext = () => createContext(getAuthConfig(), {}, {});
     let withRequestTraces = <Result extends Record<string, any>>(
       context: SlatePublicContext<any>,
       result: Result
@@ -481,11 +507,16 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       });
     });
 
+    manager.onNotification('slates/hub.runtime_info.set', async ({ params }) => {
+      runtimeInfo.set(params.runtimeInfo);
+    });
+
     manager.onRequest('slates/provider.capabilities.get', async () => ({
       capabilities: {
         hub: {
           capabilitiesNotification: true,
-          liveInvocation: true
+          liveInvocation: true,
+          runtimeInfo: true
         },
         provider: {
           triggerGroups:
@@ -1131,20 +1162,19 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
       if (action.isPublic) {
         getContextBasic();
-        return invoke(new SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
+        return invoke(
+          new SlatePublicContext(
+            input,
+            slate.spec,
+            logger,
+            getLiveInvocation(),
+            runtimeInfo.get()
+          )
+        );
       }
 
       let ctx = getContextFull();
-      return invoke(
-        new SlateContext(
-          ctx.config,
-          input,
-          ctx.auth?.output!,
-          slate.spec,
-          logger,
-          getLiveInvocation()
-        )
-      );
+      return invoke(createContext(ctx.config, input, ctx.auth?.output!, getLiveInvocation()));
     });
 
     manager.onRequest('slates/action.trigger.map_event', async ({ params }) => {
@@ -1158,7 +1188,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         `Invalid event for trigger ID: ${params.actionId}`
       );
 
-      let context = new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger);
+      let context = createContext(ctx.config, input, ctx.auth?.output!);
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1246,12 +1276,10 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let autoRegistration = getWebhookAutoRegistration(group);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         { pageToken: params.pageToken ?? null },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {
@@ -1285,16 +1313,14 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let autoRegistration = getWebhookAutoRegistration(group);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         {
           webhookTargetIdentifier: params.webhookTargetIdentifier,
           webhookTargetPayload: params.webhookTargetPayload,
           webhookUrl: params.webhookUrl
         },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {
@@ -1323,15 +1349,13 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let autoRegistration = getWebhookAutoRegistration(group);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         {
           webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
           webhookRegistrationPayload: params.webhookRegistrationPayload
         },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       await traceProviderCall(
         {
@@ -1357,13 +1381,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let manualRegistration = getWebhookManualRegistration(group);
 
-      let context = new SlateContext(
-        {},
-        { webhookUrl: params.webhookUrl },
-        {},
-        slate.spec as any,
-        logger
-      );
+      let context = createContext({}, { webhookUrl: params.webhookUrl }, {});
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1398,16 +1416,14 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let context = new SlateContext(
+      let context = createContext(
         {},
         {
           webhookUrl: params.webhookUrl,
           partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
           userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
         },
-        {},
-        slate.spec as any,
-        logger
+        {}
       );
       let res = await traceProviderCall(
         {
@@ -1447,15 +1463,13 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           : null
       });
 
-      let context = new SlateContext(
+      let context = createContext(
         {},
         {
           request: req,
           webhookRegistrationPayload: params.webhookRegistrationPayload
         },
-        {},
-        slate.spec as any,
-        logger
+        {}
       );
       let res = await traceProviderCall(
         {
@@ -1511,7 +1525,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let ctx = getContextFull();
       let group = getTriggerGroup(slate, params.triggerGroupId);
 
-      let context = new SlateContext(ctx.config, {}, ctx.auth?.output!, slate.spec, logger);
+      let context = createContext(ctx.config, {}, ctx.auth?.output!);
       let matchers = await traceProviderCall(
         {
           component: 'action',
@@ -1545,13 +1559,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let context = new SlateContext(
-        ctx.config,
-        { state: params.state },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
-      );
+      let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output!);
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1599,13 +1607,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let ctx = getContextFull();
       let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
 
-      let context = new SlateContext(
-        ctx.config,
-        { state: params.state },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
-      );
+      let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output!);
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1630,12 +1632,10 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let ctx = getContextFull();
       let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         { state: params.state, frames: params.frames, closed: params.closed ?? null },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {

package/src/runtimeInfo.test.ts

@@ -0,0 +1,129 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import {
+  getRuntimeInfo,
+  Slate,
+  SlateAuth,
+  SlateConfig,
+  SlatePublicTool,
+  SlateSpecification
+} from '@slates/provider';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { createProviderHandler } from './index';
+
+let runtimeInfo = {
+  metorial: {
+    apiUrl: 'https://api-us1.metorial.test',
+    region: 'us1',
+    environment: 'staging'
+  }
+};
+
+let createManager = async () => {
+  let spec = SlateSpecification.create({
+    key: 'runtime-info-test',
+    name: 'Runtime Info Test',
+    config: SlateConfig.create(z.object({ apiUrl: z.string().nullable() })).getDefaultConfig(
+      () => ({ apiUrl: getRuntimeInfo()?.metorial?.apiUrl ?? null })
+    ),
+    auth: SlateAuth.create().output(z.object({}))
+  });
+  let tool = SlatePublicTool.create(spec, {
+    key: 'read_runtime_info',
+    name: 'Read Runtime Info'
+  })
+    .input(z.object({}))
+    .output(z.object({ fromContext: z.any(), fromHelper: z.any() }))
+    .handleInvocation(async ctx => ({
+      output: { fromContext: ctx.runtimeInfo, fromHelper: getRuntimeInfo() },
+      message: 'ok'
+    }))
+    .build();
+  let slate = Slate.create({ spec, triggers: [], tools: [tool] });
+  let manager = await createProviderHandler(slate, []).run();
+
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hello',
+    params: { protocol: SLATES_PROTOCOL_VERSION }
+  });
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/participant.set',
+    params: {
+      participants: [
+        { type: 'consumer', id: 'consumer', name: 'Consumer' },
+        { type: 'hub', id: 'hub', name: 'Hub' }
+      ]
+    }
+  });
+
+  return manager;
+};
+
+let setRuntimeInfo = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hub.runtime_info.set',
+    params: { runtimeInfo }
+  });
+
+let invokeTool = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'tool',
+    method: 'slates/action.tool.invoke',
+    params: { actionId: 'read_runtime_info', input: {} }
+  });
+
+let getDefaultConfig = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'config',
+    method: 'slates/config.get_default',
+    params: {}
+  });
+
+describe('hub runtime info', () => {
+  it('advertises the runtime info capability', async () => {
+    let response = await SlatesProviderProtoHandlerManager.handleInput(await createManager(), {
+      jsonrpc: '2.0',
+      id: 'capabilities',
+      method: 'slates/provider.capabilities.get',
+      params: {}
+    });
+
+    expect(response).toMatchObject({
+      result: { capabilities: { hub: { runtimeInfo: true } } }
+    });
+  });
+
+  it('exposes runtime info to tools through ctx and the context helper', async () => {
+    let manager = await createManager();
+    await setRuntimeInfo(manager);
+
+    expect(await invokeTool(manager)).toMatchObject({
+      result: { output: { fromContext: runtimeInfo, fromHelper: runtimeInfo } }
+    });
+  });
+
+  it('exposes runtime info to handlers that receive no ctx argument', async () => {
+    let manager = await createManager();
+    await setRuntimeInfo(manager);
+
+    expect(await getDefaultConfig(manager)).toMatchObject({
+      result: { config: { apiUrl: runtimeInfo.metorial.apiUrl } }
+    });
+  });
+
+  it('returns null when the host sent no runtime info', async () => {
+    let manager = await createManager();
+
+    expect(await invokeTool(manager)).toMatchObject({
+      result: { output: { fromContext: null, fromHelper: null } }
+    });
+    expect(await getDefaultConfig(manager)).toMatchObject({
+      result: { config: { apiUrl: null } }
+    });
+  });
+});