@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/providers/__tests__/retry-callsite.test.ts

@@ -27,6 +27,9 @@ mock.module("../registry.js", () => ({
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
 import { CODE_DEFAULT_PROFILE_ENTRIES } from "../../config/default-profile-catalog.js";
+import { getDb } from "../../persistence/db-connection.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import { resetSubagentAttributionCacheForTests } from "../../usage/subagent-attribution.js";
 import { RetryProvider } from "../retry.js";
 import type {
   Message,
@@ -188,6 +191,70 @@ describe("RetryProvider — callSite resolution", () => {
     ).toBeUndefined();
   });
 
+  // Delegated-work attribution on the authoritative billing path. Every
+  // subagent variety shares `llm_call_site = "subagentSpawn"`, so these two
+  // orthogonal headers are what let rated usage be decomposed by variety.
+  test("forwards subagent role and spawn mode headers for a subagent conversation", async () => {
+    await initializeDb();
+    resetSubagentAttributionCacheForTests();
+    getDb().run(
+      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode)
+       VALUES ('conv-retry-advisor', 'background', 1000, 1000, 'advisor', 'advisor_consult')`,
+    );
+    setLlmConfig({
+      callSites: { subagentSpawn: { provider: "openai", model: "gpt-sub" } },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("openai", (options) => {
+        seen = options;
+      }),
+      { forwardUsageAttributionHeaders: true },
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: {
+        callSite: "subagentSpawn",
+        conversationId: "conv-retry-advisor",
+      },
+    });
+
+    const headers = (seen?.config as Record<string, unknown>)
+      .usageAttributionHeaders as Record<string, string>;
+    expect(headers["X-Vellum-Subagent-Role"]).toBe("advisor");
+    expect(headers["X-Vellum-Subagent-Spawn-Mode"]).toBe("advisor_consult");
+  });
+
+  test("omits subagent headers for a conversation that is not a subagent", async () => {
+    await initializeDb();
+    resetSubagentAttributionCacheForTests();
+    getDb().run(
+      `INSERT INTO conversations (id, conversation_type, created_at, updated_at)
+       VALUES ('conv-retry-plain', 'standard', 1000, 1000)`,
+    );
+    setLlmConfig({
+      callSites: { subagentSpawn: { provider: "openai", model: "gpt-sub" } },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("openai", (options) => {
+        seen = options;
+      }),
+      { forwardUsageAttributionHeaders: true },
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "subagentSpawn", conversationId: "conv-retry-plain" },
+    });
+
+    const headers = (seen?.config as Record<string, unknown>)
+      .usageAttributionHeaders as Record<string, string>;
+    expect(headers["X-Vellum-Subagent-Role"]).toBeUndefined();
+    expect(headers["X-Vellum-Subagent-Spawn-Mode"]).toBeUndefined();
+  });
+
   test("omits attribution headers by default for direct provider transports", async () => {
     setLlmConfig({
       callSites: {

package/src/providers/__tests__/vellum-connection-routing.test.ts

@@ -9,8 +9,9 @@ import { migrateProviderConnectionStatusLabel } from "../../persistence/migratio
 import { migrateProviderConnectionBaseUrlAndModels } from "../../persistence/migrations/250-provider-connection-base-url-and-models.js";
 import * as schema from "../../persistence/schema/index.js";
 import { createAdapterFromConnection } from "../inference/adapter-factory.js";
-import type { ProviderConnection } from "../inference/auth.js";
+import type { Auth, ProviderConnection } from "../inference/auth.js";
 import type { ResolvedAuth } from "../inference/auth.js";
+import { effectiveConnectionAuth } from "../inference/auth.js";
 import {
   createConnection,
   getConnection,
@@ -44,16 +45,11 @@ const resolvedAuth: ResolvedAuth = {
 describe("vellum connection routing", () => {
   test("isVellumManagedConnection identifies the sentinel connection", () => {
     expect(isVellumManagedConnection(vellumConnection)).toBe(true);
-    expect(
-      isVellumManagedConnection({
-        provider: "fireworks",
-        auth: { type: "platform" },
-      }),
-    ).toBe(false);
-    // `vellum` provider with non-platform auth is not a managed vellum route.
-    expect(
-      isVellumManagedConnection({ provider: "vellum", auth: { type: "none" } }),
-    ).toBe(false);
+    // The provider column alone decides: a concrete provider is never the
+    // managed route (platform auth always pairs with provider "vellum";
+    // DB migration 361 reconciles stored rows).
+    expect(isVellumManagedConnection({ provider: "fireworks" })).toBe(false);
+    expect(isVellumManagedConnection({ provider: "vellum" })).toBe(true);
   });
 
   test("the vellum sentinel is not a real provider without an override", () => {
@@ -82,6 +78,41 @@ describe("vellum connection routing", () => {
   });
 });
 
+describe("effectiveConnectionAuth", () => {
+  test("a vellum row dispatches on platform auth regardless of the stored variant", () => {
+    for (const stored of [
+      { type: "api_key", credential: "vault/x" },
+      { type: "none" },
+      { type: "platform" },
+    ] as Auth[]) {
+      expect(
+        effectiveConnectionAuth({ provider: "vellum", auth: stored }),
+      ).toEqual({ type: "platform" });
+    }
+  });
+
+  test("payload-carrying rows keep their stored auth verbatim", () => {
+    const keyed: Auth = { type: "api_key", credential: "vault/anthropic" };
+    expect(
+      effectiveConnectionAuth({ provider: "anthropic", auth: keyed }),
+    ).toBe(keyed);
+    const subscription: Auth = { type: "oauth_subscription" } as Auth;
+    expect(
+      effectiveConnectionAuth({ provider: "openai", auth: subscription }),
+    ).toBe(subscription);
+  });
+
+  test("a deliberately keyed keyless provider keeps its key", () => {
+    // Keyless means no key REQUIRED, not no key possible: the ollama adapter
+    // accepts one, so stored api_key auth on an ollama row is payload and
+    // must never be derived away.
+    const keyed: Auth = { type: "api_key", credential: "vault/ollama" };
+    expect(effectiveConnectionAuth({ provider: "ollama", auth: keyed })).toBe(
+      keyed,
+    );
+  });
+});
+
 describe("vellum connection persistence (DB round-trip)", () => {
   // Guards the P1: a persisted `provider: "vellum"` row must survive the DB
   // loaders and create route, which validate against VALID_CONNECTION_PROVIDERS.

package/src/providers/anthropic/client.ts

@@ -18,6 +18,12 @@ import {
   PLACEHOLDER_EMPTY_TURN,
 } from "../placeholder-sentinels.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
+import {
+  analyzeServerToolPairing,
+  isServerToolUseBlock,
+  isWebSearchToolResultBlock,
+  type ServerToolPairing,
+} from "../server-tool-pairing.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import type {
   ContentBlock,
@@ -489,73 +495,54 @@ function normalizeFollowingUserContent(
   };
 }
 
-/** Type-guard for server_tool_use blocks. */
-function isServerToolUseBlock(
-  block: unknown,
-): block is { type: "server_tool_use"; id: string; name: string } {
-  return (
-    typeof block === "object" &&
-    block != null &&
-    (block as { type: string }).type === "server_tool_use"
-  );
-}
-
-/** Type-guard for web_search_tool_result blocks. */
-function isWebSearchToolResultBlock(block: unknown): block is {
-  type: "web_search_tool_result";
-  tool_use_id: string;
-  content: unknown;
-} {
-  return (
-    typeof block === "object" &&
-    block != null &&
-    (block as { type: string }).type === "web_search_tool_result"
-  );
-}
-
 /**
- * Repair orphaned server-side tool blocks within assistant messages. Server-
- * side tools (e.g. web_search) are self-paired: the assistant message should
- * contain both server_tool_use and its matching web_search_tool_result. Either
- * side can go missing — a partial stream may drop the result, or a downstream
- * step (history reload, message split, compaction) may drop the use block.
- * Both cases trigger an Anthropic 400 on the next request, so this function
- * handles both directions:
+ * Repair orphaned server-side tool blocks within assistant messages, using the
+ * cross-message pairing from {@link analyzeServerToolPairing}. A pair can go
+ * missing on either side: a partial stream may drop the result, or a
+ * downstream step (history reload, message split, compaction) may drop the use
+ * block. Both cases trigger an Anthropic 400 on the next request, so this
+ * function handles both directions:
  *
- *   - server_tool_use without paired result: inject a synthetic error result.
- *   - web_search_tool_result without paired server_tool_use: downgrade to a
+ *   - server_tool_use without a paired result: inject a synthetic error
+ *     result.
+ *   - web_search_tool_result without a paired server_tool_use: downgrade to a
  *     text block describing what was found so the model retains context.
+ *
+ * Deferred use blocks (see {@link ServerToolPairing.deferredUseIds}) are not
+ * orphans: they are left intact so the provider executes the search on this
+ * request instead of seeing a synthetic failure.
  */
 function repairOrphanedServerToolBlocks(
   messages: Anthropic.MessageParam[],
+  pairing: ServerToolPairing,
 ): Anthropic.MessageParam[] {
+  if (pairing.deferredUseIds.size > 0) {
+    log.info(
+      { deferredIds: Array.from(pairing.deferredUseIds) },
+      "Preserving deferred server_tool_use blocks for provider-side execution",
+    );
+  }
   return messages.map((msg) => {
     if (msg.role !== "assistant") {
       return msg;
     }
     const content = Array.isArray(msg.content) ? msg.content : [];
 
-    const serverToolUseIds = new Set<string>();
-    const webSearchResultIds = new Set<string>();
-    for (const block of content) {
-      if (isServerToolUseBlock(block)) {
-        serverToolUseIds.add(block.id);
-      }
-      if (isWebSearchToolResultBlock(block)) {
-        webSearchResultIds.add(block.tool_use_id);
-      }
-    }
-
     const orphanServerToolUseIds = new Set<string>();
-    for (const id of serverToolUseIds) {
-      if (!webSearchResultIds.has(id)) {
-        orphanServerToolUseIds.add(id);
-      }
-    }
     const orphanWebSearchResultIds = new Set<string>();
-    for (const id of webSearchResultIds) {
-      if (!serverToolUseIds.has(id)) {
-        orphanWebSearchResultIds.add(id);
+    for (const block of content) {
+      if (
+        isServerToolUseBlock(block) &&
+        !pairing.resolvedPairIds.has(block.id) &&
+        !pairing.deferredUseIds.has(block.id)
+      ) {
+        orphanServerToolUseIds.add(block.id);
+      }
+      if (
+        isWebSearchToolResultBlock(block) &&
+        !pairing.resolvedPairIds.has(block.tool_use_id)
+      ) {
+        orphanWebSearchResultIds.add(block.tool_use_id);
       }
     }
 
@@ -709,9 +696,18 @@ function findActiveToolUseContinuationStart(
 
 function ensureToolPairing(
   messages: Anthropic.MessageParam[],
+  pairing: ServerToolPairing,
 ): Anthropic.MessageParam[] {
   const result: Anthropic.MessageParam[] = [];
 
+  // Messages carrying a deferred or cross-message-paired server tool block
+  // must go out verbatim: the provider pairs and executes these blocks across
+  // messages itself, and reordering or splitting them breaks that pairing.
+  const verbatimIds = new Set([
+    ...pairing.deferredUseIds,
+    ...pairing.crossMessageIds,
+  ]);
+
   let i = 0;
   while (i < messages.length) {
     const msg = messages[i];
@@ -724,8 +720,23 @@ function ensureToolPairing(
 
     const content = Array.isArray(msg.content) ? msg.content : [];
 
+    const hasVerbatimServerBlock =
+      verbatimIds.size > 0 &&
+      content.some(
+        (block) =>
+          (isServerToolUseBlock(block) && verbatimIds.has(block.id)) ||
+          (isWebSearchToolResultBlock(block) &&
+            verbatimIds.has(block.tool_use_id)),
+      );
+
     const { pairedContent, carryoverContent, toolUseIds } =
-      splitAssistantForToolPairing(content);
+      hasVerbatimServerBlock
+        ? {
+            pairedContent: content,
+            carryoverContent: [] as Anthropic.ContentBlockParam[],
+            toolUseIds: getOrderedToolUseIds(content),
+          }
+        : splitAssistantForToolPairing(content);
 
     if (toolUseIds.length === 0) {
       result.push(msg);
@@ -976,7 +987,7 @@ export class AnthropicProvider implements Provider {
     // edge LB, NAT idle) — only the latter should be retried.
     let innerTimeoutSignal: AbortSignal | undefined;
     try {
-      sentMessages = this.buildSentMessages(messages);
+      sentMessages = await this.buildSentMessages(messages);
       const {
         effort,
         speed,
@@ -1169,7 +1180,10 @@ export class AnthropicProvider implements Provider {
         }
         return -1;
       };
-      const applyCacheControlToLastBlock = (msgIdx: number): void => {
+      const applyCacheControlToLastBlock = (
+        msgIdx: number,
+        control: typeof cacheControl | typeof tailCacheControl = cacheControl,
+      ): void => {
         const content = msgs[msgIdx].content;
         if (!Array.isArray(content) || content.length === 0) {
           return;
@@ -1177,27 +1191,30 @@ export class AnthropicProvider implements Provider {
         const lastBlock = content[content.length - 1];
         if (typeof lastBlock !== "string") {
           (lastBlock as unknown as Record<string, unknown>).cache_control =
-            cacheControl;
+            control;
         }
       };
       const turnStartIdx = findUserTextMsgIdx(msgs.length - 1);
-      // When the latest user message is volatile (`mutableLatestUserMessage`)
-      // and it is itself the turn-start (first-of-turn, no tool-use loop yet),
-      // skip the long-TTL anchor here — it would land on per-turn-varying
-      // content and never hit again. The previous-turn anchor below becomes the
-      // primary stable breakpoint. During tool-use loops (`turnStartIdx <
-      // msgs.length - 1`) the turn-start block is fixed within the turn, so
-      // behavior is unchanged. Independent from `disableTurnStartCache`, which
-      // expresses a different intent (one-shot callers with no future hit).
-      const skipVolatileTurnStartAnchor =
-        mutableLatestUserMessage && turnStartIdx === msgs.length - 1;
-      if (
-        turnStartIdx >= 0 &&
-        !disableCache &&
-        !disableTurnStartCache &&
-        !skipVolatileTurnStartAnchor
-      ) {
-        applyCacheControlToLastBlock(turnStartIdx);
+      // Turn-start anchor. A volatile turn start (`mutableLatestUserMessage`:
+      // the message carries a per-turn block that will not recur next turn)
+      // takes the SHORT TTL instead of the long one. The long TTL would buy
+      // nothing: the bytes change next turn, so that entry can never be read
+      // across turns, and the only reads it can serve are this turn's tool-loop
+      // iterations, which the short TTL already serves, refreshing on each
+      // hit. Marking the same boundary at two different TTLs across a turn
+      // bills two writes for one reusable prefix, the long one at the higher
+      // write multiplier.
+      //
+      // The signal is turn-scoped, not request-scoped: it describes the
+      // turn-starting user message, so it holds for every request in the turn
+      // and the TTL chosen here stays consistent as the tool loop advances.
+      // `disableTurnStartCache` is independent: it expresses a different
+      // intent (one-shot callers with no future hit).
+      if (turnStartIdx >= 0 && !disableCache && !disableTurnStartCache) {
+        applyCacheControlToLastBlock(
+          turnStartIdx,
+          mutableLatestUserMessage ? tailCacheControl : cacheControl,
+        );
       }
 
       // Previous-turn anchor: when this request is the first of a new turn
@@ -1223,26 +1240,19 @@ export class AnthropicProvider implements Provider {
 
       // Advancing tail: place a short-lived 5m cache breakpoint on the last
       // block of the last message. This caches the growing tail cheaply
-      // without conflicting with the 1h breakpoints above. It fires during
-      // tool-use loops (the tail falls after the turn-starting user message)
-      // and also on a first-of-turn request whose volatile turn-start anchor
-      // was skipped while a previous-turn anchor exists: there the latest
-      // message would otherwise carry no breakpoint, so the next request's
-      // anchor can land far ahead of the previous-turn anchor and Anthropic's
-      // ~20-block cache lookback can't bridge the gap — forcing a full
-      // re-creation of the prefix. The 5m breakpoint gives the next call an
-      // exact, reachable boundary; cross-turn it expires harmlessly. The
-      // first-of-turn bridge lands on the turn-start block, so it honors
-      // `disableTurnStartCache` like the long-TTL anchor above. Skip
+      // without conflicting with the long-TTL breakpoints above. It fires
+      // during tool-use loops, where the tail falls after the turn-starting
+      // user message: without it the next iteration's anchor can land far
+      // ahead of the last written boundary and Anthropic's ~20-block cache
+      // lookback can't bridge the gap, forcing a full re-creation of the
+      // prefix. On a first-of-turn request the tail IS the turn-start message,
+      // which the anchor above already marks, so no bridge is needed. Skip
       // thinking/redacted_thinking blocks — Anthropic doesn't allow
       // cache_control on those types.
       if (
         !disableCache &&
         turnStartIdx >= 0 &&
-        (turnStartIdx < sentMessages.length - 1 ||
-          (skipVolatileTurnStartAnchor &&
-            turnStartIdx > 0 &&
-            !disableTurnStartCache))
+        turnStartIdx < sentMessages.length - 1
       ) {
         const lastMsg = sentMessages[sentMessages.length - 1];
         if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
@@ -1272,10 +1282,11 @@ export class AnthropicProvider implements Provider {
       // system is a single block or absent) + at most two message anchors
       // ≤ 4 — Anthropic's per-request cap. The two message anchors are
       // turn-start + prev-turn-anchor (first-of-turn), turn-start + tail
-      // (tool-use loop), or prev-turn-anchor + tail (first-of-turn with the
+      // (tool-use loop), prev-turn-anchor + tail (first-of-turn with the
       // volatile turn-start anchor skipped — the freed turn-start slot covers
-      // the tail). At most two message-level breakpoints are placed, so the
-      // total can't drift past 4.
+      // the tail), or the tail alone (volatile first turn, where no
+      // previous turn exists to anchor). At most two message-level
+      // breakpoints are placed, so the total can't drift past 4.
 
       // Strip orphaned UTF-16 surrogates so the Anthropic JSON parser never
       // sees invalid strings produced by upstream surrogate-splitting `.slice()` calls.
@@ -1801,7 +1812,7 @@ export class AnthropicProvider implements Provider {
     systemPrompt: string,
     tools?: ToolDefinition[],
   ): Promise<number> {
-    const sentMessages = this.buildSentMessages(messages);
+    const sentMessages = await this.buildSentMessages(messages);
 
     const system = systemPrompt
       ? systemPrompt
@@ -1837,10 +1848,12 @@ export class AnthropicProvider implements Provider {
    * `cache_control` breakpoints (which don't affect token counts) are the
    * only thing layered on top in `sendMessage`.
    */
-  private buildSentMessages(messages: Message[]): Anthropic.MessageParam[] {
+  private async buildSentMessages(
+    messages: Message[],
+  ): Promise<Anthropic.MessageParam[]> {
     // Swap any persisted attachment references back to inline base64 before
     // serializing, so the block transforms below can read `source.data`.
-    messages = resolveMediaReferences(messages);
+    messages = await resolveMediaReferences(messages);
     const formatted = messages
       .map((m) => {
         // Track whether an unknown block was dropped during filtering
@@ -2014,7 +2027,11 @@ export class AnthropicProvider implements Provider {
       formatted[i] = { ...msg, content: stripped };
     }
 
-    return ensureToolPairing(repairOrphanedServerToolBlocks(formatted));
+    const serverToolPairing = analyzeServerToolPairing(formatted);
+    return ensureToolPairing(
+      repairOrphanedServerToolBlocks(formatted, serverToolPairing),
+      serverToolPairing,
+    );
   }
 
   /**

package/src/providers/connection-resolution.ts

@@ -27,6 +27,7 @@
  *      a conversation offline.
  */
 
+import { getIsPlatform } from "../config/env-registry.js";
 import {
   resolveCallSiteConfig,
   selectWinningProfile,
@@ -468,7 +469,40 @@ export async function preflightResolvedConfig(
         errorOptions,
       );
     }
-    if ((await platformLoginPresence()) === "unauthenticated") {
+    const presence = await platformLoginPresence();
+    if (presence === "ok") {
+      return;
+    }
+    if (getIsPlatform()) {
+      // A platform-managed assistant cannot present a login screen or switch
+      // providers, so the login-or-switch wording never fits. An unreachable
+      // store is transient and recovers on its own, so it reads as a retry. A
+      // reachable but empty store can only be fixed by re-provisioning the
+      // credential platform-side.
+      if (presence === "indeterminate") {
+        throw new ConnectionResolutionError(
+          connectionName,
+          "platform_unauthenticated",
+          "The assistant's platform credentials are temporarily unavailable; retrying automatically.",
+          errorOptions,
+        );
+      }
+      log.error(
+        {
+          connectionName,
+          model: resolved.model,
+          profileName: attribution.profileName,
+        },
+        "Managed platform credential is missing and must be re-provisioned",
+      );
+      throw new ConnectionResolutionError(
+        connectionName,
+        "platform_unauthenticated",
+        "This assistant's platform credential is missing and must be re-provisioned on the Vellum platform.",
+        errorOptions,
+      );
+    }
+    if (presence === "unauthenticated") {
       throw new ConnectionResolutionError(
         connectionName,
         "platform_unauthenticated",

package/src/providers/gemini/client.ts

@@ -434,7 +434,7 @@ export class GeminiProvider implements Provider {
 
     try {
       recordProviderRequestDiagnostics({ model_id: activeModel });
-      const geminiContents = this.toGeminiContents(messages, activeModel);
+      const geminiContents = await this.toGeminiContents(messages, activeModel);
 
       const geminiConfig: genai.GenerateContentConfig = {};
 
@@ -658,7 +658,7 @@ export class GeminiProvider implements Provider {
     systemPrompt: string,
     tools?: ToolDefinition[],
   ): Promise<number> {
-    const contents = this.toGeminiContents(messages, this.model);
+    const contents = await this.toGeminiContents(messages, this.model);
     const config: genai.CountTokensConfig = {};
     if (systemPrompt) {
       config.systemInstruction = systemPrompt.replaceAll(
@@ -689,13 +689,13 @@ export class GeminiProvider implements Provider {
   }
 
   /** Convert neutral messages to Gemini Content[] format. */
-  private toGeminiContents(
+  private async toGeminiContents(
     messages: Message[],
     model: string,
-  ): genai.Content[] {
+  ): Promise<genai.Content[]> {
     // Swap any persisted attachment references back to inline base64 before
     // building parts, so the transforms below can read `source.data`.
-    messages = resolveMediaReferences(messages);
+    messages = await resolveMediaReferences(messages);
     const result: genai.Content[] = [];
 
     // Build a map from tool_use id → function name so tool_result blocks

package/src/providers/inference/adapter-factory.ts

@@ -34,9 +34,11 @@ import { RetryProvider } from "../retry.js";
 import { TogetherProvider } from "../together/client.js";
 import type { Provider } from "../types.js";
 import { UsageTrackingProvider } from "../usage-tracking.js";
+import { isVellumManagedConnection } from "../vellum-model-routing.js";
 import { VercelAIGatewayProvider } from "../vercel-ai-gateway/client.js";
 import type { ResolvedAuth } from "./auth.js";
 import type { ProviderConnection } from "./auth.js";
+import { effectiveConnectionAuth } from "./auth.js";
 import { resolveAuth } from "./resolve-auth.js";
 
 /** Unified construction opts. Adapters ignore fields they don't consume. */
@@ -244,9 +246,11 @@ export function createAdapterFromConnection(
   function makeCredentialRefresher(): () => Promise<Provider | null> {
     let lastAuth = JSON.stringify(resolvedAuth);
     return async (): Promise<Provider | null> => {
-      const refreshedAuth = await resolveAuth(connection.auth, provider, {
-        baseUrl: connection.baseUrl,
-      });
+      const refreshedAuth = await resolveAuth(
+        effectiveConnectionAuth(connection),
+        provider,
+        { baseUrl: connection.baseUrl },
+      );
       if (!refreshedAuth.ok) {
         return null;
       }
@@ -262,19 +266,20 @@ export function createAdapterFromConnection(
   // Usage-attribution headers (`X-Vellum-*`) are only meaningful when the
   // request is routed through the Vellum-managed proxy. They carry billing
   // metadata for our own backend. Forwarding them to a third-party endpoint
-  // would leak internal Vellum metadata, so gate on the auth type:
-  // `platform` is the only auth that flows through our proxy.
-  const isManagedProxy = connection.auth.type === "platform";
+  // would leak internal Vellum metadata, so gate on the managed connection
+  // identity, the only route that flows through our proxy.
+  const isManagedProxy = isVellumManagedConnection(connection);
+  const effectiveAuth = effectiveConnectionAuth(connection);
   return new UsageTrackingProvider(
     new RetryProvider(adapter, {
       forwardUsageAttributionHeaders: isManagedProxy,
       credentialSource: isManagedProxy
         ? "vellum-managed"
-        : connection.auth.type === "api_key"
+        : effectiveAuth.type === "api_key"
           ? "byok"
-          : connection.auth.type === "oauth_subscription"
+          : effectiveAuth.type === "oauth_subscription"
             ? "oauth-subscription"
-            : connection.auth.type === "none"
+            : effectiveAuth.type === "none"
               ? "no-auth"
               : undefined,
       connectionName: connection.name,
@@ -320,7 +325,8 @@ function buildConnectionAdapter(
       : undefined;
 
   const codexSubscription =
-    connection.auth.type === "oauth_subscription" && provider === "openai";
+    effectiveConnectionAuth(connection).type === "oauth_subscription" &&
+    provider === "openai";
 
   const adapter = buildProviderAdapter(provider, {
     apiKey,

package/src/providers/inference/auth.ts

@@ -72,6 +72,22 @@ export function deriveAuthForProvider(
   return credential ? { type: "api_key", credential } : null;
 }
 
+/**
+ * The auth a connection dispatches with. The stored auth object is
+ * authoritative only where it carries a payload (an api_key credential ref,
+ * the oauth_subscription marker, a deliberately keyed keyless provider);
+ * the vellum provider IS the managed route, so its auth derives from the
+ * provider and the stored value can never mislead dispatch.
+ */
+export function effectiveConnectionAuth(connection: {
+  provider: string;
+  auth: Auth;
+}): Auth {
+  return connection.provider === VELLUM_MANAGED_PROVIDER
+    ? { type: "platform" }
+    : connection.auth;
+}
+
 // ---------------------------------------------------------------------------
 // ResolvedAuth — what the dispatcher hands to each adapter
 // ---------------------------------------------------------------------------