pi-llama-cpp 0.11.0 → 0.12.0

package/tests/commandManager.test.ts

@@ -1,4 +1,5 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
+import { initTheme } from "@earendil-works/pi-coding-agent";
 import type { KeybindingsManager, TUI } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { Action } from "../src/enums/action";
@@ -10,8 +11,7 @@ import {
 } from "../src/managers/command";
 import { ServerManager } from "../src/managers/server";
 import type { LlamaSettingsManager } from "../src/managers/settings";
-import type { Server } from "../src/server";
-import { ServerListEditor } from "../src/ui/serverListEditor";
+import { ServerSettingsList } from "../src/ui/serverSettingsList";
 import {
   createMockCtx,
   createMockModel,
@@ -22,6 +22,7 @@ import {
 } from "./mocks";
 
 beforeEach(() => {
+  initTheme();
   vi.clearAllMocks();
   mockRpc.mockResolvedValue({ data: [] });
 });
@@ -42,12 +43,13 @@ describe("CommandManager", () => {
   describe("getArgumentCompletions", () => {
     it("should provide completions for /models", () => {
       const completions = commandManager.getArgumentCompletions("");
-      expect(completions).toHaveLength(4);
+      expect(completions).toHaveLength(5);
       expect(completions?.map((c) => c.value)).toEqual([
         "info",
         "unload",
-        "servers",
         "settings",
+        "servers",
+        "overrides",
       ]);
     });
 
@@ -64,7 +66,7 @@ describe("CommandManager", () => {
 
     it("should provide the server/settings completions by prefix", () => {
       const completions = commandManager.getArgumentCompletions("s");
-      expect(completions?.map((c) => c.value)).toEqual(["servers", "settings"]);
+      expect(completions?.map((c) => c.value)).toEqual(["settings", "servers"]);
     });
   });
 
@@ -77,7 +79,7 @@ describe("CommandManager", () => {
         models: [model1, model2],
       });
       const unloadSettings = makeSettingsStub({
-        resolveServers: vi.fn((): Server[] => [server]),
+        resolveServers: vi.fn(async () => [server]),
       });
       serverManager = new ServerManager(unloadSettings);
       commandManager = new CommandManager(serverManager, unloadSettings);
@@ -107,7 +109,7 @@ describe("CommandManager", () => {
         models: [model1, model2],
       });
       const infoSettings = makeSettingsStub({
-        resolveServers: vi.fn((): Server[] => [server]),
+        resolveServers: vi.fn(async () => [server]),
       });
       serverManager = new ServerManager(infoSettings);
       commandManager = new CommandManager(serverManager, infoSettings);
@@ -133,8 +135,8 @@ describe("CommandManager", () => {
       expect(formatMs(1500)).toBe("1500ms");
     });
 
-    it("should build one item per editable scalar field", () => {
-      const items = buildSettingsItems(settingsStub);
+    it("should build one item per editable scalar field", async () => {
+      const items = await buildSettingsItems(settingsStub);
       expect(items.map((i) => i.id)).toEqual([
         "reactToModelSelect",
         "autoloadOnMessage",
@@ -220,7 +222,9 @@ describe("CommandManager", () => {
         matches: vi.fn(
           (data: string, name: string) =>
             (data === ENTER && name === "tui.select.confirm") ||
-            (data === ESC && name === "tui.select.cancel"),
+            (data === ESC && name === "tui.select.cancel") ||
+            (data === "\x1b[A" && name === "tui.select.up") ||
+            (data === "\x1b[B" && name === "tui.select.down"),
         ),
       }) as unknown as KeybindingsManager;
 
@@ -256,7 +260,7 @@ describe("CommandManager", () => {
 
     it("should wire the editor to the merged servers and the write path", async () => {
       const editorSettings = makeSettingsStub({
-        llamaServers: [{ url: "http://seed:1" }],
+        getLlamaServers: vi.fn(async () => [{ url: "http://seed:1" }]),
       });
       commandManager = new CommandManager(serverManager, editorSettings);
       const ctx = createMockCtx(() => null);
@@ -269,7 +273,7 @@ describe("CommandManager", () => {
         theme: Theme,
         kb: KeybindingsManager,
         done: (result: undefined) => void,
-      ) => ServerListEditor;
+      ) => ServerSettingsList;
       const done = vi.fn();
       const editor = factory(
         { requestRender: vi.fn() } as unknown as TUI,
@@ -284,14 +288,20 @@ describe("CommandManager", () => {
         done,
       );
 
-      expect(editor).toBeInstanceOf(ServerListEditor);
+      expect(editor).toBeInstanceOf(ServerSettingsList);
       // Seeded with the merged snapshot
       expect(editor.render(80).join("\n")).toContain("http://seed:1");
 
-      // Add a server through the editor → setLlamaSetting("servers", …)
+      // Add a server through the wizard (URL → ID → name) →
+      // setLlamaSetting("servers", …) persists only after the final step
       editor.handleInput("a");
+      expect(editor.render(80).join("\n")).toContain("Add server · 1/3");
       for (const ch of "http://new:2") editor.handleInput(ch);
       editor.handleInput(ENTER);
+      expect(editor.render(80).join("\n")).toContain("Add server · 2/3");
+      editor.handleInput(ENTER); // skip optional ID
+      expect(editor.render(80).join("\n")).toContain("Add server · 3/3");
+      editor.handleInput(ENTER); // skip optional name → persist
       await new Promise((resolve) => setTimeout(resolve, 0));
       expect(editorSettings.setLlamaSetting).toHaveBeenCalledWith("servers", [
         { url: "http://seed:1" },
@@ -302,6 +312,86 @@ describe("CommandManager", () => {
       editor.handleInput(ESC);
       expect(done).toHaveBeenCalledTimes(1);
     });
+
+    it("should persist nothing when the add wizard is cancelled", async () => {
+      const editorSettings = makeSettingsStub({
+        getLlamaServers: vi.fn(async () => [{ url: "http://seed:1" }]),
+      });
+      commandManager = new CommandManager(serverManager, editorSettings);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("servers", ctx as any, mockPi as any);
+
+      const factory = vi.mocked(ctx.ui.custom).mock.calls[0][0] as (
+        tui: TUI,
+        theme: Theme,
+        kb: KeybindingsManager,
+        done: (result: undefined) => void,
+      ) => ServerSettingsList;
+      const editor = factory(
+        { requestRender: vi.fn() } as unknown as TUI,
+        createMockTheme(),
+        createMockKeybindings(),
+        vi.fn(),
+      );
+
+      // Walk to wizard step 2, then abort — nothing must be persisted
+      editor.handleInput("a");
+      for (const ch of "http://new:2") editor.handleInput(ch);
+      editor.handleInput(ENTER);
+      editor.handleInput(ESC);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(editorSettings.setLlamaSetting).not.toHaveBeenCalled();
+      // Back to the list view
+      expect(editor.render(80).join("\n")).toContain("http://seed:1");
+    });
+
+    it("should delete the selected server after confirming", async () => {
+      const editorSettings = makeSettingsStub({
+        getLlamaServers: vi.fn(async () => [
+          { url: "http://seed:1" },
+          { url: "http://doomed:2" },
+        ]),
+      });
+      commandManager = new CommandManager(serverManager, editorSettings);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("servers", ctx as any, mockPi as any);
+
+      const factory = vi.mocked(ctx.ui.custom).mock.calls[0][0] as (
+        tui: TUI,
+        theme: Theme,
+        kb: KeybindingsManager,
+        done: (result: undefined) => void,
+      ) => ServerSettingsList;
+      const editor = factory(
+        { requestRender: vi.fn() } as unknown as TUI,
+        createMockTheme(),
+        createMockKeybindings(),
+        vi.fn(),
+      );
+
+      // Move to the second row and open the confirm dialog
+      editor.handleInput("\x1b[B");
+      editor.handleInput("d");
+      expect(editor.render(80).join("\n")).toContain(
+        'Delete "http://doomed:2"?',
+      );
+
+      // Esc keeps the server
+      editor.handleInput(ESC);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(editorSettings.setLlamaSetting).not.toHaveBeenCalled();
+
+      // Re-open and confirm the default "Delete" selection
+      editor.handleInput("d");
+      editor.handleInput(ENTER);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(editorSettings.setLlamaSetting).toHaveBeenCalledWith("servers", [
+        { url: "http://seed:1" },
+      ]);
+    });
   });
 
   describe("/models interactive menu", () => {
@@ -321,7 +411,7 @@ describe("CommandManager", () => {
         }),
       );
       const settingsStub = makeSettingsStub({
-        resolveServers: vi.fn((): Server[] => servers),
+        resolveServers: vi.fn(async () => servers),
       });
       const serverManager = new ServerManager(settingsStub);
       return {
@@ -432,7 +522,7 @@ describe("CommandManager", () => {
         baseUrl: "http://127.0.0.1:8081",
         models: [modelB],
       });
-      vi.mocked(settingsStub.resolveServers).mockReturnValue([
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([
         ...servers,
         serverB,
       ]);

package/tests/dialog.test.ts

@@ -0,0 +1,186 @@
+import { initTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+  getKeybindings,
+  type KeybindingsManager,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ConfirmDialog, InputDialog } from "../src/ui/dialog";
+import { ServerSettingsList } from "../src/ui/serverSettingsList";
+
+beforeEach(() => {
+  initTheme();
+  vi.clearAllMocks();
+});
+
+const ESC = "\x1b";
+const ENTER = "\r";
+
+const createMockTheme = (): Theme =>
+  ({
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  }) as unknown as Theme;
+
+const createMockTui = (): TUI => ({ requestRender: vi.fn() }) as unknown as TUI;
+
+const createKeybindings = (): KeybindingsManager => getKeybindings();
+
+describe("InputDialog", () => {
+  const build = (
+    overrides: Partial<ConstructorParameters<typeof InputDialog>[0]> = {},
+  ) => {
+    const onSubmit = vi.fn();
+    const onCancel = vi.fn();
+    const dialog = new InputDialog({
+      theme: createMockTheme(),
+      tui: createMockTui(),
+      title: "Dialog title",
+      message: "Server URL",
+      placeholder: "http://127.0.0.1:8080",
+      validate: (raw) => (raw.startsWith("http") ? raw : null),
+      onSubmit,
+      onCancel,
+      ...overrides,
+    });
+    return { dialog, onSubmit, onCancel };
+  };
+
+  it("renders the framed title, message, placeholder and key hints", () => {
+    const { dialog } = build();
+    const rendered = dialog.render(60).join("\n");
+    expect(rendered).toContain("Dialog title");
+    expect(rendered).toContain("Server URL");
+    expect(rendered).toContain("e.g., http://127.0.0.1:8080");
+  });
+
+  it("submits the validated value on Enter", () => {
+    const { dialog, onSubmit, onCancel } = build({
+      initialValue: "http://x:1",
+    });
+    dialog.handleInput(ENTER);
+    expect(onSubmit).toHaveBeenCalledWith("http://x:1");
+    expect(onCancel).not.toHaveBeenCalled();
+  });
+
+  it("keeps the dialog open with an error on invalid input", () => {
+    const { dialog, onSubmit, onCancel } = build();
+    for (const ch of "no-scheme") dialog.handleInput(ch);
+    dialog.handleInput(ENTER);
+    expect(onSubmit).not.toHaveBeenCalled();
+    expect(dialog.render(60).join("\n")).toContain('Invalid value "no-scheme"');
+
+    // Esc still cancels after an error
+    dialog.handleInput(ESC);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+  });
+
+  it("cancels on Esc without submitting", () => {
+    const { dialog, onSubmit, onCancel } = build({
+      initialValue: "http://x:1",
+    });
+    dialog.handleInput(ESC);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+});
+
+describe("ConfirmDialog", () => {
+  const build = () => {
+    const onConfirm = vi.fn();
+    const onCancel = vi.fn();
+    const dialog = new ConfirmDialog({
+      theme: createMockTheme(),
+      tui: createMockTui(),
+      title: "Delete server",
+      message: 'Delete "http://x:1"?',
+      onConfirm,
+      onCancel,
+    });
+    return { dialog, onConfirm, onCancel };
+  };
+
+  it("renders the framed message and both options", () => {
+    const { dialog } = build();
+    const rendered = dialog.render(60).join("\n");
+    expect(rendered).toContain("Delete server");
+    expect(rendered).toContain('Delete "http://x:1"?');
+    expect(rendered).toContain("Delete");
+    expect(rendered).toContain("Cancel");
+  });
+
+  it("confirms with Enter on the default selection", () => {
+    const { dialog, onConfirm, onCancel } = build();
+    dialog.handleInput(ENTER);
+    expect(onConfirm).toHaveBeenCalledTimes(1);
+    expect(onCancel).not.toHaveBeenCalled();
+  });
+
+  it("cancels on Esc", () => {
+    const { dialog, onConfirm, onCancel } = build();
+    dialog.handleInput(ESC);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(onConfirm).not.toHaveBeenCalled();
+  });
+});
+
+describe("ServerSettingsList add wizard", () => {
+  const buildEditor = (servers: { url: string; id?: string }[] = []) => {
+    const persist = vi.fn().mockResolvedValue(undefined);
+    const done = vi.fn();
+    const onError = vi.fn();
+    const editor = new ServerSettingsList({
+      tui: createMockTui(),
+      theme: createMockTheme(),
+      keybindings: createKeybindings(),
+      servers: servers as never[],
+      persist,
+      done,
+      onError,
+    });
+    return { editor, persist, done, onError };
+  };
+
+  it("persists only the URL when the optional steps are skipped", async () => {
+    const { editor, persist } = buildEditor();
+
+    editor.handleInput("a");
+    for (const ch of "http://x:1") editor.handleInput(ch);
+    editor.handleInput(ENTER); // URL → ID
+    editor.handleInput(ENTER); // skip ID → name
+    editor.handleInput(ENTER); // skip name → persist
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(persist).toHaveBeenCalledWith([{ url: "http://x:1" }]);
+  });
+
+  it("persists the URL and ID when the ID step is filled", async () => {
+    const { editor, persist } = buildEditor();
+
+    editor.handleInput("a");
+    for (const ch of "http://x:1") editor.handleInput(ch);
+    editor.handleInput(ENTER);
+    for (const ch of "my-id") editor.handleInput(ch);
+    editor.handleInput(ENTER); // ID → name
+    editor.handleInput(ENTER); // skip name → persist
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(persist).toHaveBeenCalledWith([{ url: "http://x:1", id: "my-id" }]);
+  });
+
+  it("rejects an invalid URL at step 1 and aborts cleanly on Esc", async () => {
+    const { editor, persist } = buildEditor();
+
+    editor.handleInput("a");
+    for (const ch of "not-a-url") editor.handleInput(ch);
+    editor.handleInput(ENTER);
+    expect(persist).not.toHaveBeenCalled();
+    expect(editor.render(80).join("\n")).toContain('Invalid value "not-a-url"');
+
+    editor.handleInput(ESC);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(persist).not.toHaveBeenCalled();
+    // Back at the (empty) list view
+    expect(editor.render(80).join("\n")).toContain("(a) add server");
+  });
+});

package/tests/events.test.ts

@@ -299,7 +299,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
 
 describe("EventManager.onModelSelect", () => {
   beforeEach(() => {
-    vi.mocked(settingsStub.resolveReactToModelSelect).mockReturnValue(true);
+    vi.mocked(settingsStub.resolveReactToModelSelect).mockResolvedValue(true);
   });
 
   it("should load the model when reactToModelSelect is true", async () => {
@@ -319,7 +319,7 @@ describe("EventManager.onModelSelect", () => {
   });
 
   it("should return early when reactToModelSelect is false", async () => {
-    vi.mocked(settingsStub.resolveReactToModelSelect).mockReturnValue(false);
+    vi.mocked(settingsStub.resolveReactToModelSelect).mockResolvedValue(false);
 
     const server = createMockServer({
       models: ["model-a"].map((id) => createMockModel(id)),
@@ -339,7 +339,7 @@ describe("EventManager.onModelSelect", () => {
 
 describe("EventManager.autoLoadIfNeeded", () => {
   it("should load the model when autoloadOnMessage is true and model is UNLOADED", async () => {
-    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(true);
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockResolvedValue(true);
 
     const server = createMockServer({
       models: [
@@ -358,7 +358,7 @@ describe("EventManager.autoLoadIfNeeded", () => {
   });
 
   it("should not load the model when autoloadOnMessage is false", async () => {
-    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(false);
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockResolvedValue(false);
 
     const server = createMockServer({
       models: [
@@ -377,7 +377,7 @@ describe("EventManager.autoLoadIfNeeded", () => {
   });
 
   it("should not load the model when model is already LOADED", async () => {
-    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(true);
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockResolvedValue(true);
 
     const server = createMockServer({
       models: [
@@ -396,7 +396,7 @@ describe("EventManager.autoLoadIfNeeded", () => {
   });
 
   it("should not load the model when model is SLEEPING", async () => {
-    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(true);
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockResolvedValue(true);
 
     const server = createMockServer({
       models: [
@@ -427,7 +427,7 @@ describe("EventManager with a live ServerManager", () => {
       ],
     });
 
-    vi.mocked(settingsStub.resolveServers).mockReturnValue([serverA]);
+    vi.mocked(settingsStub.resolveServers).mockResolvedValue([serverA]);
     const serverManager = new ServerManager(settingsStub);
     const mockPi = { registerProvider: vi.fn(), unregisterProvider: vi.fn() };
     await serverManager.update(mockPi as any);
@@ -435,7 +435,10 @@ describe("EventManager with a live ServerManager", () => {
     const eventManager = new EventManager(serverManager, settingsStub);
 
     // Second scan adds serverB — no manager re-construction
-    vi.mocked(settingsStub.resolveServers).mockReturnValue([serverA, serverB]);
+    vi.mocked(settingsStub.resolveServers).mockResolvedValue([
+      serverA,
+      serverB,
+    ]);
     await serverManager.update(mockPi as any);
 
     // onBeforeProviderRequest sees the new server's models
@@ -447,7 +450,7 @@ describe("EventManager with a live ServerManager", () => {
     expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.medium);
 
     // onModelSelect sees the new server's models too
-    vi.mocked(settingsStub.resolveReactToModelSelect).mockReturnValue(true);
+    vi.mocked(settingsStub.resolveReactToModelSelect).mockResolvedValue(true);
     const selectCtx = createMockCtx();
     await eventManager.onModelSelect(
       { model: { provider: serverB.providerId, id: "model-b" } } as any,

package/tests/legacyModel.test.ts

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
 import { Mode } from "../src/enums/mode";
-import { Status } from "../src/enums/status";
 import { DataProperty } from "../src/interfaces/endpoints/models";
 import { LegacyModel } from "../src/models/legacyModel";
 import { createMockServer, mockRpc } from "./mocks";
@@ -47,28 +46,14 @@ describe("LegacyModel capabilities", () => {
 
     expect(capabilities).toEqual(["text"]);
   });
-});
-
-describe("LegacyModel getStatus", () => {
-  it("should return LOADED when not sleeping", async () => {
-    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
-
-    const model = createModel();
-    const status = await model.getStatus();
 
-    expect(status).toBe(Status.LOADED);
-    expect(mockRpc).toHaveBeenCalledWith(
-      `/props?model=${model.id}&autoload=false`,
-    );
-  });
-
-  it("should return SLEEPING when is_sleeping is true", async () => {
-    mockRpc.mockResolvedValueOnce({ is_sleeping: true });
+  it("should fall back to text-only when auth fails", async () => {
+    mockRpc.mockRejectedValue(new Error("401 Unauthorized"));
 
     const model = createModel();
-    const status = await model.getStatus();
+    const capabilities = await model.getCapabilities();
 
-    expect(status).toBe(Status.SLEEPING);
+    expect(capabilities).toEqual(["text"]);
   });
 });
 

package/tests/mocks.ts

@@ -12,7 +12,7 @@ import {
 } from "../src/constants";
 import { Mode } from "../src/enums/mode";
 import { Status } from "../src/enums/status";
-import type { LlamaServer } from "../src/interfaces/settings";
+import type { ModelOverride } from "../src/interfaces/settings";
 import type { LlamaSettingsManager } from "../src/managers/settings";
 import { BaseModel } from "../src/models/baseModel";
 import { Server } from "../src/server";
@@ -32,18 +32,19 @@ export const makeSettingsStub = (
   overrides: Partial<LlamaSettingsManager> = {},
 ): LlamaSettingsManager =>
   ({
-    resolveTimeouts: vi.fn(() => ({
+    getLlamaSettings: vi.fn(async () => ({})),
+    getLlamaServers: vi.fn(async () => []),
+    resolveTimeouts: vi.fn(async () => ({
       pollingTimeout: POLLING_TIMEOUT,
       serverTimeout: SERVER_TIMEOUT,
     })),
-    resolveServers: vi.fn((): Server[] => []),
-    resolveSortBy: vi.fn(() => SORT_BY),
+    resolveServers: vi.fn(async () => []),
+    resolveSortBy: vi.fn(async () => SORT_BY),
     resolveApiKey: vi.fn(() => API_KEY_PLACEHOLDER),
-    resolveReactToModelSelect: vi.fn(() => REACT_TO_MODEL_SELECT),
-    resolveAutoloadOnMessage: vi.fn(() => AUTOLOAD_ON_MESSAGE),
+    resolveReactToModelSelect: vi.fn(async () => REACT_TO_MODEL_SELECT),
+    resolveAutoloadOnMessage: vi.fn(async () => AUTOLOAD_ON_MESSAGE),
     resolveThinkingLevel: vi.fn(() => undefined),
     resolveThinkingBudgets: vi.fn(() => ({ ...THINKING_BUDGETS })),
-    llamaServers: [] as LlamaServer[],
     takeWarnings: vi.fn((): string[] => []),
     setLlamaSetting: vi.fn(() => Promise.resolve()),
     ...overrides,
@@ -102,6 +103,7 @@ export type MockServerOverrides = Partial<
   models?: BaseModel[];
   pollingTimeout?: number;
   serverTimeout?: number;
+  overrides?: Record<string, ModelOverride>;
 };
 
 /**
@@ -124,6 +126,7 @@ export const createMockServer = (
     models,
     pollingTimeout,
     serverTimeout,
+    overrides: modelOverrides,
     initialize,
     ...members
   } = overrides;
@@ -131,7 +134,7 @@ export const createMockServer = (
   const settings = makeSettingsStub({
     ...(apiKey !== undefined && { resolveApiKey: vi.fn(() => apiKey) }),
     ...((pollingTimeout !== undefined || serverTimeout !== undefined) && {
-      resolveTimeouts: vi.fn(() => ({
+      resolveTimeouts: vi.fn(async () => ({
         pollingTimeout: pollingTimeout ?? POLLING_TIMEOUT,
         serverTimeout: serverTimeout ?? SERVER_TIMEOUT,
       })),
@@ -145,6 +148,7 @@ export const createMockServer = (
       baseUrl: baseUrl ?? "http://127.0.0.1:8080",
       customId,
       customName,
+      overrides: modelOverrides,
     },
     {
       createApiClient: () => apiClient,