fix(usage-logs): filter blank model options

biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.4.15/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
   "vcs": {
     "enabled": true,
     "clientKind": "git",

src/app/[locale]/dashboard/logs/_components/filters/request-filters.tsx

@@ -71,6 +71,7 @@ export function RequestFilters({
     () => new Map(providers.map((provider) => [provider.id, provider.name])),
     [providers]
   );
+  const modelOptions = useMemo(() => models.filter((model) => model.trim().length > 0), [models]);
 
   useEffect(() => {
     isMountedRef.current = true;
@@ -256,7 +257,7 @@ export function RequestFilters({
           </SelectTrigger>
           <SelectContent>
             <SelectItem value="all">{t("logs.filters.allModels")}</SelectItem>
-            {models.map((model) => (
+            {modelOptions.map((model) => (
               <SelectItem key={model} value={model}>
                 {model}
               </SelectItem>

src/app/[locale]/dashboard/logs/_hooks/use-lazy-filter-options.ts

@@ -98,8 +98,13 @@ function createLazyFilterHook<T>(
  * 惰性加载 Models 列表
  * 用于 Model 筛选器下拉，展开时才加载数据
  */
-export const useLazyModels: () => UseLazyFilterOptionsReturn<string> =
-  createLazyFilterHook<string>(getModelList);
+export const useLazyModels: () => UseLazyFilterOptionsReturn<string> = createLazyFilterHook<string>(
+  async () => {
+    const result = await getModelList();
+    if (!result.ok) return result;
+    return { ...result, data: result.data.filter(isNonBlankString) };
+  }
+);
 
 /**
  * 惰性加载 StatusCodes 列表
@@ -114,3 +119,7 @@ export const useLazyStatusCodes: () => UseLazyFilterOptionsReturn<number> =
  */
 export const useLazyEndpoints: () => UseLazyFilterOptionsReturn<string> =
   createLazyFilterHook<string>(getEndpointList);
+
+function isNonBlankString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}

src/repository/usage-logs.ts

@@ -1469,10 +1469,20 @@ export async function getUsedModels(): Promise<string[]> {
   const results = await db
     .selectDistinct({ model: messageRequest.model })
     .from(messageRequest)
-    .where(and(isNull(messageRequest.deletedAt), sql`${messageRequest.model} IS NOT NULL`))
+    .where(
+      and(
+        isNull(messageRequest.deletedAt),
+        sql`${messageRequest.model} IS NOT NULL`,
+        sql`btrim(${messageRequest.model}) <> ''`
+      )
+    )
     .orderBy(messageRequest.model);
 
-  return results.map((r) => r.model).filter((m): m is string => m !== null);
+  return results.map((r) => r.model).filter(isNonBlankString);
+}
+
+function isNonBlankString(value: string | null): value is string {
+  return typeof value === "string" && value.trim().length > 0;
 }
 
 /**

tests/unit/dashboard-logs-lazy-filter-options.test.tsx

@@ -0,0 +1,93 @@
+/**
+ * @vitest-environment happy-dom
+ */
+
+import type { ReactNode } from "react";
+import { act, useEffect } from "react";
+import { createRoot } from "react-dom/client";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { useLazyModels } from "@/app/[locale]/dashboard/logs/_hooks/use-lazy-filter-options";
+
+const getModelListMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@/lib/api-client/v1/actions/usage-logs", () => ({
+  getEndpointList: vi.fn(async () => ({ ok: true, data: [] })),
+  getModelList: getModelListMock,
+  getStatusCodeList: vi.fn(async () => ({ ok: true, data: [] })),
+}));
+
+type HookSnapshot = ReturnType<typeof useLazyModels>;
+
+function HookProbe({ onSnapshot }: { onSnapshot: (snapshot: HookSnapshot) => void }) {
+  const snapshot = useLazyModels();
+
+  useEffect(() => {
+    onSnapshot(snapshot);
+  }, [snapshot, onSnapshot]);
+
+  return null;
+}
+
+function renderHookProbe(node: ReactNode) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const root = createRoot(container);
+
+  act(() => {
+    root.render(node);
+  });
+
+  return () => {
+    act(() => root.unmount());
+    container.remove();
+  };
+}
+
+async function waitForLoaded(read: () => HookSnapshot | null): Promise<HookSnapshot> {
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < 1000) {
+    const snapshot = read();
+    if (snapshot?.isLoaded) return snapshot;
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+  }
+
+  throw new Error("Timed out waiting for useLazyModels to load.");
+}
+
+describe("useLazyModels", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    getModelListMock.mockReset();
+  });
+
+  test("drops malformed model options instead of failing the lazy load", async () => {
+    getModelListMock.mockResolvedValue({
+      ok: true,
+      data: ["", null, 42, "   ", "claude-sonnet-4-5"] as unknown as string[],
+    });
+
+    let latest: HookSnapshot | null = null;
+    const unmount = renderHookProbe(
+      <HookProbe
+        onSnapshot={(snapshot) => {
+          latest = snapshot;
+        }}
+      />
+    );
+
+    await act(async () => {
+      latest?.onOpenChange(true);
+    });
+
+    const loaded = await waitForLoaded(() => latest);
+
+    expect(loaded.error).toBeNull();
+    expect(loaded.data).toEqual(["claude-sonnet-4-5"]);
+
+    unmount();
+  });
+});

tests/unit/dashboard-logs-sessionid-suggestions-ui.test.tsx

@@ -5,7 +5,7 @@
 import type { ReactNode } from "react";
 import { act } from "react";
 import { createRoot } from "react-dom/client";
-import { describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
 
 vi.mock("server-only", () => ({}));
 
@@ -39,6 +39,12 @@ const usersActionMocks = vi.hoisted(() => ({
   })),
 }));
 
+const lazyFilterOptionMocks = vi.hoisted(() => ({
+  models: [] as string[],
+  endpoints: [] as string[],
+  statusCodes: [] as number[],
+}));
+
 vi.mock("@/actions/usage-logs", () => ({
   exportUsageLogs: usageLogsActionMocks.exportUsageLogs,
   getUsageLogSessionIdSuggestions: usageLogsActionMocks.getUsageLogSessionIdSuggestions,
@@ -132,7 +138,11 @@ vi.mock("@/components/ui/select", () => ({
   Select: ({ children }: { children?: ReactNode }) => <div>{children}</div>,
   SelectTrigger: ({ children }: { children?: ReactNode }) => <div>{children}</div>,
   SelectContent: ({ children }: { children?: ReactNode }) => <div>{children}</div>,
-  SelectItem: ({ children }: { children?: ReactNode }) => <div>{children}</div>,
+  SelectItem: ({ children, value }: { children?: ReactNode; value: string }) => (
+    <div data-select-item="" data-select-value={value}>
+      {children}
+    </div>
+  ),
   SelectValue: () => <span />,
 }));
 
@@ -160,17 +170,17 @@ vi.mock("@/components/ui/command", () => ({
 // Mock lazy filter hooks
 vi.mock("@/app/[locale]/dashboard/logs/_hooks/use-lazy-filter-options", () => ({
   useLazyModels: () => ({
-    data: [],
+    data: lazyFilterOptionMocks.models,
     isLoading: false,
     onOpenChange: vi.fn(),
   }),
   useLazyEndpoints: () => ({
-    data: [],
+    data: lazyFilterOptionMocks.endpoints,
     isLoading: false,
     onOpenChange: vi.fn(),
   }),
   useLazyStatusCodes: () => ({
-    data: [],
+    data: lazyFilterOptionMocks.statusCodes,
     isLoading: false,
     onOpenChange: vi.fn(),
   }),
@@ -197,7 +207,49 @@ function setReactInputValue(input: HTMLInputElement, value: string) {
   input.dispatchEvent(new Event("change", { bubbles: true }));
 }
 
+beforeEach(() => {
+  lazyFilterOptionMocks.models = [];
+  lazyFilterOptionMocks.endpoints = [];
+  lazyFilterOptionMocks.statusCodes = [];
+});
+
 describe("UsageLogsFilters sessionId suggestions", () => {
+  test("should ignore empty model options before rendering Select items", async () => {
+    vi.clearAllMocks();
+    document.body.innerHTML = "";
+    lazyFilterOptionMocks.models = ["", "   ", "claude-sonnet-4-5", "gpt-4o"];
+
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const root = createRoot(container);
+
+    await act(async () => {
+      root.render(
+        <UsageLogsFilters
+          isAdmin={false}
+          providers={[]}
+          initialKeys={[]}
+          filters={{}}
+          onChange={() => {}}
+          onReset={() => {}}
+        />
+      );
+    });
+
+    const values = Array.from(container.querySelectorAll("[data-select-value]")).map((el) =>
+      el.getAttribute("data-select-value")
+    );
+    expect(values).toContain("claude-sonnet-4-5");
+    expect(values).toContain("gpt-4o");
+    expect(values).not.toContain("");
+    expect(values).not.toContain("   ");
+
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+  });
+
   test("should debounce and require min length (>=2)", async () => {
     vi.useFakeTimers();
     vi.clearAllMocks();

tests/unit/repository/usage-logs-model-filter-options.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test, vi } from "vitest";
+
+function createThenableQuery<T>(result: T) {
+  const query: any = Promise.resolve(result);
+  query.from = vi.fn(() => query);
+  query.where = vi.fn(() => query);
+  query.orderBy = vi.fn(() => query);
+  return query;
+}
+
+describe("usage log model filter options", () => {
+  test("getUsedModels omits empty or blank model names", async () => {
+    vi.resetModules();
+
+    const selectDistinctMock = vi.fn(() =>
+      createThenableQuery([
+        { model: "" },
+        { model: "   " },
+        { model: "claude-sonnet-4-5" },
+        { model: "gpt-4o" },
+        { model: null },
+      ])
+    );
+
+    vi.doMock("@/drizzle/db", () => ({
+      db: { selectDistinct: selectDistinctMock },
+    }));
+
+    const { getUsedModels } = await import("@/repository/usage-logs");
+
+    await expect(getUsedModels()).resolves.toEqual(["claude-sonnet-4-5", "gpt-4o"]);
+  });
+});