chore: remove dead maxRunCount dequeue knob

Remove the dead `maxRunCount` dequeue option
(`TRIGGER_DEQUEUE_MAX_RUN_COUNT`) from the supervisor, the worker
dequeue request schema, the self-hosting docs and the Helm chart.
Server-side dequeue batching was removed in
#2127 and the field has been accepted and
ignored since; older supervisors that still send it keep working.

Mono-RevId: 7904c59a81b5bf4aa0614cd61f0ab21f7fe663b4

Author: nicktrn

apps/supervisor/src/env.ts

@@ -76,7 +76,6 @@ export const Env = z
       .optional(),
     TRIGGER_DEQUEUE_INTERVAL_MS: z.coerce.number().int().default(250),
     TRIGGER_DEQUEUE_IDLE_INTERVAL_MS: z.coerce.number().int().default(1000),
-    TRIGGER_DEQUEUE_MAX_RUN_COUNT: z.coerce.number().int().default(1),
     TRIGGER_DEQUEUE_MIN_CONSUMER_COUNT: z.coerce.number().int().default(1),
     TRIGGER_DEQUEUE_MAX_CONSUMER_COUNT: z.coerce.number().int().default(10),
     TRIGGER_DEQUEUE_SCALING_STRATEGY: z.enum(["none", "smooth", "aggressive"]).default("none"),

apps/supervisor/src/index.ts

@@ -347,7 +347,6 @@ class ManagedSupervisor {
       dequeueIntervalMs: env.TRIGGER_DEQUEUE_INTERVAL_MS,
       dequeueIdleIntervalMs: env.TRIGGER_DEQUEUE_IDLE_INTERVAL_MS,
       queueConsumerEnabled: env.TRIGGER_DEQUEUE_ENABLED,
-      maxRunCount: env.TRIGGER_DEQUEUE_MAX_RUN_COUNT,
       queueClass: env.TRIGGER_WORKER_QUEUE_CLASS,
       subscriptions: env.TRIGGER_WORKER_QUEUE_SUBSCRIPTIONS,
       metricsRegistry: register,

apps/webapp/app/routes/engine.v1.worker-actions.dequeue.e2e.test.ts

@@ -72,12 +72,10 @@ describe("dequeue request validation", () => {
 
     const invalidRequests: Array<[body: unknown, status: number]> = [
       [{ queueClass: "restore" }, 400],
-      [{ maxRunCount: "invalid" }, 400],
       [{ maxResources: { cpu: "invalid", memory: 1 } }, 400],
       [{ subscriptions: [] }, 422],
       [{ subscriptions: [{ ...subscription, weight: 2 }] }, 422],
       [{ queueClass: "default", subscriptions: [subscription] }, 422],
-      [{ maxRunCount: "invalid", subscriptions: [] }, 400],
       [{ queueClass: "invalid", subscriptions: [subscription] }, 400],
     ];
     for (const [body, status] of invalidRequests) {

docs/self-hosting/env/supervisor.mdx

@@ -31,7 +31,6 @@ mode: "wide"
 | `TRIGGER_DEQUEUE_ENABLED`                   | No       | true        | Enable dequeue to pull runs from the queue.                 |
 | `TRIGGER_DEQUEUE_INTERVAL_MS`               | No       | 250         | Dequeue interval (ms).                                      |
 | `TRIGGER_DEQUEUE_IDLE_INTERVAL_MS`          | No       | 1000 (1s)   | Dequeue idle interval (ms).                                 |
-| `TRIGGER_DEQUEUE_MAX_RUN_COUNT`             | No       | 10          | Max dequeue run count.                                      |
 | `TRIGGER_DEQUEUE_MAX_CONSUMER_COUNT`        | No       | 1           | Max dequeue consumer count.                                 |
 | **Docker settings**                         |          |             |                                                             |
 | `DOCKER_API_VERSION`                        | No       | v1.41       | Docker API version. You should probably not touch this.     |

hosting/k8s/helm/templates/supervisor.yaml

@@ -250,8 +250,6 @@ spec:
               value: {{ .Values.supervisor.config.dequeue.enabled | quote }}
             - name: TRIGGER_DEQUEUE_INTERVAL_MS
               value: {{ .Values.supervisor.config.dequeue.intervalMs | quote }}
-            - name: TRIGGER_DEQUEUE_MAX_RUN_COUNT
-              value: {{ .Values.supervisor.config.dequeue.maxRunCount | quote }}
             - name: TRIGGER_DEQUEUE_IDLE_INTERVAL_MS
               value: {{ .Values.supervisor.config.dequeue.idleIntervalMs | quote }}
             # Heartbeat configuration

hosting/k8s/helm/values.yaml

@@ -336,7 +336,6 @@ supervisor:
     dequeue:
       enabled: true
       intervalMs: 250
-      maxRunCount: 100
       idleIntervalMs: 500
     runner:
       heartbeatIntervalSeconds: 30

internal-packages/run-engine/src/engine/tests/ttl.test.ts

@@ -858,7 +858,6 @@ describe("RunEngine ttl", () => {
         const dequeued = await engine.dequeueFromWorkerQueue({
           consumerId: "test-consumer",
           workerQueue: "main",
-          maxRunCount: 1,
           backgroundWorkerId: (await prisma.backgroundWorker.findFirst({
             where: { runtimeEnvironmentId: authenticatedEnvironment.id },
           }))!.id,

packages/core/src/v3/runEngineWorker/supervisor/queueConsumer.ts

@@ -19,7 +19,6 @@ export type RunQueueConsumerOptions = {
   idleIntervalMs: number;
   preDequeue?: PreDequeueFn;
   preSkip?: PreSkipFn;
-  maxRunCount?: number;
   /** Which worker-queue class this consumer pulls from. Defaults to the worker's region queue. */
   queueClass?: WorkerQueueClass;
   subscriptions?: WeightedWorkerQueueSubscription[];
@@ -35,7 +34,6 @@ export class RunQueueConsumer implements QueueConsumer {
   private readonly client: SupervisorHttpClient;
   private readonly preDequeue?: PreDequeueFn;
   private readonly preSkip?: PreSkipFn;
-  private readonly maxRunCount?: number;
   private readonly queueClass?: WorkerQueueClass;
   private readonly subscriptions?: WeightedWorkerQueueSubscription[];
   private readonly onDequeue: (
@@ -58,7 +56,6 @@ export class RunQueueConsumer implements QueueConsumer {
     this.idleIntervalMs = opts.idleIntervalMs;
     this.preDequeue = opts.preDequeue;
     this.preSkip = opts.preSkip;
-    this.maxRunCount = opts.maxRunCount;
     this.queueClass = opts.queueClass;
     this.subscriptions = opts.subscriptions;
     this.lastScheduledIntervalMs = opts.idleIntervalMs;
@@ -89,7 +86,6 @@ export class RunQueueConsumer implements QueueConsumer {
       enabled: this.isEnabled,
       intervalMs: this.intervalMs,
       idleIntervalMs: this.idleIntervalMs,
-      maxRunCount: this.maxRunCount,
       preDequeue: !!this.preDequeue,
       preSkip: !!this.preSkip,
     });
@@ -140,7 +136,6 @@ export class RunQueueConsumer implements QueueConsumer {
     try {
       const response = await this.client.dequeue({
         maxResources: preDequeueResult?.maxResources,
-        maxRunCount: this.maxRunCount,
         queueClass: this.queueClass,
         subscriptions: this.subscriptions,
       });

packages/core/src/v3/runEngineWorker/supervisor/schemas.ts

@@ -87,7 +87,6 @@ export type WorkerQueueClass = z.infer<typeof WorkerQueueClass>;
 export const WorkerApiDequeueRequestBody = z
   .object({
     maxResources: MachineResources.optional(),
-    maxRunCount: z.number().optional(),
     /** Legacy selection. Absent or "default" targets the worker group's base queue. */
     queueClass: WorkerQueueClass.optional(),
     /** V2 selection. The server derives region from the authenticated worker. */

packages/core/src/v3/runEngineWorker/supervisor/session.test.ts

@@ -50,7 +50,6 @@ describe("SupervisorSession queue selection", () => {
       heartbeatIntervalSeconds: 3600,
       dequeueIntervalMs: 10,
       dequeueIdleIntervalMs: 10,
-      maxRunCount: 1,
       scaling: { strategy: "none", minConsumerCount: 1, maxConsumerCount: 1 },
       ...selection,
     });
@@ -59,7 +58,7 @@ describe("SupervisorSession queue selection", () => {
       await session.start();
       expect(await dequeued).toEqual({
         path: "/engine/v1/worker-actions/dequeue",
-        body: { maxRunCount: 1, ...selection },
+        body: selection,
       });
     } finally {
       await session.stop();