@teamkeel/functions-runtime 0.436.1 → 0.437.0

package/dist/index.cjs

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