Share Codex usage provider resolution

lintowe · lintowe · commit 575e9e20f0f5 · 2026-05-08T17:48:40.000+03:00
diff --git a/apps/web/src/components/BranchToolbar.tsx b/apps/web/src/components/BranchToolbar.tsx
@@ -1,10 +1,5 @@
 import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime";
-import {
-  ProviderDriverKind,
-  type EnvironmentId,
-  type ServerProvider,
-  type ThreadId,
-} from "@t3tools/contracts";
+import { type EnvironmentId, type ProviderInstanceId, type ThreadId } from "@t3tools/contracts";
 import type { CodexUsageIndicatorMode } from "@t3tools/contracts/settings";
 import {
   ChevronDownIcon,
@@ -44,11 +39,6 @@ import {
   MenuTrigger,
 } from "./ui/menu";
 import { Separator } from "./ui/separator";
-import {
-  deriveProviderInstanceEntries,
-  resolveProviderDriverKindForInstanceSelection,
-  sortProviderInstanceEntries,
-} from "../providerInstances";
 
 interface BranchToolbarProps {
   environmentId: EnvironmentId;
@@ -63,8 +53,8 @@ interface BranchToolbarProps {
   onComposerFocusRequest?: () => void;
   availableEnvironments?: readonly EnvironmentOption[];
   onEnvironmentChange?: (environmentId: EnvironmentId) => void;
-  providerStatuses: readonly ServerProvider[];
   codexUsageIndicatorMode: CodexUsageIndicatorMode;
+  codexUsageInstanceId: ProviderInstanceId | null;
 }
 
 interface MobileRunContextSelectorProps {
@@ -216,8 +206,8 @@ export const BranchToolbar = memo(function BranchToolbar({
   onComposerFocusRequest,
   availableEnvironments,
   onEnvironmentChange,
-  providerStatuses,
   codexUsageIndicatorMode,
+  codexUsageInstanceId,
 }: BranchToolbarProps) {
   const threadRef = useMemo(
     () => scopeThreadRef(environmentId, threadId),
@@ -228,9 +218,6 @@ export const BranchToolbar = memo(function BranchToolbar({
   const draftThread = useComposerDraftStore((store) =>
     draftId ? store.getDraftSession(draftId) : store.getDraftThreadByRef(threadRef),
   );
-  const composerDraft = useComposerDraftStore((store) =>
-    store.getComposerDraft(draftId ?? threadRef),
-  );
   const activeProjectRef = serverThread
     ? scopeProjectRef(serverThread.environmentId, serverThread.projectId)
     : draftThread
@@ -255,30 +242,7 @@ export const BranchToolbar = memo(function BranchToolbar({
   const showEnvironmentPicker = Boolean(
     availableEnvironments && availableEnvironments.length > 1 && onEnvironmentChange,
   );
-  const providerInstanceEntries = useMemo(
-    () => sortProviderInstanceEntries(deriveProviderInstanceEntries(providerStatuses)),
-    [providerStatuses],
-  );
-  const selectedInstanceId =
-    composerDraft?.activeProvider ??
-    serverThread?.session?.providerInstanceId ??
-    serverThread?.modelSelection.instanceId ??
-    activeProject?.defaultModelSelection?.instanceId ??
-    null;
-  const selectedProvider =
-    resolveProviderDriverKindForInstanceSelection(
-      providerInstanceEntries,
-      providerStatuses,
-      selectedInstanceId,
-    ) ?? ProviderDriverKind.make("codex");
-  const selectedEntry = selectedInstanceId
-    ? providerInstanceEntries.find((entry) => entry.instanceId === selectedInstanceId)
-    : providerInstanceEntries.find(
-        (entry) => entry.driverKind === selectedProvider && entry.enabled,
-      );
-  const showCodexUsage =
-    codexUsageIndicatorMode !== "off" &&
-    selectedEntry?.driverKind === ProviderDriverKind.make("codex");
+  const showCodexUsage = codexUsageIndicatorMode !== "off" && codexUsageInstanceId !== null;
   const isMobile = useIsMobile();
 
   if (!hasActiveThread || !activeProject) return null;
@@ -316,11 +280,11 @@ export const BranchToolbar = memo(function BranchToolbar({
             activeWorktreePath={activeWorktreePath}
             onEnvModeChange={onEnvModeChange}
           />
-          {showCodexUsage && selectedEntry ? (
+          {showCodexUsage ? (
             <>
               <Separator orientation="vertical" className="mx-0.5 h-3.5!" />
               <CodexUsageIndicator
-                instanceId={selectedEntry.instanceId}
+                instanceId={codexUsageInstanceId}
                 mode={codexUsageIndicatorMode}
               />
             </>
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
@@ -118,6 +118,11 @@ import { newCommandId, newDraftId, newMessageId, newThreadId } from "~/lib/utils
 import { getProviderModelCapabilities, resolveSelectableProvider } from "../providerModels";
 import { useSettings } from "../hooks/useSettings";
 import { resolveAppModelSelectionForInstance } from "../modelSelection";
+import {
+  deriveProviderInstanceEntries,
+  resolveSelectedProviderInstanceId,
+  sortProviderInstanceEntries,
+} from "../providerInstances";
 import { isTerminalFocused } from "../lib/terminalFocus";
 import { deriveLogicalProjectKeyFromSettings } from "../logicalProject";
 import {
@@ -1257,11 +1262,56 @@ export default function ChatView(props: ChatViewProps) {
     versionMismatchServerLabel,
   ]);
   const providerStatuses = serverConfig?.providers ?? EMPTY_PROVIDERS;
+  const providerInstanceEntries = useMemo(
+    () => sortProviderInstanceEntries(deriveProviderInstanceEntries(providerStatuses)),
+    [providerStatuses],
+  );
   const unlockedSelectedProvider = resolveSelectableProvider(
     providerStatuses,
     selectedProviderByThreadId ?? threadProvider ?? ProviderDriverKind.make("codex"),
   );
   const selectedProvider: ProviderDriverKind = lockedProvider ?? unlockedSelectedProvider;
+  const lockedContinuationGroupKey = useMemo((): string | null => {
+    if (!lockedProvider || !activeThread) return null;
+    const lockedInstanceId =
+      activeThread.session?.providerInstanceId ?? activeThread.modelSelection.instanceId;
+    if (!lockedInstanceId) return null;
+    return (
+      providerInstanceEntries.find((entry) => entry.instanceId === lockedInstanceId)
+        ?.continuationGroupKey ?? null
+    );
+  }, [activeThread, lockedProvider, providerInstanceEntries]);
+  const codexUsageInstanceId = useMemo(() => {
+    if (settings.codexUsageIndicatorMode === "off") return null;
+    const selectedInstanceId = resolveSelectedProviderInstanceId({
+      entries: providerInstanceEntries,
+      candidates: [
+        composerActiveProvider,
+        activeThread?.session?.providerInstanceId,
+        activeThread?.modelSelection.instanceId,
+        activeProject?.defaultModelSelection?.instanceId,
+      ],
+      selectedProvider,
+      lockedProvider,
+      lockedContinuationGroupKey,
+    });
+    const selectedEntry = providerInstanceEntries.find(
+      (entry) => entry.instanceId === selectedInstanceId,
+    );
+    return selectedEntry?.driverKind === ProviderDriverKind.make("codex")
+      ? selectedEntry.instanceId
+      : null;
+  }, [
+    activeProject?.defaultModelSelection?.instanceId,
+    activeThread?.modelSelection.instanceId,
+    activeThread?.session?.providerInstanceId,
+    composerActiveProvider,
+    lockedContinuationGroupKey,
+    lockedProvider,
+    providerInstanceEntries,
+    selectedProvider,
+    settings.codexUsageIndicatorMode,
+  ]);
   const phase = derivePhase(activeThread?.session ?? null);
   const threadActivities = activeThread?.activities ?? EMPTY_ACTIVITIES;
   const workLogEntries = useMemo(
@@ -3642,6 +3692,7 @@ export default function ChatView(props: ChatViewProps) {
                   interactionMode={interactionMode}
                   lockedProvider={lockedProvider}
                   providerStatuses={providerStatuses as ServerProvider[]}
+                  providerInstanceEntries={providerInstanceEntries}
                   activeProjectDefaultModelSelection={activeProject?.defaultModelSelection}
                   activeThreadModelSelection={activeThread?.modelSelection}
                   activeThreadActivities={activeThread?.activities}
@@ -3685,8 +3736,8 @@ export default function ChatView(props: ChatViewProps) {
                 threadId={activeThread.id}
                 {...(routeKind === "draft" && draftId ? { draftId } : {})}
                 onEnvModeChange={onEnvModeChange}
-                providerStatuses={providerStatuses as ServerProvider[]}
                 codexUsageIndicatorMode={settings.codexUsageIndicatorMode}
+                codexUsageInstanceId={codexUsageInstanceId}
                 {...(canOverrideServerThreadEnvMode ? { effectiveEnvModeOverride: envMode } : {})}
                 {...(canOverrideServerThreadEnvMode
                   ? {
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
@@ -98,9 +98,8 @@ import {
 import { proposedPlanTitle } from "../../proposedPlan";
 import { getProviderInteractionModeToggle } from "../../providerModels";
 import {
-  deriveProviderInstanceEntries,
   resolveProviderDriverKindForInstanceSelection,
-  sortProviderInstanceEntries,
+  resolveSelectedProviderInstanceId,
   type ProviderInstanceEntry,
 } from "../../providerInstances";
 import { type AppModelOption, getAppModelOptionsForInstance } from "../../modelSelection";
@@ -432,6 +431,7 @@ export interface ChatComposerProps {
   // Provider / model
   lockedProvider: ProviderDriverKind | null;
   providerStatuses: ServerProvider[];
+  providerInstanceEntries: ReadonlyArray<ProviderInstanceEntry>;
   activeProjectDefaultModelSelection: ModelSelection | null | undefined;
   activeThreadModelSelection: ModelSelection | null | undefined;
 
@@ -526,6 +526,7 @@ export const ChatComposer = memo(
       interactionMode,
       lockedProvider,
       providerStatuses,
+      providerInstanceEntries,
       activeProjectDefaultModelSelection,
       activeThreadModelSelection,
       activeThreadActivities,
@@ -591,13 +592,6 @@ export const ChatComposer = memo(
     // ------------------------------------------------------------------
     // Model state
     // ------------------------------------------------------------------
-    // Instance-aware projection of the wire provider list. One entry per
-    // configured instance (default built-in + any custom `providerInstances.*`),
-    // sorted default-first per driver kind for a stable picker order.
-    const providerInstanceEntries = useMemo<ReadonlyArray<ProviderInstanceEntry>>(
-      () => sortProviderInstanceEntries(deriveProviderInstanceEntries(providerStatuses)),
-      [providerStatuses],
-    );
     const selectedProviderByThreadId = composerDraft.activeProvider ?? null;
     const threadProvider =
       activeThread?.session?.providerInstanceId ??
@@ -629,66 +623,24 @@ export const ChatComposer = memo(
       providerInstanceEntries,
     ]);
 
-    // Resolve which configured instance the composer is currently targeting.
-    // Priority:
-    //   1. The composer draft's `activeProvider` — the user's unsaved pick
-    //      from the model picker (must win, otherwise the UI appears to
-    //      ignore picker selections).
-    //   2. Thread's persisted instance id (server-side saved selection).
-    //   3. Project default's instance id.
-    //   4. First enabled entry matching the current driver kind.
-    //   5. First enabled entry overall / default instance for the kind.
-    //
     const selectedInstanceId = useMemo<ProviderInstanceId>(() => {
-      const candidates: Array<string | null | undefined> = [
-        composerDraft.activeProvider,
-        activeThread?.session?.providerInstanceId,
-        activeThreadModelSelection?.instanceId,
-        activeProjectDefaultModelSelection?.instanceId,
-      ];
-      for (const candidate of candidates) {
-        if (!candidate) continue;
-        const match = providerInstanceEntries.find(
-          (entry) => entry.instanceId === candidate && entry.enabled,
-        );
-        if (match) {
-          // When locked to a specific driver kind, ignore persisted instance
-          // ids from a different kind or continuation group.
-          if (lockedProvider && match.driverKind !== lockedProvider) continue;
-          if (
-            lockedContinuationGroupKey &&
-            match.continuationGroupKey !== lockedContinuationGroupKey
-          ) {
-            continue;
-          }
-          return match.instanceId;
-        }
-      }
-      if (explicitSelectedInstanceId) {
-        return ProviderInstanceId.make(explicitSelectedInstanceId);
-      }
-      const byKind = providerInstanceEntries.find(
-        (entry) =>
-          entry.enabled &&
-          entry.driverKind === selectedProvider &&
-          (!lockedContinuationGroupKey ||
-            entry.continuationGroupKey === lockedContinuationGroupKey),
-      );
-      if (byKind) return byKind.instanceId;
-      const anyEnabled = providerInstanceEntries.find((entry) => entry.enabled);
-      return (
-        anyEnabled?.instanceId ??
-        providerInstanceEntries[0]?.instanceId ??
-        activeThreadModelSelection?.instanceId ??
-        activeProjectDefaultModelSelection?.instanceId ??
-        ProviderInstanceId.make("codex")
-      );
+      return resolveSelectedProviderInstanceId({
+        entries: providerInstanceEntries,
+        candidates: [
+          composerDraft.activeProvider,
+          activeThread?.session?.providerInstanceId,
+          activeThreadModelSelection?.instanceId,
+          activeProjectDefaultModelSelection?.instanceId,
+        ],
+        selectedProvider,
+        lockedProvider,
+        lockedContinuationGroupKey,
+      });
     }, [
       activeProjectDefaultModelSelection?.instanceId,
       activeThread?.session?.providerInstanceId,
       activeThreadModelSelection?.instanceId,
       composerDraft.activeProvider,
-      explicitSelectedInstanceId,
       lockedContinuationGroupKey,
       lockedProvider,
       providerInstanceEntries,
diff --git a/apps/web/src/providerInstances.ts b/apps/web/src/providerInstances.ts
@@ -16,7 +16,7 @@ import {
   defaultInstanceIdForDriver,
   PROVIDER_DISPLAY_NAMES,
   type ProviderDriverKind,
-  type ProviderInstanceId,
+  ProviderInstanceId,
   type ServerProvider,
   type ServerProviderModel,
   type ServerProviderState,
@@ -184,6 +184,44 @@ export function sortProviderInstanceEntries(
   return sorted;
 }
 
+export function resolveSelectedProviderInstanceId(input: {
+  entries: ReadonlyArray<ProviderInstanceEntry>;
+  candidates: ReadonlyArray<ProviderInstanceId | null | undefined>;
+  selectedProvider: ProviderDriverKind;
+  lockedProvider?: ProviderDriverKind | null | undefined;
+  lockedContinuationGroupKey?: string | null | undefined;
+}): ProviderInstanceId {
+  const lockedProvider = input.lockedProvider ?? null;
+  const lockedContinuationGroupKey = input.lockedContinuationGroupKey ?? null;
+  const explicitSelection = input.candidates.find((candidate) => candidate != null);
+
+  for (const candidate of input.candidates) {
+    if (!candidate) continue;
+    const match = input.entries.find((entry) => entry.instanceId === candidate && entry.enabled);
+    if (!match) continue;
+    if (lockedProvider && match.driverKind !== lockedProvider) continue;
+    if (lockedContinuationGroupKey && match.continuationGroupKey !== lockedContinuationGroupKey) {
+      continue;
+    }
+    return match.instanceId;
+  }
+
+  if (explicitSelection) {
+    return ProviderInstanceId.make(explicitSelection);
+  }
+
+  const byKind = input.entries.find(
+    (entry) =>
+      entry.enabled &&
+      entry.driverKind === input.selectedProvider &&
+      (!lockedContinuationGroupKey || entry.continuationGroupKey === lockedContinuationGroupKey),
+  );
+  if (byKind) return byKind.instanceId;
+
+  const anyEnabled = input.entries.find((entry) => entry.enabled);
+  return anyEnabled?.instanceId ?? input.entries[0]?.instanceId ?? ProviderInstanceId.make("codex");
+}
+
 /**
  * Look up a single instance entry by exact `instanceId`. Missing snapshots
  * are not inferred from driver kind in UI routing code.
