@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/config/seed-inference-profiles.ts

@@ -9,13 +9,17 @@ import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getLogger } from "../util/logger.js";
 import {
-  getEffectiveProfiles,
+  getEffectiveProfilesForProvider,
   MANAGED_PROFILE_NAMES,
   MANAGED_PROFILE_TEMPLATES,
 } from "./default-profile-catalog.js";
 import { loadRawConfig, saveRawConfig } from "./loader.js";
 import { isDispatchableProfile } from "./profile-dispatchability.js";
-import { isDefaultProviderChoice, type ProfileEntry } from "./schemas/llm.js";
+import {
+  type DefaultProviderConfig,
+  isDefaultProviderChoice,
+  type ProfileEntry,
+} from "./schemas/llm.js";
 
 const log = getLogger("seed-inference-profiles");
 
@@ -141,8 +145,13 @@ export function seedInferenceProfiles(
   // Profile lookups below go through the effective view: a default profile
   // resolves from the code catalog whether or not the workspace carries a
   // stub for it, and a stub contributes only its status/label overlays.
-  const effectiveProfiles = getEffectiveProfiles(
+  // Resolved against `llm.defaultProvider` so the managed backups count as
+  // available only on the managed column, matching what the schema accepts
+  // as a reference: an `activeProfile` naming a backup on a BYOK install is
+  // then repaired here rather than preserved as a dangling selection.
+  const effectiveProfiles = getEffectiveProfilesForProvider(
     profiles as Record<string, ProfileEntry>,
+    seedResolutionDefaultProvider(llm),
   ) as Record<string, Record<string, unknown>>;
 
   // Active profile resolution.
@@ -230,6 +239,26 @@ export function seedInferenceProfiles(
   saveRawConfig(config);
 }
 
+/**
+ * The `llm.defaultProvider` to resolve the effective catalog against, read
+ * from RAW config. Only a value the matrix can implement is used: a
+ * hand-edited or legacy provider outside `DEFAULT_PROVIDER_CHOICES` has no
+ * column and no verified intent resolution, so materializing against it
+ * could throw and fail the whole boot seed. Such a value falls back to
+ * `null`, which resolves the managed column.
+ */
+function seedResolutionDefaultProvider(
+  llm: Record<string, unknown>,
+): DefaultProviderConfig | null {
+  const raw = readObject(llm.defaultProvider);
+  const provider = readString(raw?.provider);
+  if (provider === undefined || !isDefaultProviderChoice(provider)) {
+    return null;
+  }
+  const connectionName = readString(raw?.connectionName);
+  return { provider, ...(connectionName ? { connectionName } : {}) };
+}
+
 export function readObject(value: unknown): Record<string, unknown> | null {
   return value !== null && typeof value === "object" && !Array.isArray(value)
     ? (value as Record<string, unknown>)

package/src/config/skill-state.ts

@@ -1,3 +1,4 @@
+import { isSkillCompatibleWithPlatform } from "../skills/platform-compatibility.js";
 import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
 import type { AssistantConfig, SkillEntryConfig } from "./schema.js";
 import type { SkillSummary } from "./skills.js";
@@ -31,6 +32,10 @@ export function resolveSkillStates(
   };
 
   for (const skill of catalog) {
+    if (!isSkillCompatibleWithPlatform(skill)) {
+      continue;
+    }
+
     // Assistant feature flag gate: if the skill declares a flag and it's disabled, skip it
     const flagKey = skillFlagKey(skill);
     if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) {

package/src/config/skills.ts

@@ -18,11 +18,17 @@ import {
 
 import { z } from "zod";
 
+import type { ClientOs } from "../channels/types.js";
 import { getDefaultPluginSkillRoots } from "../plugins/defaults/main.js";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
 import { parseFrontmatterFields } from "../skills/frontmatter.js";
 import type { InlineCommandExpansion } from "../skills/inline-command-expansions.js";
 import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
+import {
+  normalizeSkillPlatforms,
+  SKILL_PLATFORM_VALUES,
+  type SkillPlatform,
+} from "../skills/platform-compatibility.js";
 import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import type { OwnerInfo } from "../tools/types.js";
@@ -50,6 +56,7 @@ const VellumMetadataSchema = z
     "avoid-when": z.array(z.string()).optional(),
     category: z.string().optional(),
     "always-candidate": z.boolean().optional(),
+    platforms: z.array(z.enum(SKILL_PLATFORM_VALUES)).optional(),
   })
   .passthrough();
 
@@ -128,6 +135,8 @@ export interface SkillSummary {
    * the model must judge, not embedding similarity.
    */
   alwaysCandidate?: boolean;
+  /** Host operating systems on which this skill may be offered and loaded. */
+  platforms?: SkillPlatform[];
   /** Parsed inline command expansion descriptors (`!\`command\``) found in the skill body. */
   inlineCommandExpansions?: InlineCommandExpansion[];
 }
@@ -184,6 +193,8 @@ export interface SkillToolEntry {
   executor: string;
   /** Where the tool script runs. */
   execution_target: "host" | "sandbox";
+  /** Client operating systems that may expose this tool. Unset means all. */
+  supported_client_os?: ClientOs[];
 }
 
 /**
@@ -251,6 +262,7 @@ interface ParsedFrontmatter {
   avoidWhen?: string[];
   category?: string;
   alwaysCandidate?: boolean;
+  platforms?: SkillPlatform[];
   inlineCommandExpansions?: InlineCommandExpansion[];
 }
 
@@ -373,6 +385,8 @@ function parseFrontmatter(
       ? vellum["always-candidate"]
       : undefined;
 
+  const platforms = normalizeSkillPlatforms(vellum?.platforms);
+
   const strippedBody = stripCommentLines(body);
 
   // Parse inline command expansions from the body (after frontmatter/comment stripping)
@@ -398,6 +412,7 @@ function parseFrontmatter(
     avoidWhen,
     category,
     alwaysCandidate,
+    platforms,
     inlineCommandExpansions,
   };
 }
@@ -558,6 +573,7 @@ function readSkillFromDirectory(
       avoidWhen: parsed.avoidWhen,
       category: parsed.category,
       alwaysCandidate: parsed.alwaysCandidate,
+      platforms: parsed.platforms,
       inlineCommandExpansions: parsed.inlineCommandExpansions,
     };
   } catch (err) {
@@ -614,6 +630,7 @@ function readBundledSkillFromDirectory(
       avoidWhen: parsed.avoidWhen,
       category: parsed.category,
       alwaysCandidate: parsed.alwaysCandidate,
+      platforms: parsed.platforms,
       inlineCommandExpansions: parsed.inlineCommandExpansions,
     };
   } catch (err) {
@@ -682,6 +699,7 @@ function loadBundledSkills(): SkillSummary[] {
       avoidWhen: skill.avoidWhen,
       category: skill.category,
       alwaysCandidate: skill.alwaysCandidate,
+      platforms: skill.platforms,
       inlineCommandExpansions: skill.inlineCommandExpansions,
     });
   }
@@ -972,6 +990,7 @@ function skillSummaryFromDefinition(
     avoidWhen: skill.avoidWhen,
     category: skill.category,
     alwaysCandidate: skill.alwaysCandidate,
+    platforms: skill.platforms,
     inlineCommandExpansions: skill.inlineCommandExpansions,
   };
 }
@@ -1035,6 +1054,7 @@ export function loadSkillCatalog(
             avoidWhen: parsed.avoidWhen,
             category: parsed.category,
             alwaysCandidate: parsed.alwaysCandidate,
+            platforms: parsed.platforms,
             inlineCommandExpansions: parsed.inlineCommandExpansions,
           });
         } catch (err) {
@@ -1182,6 +1202,7 @@ export function loadSkillCatalog(
           avoidWhen: parsed.avoidWhen,
           category: parsed.category,
           alwaysCandidate: parsed.alwaysCandidate,
+          platforms: parsed.platforms,
           inlineCommandExpansions: parsed.inlineCommandExpansions,
         };
 

package/src/contacts/notify-contacts-changed.ts

@@ -1,3 +1,4 @@
+import { invalidateAllContactThresholdCaches } from "../permissions/gateway-threshold-reader.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { invalidateGuardianContactCache } from "./guardian-contact-reader.js";
 import { invalidateGuardianDeliveryCache } from "./guardian-delivery-reader.js";
@@ -7,11 +8,13 @@ import { invalidateGuardianDeliveryCache } from "./guardian-delivery-reader.js";
  * a successful contact write:
  *
  * - broadcasts `contacts_changed` so connected clients refresh their view, and
- * - drops the guardian-contact and guardian-delivery caches so the next read
- *   refetches from the gateway instead of serving a stale set.
+ * - drops the guardian-contact, guardian-delivery, and contact-threshold
+ *   caches so the next read refetches from the gateway instead of serving
+ *   a stale set.
  */
 export function notifyContactsChanged(): void {
   broadcastMessage({ type: "contacts_changed" });
   invalidateGuardianContactCache();
   invalidateGuardianDeliveryCache();
+  invalidateAllContactThresholdCaches();
 }

package/src/context/compactor.ts

@@ -75,6 +75,40 @@ const COMPACTION_CALL_SITE: LLMCallSite = "mainAgent";
  */
 const COMPACTION_LOG_CALL_SITE: LLMCallSite = "compactionAgent";
 
+/**
+ * What actually served a compaction call, for attribution on both the request
+ * log and the usage row. A wrapper may reroute the request away from the
+ * caller's resolution (`RetryProvider`'s fallback-profile escalation), in
+ * which case the response carries the provider and profile that answered.
+ *
+ * Single source of truth on purpose: the request log and the usage row must
+ * never disagree about which provider ran, and every result-construction site
+ * below spreads {@link servedAttribution} rather than re-deriving the pair.
+ */
+function servedProvider(
+  response: ProviderResponse,
+  provider: Provider,
+): string {
+  return response.actualProvider ?? provider.name;
+}
+
+function servedAttribution(
+  response: ProviderResponse,
+  provider: Provider,
+): Pick<
+  CompactionRunResult,
+  "summaryActualProvider" | "summaryActualInferenceProfile"
+> {
+  return {
+    summaryActualProvider: servedProvider(response, provider),
+    // Only present on a reroute. Absent leaves `summaryOverrideProfile` in
+    // charge, which is what the caller resolved and what actually ran.
+    ...(response.actualInferenceProfile !== undefined
+      ? { summaryActualInferenceProfile: response.actualInferenceProfile }
+      : {}),
+  };
+}
+
 /**
  * Best-effort: persist a successful compaction LLM call into
  * `llm_request_logs` with `call_site = "compactionAgent"`. The compactor
@@ -100,7 +134,7 @@ function recordCompactionRequestLog(
       JSON.stringify(response.rawRequest),
       JSON.stringify(response.rawResponse),
       undefined,
-      response.actualProvider ?? provider.name,
+      servedProvider(response, provider),
       COMPACTION_LOG_CALL_SITE,
     );
   } catch (err) {
@@ -321,6 +355,22 @@ export interface CompactionRunResult {
   summaryModel: string;
   summaryCallSite?: LLMCallSite;
   summaryOverrideProfile?: string | null;
+  /**
+   * Provider that actually served the summary call: the response's
+   * `actualProvider` when a wrapper rerouted the request, otherwise the
+   * configured provider's name. Set on every path that made a call, so the
+   * usage row's `provider` follows a fallback the way its `model` already
+   * does. Absent only where no call happened (see {@link emptyResult}), where
+   * the caller's own provider stands.
+   */
+  summaryActualProvider?: string;
+  /**
+   * Inference profile that actually governed the summary call, set only when
+   * a wrapper rerouted the request away from `summaryOverrideProfile`
+   * (`RetryProvider`'s fallback-profile escalation). Absent on the normal
+   * path, where `summaryOverrideProfile` is already correct.
+   */
+  summaryActualInferenceProfile?: string;
   summaryCacheCreationInputTokens?: number;
   summaryCacheReadInputTokens?: number;
   summaryRawResponses?: unknown[];
@@ -1052,6 +1102,18 @@ export function buildSummaryMemoryText(
 // Orchestrator
 // ---------------------------------------------------------------------------
 
+/**
+ * A result for every path that compacted nothing: the pre-call bail-outs
+ * (disabled, below threshold, no messages, bad boundary) and the two
+ * provider-error paths, which are spread over with `summaryFailed: true`.
+ *
+ * Deliberately carries no `summaryActualProvider` /
+ * `summaryActualInferenceProfile`: no call was served, so there is nothing to
+ * attribute to, and leaving them absent keeps the caller's own provider and
+ * profile in charge. Nothing is billed either way, since the zero token
+ * counts here make `recordUsage` return before it writes a row. The
+ * call-bearing paths below spread {@link servedAttribution} on top.
+ */
 function emptyResult(
   args: CompactionRunArgs,
   thresholdTokens: number,
@@ -1340,6 +1402,7 @@ export async function runAssistantDrivenCompaction(
       summaryInputTokens: response.usage.inputTokens,
       summaryOutputTokens: response.usage.outputTokens,
       summaryModel: response.model,
+      ...servedAttribution(response, args.provider),
       summaryCacheCreationInputTokens:
         response.usage.cacheCreationInputTokens ?? 0,
       summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
@@ -1378,6 +1441,7 @@ export async function runAssistantDrivenCompaction(
         summaryInputTokens: response.usage.inputTokens,
         summaryOutputTokens: response.usage.outputTokens,
         summaryModel: response.model,
+        ...servedAttribution(response, args.provider),
         summaryCacheCreationInputTokens:
           response.usage.cacheCreationInputTokens ?? 0,
         summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
@@ -1548,6 +1612,7 @@ export async function runAssistantDrivenCompaction(
       summaryInputTokens: response.usage.inputTokens,
       summaryOutputTokens: response.usage.outputTokens,
       summaryModel: response.model,
+      ...servedAttribution(response, args.provider),
       summaryCacheCreationInputTokens:
         response.usage.cacheCreationInputTokens ?? 0,
       summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
@@ -1623,6 +1688,7 @@ export async function runAssistantDrivenCompaction(
     summaryModel: response.model,
     summaryCallSite: COMPACTION_CALL_SITE,
     summaryOverrideProfile: args.overrideProfile ?? null,
+    ...servedAttribution(response, args.provider),
     summaryCacheCreationInputTokens:
       response.usage.cacheCreationInputTokens ?? 0,
     summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
@@ -1808,6 +1874,12 @@ export async function runEmergencyCompaction(
       summaryInputTokens: response.usage.inputTokens,
       summaryOutputTokens: response.usage.outputTokens,
       summaryModel: response.model,
+      // This path bills real tokens, so its provider must follow a reroute
+      // like every other call-bearing path. It is the one such path that sets
+      // no `summaryCallSite`/`summaryOverrideProfile`, which leaves its
+      // profile attribution null; that gap predates this change and is not
+      // widened by it.
+      ...servedAttribution(response, args.provider),
     };
   }
 
@@ -1855,6 +1927,7 @@ export async function runEmergencyCompaction(
     summaryModel: response.model,
     summaryCallSite: COMPACTION_CALL_SITE,
     summaryOverrideProfile: args.overrideProfile ?? null,
+    ...servedAttribution(response, args.provider),
     summaryCacheCreationInputTokens:
       response.usage.cacheCreationInputTokens ?? 0,
     summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -36,14 +36,28 @@ import type { ChannelCapabilities } from "../conversation-runtime-assembly.js";
 
 // Control how many capable clients the hub reports per capability.
 const mockClientCountByCapability = new Map<string, number>();
+const mockClientsByCapability = new Map<
+  string,
+  Array<{
+    clientId: string;
+    capabilities: string[];
+    interfaceId: string;
+    actorPrincipalId?: string;
+  }>
+>();
 
 mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     listClientsByCapability: (cap: string) => {
+      const clients = mockClientsByCapability.get(cap);
+      if (clients) {
+        return clients;
+      }
       const count = mockClientCountByCapability.get(cap) ?? 0;
       return Array.from({ length: count }, (_, i) => ({
         clientId: `mock-${cap}-client-${i}`,
         capabilities: [cap],
+        interfaceId: "macos",
       }));
     },
   },
@@ -58,6 +72,9 @@ const {
   HOST_TOOL_TO_CAPABILITY,
   isToolActiveForContext,
 } = await import("../conversation-tool-setup.js");
+const { registerSkillTools, unregisterSkillTools } =
+  await import("../../tools/registry.js");
+const { finalizeTool } = await import("../../tools/tool-defaults.js");
 type SkillProjectionCache =
   import("../conversation-skill-tools.js").SkillProjectionCache;
 
@@ -76,9 +93,129 @@ function makeCtx(
 
 beforeEach(() => {
   mockClientCountByCapability.clear();
+  mockClientsByCapability.clear();
 });
 
-describe("isToolActiveForContext — Slack task_progress UI exception", () => {
+describe("isToolActiveForContext - client OS eligibility", () => {
+  test("hides a macOS-only skill tool from Windows turns", () => {
+    const skillId = "client-os-test-skill";
+    registerSkillTools(skillId, [
+      finalizeTool({
+        name: "client_os_test_tool",
+        supportedClientOs: ["macos"],
+      }),
+    ]);
+
+    try {
+      expect(
+        isToolActiveForContext(
+          "client_os_test_tool",
+          makeCtx({
+            clientOs: "windows",
+            currentTurnClientOs: "windows",
+          }),
+        ),
+      ).toBe(false);
+      expect(
+        isToolActiveForContext(
+          "client_os_test_tool",
+          makeCtx({ clientOs: "macos", currentTurnClientOs: "macos" }),
+        ),
+      ).toBe(true);
+    } finally {
+      unregisterSkillTools(skillId);
+    }
+  });
+
+  test("uses same-user target desktops for cross-client tool eligibility", () => {
+    const skillId = "cross-client-os-test-skill";
+    registerSkillTools(skillId, [
+      finalizeTool({
+        name: "computer_use_platform_test",
+        supportedClientOs: ["macos"],
+      }),
+    ]);
+    const ctx = makeCtx({
+      clientOs: "web",
+      currentTurnClientOs: "web",
+      transportInterface: "web",
+      getTurnActorPrincipalId: () => "actor-1",
+    });
+
+    try {
+      mockClientsByCapability.set("host_cu", [
+        {
+          clientId: "mac-client",
+          capabilities: ["host_cu"],
+          interfaceId: "macos",
+          actorPrincipalId: "actor-1",
+        },
+      ]);
+      expect(isToolActiveForContext("computer_use_platform_test", ctx)).toBe(
+        true,
+      );
+
+      mockClientsByCapability.set("host_cu", [
+        {
+          clientId: "windows-client",
+          capabilities: ["host_cu"],
+          interfaceId: "windows",
+          actorPrincipalId: "actor-1",
+        },
+      ]);
+      expect(isToolActiveForContext("computer_use_platform_test", ctx)).toBe(
+        false,
+      );
+    } finally {
+      unregisterSkillTools(skillId);
+    }
+  });
+
+  test("uses pinned client OS without falling through to live context", () => {
+    const skillId = "pinned-client-os-test-skill";
+    registerSkillTools(skillId, [
+      finalizeTool({
+        name: "client_os_pinned_test_tool",
+        supportedClientOs: ["macos"],
+      }),
+    ]);
+
+    try {
+      expect(
+        isToolActiveForContext(
+          "client_os_pinned_test_tool",
+          makeCtx({
+            clientOs: "windows",
+            currentTurnClientOs: "windows",
+            toolContextPin: {
+              hasNoClient: false,
+              transportInterface: "macos",
+              clientOs: "macos",
+            },
+          }),
+        ),
+      ).toBe(true);
+      expect(
+        isToolActiveForContext(
+          "client_os_pinned_test_tool",
+          makeCtx({
+            clientOs: "macos",
+            currentTurnClientOs: "macos",
+            toolContextPin: {
+              hasNoClient: false,
+              transportInterface: "windows",
+              clientOs: "windows",
+            },
+          }),
+        ),
+      ).toBe(false);
+    } finally {
+      unregisterSkillTools(skillId);
+    }
+  });
+});
+
+describe("isToolActiveForContext - Slack task_progress UI exception", () => {
   test("ui_show and ui_update are active for Slack task_progress turns", () => {
     const ctx = makeCtx({
       hasNoClient: false,

package/src/daemon/config-watcher.ts

@@ -15,6 +15,8 @@ import {
 } from "node:fs";
 import { basename, join } from "node:path";
 
+import { AVATAR_IMAGE_FILENAME } from "@vellumai/avatar-manifest";
+
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
 import { resetCleanupScheduleThrottle } from "../persistence/cleanup-schedule-state.js";
@@ -37,7 +39,6 @@ import { WORKSPACE_THEME_RELATIVE_PATH } from "../theme/workspace-theme.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import {
-  AVATAR_IMAGE_FILENAME,
   getAvatarDir,
   getSignalsDir,
   getSoundsDir,

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

@@ -211,6 +211,15 @@ export interface EventHandlerState {
   firstAssistantText: string;
   /** Most recent resolved provider for the current exchange's usage accounting. */
   exchangeProviderName: string | undefined;
+  /**
+   * Inference profile the most recent LLM call actually ran under, set only
+   * when a wrapper rerouted that call (`RetryProvider`'s fallback-profile
+   * escalation). Overwritten by every call, exactly like
+   * `exchangeProviderName` and `model`, so the ledger row's provider, model,
+   * and profile all describe the same call. `undefined` means the last call
+   * was not rerouted and the conversation's own profile resolution stands.
+   */
+  exchangeInferenceProfile: string | undefined;
   exchangeInputTokens: number;
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
@@ -236,6 +245,14 @@ export interface EventHandlerState {
    * the loop persists the failure as an assistant message.
    */
   providerErrorCategory: string | null;
+  /**
+   * Connection and profile attribution of the most recent provider error
+   * (`classifyConversationError(...).connectionName` / `.profileName`).
+   * Carried into the turn's outcome stamp so failure consumers scope
+   * identity by the route the call actually resolved.
+   */
+  providerErrorConnection: string | null;
+  providerErrorProfile: string | null;
   persistProviderErrorAsAssistantMessage: boolean;
   lastAssistantMessageId: string | undefined;
   /**
@@ -578,6 +595,7 @@ export function createEventHandlerState(): EventHandlerState {
     pendingDirectiveDisplayBuffer: "",
     firstAssistantText: "",
     exchangeProviderName: undefined,
+    exchangeInferenceProfile: undefined,
     exchangeInputTokens: 0,
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
@@ -589,6 +607,8 @@ export function createEventHandlerState(): EventHandlerState {
     providerErrorUserMessage: null,
     providerErrorCode: null,
     providerErrorCategory: null,
+    providerErrorConnection: null,
+    providerErrorProfile: null,
     persistProviderErrorAsAssistantMessage: false,
     lastAssistantMessageId: undefined,
     assistantRowAwaitingFinalization: false,
@@ -2722,6 +2742,8 @@ function handleError(
   state.providerErrorUserMessage = classified.userMessage;
   state.providerErrorCode = classified.code;
   state.providerErrorCategory = classified.errorCategory;
+  state.providerErrorConnection = classified.connectionName ?? null;
+  state.providerErrorProfile = classified.profileName ?? null;
   state.persistProviderErrorAsAssistantMessage =
     shouldPersistProviderErrorAsAssistantMessage(classified);
 }
@@ -3071,6 +3093,11 @@ function handleUsage(
 ): void {
   const providerName = event.actualProvider ?? deps.ctx.provider.name;
   state.exchangeProviderName = providerName;
+  // Assigned unconditionally, not merged: a later non-rerouted call clearing
+  // this back to `undefined` is correct, because provider and model are being
+  // overwritten from that same call. Keeping a stale profile from an earlier
+  // fallback would reintroduce the very contradiction this field prevents.
+  state.exchangeInferenceProfile = event.actualInferenceProfile;
   state.exchangeLlmCallCount += 1;
   state.exchangeInputTokens += event.inputTokens;
   state.lastCallInputTokens = event.inputTokens;