feat(webapp): route keyless deployments to containers at trigger

Runs whose deployment has no compute template now go to containers when they are triggered. The task metadata cache carries the deployment's template key, so the trigger reads it with no new database query. The key only keeps a run off compute; it never moves a run that is not migrated.

Mono-RevId: cf013ae7cd32ef2e02711ac9278c11ad222487c1

Author: 1stvamp

.server-changes/route-keyless-deployments-at-trigger.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Runs whose deployment has no compute template now go to containers when they are triggered, instead of first passing through the compute worker queue.

apps/webapp/app/runEngine/concerns/computeMigration.server.ts

@@ -50,6 +50,8 @@ type ResolveInput = MigrationDecisionInput & {
   backing: { workerQueue: string; enableFastPath: boolean } | undefined;
   envType: string;
   environmentCompat: WorkerQueueEnvironmentOverride["compat"];
+  /** Template key of the deployment from the task metadata. Missing means no key. */
+  templateKey: string | null | undefined;
 };
 
 /**
@@ -59,7 +61,10 @@ type ResolveInput = MigrationDecisionInput & {
  * either way. Same-geo swap (us-east-1 -> us-east-1-next): any explicit placement
  * is a geography preference, honored by staying in-region. Applied after region
  * resolution, mirroring the scheduled-split. An environment compat of compute or container
- * decides the swap ahead of the org's migration decision.
+ * decides the swap ahead of the org's migration decision. A deployment without a template key
+ * stays on the base queue. The key can only keep a migrated run off compute: templates can exist
+ * for orgs that are not migrated, and the dequeue check still covers keyless runs that reach
+ * compute.
  */
 export function resolveComputeMigration({
   baseWorkerQueue,
@@ -68,6 +73,7 @@ export function resolveComputeMigration({
   backing,
   envType,
   environmentCompat,
+  templateKey,
   ...decision
 }: ResolveInput): {
   workerQueue: string | undefined;
@@ -85,5 +91,6 @@ export function resolveComputeMigration({
         ? false
         : isOrgMigrated(decision);
   if (!migrated) return passthrough;
+  if (!templateKey) return passthrough;
   return { workerQueue: backing.workerQueue, region, enableFastPath: backing.enableFastPath };
 }

apps/webapp/app/runEngine/concerns/queues.server.ts

@@ -2,7 +2,10 @@ import { sanitizeQueueName } from "@trigger.dev/core/v3/isomorphic";
 import type { PrismaClientOrTransaction } from "@trigger.dev/database";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
-import { findCurrentWorkerFromEnvironment } from "~/v3/models/workerDeployment.server";
+import {
+  findCurrentWorkerDeployment,
+  findCurrentWorkerFromEnvironment,
+} from "~/v3/models/workerDeployment.server";
 import type {
   LockedBackgroundWorker,
   QueueManager,
@@ -101,6 +104,7 @@ export class DefaultQueueManager implements QueueManager {
     let taskTtl: string | null | undefined;
     let taskKind: string | undefined;
     let taskGates: TaskMetadataGate[] | null | undefined;
+    let templateKey: string | null | undefined;
 
     // Determine queue name based on lockToVersion and provided options
     if (lockedBackgroundWorker) {
@@ -153,6 +157,7 @@ export class DefaultQueueManager implements QueueManager {
         }
         taskKind = lockedMeta?.triggerSource;
         taskGates = lockedMeta?.gates;
+        templateKey = lockedMeta?.templateKey;
       } else {
         // No queue override - resolve default queue + TTL + triggerSource via cache,
         // falling back to a single BackgroundWorkerTask lookup on miss.
@@ -192,6 +197,7 @@ export class DefaultQueueManager implements QueueManager {
         lockedQueueId = lockedMeta.queueId ?? undefined;
         taskKind = lockedMeta.triggerSource;
         taskGates = lockedMeta.gates;
+        templateKey = lockedMeta.templateKey;
       }
     } else {
       // Task is not locked to a specific version, use regular logic
@@ -208,6 +214,7 @@ export class DefaultQueueManager implements QueueManager {
       taskTtl = taskInfo.taskTtl;
       taskKind = taskInfo.taskKind;
       taskGates = taskInfo.taskGates;
+      templateKey = taskInfo.templateKey;
     }
 
     // Sanitize the final determined queue name once
@@ -292,6 +299,7 @@ export class DefaultQueueManager implements QueueManager {
       taskTtl,
       taskKind,
       gates: gates && gates.length > 0 ? gates : undefined,
+      templateKey,
     };
   }
 
@@ -300,6 +308,7 @@ export class DefaultQueueManager implements QueueManager {
     taskTtl?: string | null;
     taskKind?: string | undefined;
     taskGates?: TaskMetadataGate[] | null;
+    templateKey?: string | null;
   }> {
     const { taskId, environment, body } = request;
     const { queue } = body.options ?? {};
@@ -323,6 +332,7 @@ export class DefaultQueueManager implements QueueManager {
         taskTtl: meta?.ttl ?? undefined,
         taskKind: meta?.triggerSource,
         taskGates: meta?.gates,
+        templateKey: meta?.templateKey,
       };
     }
 
@@ -344,6 +354,7 @@ export class DefaultQueueManager implements QueueManager {
         taskTtl: meta.ttl,
         taskKind: meta.triggerSource,
         taskGates: meta.gates,
+        templateKey: meta.templateKey,
       };
     }
 
@@ -352,6 +363,7 @@ export class DefaultQueueManager implements QueueManager {
       taskTtl: meta.ttl,
       taskKind: meta.triggerSource,
       taskGates: meta.gates,
+      templateKey: meta.templateKey,
     };
   }
 
@@ -404,6 +416,7 @@ export class DefaultQueueManager implements QueueManager {
 
     recordTaskMetaResolve("locked", source);
 
+    const templateKey = row.worker.deployment?.templateKey ?? null;
     const entry: TaskMetadataEntry = {
       slug,
       ttl: row.ttl,
@@ -415,9 +428,9 @@ export class DefaultQueueManager implements QueueManager {
 
     // Fire-and-forget back-fill — `setByWorker` upserts the single field and
     // refreshes the hash TTL. Errors are logged inside the cache and swallowed.
-    void this.taskMetaCache.setByWorker(workerId, entry);
+    void this.taskMetaCache.setByWorker(workerId, entry, templateKey);
 
-    return entry;
+    return { ...entry, templateKey };
   }
 
   private findLockedTaskRow(
@@ -433,6 +446,7 @@ export class DefaultQueueManager implements QueueManager {
         triggerSource: true,
         gates: true,
         queue: { select: { id: true, name: true } },
+        worker: { select: { deployment: { select: { templateKey: true } } } },
       },
     });
   }
@@ -459,7 +473,18 @@ export class DefaultQueueManager implements QueueManager {
     // the adjacent BackgroundWorkerTask lookup below uses `replicaPrisma` too
     // (replica lag for "just deployed" is bounded the same way for both
     // queries; reading from the writer here would only widen the window).
-    const worker = await findCurrentWorkerFromEnvironment(environment, this.replicaPrisma);
+    let worker: { id: string } | null;
+    let templateKey: string | null = null;
+    if (environment.type === "DEVELOPMENT") {
+      worker = await findCurrentWorkerFromEnvironment(environment, this.replicaPrisma);
+    } else {
+      const deployment = await findCurrentWorkerDeployment({
+        environmentId: environment.id,
+        prismaClient: this.replicaPrisma,
+      });
+      worker = deployment?.worker ?? null;
+      templateKey = deployment?.templateKey ?? null;
+    }
     if (!worker) {
       recordTaskMetaResolve("current", "miss");
       return null;
@@ -495,9 +520,9 @@ export class DefaultQueueManager implements QueueManager {
     // keyspaces so a subsequent locked-or-not trigger hits the cache. The
     // env-keyspace TTL is preserved (promotion owns it); the by-worker TTL
     // is refreshed (sliding window keeps active workers warm).
-    void this.taskMetaCache.setByCurrentWorker(environment.id, worker.id, entry);
+    void this.taskMetaCache.setByCurrentWorker(environment.id, worker.id, entry, templateKey);
 
-    return entry;
+    return { ...entry, templateKey };
   }
 
   async validateQueueLimits(

apps/webapp/app/runEngine/concerns/workerQueueAssignment.server.test.ts

@@ -251,6 +251,7 @@ describe("per-environment worker queue overrides", () => {
         flags: { computeMigrationEnabled: migrationEnabled, computeMigrationFreePercentage: 100 },
         envType: environmentType,
         environmentCompat: environmentOverride.compat,
+        templateKey: "a".repeat(64),
       });
       const workerQueue = workerQueueForBirth({
         workerQueue: migrated.workerQueue!,
@@ -323,6 +324,7 @@ describe("per-environment worker queue overrides", () => {
         flags: undefined,
         envType: "STAGING",
         environmentCompat: environmentOverride.compat,
+        templateKey: "a".repeat(64),
       });
       expect(migrated.workerQueue).toBe("us-east-1-next");
       const birth = (v2Enabled: boolean) =>
@@ -354,6 +356,7 @@ describe("per-environment worker queue overrides", () => {
         flags: undefined,
         envType: "STAGING",
         environmentCompat: environmentOverride.compat,
+        templateKey: "a".repeat(64),
       });
       expect(
         workerQueueForBirth({

apps/webapp/app/runEngine/services/triggerTask.server.ts

@@ -445,7 +445,7 @@ export class RunEngineTriggerTaskService {
           const parkedOnExternalDeploymentId =
             externalDeploymentResolution?.outcome === "park" ? externalDeploymentId : undefined;
 
-          const { queueName, lockedQueueId, taskTtl, taskKind, gates } =
+          const { queueName, lockedQueueId, taskTtl, taskKind, gates, templateKey } =
             await this.queueConcern.resolveQueueProperties(
               triggerRequest,
               lockedToBackgroundWorker ?? undefined
@@ -534,6 +534,7 @@ export class RunEngineTriggerTaskService {
             flags: globalFlagsRegistry.current(),
             envType: environment.type,
             environmentCompat: environmentOverride.compat,
+            templateKey,
           });
 
           const triggerSource = options.triggerSource ?? "api";

apps/webapp/app/runEngine/types.ts

@@ -48,6 +48,8 @@ export type QueueProperties = {
   taskKind?: string;
   /** Other queues the run must also hold a concurrency slot in while executing. */
   gates?: Array<{ queue: string; concurrencyKey?: string }>;
+  /** Template key of the deployment the task metadata came from, if it has one. */
+  templateKey?: string | null;
 };
 
 export type LockedBackgroundWorker = Pick<