Skip to content

Commit e404398

Browse files
committed
fix(gui): keep Claude sidecar Auto as a selectable draft
Empty Auto was collapsing to Inherit before a model could be entered. Keep Auto in memory with an enabled model input, and only persist { backend: null, model } when the trimmed model is non-empty.
1 parent b2f76a2 commit e404398

5 files changed

Lines changed: 282 additions & 36 deletions

File tree

‎gui/src/pages/ClaudeCode.tsx‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ import {
1111
ClaudeCodeQuickstartSection,
1212
ClaudeCodeSettingsCard,
1313
} from "./claude-code-sections";
14+
import { serializeSidecarOverride } from "./claude-code-sidecar";
1415
import { formatCompactWindow, type ClaudeCodeState, type MapRow } from "./claude-code-types";
1516
import { SmallFastModelSetting } from "./claude-code-settings";
1617

@@ -102,12 +103,8 @@ export default function ClaudeCode({ apiBase }: { apiBase: string }) {
102103
injectAgents: state.injectAgents,
103104
smallFastModel: state.smallFastModel,
104105
modelMap,
105-
webSearchSidecar: state.webSearchSidecar
106-
? { backend: state.webSearchSidecar.backend ?? null, model: state.webSearchSidecar.model ?? "" }
107-
: null,
108-
visionSidecar: state.visionSidecar
109-
? { backend: state.visionSidecar.backend ?? null, model: state.visionSidecar.model ?? "" }
110-
: null,
106+
webSearchSidecar: serializeSidecarOverride(state.webSearchSidecar),
107+
visionSidecar: serializeSidecarOverride(state.visionSidecar),
111108
}),
112109
});
113110
await readJsonOrThrow(r, t("claude.saveFailed"));

‎gui/src/pages/claude-code-sections.tsx‎

Lines changed: 14 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,12 @@ import { IconPlus, IconX } from "../icons";
22
import { useT } from "../i18n/shared";
33
import { Trans } from "../i18n/provider";
44
import { Select } from "../ui";
5-
import type { SidecarBackend } from "./claude-manual-env";
5+
import {
6+
applySidecarBackendChange,
7+
applySidecarModelChange,
8+
sidecarSelectValue,
9+
type SidecarSelectValue,
10+
} from "./claude-code-sidecar";
611
import { AutoConnectSetting, SettingToggle } from "./claude-code-settings";
712
import type { ClaudeCodeState, MapRow } from "./claude-code-types";
813

@@ -119,36 +124,19 @@ export function ClaudeCodeSettingsCard({
119124
</div>
120125
<div className="setting-controls" style={{ display: "flex", gap: 8 }}>
121126
<Select
122-
value={
123-
!override || (!override.backend && !(override.model?.trim()))
124-
? "inherit"
125-
: override.backend ?? "auto"
126-
}
127+
value={sidecarSelectValue(override)}
127128
options={[
128129
{ value: "inherit", label: t("claude.useMainSetting") },
129130
{ value: "auto", label: t("dash.backendAuto") },
130131
{ value: "openai", label: t("dash.backendOpenAI") },
131132
{ value: "anthropic", label: t("dash.backendAnthropic") },
132133
]}
133134
onChange={value => {
134-
// Empty Auto ({ backend: undefined, model: "" }) is deleted by the
135-
// management API and reloads as inherit — don't offer a distinct
136-
// non-persistable Auto state.
137-
if (value === "inherit") {
138-
onStateChange({ ...state, [key]: undefined });
139-
return;
140-
}
141-
if (value === "auto") {
142-
const model = override?.model?.trim();
143-
onStateChange({
144-
...state,
145-
[key]: model ? { model: override!.model, backend: undefined } : undefined,
146-
});
147-
return;
148-
}
135+
// Auto may exist as an empty in-memory draft so the model input
136+
// stays enabled; empty Auto serializes to null on save.
149137
onStateChange({
150138
...state,
151-
[key]: { ...override, backend: value as SidecarBackend },
139+
[key]: applySidecarBackendChange(override, value as SidecarSelectValue),
152140
});
153141
}}
154142
label={t("dash.sidecarBackend")}
@@ -158,14 +146,10 @@ export function ClaudeCodeSettingsCard({
158146
className="input mono"
159147
value={override?.model ?? ""}
160148
onChange={e => {
161-
const model = e.target.value;
162-
// Clearing the only field of an Auto override collapses to inherit
163-
// (same persist semantics as an empty sidecar object).
164-
if (!model.trim() && !override?.backend) {
165-
onStateChange({ ...state, [key]: undefined });
166-
return;
167-
}
168-
onStateChange({ ...state, [key]: { ...override, model } });
149+
onStateChange({
150+
...state,
151+
[key]: applySidecarModelChange(override, e.target.value),
152+
});
169153
}}
170154
placeholder={t("claude.sidecarModelPlaceholder")}
171155
disabled={!override}
Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
/**
2+
* Claude Code sidecar override helpers — keep Auto as an in-memory draft so
3+
* users can enter a model before persist, and only serialize Auto when a
4+
* trimmed model is present.
5+
*/
6+
7+
import type { SidecarBackend, SidecarOverride } from "./claude-manual-env";
8+
9+
export type SidecarSelectValue = "inherit" | "auto" | SidecarBackend;
10+
11+
export type PersistedSidecarOverride = {
12+
backend: SidecarBackend | null;
13+
model: string;
14+
};
15+
16+
/** Select value: any in-memory override without a backend is Auto (including empty drafts). */
17+
export function sidecarSelectValue(override?: SidecarOverride): SidecarSelectValue {
18+
if (!override) return "inherit";
19+
return override.backend ?? "auto";
20+
}
21+
22+
/** Backend select changes. Inherit clears; Auto/OpenAI/Anthropic preserve model. */
23+
export function applySidecarBackendChange(
24+
override: SidecarOverride | undefined,
25+
value: SidecarSelectValue,
26+
): SidecarOverride | undefined {
27+
if (value === "inherit") return undefined;
28+
if (value === "auto") return { ...override, backend: undefined };
29+
return { ...override, backend: value };
30+
}
31+
32+
/** Model typing updates the draft in place; empty Auto stays selectable until save. */
33+
export function applySidecarModelChange(
34+
override: SidecarOverride | undefined,
35+
model: string,
36+
): SidecarOverride {
37+
return { ...override, model };
38+
}
39+
40+
/**
41+
* Persist shape for PUT /api/claude-code.
42+
* Empty Auto drafts ({ backend: undefined } / blank model) become null → reload as Inherit.
43+
*/
44+
export function serializeSidecarOverride(
45+
override?: SidecarOverride,
46+
): PersistedSidecarOverride | null {
47+
if (!override) return null;
48+
const trimmed = (override.model ?? "").trim();
49+
if (!override.backend) {
50+
if (!trimmed) return null;
51+
return { backend: null, model: trimmed };
52+
}
53+
return { backend: override.backend, model: override.model ?? "" };
54+
}
Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,148 @@
1+
import { afterEach, beforeEach, expect, test } from "bun:test";
2+
import { Window } from "happy-dom";
3+
import { act, useState } from "react";
4+
import type { Root } from "react-dom/client";
5+
import { LanguageProvider } from "../src/i18n/provider";
6+
import { ClaudeCodeSettingsCard } from "../src/pages/claude-code-sections";
7+
import type { ClaudeCodeState } from "../src/pages/claude-code-types";
8+
9+
const globals = ["document", "window", "navigator", "localStorage", "IS_REACT_ACT_ENVIRONMENT"] as const;
10+
let previousGlobals: Record<(typeof globals)[number], unknown>;
11+
let testWindow: Window;
12+
13+
beforeEach(() => {
14+
previousGlobals = Object.fromEntries(globals.map(key => [key, Reflect.get(globalThis, key)])) as typeof previousGlobals;
15+
testWindow = new Window({ url: "http://localhost/" });
16+
Object.defineProperty(testWindow.navigator, "language", { configurable: true, value: "en-US" });
17+
Object.defineProperties(globalThis, {
18+
document: { configurable: true, value: testWindow.document },
19+
window: { configurable: true, value: testWindow },
20+
navigator: { configurable: true, value: testWindow.navigator },
21+
localStorage: { configurable: true, value: testWindow.localStorage },
22+
});
23+
(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
24+
});
25+
26+
afterEach(() => {
27+
testWindow.close();
28+
for (const key of globals) {
29+
Object.defineProperty(globalThis, key, { configurable: true, value: previousGlobals[key] });
30+
}
31+
});
32+
33+
const BASE_STATE: ClaudeCodeState = {
34+
enabled: true,
35+
authMode: "proxy",
36+
autoConnectSupported: false,
37+
systemEnv: false,
38+
fastMode: null,
39+
maxContextTokens: null,
40+
autoContext: true,
41+
autoCompactWindow: null,
42+
injectAgents: true,
43+
smallFastModel: "",
44+
effectiveModelEnv: {},
45+
available: [],
46+
aliases: [],
47+
port: 10100,
48+
};
49+
50+
async function mountSettings(
51+
initial: ClaudeCodeState = BASE_STATE,
52+
): Promise<{ root: Root; host: HTMLDivElement; getState: () => ClaudeCodeState }> {
53+
const host = document.createElement("div");
54+
document.body.append(host);
55+
let latest = initial;
56+
function Harness() {
57+
const [state, setState] = useState(initial);
58+
latest = state;
59+
return (
60+
<LanguageProvider>
61+
<ClaudeCodeSettingsCard
62+
state={state}
63+
autoCompactOptions={[{ value: "", label: "Default" }]}
64+
onStateChange={setState}
65+
/>
66+
</LanguageProvider>
67+
);
68+
}
69+
const { createRoot } = await import("react-dom/client");
70+
let root!: Root;
71+
await act(async () => {
72+
root = createRoot(host);
73+
root.render(<Harness />);
74+
});
75+
return { root, host, getState: () => latest };
76+
}
77+
78+
function sidecarModelInputs(host: HTMLElement): HTMLInputElement[] {
79+
return [...host.querySelectorAll<HTMLInputElement>('input[aria-label="Model"]')];
80+
}
81+
82+
function sidecarBackendTriggers(host: HTMLElement): HTMLButtonElement[] {
83+
return [...host.querySelectorAll<HTMLButtonElement>('button.select-trigger[aria-label="Backend"]')];
84+
}
85+
86+
async function pickOption(trigger: HTMLButtonElement, label: string): Promise<void> {
87+
await act(async () => {
88+
trigger.click();
89+
});
90+
const option = [...document.body.querySelectorAll<HTMLElement>('[role="option"]')]
91+
.find(el => el.textContent?.includes(label));
92+
expect(option).toBeTruthy();
93+
await act(async () => {
94+
option!.click();
95+
});
96+
}
97+
98+
test("Inherit → Auto stays Auto and enables the sidecar model input", async () => {
99+
const { root, host, getState } = await mountSettings();
100+
const [webSearchTrigger] = sidecarBackendTriggers(host);
101+
const [webSearchModel] = sidecarModelInputs(host);
102+
expect(webSearchTrigger).toBeTruthy();
103+
expect(webSearchModel.disabled).toBe(true);
104+
expect(getState().webSearchSidecar).toBeUndefined();
105+
106+
await pickOption(webSearchTrigger!, "Auto");
107+
108+
expect(getState().webSearchSidecar).toEqual({ backend: undefined });
109+
expect(sidecarSelectLabel(host, 0)).toContain("Auto");
110+
expect(sidecarModelInputs(host)[0]!.disabled).toBe(false);
111+
112+
await act(async () => { root.unmount(); });
113+
});
114+
115+
test("Empty Auto draft keeps model input enabled until Inherit is chosen", async () => {
116+
const { root, host, getState } = await mountSettings();
117+
const [webSearchTrigger] = sidecarBackendTriggers(host);
118+
await pickOption(webSearchTrigger!, "Auto");
119+
120+
const model = sidecarModelInputs(host)[0]!;
121+
await act(async () => {
122+
Object.getOwnPropertyDescriptor(testWindow.HTMLInputElement.prototype, "value")!
123+
.set!.call(model, "gpt-4o");
124+
model.dispatchEvent(new testWindow.Event("input", { bubbles: true }));
125+
});
126+
expect(getState().webSearchSidecar).toEqual({ backend: undefined, model: "gpt-4o" });
127+
128+
await act(async () => {
129+
Object.getOwnPropertyDescriptor(testWindow.HTMLInputElement.prototype, "value")!
130+
.set!.call(model, "");
131+
model.dispatchEvent(new testWindow.Event("input", { bubbles: true }));
132+
});
133+
134+
// Clearing the model must not collapse Auto back to Inherit.
135+
expect(getState().webSearchSidecar).toEqual({ backend: undefined, model: "" });
136+
expect(model.disabled).toBe(false);
137+
expect(sidecarSelectLabel(host, 0)).toContain("Auto");
138+
139+
await pickOption(sidecarBackendTriggers(host)[0]!, "Use main setting");
140+
expect(getState().webSearchSidecar).toBeUndefined();
141+
expect(sidecarModelInputs(host)[0]!.disabled).toBe(true);
142+
143+
await act(async () => { root.unmount(); });
144+
});
145+
146+
function sidecarSelectLabel(host: HTMLElement, index: number): string {
147+
return sidecarBackendTriggers(host)[index]?.textContent ?? "";
148+
}
Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
import { expect, test } from "bun:test";
2+
import {
3+
applySidecarBackendChange,
4+
applySidecarModelChange,
5+
serializeSidecarOverride,
6+
sidecarSelectValue,
7+
} from "../src/pages/claude-code-sidecar";
8+
9+
test("Inherit → Auto remains Auto (empty draft) and keeps a selectable override", () => {
10+
const draft = applySidecarBackendChange(undefined, "auto");
11+
expect(draft).toEqual({ backend: undefined });
12+
expect(sidecarSelectValue(draft)).toBe("auto");
13+
// Model input is enabled whenever an override object exists.
14+
expect(draft).toBeTruthy();
15+
});
16+
17+
test("Entering a model under Auto survives serialize (save payload)", () => {
18+
let override = applySidecarBackendChange(undefined, "auto");
19+
override = applySidecarModelChange(override, " gpt-4o-mini ");
20+
expect(sidecarSelectValue(override)).toBe("auto");
21+
expect(serializeSidecarOverride(override)).toEqual({
22+
backend: null,
23+
model: "gpt-4o-mini",
24+
});
25+
});
26+
27+
test("Empty Auto serializes as null (reloads as Inherit)", () => {
28+
expect(serializeSidecarOverride({ backend: undefined })).toBeNull();
29+
expect(serializeSidecarOverride({ backend: undefined, model: "" })).toBeNull();
30+
expect(serializeSidecarOverride({ backend: undefined, model: " " })).toBeNull();
31+
expect(serializeSidecarOverride({})).toBeNull();
32+
});
33+
34+
test("Switching back to Inherit clears the override", () => {
35+
const withModel = applySidecarModelChange(
36+
applySidecarBackendChange(undefined, "auto"),
37+
"gpt-4o",
38+
);
39+
expect(applySidecarBackendChange(withModel, "inherit")).toBeUndefined();
40+
expect(sidecarSelectValue(undefined)).toBe("inherit");
41+
expect(serializeSidecarOverride(undefined)).toBeNull();
42+
});
43+
44+
test("Switching Auto ↔ OpenAI ↔ Anthropic preserves the model", () => {
45+
let override = applySidecarModelChange(
46+
applySidecarBackendChange(undefined, "auto"),
47+
"claude-sonnet-4",
48+
);
49+
override = applySidecarBackendChange(override, "openai")!;
50+
expect(override).toEqual({ backend: "openai", model: "claude-sonnet-4" });
51+
override = applySidecarBackendChange(override, "anthropic")!;
52+
expect(override).toEqual({ backend: "anthropic", model: "claude-sonnet-4" });
53+
override = applySidecarBackendChange(override, "auto")!;
54+
expect(override).toEqual({ backend: undefined, model: "claude-sonnet-4" });
55+
expect(sidecarSelectValue(override)).toBe("auto");
56+
});
57+
58+
test("Explicit backends serialize even with an empty model", () => {
59+
expect(serializeSidecarOverride({ backend: "openai", model: "" })).toEqual({
60+
backend: "openai",
61+
model: "",
62+
});
63+
});

0 commit comments

Comments
 (0)