The best way to control Claude Code, Codex and more from any computer or phone
fix(web): composer keeps the picked effort when it falls back to another instance (#23957)
Co-authored-by: maria-rcks <254055478+maria-rcks@users.noreply.github.com>
Mantas Kantautas committed
Oct 30, 2026 at 23:27 UTC
7c90d51d6181bb188583c852e028ce33df339f86
4 files changed
+224
-17
apps/web/src/components/ChatView.logic.ts
+1
@@ -531,6 +531,7 @@ export function resolveComposerProviderSelection(input: {
531
: requestedInstanceId;
532
return {
533
selectedProviderEntry,
534
+ requestedInstanceId,
535
requestedDriverKind,
536
lockedContinuationGroupKey,
537
unavailableProviderInstanceId,
apps/web/src/components/chat/useComposerProviderModel.ts
+1
@@ -70,6 +70,7 @@ export function useComposerProviderModel(
70
providers: providerStatuses,
71
selectedProvider,
72
selectedInstanceId,
73
+ requestedInstanceId: selection.requestedInstanceId,
74
threadModelSelection,
75
projectModelSelection,
76
settings,
apps/web/src/composerDraftStore.ts
+60
-16
@@ -637,17 +637,10 @@ interface ComposerDraftModelState {
637
modelSelectionByProvider: Partial<Record<ProviderInstanceId, ModelSelection>>;
638
}
639
640
-function providerSelectionsFromModelSelection(
640
+function selectionsByInstance(
641
modelSelection: ModelSelection | null | undefined,
642
-): ProviderOptionSelectionsByProvider | null {
643
- if (!modelSelection) {
644
- return null;
645
- }
646
- const options = modelSelection.options;
647
- if (!options || options.length === 0) {
648
- return null;
649
- }
650
- return { [modelSelection.instanceId]: options };
642
+): Partial<Record<string, ModelSelection>> | null {
643
+ return modelSelection ? { [modelSelection.instanceId]: modelSelection } : null;
644
}
645
646
function modelSelectionByProviderToOptions(
@@ -1100,6 +1093,8 @@ export function deriveEffectiveComposerModelState(input: {
1093
providers: ReadonlyArray<ServerProvider>;
1094
selectedProvider: ProviderDriverKind;
1095
selectedInstanceId?: ProviderInstanceId | null | undefined;
1096
+ /** The instance the draft, thread or project asked for; differs from the selection on fallback. */
1097
+ requestedInstanceId?: ProviderInstanceId | null | undefined;
1098
threadModelSelection: ModelSelection | null | undefined;
1099
projectModelSelection: ModelSelection | null | undefined;
1100
settings: UnifiedSettings;
@@ -1159,18 +1154,67 @@ export function deriveEffectiveComposerModelState(input: {
1154
activeSelection.model,
1155
))
1156
: baseModel;
1162
- const modelOptions =
1163
- modelSelectionByProviderToOptions(input.draft?.modelSelectionByProvider) ??
1164
- providerSelectionsFromModelSelection(input.threadModelSelection) ??
1165
- providerSelectionsFromModelSelection(input.projectModelSelection) ??
1166
- null;
1157
+ // Options come from the first of the draft, thread and project that has any. Their selections
1158
+ // stay with them, so a fallback instance can check which model the options belong to.
1159
+ const optionSelections =
1160
+ [
1161
+ input.draft?.modelSelectionByProvider,
1162
+ selectionsByInstance(input.threadModelSelection),
1163
+ selectionsByInstance(input.projectModelSelection),
1164
+ ].find((selections) => modelSelectionByProviderToOptions(selections) !== null) ?? null;
1165
+ const modelOptions = modelSelectionByProviderToOptions(optionSelections);
1166
1167
return {
1168
selectedModel,
1170
- modelOptions,
1169
+ modelOptions: withFallbackInstanceOptions({
1170
+ ...input,
1171
+ modelOptions,
1172
+ optionSelections,
1173
+ selectedModel,
1174
+ }),
1175
};
1176
}
1177
1178
+/**
1179
+ * When the requested instance is disabled or unavailable, the composer shows another instance of
1180
+ * the same driver. When that instance has no options of its own and shows the model the requested
1181
+ * instance's options were picked with, it takes those options instead of the model's defaults.
1182
+ */
1183
+function withFallbackInstanceOptions(input: {
1184
+ readonly modelOptions: ProviderOptionSelectionsByProvider | null;
1185
+ readonly optionSelections: Partial<Record<string, ModelSelection>> | null;
1186
+ readonly selectedModel: string;
1187
+ readonly providers: ReadonlyArray<ServerProvider>;
1188
+ readonly selectedProvider: ProviderDriverKind;
1189
+ readonly selectedInstanceId?: ProviderInstanceId | null | undefined;
1190
+ readonly requestedInstanceId?: ProviderInstanceId | null | undefined;
1191
+}): ProviderOptionSelectionsByProvider | null {
1192
+ const { modelOptions, selectedInstanceId, requestedInstanceId } = input;
1193
+ if (
1194
+ !modelOptions ||
1195
+ !selectedInstanceId ||
1196
+ !requestedInstanceId ||
1197
+ selectedInstanceId === requestedInstanceId ||
1198
+ modelOptions[selectedInstanceId] !== undefined
1199
+ ) {
1200
+ return modelOptions;
1201
+ }
1202
+ const requestedOptions = modelOptions[requestedInstanceId];
1203
+ const requestedDriver = input.providers.find(
1204
+ (provider) => provider.instanceId === requestedInstanceId,
1205
+ )?.driver;
1206
+ // The model of the selection the options came from, which can differ from the shown model's source.
1207
+ const requestedModel = input.optionSelections?.[requestedInstanceId]?.model;
1208
+ if (
1209
+ !requestedOptions ||
1210
+ requestedDriver !== input.selectedProvider ||
1211
+ requestedModel !== input.selectedModel
1212
+ ) {
1213
+ return modelOptions;
1214
+ }
1215
+ return { ...modelOptions, [selectedInstanceId]: requestedOptions };
1216
+}
1217
+
1218
function revokeObjectPreviewUrl(previewUrl: string): void {
1219
if (typeof URL === "undefined") {
1220
return;
apps/web/src/modelSelection.test.ts
+162
-1
@@ -10,7 +10,12 @@ import { describe, expect, it } from "vite-plus/test";
10
import { createModelSelection } from "@t3tools/shared/model";
11
import { deriveEffectiveComposerModelState } from "./composerDraftStore";
12
import { getComposerProviderState } from "./components/chat/composerProviderState";
13
-import { deriveProviderInstanceEntries, NO_PROVIDER_MODEL_SELECTION } from "./providerInstances";
13
+import { resolveComposerProviderSelection } from "./components/ChatView.logic";
14
+import {
15
+ deriveProviderInstanceEntries,
16
+ NO_PROVIDER_MODEL_SELECTION,
17
+ providerInstanceEntriesFor,
18
+} from "./providerInstances";
19
import {
20
getAppModelOptionsForInstance,
21
resolveAppModelSelectionForInstance,
@@ -780,3 +785,159 @@ describe("default model settings and new-thread composer parity", () => {
785
},
786
);
787
});
788
+
789
+describe("composer fallback to another instance of the same driver", () => {
790
+ const claude = ProviderDriverKind.make("claudeAgent");
791
+ const codex = ProviderDriverKind.make("codex");
792
+ const disabled = ProviderInstanceId.make("claudeAgent");
793
+ const fallback = ProviderInstanceId.make("claude_team");
794
+ const effortModels: ServerProvider["models"] = [
795
+ {
796
+ slug: "claude-opus-5-5",
797
+ name: "Claude Opus 5.5",
798
+ isCustom: false,
799
+ capabilities: {
800
+ optionDescriptors: [
801
+ {
802
+ id: "effort",
803
+ label: "Effort",
804
+ type: "select",
805
+ options: ["medium", "high", "xhigh"].map((id) => ({
806
+ id,
807
+ label: id,
808
+ isDefault: id === "medium",
809
+ })),
810
+ },
811
+ ],
812
+ },
813
+ },
814
+ ];
815
+ const providers: ReadonlyArray<ServerProvider> = [
816
+ {
817
+ ...provider({ provider: claude, instanceId: disabled }),
818
+ enabled: false,
819
+ models: effortModels,
820
+ },
821
+ { ...provider({ provider: claude, instanceId: fallback }), models: effortModels },
822
+ ];
823
+ const picked = createModelSelection(disabled, "claude-opus-5-5", [
824
+ { id: "effort", value: "xhigh" },
825
+ ]);
826
+
827
+ // The same steps useComposerProviderModel takes, without the draft store.
828
+ function composerFor(input: {
829
+ readonly providers: ReadonlyArray<ServerProvider>;
830
+ readonly draft?: Parameters<typeof deriveEffectiveComposerModelState>[0]["draft"];
831
+ readonly threadModelSelection: ReturnType<typeof createModelSelection>;
832
+ }) {
833
+ const settings = {
834
+ ...DEFAULT_UNIFIED_SETTINGS,
835
+ providerInstances: Object.fromEntries(
836
+ input.providers.map((provider) => [
837
+ provider.instanceId,
838
+ {
839
+ driver: provider.driver,
840
+ enabled: provider.enabled,
841
+ config: {},
842
+ },
843
+ ]),
844
+ ),
845
+ };
846
+ const selection = resolveComposerProviderSelection({
847
+ entries: providerInstanceEntriesFor(input.providers, settings, null),
848
+ candidateInstanceIds: [input.threadModelSelection.instanceId],
849
+ lockedProvider: null,
850
+ lockedInstanceId: undefined,
851
+ });
852
+ const selectedInstanceId = selection.selectedProviderEntry!.instanceId;
853
+ const selectedProvider = selection.selectedProviderEntry!.driverKind;
854
+ const state = deriveEffectiveComposerModelState({
855
+ draft: input.draft ?? null,
856
+ providers: input.providers,
857
+ selectedProvider,
858
+ selectedInstanceId,
859
+ requestedInstanceId: selection.requestedInstanceId,
860
+ threadModelSelection: input.threadModelSelection,
861
+ projectModelSelection: null,
862
+ settings,
863
+ });
864
+ const traits = getComposerProviderState({
865
+ provider: selectedProvider,
866
+ model: state.selectedModel,
867
+ models: selection.selectedProviderEntry!.models,
868
+ modelOptions: state.modelOptions?.[selectedInstanceId],
869
+ planModeEnabled: false,
870
+ });
871
+ return { selectedInstanceId, state, traits };
872
+ }
873
+
874
+ it("keeps the requested instance's effort on the fallback instance", () => {
875
+ const { selectedInstanceId, state, traits } = composerFor({
876
+ providers,
877
+ threadModelSelection: picked,
878
+ });
879
+
880
+ expect(selectedInstanceId).toBe(fallback);
881
+ expect(state.selectedModel).toBe("claude-opus-5-5");
882
+ expect(traits.promptEffort).toBe("xhigh");
883
+ expect(
884
+ createModelSelection(fallback, state.selectedModel, traits.modelOptionsForDispatch),
885
+ ).toEqual(
886
+ createModelSelection(fallback, "claude-opus-5-5", [{ id: "effort", value: "xhigh" }]),
887
+ );
888
+ });
889
+
890
+ it("keeps options the fallback instance already has", () => {
891
+ const { traits } = composerFor({
892
+ providers,
893
+ threadModelSelection: picked,
894
+ draft: {
895
+ activeProvider: disabled,
896
+ modelSelectionByProvider: {
897
+ [disabled]: picked,
898
+ [fallback]: createModelSelection(fallback, "claude-opus-5-5", [
899
+ { id: "effort", value: "high" },
900
+ ]),
901
+ },
902
+ },
903
+ });
904
+
905
+ expect(traits.promptEffort).toBe("high");
906
+ });
907
+
908
+ it("does not carry options picked with another model", () => {
909
+ // An optionless draft pick takes its options from the thread, which holds another model.
910
+ const { state, traits } = composerFor({
911
+ providers,
912
+ threadModelSelection: createModelSelection(disabled, "claude-sonnet-4-6", [
913
+ { id: "effort", value: "high" },
914
+ ]),
915
+ draft: {
916
+ activeProvider: disabled,
917
+ modelSelectionByProvider: { [disabled]: createModelSelection(disabled, "claude-opus-5-5") },
918
+ },
919
+ });
920
+
921
+ expect(state.selectedModel).toBe("claude-opus-5-5");
922
+ expect(traits.promptEffort).toBe("medium");
923
+ expect(traits.modelOptionsForDispatch).toBeUndefined();
924
+ });
925
+
926
+ it("does not carry options to another driver", () => {
927
+ const codexOnly: ReadonlyArray<ServerProvider> = [
928
+ {
929
+ ...provider({ provider: claude, instanceId: disabled }),
930
+ enabled: false,
931
+ models: effortModels,
932
+ },
933
+ provider({ provider: codex, instanceId: "codex", models: ["gpt-6-astra"] }),
934
+ ];
935
+ const { selectedInstanceId, state } = composerFor({
936
+ providers: codexOnly,
937
+ threadModelSelection: picked,
938
+ });
939
+
940
+ expect(selectedInstanceId).toBe(ProviderInstanceId.make("codex"));
941
+ expect(state.modelOptions?.[selectedInstanceId]).toBeUndefined();
942
+ });
943
+});