@teamkeel/functions-runtime 0.438.0 → 0.439.0

package/dist/index.cjs

@@ -51,6 +51,7 @@ __export(index_exports, {
   checkBuiltInPermissions: () => checkBuiltInPermissions,
   createFlowContext: () => createFlowContext,
   handleFlow: () => handleFlow,
+  handleJob: () => handleJob,
   handleRequest: () => handleRequest,
   handleRoute: () => handleRoute,
   handleSubscriber: () => handleSubscriber,
@@ -1132,18 +1133,18 @@ var opMapping = {
     notEquals: { op: "=", value: /* @__PURE__ */ __name((v) => import_kysely4.sql`NOT ${v}`, "value") }
   }
 };
-function applyWhereConditions(context5, qb, where = {}) {
-  const conf = context5.tableConfig();
+function applyWhereConditions(context6, qb, where = {}) {
+  const conf = context6.tableConfig();
   for (const key of Object.keys(where)) {
     const v = where[key];
     if (conf && conf[(0, import_change_case.snakeCase)(key)]) {
       const rel = conf[(0, import_change_case.snakeCase)(key)];
-      context5.withJoin(rel.referencesTable, () => {
-        qb = applyWhereConditions(context5, qb, v);
+      context6.withJoin(rel.referencesTable, () => {
+        qb = applyWhereConditions(context6, qb, v);
       });
       continue;
     }
-    const fieldName = `${context5.tableAlias()}.${(0, import_change_case.snakeCase)(key)}`;
+    const fieldName = `${context6.tableAlias()}.${(0, import_change_case.snakeCase)(key)}`;
     if (Object.prototype.toString.call(v) !== "[object Object]") {
       const operator = v === null || Array.isArray(v) ? import_kysely4.sql`is not distinct from` : "=";
       qb = qb.where(fieldName, operator, import_kysely4.sql`${v}`);
@@ -1177,15 +1178,15 @@ function applyWhereConditions(context5, qb, where = {}) {
 __name(applyWhereConditions, "applyWhereConditions");
 
 // src/applyAdditionalQueryConstraints.js
-function applyLimit(context5, qb, limit) {
+function applyLimit(context6, qb, limit) {
   return qb.limit(limit);
 }
 __name(applyLimit, "applyLimit");
-function applyOffset(context5, qb, offset) {
+function applyOffset(context6, qb, offset) {
   return qb.offset(offset);
 }
 __name(applyOffset, "applyOffset");
-function applyOrderBy(context5, qb, tableName, orderBy = {}) {
+function applyOrderBy(context6, qb, tableName, orderBy = {}) {
   Object.entries(orderBy).forEach(([key, sortOrder]) => {
     qb = qb.orderBy(`${tableName}.${(0, import_change_case.snakeCase)(key)}`, sortOrder.toLowerCase());
   });
@@ -1194,41 +1195,41 @@ function applyOrderBy(context5, qb, tableName, orderBy = {}) {
 __name(applyOrderBy, "applyOrderBy");
 
 // src/applyJoins.js
-function applyJoins(context5, qb, where) {
-  const conf = context5.tableConfig();
+function applyJoins(context6, qb, where) {
+  const conf = context6.tableConfig();
   if (!conf) {
     return qb;
   }
-  const srcTable = context5.tableAlias();
+  const srcTable = context6.tableAlias();
   for (const key of Object.keys(where)) {
     const rel = conf[(0, import_change_case.snakeCase)(key)];
     if (!rel) {
       continue;
     }
     const targetTable = rel.referencesTable;
-    if (context5.hasJoin(targetTable)) {
+    if (context6.hasJoin(targetTable)) {
       continue;
     }
-    context5.withJoin(targetTable, () => {
+    context6.withJoin(targetTable, () => {
       switch (rel.relationshipType) {
         case "hasMany":
           qb = qb.innerJoin(
-            `${targetTable} as ${context5.tableAlias()}`,
+            `${targetTable} as ${context6.tableAlias()}`,
             `${srcTable}.id`,
-            `${context5.tableAlias()}.${rel.foreignKey}`
+            `${context6.tableAlias()}.${rel.foreignKey}`
           );
           break;
         case "belongsTo":
           qb = qb.innerJoin(
-            `${targetTable} as ${context5.tableAlias()}`,
+            `${targetTable} as ${context6.tableAlias()}`,
             `${srcTable}.${rel.foreignKey}`,
-            `${context5.tableAlias()}.id`
+            `${context6.tableAlias()}.id`
           );
           break;
         default:
           throw new Error(`unknown relationshipType: ${rel.relationshipType}`);
       }
-      qb = applyJoins(context5, qb, where[key]);
+      qb = applyJoins(context6, qb, where[key]);
     });
   }
   return qb;
@@ -1458,17 +1459,17 @@ var QueryBuilder = class _QueryBuilder {
    * @param {import("./QueryContext").QueryContext} context
    * @param {import("kysely").Kysely} db
    */
-  constructor(tableName, context5, db) {
+  constructor(tableName, context6, db) {
     this._tableName = tableName;
-    this._context = context5;
+    this._context = context6;
     this._db = db;
     this._modelName = upperCamelCase(this._tableName);
   }
   where(where) {
-    const context5 = this._context.clone();
-    let builder = applyJoins(context5, this._db, where);
-    builder = applyWhereConditions(context5, builder, where);
-    return new _QueryBuilder(this._tableName, context5, builder);
+    const context6 = this._context.clone();
+    let builder = applyJoins(context6, this._db, where);
+    builder = applyWhereConditions(context6, builder, where);
+    return new _QueryBuilder(this._tableName, context6, builder);
   }
   sql() {
     return this._db.compile().sql;
@@ -1533,19 +1534,19 @@ var QueryBuilder = class _QueryBuilder {
     const name = spanNameForModelAPI(this._modelName, "findMany");
     const db = useDatabase();
     return withSpan(name, async (span) => {
-      const context5 = new QueryContext([this._tableName], this._tableConfigMap);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
       let builder = db.selectFrom((qb) => {
         return this._db.as(this._tableName);
       }).selectAll();
       if (params?.limit) {
-        builder = applyLimit(context5, builder, params.limit);
+        builder = applyLimit(context6, builder, params.limit);
       }
       if (params?.offset) {
-        builder = applyOffset(context5, builder, params.offset);
+        builder = applyOffset(context6, builder, params.offset);
       }
       if (params?.orderBy !== void 0 && Object.keys(params?.orderBy).length > 0) {
         builder = applyOrderBy(
-          context5,
+          context6,
           builder,
           this._tableName,
           params.orderBy
@@ -1579,7 +1580,7 @@ var QueryBuilder = class _QueryBuilder {
     );
     const db = useDatabase();
     return withSpan(name, async (span) => {
-      const context5 = new QueryContext([this._tableName], this._tableConfigMap);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
       const isOffsetPagination = params.limit != null && params.limit > 0;
       const isBackward = params.last != null && params.last > 0;
       const DEFAULT_PAGE_SIZE = 50;
@@ -1627,7 +1628,7 @@ var QueryBuilder = class _QueryBuilder {
           ])
         ) : normalizedOrderBy;
         builder = applyOrderBy(
-          context5,
+          context6,
           builder,
           this._tableName,
           effectiveOrderBy
@@ -1700,10 +1701,10 @@ var QueryBuilder = class _QueryBuilder {
         }
       }
       if (limit != null) {
-        builder = applyLimit(context5, builder, limit);
+        builder = applyLimit(context6, builder, limit);
       }
       if (isOffsetPagination && params.offset) {
-        builder = applyOffset(context5, builder, params.offset);
+        builder = applyOffset(context6, builder, params.offset);
       }
       span.setAttribute("sql", builder.compile().sql);
       let rows = await builder.execute();
@@ -1808,9 +1809,9 @@ var ModelAPI = class {
     const db = useDatabase();
     return withSpan(name, async (span) => {
       let builder = db.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
-      const context5 = new QueryContext([this._tableName], this._tableConfigMap);
-      builder = applyJoins(context5, builder, where);
-      builder = applyWhereConditions(context5, builder, where);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      builder = applyJoins(context6, builder, where);
+      builder = applyWhereConditions(context6, builder, where);
       span.setAttribute("sql", builder.compile().sql);
       const row = await builder.executeTakeFirst();
       if (!row) {
@@ -1824,23 +1825,23 @@ var ModelAPI = class {
     const db = useDatabase();
     const where = params?.where || {};
     return withSpan(name, async (span) => {
-      const context5 = new QueryContext([this._tableName], this._tableConfigMap);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
       let builder = db.selectFrom((qb) => {
         let builder2 = qb.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
-        builder2 = applyJoins(context5, builder2, where);
-        builder2 = applyWhereConditions(context5, builder2, where);
+        builder2 = applyJoins(context6, builder2, where);
+        builder2 = applyWhereConditions(context6, builder2, where);
         builder2 = builder2.as(this._tableName);
         return builder2;
       }).selectAll();
       if (params?.limit) {
-        builder = applyLimit(context5, builder, params.limit);
+        builder = applyLimit(context6, builder, params.limit);
       }
       if (params?.offset) {
-        builder = applyOffset(context5, builder, params.offset);
+        builder = applyOffset(context6, builder, params.offset);
       }
       if (params?.orderBy !== void 0 && Object.keys(params?.orderBy).length > 0) {
         builder = applyOrderBy(
-          context5,
+          context6,
           builder,
           this._tableName,
           params.orderBy
@@ -1891,8 +1892,8 @@ var ModelAPI = class {
         }
       }
       builder = builder.set(snakeCaseObject(row));
-      const context5 = new QueryContext([this._tableName], this._tableConfigMap);
-      builder = applyWhereConditions(context5, builder, where);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      builder = applyWhereConditions(context6, builder, where);
       span.setAttribute("sql", builder.compile().sql);
       try {
         const row2 = await builder.executeTakeFirstOrThrow();
@@ -1907,8 +1908,8 @@ var ModelAPI = class {
     const db = useDatabase();
     return withSpan(name, async (span) => {
       let builder = db.deleteFrom(this._tableName).returning(["id"]);
-      const context5 = new QueryContext([this._tableName], this._tableConfigMap);
-      builder = applyWhereConditions(context5, builder, where);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      builder = applyWhereConditions(context6, builder, where);
       span.setAttribute("sql", builder.compile().sql);
       try {
         const row = await builder.executeTakeFirstOrThrow();
@@ -1921,10 +1922,10 @@ var ModelAPI = class {
   where(where) {
     const db = useDatabase();
     let builder = db.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
-    const context5 = new QueryContext([this._tableName], this._tableConfigMap);
-    builder = applyJoins(context5, builder, where);
-    builder = applyWhereConditions(context5, builder, where);
-    return new QueryBuilder(this._tableName, context5, builder);
+    const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+    builder = applyJoins(context6, builder, where);
+    builder = applyWhereConditions(context6, builder, where);
+    return new QueryBuilder(this._tableName, context6, builder);
   }
 };
 async function create(conn, tableName, tableConfigs, values) {
@@ -2748,6 +2749,7 @@ var PROTO_ACTION_TYPES = {
   DELETE: "ACTION_TYPE_DELETE",
   READ: "ACTION_TYPE_READ",
   WRITE: "ACTION_TYPE_WRITE",
+  JOB: "JOB_TYPE",
   SUBSCRIBER: "SUBSCRIBER_TYPE",
   FLOW: "FLOW_TYPE"
 };
@@ -2924,10 +2926,103 @@ async function handleRequest(request, config) {
 }
 __name(handleRequest, "handleRequest");
 
-// src/handleSubscriber.js
+// src/handleJob.js
 var import_json_rpc_23 = require("json-rpc-2.0");
 var opentelemetry3 = __toESM(require("@opentelemetry/api"), 1);
 
+// src/tryExecuteJob.js
+function tryExecuteJob({ db, permitted, request, functionConfig }, cb) {
+  return withPermissions(permitted, async ({ getPermissionState }) => {
+    let requiresTransaction = false;
+    if (functionConfig?.dbTransaction !== void 0) {
+      requiresTransaction = functionConfig.dbTransaction;
+    }
+    return withDatabase(db, requiresTransaction, async () => {
+      await withAuditContext(request, async () => {
+        return cb();
+      });
+      if (getPermissionState() === PERMISSION_STATE.UNPERMITTED) {
+        throw new PermissionError(`Not permitted to access ${request.method}`);
+      }
+    });
+  });
+}
+__name(tryExecuteJob, "tryExecuteJob");
+
+// src/handleJob.js
+async function handleJob(request, config) {
+  const activeContext = opentelemetry3.propagation.extract(
+    opentelemetry3.context.active(),
+    request.meta?.tracing
+  );
+  return opentelemetry3.context.with(activeContext, () => {
+    return withSpan(request.method, async (span) => {
+      let db = null;
+      try {
+        const { createJobContextAPI, jobs } = config;
+        if (!jobs[request.method]) {
+          const message = `job '${request.method}' does not exist or has not been implemented`;
+          span.setStatus({
+            code: opentelemetry3.SpanStatusCode.ERROR,
+            message
+          });
+          return (0, import_json_rpc_23.createJSONRPCErrorResponse)(
+            request.id,
+            import_json_rpc_23.JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+        const ctx = createJobContextAPI({
+          meta: request.meta
+        });
+        const permitted = request.meta && request.meta.permissionState.status === "granted" ? true : null;
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN
+        });
+        const jobFunction = jobs[request.method];
+        const actionType = PROTO_ACTION_TYPES.JOB;
+        const functionConfig = jobFunction?.config ?? {};
+        await tryExecuteJob(
+          { request, permitted, db, actionType, functionConfig },
+          async () => {
+            const inputs = parseInputs(request.params);
+            return jobFunction(ctx, inputs);
+          }
+        );
+        return (0, import_json_rpc_23.createJSONRPCSuccessResponse)(request.id, null);
+      } catch (e) {
+        if (e instanceof Error) {
+          span.recordException(e);
+          span.setStatus({
+            code: opentelemetry3.SpanStatusCode.ERROR,
+            message: e.message
+          });
+          return errorToJSONRPCResponse(request, e);
+        }
+        const message = JSON.stringify(e);
+        span.setStatus({
+          code: opentelemetry3.SpanStatusCode.ERROR,
+          message
+        });
+        return (0, import_json_rpc_23.createJSONRPCErrorResponse)(
+          request.id,
+          RuntimeErrors.UnknownError,
+          message
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+__name(handleJob, "handleJob");
+
+// src/handleSubscriber.js
+var import_json_rpc_24 = require("json-rpc-2.0");
+var opentelemetry4 = __toESM(require("@opentelemetry/api"), 1);
+
 // src/tryExecuteSubscriber.js
 function tryExecuteSubscriber({ request, db, functionConfig }, cb) {
   let requiresTransaction = false;
@@ -2944,11 +3039,11 @@ __name(tryExecuteSubscriber, "tryExecuteSubscriber");
 
 // src/handleSubscriber.js
 async function handleSubscriber(request, config) {
-  const activeContext = opentelemetry3.propagation.extract(
-    opentelemetry3.context.active(),
+  const activeContext = opentelemetry4.propagation.extract(
+    opentelemetry4.context.active(),
     request.meta?.tracing
   );
-  return opentelemetry3.context.with(activeContext, () => {
+  return opentelemetry4.context.with(activeContext, () => {
     return withSpan(request.method, async (span) => {
       let db = null;
       try {
@@ -2956,12 +3051,12 @@ async function handleSubscriber(request, config) {
         if (!subscribers[request.method]) {
           const message = `subscriber '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
-            code: opentelemetry3.SpanStatusCode.ERROR,
+            code: opentelemetry4.SpanStatusCode.ERROR,
             message
           });
-          return (0, import_json_rpc_23.createJSONRPCErrorResponse)(
+          return (0, import_json_rpc_24.createJSONRPCErrorResponse)(
             request.id,
-            import_json_rpc_23.JSONRPCErrorCode.MethodNotFound,
+            import_json_rpc_24.JSONRPCErrorCode.MethodNotFound,
             message
           );
         }
@@ -2981,22 +3076,22 @@ async function handleSubscriber(request, config) {
             return subscriberFunction(ctx, inputs);
           }
         );
-        return (0, import_json_rpc_23.createJSONRPCSuccessResponse)(request.id, null);
+        return (0, import_json_rpc_24.createJSONRPCSuccessResponse)(request.id, null);
       } catch (e) {
         if (e instanceof Error) {
           span.recordException(e);
           span.setStatus({
-            code: opentelemetry3.SpanStatusCode.ERROR,
+            code: opentelemetry4.SpanStatusCode.ERROR,
             message: e.message
           });
           return errorToJSONRPCResponse(request, e);
         }
         const message = JSON.stringify(e);
         span.setStatus({
-          code: opentelemetry3.SpanStatusCode.ERROR,
+          code: opentelemetry4.SpanStatusCode.ERROR,
           message
         });
-        return (0, import_json_rpc_23.createJSONRPCErrorResponse)(
+        return (0, import_json_rpc_24.createJSONRPCErrorResponse)(
           request.id,
           RuntimeErrors.UnknownError,
           message
@@ -3012,14 +3107,14 @@ async function handleSubscriber(request, config) {
 __name(handleSubscriber, "handleSubscriber");
 
 // src/handleRoute.js
-var import_json_rpc_24 = require("json-rpc-2.0");
-var opentelemetry4 = __toESM(require("@opentelemetry/api"), 1);
+var import_json_rpc_25 = require("json-rpc-2.0");
+var opentelemetry5 = __toESM(require("@opentelemetry/api"), 1);
 async function handleRoute(request, config) {
-  const activeContext = opentelemetry4.propagation.extract(
-    opentelemetry4.context.active(),
+  const activeContext = opentelemetry5.propagation.extract(
+    opentelemetry5.context.active(),
     request.meta?.tracing
   );
-  return opentelemetry4.context.with(activeContext, () => {
+  return opentelemetry5.context.with(activeContext, () => {
     return withSpan(request.method, async (span) => {
       let db = null;
       try {
@@ -3027,12 +3122,12 @@ async function handleRoute(request, config) {
         if (!functions[request.method]) {
           const message = `route function '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
-            code: opentelemetry4.SpanStatusCode.ERROR,
+            code: opentelemetry5.SpanStatusCode.ERROR,
             message
           });
-          return (0, import_json_rpc_24.createJSONRPCErrorResponse)(
+          return (0, import_json_rpc_25.createJSONRPCErrorResponse)(
             request.id,
-            import_json_rpc_24.JSONRPCErrorCode.MethodNotFound,
+            import_json_rpc_25.JSONRPCErrorCode.MethodNotFound,
             message
           );
         }
@@ -3057,28 +3152,28 @@ async function handleRoute(request, config) {
         if (result instanceof Error) {
           span.recordException(result);
           span.setStatus({
-            code: opentelemetry4.SpanStatusCode.ERROR,
+            code: opentelemetry5.SpanStatusCode.ERROR,
             message: result.message
           });
           return errorToJSONRPCResponse(request, result);
         }
-        const response = (0, import_json_rpc_24.createJSONRPCSuccessResponse)(request.id, result);
+        const response = (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, result);
         return response;
       } catch (e) {
         if (e instanceof Error) {
           span.recordException(e);
           span.setStatus({
-            code: opentelemetry4.SpanStatusCode.ERROR,
+            code: opentelemetry5.SpanStatusCode.ERROR,
             message: e.message
           });
           return errorToJSONRPCResponse(request, e);
         }
         const message = JSON.stringify(e);
         span.setStatus({
-          code: opentelemetry4.SpanStatusCode.ERROR,
+          code: opentelemetry5.SpanStatusCode.ERROR,
           message
         });
-        return (0, import_json_rpc_24.createJSONRPCErrorResponse)(
+        return (0, import_json_rpc_25.createJSONRPCErrorResponse)(
           request.id,
           RuntimeErrors.UnknownError,
           message
@@ -3094,8 +3189,8 @@ async function handleRoute(request, config) {
 __name(handleRoute, "handleRoute");
 
 // src/handleFlow.ts
-var import_json_rpc_25 = require("json-rpc-2.0");
-var opentelemetry5 = __toESM(require("@opentelemetry/api"), 1);
+var import_json_rpc_26 = require("json-rpc-2.0");
+var opentelemetry6 = __toESM(require("@opentelemetry/api"), 1);
 
 // src/tryExecuteFlow.js
 function tryExecuteFlow(db, request, cb) {
@@ -4164,11 +4259,11 @@ __name(complete, "complete");
 // src/handleFlow.ts
 var import_change_case3 = require("change-case");
 async function handleFlow(request, config) {
-  const activeContext = opentelemetry5.propagation.extract(
-    opentelemetry5.context.active(),
+  const activeContext = opentelemetry6.propagation.extract(
+    opentelemetry6.context.active(),
     request.meta?.tracing
   );
-  return opentelemetry5.context.with(activeContext, () => {
+  return opentelemetry6.context.with(activeContext, () => {
     return withSpan(request.method, async (span) => {
       span.setAttribute(KEEL_INTERNAL_ATTR, true);
       let db = null;
@@ -4182,12 +4277,12 @@ async function handleFlow(request, config) {
         if (!flows[request.method]) {
           const message = `flow '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
-            code: opentelemetry5.SpanStatusCode.ERROR,
+            code: opentelemetry6.SpanStatusCode.ERROR,
             message
           });
-          return (0, import_json_rpc_25.createJSONRPCErrorResponse)(
+          return (0, import_json_rpc_26.createJSONRPCErrorResponse)(
             request.id,
-            import_json_rpc_25.JSONRPCErrorCode.MethodNotFound,
+            import_json_rpc_26.JSONRPCErrorCode.MethodNotFound,
             message
           );
         }
@@ -4229,7 +4324,7 @@ async function handleFlow(request, config) {
         } catch (e) {
           if (e instanceof StepCreatedDisrupt) {
             span.setAttribute(KEEL_INTERNAL_ATTR, KEEL_INTERNAL_CHILDREN);
-            return (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, {
+            return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
               runId,
               runCompleted: false,
               config: flowConfig,
@@ -4238,12 +4333,12 @@ async function handleFlow(request, config) {
           }
           if (e instanceof CallbackDisrupt) {
             if (e.error) {
-              return (0, import_json_rpc_25.createJSONRPCErrorResponse)(request.id, 500, e.response);
+              return (0, import_json_rpc_26.createJSONRPCErrorResponse)(request.id, 500, e.response);
             }
-            return (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, e.response);
+            return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, e.response);
           }
           if (e instanceof UIRenderDisrupt) {
-            return (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, {
+            return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
               runId,
               stepId: e.stepId,
               config: flowConfig,
@@ -4253,19 +4348,19 @@ async function handleFlow(request, config) {
           if (e instanceof Error) {
             span.recordException(e);
             span.setStatus({
-              code: opentelemetry5.SpanStatusCode.ERROR,
+              code: opentelemetry6.SpanStatusCode.ERROR,
               message: e instanceof Error ? e.message : "unknown error"
             });
           }
           if (e instanceof ExhuastedRetriesDisrupt) {
-            return (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, {
+            return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
               runId,
               runCompleted: true,
               error: "flow failed due to exhausted step retries",
               config: flowConfig
             });
           }
-          return (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, {
+          return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
             runId,
             runCompleted: true,
             error: e instanceof Error ? e.message : "unknown error",
@@ -4293,7 +4388,7 @@ async function handleFlow(request, config) {
         } else if (response) {
           data = response;
         }
-        return (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, {
+        return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
           runId,
           runCompleted: true,
           data,
@@ -4303,17 +4398,17 @@ async function handleFlow(request, config) {
         if (e instanceof Error) {
           span.recordException(e);
           span.setStatus({
-            code: opentelemetry5.SpanStatusCode.ERROR,
+            code: opentelemetry6.SpanStatusCode.ERROR,
             message: e.message
           });
           return errorToJSONRPCResponse(request, e);
         }
         const message = JSON.stringify(e);
         span.setStatus({
-          code: opentelemetry5.SpanStatusCode.ERROR,
+          code: opentelemetry6.SpanStatusCode.ERROR,
           message
         });
-        return (0, import_json_rpc_25.createJSONRPCErrorResponse)(
+        return (0, import_json_rpc_26.createJSONRPCErrorResponse)(
           request.id,
           RuntimeErrors.UnknownError,
           message
@@ -4356,6 +4451,7 @@ __name(ksuid, "ksuid");
   checkBuiltInPermissions,
   createFlowContext,
   handleFlow,
+  handleJob,
   handleRequest,
   handleRoute,
   handleSubscriber,