@vellumai/assistant 0.11.1-dev.202608032034.aebd2da → 0.11.1-dev.202608032226.351a4e2

package/src/__tests__/workspace-migration-138-backfill-home-feed-titles.test.ts

@@ -0,0 +1,373 @@
+/**
+ * Tests for workspace migration `138-backfill-home-feed-titles`.
+ *
+ * The migration gives every item in `<workspace>/data/home-feed.json` a
+ * non-empty `title`, derived from the item's own `summary` when the
+ * field is missing or blank.
+ *
+ * Cases covered:
+ *   1. Missing file, malformed JSON, and a non-object root are no-ops.
+ *   2. Title-less items gain a first-sentence title from the summary.
+ *   3. Items that already have a title are untouched.
+ *   4. A long summary truncates to 60 characters with an ellipsis, the
+ *      same cap the notification pipeline's derivation applies.
+ *   5. Markdown-rich and multi-line summaries yield a single line of
+ *      plain text.
+ *   6. `version`, `updatedAt`, and unrelated item fields are preserved.
+ *   7. A second run writes nothing.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { backfillHomeFeedTitlesMigration } from "../workspace/migrations/138-backfill-home-feed-titles.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { getLastWorkspaceMigrationId } from "../workspace/migrations/runner.js";
+
+let workspaceDir: string;
+let feedPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-138-test-"));
+  feedPath = join(workspaceDir, "data", "home-feed.json");
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function writeFeedFile(contents: unknown): void {
+  mkdirSync(join(workspaceDir, "data"), { recursive: true });
+  writeFileSync(feedPath, JSON.stringify(contents, null, 2), "utf-8");
+}
+
+function readFeedFile(): {
+  version: number;
+  items: Array<Record<string, unknown>>;
+  updatedAt: string;
+} {
+  return JSON.parse(readFileSync(feedPath, "utf-8"));
+}
+
+function makeItem(
+  overrides: Record<string, unknown> & { id: string },
+): Record<string, unknown> {
+  return {
+    type: "notification",
+    priority: 50,
+    summary: "Something happened.",
+    timestamp: "2026-08-01T12:00:00.000Z",
+    status: "new",
+    createdAt: "2026-08-01T12:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function writeFeed(items: Array<Record<string, unknown>>): void {
+  writeFeedFile({
+    version: 2,
+    updatedAt: "2026-08-01T12:00:00.000Z",
+    items,
+  });
+}
+
+describe("workspace migration 138-backfill-home-feed-titles", () => {
+  test("has the expected id and description", () => {
+    expect(backfillHomeFeedTitlesMigration.id).toBe(
+      "138-backfill-home-feed-titles",
+    );
+    expect(backfillHomeFeedTitlesMigration.description).toContain("title");
+  });
+
+  // getLastWorkspaceMigrationId() reports the final array entry as the
+  // registry ceiling to the identity and rollback routes, so the
+  // highest-numbered migration must sit last in the registry.
+  test("the registry ceiling stays at the highest-numbered migration", () => {
+    const numericId = (id: string) => Number.parseInt(id, 10);
+    const highest = Math.max(
+      ...WORKSPACE_MIGRATIONS.map((m) => numericId(m.id)).filter(
+        Number.isFinite,
+      ),
+    );
+    const last = getLastWorkspaceMigrationId(WORKSPACE_MIGRATIONS);
+    expect(last).not.toBeNull();
+    expect(numericId(last!)).toBe(highest);
+  });
+
+  test("missing file is a no-op (no error, no file created)", () => {
+    expect(existsSync(feedPath)).toBe(false);
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(existsSync(feedPath)).toBe(false);
+  });
+
+  test("derives a title from the summary's first sentence", () => {
+    writeFeed([
+      makeItem({
+        id: "a-1",
+        summary: "Alice replied to your thread. She needs an answer.",
+      }),
+      makeItem({ id: "a-2", summary: "Deploy finished!" }),
+      makeItem({ id: "a-3", summary: "Ready to review? The draft is up." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const titles = readFeedFile().items.map((item) => item.title);
+    expect(titles).toEqual([
+      "Alice replied to your thread.",
+      "Deploy finished!",
+      "Ready to review?",
+    ]);
+  });
+
+  test("backfills items whose title is missing, empty, blank, or not a string", () => {
+    writeFeed([
+      makeItem({ id: "missing", summary: "First item summary." }),
+      makeItem({ id: "empty", title: "", summary: "Second item summary." }),
+      makeItem({ id: "blank", title: "   ", summary: "Third item summary." }),
+      makeItem({ id: "wrong-type", title: null, summary: "Fourth summary." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const titles = readFeedFile().items.map((item) => item.title);
+    expect(titles).toEqual([
+      "First item summary.",
+      "Second item summary.",
+      "Third item summary.",
+      "Fourth summary.",
+    ]);
+  });
+
+  test("leaves items that already have a title untouched", () => {
+    writeFeed([
+      makeItem({
+        id: "titled",
+        title: "Existing headline",
+        summary: "A completely different summary sentence.",
+      }),
+      makeItem({ id: "untitled", summary: "Needs a headline." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const items = readFeedFile().items;
+    expect(items[0]!.title).toBe("Existing headline");
+    expect(items[1]!.title).toBe("Needs a headline.");
+  });
+
+  test("truncates a long summary to 60 characters with an ellipsis", () => {
+    const summary =
+      "Bob shared a very long document that keeps going well past the limit";
+    writeFeed([makeItem({ id: "long", summary })]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const title = readFeedFile().items[0]!.title as string;
+    expect(title).toBe(
+      "Bob shared a very long document that keeps going well past t…",
+    );
+    // The ellipsis sits past the cap, so the retained text is exactly 60.
+    expect(title.slice(0, -1).length).toBe(60);
+  });
+
+  test("truncates a long first sentence rather than the whole summary", () => {
+    writeFeed([
+      makeItem({
+        id: "long-sentence",
+        summary:
+          "This opening sentence runs well beyond the sixty character cap on derived titles. Then another.",
+      }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const title = readFeedFile().items[0]!.title as string;
+    expect(title).toBe(
+      "This opening sentence runs well beyond the sixty character c…",
+    );
+  });
+
+  test("flattens a markdown-rich multi-line summary into one plain line", () => {
+    writeFeed([
+      makeItem({
+        id: "markdown",
+        summary:
+          "## Nightly run\n\n- **Deploy** finished\n- Tests passed\n\nSee the `report` for details.",
+      }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBe(
+      "Nightly run Deploy finished Tests passed See the report for…",
+    );
+  });
+
+  test("unwraps inline markdown before taking the first sentence", () => {
+    writeFeed([
+      makeItem({
+        id: "inline",
+        summary:
+          "**Alice** shared the [design doc](https://example.com/doc). Review it soon.",
+      }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBe("Alice shared the design doc.");
+  });
+
+  test("collapses a newline-only summary run into single spaces", () => {
+    writeFeed([
+      makeItem({ id: "newlines", summary: "Backup complete\n\nNo errors" }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBe("Backup complete No errors");
+  });
+
+  test("skips an item whose summary is markdown structure only", () => {
+    writeFeed([makeItem({ id: "structure-only", summary: "##\n\n- \n\n> " })]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBeUndefined();
+  });
+
+  test("preserves version, updatedAt, and unrelated item fields", () => {
+    writeFeedFile({
+      version: 2,
+      updatedAt: "2026-08-01T12:00:00.000Z",
+      items: [
+        makeItem({
+          id: "keep-fields",
+          summary: "Payment failed.",
+          urgency: "high",
+          conversationId: "conv-abc",
+          actions: [{ label: "Retry", kind: "prompt" }],
+          detailPanel: { kind: "text", body: "Details" },
+        }),
+      ],
+    });
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const out = readFeedFile();
+    expect(out.version).toBe(2);
+    expect(out.updatedAt).toBe("2026-08-01T12:00:00.000Z");
+
+    const item = out.items[0]!;
+    expect(item.title).toBe("Payment failed.");
+    expect(item.id).toBe("keep-fields");
+    expect(item.type).toBe("notification");
+    expect(item.priority).toBe(50);
+    expect(item.status).toBe("new");
+    expect(item.urgency).toBe("high");
+    expect(item.conversationId).toBe("conv-abc");
+    expect(item.actions).toEqual([{ label: "Retry", kind: "prompt" }]);
+    expect(item.detailPanel).toEqual({ kind: "text", body: "Details" });
+  });
+
+  test("idempotent: a second run writes nothing", () => {
+    writeFeed([
+      makeItem({ id: "a-1", summary: "Alice replied to your thread." }),
+      makeItem({ id: "a-2", title: "Already titled", summary: "Body text." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+    const afterFirst = readFileSync(feedPath, "utf-8");
+    const afterFirstStat = statSync(feedPath);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(afterFirst);
+    expect(statSync(feedPath).mtimeMs).toBe(afterFirstStat.mtimeMs);
+  });
+
+  test("a fully titled feed is left byte-identical", () => {
+    writeFeed([makeItem({ id: "a-1", title: "Titled", summary: "Body." })]);
+    const before = readFileSync(feedPath, "utf-8");
+    const beforeStat = statSync(feedPath);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(before);
+    expect(statSync(feedPath).mtimeMs).toBe(beforeStat.mtimeMs);
+  });
+
+  test("malformed JSON does not throw and leaves the file alone", () => {
+    mkdirSync(join(workspaceDir, "data"), { recursive: true });
+    writeFileSync(feedPath, "{not valid json", "utf-8");
+    const before = readFileSync(feedPath, "utf-8");
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(before);
+  });
+
+  test("non-object root is a no-op", () => {
+    writeFeedFile([1, 2, 3]);
+    const before = readFileSync(feedPath, "utf-8");
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(before);
+  });
+
+  test("items that cannot yield a title are skipped without throwing", () => {
+    writeFeedFile({
+      version: 2,
+      updatedAt: "2026-08-01T12:00:00.000Z",
+      items: [
+        "not an object",
+        makeItem({ id: "no-summary", summary: undefined }),
+        makeItem({ id: "blank-summary", summary: "   " }),
+        makeItem({ id: "ok", summary: "Has a summary." }),
+      ],
+    });
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    const items: unknown[] = readFeedFile().items;
+    expect(items[0]).toBe("not an object");
+    expect((items[1] as Record<string, unknown>).title).toBeUndefined();
+    expect((items[2] as Record<string, unknown>).title).toBeUndefined();
+    expect((items[3] as Record<string, unknown>).title).toBe("Has a summary.");
+  });
+
+  test("down() is a no-op (forward-only migration)", () => {
+    writeFeed([makeItem({ id: "a-1", summary: "Alice replied." })]);
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+    const after = readFileSync(feedPath, "utf-8");
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.down(workspaceDir),
+    ).not.toThrow();
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(after);
+  });
+});

package/src/agent/loop.ts

@@ -1028,6 +1028,10 @@ export class AgentLoop {
     // rejection means the repair could not recover, so the error surfaces
     // instead of looping. Turn-scoped, so each turn recovers afresh.
     let orderingRepairAttempted = false;
+    // One resume per turn after a call dies mid-generation: a second
+    // interruption means re-issuing is not getting through, so the error
+    // surfaces instead of looping.
+    let interruptedCallResumed = false;
     let lastLlmCallTime = 0;
     let exitReason: ExitReason | null = null;
     // Armed at the end of a tool-use iteration so the budget gate runs at the
@@ -1176,6 +1180,12 @@ export class AgentLoop {
       // elsewhere in the turn body (tool execution, the success-path stop
       // chain, post-model-call hooks) must not re-enter the stop chain.
       let providerCallError: unknown;
+      // Set once the model streams its first token on this iteration's call.
+      // Two readers: latency instrumentation stamps time-to-first-token off
+      // its rising edge, and the outer catch reads it to tell a refused
+      // request from a generation that died mid-flight. Declared here so that
+      // catch can reach it.
+      let streamedTokens = false;
 
       try {
         // ── Pre-call budget gate ─────────────────────────────────────
@@ -1527,11 +1537,6 @@ export class AgentLoop {
         // the client would otherwise see nothing.
         let streamedVisibleText = false;
 
-        // Latency instrumentation: stamp the first streamed token (thinking or
-        // text) of THIS call exactly once, so each per-call segment carries its
-        // own time-to-first-token. Reset per provider call.
-        let firstTokenMarked = false;
-
         // The `onEvent` wrapping below applies sensitive-output placeholder
         // substitution to streamed text while forwarding every other event
         // type through unchanged.
@@ -1541,10 +1546,10 @@ export class AgentLoop {
           config: providerConfig,
           onEvent: (event) => {
             if (
-              !firstTokenMarked &&
+              !streamedTokens &&
               (event.type === "thinking_delta" || event.type === "text_delta")
             ) {
-              firstTokenMarked = true;
+              streamedTokens = true;
               latencyTracker?.markFirstToken(
                 event.type === "thinking_delta" ? "thinking" : "text",
               );
@@ -2498,6 +2503,30 @@ export class AgentLoop {
             newMessagesStart = history.length;
             continue;
           }
+
+          // Last: the call died mid-generation. `streamedTokens` means the
+          // provider accepted the request and started producing before it
+          // failed, so the request is fine and re-issuing it as-is is the
+          // recovery — nothing to repair, which is why no branch above claims
+          // it. A rejection that streamed nothing is the opposite case (the
+          // provider refused the request), and an identical resend would be
+          // refused identically, so those surface. Main-agent turns only:
+          // background call sites answer to callers that handle their own
+          // failures.
+          if (
+            streamedTokens &&
+            !interruptedCallResumed &&
+            callSite === "mainAgent" &&
+            postModelCallContinues < MAX_POST_MODEL_CALL_CONTINUES
+          ) {
+            interruptedCallResumed = true;
+            postModelCallContinues++;
+            rlog.warn(
+              { turn: toolUseTurns, messageCount: history.length, err },
+              "Model call died mid-generation, resuming the turn",
+            );
+            continue;
+          }
         }
 
         rlog.error(

package/src/cli/commands/notifications.help.ts

@@ -86,7 +86,7 @@ Examples:
         {
           flags: "--title <title>",
           description:
-            "Short headline (≤ 8 words). Always provide one — the auto-derived fallback just truncates --message.",
+            "Short headline. Titles over 40 characters are trimmed to fit, and one over 40 characters that also runs past 7 words is cut to its first 5. A title that reads like prose (a reasoning opener, or a full sentence ending in terminal punctuation) is discarded in favor of a headline derived from --message.",
         },
         {
           flags: "--urgency <urgency>",
@@ -263,7 +263,8 @@ Examples:
         },
         {
           flags: "--title <title>",
-          description: "New short headline (≤ 8 words).",
+          description:
+            "New short headline (≤ 8 words). An empty value is ignored, so the existing title stays put.",
         },
         {
           flags: "--urgency <urgency>",

package/src/config/llm-resolver.ts

@@ -114,12 +114,29 @@ export interface ResolveCallSiteOpts {
 
 export type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
 
+export interface ResolvedCallSiteConfig {
+  config: z.infer<typeof LLMConfigBase>;
+  profileName?: string;
+}
+
+export function resolveCallSiteConfigWithProfile(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+  opts: ResolveCallSiteOpts = {},
+): ResolvedCallSiteConfig {
+  const selection = selectWinningProfile(callSite, llm, opts);
+  return {
+    config: resolveOverrideOrDefault(callSite, llm, selection),
+    ...(selection.profileName ? { profileName: selection.profileName } : {}),
+  };
+}
+
 export function resolveCallSiteConfig(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
   opts: ResolveCallSiteOpts = {},
 ): z.infer<typeof LLMConfigBase> {
-  return resolveOverrideOrDefault(callSite, llm, opts);
+  return resolveCallSiteConfigWithProfile(callSite, llm, opts).config;
 }
 
 // ─── Single-winner profile resolution ───────────────────────────────────────
@@ -358,9 +375,8 @@ const CODE_DEFAULT_BASE: z.infer<typeof LLMConfigBase> = LLMConfigBase.parse(
 function resolveOverrideOrDefault(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
-  opts: ResolveCallSiteOpts,
+  selection: ProfileWinnerSelection,
 ): z.infer<typeof LLMConfigBase> {
-  const selection = selectWinningProfile(callSite, llm, opts);
   const winnerFragment: Mergeable =
     selection.entry == null ? {} : winnerConfigFragment(selection.entry);
 

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -120,6 +120,7 @@ import type { AssistantSurface } from "./conversation-agent-loop.js";
 import {
   buildConversationErrorMessage,
   classifyConversationError,
+  type ConversationErrorAttribution,
   maxTokensReachedClassification,
 } from "./conversation-error.js";
 import { buildDeferredFinalizeEffect } from "./conversation-turn-finalize.js";
@@ -555,6 +556,8 @@ export interface EventHandlerDeps {
    * degrades gracefully when it's absent.
    */
   readonly latencyTracker?: TurnLatencyTracker;
+  /** Best-effort resolved route metadata for provider error classification. */
+  readonly errorAttribution?: () => ConversationErrorAttribution;
 }
 
 // ── Factory ──────────────────────────────────────────────────────────
@@ -2628,9 +2631,7 @@ function handleError(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "error" }>,
 ): void {
-  const classified = classifyConversationError(event.error, {
-    phase: "agent_loop",
-  });
+  const classified = classifyAgentLoopError(event.error, deps);
   if (classified.errorCategory === "provider_api_error") {
     log.error(
       {
@@ -3140,9 +3141,7 @@ function handleProviderError(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "provider_error" }>,
 ): void {
-  const classified = classifyConversationError(event.error, {
-    phase: "agent_loop",
-  });
+  const classified = classifyAgentLoopError(event.error, deps);
   if (!shouldPersistProviderErrorAsAssistantMessage(classified)) {
     return;
   }
@@ -3164,6 +3163,16 @@ function handleProviderError(
   }
 }
 
+function classifyAgentLoopError(
+  error: Error,
+  deps: EventHandlerDeps,
+): ReturnType<typeof classifyConversationError> {
+  return classifyConversationError(error, {
+    phase: "agent_loop",
+    ...deps.errorAttribution?.(),
+  });
+}
+
 // ── Dispatcher ───────────────────────────────────────────────────────
 
 /** Routes an AgentEvent to the appropriate handler. */

package/src/daemon/conversation-agent-loop.ts

@@ -30,7 +30,7 @@ import {
 } from "../config/llm-context-resolution.js";
 import {
   resolveCallSiteConfig,
-  resolveEffectiveProfileKey,
+  resolveCallSiteConfigWithProfile,
   resolveProfilelessModelKey,
   selectWinningProfile,
 } from "../config/llm-resolver.js";
@@ -61,6 +61,11 @@ import { HOOKS } from "../plugin-api/constants.js";
 import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/conversation-graph-memory.js";
 import { enqueueMemoryRetrospectiveOnCompaction } from "../plugins/defaults/memory/memory-retrospective-enqueue.js";
 import { runHook } from "../plugins/pipeline.js";
+import { isManagedConnectionRoute } from "../providers/connection-resolution.js";
+import {
+  ConnectionResolutionError,
+  resolveRoutingIdentity,
+} from "../providers/routing-identity.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
@@ -95,6 +100,7 @@ import {
   budgetYieldUnrecoveredClassification,
   buildConversationErrorMessage,
   classifyConversationError,
+  type ConversationErrorAttribution,
   isUserCancellation,
 } from "./conversation-error.js";
 import { raceWithTimeout } from "./conversation-media-retry.js";
@@ -422,10 +428,7 @@ export async function runAgentLoopImpl(
   // connection and profile so credential/connection errors point at the
   // exact slot to fix instead of a generic banner. Resolution can itself
   // throw on a broken config — attribution must never mask the real error.
-  const turnErrorAttribution = (): {
-    connectionName?: string;
-    profileName?: string;
-  } => {
+  const turnErrorAttribution = (): ConversationErrorAttribution => {
     try {
       const overrideProfile = readCurrentOverrideProfile();
       const resolveOpts = {
@@ -433,21 +436,30 @@ export async function runAgentLoopImpl(
         forceOverrideProfile,
         selectionSeed: ctx.conversationId,
       };
-      const resolved = resolveCallSiteConfig(
-        turnCallSite,
-        config.llm,
-        resolveOpts,
-      );
-      const profileName = resolveEffectiveProfileKey(
-        turnCallSite,
-        config.llm,
-        resolveOpts,
-      );
+      const { config: resolved, profileName } =
+        resolveCallSiteConfigWithProfile(turnCallSite, config.llm, resolveOpts);
+      let connectionName = resolved.provider_connection;
+      try {
+        connectionName =
+          resolveRoutingIdentity(resolved.provider, resolved.model)
+            ?.connectionName ?? connectionName;
+      } catch (error) {
+        if (!(error instanceof ConnectionResolutionError)) {
+          throw error;
+        }
+        connectionName = error.connectionName;
+      }
+      // Managed-ness comes from the connection row, matching what dispatch
+      // decides. The profile's own provider can't stand in: a concrete
+      // provider tweak over a managed winner keeps the managed connection
+      // while replacing the provider (`llm-resolver.ts`).
+      const isManagedRoute = connectionName
+        ? isManagedConnectionRoute(connectionName)
+        : undefined;
       return {
-        ...(resolved.provider_connection
-          ? { connectionName: resolved.provider_connection }
-          : {}),
+        ...(connectionName ? { connectionName } : {}),
         ...(profileName ? { profileName } : {}),
+        ...(isManagedRoute !== undefined ? { isManagedRoute } : {}),
       };
     } catch {
       return {};
@@ -1049,6 +1061,7 @@ export async function runAgentLoopImpl(
       turnInterfaceContext: capturedTurnInterfaceContext,
       applyCompaction: applySuccessfulCompaction,
       latencyTracker,
+      errorAttribution: turnErrorAttribution,
     };
     const eventHandler = (event: AgentEvent): Promise<void> => {
       if (