fix(dashboard-agent): tell get_queue who feeds a custom queue

A custom queue's name has nothing to do with any task id, but the agent searched the deployed task list for a task named after the queue, found none, and reported the queue's tasks as deleted or renamed.

get_queue now returns consumerTasks for a custom queue — the deployed task slugs whose queue config names it — and the prompt says an absent task of that name is not evidence about the queue.

Author: kathiekiwi

.changeset/quiet-hounds-shave.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/core": patch
+---
+
+The current-worker API now reports each task's queue, so you can see which tasks write to a given queue.

apps/webapp/app/routes/api.v1.projects.$projectRef.$env.workers.$tagName.ts

@@ -70,6 +70,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
         triggerSource: true,
         createdAt: true,
         payloadSchema: true,
+        queueConfig: true,
       },
       orderBy: {
         slug: "asc",
@@ -100,6 +101,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
           triggerSource: task.triggerSource,
           createdAt: task.createdAt,
           payloadSchema: task.payloadSchema,
+          queueConfig: task.queueConfig,
         })),
       },
       urls,

internal-packages/dashboard-agent/src/__snapshots__/prompt-prefix.test.ts.snap

@@ -4,34 +4,34 @@ exports[`the prefix stays inside its budget > matches the committed measurement
 {
   "assistant": {
     "prompt": {
-      "chars": 25593,
-      "estimatedTokens": 6398,
+      "chars": 25947,
+      "estimatedTokens": 6487,
     },
     "tools": {
-      "chars": 49377,
+      "chars": 49485,
       "count": 24,
-      "estimatedTokens": 12344,
+      "estimatedTokens": 12371,
     },
     "total": {
-      "chars": 74971,
-      "estimatedTokens": 18743,
-      "fingerprint": "6cfbe831",
+      "chars": 75433,
+      "estimatedTokens": 18858,
+      "fingerprint": "5418eb6b",
     },
   },
   "code": {
     "prompt": {
-      "chars": 28348,
-      "estimatedTokens": 7087,
+      "chars": 28702,
+      "estimatedTokens": 7176,
     },
     "tools": {
-      "chars": 52386,
+      "chars": 52494,
       "count": 28,
-      "estimatedTokens": 13097,
+      "estimatedTokens": 13124,
     },
     "total": {
-      "chars": 80735,
-      "estimatedTokens": 20184,
-      "fingerprint": "4c412f1e",
+      "chars": 81197,
+      "estimatedTokens": 20299,
+      "fingerprint": "9202c360",
     },
   },
 }

internal-packages/dashboard-agent/src/tool-api.ts

@@ -69,6 +69,22 @@ export function queueMetricsAreEmpty(data: unknown): boolean {
   );
 }
 
+/**
+ * The deployed tasks whose `queueConfig` points at this queue, from the current worker's
+ * task list. A custom queue's name is unrelated to any task id, so who consumes it can
+ * only be read off the tasks — never guessed from the name.
+ */
+export function consumerTasksForQueue(workers: unknown, queueName: string): string[] {
+  const tasks = (workers as { worker?: { tasks?: unknown } } | null)?.worker?.tasks;
+  if (!Array.isArray(tasks)) return [];
+  const slugs = new Set<string>();
+  for (const task of tasks as Array<{ slug?: unknown; queueConfig?: { name?: unknown } | null }>) {
+    if (typeof task?.slug !== "string") continue;
+    if (task.queueConfig?.name === queueName) slugs.add(task.slug);
+  }
+  return [...slugs].sort();
+}
+
 /**
  * Metrics plus the queue's live row. `paused` is the part the model must lead with: a queue
  * someone stopped explains its own emptiness, and every metric below it is a consequence
@@ -389,6 +405,26 @@ export function buildApiTools(args: {
           return result?.ok ? (result.data as Record<string, unknown>) : undefined;
         };
 
+        // Only a custom queue needs this read: a task queue's consumer is the task it is
+        // named after, while a custom queue's name says nothing about who writes to it.
+        const answer = async (
+          metrics: unknown,
+          kind: "task" | "custom",
+          state: Record<string, unknown> | undefined
+        ) => {
+          const base = withLiveState(metrics, kind, state);
+          if (base.queueType !== "custom" || !hasAuth || !projectRef || !environmentName) {
+            return base;
+          }
+          const workers = await apiGet(
+            origin,
+            `/api/v1/projects/${projectRef}/${environmentName}/workers/current`,
+            userActorToken!
+          );
+          if (!workers.ok) return base;
+          return { ...base, consumerTasks: consumerTasksForQueue(workers.data, queue) };
+        };
+
         const first = await read(type ?? "task");
         if (!first) return { error: "No current environment is available to read queues from." };
         if (!first.ok) {
@@ -400,16 +436,16 @@ export function buildApiTools(args: {
           const otherKind = type === "custom" ? "task" : "custom";
           const other = await read(otherKind);
           if (other?.ok && !queueMetricsAreEmpty(other.data)) {
-            return withLiveState(other.data, otherKind, await live(otherKind));
+            return await answer(other.data, otherKind, await live(otherKind));
           }
           // Neither kind has metrics, so the live row is the only thing that can tell them
           // apart: a paused or empty queue that exists, against a name that doesn't.
           const kind = type ?? "task";
           const state = (await live(kind)) ?? (await live(otherKind));
-          return withLiveState(first.data, kind, state);
+          return await answer(first.data, kind, state);
         }
         const kind = type ?? "task";
-        return withLiveState(first.data, kind, await live(kind));
+        return await answer(first.data, kind, await live(kind));
       },
     }),
 

internal-packages/dashboard-agent/src/tool-queue.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { queueMetricsAreEmpty } from "./tool-api";
+import { consumerTasksForQueue, queueMetricsAreEmpty } from "./tool-api";
 
 /**
  * The metrics route answers an unknown queue with zeroes rather than a 404, so asking for
@@ -29,3 +29,42 @@ describe("queueMetricsAreEmpty", () => {
     expect(queueMetricsAreEmpty({ ...zeroes, waitMs: { p50: 0, p95: null } })).toBe(false);
   });
 });
+
+/**
+ * The environment that produced the bug: `email-sends` is a custom queue two deployed tasks
+ * write to, and no task is named after it. Reading the deployed task list for a task called
+ * `email-sends` finds nothing, which is what let the agent invent a deleted task.
+ */
+describe("consumerTasksForQueue", () => {
+  const workers = {
+    worker: {
+      tasks: [
+        { slug: "send-order-receipt", queueConfig: { name: "email-sends" } },
+        { slug: "send-welcome-email", queueConfig: { name: "email-sends" } },
+        { slug: "generate-monthly-report", queueConfig: { name: "reports-heavy" } },
+        { slug: "sync-inventory", queueConfig: { name: "webhooks" } },
+        { slug: "email-sends-audit", queueConfig: null },
+      ],
+    },
+  };
+
+  it("names the tasks that write to a custom queue nothing is named after", () => {
+    expect(consumerTasksForQueue(workers, "email-sends")).toEqual([
+      "send-order-receipt",
+      "send-welcome-email",
+    ]);
+    expect(consumerTasksForQueue(workers, "reports-heavy")).toEqual(["generate-monthly-report"]);
+  });
+
+  it("matches the queue config's name, not the task slug", () => {
+    // `email-sends-audit` has no queue config, so it is on its own task queue.
+    expect(consumerTasksForQueue(workers, "email-sends-audit")).toEqual([]);
+    expect(consumerTasksForQueue(workers, "send-order-receipt")).toEqual([]);
+  });
+
+  it("says nothing rather than something wrong when the task list is missing", () => {
+    expect(consumerTasksForQueue(null, "email-sends")).toEqual([]);
+    expect(consumerTasksForQueue({ worker: {} }, "email-sends")).toEqual([]);
+    expect(consumerTasksForQueue({ worker: { tasks: [{}] } }, "email-sends")).toEqual([]);
+  });
+});

internal-packages/dashboard-agent/src/tool-schemas.ts

@@ -190,7 +190,7 @@ export const getReportSchema = tool({
 
 export const getQueueSchema = tool({
   description:
-    "Get one queue's metrics over a window: wait latency (p50/p95), peak depth, how many runs started (throughput), and how often the queue was throttled by its concurrency limit. Use this for 'how deep is the X queue', 'is X backed up', or 'why are runs waiting'. The answer also carries the queue's live row: `paused`, `queuedNow`, `runningNow`, `concurrencyLimit`, and `exists: false` when no queue of that name is there at all.",
+    "Get one queue's metrics over a window: wait latency (p50/p95), peak depth, how many runs started (throughput), and how often the queue was throttled by its concurrency limit. Use this for 'how deep is the X queue', 'is X backed up', or 'why are runs waiting'. The answer also carries the queue's live row: `paused`, `queuedNow`, `runningNow`, `concurrencyLimit`, and `exists: false` when no queue of that name is there at all. For a custom queue it also carries `consumerTasks`: the deployed tasks whose queue config names this queue.",
   inputSchema: z.object({
     queue: z
       .string()
@@ -483,7 +483,7 @@ You have read-only tools that act as the user against their own account:
 - ask_support: ask the Trigger.dev support assistant about how Trigger.dev works (docs, concepts, features, configuration, how-tos).
 - render_view: render a structured view in the panel from the block catalog. The catalog has the "diagnosis" block (a failure card for a single run), the "chart" block (a line/bar chart of run_query results), the "actions" block (a row of 1-3 buttons offering next steps — a watch intent opens the watch card pre-filled, an ask intent sends the labelled question as the user's next message), and the "investigation" block (a live card for a hypothesis-driven investigation).
 - get_report: the composed health report for the current environment (flow, execution, liveness), with a severity and the metrics behind each.
-- get_queue: one queue's wait latency, peak depth, throughput, and throttling over a window, plus its live row. Lead with paused when it is true: a paused queue explains its own emptiness, and every metric under it is a consequence, not a finding — say it is paused, and only then the numbers. queuedNow is what is waiting right now, which a window of metrics cannot show; exists:false is the only thing that means the queue isn't there, never zeroed metrics.
+- get_queue: one queue's wait latency, peak depth, throughput, and throttling over a window, plus its live row. Lead with paused when it is true: a paused queue explains its own emptiness, and every metric under it is a consequence, not a finding — say it is paused, and only then the numbers. queuedNow is what is waiting right now, which a window of metrics cannot show; exists:false is the only thing that means the queue isn't there, never zeroed metrics. A custom queue's name is not a task id, so no task being named after it is not evidence about it — never conclude from list_tasks or a deployment that a queue is unconsumed, undeployed, deleted, or renamed. consumerTasks is the answer to "who feeds this queue": empty means nothing deployed writes to it, and absent means you did not ask a custom queue.
 - list_deploys: recent deployments (versions) in the current environment, with status and commit message.
 - get_deploy: one deployment's detail, or the current promoted one when you omit the version.
 - correlate_version: the version, commit, and pull request a specific run actually ran.

packages/core/src/v3/schemas/api.ts

@@ -126,6 +126,7 @@ export const GetWorkerTaskResponse = z.object({
   triggerSource: z.string(),
   createdAt: z.coerce.date(),
   payloadSchema: z.any().nullish(),
+  queueConfig: z.any().nullish(),
 });
 
 export const GetWorkerByTagResponse = z.object({