fix: model-aware thinking budget, focus timing and pending edits

Three more consequences of the earlier fixes in this branch.

The thinking budget rendered with the shared model-agnostic -1..32000
range, which the new clamp then enforced: Gemini 2.5 Pro was capped below
its documented 32,768 ceiling while Flash values above 24,576 were still
accepted and sent on. The ceiling is now resolved per model alongside the
other model-aware defaults. Only the maximum moves, because -1 is the
"decide automatically" sentinel and raising the floor would clamp it away.

Restoring focus from afterSlide was too early. That callback runs on the
same frame as the deferred state flip, so the opener's ancestor was often
still inert and the browser refused the focus, leaving it on a scrim about
to be hidden. It now happens once the closed state has committed.

Migrating Google to the shared controls also made its fields debounced,
so Save or Export clicked straight after typing read the previous value.
The debounce hook exposes a flush, and the text controls call it on blur,
which is the event a Save click already fires first.

Author: berry-13

client/src/components/SidePanel/Parameters/DynamicInput.tsx

@@ -28,7 +28,9 @@ function DynamicInput({
   const localize = useLocalize();
   const { preset } = useChatContext();
 
-  const [setInputValue, inputValue, setLocalValue] = useDebouncedInput<string | number>({
+  const [setInputValue, inputValue, setLocalValue, flushInputValue] = useDebouncedInput<
+    string | number
+  >({
     optionKey: settingKey,
     initialValue: optionType !== OptionTypes.Custom ? conversation?.[settingKey] : defaultValue,
     setter: () => ({}),
@@ -66,6 +68,9 @@ function DynamicInput({
    *  say) was persisted and only rejected later by the provider. Clamping on
    *  blur rather than on change leaves partially typed numbers alone. */
   const handleInputBlur = () => {
+    /** Clicking Save blurs the field first, so committing the pending edit here
+     *  is what stops submitPreset reading the value from before it. */
+    flushInputValue();
     if (type !== SettingTypes.Number || range == null) {
       return;
     }

client/src/components/SidePanel/Parameters/DynamicTextarea.tsx

@@ -26,7 +26,9 @@ function DynamicTextarea({
   const localize = useLocalize();
   const { preset } = useChatContext();
 
-  const [setInputValue, inputValue, setLocalValue] = useDebouncedInput<string | null>({
+  const [setInputValue, inputValue, setLocalValue, flushInputValue] = useDebouncedInput<
+    string | null
+  >({
     optionKey: settingKey,
     initialValue:
       optionType !== OptionTypes.Custom
@@ -75,6 +77,9 @@ function DynamicTextarea({
             disabled={readonly}
             value={inputValue ?? ''}
             onChange={setInputValue}
+            /** Clicking Save blurs this first, so the pending edit is committed
+             *  before submitPreset reads the preset. */
+            onBlur={flushInputValue}
             aria-label={localize(label as TranslationKeys)}
             placeholder={
               placeholderCode

client/src/hooks/Conversations/useDebouncedInput.ts

@@ -1,5 +1,5 @@
-import debounce from 'lodash/debounce';
 import React, { useState, useCallback, useMemo } from 'react';
+import debounce from 'lodash/debounce';
 import type { SetterOrUpdater } from 'recoil';
 import type { TSetOption } from '~/common';
 import { defaultDebouncedDelay } from '~/common';
@@ -23,7 +23,7 @@ function useDebouncedInput<T = unknown>({
   (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement> | T, numeric?: boolean) => void,
   T,
   SetterOrUpdater<T>,
-  // (newValue: string) => void,
+  () => void,
 ] {
   const [value, setValue] = useState<T>(initialValue);
 
@@ -52,7 +52,13 @@ function useDebouncedInput<T = unknown>({
     },
     [setDebouncedOption],
   );
-  return [onChange, value, setValue];
+  /** Lets a caller commit a pending edit immediately, e.g. on blur, so a Save
+   *  clicked in the same gesture does not read the pre-edit value. */
+  const flush = useCallback(() => {
+    setDebouncedOption.flush();
+  }, [setDebouncedOption]);
+
+  return [onChange, value, setValue, flush];
 }
 
 export default useDebouncedInput;

client/src/routes/Root.tsx

@@ -64,6 +64,7 @@ export default function Root() {
   /** The drawer and pane snap under reduced motion (see kickDrawerAnimation),
    *  so the scrim must not keep fading on its own. */
   const prefersReducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)');
+  const restoreFocusRef = useRef(false);
   const paneRef = useRef<HTMLDivElement>(null);
   /** Focus handoff lives in the drawer header's own expanded-effect — the
    * commit drives it, so every opener (button, swipe) is covered without a
@@ -107,6 +108,16 @@ export default function Root() {
     }
   }, [termsData]);
 
+  /** Focus can only move once the pane has actually shed `inert`, which is a
+   *  commit later than the close is requested. */
+  useEffect(() => {
+    if (sidebarExpanded || !restoreFocusRef.current) {
+      return;
+    }
+    restoreFocusRef.current = false;
+    document.getElementById(OPEN_SIDEBAR_ID)?.focus();
+  }, [sidebarExpanded]);
+
   const handleAcceptTerms = () => {
     setShowTerms(false);
   };
@@ -150,14 +161,15 @@ export default function Root() {
                     <button
                       type="button"
                       aria-label={localize('com_nav_close_sidebar')}
-                      onClick={() =>
+                      onClick={() => {
                         /** The scrim goes aria-hidden and untabbable on close,
-                         *  so focus cannot stay here; afterSlide hands it to the
-                         *  control that reopens the drawer. */
-                        setSidebarOpen(false, () =>
-                          document.getElementById(OPEN_SIDEBAR_ID)?.focus(),
-                        )
-                      }
+                         *  so focus cannot stay here. The handoff waits for the
+                         *  committed state below rather than riding afterSlide,
+                         *  which fires on the same frame as the deferred flip,
+                         *  while the opener's ancestor is still inert. */
+                        restoreFocusRef.current = true;
+                        setSidebarOpen(false);
+                      }}
                       tabIndex={sidebarExpanded ? 0 : -1}
                       aria-hidden={!sidebarExpanded || undefined}
                       className={cn(

packages/data-provider/src/parameterSettings.ts

@@ -6,6 +6,7 @@ import {
   EModelEndpoint,
   openAISettings,
   googleSettings,
+  getGoogleThinkingBudgetMax,
   Providers,
   ReasoningEffort,
   AnthropicEffort,
@@ -1267,9 +1268,19 @@ export function applyModelAwareDefaults(
   if (endpoint !== EModelEndpoint.google || !model) {
     return settings;
   }
-  return settings.map((setting) =>
-    setting.key === 'maxOutputTokens'
-      ? { ...setting, default: googleSettings.maxOutputTokens.reset(model) }
-      : setting,
-  );
+  return settings.map((setting) => {
+    if (setting.key === 'maxOutputTokens') {
+      return { ...setting, default: googleSettings.maxOutputTokens.reset(model) };
+    }
+    /** The shared thinking budget range is model-agnostic, so it caps Pro below
+     *  its real ceiling and accepts Flash values the provider rejects. Only the
+     *  maximum moves: -1 stays reachable as the "decide automatically" value. */
+    if (setting.key === 'thinkingBudget' && setting.range != null) {
+      const max = getGoogleThinkingBudgetMax(model);
+      if (max != null) {
+        return { ...setting, range: { ...setting.range, max } };
+      }
+    }
+    return setting;
+  });
 }

packages/data-provider/src/schemas.ts

@@ -463,6 +463,32 @@ const getGoogleMaxOutputTokens = (modelName: string): number => {
   return GOOGLE_LEGACY_MAX_OUTPUT;
 };
 
+/**
+ * Per-model thinking budget ceilings, documented in
+ * `com_endpoint_google_thinking_budget`: Gemini 2.5 Pro accepts up to 32,768
+ * tokens while Flash and Flash Lite stop at 24,576. The generic 32,000 in the
+ * shared definition both under-limits Pro and lets invalid Flash values through.
+ *
+ * Only the ceiling varies here. The documented floors (128 / 0 / 512) are the
+ * supported thinking ranges, but -1 is the "decide automatically" sentinel, so
+ * raising the minimum would clamp auto away.
+ */
+const GOOGLE_THINKING_BUDGET_PRO_MAX = 32768 as const;
+const GOOGLE_THINKING_BUDGET_FLASH_MAX = 24576 as const;
+
+export const getGoogleThinkingBudgetMax = (modelName: string): number | undefined => {
+  if (!/gemini-2\.5/i.test(modelName)) {
+    return undefined;
+  }
+  if (/flash/i.test(modelName)) {
+    return GOOGLE_THINKING_BUDGET_FLASH_MAX;
+  }
+  if (/pro/i.test(modelName)) {
+    return GOOGLE_THINKING_BUDGET_PRO_MAX;
+  }
+  return undefined;
+};
+
 export const googleSettings = {
   model: {
     default: 'gemini-1.5-flash-latest' as const,