From 3ea07a40e378a6846aa0868f37fbaeadee5429a2 Mon Sep 17 00:00:00 2001 From: Lukas Boguth Date: Mon, 9 Nov 2026 13:05:42 +0100 Subject: [PATCH 1/4] feat: reorder providers in settings and follow that order everywhere MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Providers in Settings → Providers can be reordered by dragging the grip or with the arrow keys on it. The order is saved in server settings (`providerOrder`), so every device on the environment sees it. Usage, Limits and the model picker on web and mobile follow it; without a saved order they keep today's ordering. --- .../features/usage/UsageDailyChart.ios.tsx | 5 +- .../src/features/usage/UsageDailyChart.tsx | 5 +- .../src/features/usage/UsageLimitsPooled.tsx | 5 +- .../src/features/usage/UsageRouteScreen.tsx | 25 +++- .../src/features/usage/usageChartData.ts | 5 +- .../src/features/usage/usageProviders.ts | 26 ++++ apps/mobile/src/lib/modelOptions.test.ts | 7 + apps/mobile/src/lib/modelOptions.ts | 8 +- .../settings/ProviderInstanceCard.tsx | 4 + .../settings/ProviderSettingsPanel.tsx | 138 +++++++++++++++++- apps/web/src/components/usage/UsageLimits.tsx | 11 +- .../usage/UsageLimitsPooled.browser.test.tsx | 6 +- .../components/usage/UsageLimitsPooled.tsx | 4 +- apps/web/src/components/usage/UsagePage.tsx | 18 ++- .../src/components/usage/usageProviders.ts | 17 +++ apps/web/src/providerInstances.test.ts | 28 ++++ apps/web/src/providerInstances.ts | 9 +- apps/web/src/state/usage.ts | 17 +++ apps/web/src/textGenerators.ts | 2 +- docs/user/usage.md | 5 + packages/contracts/src/settings.ts | 5 + packages/shared/package.json | 4 + packages/shared/src/providerOrder.test.ts | 58 ++++++++ packages/shared/src/providerOrder.ts | 42 ++++++ packages/shared/src/serverSettings.test.ts | 8 +- packages/shared/src/serverSettings.ts | 2 + packages/shared/src/usageLimits.test.ts | 29 ++++ packages/shared/src/usageLimits.ts | 44 +++--- 28 files changed, 484 insertions(+), 53 deletions(-) create mode 100644 packages/shared/src/providerOrder.test.ts create mode 100644 packages/shared/src/providerOrder.ts diff --git a/apps/mobile/src/features/usage/UsageDailyChart.ios.tsx b/apps/mobile/src/features/usage/UsageDailyChart.ios.tsx index 9f0ebc61df91a..ae055c6553c37 100644 --- a/apps/mobile/src/features/usage/UsageDailyChart.ios.tsx +++ b/apps/mobile/src/features/usage/UsageDailyChart.ios.tsx @@ -4,7 +4,7 @@ import { frame } from "@expo/ui/swift-ui/modifiers"; import type { DailyTotals } from "@t3tools/shared/usageMerge"; import { buildChartDays, type UsageChartMetric } from "./usageChartData"; -import { useProviderColors } from "./usageProviders"; +import { PROVIDER_ORDER, useProviderColors, useSavedUsageProviderOrder } from "./usageProviders"; export interface UsageDailyChartProps { readonly days: readonly string[]; @@ -15,8 +15,9 @@ export interface UsageDailyChartProps { export function UsageDailyChart({ days, daily, metric, height }: UsageDailyChartProps) { const colors = useProviderColors(); + const providerOrder = useSavedUsageProviderOrder() ?? PROVIDER_ORDER; - const data: ChartDataPoint[] = buildChartDays(days, daily, metric).flatMap((day) => + const data: ChartDataPoint[] = buildChartDays(days, daily, metric, providerOrder).flatMap((day) => day.values.map((entry) => ({ x: day.day, y: entry.value, diff --git a/apps/mobile/src/features/usage/UsageDailyChart.tsx b/apps/mobile/src/features/usage/UsageDailyChart.tsx index 5d64cf9dbc7e7..6478e370f572b 100644 --- a/apps/mobile/src/features/usage/UsageDailyChart.tsx +++ b/apps/mobile/src/features/usage/UsageDailyChart.tsx @@ -3,7 +3,7 @@ import { View } from "react-native"; import type { DailyTotals } from "@t3tools/shared/usageMerge"; import { buildChartDays, type UsageChartMetric } from "./usageChartData"; -import { useProviderColors } from "./usageProviders"; +import { PROVIDER_ORDER, useProviderColors, useSavedUsageProviderOrder } from "./usageProviders"; export interface UsageDailyChartProps { readonly days: readonly string[]; @@ -14,7 +14,8 @@ export interface UsageDailyChartProps { export function UsageDailyChart({ days, daily, metric, height }: UsageDailyChartProps) { const colors = useProviderColors(); - const chartDays = buildChartDays(days, daily, metric); + const providerOrder = useSavedUsageProviderOrder() ?? PROVIDER_ORDER; + const chartDays = buildChartDays(days, daily, metric, providerOrder); const max = chartDays.reduce((peak, day) => Math.max(peak, day.total), 0); return ( diff --git a/apps/mobile/src/features/usage/UsageLimitsPooled.tsx b/apps/mobile/src/features/usage/UsageLimitsPooled.tsx index 218a7f21feb18..d78c02588fd0b 100644 --- a/apps/mobile/src/features/usage/UsageLimitsPooled.tsx +++ b/apps/mobile/src/features/usage/UsageLimitsPooled.tsx @@ -28,7 +28,7 @@ import { ProviderIcon } from "../../components/ProviderIcon"; import { SettingsScreen } from "../settings/components/SettingsScreen"; import { environmentPresentations } from "../../state/presentation"; import { ResetCredits } from "./UsageLimitsSection"; -import { usageProviderKind, useProviderColors } from "./usageProviders"; +import { usageProviderKind, useProviderColors, useSavedDriverOrder } from "./usageProviders"; const PACE_LABEL = { ahead: "Ahead of pace", on: "On pace", under: "Under pace" } as const; @@ -417,7 +417,8 @@ export function UsageLimitsSection({ selectedEnvironmentIds === null ? presentations : new Map([...presentations].filter(([id]) => selectedEnvironmentIds.has(id))); - const pools = collectLimitPools(collectLimitAccounts(selected), now); + const driverOrder = useSavedDriverOrder(); + const pools = collectLimitPools(collectLimitAccounts(selected), now, driverOrder); const notices = collectLimitNotices(selected); const externalLinks = collectExternalUsageLinks(selected); const colors = useProviderColors(); diff --git a/apps/mobile/src/features/usage/UsageRouteScreen.tsx b/apps/mobile/src/features/usage/UsageRouteScreen.tsx index 4287cc3e1cbef..2607179191f3a 100644 --- a/apps/mobile/src/features/usage/UsageRouteScreen.tsx +++ b/apps/mobile/src/features/usage/UsageRouteScreen.tsx @@ -27,6 +27,7 @@ import { makeWindow, usageSourceMessages, } from "@t3tools/shared/usageFormat"; +import { sortByProviderOrder } from "@t3tools/shared/providerOrder"; import { use, useRef, useState, type ReactNode } from "react"; import { View } from "react-native"; import { RefreshControl } from "../../components/ui/RefreshControl"; @@ -47,7 +48,12 @@ import { toggleUsageEnvironment } from "./usageEnvironmentSelection"; import { useRefreshLimits } from "./UsageLimitsSection"; import { UsageLimitsSection } from "./UsageLimitsPooled"; import type { UsageChartMetric } from "./usageChartData"; -import { PROVIDER_LABEL, useProviderColors, useUsageMixColors } from "./usageProviders"; +import { + PROVIDER_LABEL, + useProviderColors, + useSavedUsageProviderOrder, + useUsageMixColors, +} from "./usageProviders"; type UsageView = UsageChartMetric | "limits"; const VIEW_OPTIONS = [ @@ -427,6 +433,11 @@ function ChartCard(props: { }) { const { merged, metric } = props; const colors = useProviderColors(); + const savedOrder = useSavedUsageProviderOrder(); + const legendProviders = + savedOrder === null + ? merged.providers + : sortByProviderOrder(merged.providers, savedOrder, (provider) => provider.provider); const hasActivity = props.daily.some((period) => period.totalTokens > 0); const [fillHeight, setFillHeight] = useState(0); const height = props.fill ? Math.max(fillHeight, props.height) : props.height; @@ -475,7 +486,7 @@ function ChartCard(props: { - {merged.providers.map((provider) => ( + {legendProviders.map((provider) => ( - metric === "cost" ? b.costUsd - a.costUsd : b.totalTokens - a.totalTokens, - ); + const ordered = + savedOrder === null + ? [...merged.providers].sort((a, b) => + metric === "cost" ? b.costUsd - a.costUsd : b.totalTokens - a.totalTokens, + ) + : sortByProviderOrder(merged.providers, savedOrder, (provider) => provider.provider); return ( diff --git a/apps/mobile/src/features/usage/usageChartData.ts b/apps/mobile/src/features/usage/usageChartData.ts index 0826adf7587a5..4fc7af5aa1689 100644 --- a/apps/mobile/src/features/usage/usageChartData.ts +++ b/apps/mobile/src/features/usage/usageChartData.ts @@ -1,8 +1,6 @@ import type { UsageProviderKind } from "@t3tools/contracts"; import type { DailyTotals } from "@t3tools/shared/usageMerge"; -import { PROVIDER_ORDER } from "./usageProviders"; - export type UsageChartMetric = "cost" | "tokens"; export interface UsageChartDay { @@ -15,11 +13,12 @@ export function buildChartDays( days: readonly string[], daily: readonly DailyTotals[], metric: UsageChartMetric, + providerOrder: readonly UsageProviderKind[], ): readonly UsageChartDay[] { const byDay = new Map(daily.map((totals) => [totals.day, totals])); return days.map((day) => { const totals = byDay.get(day); - const values = PROVIDER_ORDER.map((provider) => { + const values = providerOrder.map((provider) => { const entry = totals?.byProvider.get(provider); const value = entry === undefined ? 0 : metric === "cost" ? entry.costUsd : entry.totalTokens; return { provider, value }; diff --git a/apps/mobile/src/features/usage/usageProviders.ts b/apps/mobile/src/features/usage/usageProviders.ts index ce9c778a77762..1eb4bb4b2568c 100644 --- a/apps/mobile/src/features/usage/usageProviders.ts +++ b/apps/mobile/src/features/usage/usageProviders.ts @@ -1,4 +1,12 @@ +import { useAtomValue } from "@effect/atom-react"; import type { UsageProviderKind } from "@t3tools/contracts"; +import { + firstProviderOrderSettings, + providerDriverOrder, + sortByProviderOrder, +} from "@t3tools/shared/providerOrder"; + +import { environmentPresentations } from "../../state/presentation"; import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider"; export const PROVIDER_ORDER: readonly UsageProviderKind[] = [ @@ -17,6 +25,24 @@ export function usageProviderKind(driver: string): UsageProviderKind | null { return PROVIDER_ORDER.find((kind) => kind === driver) ?? null; } +/** Driver kinds from the first environment with a saved order in Settings → Providers. */ +export function useSavedDriverOrder(): readonly string[] { + const presentations = useAtomValue(environmentPresentations.presentationsAtom); + const settings = firstProviderOrderSettings( + [...presentations.values()].map((presentation) => presentation.serverConfig?.settings), + ); + return settings === null ? [] : providerDriverOrder(settings); +} + +/** Null until an environment saves an order; each section then keeps its own ranking. */ +export function useSavedUsageProviderOrder(): readonly UsageProviderKind[] | null { + const driverOrder = useSavedDriverOrder(); + if (driverOrder.length === 0) return null; + return sortByProviderOrder(PROVIDER_ORDER, driverOrder, (kind) => + kind === "claude" ? "claudeAgent" : kind, + ); +} + export const PROVIDER_LABEL: Record = { claude: "Claude Code", codex: "Codex", diff --git a/apps/mobile/src/lib/modelOptions.test.ts b/apps/mobile/src/lib/modelOptions.test.ts index 73ce33f99dbf1..d9db3bcf3e6b6 100644 --- a/apps/mobile/src/lib/modelOptions.test.ts +++ b/apps/mobile/src/lib/modelOptions.test.ts @@ -186,6 +186,13 @@ describe("mobile model options", () => { (option) => option.providerKey === "codex", ), ); + const reordered = { + providers, + settings: { ...DEFAULT_SERVER_SETTINGS, providerOrder: ["claudeAgent"] }, + } as unknown as ServerConfig; + expect( + buildModelOptions(reordered, selection, undefined, null).map((option) => option.providerKey), + ).toEqual(["claudeAgent", "codex"]); }); it("keeps accounts in the continuation group and excludes other providers", () => { diff --git a/apps/mobile/src/lib/modelOptions.ts b/apps/mobile/src/lib/modelOptions.ts index e68a84b585417..8da050047086e 100644 --- a/apps/mobile/src/lib/modelOptions.ts +++ b/apps/mobile/src/lib/modelOptions.ts @@ -23,6 +23,7 @@ import { } from "@t3tools/shared/model"; import { resolveModelShortName } from "@t3tools/client-runtime/provider-clients"; import { resolveProvidersForCwd } from "@t3tools/client-runtime/providerSkills"; +import { sortByProviderOrder } from "@t3tools/shared/providerOrder"; export type ModelOption = { readonly key: string; @@ -363,7 +364,12 @@ export function buildModelOptions( }; }; - for (const provider of config?.providers ?? []) { + const orderedProviders = sortByProviderOrder( + config?.providers ?? [], + config?.settings?.providerOrder ?? [], + (provider) => provider.instanceId, + ); + for (const provider of orderedProviders) { if ( !matchesLockedProvider(provider) || isDriverDisallowed(config, provider.driver) || diff --git a/apps/web/src/components/settings/ProviderInstanceCard.tsx b/apps/web/src/components/settings/ProviderInstanceCard.tsx index 66b5e1fc48ec7..ae6fa526722d0 100644 --- a/apps/web/src/components/settings/ProviderInstanceCard.tsx +++ b/apps/web/src/components/settings/ProviderInstanceCard.tsx @@ -680,6 +680,8 @@ interface ProviderInstanceCardProps { readonly mode: "list" | "editor"; readonly selected?: boolean | undefined; readonly onSelect?: (() => void) | undefined; + /** List mode only: renders the reorder grip, given the row's display name. */ + readonly dragHandle?: ((label: string) => ReactNode) | undefined; readonly readOnly?: boolean | undefined; readonly canWriteSettings?: boolean; readonly onUpdate: (nextInstance: ProviderInstanceConfig) => Promise; @@ -754,6 +756,7 @@ export function ProviderInstanceCard({ mode, selected = false, onSelect, + dragHandle, readOnly = false, canWriteSettings = true, onUpdate, @@ -1146,6 +1149,7 @@ export function ProviderInstanceCard({ aria-label={`Select ${displayName}`} aria-pressed={selected} /> + {dragHandle?.(displayName)} {titleIconNode} diff --git a/apps/web/src/components/settings/ProviderSettingsPanel.tsx b/apps/web/src/components/settings/ProviderSettingsPanel.tsx index c3cf285980147..e08c18a8a5a55 100644 --- a/apps/web/src/components/settings/ProviderSettingsPanel.tsx +++ b/apps/web/src/components/settings/ProviderSettingsPanel.tsx @@ -33,10 +33,27 @@ import { getBackgroundActivityPresetSettings, resolveServerBackgroundActivitySettings, } from "@t3tools/shared/backgroundActivitySettings"; +import { sortByProviderOrder } from "@t3tools/shared/providerOrder"; import * as Arr from "effect/Array"; import * as Duration from "effect/Duration"; import * as Result from "effect/Result"; -import { PlusIcon } from "lucide-react"; +import { + closestCenter, + DndContext, + type DragEndEvent, + PointerSensor, + useSensor, + useSensors, +} from "@dnd-kit/core"; +import { restrictToParentElement, restrictToVerticalAxis } from "@dnd-kit/modifiers"; +import { + arrayMove, + SortableContext, + useSortable, + verticalListSortingStrategy, +} from "@dnd-kit/sortable"; +import { CSS } from "@dnd-kit/utilities"; +import { GripVerticalIcon, PlusIcon } from "lucide-react"; import { useRef, useState, type ReactNode } from "react"; import { isDesktopLocalConnectionTarget } from "../../connection/desktopLocal"; @@ -775,13 +792,28 @@ export function EnvironmentProviderSettings({ } } + const orderedRows = sortByProviderOrder(rows, settings.providerOrder, (row) => row.instanceId); const targetInstanceMissing = targetInstanceId !== undefined && selectedInstanceId === targetInstanceId && - !rows.some((row) => row.instanceId === targetInstanceId); + !orderedRows.some((row) => row.instanceId === targetInstanceId); const selectedRow = - rows.find((row) => row.instanceId === selectedInstanceId) ?? - (targetInstanceMissing ? null : (rows[0] ?? null)); + orderedRows.find((row) => row.instanceId === selectedInstanceId) ?? + (targetInstanceMissing ? null : (orderedRows[0] ?? null)); + const canReorder = !readOnly && canWriteSettings && orderedRows.length > 1; + const moveProvider = (id: ProviderInstanceId, to: number) => { + const ids = orderedRows.map((row) => row.instanceId); + const from = ids.indexOf(id); + if (from === -1 || to < 0 || to >= ids.length || from === to) return; + updateSettings({ providerOrder: arrayMove(ids, from, to) }); + }; + const dropProvider = (event: DragEndEvent) => { + if (!event.over) return; + moveProvider( + event.active.id as ProviderInstanceId, + orderedRows.findIndex((row) => row.instanceId === event.over?.id), + ); + }; const persistInstance = async ( instanceId: ProviderInstanceId, @@ -929,7 +961,11 @@ export function EnvironmentProviderSettings({ const favorites = settings.favorites.length > 0 ? settings.favorites : NO_FAVORITES; const representativeProjectId = projectIds[0]; - const renderProviderInstance = (row: InstanceRow, mode: "list" | "editor") => { + const renderProviderInstance = ( + row: InstanceRow, + mode: "list" | "editor", + dragHandle?: (label: string) => ReactNode, + ) => { const showProjectOverride = representativeProjectId !== undefined && supportsProjectProviderOverrides; return ( @@ -944,6 +980,7 @@ export function EnvironmentProviderSettings({ isDirty={row.isDirty === true} mode={mode} selected={mode === "list" && selectedRow?.instanceId === row.instanceId} + dragHandle={dragHandle} readOnly={readOnly} canWriteSettings={canWriteSettings} liveProvider={serverProviders.find((candidate) => candidate.instanceId === row.instanceId)} @@ -1052,7 +1089,22 @@ export function EnvironmentProviderSettings({ className="@min-[48rem]/providers:min-h-0 @min-[48rem]/providers:flex-1" >
- {rows.map((row) => renderProviderInstance(row, "list"))} + row.instanceId)} + disabled={!canReorder} + onDrop={dropProvider} + > + {orderedRows.map((row, index) => ( + moveProvider(row.instanceId, index + step)} + > + {(dragHandle) => renderProviderInstance(row, "list", dragHandle)} + + ))} + {canAddProvider ? ( + ))} +
+ ); +} diff --git a/apps/web/src/components/usage/UsageLimits.tsx b/apps/web/src/components/usage/UsageLimits.tsx index e41aa20998b1c..79b3a07c83d94 100644 --- a/apps/web/src/components/usage/UsageLimits.tsx +++ b/apps/web/src/components/usage/UsageLimits.tsx @@ -19,6 +19,7 @@ import { type ResetCreditChoice, resetCreditChoices, } from "@t3tools/shared/usageLimits"; +import { providerDriverOrder } from "@t3tools/shared/providerOrder"; import { GaugeIcon, TrendingDownIcon, TrendingUpIcon } from "lucide-react"; import { Fragment, useLayoutEffect, useState } from "react"; @@ -40,6 +41,7 @@ import { } from "../ui/alert-dialog"; import { Button } from "../ui/button"; import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; +import { useProviderOrderSettings } from "../../state/usage"; import { UsageLimitsPooled } from "./UsageLimitsPooled"; import { PROVIDER_PRESENTATION } from "./usageProviders"; @@ -390,5 +392,12 @@ export function UsageLimitsSection({ ]; }), ); - return ; + const providerOrderSettings = useProviderOrderSettings(); + return ( + + ); } diff --git a/apps/web/src/components/usage/UsageLimitsPooled.browser.test.tsx b/apps/web/src/components/usage/UsageLimitsPooled.browser.test.tsx index ab114fbbd6f21..b08eb9c7e4cf8 100644 --- a/apps/web/src/components/usage/UsageLimitsPooled.browser.test.tsx +++ b/apps/web/src/components/usage/UsageLimitsPooled.browser.test.tsx @@ -52,7 +52,11 @@ describe("UsageLimitsPooled ChatGPT usage card", () => { ], ]); await using screen = await render( - , + , ); await expect diff --git a/apps/web/src/components/usage/UsageLimitsPooled.tsx b/apps/web/src/components/usage/UsageLimitsPooled.tsx index 8ec1c7a02afcd..a8ba1f170d599 100644 --- a/apps/web/src/components/usage/UsageLimitsPooled.tsx +++ b/apps/web/src/components/usage/UsageLimitsPooled.tsx @@ -622,13 +622,15 @@ function PoolSection({ pool, now }: { readonly pool: LimitPool; readonly now: nu export function UsageLimitsPooled({ presentations, now, + driverOrder, }: { readonly presentations: Parameters[0]; readonly now: number; + readonly driverOrder: readonly string[]; }) { const [segmentPopover] = useState(() => PopoverCreateHandle()); const segmentPopoverActions = useRef(null); - const pools = collectLimitPools(collectLimitAccounts(presentations), now); + const pools = collectLimitPools(collectLimitAccounts(presentations), now, driverOrder); const notices = collectLimitNotices(presentations); const externalLinks = collectExternalUsageLinks(presentations); return ( diff --git a/apps/web/src/components/usage/UsagePage.tsx b/apps/web/src/components/usage/UsagePage.tsx index b60ae71d9ad52..4469da754a4ae 100644 --- a/apps/web/src/components/usage/UsagePage.tsx +++ b/apps/web/src/components/usage/UsagePage.tsx @@ -38,7 +38,7 @@ import { primaryServerKeybindingsAtom, serverEnvironment } from "../../state/ser import { isCommandPaletteOpen } from "../../commandPaletteBus"; import { isModelPickerOpen } from "../../modelPickerVisibility"; import { shortcutLabelForCommand } from "../../keybindings"; -import { useUsage, type EnvironmentUsageStatus } from "../../state/usage"; +import { useProviderOrderSettings, useUsage, type EnvironmentUsageStatus } from "../../state/usage"; import { useAtomCommand } from "../../state/use-atom-command"; import { enumerateDays, @@ -100,6 +100,7 @@ import { PROVIDER_PRESENTATION, providersWithUsage, rankProvidersByMetric, + usageProviderOrder, } from "./usageProviders"; import { readUsagePagePreferences, @@ -615,13 +616,15 @@ function UsageOverview({ // Copy the primitive; JSX reads of loading.partial would merge all derivations into one compiler cache // scope. const loadingPartial = loading.partial === true; + const providerOrderSettings = useProviderOrderSettings(); + const providerOrder = usageProviderOrder(providerOrderSettings); const loadingProviders = new Set( - PROVIDER_ORDER.filter((provider) => loading.everyProvider || loading.providers.has(provider)), + providerOrder.filter((provider) => loading.everyProvider || loading.providers.has(provider)), ); const providersWithData = new Set(providersWithUsage(merged.providers)); // Only loading.providers excludes hidden providers without data. Filter a fresh array so the compiler can // cache independently. - const activeProviders = [...PROVIDER_ORDER].filter( + const activeProviders = [...providerOrder].filter( (provider) => providersWithData.has(provider) || loading.providers.has(provider), ); const chartLoadingProviders = new Set( @@ -646,7 +649,11 @@ function UsageOverview({ (peak, model) => Math.max(peak, metric === "tokens" ? model.totalTokens : model.costUsd), 0, ); - const rankedProviders = rankProvidersByMetric(activeProviders, merged.providers, metric); + // A saved order replaces the metric ranking so every surface reads the same. + const rankedProviders = + providerOrderSettings === null + ? rankProvidersByMetric(activeProviders, merged.providers, metric) + : activeProviders; return (
@@ -1252,6 +1259,7 @@ function UsageProviderFilter({ readonly hiddenProviders: ReadonlySet; readonly onChange: (hiddenProviders: readonly UsageProviderKind[]) => void; }) { + const providerOrder = usageProviderOrder(useProviderOrderSettings()); const visible = PROVIDER_ORDER.filter((provider) => !hiddenProviders.has(provider)); const label = visible.length === PROVIDER_ORDER.length @@ -1280,7 +1288,7 @@ function UsageProviderFilter({ All providers - {PROVIDER_ORDER.map((provider) => ( + {providerOrder.map((provider) => ( PROVIDER_PRESENTATION[provider].driverKind, + ); +} + export function providersWithUsage( totals: readonly { readonly provider: UsageProviderKind; diff --git a/apps/web/src/providerInstances.test.ts b/apps/web/src/providerInstances.test.ts index 891f3312ae833..2e59badd82c89 100644 --- a/apps/web/src/providerInstances.test.ts +++ b/apps/web/src/providerInstances.test.ts @@ -13,6 +13,7 @@ import { deriveProviderInstanceEntries, getDefaultProviderInstanceModel, isProviderInstancePickerReady, + providerInstanceEntriesFor, resolveDefaultProviderModelSelection, resolveSelectableProviderInstance, shouldShowInstanceBadge, @@ -162,6 +163,33 @@ describe("applyProviderInstanceSettings", () => { }); }); +describe("providerInstanceEntriesFor", () => { + const codex = ProviderDriverKind.make("codex"); + const entries = (providerOrder: string[]) => + providerInstanceEntriesFor( + [ + provider({ provider: codex, instanceId: "codex_personal" }), + provider({ provider: codex, instanceId: "codex" }), + provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: "claudeAgent" }), + ], + { + providerInstances: {}, + projectSettingsOverrides: {}, + providerOrder: providerOrder.map((id) => ProviderInstanceId.make(id)), + }, + null, + ).map((entry) => entry.instanceId); + + it("follows the saved order, then puts each driver's default first", () => { + expect(entries([])).toEqual(["codex", "codex_personal", "claudeAgent"]); + expect(entries(["claudeAgent", "codex_personal"])).toEqual([ + "claudeAgent", + "codex_personal", + "codex", + ]); + }); +}); + describe("deriveProviderEntriesByEnvironment", () => { it("resolves registry branding from each environment's settings", () => { const instanceId = "custom-acp"; diff --git a/apps/web/src/providerInstances.ts b/apps/web/src/providerInstances.ts index fa4cd69a75dc5..47903a11b9559 100644 --- a/apps/web/src/providerInstances.ts +++ b/apps/web/src/providerInstances.ts @@ -12,6 +12,7 @@ import { type ServerSettings, type ServerProviderState, } from "@t3tools/contracts"; +import { sortByProviderOrder } from "@t3tools/shared/providerOrder"; import { normalizeProviderAccentColor, resolveProviderInstanceDisplayName, @@ -158,16 +159,20 @@ function applyProviderInstanceBranding( }; } -/** Picker order: each driver's default instance first, then its custom instances. */ +/** Picker order: the saved provider order, then each driver's default instance before its custom ones. */ export function providerInstanceEntriesFor( providers: ReadonlyArray, - settings: Pick, + settings: Pick< + ServerSettings, + "providerInstances" | "projectSettingsOverrides" | "providerOrder" + >, projectId: ProjectId | null, ): ReadonlyArray { return pipe( deriveProviderInstanceEntries(providers), (entries) => applyProviderInstanceSettings(entries, settings, projectId), sortProviderInstanceEntries, + (entries) => sortByProviderOrder(entries, settings.providerOrder, (entry) => entry.instanceId), ); } diff --git a/apps/web/src/state/usage.ts b/apps/web/src/state/usage.ts index bf5de2e330a3f..e7066d37ee07a 100644 --- a/apps/web/src/state/usage.ts +++ b/apps/web/src/state/usage.ts @@ -13,8 +13,13 @@ import { resolveUsageAccess } from "@t3tools/client-runtime/state/usage-access"; import { AsyncResult, Atom } from "effect/reactivity"; import { useState } from "react"; +import { + firstProviderOrderSettings, + type ProviderOrderSettings, +} from "@t3tools/shared/providerOrder"; import { mergeUsage, type EnvironmentUsage, type MergedUsage } from "@t3tools/shared/usageMerge"; import { appAtomRegistry } from "../rpc/atomRegistry"; +import { useEnvironments, usePrimaryEnvironmentId } from "./environments"; import { environmentPresentations } from "./presentation"; import { serverEnvironment } from "./server"; import { environmentSession, readEnvironmentScope } from "./session"; @@ -244,3 +249,15 @@ export function useUsage( refresh, }; } + +/** The order Usage and Limits follow: the primary's saved order, else the first other saved one. */ +export function useProviderOrderSettings(): ProviderOrderSettings | null { + const { environments } = useEnvironments(); + const primaryEnvironmentId = usePrimaryEnvironmentId(); + return firstProviderOrderSettings( + [ + ...environments.filter((environment) => environment.environmentId === primaryEnvironmentId), + ...environments.filter((environment) => environment.environmentId !== primaryEnvironmentId), + ].map((environment) => environment.serverConfig?.settings), + ); +} diff --git a/apps/web/src/textGenerators.ts b/apps/web/src/textGenerators.ts index fa7941d150e18..0f6df07004798 100644 --- a/apps/web/src/textGenerators.ts +++ b/apps/web/src/textGenerators.ts @@ -279,7 +279,7 @@ export function useTextGenerationTargets(input: { readonly environmentId: EnvironmentId | null; readonly settings: Pick< ServerSettings, - "providerInstances" | "projectSettingsOverrides" | "textGenerators" + "providerInstances" | "projectSettingsOverrides" | "textGenerators" | "providerOrder" >; readonly providers: ReadonlyArray; readonly projectId: ProjectId | null; diff --git a/docs/user/usage.md b/docs/user/usage.md index 5160becc21567..1c9a22f75729f 100644 --- a/docs/user/usage.md +++ b/docs/user/usage.md @@ -6,6 +6,11 @@ desktop when the terminal is not focused. Customize `usage.open` in On mobile, choose **Usage** in the workspace navigation. +Providers appear in the order you set in **Settings → Providers**. Drag a provider by its grip, or +focus the grip and use Space and the arrow keys. The order is saved on the server, so usage, limits, +and the model picker match on every device connected to it. With several environments, the primary +environment's order applies. Until you reorder providers, usage ranks them by the selected metric. + ## Understand your usage **Usage** combines Codex, Claude Code, Grok Build, OpenCode, Antigravity, Pi, Muse Code, and Cursor history diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts index 040b5e0736a31..ff684bf227bbf 100644 --- a/packages/contracts/src/settings.ts +++ b/packages/contracts/src/settings.ts @@ -1569,6 +1569,10 @@ export const ServerSettings = Schema.Struct({ providerInstances: Schema.Record(ProviderInstanceId, ProviderInstanceConfig).pipe( Schema.withDecodingDefault(Effect.succeed({})), ), + // Order from Settings → Providers; unlisted instances follow in built-in order, missing ids are skipped. + providerOrder: Schema.Array(ProviderInstanceId).pipe( + Schema.withDecodingDefault(Effect.succeed([])), + ), observability: ObservabilitySettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), sourceControlHosts: Schema.Record(Schema.String, SourceControlHostSettings).pipe( Schema.withDecodingDefault(Effect.succeed({})), @@ -1968,6 +1972,7 @@ export const ServerSettingsPatch = Schema.Struct({ offeredSourceControlProviders: Schema.optionalKey(Schema.Record(Schema.String, Schema.Boolean)), // Replace whole maps to avoid half-merged driver configs. providerInstances: Schema.optionalKey(Schema.Record(ProviderInstanceId, ProviderInstanceConfig)), + providerOrder: Schema.optionalKey(Schema.Array(ProviderInstanceId)), // Merge per source to avoid racing other edits; null removes an entry. usageLimitSources: Schema.optionalKey( Schema.Record(UsageLimitSourceId, Schema.NullOr(UsageLimitSourceConfig)), diff --git a/packages/shared/package.json b/packages/shared/package.json index 3de18958220ef..0aebc70fbe290 100644 --- a/packages/shared/package.json +++ b/packages/shared/package.json @@ -63,6 +63,10 @@ "types": "./src/model.ts", "import": "./src/model.ts" }, + "./providerOrder": { + "types": "./src/providerOrder.ts", + "import": "./src/providerOrder.ts" + }, "./advertisedEndpoint": { "types": "./src/advertisedEndpoint.ts", "import": "./src/advertisedEndpoint.ts" diff --git a/packages/shared/src/providerOrder.test.ts b/packages/shared/src/providerOrder.test.ts new file mode 100644 index 0000000000000..ef4871643b247 --- /dev/null +++ b/packages/shared/src/providerOrder.test.ts @@ -0,0 +1,58 @@ +import { + DEFAULT_SERVER_SETTINGS, + ProviderDriverKind, + ProviderInstanceId, +} from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; +import { + firstProviderOrderSettings, + providerDriverOrder, + sortByProviderOrder, +} from "./providerOrder.ts"; + +const ids = (...values: string[]) => values.map((value) => ProviderInstanceId.make(value)); + +describe("sortByProviderOrder", () => { + it.each([ + { + name: "puts listed ids first and keeps the rest in incoming order", + items: ["codex", "claudeAgent", "cursor", "grok"], + order: ["grok", "codex"], + expected: ["grok", "codex", "claudeAgent", "cursor"], + }, + { + name: "skips missing ids and ranks repeats by their first position", + items: ["codex", "claudeAgent"], + order: ["gone", "claudeAgent", "codex", "claudeAgent"], + expected: ["claudeAgent", "codex"], + }, + ])("$name", ({ items, order, expected }) => { + expect(sortByProviderOrder(items, order, (id) => id)).toEqual(expected); + }); +}); + +describe("providerDriverOrder", () => { + it("maps custom instances to their driver", () => { + expect( + providerDriverOrder({ + providerInstances: { + [ProviderInstanceId.make("codex_work")]: { + driver: ProviderDriverKind.make("codex"), + enabled: true, + config: {}, + }, + }, + providerOrder: ids("grok", "codex_work", "claudeAgent"), + }), + ).toEqual(["grok", "codex", "claudeAgent"]); + }); +}); + +describe("firstProviderOrderSettings", () => { + it("returns the first environment that saved an order", () => { + const saved = { ...DEFAULT_SERVER_SETTINGS, providerOrder: ids("grok") }; + + expect(firstProviderOrderSettings([null, DEFAULT_SERVER_SETTINGS, saved])).toBe(saved); + expect(firstProviderOrderSettings([DEFAULT_SERVER_SETTINGS])).toBeNull(); + }); +}); diff --git a/packages/shared/src/providerOrder.ts b/packages/shared/src/providerOrder.ts new file mode 100644 index 0000000000000..6909c56bdec46 --- /dev/null +++ b/packages/shared/src/providerOrder.ts @@ -0,0 +1,42 @@ +import type { ServerSettings } from "@t3tools/contracts"; + +export type ProviderOrderSettings = Pick; + +/** Listed ids first in saved order; the rest keep their incoming order. A repeated id ranks by its first position. */ +export function sortByProviderOrder( + items: readonly T[], + order: readonly string[], + idOf: (item: T) => string, +): T[] { + if (order.length === 0) return [...items]; + const rank = new Map(); + for (const [index, id] of order.entries()) { + if (!rank.has(id)) rank.set(id, index); + } + // Hermes lacks Array#toSorted. + return [...items].sort( + (left, right) => + (rank.get(idOf(left)) ?? order.length) - (rank.get(idOf(right)) ?? order.length), + ); +} + +/** Driver kinds in saved order, each ranked by its first listed instance. */ +export function providerDriverOrder(settings: ProviderOrderSettings): string[] { + return settings.providerOrder.map((id) => { + const instance = Object.hasOwn(settings.providerInstances, id) + ? settings.providerInstances[id] + : undefined; + // Default instance ids are the driver slug. + return instance?.driver ?? id; + }); +} + +/** The first saved order; callers that merge environments list the primary first. */ +export function firstProviderOrderSettings( + candidates: Iterable, +): ProviderOrderSettings | null { + for (const settings of candidates) { + if (settings && settings.providerOrder.length > 0) return settings; + } + return null; +} diff --git a/packages/shared/src/serverSettings.test.ts b/packages/shared/src/serverSettings.test.ts index 9836fe10fc77f..bd4712ea63e26 100644 --- a/packages/shared/src/serverSettings.test.ts +++ b/packages/shared/src/serverSettings.test.ts @@ -542,7 +542,7 @@ describe("serverSettings helpers", () => { ); }); - it("replaces providerInstances maps so omitted instance fields are cleared", () => { + it("replaces providerInstances maps and the provider order whole", () => { const codexId = ProviderInstanceId.make("codex"); const current = { ...DEFAULT_SERVER_SETTINGS, @@ -574,6 +574,12 @@ describe("serverSettings helpers", () => { enabled: true, config: { homePath: "~/.codex" }, }); + expect( + applyServerSettingsPatch( + { ...current, providerOrder: [codexId, ProviderInstanceId.make("grok")] }, + { providerOrder: [ProviderInstanceId.make("grok")] }, + ).providerOrder, + ).toEqual([ProviderInstanceId.make("grok")]); }); it("keeps a project's providerInstances override when a patch entry omits the key", () => { diff --git a/packages/shared/src/serverSettings.ts b/packages/shared/src/serverSettings.ts index 023c6eb74333e..a2dcb89ee6d88 100644 --- a/packages/shared/src/serverSettings.ts +++ b/packages/shared/src/serverSettings.ts @@ -544,6 +544,8 @@ export function applyServerSettingsPatch( ...(patch.providerInstances !== undefined ? { providerInstances: patch.providerInstances } : {}), + // deepMerge merges arrays by index and would keep stale tail entries. + ...(patch.providerOrder !== undefined ? { providerOrder: patch.providerOrder } : {}), ...(patch.worktreesDirectory !== undefined && patch.worktreesDirectory !== current.worktreesDirectory ? { diff --git a/packages/shared/src/usageLimits.test.ts b/packages/shared/src/usageLimits.test.ts index b66001ca19244..a9457df4038aa 100644 --- a/packages/shared/src/usageLimits.test.ts +++ b/packages/shared/src/usageLimits.test.ts @@ -1018,6 +1018,35 @@ describe("pools", () => { ).toContainEqual(["pro@example.com", 95]); }); + it("orders pools by the saved driver order", () => { + const account = (id: string, driver: string) => ({ + id, + driver: ProviderDriverKind.make(driver), + usageLimits: { checkedAt, windows: [{ ...weekly, id: `${id}-weekly`, usedPercent: 50 }] }, + }); + const accounts = collectLimitAccounts( + new Map([ + [ + EnvironmentId.make("env-a"), + { + ...laptop, + serverConfig: { + providers: [], + usageLimitSources: [ + { ...source, accounts: [account("c", "codex"), account("a", "claudeAgent")] }, + ], + }, + }, + ], + ]), + ); + const drivers = (order?: string[]) => + collectLimitPools(accounts, now, order).map((pool) => pool.driver); + + expect(drivers()).toEqual(["codex", "claudeAgent"]); + expect(drivers(["claudeAgent"])).toEqual(["claudeAgent", "codex"]); + }); + it("pools windows by id across accounts and orders resets by when they land", () => { const input = new Map([ [ diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts index 6fe6c70a89a4f..3cbd1cd633be0 100644 --- a/packages/shared/src/usageLimits.ts +++ b/packages/shared/src/usageLimits.ts @@ -19,6 +19,7 @@ import { } from "@t3tools/contracts"; import * as DateTime from "effect/DateTime"; +import { sortByProviderOrder } from "./providerOrder.ts"; import { isLocalLoopbackHost, isWildcardHost } from "./hostClassification.ts"; @@ -529,6 +530,7 @@ const WINDOW_KIND_ORDER: Record = { export function collectLimitPools( accounts: readonly LimitAccount[], now: number, + driverOrder: readonly string[] = [], ): readonly LimitPool[] { const byDriver = new Map(); for (const account of accounts) { @@ -536,27 +538,29 @@ export function collectLimitPools( if (list) list.push(account); else byDriver.set(account.driver, [account]); } - return [...byDriver].map(([driver, members]) => { - const orderWindow = members - .flatMap((account) => account.limits.windows) - .sort((left, right) => WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind])[0]; - const orderReset = (account: LimitAccount) => { - const window = account.limits.windows.find( - (window) => orderWindow && poolKey(driver, window) === poolKey(driver, orderWindow), - ); - return ( - (window ? resetMillis(poolMember(account, window, now).window) : null) ?? - Number.POSITIVE_INFINITY + return sortByProviderOrder([...byDriver], driverOrder, ([driver]) => driver).map( + ([driver, members]) => { + const orderWindow = members + .flatMap((account) => account.limits.windows) + .sort((left, right) => WINDOW_KIND_ORDER[left.kind] - WINDOW_KIND_ORDER[right.kind])[0]; + const orderReset = (account: LimitAccount) => { + const window = account.limits.windows.find( + (window) => orderWindow && poolKey(driver, window) === poolKey(driver, orderWindow), + ); + return ( + (window ? resetMillis(poolMember(account, window, now).window) : null) ?? + Number.POSITIVE_INFINITY + ); + }; + const sorted = [...members].sort( + (left, right) => + orderReset(left) - orderReset(right) || + accountSortName(left).localeCompare(accountSortName(right)) || + left.key.localeCompare(right.key), ); - }; - const sorted = [...members].sort( - (left, right) => - orderReset(left) - orderReset(right) || - accountSortName(left).localeCompare(accountSortName(right)) || - left.key.localeCompare(right.key), - ); - return { driver, accounts: sorted, windows: poolWindows(sorted, now) }; - }); + return { driver, accounts: sorted, windows: poolWindows(sorted, now) }; + }, + ); } function accountSortName(account: LimitAccount): string { From 2cf0831d5d120800c6ad7af325ca86786ab4de08 Mon Sep 17 00:00:00 2001 From: Lukas Boguth Date: Mon, 9 Nov 2026 13:23:54 +0100 Subject: [PATCH 2/4] fix(web): consecutive provider moves build on the pending order Arrow presses before the first write landed each started from the server order, so two presses moved a provider one row. The panel now keeps the pending order until the server reports it or the write fails. Also documents that the first provider in the order is the fallback for new conversations without a remembered model. --- .../settings/ProviderSettingsPanel.tsx | 24 +++++++++++++++++-- docs/user/usage.md | 1 + 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/apps/web/src/components/settings/ProviderSettingsPanel.tsx b/apps/web/src/components/settings/ProviderSettingsPanel.tsx index e08c18a8a5a55..dba9172945562 100644 --- a/apps/web/src/components/settings/ProviderSettingsPanel.tsx +++ b/apps/web/src/components/settings/ProviderSettingsPanel.tsx @@ -572,6 +572,16 @@ export function EnvironmentProviderSettings({ const canWriteSettings = useEnvironmentScope(environmentId, AuthSettingsWriteScope); const canRefreshProviders = useEnvironmentScope(environmentId, AuthOrchestrationReadScope); const updateSettings = useUpdateEnvironmentSettings(environmentId); + const [pendingProviderOrder, setPendingProviderOrder] = useState< + readonly ProviderInstanceId[] | null + >(null); + if ( + pendingProviderOrder !== null && + pendingProviderOrder.length === settings.providerOrder.length && + pendingProviderOrder.every((id, index) => settings.providerOrder[index] === id) + ) { + setPendingProviderOrder(null); + } const updateModelPreferences = useUpdateEnvironmentModelPreferences(environmentId); const toggleModelFavorite = useToggleEnvironmentModelFavorite(environmentId); const persistProviderInstance = usePersistEnvironmentProviderInstanceMutation(environmentId); @@ -792,7 +802,11 @@ export function EnvironmentProviderSettings({ } } - const orderedRows = sortByProviderOrder(rows, settings.providerOrder, (row) => row.instanceId); + const orderedRows = sortByProviderOrder( + rows, + pendingProviderOrder ?? settings.providerOrder, + (row) => row.instanceId, + ); const targetInstanceMissing = targetInstanceId !== undefined && selectedInstanceId === targetInstanceId && @@ -805,7 +819,13 @@ export function EnvironmentProviderSettings({ const ids = orderedRows.map((row) => row.instanceId); const from = ids.indexOf(id); if (from === -1 || to < 0 || to >= ids.length || from === to) return; - updateSettings({ providerOrder: arrayMove(ids, from, to) }); + const next = arrayMove(ids, from, to); + // Later moves build on this order until the server reports it or the write fails. + setPendingProviderOrder(next); + updateSettings( + { providerOrder: next }, + { onFailed: () => setPendingProviderOrder((current) => (current === next ? null : current)) }, + ); }; const dropProvider = (event: DragEndEvent) => { if (!event.over) return; diff --git a/docs/user/usage.md b/docs/user/usage.md index 1c9a22f75729f..f01b98f97bd66 100644 --- a/docs/user/usage.md +++ b/docs/user/usage.md @@ -10,6 +10,7 @@ Providers appear in the order you set in **Settings → Providers**. Drag a prov focus the grip and use Space and the arrow keys. The order is saved on the server, so usage, limits, and the model picker match on every device connected to it. With several environments, the primary environment's order applies. Until you reorder providers, usage ranks them by the selected metric. +When no model is remembered for a new conversation, it starts with the first provider in this order. ## Understand your usage From e2341f14069aa92c32d26df2c49422af14229eb3 Mon Sep 17 00:00:00 2001 From: Lukas Boguth Date: Mon, 9 Nov 2026 13:30:12 +0100 Subject: [PATCH 3/4] fix: hide provider reordering on servers that drop the order Older servers silently drop providerOrder, so a move looked saved and snapped back later. The server now advertises a providerOrder capability and the settings panel shows the grips only where it is present. Also corrects the user guide: arrow keys alone move a provider, and mobile follows the first environment with a saved order. --- apps/server/src/environment/ServerEnvironment.test.ts | 1 + apps/server/src/environment/ServerEnvironment.ts | 1 + apps/web/src/components/settings/ProviderSettingsPanel.tsx | 7 ++++++- docs/user/usage.md | 6 +++--- packages/contracts/src/environment.ts | 2 ++ 5 files changed, 13 insertions(+), 4 deletions(-) diff --git a/apps/server/src/environment/ServerEnvironment.test.ts b/apps/server/src/environment/ServerEnvironment.test.ts index 3a9bfafb82eaf..805331d95d4a9 100644 --- a/apps/server/src/environment/ServerEnvironment.test.ts +++ b/apps/server/src/environment/ServerEnvironment.test.ts @@ -288,6 +288,7 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("ServerEnvironmen expect(second.capabilities.requiredWorktreeBootstrap).toBe(true); expect(second.capabilities.usagePriceOverrides).toBe(true); expect(second.capabilities.threadActiveReorder).toBe(true); + expect(second.capabilities.providerOrder).toBe(true); expect(second.capabilities.threadTitleRegeneration).toBe(true); expect(second.capabilities.threadPullRequests).toBe(true); expect(second.capabilities.threadPullRequestLinking).toBe(true); diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts index 0f3a88f5c0d94..658bb4979d05d 100644 --- a/apps/server/src/environment/ServerEnvironment.ts +++ b/apps/server/src/environment/ServerEnvironment.ts @@ -257,6 +257,7 @@ export const make = Effect.gen(function* () { usageModelAliases: true, threadPinning: true, threadPinReorder: true, + providerOrder: true, threadActiveReorder: true, threadAutoSettleOptOut: true, threadProjectFromScratch: true, diff --git a/apps/web/src/components/settings/ProviderSettingsPanel.tsx b/apps/web/src/components/settings/ProviderSettingsPanel.tsx index dba9172945562..f5449e46578ee 100644 --- a/apps/web/src/components/settings/ProviderSettingsPanel.tsx +++ b/apps/web/src/components/settings/ProviderSettingsPanel.tsx @@ -591,6 +591,10 @@ export function EnvironmentProviderSettings({ serverEnvironment.configValueAtom(environmentId), (config) => config?.environment.capabilities.projectProviderInstanceOverrides === true, ); + const supportsProviderOrder = useAtomValue( + serverEnvironment.configValueAtom(environmentId), + (config) => config?.environment.capabilities.providerOrder === true, + ); const refreshServerProviders = useAtomCommand(serverEnvironment.refreshProviders, { reportFailure: false, }); @@ -814,7 +818,8 @@ export function EnvironmentProviderSettings({ const selectedRow = orderedRows.find((row) => row.instanceId === selectedInstanceId) ?? (targetInstanceMissing ? null : (orderedRows[0] ?? null)); - const canReorder = !readOnly && canWriteSettings && orderedRows.length > 1; + const canReorder = + !readOnly && canWriteSettings && supportsProviderOrder && orderedRows.length > 1; const moveProvider = (id: ProviderInstanceId, to: number) => { const ids = orderedRows.map((row) => row.instanceId); const from = ids.indexOf(id); diff --git a/docs/user/usage.md b/docs/user/usage.md index f01b98f97bd66..bb87da774e5e9 100644 --- a/docs/user/usage.md +++ b/docs/user/usage.md @@ -7,9 +7,9 @@ desktop when the terminal is not focused. Customize `usage.open` in On mobile, choose **Usage** in the workspace navigation. Providers appear in the order you set in **Settings → Providers**. Drag a provider by its grip, or -focus the grip and use Space and the arrow keys. The order is saved on the server, so usage, limits, -and the model picker match on every device connected to it. With several environments, the primary -environment's order applies. Until you reorder providers, usage ranks them by the selected metric. +focus the grip and press the up or down arrow key. The order is saved on the server, so usage, limits, +and the model picker match on every device connected to it. With several environments, web and +desktop use the primary environment's order, and mobile uses the first environment that has one. Until you reorder providers, usage ranks them by the selected metric. When no model is remembered for a new conversation, it starts with the first provider in this order. ## Understand your usage diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts index fd091152599d3..38e34bd564aab 100644 --- a/packages/contracts/src/environment.ts +++ b/packages/contracts/src/environment.ts @@ -133,6 +133,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({ usageModelAliases: Schema.optionalKey(Schema.Boolean), threadPinning: Schema.optionalKey(Schema.Boolean), threadPinReorder: Schema.optionalKey(Schema.Boolean), + /** Hide provider reordering when absent; older servers silently drop `providerOrder`. */ + providerOrder: Schema.optionalKey(Schema.Boolean), threadActiveReorder: Schema.optionalKey(Schema.Boolean), threadAutoSettleOptOut: Schema.optionalKey(Schema.Boolean), threadProjectFromScratch: Schema.optionalKey(Schema.Boolean), From 2a15ecf964425d297ea5ac81a34779398c4e5161 Mon Sep 17 00:00:00 2001 From: Lukas Boguth Date: Mon, 9 Nov 2026 13:58:22 +0100 Subject: [PATCH 4/4] fix(mobile): new conversations start with the first available provider Mobile picked the first default model across all providers, so a hidden default on the first provider jumped to a later provider. It now picks the first available provider, then its default model, matching web. Also covers the reorder capability gate and consecutive arrow-key moves in the provider settings browser test. --- apps/mobile/src/lib/modelOptions.test.ts | 16 +++++++ apps/mobile/src/lib/modelOptions.ts | 9 +++- ...SettingsPanel.environment.browser.test.tsx | 42 ++++++++++++++++++- 3 files changed, 64 insertions(+), 3 deletions(-) diff --git a/apps/mobile/src/lib/modelOptions.test.ts b/apps/mobile/src/lib/modelOptions.test.ts index d9db3bcf3e6b6..ad73d31313cb8 100644 --- a/apps/mobile/src/lib/modelOptions.test.ts +++ b/apps/mobile/src/lib/modelOptions.test.ts @@ -598,6 +598,22 @@ describe("mobile model options", () => { modelOptions: [unavailable], }), ).toBeNull(); + + const option = (providerKey: string, model: string, isDefault = false) => + ({ + providerKey, + selection: { instanceId: ProviderInstanceId.make(providerKey), model }, + isDefault, + }) as ModelOption; + const firstVisible = option("claudeAgent", "visible"); + expect( + resolveNewTaskModelSelection({ + draftSelection: null, + projectDefaultSelection: null, + stickySelection: null, + modelOptions: [firstVisible, option("codex", "default", true)], + }), + ).toBe(firstVisible.selection); }); describe("project-aware enablement", () => { diff --git a/apps/mobile/src/lib/modelOptions.ts b/apps/mobile/src/lib/modelOptions.ts index 8da050047086e..52772c502a52d 100644 --- a/apps/mobile/src/lib/modelOptions.ts +++ b/apps/mobile/src/lib/modelOptions.ts @@ -278,12 +278,17 @@ export function resolveNewTaskModelSelection(input: { readonly stickySelection: ModelSelection | null; readonly modelOptions: ReadonlyArray; }): ModelSelection | null { + // Like web, the first available provider wins before its default model. + const first = input.modelOptions.find((option) => !option.isUnavailable); + const providerDefault = input.modelOptions.find( + (option) => + option.providerKey === first?.providerKey && option.isDefault && !option.isUnavailable, + ); return ( input.draftSelection ?? input.projectDefaultSelection ?? input.stickySelection ?? - input.modelOptions.find((option) => option.isDefault && !option.isUnavailable)?.selection ?? - input.modelOptions.find((option) => !option.isUnavailable)?.selection ?? + (providerDefault ?? first)?.selection ?? null ); } diff --git a/apps/web/src/components/settings/ProviderSettingsPanel.environment.browser.test.tsx b/apps/web/src/components/settings/ProviderSettingsPanel.environment.browser.test.tsx index 0b9bcc943b76e..66e3136137f47 100644 --- a/apps/web/src/components/settings/ProviderSettingsPanel.environment.browser.test.tsx +++ b/apps/web/src/components/settings/ProviderSettingsPanel.environment.browser.test.tsx @@ -20,6 +20,7 @@ import { act, render } from "../../../test/render"; const state = vi.hoisted(() => ({ providers: null as unknown as Atom.Writable>, + config: null as unknown as Atom.Writable, providerAuthQuery: null as unknown, providerAuth: null as ProviderAuthState | null, settings: null as unknown as UnifiedSettings, @@ -45,7 +46,8 @@ vi.mock(import("../../state/server"), async (original) => { const { Atom } = await import("effect/reactivity"); const providers = Atom.make>([]).pipe(Atom.keepAlive); state.providers = providers; - const config = Atom.make(null); + const config = Atom.make(null).pipe(Atom.keepAlive); + state.config = config; const providerAuth = Atom.make(null); state.providerAuthQuery = providerAuth; const commandLabels = { @@ -247,9 +249,47 @@ async function setup() { state.uninstall.mockReset().mockResolvedValue(AsyncResult.success({})); state.acceptUrlAuth.mockReset().mockResolvedValue(AsyncResult.success({ accepted: true })); await setProviders([]); + await act(async () => appAtomRegistry.set(state.config, null)); } describe("EnvironmentProviderSettings routing", () => { + it("offers reordering only where the server keeps the order, building on pending moves", async () => { + await setup(); + state.settings = { + ...DEFAULT_UNIFIED_SETTINGS, + providerInstances: { + [customId]: { driver: ProviderDriverKind.make("codex"), enabled: true, config: {} }, + }, + }; + await setProviders([provider()]); + await using _screen = await render(panel()); + await expect.element(page.getByRole("button", { name: "Select Claude" })).toBeVisible(); + await expect + .element(page.getByRole("button", { name: /^Reorder / }).first()) + .not.toBeInTheDocument(); + + await act(async () => + appAtomRegistry.set(state.config, { environment: { capabilities: { providerOrder: true } } }), + ); + const grips = page.getByRole("button", { name: /^Reorder / }); + await expect.element(grips.nth(2)).toBeVisible(); + const moved = (await grips.nth(2).element().getAttribute("aria-label"))!.replace( + "Reorder ", + "", + ); + (grips.nth(2).element() as HTMLElement).focus(); + await userEvent.keyboard("{ArrowUp}{ArrowUp}"); + + const orders = state.updateSettings.mock.calls.map( + ([patch]) => (patch as { providerOrder: string[] }).providerOrder, + ); + expect(orders).toHaveLength(2); + expect(orders[1]![0]).toBe(orders[0]![1]); + await expect + .element(page.getByRole("button", { name: /^Reorder / }).first()) + .toHaveAccessibleName(`Reorder ${moved}`); + }); + it("does not substitute another account when the requested instance was removed", async () => { await setup(); await setProviders([provider()]);