From af598fd6252804b08f6f33df7612ec5c621e50a8 Mon Sep 17 00:00:00 2001
From: Mike Tuev R9FT <ra9ftm@gmail.com>
Date: Wed, 23 Sep 2026 22:33:19 +0500
Subject: [PATCH] fix(dashboard): let the web-search route model be cleared
 again
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`settings.webSearchRouteModel` (layer 2 of #4481) reroutes EVERY request carrying
a native web_search tool to the configured model
(`webSearchRouting.ts::resolveWebSearchRouteOverride`), and its own help text says
"leave blank to disable". The dashboard field, however, rendered
`ModelSelectField` without `allowEmpty`, so the underlying `<Select>` marked its
placeholder `disabled` (`placeholderDisabled={!allowEmpty}`). Once any model had
been selected, the blank value was unreachable from the UI — the override stayed
pinned forever and every web_search request silently left the operator's
configured provider (observed live: `WEBSEARCH-ROUTE web_search tool -> model
override: claude-opus-5-5 -> cx/gpt-6-astra`). The only way out was editing the
settings row in SQLite by hand.

Pass `allowEmpty` so the blank option is selectable, plus `allowCustomInput` so an
unlisted/self-hosted target can be typed and blanked — matching how the Modality
Bridge pickers already use the same component.

The API side already accepted the empty value: `settingsSchemas.ts` types it as
`z.string().max(200).optional()` and the paid-model guard in
`src/app/api/settings/route.ts` only runs for a non-empty string.
---
 .../settings/components/RoutingTab.tsx        |  11 ++
 .../web-search-route-model-clearable.test.tsx | 112 ++++++++++++++++++
 2 files changed, 123 insertions(+)
 create mode 100644 tests/unit/ui/web-search-route-model-clearable.test.tsx

diff --git a/src/app/(dashboard)/dashboard/settings/components/RoutingTab.tsx b/src/app/(dashboard)/dashboard/settings/components/RoutingTab.tsx
index f23b36ff5d72..9f64d885bb3c 100644
--- a/src/app/(dashboard)/dashboard/settings/components/RoutingTab.tsx
+++ b/src/app/(dashboard)/dashboard/settings/components/RoutingTab.tsx
@@ -1501,6 +1501,17 @@ export default function RoutingTab() {
                 value={String(settings.webSearchRouteModel ?? "")}
                 onChange={(v) => updateSetting({ webSearchRouteModel: v })}
                 placeholder={t("webSearchRoutePlaceholder")}
+                // The setting is documented as "leave blank to disable", but without
+                // `allowEmpty` the <Select> renders its placeholder as `disabled`
+                // (ModelSelectField -> Select `placeholderDisabled={!allowEmpty}`), so
+                // once a model was picked the override could never be cleared from the
+                // dashboard again — every web_search request stayed pinned to it
+                // (webSearchRouting.ts resolveWebSearchRouteOverride). `allowCustomInput`
+                // additionally exposes the free-text field so an unlisted/self-hosted
+                // target can be typed and blanked, matching the Modality Bridge pickers.
+                allowEmpty
+                allowCustomInput
+                testId="web-search-route-model"
                 disabled={loading}
                 ariaLabel={t("webSearchRouteTitle")}
               />
diff --git a/tests/unit/ui/web-search-route-model-clearable.test.tsx b/tests/unit/ui/web-search-route-model-clearable.test.tsx
new file mode 100644
index 000000000000..cd478614b3cd
--- /dev/null
+++ b/tests/unit/ui/web-search-route-model-clearable.test.tsx
@@ -0,0 +1,112 @@
+// @vitest-environment jsdom
+/**
+ * The Web-Search Routing setting (`settings.webSearchRouteModel`, layer 2 of #4481)
+ * is documented as "leave blank to disable": when it holds a model, EVERY request
+ * carrying a native web_search tool is rerouted to that model
+ * (open-sse/services/webSearchRouting.ts -> resolveWebSearchRouteOverride).
+ *
+ * The dashboard field rendered a <ModelSelectField> without `allowEmpty`, which makes
+ * the <Select> placeholder `disabled` (`placeholderDisabled={!allowEmpty}`). Once a
+ * model had been selected there was no way back to the blank value from the UI — the
+ * override stayed pinned forever and every web_search request silently left the
+ * operator's configured provider. Clearing it required editing the settings row in
+ * SQLite by hand.
+ *
+ * Guards both halves: the picker must actually offer a blank option, and the settings
+ * tab must keep passing `allowEmpty`.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import ModelSelectField from "@/shared/components/ModelSelectField";
+
+vi.mock("next-intl", () => ({
+  useTranslations: () => {
+    const t = (key: string) => key;
+    return t;
+  },
+}));
+
+const REPO_ROOT = path.resolve(__dirname, "../../..");
+const ROUTING_TAB = path.join(
+  REPO_ROOT,
+  "src/app/(dashboard)/dashboard/settings/components/RoutingTab.tsx"
+);
+
+function mockModels(models: string[]) {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        models: models.map((full) => ({ fullModel: full })),
+      }),
+    }))
+  );
+}
+
+describe("web-search route model is clearable", () => {
+  beforeEach(() => {
+    mockModels(["cx/gpt-6-astra", "claude/claude-opus-5-5"]);
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+  });
+
+  it("offers a selectable blank option when allowEmpty is set", async () => {
+    const onChange = vi.fn();
+    render(
+      <ModelSelectField
+        value="cx/gpt-6-astra"
+        onChange={onChange}
+        placeholder="webSearchRoutePlaceholder"
+        allowEmpty
+        ariaLabel="webSearchRouteTitle"
+      />
+    );
+
+    const select = (await screen.findByLabelText("webSearchRouteTitle")) as HTMLSelectElement;
+    const placeholderOption = Array.from(select.options).find((option) => option.value === "");
+
+    expect(placeholderOption, "the picker must render a blank option").toBeTruthy();
+    expect(
+      placeholderOption?.disabled,
+      "the blank option must be selectable — otherwise the override can never be disabled"
+    ).toBe(false);
+
+    fireEvent.change(select, { target: { value: "" } });
+    expect(onChange).toHaveBeenCalledWith("");
+  });
+
+  it("keeps the blank option disabled without allowEmpty (documents the old behavior)", async () => {
+    render(
+      <ModelSelectField
+        value="cx/gpt-6-astra"
+        onChange={() => {}}
+        placeholder="webSearchRoutePlaceholder"
+        ariaLabel="webSearchRouteTitle"
+      />
+    );
+
+    const select = (await screen.findByLabelText("webSearchRouteTitle")) as HTMLSelectElement;
+    const placeholderOption = Array.from(select.options).find((option) => option.value === "");
+    expect(placeholderOption?.disabled).toBe(true);
+  });
+
+  it("RoutingTab passes allowEmpty to the webSearchRouteModel picker", () => {
+    const source = readFileSync(ROUTING_TAB, "utf8");
+    const fieldStart = source.indexOf("settings.webSearchRouteModel");
+    expect(fieldStart, "webSearchRouteModel field not found in RoutingTab").toBeGreaterThan(-1);
+
+    const fieldEnd = source.indexOf("/>", fieldStart);
+    const fieldSource = source.slice(fieldStart, fieldEnd);
+
+    expect(
+      /\ballowEmpty\b/.test(fieldSource),
+      "the webSearchRouteModel picker must pass allowEmpty so the override can be cleared"
+    ).toBe(true);
+  });
+});