feat(dashboard-agent): move the agent to Claude Sonnet 5, with per-role model overrides and a managed summary prompt

feat(dashboard-agent): move the agent to Claude Sonnet 5, with per-role
model overrides and a managed summary prompt

The in-dashboard agent now answers with Claude Sonnet 5 for its main
turns, the code and watch prompts, the warm first-turn step, compaction
summaries, attention wakes and the turn eval judge. Claude Haiku 4.5
stays on chat titles.

- Adds the Bedrock inference profile mapping for Sonnet 5 and keeps the
Sonnet 4.6 entry so stored prompt versions that still name it resolve.
- Switches thinking off for the bounded calls (summaries, attention
wakes) so their output caps are all answer.
- Main turns and the warm first-turn step pass each model's documented
output ceiling explicitly, so an unknown-to-the-provider id no longer
falls back to a 4096-token cap.
- The compaction summariser is a managed prompt
(`dashboard-agent-summary`), so its text and model can be versioned and
overridden from the dashboard like the system prompt.
- Each role's model can be overridden per environment with
`DASHBOARD_AGENT_MODEL`, `DASHBOARD_AGENT_SUMMARY_MODEL`,
`DASHBOARD_AGENT_JUDGE_MODEL` and `DASHBOARD_AGENT_TITLE_MODEL`, with
the above as defaults.
- No dependency changes; the installed providers accept the new id.

Mono-RevId: c01a1daba486863c535fede891d96259fa6b7386

Author: ericallam

apps/webapp/app/components/runs/v3/agent/AgentMessageView.tsx

@@ -132,8 +132,11 @@ export function renderPart(part: UIMessage["parts"][number], i: number) {
     return p.text ? <AssistantResponse key={i} text={p.text} headerLabel="" /> : null;
   }
 
-  // Reasoning — amber-bordered italic block
+  // Reasoning — amber-bordered italic block. Models that think adaptively with the
+  // text omitted (Sonnet 5 and later by default) still emit the part with no text;
+  // an empty block would be a bare amber bar, so those render nothing.
   if (type === "reasoning") {
+    if (!p.text) return null;
     return (
       <div key={i} className="border-l-2 border-amber-500/40 pl-2">
         <ChatBubble>

apps/webapp/app/env.server.ts

@@ -263,6 +263,11 @@ const EnvironmentSchema = z
     // uses its own key on the Trigger side. When unset, Head Start is disabled
     // and the first turn falls back to the normal cold-start path.
     ANTHROPIC_API_KEY: z.string().optional(),
+    // The model the dashboard agent's head-start step runs on (canonical `claude-…`
+    // id, default in the agent package). The internal seam reads process.env
+    // directly; this entry documents it webapp-side. The agent run reads its own
+    // DASHBOARD_AGENT_*_MODEL vars from the agent project's environment.
+    DASHBOARD_AGENT_MODEL: z.string().optional(),
     // Selects the dashboard agent's LLM provider (default anthropic). The internal
     // seam reads process.env directly; this entry validates the value webapp-side.
     DASHBOARD_AGENT_MODEL_PROVIDER: z.preprocess(

apps/webapp/app/services/dashboardAgentHeadStart.server.ts

@@ -1,10 +1,11 @@
-import { DASHBOARD_AGENT_MODEL } from "@internal/dashboard-agent/tool-schemas";
 import { systemPromptFor, toolSchemasFor } from "@internal/dashboard-agent/prompt-assembly";
 import {
   describePromptPrefix,
   promptCacheAttributes,
 } from "@internal/dashboard-agent/prompt-prefix";
 import {
+  dashboardAgentModel,
+  maxOutputTokensFor,
   resolveDashboardAgentModel,
   withCacheBreakpoint,
 } from "@internal/dashboard-agent/model-provider";
@@ -109,7 +110,9 @@ export async function startDashboardAgentHeadStart(params: {
     run: async ({ chat: helper }) =>
       streamText({
         ...helper.toStreamTextOptions({ tools }),
-        model: resolveDashboardAgentModel(DASHBOARD_AGENT_MODEL),
+        model: resolveDashboardAgentModel(dashboardAgentModel(env.DASHBOARD_AGENT_MODEL)),
+        // Same ceiling the agent run uses; the pinned provider caps an unknown id at 4096.
+        maxOutputTokens: maxOutputTokensFor(dashboardAgentModel(env.DASHBOARD_AGENT_MODEL)),
         // A structured system message, not a bare string: without provider options
         // the provider neither writes nor reads the cache, so this call paid full price
         // for the prefix and the agent's step 2 then paid for a fresh write. The tool

internal-packages/dashboard-agent/src/agent-runtime.ts

@@ -169,13 +169,20 @@ export function trackSeededInvestigation(
  * The action turn in flight, set by `onAction` when it returns `chat.turn()` and read
  * by the turn's hooks: a wake turn runs without tools (it reports what the check
  * established and carries no delegated token), a wake the narration plan marks
- * `haiku` runs on the small model with a bounded budget, and neither kind is judged
+ * `bounded` runs with an output cap, and neither kind is judged
  * by the eval. `onTurnStart` drops a marker the previous turn left behind, so a
  * settlement that failed on both attempts never taints the next typed turn.
  */
+/**
+ * The canonical `"anthropic:<id>"` the current turn's model call resolved to, set in
+ * `run()` and read by `onTurnComplete`, so the eval row records the model that
+ * answered rather than the one the deployed prompt version names.
+ */
+export const turnModelKey = locals.create<string>("dashboard-agent.turnModel");
+
 export const pendingActionTurnKey = locals.create<{
   kind: "wake" | "investigate";
-  model?: "haiku";
+  bounded?: true;
 }>("dashboard-agent.pendingActionTurn");
 
 /**

internal-packages/dashboard-agent/src/compaction.test.ts

@@ -1,6 +1,7 @@
 // `@trigger.dev/sdk/ai/test` MUST be imported before the agent module so the
 // resource catalog is installed before `chat.agent({ id })` registers.
 import { mockChatAgent, type MockChatAgentHarness } from "@trigger.dev/sdk/ai/test";
+import { DASHBOARD_AGENT_SUMMARY_PROMPT } from "./prompts";
 
 import { afterEach, describe, expect, it } from "vitest";
 import { simulateReadableStream, type ModelMessage, type UIMessage } from "ai";
@@ -26,7 +27,6 @@ import {
   safeTail,
   shouldCompactConversation,
   STATIC_PREFIX_TOKENS,
-  SUMMARY_INSTRUCTION,
   withDurableState,
 } from "./compaction";
 
@@ -422,7 +422,7 @@ describe("the summariser's input", () => {
  * the watch line asks for a record and never for present state.
  */
 describe("the summary instruction never asks for present state", () => {
-  const watchLine = SUMMARY_INSTRUCTION.split("\n").find((line) => /watch/i.test(line));
+  const watchLine = DASHBOARD_AGENT_SUMMARY_PROMPT.split("\n").find((line) => /watch/i.test(line));
 
   it("has a line about watches at all", () => {
     expect(watchLine).toBeDefined();

internal-packages/dashboard-agent/src/compaction.ts

@@ -9,6 +9,8 @@ import {
   sanitizeReplayedToolInputs,
 } from "./agent-runtime";
 import { stripAgentLinks } from "./linkify-agent-text";
+import { dashboardAgentSummaryModel, promptModel, withoutThinking } from "./model-provider";
+import { summaryPrompt } from "./prompts";
 
 /**
  * Bounded context: how a long conversation is summarised, and what may never be
@@ -54,26 +56,13 @@ export const COMPACTION_KEPT_TAIL_CHARS = 40_000;
 /** Per message, when the transcript is rendered for the summariser. */
 const SUMMARY_INPUT_MESSAGE_CHARS = 2_000;
 
-/** The summariser: cheap, bounded, and told exactly what it may not drop. */
-const SUMMARY_MODEL = "anthropic:claude-haiku-4-5" as const;
-
 /**
  * A hard ceiling on the summary, because "under 400 words" is an instruction and not a
  * budget. 400 words is ~530 tokens, so this is roughly double what the summary needs.
+ * Thinking is switched off for the call, so none of it goes on hidden reasoning.
  */
 const SUMMARY_MAX_OUTPUT_TOKENS = 1_000;
 
-export const SUMMARY_INSTRUCTION = `You are compacting a support conversation between a user and an agent that reads a Trigger.dev dashboard, so the agent can keep going with a shorter history.
-
-Write a summary in under 400 words, as notes rather than prose. Keep, in this order:
-1. What the user is trying to do, in their own terms, and anything they asked to be remembered.
-2. Facts already established, with the run ids, queue names, task identifiers, error fingerprints and numbers they rest on. Never restate a number you cannot see.
-3. Any investigation that is open: its investigationId, its title and its current outcome.
-4. Any watch the transcript records — what it was set up to watch, and what it said if it reported. Write it as what the transcript recorded, never as what is true now: a watch can expire or be cancelled without saying so here, so never present one as current.
-5. What was asked most recently and what is still unanswered.
-
-Drop tool mechanics, retries, and anything already superseded. Do not add advice, and do not invent anything that is not in the transcript. Everything you write is a record of what the transcript said, not a claim about the present.`;
-
 /** A summary that reads as a summary, and never as the user's next question. */
 function summaryMessage(summary: string, durableState?: string): ModelMessage {
   return {
@@ -273,11 +262,28 @@ export function renderTranscriptForSummary(messages: ModelMessage[]): string {
 }
 
 async function summarizeConversation(event: SummarizeEvent): Promise<string> {
+  // The summariser is a managed prompt: its text and model are versioned on the
+  // platform and overridable from the dashboard, like the system prompt.
+  const resolved = await summaryPrompt.resolve({});
+  // Dashboard-managed call settings first; the bounded-call safeguards below stay fixed.
+  const managed = (resolved.config ?? {}) as Partial<
+    Pick<Parameters<typeof generateText>[0], "temperature" | "topP" | "topK" | "stopSequences">
+  >;
   const { text } = await generateText({
-    model: locals.get(dashboardAgentModelKey) ?? resolveDashboardAgentModel(SUMMARY_MODEL),
-    system: SUMMARY_INSTRUCTION,
+    ...managed,
+    model:
+      locals.get(dashboardAgentModelKey) ??
+      resolveDashboardAgentModel(
+        promptModel(resolved, {
+          env: "DASHBOARD_AGENT_SUMMARY_MODEL",
+          fallback: dashboardAgentSummaryModel,
+        })
+      ),
+    system: resolved.text,
     prompt: renderTranscriptForSummary(event.messages),
     maxOutputTokens: SUMMARY_MAX_OUTPUT_TOKENS,
+    providerOptions: withoutThinking(),
+    ...resolved.toAISDKTelemetry(),
   });
   return text.trim();
 }

internal-packages/dashboard-agent/src/dashboard-agent.eval.ts

@@ -16,12 +16,13 @@ import {
   dashboardAgentToolsKey,
   type DashboardAgentStore,
 } from "./dashboard-agent";
+import { dashboardAgentJudgeModel, dashboardAgentModel } from "./model-provider";
 import { dashboardAgentCodeToolSchemas, dashboardAgentToolSchemas } from "./tool-schemas";
 import { showCodeAskPrompt } from "./tools";
 
 const HAS_KEY = Boolean(process.env.ANTHROPIC_API_KEY);
-const AGENT_MODEL = "claude-sonnet-4-6";
-const JUDGE_MODEL = "claude-sonnet-4-6";
+const AGENT_MODEL = dashboardAgentModel();
+const JUDGE_MODEL = dashboardAgentJudgeModel();
 
 const CLIENT_DATA = {
   userId: "user_eval",

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

@@ -20,6 +20,7 @@ import {
   dashboardAgentStorage,
   getStore,
   pendingActionTurnKey,
+  turnModelKey,
   getSystemPrompt,
   modeFor,
   resolveDashboardAgentModel,
@@ -30,7 +31,14 @@ import {
   type DashboardAgentStore,
 } from "./agent-runtime";
 import { titlePrompt } from "./prompts";
-import { withCacheBreakpoint } from "./model-provider";
+import {
+  dashboardAgentModel,
+  dashboardAgentTitleModel,
+  maxOutputTokensFor,
+  promptModel,
+  withCacheBreakpoint,
+  withoutThinking,
+} from "./model-provider";
 import { recordPromptCacheUsage, stepCachePrepareStep } from "./step-cache";
 import { dashboardAgentActionSchema, handleWatchAction } from "./watch-actions";
 import { dashboardAgentCompaction, withDurableState } from "./compaction";
@@ -320,7 +328,12 @@ async function generateAndSaveTitle(
   const { text } = await generateText({
     model:
       locals.get(dashboardAgentModelKey) ??
-      resolveDashboardAgentModel(resolved.model ?? "anthropic:claude-haiku-4-5"),
+      resolveDashboardAgentModel(
+        promptModel(resolved, {
+          env: "DASHBOARD_AGENT_TITLE_MODEL",
+          fallback: dashboardAgentTitleModel,
+        })
+      ),
     system: resolved.text,
     prompt: userText,
     ...resolved.toAISDKTelemetry(),
@@ -359,8 +372,8 @@ export function prepareTurnMessages(args: {
   );
 }
 
-/** The output budget of a small-model wake: the headline and a sentence around it. */
-const HAIKU_WAKE_MAX_OUTPUT_TOKENS = 300;
+/** The output budget of an attention wake: the headline and a sentence around it. */
+const WAKE_MAX_OUTPUT_TOKENS = 300;
 
 export const dashboardAgent = chat.agent({
   id: "dashboard-agent",
@@ -556,7 +569,9 @@ export const dashboardAgent = chat.agent({
               projectRef: clientData.projectRef,
               environment: clientData.environmentName,
               currentPage: clientData.currentPage,
-              model: resolved.model,
+              // The model that answered: an env override or dashboard override can
+              // differ from the one the deployed prompt version names.
+              model: locals.get(turnModelKey) ?? resolved.model,
               promptSlug: resolved.promptId,
               promptVersion: resolved.version,
               userText: userMessage ? extractText(userMessage) : "",
@@ -597,21 +612,28 @@ export const dashboardAgent = chat.agent({
     const actionTurn = locals.get(pendingActionTurnKey);
     const wake = actionTurn?.kind === "wake";
     const tools = wake ? {} : turnTools;
-    // A wake the plan gave a headline is a sentence or two on the small model, bounded
-    // so a chatty turn cannot run up the bill on something nobody asked.
-    const smallWake = wake && actionTurn.model === "haiku";
+    // A wake the plan gave a headline is a sentence or two, bounded so a chatty turn
+    // cannot run up the bill on something nobody asked. Thinking is switched off for
+    // it, so the cap is all answer.
+    const boundedWake = wake && actionTurn.bounded === true;
     const options = chat.toStreamTextOptions({ tools });
+    const modelId = promptModel(resolved, {
+      env: "DASHBOARD_AGENT_MODEL",
+      fallback: dashboardAgentModel,
+    });
+    locals.set(turnModelKey, modelId);
     let step = 0;
     return streamText({
       ...options,
-      model:
-        locals.get(dashboardAgentModelKey) ??
-        resolveDashboardAgentModel(
-          smallWake
-            ? "anthropic:claude-haiku-4-5"
-            : (resolved.model ?? "anthropic:claude-sonnet-4-6")
-        ),
-      ...(smallWake ? { maxOutputTokens: HAIKU_WAKE_MAX_OUTPUT_TOKENS } : {}),
+      model: locals.get(dashboardAgentModelKey) ?? resolveDashboardAgentModel(modelId),
+      // The documented ceiling for the model this turn resolved to; the pinned providers
+      // would otherwise cap an unknown id at 4096, thinking included.
+      ...(maxOutputTokensFor(modelId) !== undefined
+        ? { maxOutputTokens: maxOutputTokensFor(modelId) }
+        : {}),
+      ...(boundedWake
+        ? { maxOutputTokens: WAKE_MAX_OUTPUT_TOKENS, providerOptions: withoutThinking() }
+        : {}),
       messages,
       abortSignal: signal,
       prepareStep: stepCachePrepareStep(options) as never,

internal-packages/dashboard-agent/src/eval-turn.ts

@@ -5,7 +5,7 @@ import {
 } from "@internal/dashboard-agent-db";
 import { logger, task } from "@trigger.dev/sdk";
 import { EVAL_ERROR_CATEGORIES, redactedEvalOutputErrored } from "./eval-policy";
-import { resolveDashboardAgentModel } from "./model-provider";
+import { resolveDashboardAgentModel, dashboardAgentJudgeModel } from "./model-provider";
 import { generateObject } from "ai";
 import { z } from "zod";
 
@@ -23,8 +23,6 @@ import { z } from "zod";
  * tool data verbatim. The comment above `evalTurn` lists exactly what a row holds.
  */
 
-const JUDGE_MODEL = "claude-sonnet-4-6";
-
 // One connection pool per worker process for the eval task (separate from the
 // agent's; eval runs are their own runs and may land on other workers).
 let dbClient: DashboardAgentDbClient | undefined;
@@ -163,8 +161,9 @@ const JUDGE_SYSTEM = [
 export const evalTurn = task({
   id: "dashboard-agent-eval-turn",
   run: async (payload: EvalTurnPayload, { ctx }) => {
+    const judgeModel = dashboardAgentJudgeModel();
     const { object } = await generateObject({
-      model: resolveDashboardAgentModel(`anthropic:${JUDGE_MODEL}`),
+      model: resolveDashboardAgentModel(`anthropic:${judgeModel}`),
       schema: TurnEval,
       system: JUDGE_SYSTEM,
       prompt: [
@@ -194,7 +193,7 @@ export const evalTurn = task({
       promptVersion: payload.promptVersion,
       toolsUsed: payload.toolActivity.map((t) => t.toolName),
       toolError,
-      judgeModel: JUDGE_MODEL,
+      judgeModel,
       scoreGrounded: object.grounded,
       scoreAnswered: object.answered,
       scoreConcise: object.concise,