feat: Auto-select default model when connecting a provider

When a user connects a provider (OpenRouter, Anthropic, or ChatGPT),
automatically select the first (default) model from that provider.

Changes:
- Add pendingProviderAutoSelect field to track newly connected provider
- Set flag on OpenRouterKeySaved, AnthropicOAuthConnected, ChatGPTOAuthConnected
- Update ModelsConfigReceived to auto-select first model from pending provider
- Persist auto-selected model to localStorage
- Add comprehensive tests for all three providers

Author: itayadler

libs/client/src/Client__TaskTabs.story.res

@@ -72,6 +72,7 @@ module Fixtures = {
     chatgptOAuthStatus: StateTypes.ChatGPTNotConnected,
     modelsConfig: None,
     selectedModel: None,
+    pendingProviderAutoSelect: None,
     sessionsLoadState: StateTypes.SessionsNotLoaded,
   }
 

libs/client/src/state/Client__StateSnapshot__Storybook.res

@@ -160,6 +160,7 @@ let snapshotToState = (snapshot: Snapshot.t): StateTypes.state => {
     chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
     modelsConfig: None,
     selectedModel: None,
+    pendingProviderAutoSelect: None,
     sessionsLoadState: Client__State__Types.SessionsNotLoaded, // Cannot restore load state from snapshot
   }
 }

libs/client/src/state/Client__State__StateReducer.res

@@ -216,6 +216,7 @@ let defaultState: state = {
   chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
   modelsConfig: None,
   selectedModel: loadSelectedModelFromStorage(), // Load from localStorage on init
+  pendingProviderAutoSelect: None,
   sessionsLoadState: Client__State__Types.SessionsNotLoaded,
 }
 
@@ -1280,6 +1281,7 @@ let next = (state: state, action) => {
         source: UserOverride,
         saveStatus: Saved,
       },
+      pendingProviderAutoSelect: Some("openrouter"),
     }->FrontmanReactStatestore.StateReducer.update(~sideEffects=effects)
 
   | OpenRouterKeySaveError({error}) =>
@@ -1311,24 +1313,51 @@ let next = (state: state, action) => {
     }
 
   | ModelsConfigReceived({config}) =>
-    // Set models config and initialize selected model if not already set
-    let selectedModel = switch state.selectedModel {
-    | Some(model) => Some(model)
+    // When a provider was just connected, auto-select its first model.
+    // Otherwise keep the current selection (or fall back to server default).
+    let (selectedModel, didAutoSelect) = switch state.pendingProviderAutoSelect {
+    | Some(providerId) =>
+      // Find the first model from the newly connected provider
+      let providerModel =
+        config.providers
+        ->Array.find(p => p.id == providerId)
+        ->Option.flatMap(p => p.models->Array.get(0))
+        ->Option.map((m): Client__State__Types.selectedModel => {
+          provider: providerId,
+          value: m.value,
+        })
+      switch providerModel {
+      | Some(model) => (Some(model), true)
+      | None => (state.selectedModel, false)
+      }
     | None =>
-      // Use default model from config
-      Some(
+      switch state.selectedModel {
+      | Some(model) => (Some(model), false)
+      | None =>
+        // Use default model from config
         (
-          {
-            provider: config.defaultModel.provider,
-            value: config.defaultModel.value,
-          }: Client__State__Types.selectedModel
-        ),
-      )
+          Some(
+            (
+              {
+                provider: config.defaultModel.provider,
+                value: config.defaultModel.value,
+              }: Client__State__Types.selectedModel
+            ),
+          ),
+          true,
+        )
+      }
+    }
+    // Persist whenever we picked a new model
+    switch (didAutoSelect, selectedModel) {
+    | (true, Some(model)) => saveSelectedModelToStorage(model)
+    | _ => ()
     }
     {
       ...state,
       modelsConfig: Some(config),
       selectedModel,
+      pendingProviderAutoSelect: None,
     }->FrontmanReactStatestore.StateReducer.update
 
   | SetSelectedModel({model}) =>
@@ -1400,6 +1429,7 @@ let next = (state: state, action) => {
     {
       ...state,
       anthropicOAuthStatus: Client__State__Types.Connected({expiresAt: expiresAtMs}),
+      pendingProviderAutoSelect: Some("anthropic"),
     }->FrontmanReactStatestore.StateReducer.update(~sideEffects=effects)
 
   | AnthropicOAuthError({error}) =>
@@ -1513,6 +1543,7 @@ let next = (state: state, action) => {
       {
         ...state,
         chatgptOAuthStatus: Client__State__Types.ChatGPTConnected({expiresAt: expiresAtMs}),
+        pendingProviderAutoSelect: Some("openai"),
       }->FrontmanReactStatestore.StateReducer.update(~sideEffects=effects)
     | _ => state->FrontmanReactStatestore.StateReducer.update
     }

libs/client/src/state/Client__State__Types.res

@@ -160,5 +160,8 @@ type state = {
   chatgptOAuthStatus: chatgptOAuthStatus,
   modelsConfig: option<modelsConfig>,
   selectedModel: option<selectedModel>,
+  // When a provider is freshly connected, this holds its id (e.g. "anthropic")
+  // so the next ModelsConfigReceived auto-selects a default model from it.
+  pendingProviderAutoSelect: option<string>,
   sessionsLoadState: sessionsLoadState,
 }

libs/client/test/Client__ChatGPTOAuth.test.res

@@ -20,6 +20,7 @@ let _makeState = (~chatgptOAuthStatus: Types.chatgptOAuthStatus): Types.state =>
     chatgptOAuthStatus,
     modelsConfig: None,
     selectedModel: None,
+    pendingProviderAutoSelect: None,
     sessionsLoadState: Types.SessionsNotLoaded,
   }
 }

libs/client/test/Client__ModelsRefresh.test.res

@@ -12,7 +12,7 @@ let _dummyDeleteSession: Types.deleteSessionFn = (_, ~onComplete as _) => ()
 let _apiBaseUrl = "http://localhost:4000"
 
 // Helper: base state with an active ACP session (needed to emit effects)
-let _makeState = (~anthropicOAuthStatus=Types.NotConnected, ~chatgptOAuthStatus=Types.ChatGPTNotConnected, ~openrouterKeySettings={Types.source: Types.None, saveStatus: Types.Idle}): Types.state => {
+let _makeState = (~anthropicOAuthStatus=Types.NotConnected, ~chatgptOAuthStatus=Types.ChatGPTNotConnected, ~openrouterKeySettings={Types.source: Types.None, saveStatus: Types.Idle}, ~selectedModel=None, ~pendingProviderAutoSelect=None): Types.state => {
   {
     tasks: Dict.make(),
     currentTask: Types.Task.New(Types.Task.makeNew(~previewUrl="http://localhost:3000")),
@@ -30,7 +30,8 @@ let _makeState = (~anthropicOAuthStatus=Types.NotConnected, ~chatgptOAuthStatus=
     anthropicOAuthStatus,
     chatgptOAuthStatus,
     modelsConfig: None,
-    selectedModel: None,
+    selectedModel,
+    pendingProviderAutoSelect,
     sessionsLoadState: Types.SessionsNotLoaded,
   }
 }
@@ -137,3 +138,186 @@ describe("Models list refresh requires active ACP session", () => {
     t->expect(_hasFetchModelsEffect(effects))->Expect.toBe(false)
   })
 })
+
+// ============================================================================
+// Auto-select default model from newly connected provider
+// ============================================================================
+
+module SampleConfig = {
+  let anthropicProvider: Types.providerConfig = {
+    id: "anthropic",
+    name: "Anthropic (Claude Pro/Max)",
+    models: [
+      {displayName: "Claude Sonnet 4.5", value: "claude-sonnet-4-5"},
+      {displayName: "Claude Opus 4.5", value: "claude-opus-4-5"},
+    ],
+  }
+  let openaiProvider: Types.providerConfig = {
+    id: "openai",
+    name: "ChatGPT Pro/Plus",
+    models: [
+      {displayName: "GPT-5.1 Codex Max", value: "gpt-5.1-codex-max"},
+      {displayName: "GPT-5.2", value: "gpt-5.2"},
+    ],
+  }
+  let openrouterProvider: Types.providerConfig = {
+    id: "openrouter",
+    name: "OpenRouter",
+    models: [
+      {displayName: "Gemini 3 Flash Preview", value: "google/gemini-3-flash-preview"},
+      {displayName: "Claude Haiku 4.5", value: "anthropic/claude-haiku-4.5"},
+    ],
+  }
+  let configWithAnthropic: Types.modelsConfig = {
+    providers: [anthropicProvider, openrouterProvider],
+    defaultModel: {provider: "anthropic", value: "claude-sonnet-4-5"},
+  }
+  let configWithOpenAI: Types.modelsConfig = {
+    providers: [openaiProvider, anthropicProvider, openrouterProvider],
+    defaultModel: {provider: "openai", value: "gpt-5.1-codex-max"},
+  }
+  let configWithOpenRouterOnly: Types.modelsConfig = {
+    providers: [openrouterProvider],
+    defaultModel: {provider: "openrouter", value: "google/gemini-3-flash-preview"},
+  }
+}
+
+describe("Provider connect sets pendingProviderAutoSelect", () => {
+  test("AnthropicOAuthConnected sets pendingProviderAutoSelect to anthropic", t => {
+    let state = _makeState()
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      AnthropicOAuthConnected({expiresAt: "2026-12-31T00:00:00Z"}),
+    )
+
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(Some("anthropic"))
+  })
+
+  test("ChatGPTOAuthConnected sets pendingProviderAutoSelect to openai", t => {
+    let state = _makeState(
+      ~chatgptOAuthStatus=Types.ChatGPTShowingCode({
+        deviceAuthId: "device-1",
+        userCode: "ABCD-1234",
+        verificationUrl: "https://auth.openai.com/codex/device",
+      }),
+    )
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ChatGPTOAuthConnected({deviceAuthId: "device-1", expiresAt: "2026-12-31T00:00:00Z"}),
+    )
+
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(Some("openai"))
+  })
+
+  test("OpenRouterKeySaved sets pendingProviderAutoSelect to openrouter", t => {
+    let state = _makeState()
+
+    let (nextState, _effects) = Reducer.next(state, OpenRouterKeySaved)
+
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(Some("openrouter"))
+  })
+})
+
+describe("ModelsConfigReceived auto-selects model from newly connected provider", () => {
+  test("auto-selects first Anthropic model when pendingProviderAutoSelect is anthropic", t => {
+    let state = _makeState(
+      ~pendingProviderAutoSelect=Some("anthropic"),
+      ~selectedModel=Some({provider: "openrouter", value: "google/gemini-3-flash-preview"}),
+    )
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ModelsConfigReceived({config: SampleConfig.configWithAnthropic}),
+    )
+
+    t
+    ->expect(nextState.selectedModel)
+    ->Expect.toEqual(Some({provider: "anthropic", value: "claude-sonnet-4-5"}))
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(None)
+  })
+
+  test("auto-selects first OpenAI model when pendingProviderAutoSelect is openai", t => {
+    let state = _makeState(
+      ~pendingProviderAutoSelect=Some("openai"),
+      ~selectedModel=Some({provider: "openrouter", value: "google/gemini-3-flash-preview"}),
+    )
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ModelsConfigReceived({config: SampleConfig.configWithOpenAI}),
+    )
+
+    t
+    ->expect(nextState.selectedModel)
+    ->Expect.toEqual(Some({provider: "openai", value: "gpt-5.1-codex-max"}))
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(None)
+  })
+
+  test("auto-selects first OpenRouter model when pendingProviderAutoSelect is openrouter", t => {
+    let state = _makeState(
+      ~pendingProviderAutoSelect=Some("openrouter"),
+      ~selectedModel=Some({provider: "openrouter", value: "anthropic/claude-haiku-4.5"}),
+    )
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ModelsConfigReceived({config: SampleConfig.configWithOpenRouterOnly}),
+    )
+
+    t
+    ->expect(nextState.selectedModel)
+    ->Expect.toEqual(Some({provider: "openrouter", value: "google/gemini-3-flash-preview"}))
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(None)
+  })
+
+  test("keeps current selection when no pending provider auto-select", t => {
+    let existingModel: Types.selectedModel = {
+      provider: "openrouter",
+      value: "google/gemini-3-flash-preview",
+    }
+    let state = _makeState(~selectedModel=Some(existingModel))
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ModelsConfigReceived({config: SampleConfig.configWithAnthropic}),
+    )
+
+    t->expect(nextState.selectedModel)->Expect.toEqual(Some(existingModel))
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(None)
+  })
+
+  test("falls back to server default when no selection and no pending provider", t => {
+    let state = _makeState()
+
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ModelsConfigReceived({config: SampleConfig.configWithAnthropic}),
+    )
+
+    t
+    ->expect(nextState.selectedModel)
+    ->Expect.toEqual(Some({provider: "anthropic", value: "claude-sonnet-4-5"}))
+  })
+
+  test("clears pendingProviderAutoSelect even if provider not in config", t => {
+    let existingModel: Types.selectedModel = {
+      provider: "openrouter",
+      value: "google/gemini-3-flash-preview",
+    }
+    let state = _makeState(
+      ~pendingProviderAutoSelect=Some("openai"),
+      ~selectedModel=Some(existingModel),
+    )
+
+    // Config doesn't have OpenAI provider — keep existing selection
+    let (nextState, _effects) = Reducer.next(
+      state,
+      ModelsConfigReceived({config: SampleConfig.configWithOpenRouterOnly}),
+    )
+
+    t->expect(nextState.selectedModel)->Expect.toEqual(Some(existingModel))
+    t->expect(nextState.pendingProviderAutoSelect)->Expect.toEqual(None)
+  })
+})

libs/client/test/Client__State__StateReducer.test.res

@@ -41,6 +41,7 @@ module TestHelpers = {
         chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
         modelsConfig: None,
         selectedModel: None,
+        pendingProviderAutoSelect: None,
         sessionsLoadState: Client__State__Types.SessionsNotLoaded,
       }: Client__State__Types.state
     )
@@ -666,6 +667,7 @@ describe("Client State Reducer - Task Management Actions", () => {
       chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
       modelsConfig: None,
       selectedModel: None,
+      pendingProviderAutoSelect: None,
       sessionsLoadState: Client__State__Types.SessionsNotLoaded,
     }
 
@@ -714,6 +716,7 @@ describe("Client State Reducer - Task Management Actions", () => {
       chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
       modelsConfig: None,
       selectedModel: None,
+      pendingProviderAutoSelect: None,
       sessionsLoadState: Client__State__Types.SessionsNotLoaded,
     }
 
@@ -761,6 +764,7 @@ describe("Client State Reducer - Task Management Actions", () => {
       chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
       modelsConfig: None,
       selectedModel: None,
+      pendingProviderAutoSelect: None,
       sessionsLoadState: Client__State__Types.SessionsNotLoaded,
     }
 
@@ -829,6 +833,7 @@ describe("Client State Reducer - Task Management Actions", () => {
       chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
       modelsConfig: None,
       selectedModel: None,
+      pendingProviderAutoSelect: None,
       sessionsLoadState: Client__State__Types.SessionsNotLoaded,
     }
 
@@ -945,6 +950,7 @@ describe("Client State Reducer - Session Loading Actions", () => {
       chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
       modelsConfig: None,
       selectedModel: None,
+      pendingProviderAutoSelect: None,
       sessionsLoadState: Client__State__Types.SessionsLoading,
     }
 
@@ -1033,6 +1039,7 @@ describe("Client State Reducer - Session Loading Actions", () => {
       chatgptOAuthStatus: Client__State__Types.ChatGPTNotConnected,
       modelsConfig: None,
       selectedModel: None,
+      pendingProviderAutoSelect: None,
       sessionsLoadState: Client__State__Types.SessionsLoaded,
     }