From bbccfd9d4494ddca92da3e3666e70a3e5bab9050 Mon Sep 17 00:00:00 2001
From: Krasimir Kralev <263465593+KrasimirKralev@users.noreply.github.com>
Date: Sun, 19 Apr 2026 02:51:07 +0300
Subject: [PATCH 1/2] fix(ai-provider): sweep sessions, show progress + green
 banner on switch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Changing the primary AI provider in Settings (e.g. OpenAI → ClawBox AI)
had three user-visible problems:

1. Chat kept responding as the OLD provider after the switch.
   The configure route updated agents.defaults.model.primary but
   left every existing session's per-session override pointing at
   the previous model. OpenClaw's resolver respected those sticky
   overrides on the next turn, so the chat stayed bound to the old
   provider until the user cleared the session — or refreshed the
   page and noticed it still answered wrong.

2. Chat 'froze' during the gateway restart. The chat popup only
   had skill-install-aware retry logic, so a provider-change gateway
   restart dropped the WS and the user saw no progress; only the
   bare retry loop slowly reconnected.

3. No affirmative 'switched to X' feedback — when reconnect finally
   landed, the chat looked identical to before. The dropdown already
   shows a green 'Switched chat to X' banner when switching models
   from within the chat pane (PR #73); provider changes via Settings
   deserved the same.

Changes:

- src/app/setup-api/ai-models/configure/route.ts: after
  'agents.defaults.model.primary' is written, sweep per-session
  model overrides via applyModelOverrideToAllAgentSessions with
  source: 'user' so OpenClaw's resolver keeps the new primary
  bound across existing sessions. Mirrors the sweep in
  /setup-api/chat/model from PR #73. Only runs when this call
  actually set a new primary (skips local-only scopes).

- src/components/ChatPopup.tsx: listens for the existing
  clawbox:primary-ai-configured event (dispatched by SettingsApp
  after provider configure succeeds) alongside
  clawbox-skill-installed. Reuses the reloadingSkill overlay +
  progress bar + quadrupled retry budget — makes the gateway
  restart visible instead of letting the chat look frozen. Banner
  label adapts ('Switching AI provider...' vs 'Reloading skills...')
  via a new reloadReason state; a matching reloadReasonRef escapes
  the frozen closure captured by the one-time WebSocket hello
  resolve callback. After reconnect on a provider change, the
  auto-'my skills were just updated' prompt is skipped (no skill
  changed, nothing to confirm) and a green 'Switched chat to
  <label>' banner is pushed using the refreshed chat/model state.

- src/app/setup-api/chat/model/route.ts: PROVIDER_LABELS map was
  missing 'openai-codex', so labelForProvider fell back to the
  generic 'AI Provider' placeholder — which made the new banner
  read 'Switched chat to AI Provider' when switching to or from
  openai-codex. Added 'openai-codex: "OpenAI Codex"'.

Post-fix /simplify pass converted the inline fetch().then().then()
chain in ChatPopup's reload branch to async/await to match the
existing refreshChatModelState pattern in the same file. Semantics
unchanged.
---
 .../setup-api/ai-models/configure/route.ts    | 35 +++++++++-
 src/app/setup-api/chat/model/route.ts         |  1 +
 src/components/ChatPopup.tsx                  | 66 +++++++++++++++++--
 3 files changed, 94 insertions(+), 8 deletions(-)

diff --git a/src/app/setup-api/ai-models/configure/route.ts b/src/app/setup-api/ai-models/configure/route.ts
index e888c17d6..c3b43cf1c 100644
--- a/src/app/setup-api/ai-models/configure/route.ts
+++ b/src/app/setup-api/ai-models/configure/route.ts
@@ -12,6 +12,8 @@ import {
   DEFAULT_COMPACTION_RESERVE_TOKENS_FLOOR,
   inferConfiguredLocalModel,
   readConfig as readOpenClawConfig,
+  applyModelOverrideToAllAgentSessions,
+  parseFullyQualifiedModel,
 } from "@/lib/openclaw-config";
 import {
   getDefaultLlamaCppModel,
@@ -588,7 +590,38 @@ export async function POST(request: Request) {
       await ensureFallbackModel(config.defaultModel);
     }
 
-    // 8. Restart OpenClaw gateway so it picks up the new auth profile and model
+    // 8. Sweep every existing session's per-session override to the new
+    //    primary model, tagged `source: "user"` so OpenClaw's per-turn
+    //    model resolver returns early and doesn't flip the session back
+    //    to the previous provider on the first message after the switch.
+    //    Without this, a session that was bound to e.g. openai-codex
+    //    keeps routing to openai-codex even after the user changes the
+    //    primary provider to ClawBox AI / DeepSeek / etc. — the new
+    //    default only seeds future sessions. Mirror of the sweep in
+    //    /setup-api/chat/model (see PR #73 for context on why "user" is
+    //    the only sticky source value).
+    //
+    //    Only sweep when this configure call actually set a new primary
+    //    (skip for local-only local-AI setups that leave the primary
+    //    alone).
+    if (!isLocalScope || shouldPromoteLocalToPrimary) {
+      const parsedPrimary = parseFullyQualifiedModel(config.defaultModel);
+      if (parsedPrimary) {
+        try {
+          await applyModelOverrideToAllAgentSessions({
+            provider: parsedPrimary.provider,
+            modelId: parsedPrimary.modelId,
+            source: "user",
+          });
+        } catch (err) {
+          // Non-fatal: the default change above still takes effect for
+          // brand-new sessions; worst case the user resets the open chat.
+          console.error("[configure] Failed to sweep session overrides:", err);
+        }
+      }
+    }
+
+    // 9. Restart OpenClaw gateway so it picks up the new auth profile and model
     try {
       await restartGateway();
     } catch (err) {
diff --git a/src/app/setup-api/chat/model/route.ts b/src/app/setup-api/chat/model/route.ts
index bacb10b64..344371261 100644
--- a/src/app/setup-api/chat/model/route.ts
+++ b/src/app/setup-api/chat/model/route.ts
@@ -31,6 +31,7 @@ const PROVIDER_LABELS: Record<string, string> = {
   clawai: "ClawBox AI",
   anthropic: "Anthropic Claude",
   openai: "OpenAI GPT",
+  "openai-codex": "OpenAI Codex",
   google: "Google Gemini",
   openrouter: "OpenRouter",
   ollama: "Ollama Local",
diff --git a/src/components/ChatPopup.tsx b/src/components/ChatPopup.tsx
index 8d071c1d3..0bfd19770 100644
--- a/src/components/ChatPopup.tsx
+++ b/src/components/ChatPopup.tsx
@@ -379,9 +379,15 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
           const sessionDefaults = snapshot?.sessionDefaults as Record<string, unknown> | undefined
           const mainSessionKey = (sessionDefaults?.mainSessionKey as string) || 'main'
           sessionKeyRef.current = mainSessionKey
-          // If a skill was just installed/uninstalled, start fresh session
+          // If a skill was just installed/uninstalled, start fresh session.
+          // Provider changes re-use the same flag for retry-budget + overlay
+          // purposes, but we skip the auto-send prompt for them (no skill
+          // changed, there's nothing to confirm) — just reset and hand
+          // control back to the user.
           if (skillInstalledRef.current) {
+            const wasProviderChange = reloadReasonRef.current === 'provider'
             skillInstalledRef.current = false
+            reloadReasonRef.current = 'skill' // reset for next reload
             setMessages([])
             greetedRef.current = true // prevent auto-greet
             const evt = skillEventRef.current
@@ -400,9 +406,34 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
             // Complete the progress bar
             if (reloadTimerRef.current) clearInterval(reloadTimerRef.current)
             setReloadProgress(100)
-            // Small delay to show 100%, then switch to sending dots
-            setTimeout(() => {
+            // Small delay to show 100%, then either auto-send the skill
+            // context message (skill install/uninstall) or, for a
+            // provider change, just drop the overlay and surface a
+            // green "Switched chat to X" banner so the user has an
+            // explicit confirmation the new provider is active.
+            setTimeout(async () => {
               setReloadingSkill(false)
+              if (wasProviderChange) {
+                // Refresh chat/model state so we can label the banner with
+                // the new active provider. Fire-and-forget — if the fetch
+                // fails the worst case is we don't show the banner, not
+                // that the chat is broken.
+                try {
+                  const res = await fetch('/setup-api/chat/model', { cache: 'no-store' })
+                  const state = await res.json() as ChatModelState
+                  setChatModelState(state)
+                  const label = state.activeLabel ?? state.primary?.label ?? 'the new AI provider'
+                  setMessages(prev => [...prev, {
+                    role: 'system',
+                    text: `Switched chat to ${label}.`,
+                    timestamp: Date.now(),
+                    variant: 'success',
+                  }])
+                } catch {
+                  // Ignore — banner is best-effort confirmation only.
+                }
+                return
+              }
               setSending(true)
               setMessages([{ role: 'user', text: contextMsg.replace(/\[System:.*?\]\s*/g, ''), timestamp: Date.now() }])
               wsRequest('chat.send', {
@@ -774,12 +805,22 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
   const skillEventRef = useRef<{ action: string; name?: string; id?: string } | null>(null)
   const [reloadingSkill, setReloadingSkill] = useState(false)
   const [reloadProgress, setReloadProgress] = useState(0)
+  const [reloadReason, setReloadReason] = useState<'skill' | 'provider'>('skill')
+  // Duplicate of reloadReason behind a ref because the WebSocket `hello`
+  // resolve callback is created once (inside a useCallback with [] deps)
+  // and captures whatever reloadReason state was at mount time —
+  // without this ref, the `wasProviderChange` branch would never fire
+  // because the state update from the event handler doesn't propagate
+  // into that frozen closure.
+  const reloadReasonRef = useRef<'skill' | 'provider'>('skill')
   const reloadTimerRef = useRef<ReturnType<typeof setInterval> | null>(null)
   useEffect(() => {
-    const handler = (e: Event) => {
+    const makeHandler = (reason: 'skill' | 'provider') => (e: Event) => {
       const detail = (e as CustomEvent).detail || {}
       skillInstalledRef.current = true
       skillEventRef.current = detail
+      reloadReasonRef.current = reason
+      setReloadReason(reason)
       setReloadingSkill(true)
       setReloadProgress(0)
       retryCountRef.current = 0
@@ -795,9 +836,20 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
         }
       }, 200)
     }
-    window.addEventListener('clawbox-skill-installed', handler)
+    const skillHandler = makeHandler('skill')
+    // Treat a primary-AI-provider change the same as a skill install:
+    // the gateway is restarting, the chat WS is about to drop, and
+    // without the progress overlay the user sees the chat freeze until
+    // the bare retry loop reconnects. Reusing the skillInstalledRef flag
+    // also gets us the quadrupled retry budget for the reconnect, so
+    // slower restarts don't trigger the 'Could not connect to gateway'
+    // fallback UI.
+    const providerHandler = makeHandler('provider')
+    window.addEventListener('clawbox-skill-installed', skillHandler)
+    window.addEventListener('clawbox:primary-ai-configured', providerHandler)
     return () => {
-      window.removeEventListener('clawbox-skill-installed', handler)
+      window.removeEventListener('clawbox-skill-installed', skillHandler)
+      window.removeEventListener('clawbox:primary-ai-configured', providerHandler)
       if (reloadTimerRef.current) clearInterval(reloadTimerRef.current)
     }
   }, [])
@@ -1024,7 +1076,7 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
               <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 14, width: '85%' }}>
                 <div style={SPINNER_STYLE} />
                 <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 10, width: '100%' }}>
-                  <span>Reloading skills...</span>
+                  <span>{reloadReason === 'provider' ? 'Switching AI provider...' : 'Reloading skills...'}</span>
                   <div role="progressbar" aria-valuemin={0} aria-valuemax={100} aria-valuenow={reloadProgress} aria-label="Reload progress" style={{ width: '100%', height: 4, borderRadius: 2, background: 'rgba(255,255,255,0.08)', overflow: 'hidden' }}>
                     <div style={{
                       height: '100%', borderRadius: 2, background: '#f97316',

From 1867c70ee97780aedb29b262beb9e7410edab143 Mon Sep 17 00:00:00 2001
From: Krasimir Kralev <263465593+KrasimirKralev@users.noreply.github.com>
Date: Sun, 19 Apr 2026 02:58:50 +0300
Subject: [PATCH 2/2] =?UTF-8?q?fix(chat):=20address=20CodeRabbit=20#83=20?=
 =?UTF-8?q?=E2=80=94=20preserve=20transcript=20+=20force=20hello=20on=20pr?=
 =?UTF-8?q?ovider=20change?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two Major findings on PR #83:

1. Provider switches were wiping the chat transcript. setMessages([])
   ran unconditionally in the skillInstalledRef branch before the
   wasProviderChange check, so a Settings provider change cleared
   the user's visible history. Skill installs still want the reset
   (new tools may change the assistant's behavior), but provider
   changes don't — the conversation semantics are unchanged.
   Guarded the reset + greetedRef bump behind !wasProviderChange.

2. Provider-reload overlay could get stuck on fast gateway restarts.
   The configure route restarts the gateway before returning its
   response, and the primary-ai-configured event fires only after
   that response lands. If the WS retry loop has already
   reconnected by then, no future hello triggers the reload branch
   and the overlay stays up indefinitely.

   The provider handler now, after seeding state:
   - closes any currently-open WebSocket (so the resolve-branch
     fires on a fresh connect rather than relying on a stale hello
     that missed skillInstalledRef=true)
   - resets retryCountRef and calls connect() directly

   This makes the completion independent of any in-flight hello's
   timing relative to when the event is dispatched.
---
 src/components/ChatPopup.tsx | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/src/components/ChatPopup.tsx b/src/components/ChatPopup.tsx
index 0bfd19770..13ce6ea67 100644
--- a/src/components/ChatPopup.tsx
+++ b/src/components/ChatPopup.tsx
@@ -388,8 +388,14 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
             const wasProviderChange = reloadReasonRef.current === 'provider'
             skillInstalledRef.current = false
             reloadReasonRef.current = 'skill' // reset for next reload
-            setMessages([])
-            greetedRef.current = true // prevent auto-greet
+            // Only reset the transcript for skill install/uninstall/etc.
+            // Provider changes keep the visible history so the user's
+            // earlier context isn't wiped — only the backend session
+            // override changed, not the conversation semantics.
+            if (!wasProviderChange) {
+              setMessages([])
+              greetedRef.current = true // prevent auto-greet
+            }
             const evt = skillEventRef.current
             skillEventRef.current = null
             // Build context message about the skill change
@@ -844,7 +850,22 @@ function ChatPopup({ isOpen, onClose, onOpenFull, onOpenSettingsSection, onThink
     // also gets us the quadrupled retry budget for the reconnect, so
     // slower restarts don't trigger the 'Could not connect to gateway'
     // fallback UI.
-    const providerHandler = makeHandler('provider')
+    const providerReloadHandler = makeHandler('provider')
+    const providerHandler = (e: Event) => {
+      providerReloadHandler(e)
+      // The configure route restarts the gateway before returning its
+      // response, and the Settings event fires *after* the response —
+      // so by the time we get here the WS may already have reconnected
+      // on its own. If so, no future `hello` is coming to trip the
+      // reload branch in the resolve callback, and the overlay would
+      // stay up forever. Force a fresh connect() so the resolve-branch
+      // fires exactly once, right now, with reloadReasonRef=='provider'.
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        try { wsRef.current.close() } catch { /* ignore */ }
+      }
+      retryCountRef.current = 0
+      connect()
+    }
     window.addEventListener('clawbox-skill-installed', skillHandler)
     window.addEventListener('clawbox:primary-ai-configured', providerHandler)
     return () => {