pi-llama-cpp 0.10.0 → 0.12.0

package/tests/settings.test.ts

@@ -1,3 +1,4 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   API_KEY_PLACEHOLDER,
@@ -6,6 +7,7 @@ import {
   PROVIDER_PREFIX,
   SERVER_TIMEOUT,
 } from "../src/constants";
+import type { ModelOverride } from "../src/interfaces/settings";
 import { settings } from "../src/managers/settings";
 import { Server } from "../src/server";
 
@@ -17,6 +19,7 @@ const mockSettingsManager = vi.hoisted(() => ({
   getGlobalSettings: vi.fn(),
   getDefaultThinkingLevel: vi.fn(),
   getThinkingBudgets: vi.fn(),
+  reload: vi.fn(),
 }));
 
 // Mock getAgentDir, readStoredCredential, and SettingsManager before importing resolver
@@ -31,10 +34,14 @@ vi.mock("@earendil-works/pi-coding-agent", () => ({
 
 vi.mock("node:fs/promises", () => ({
   readFile: vi.fn(),
+  writeFile: vi.fn(),
+  rename: vi.fn(),
+  access: vi.fn(),
 }));
 
 // Import mocked modules
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { access } from "node:fs/promises";
 
 describe("URL resolution fallback chain", () => {
   const mockGetAgentDir = vi.mocked(getAgentDir);
@@ -62,7 +69,7 @@ describe("URL resolution fallback chain", () => {
     // Ensure env var is not set (and not inherited from environment)
     delete process.env.LLAMA_SERVER_URL;
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual([LLAMA_SERVER_URL]);
   });
@@ -73,7 +80,7 @@ describe("URL resolution fallback chain", () => {
     });
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://env-url:8080"]);
   });
@@ -81,7 +88,7 @@ describe("URL resolution fallback chain", () => {
   it("should use env variable when no other config exists", async () => {
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://env-url:8080"]);
   });
@@ -91,7 +98,7 @@ describe("URL resolution fallback chain", () => {
       llamaServerUrl: "http://project:9999",
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://project:9999"]);
   });
@@ -101,7 +108,7 @@ describe("URL resolution fallback chain", () => {
       llamaServerUrl: "http://global:8080",
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://global:8080"]);
   });
@@ -109,7 +116,7 @@ describe("URL resolution fallback chain", () => {
   it("should strip trailing slashes from resolved URL", async () => {
     process.env.LLAMA_SERVER_URL = "http://localhost:8080/";
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://localhost:8080"]);
   });
@@ -117,8 +124,8 @@ describe("URL resolution fallback chain", () => {
   it("should cache the resolved URL on subsequent calls", async () => {
     process.env.LLAMA_SERVER_URL = "http://first:8080";
 
-    const result1 = settings.resolveUrls();
-    const result2 = settings.resolveUrls();
+    const result1 = await settings.resolveUrls();
+    const result2 = await settings.resolveUrls();
 
     expect(result1).toEqual(["http://first:8080"]);
     expect(result2).toEqual(["http://first:8080"]);
@@ -127,10 +134,38 @@ describe("URL resolution fallback chain", () => {
   it("should handle multiple URLs separated by semicolons", async () => {
     process.env.LLAMA_SERVER_URL = "http://first:8080;http://second:9090/";
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://first:8080", "http://second:9090"]);
   });
+
+  it("should drop env URLs without an http(s) scheme, warn, and fall through", async () => {
+    process.env.LLAMA_SERVER_URL = "127.0.0.1:8080";
+
+    const result = await settings.resolveUrls();
+
+    expect(result).toEqual([LLAMA_SERVER_URL]);
+    expect(settings.takeWarnings()).toEqual([
+      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
+    ]);
+    expect(settings.takeWarnings()).toEqual([]); // drained
+  });
+
+  it("should drop server entries without an http(s) scheme and warn", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [{ url: "127.0.0.1:8080" }, { url: "http://good:8080/" }],
+      },
+    });
+
+    const result = await settings.resolveUrls();
+
+    expect(result).toEqual(["http://good:8080"]);
+    expect(settings.takeWarnings()).toEqual([
+      "Ignoring invalid server URL '127.0.0.1:8080' (needs http(s)://)",
+    ]);
+    expect(settings.takeWarnings()).toEqual([]); // drained
+  });
 });
 
 describe("llamaSettings.servers resolution", () => {
@@ -164,7 +199,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual([
       "http://project-server:8080",
@@ -184,7 +219,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://project:8080"]);
   });
@@ -196,7 +231,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://global:8080"]);
   });
@@ -209,7 +244,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://env:8080"]);
   });
@@ -221,7 +256,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://server:9090"]);
   });
@@ -234,7 +269,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://server:9090"]);
   });
@@ -247,7 +282,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://legacy:8080"]);
   });
@@ -259,7 +294,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://localhost:8080"]);
   });
@@ -315,13 +350,16 @@ describe("API key resolution", () => {
 
 describe("Server with custom id", () => {
   it("should use custom id as providerId when provided", () => {
-    const server = new Server("http://127.0.0.1:8080", "my-custom-id");
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+    });
 
     expect(server.providerId).toEqual("my-custom-id");
   });
 
   it("should fall back to URL-based providerId when no custom id", () => {
-    const server = new Server("http://127.0.0.1:8080");
+    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
 
     expect(server.providerId).toEqual(
       `${PROVIDER_PREFIX}=http://127.0.0.1:8080`,
@@ -329,14 +367,19 @@ describe("Server with custom id", () => {
   });
 
   it("should try custom id first in getApiKey(), then fall back to URL-based", () => {
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+    });
+
+    // Server construction resolves the key eagerly (ApiClient built there);
+    // clear so the assertions below observe only the explicit getApiKey() call
     vi.clearAllMocks();
     // Mock: custom id returns placeholder (no key found)
     mockReadStoredCredential
       .mockReturnValueOnce(API_KEY_PLACEHOLDER)
       .mockReturnValueOnce({ key: "fallback-key" });
 
-    const server = new Server("http://127.0.0.1:8080", "my-custom-id");
-
     const result = server.getApiKey();
 
     expect(result).toEqual("fallback-key");
@@ -350,7 +393,10 @@ describe("Server with custom id", () => {
   it("should return custom id key directly when found", () => {
     mockReadStoredCredential.mockReturnValue({ key: "custom-key" });
 
-    const server = new Server("http://127.0.0.1:8080", "my-custom-id");
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+    });
 
     const result = server.getApiKey();
 
@@ -361,27 +407,26 @@ describe("Server with custom id", () => {
 
 describe("Server with custom name", () => {
   it("should use custom name as suffix in providerName", () => {
-    const server = new Server(
-      "http://127.0.0.1:8080",
-      undefined,
-      "Remote Server",
-    );
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customName: "Remote Server",
+    });
 
     expect(server.providerName).toEqual(`Llama.cpp (Remote Server)`);
   });
 
   it("should fall back to URL-based name when no custom name", () => {
-    const server = new Server("http://127.0.0.1:8080");
+    const server = new Server(settings, { baseUrl: "http://127.0.0.1:8080" });
 
     expect(server.providerName).toEqual(`Llama.cpp (http://127.0.0.1:8080)`);
   });
 
   it("should use custom name even with custom id", () => {
-    const server = new Server(
-      "http://127.0.0.1:8080",
-      "my-custom-id",
-      "Remote Server",
-    );
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      customId: "my-custom-id",
+      customName: "Remote Server",
+    });
 
     expect(server.providerId).toEqual("my-custom-id");
     expect(server.providerName).toEqual(`Llama.cpp (Remote Server)`);
@@ -396,7 +441,7 @@ describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
   it("should return true when reactToModelSelect is not set", async () => {
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveReactToModelSelect();
+    const result = await settings.resolveReactToModelSelect();
 
     expect(result).toBe(true);
   });
@@ -404,11 +449,19 @@ describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
   it("should return false when autoloadOnMessage is not set", async () => {
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveAutoloadOnMessage();
+    const result = await settings.resolveAutoloadOnMessage();
 
     expect(result).toBe(false);
   });
 
+  it("should return 'asc' when sortBy is not set", async () => {
+    const { settings } = await import("../src/managers/settings");
+
+    const result = await settings.resolveSortBy();
+
+    expect(result).toBe("asc");
+  });
+
   it("should return user values when set", async () => {
     mockSettingsManager.getProjectSettings.mockReturnValue({
       llamaSettings: {
@@ -419,8 +472,8 @@ describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
 
     const { settings } = await import("../src/managers/settings");
 
-    expect(settings.resolveReactToModelSelect()).toBe(false);
-    expect(settings.resolveAutoloadOnMessage()).toBe(true);
+    expect(await settings.resolveReactToModelSelect()).toBe(false);
+    expect(await settings.resolveAutoloadOnMessage()).toBe(true);
   });
 });
 
@@ -445,7 +498,7 @@ describe("resolveServers", () => {
     mockGetGlobalSettings.mockReturnValue({});
   });
 
-  it("should use llamaSettings.servers when configured", () => {
+  it("should use llamaSettings.servers when configured", async () => {
     mockGetProjectSettings.mockReturnValue({
       llamaSettings: {
         servers: [
@@ -454,7 +507,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = settings.resolveServers();
+    const result = await settings.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe("http://custom:8080");
@@ -464,20 +517,20 @@ describe("resolveServers", () => {
   it("should fall back to resolveUrls when servers is empty", async () => {
     process.env.LLAMA_SERVER_URL = "http://env-server:9090";
 
-    const result = settings.resolveServers();
+    const result = await settings.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe("http://env-server:9090");
   });
 
-  it("should fall back to default URL when no config exists", () => {
-    const result = settings.resolveServers();
+  it("should fall back to default URL when no config exists", async () => {
+    const result = await settings.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe(LLAMA_SERVER_URL);
   });
 
-  it("should apply id/name from llamaSettings.servers as overrides", () => {
+  it("should apply id/name from llamaSettings.servers as overrides", async () => {
     mockGetProjectSettings.mockReturnValue({
       llamaSettings: {
         servers: [
@@ -486,7 +539,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = settings.resolveServers();
+    const result = await settings.resolveServers();
 
     expect(result).toHaveLength(1);
     expect(result[0].baseUrl).toBe("http://127.0.0.1:8080");
@@ -494,7 +547,7 @@ describe("resolveServers", () => {
     expect(result[0].providerName).toBe(`Llama.cpp (Custom)`);
   });
 
-  it("should handle multiple URLs with partial id/name overrides", () => {
+  it("should handle multiple URLs with partial id/name overrides", async () => {
     mockGetProjectSettings.mockReturnValue({
       llamaSettings: {
         servers: [{ url: "http://first:8080", id: "first-server" }],
@@ -502,7 +555,7 @@ describe("resolveServers", () => {
     });
     process.env.LLAMA_SERVER_URL = "http://first:8080;http://second:9090";
 
-    const result = settings.resolveServers();
+    const result = await settings.resolveServers();
 
     expect(result).toHaveLength(2);
     expect(result[0].baseUrl).toBe("http://first:8080");
@@ -519,7 +572,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = settings.resolveServers();
+    const result = await settings.resolveServers();
 
     // env variable takes precedence via resolveUrls
     expect(result).toHaveLength(1);
@@ -535,7 +588,7 @@ describe("resolveTimeouts", () => {
   it("should return default timeouts when not configured", async () => {
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveTimeouts();
+    const result = await settings.resolveTimeouts();
 
     expect(result).toEqual({
       pollingTimeout: POLLING_TIMEOUT,
@@ -552,7 +605,7 @@ describe("resolveTimeouts", () => {
 
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveTimeouts();
+    const result = await settings.resolveTimeouts();
 
     expect(result.pollingTimeout).toBe(120000);
     expect(result.serverTimeout).toBe(SERVER_TIMEOUT);
@@ -567,7 +620,7 @@ describe("resolveTimeouts", () => {
 
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveTimeouts();
+    const result = await settings.resolveTimeouts();
 
     expect(result.pollingTimeout).toBe(POLLING_TIMEOUT);
     expect(result.serverTimeout).toBe(3000);
@@ -583,7 +636,7 @@ describe("resolveTimeouts", () => {
 
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveTimeouts();
+    const result = await settings.resolveTimeouts();
 
     expect(result).toEqual({
       pollingTimeout: 90000,
@@ -634,3 +687,553 @@ describe("Thinking config resolution", () => {
     );
   });
 });
+
+describe("setLlamaSetting", () => {
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
+  const mockReload = vi.mocked(mockSettingsManager.reload);
+  const mockReadFile = vi.mocked(readFile);
+  const mockWriteFile = vi.mocked(writeFile);
+  const mockRename = vi.mocked(rename);
+  const mockAccess = vi.mocked(access);
+
+  const GLOBAL_SETTINGS_PATH = "/fake/agent/dir/settings.json";
+  const PROJECT_SETTINGS_PATH = "/fake/project/.pi/settings.json";
+  const FAKE_CWD = "/fake/project";
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    vi.spyOn(process, "cwd").mockReturnValue(FAKE_CWD);
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
+    mockReload.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue("{}");
+    mockWriteFile.mockResolvedValue(undefined);
+    mockRename.mockResolvedValue(undefined);
+  });
+
+  it("should write to project settings when .pi/settings.json exists (auto scope)", async () => {
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue("{}");
+
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("sortBy", "desc");
+
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      `${PROJECT_SETTINGS_PATH}.tmp`,
+      expect.any(String),
+      "utf-8",
+    );
+    expect(mockRename).toHaveBeenCalledWith(
+      `${PROJECT_SETTINGS_PATH}.tmp`,
+      PROJECT_SETTINGS_PATH,
+    );
+  });
+
+  it("should write to global settings when .pi/settings.json does not exist (auto scope)", async () => {
+    mockAccess.mockRejectedValue(new Error("ENOENT"));
+    mockReadFile.mockResolvedValue("{}");
+
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("sortBy", "desc");
+
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      `${GLOBAL_SETTINGS_PATH}.tmp`,
+      expect.any(String),
+      "utf-8",
+    );
+    expect(mockRename).toHaveBeenCalledWith(
+      `${GLOBAL_SETTINGS_PATH}.tmp`,
+      GLOBAL_SETTINGS_PATH,
+    );
+  });
+
+  it("should always write to global when scope is explicitly 'global'", async () => {
+    mockAccess.mockResolvedValue(undefined); // project exists but we override
+    mockReadFile.mockResolvedValue("{}");
+
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("sortBy", "desc", "global");
+
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      `${GLOBAL_SETTINGS_PATH}.tmp`,
+      expect.any(String),
+      "utf-8",
+    );
+  });
+
+  it("should always write to project when scope is explicitly 'project'", async () => {
+    mockAccess.mockRejectedValue(new Error("ENOENT")); // project doesn't exist but we override
+    mockReadFile.mockResolvedValue("{}");
+
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("sortBy", "desc", "project");
+
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      `${PROJECT_SETTINGS_PATH}.tmp`,
+      expect.any(String),
+      "utf-8",
+    );
+  });
+
+  it("should write the merged llamaSettings key atomically and reload", async () => {
+    mockAccess.mockRejectedValue(new Error("ENOENT")); // no project settings
+    mockReadFile.mockResolvedValue(
+      JSON.stringify(
+        { unrelated: true, llamaSettings: { reactToModelSelect: true } },
+        null,
+        2,
+      ),
+    );
+
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("sortBy", "desc");
+
+    expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    const [tmpPath, written, encoding] = mockWriteFile.mock.calls[0];
+    expect(tmpPath).toBe(`${GLOBAL_SETTINGS_PATH}.tmp`);
+    expect(encoding).toBe("utf-8");
+    const parsed = JSON.parse(written as string);
+    expect(parsed).toEqual({
+      unrelated: true,
+      llamaSettings: { reactToModelSelect: true, sortBy: "desc" },
+    });
+    expect(mockRename).toHaveBeenCalledWith(
+      `${GLOBAL_SETTINGS_PATH}.tmp`,
+      GLOBAL_SETTINGS_PATH,
+    );
+    expect(mockReload).toHaveBeenCalledTimes(1);
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it("should reflect the new value in resolvers immediately after the write", async () => {
+    mockSettingsManager.reload.mockImplementation(async () => {
+      mockGetGlobalSettings.mockReturnValue({
+        llamaSettings: { sortBy: "desc" },
+      });
+    });
+
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("sortBy", "desc");
+
+    expect(await settings.resolveSortBy()).toBe("desc");
+  });
+
+  it("should reject and skip reload when the write fails", async () => {
+    mockAccess.mockRejectedValue(new Error("ENOENT"));
+    mockWriteFile.mockRejectedValue(new Error("ENOSPC: simulated"));
+
+    const { settings } = await import("../src/managers/settings");
+    await expect(settings.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
+      "ENOSPC",
+    );
+    expect(mockReload).not.toHaveBeenCalled();
+  });
+
+  it("should reject and leave the file untouched when the JSON is invalid", async () => {
+    mockAccess.mockRejectedValue(new Error("ENOENT"));
+    mockReadFile.mockResolvedValue("{ broken");
+
+    const { settings } = await import("../src/managers/settings");
+    await expect(settings.setLlamaSetting("sortBy", "desc")).rejects.toThrow(
+      /Cannot parse/,
+    );
+    expect(mockWriteFile).not.toHaveBeenCalled();
+    expect(mockReload).not.toHaveBeenCalled();
+  });
+
+  it("should persist booleans and numbers with type fidelity", async () => {
+    mockAccess.mockRejectedValue(new Error("ENOENT"));
+    const { settings } = await import("../src/managers/settings");
+    await settings.setLlamaSetting("reactToModelSelect", false);
+
+    const [, firstWrite] = mockWriteFile.mock.calls[0];
+    expect(JSON.parse(firstWrite as string)).toEqual({
+      llamaSettings: { reactToModelSelect: false },
+    });
+
+    await settings.setLlamaSetting("pollingTimeout", 120000);
+
+    const [, secondWrite] = mockWriteFile.mock.calls[1];
+    expect(JSON.parse(secondWrite as string)).toEqual({
+      llamaSettings: { pollingTimeout: 120000 },
+    });
+  });
+
+  it("should still construct the manager without arguments", async () => {
+    const { LlamaSettingsManager } = await import("../src/managers/settings");
+
+    expect(() => new LlamaSettingsManager()).not.toThrow();
+  });
+});
+
+describe("resolveServerOverrides", () => {
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
+  });
+
+  it("should return overrides for a server that has them configured", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [
+          {
+            url: "http://127.0.0.1:8080",
+            overrides: {
+              "llama-3-8b": { cost: { input: 0.2, output: 0.6 } },
+              "llama-3-70b": {
+                cost: {
+                  input: 0.1,
+                  output: 0.3,
+                  cacheRead: 0.01,
+                  cacheWrite: 0.02,
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await settings.resolveServerOverrides(
+      "http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual({
+      "llama-3-8b": { cost: { input: 0.2, output: 0.6 } },
+      "llama-3-70b": {
+        cost: {
+          input: 0.1,
+          output: 0.3,
+          cacheRead: 0.01,
+          cacheWrite: 0.02,
+        },
+      },
+    });
+  });
+
+  it("should return empty object for a server without overrides", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [{ url: "http://127.0.0.1:8080" }],
+      },
+    });
+
+    const result = await settings.resolveServerOverrides(
+      "http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual({});
+  });
+
+  it("should return empty object when server URL is not in config", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [{ url: "http://127.0.0.1:9090" }],
+      },
+    });
+
+    const result = await settings.resolveServerOverrides(
+      "http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual({});
+  });
+
+  it("should use global settings when no project config exists", async () => {
+    mockGetGlobalSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [
+          {
+            url: "http://global:8080",
+            overrides: { "model-a": { cost: { input: 0.5 } } },
+          },
+        ],
+      },
+    });
+
+    const result = await settings.resolveServerOverrides("http://global:8080");
+
+    expect(result).toEqual({ "model-a": { cost: { input: 0.5 } } });
+  });
+
+  it("should prioritize project overrides over global overrides", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [
+          {
+            url: "http://shared:8080",
+            overrides: { "model-b": { cost: { input: 0.1, output: 0.2 } } },
+          },
+        ],
+      },
+    });
+    mockGetGlobalSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [
+          {
+            url: "http://shared:8080",
+            overrides: { "model-b": { cost: { input: 0.5, output: 0.5 } } },
+          },
+        ],
+      },
+    });
+
+    const result = await settings.resolveServerOverrides("http://shared:8080");
+
+    expect(result).toEqual({
+      "model-b": { cost: { input: 0.1, output: 0.2 } },
+    });
+  });
+
+  it("should return empty object when servers list is empty", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: { servers: [] },
+    });
+
+    const result = await settings.resolveServerOverrides(
+      "http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual({});
+  });
+
+  it("should return empty object when llamaSettings is missing", async () => {
+    mockGetProjectSettings.mockReturnValue({});
+
+    const result = await settings.resolveServerOverrides(
+      "http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual({});
+  });
+
+  it("should support partial override objects", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [
+          {
+            url: "http://127.0.0.1:8080",
+            overrides: { "partial-model": { cost: { input: 0.1 } } },
+          },
+        ],
+      },
+    });
+
+    const result = await settings.resolveServerOverrides(
+      "http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual({ "partial-model": { cost: { input: 0.1 } } });
+  });
+});
+
+describe("Server with overrides", () => {
+  it("should store and expose resolved overrides", () => {
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+      overrides: {
+        "model-a": { cost: { input: 0.2, output: 0.6 } },
+        "model-b": { cost: { input: 0.1, output: 0.3, cacheRead: 0.01 } },
+      },
+    });
+
+    expect(server.getOverrides()).toEqual({
+      "model-a": { cost: { input: 0.2, output: 0.6 } },
+      "model-b": { cost: { input: 0.1, output: 0.3, cacheRead: 0.01 } },
+    });
+  });
+
+  it("should return empty object when no overrides are provided", () => {
+    const server = new Server(settings, {
+      baseUrl: "http://127.0.0.1:8080",
+    });
+
+    expect(server.getOverrides()).toEqual({});
+  });
+});
+
+describe("resolveServers passes overrides", () => {
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
+  });
+
+  it("should pass resolved overrides to Server instances", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaSettings: {
+        servers: [
+          {
+            url: "http://overrides-server:8080",
+            overrides: { "model-x": { cost: { input: 0.5, output: 1.0 } } },
+          },
+          {
+            url: "http://no-overrides-server:9090",
+          },
+        ],
+      },
+    });
+
+    const result = await settings.resolveServers();
+
+    expect(result).toHaveLength(2);
+    expect(result[0].getOverrides()).toEqual({
+      "model-x": { cost: { input: 0.5, output: 1.0 } },
+    });
+    expect(result[1].getOverrides()).toEqual({});
+  });
+});
+
+describe("Server.findOverrideForModel", () => {
+  function createServer(overrides: Record<string, ModelOverride>): Server {
+    return new Server(settings as any, {
+      baseUrl: "http://127.0.0.1:8080",
+      overrides,
+    });
+  }
+
+  it("should return undefined when overrides is empty", () => {
+    const server = createServer({});
+    expect(server.findOverrideForModel("llama-3-8b")).toBeUndefined();
+  });
+
+  it("should return undefined when no key matches", () => {
+    const server = createServer({
+      mistral: { cost: { input: 0.1 } },
+      "gpt-4": { cost: { input: 0.3 } },
+    });
+    expect(server.findOverrideForModel("llama-3-8b")).toBeUndefined();
+  });
+
+  it("should match exact ID", () => {
+    const server = createServer({
+      "llama-3-8b": { cost: { input: 0.2, output: 0.6 } },
+    });
+    expect(server.findOverrideForModel("llama-3-8b")).toEqual({
+      cost: { input: 0.2, output: 0.6 },
+    });
+  });
+
+  it("should match prefix", () => {
+    const server = createServer({
+      llama: { cost: { input: 0.01, output: 0.02 } },
+    });
+    expect(server.findOverrideForModel("llama-3-8b")).toEqual({
+      cost: { input: 0.01, output: 0.02 },
+    });
+  });
+
+  it("should prefer longest match (most specific)", () => {
+    const server = createServer({
+      llama: { cost: { input: 0.01, output: 0.02 } },
+      "llama-3": { cost: { input: 0.05, output: 0.1 } },
+      "llama-3-8b": { cost: { input: 0.2, output: 0.6 } },
+    });
+    expect(server.findOverrideForModel("llama-3-8b")).toEqual({
+      cost: { input: 0.2, output: 0.6 },
+    });
+  });
+
+  it("should match the second-longest when exact match is absent", () => {
+    const server = createServer({
+      llama: { cost: { input: 0.01, output: 0.02 } },
+      "llama-3": { cost: { input: 0.05, output: 0.1 } },
+      "llama-3-8b": { cost: { input: 0.2, output: 0.6 } },
+    });
+    expect(server.findOverrideForModel("llama-3-70b")).toEqual({
+      cost: { input: 0.05, output: 0.1 },
+    });
+  });
+
+  it("should skip empty keys", () => {
+    const server = createServer({
+      "": { cost: { input: 0.001 } },
+      llama: { cost: { input: 0.01 } },
+    });
+    expect(server.findOverrideForModel("llama-3-8b")).toEqual({
+      cost: { input: 0.01 },
+    });
+  });
+
+  it("should not match when model ID is shorter than key", () => {
+    const server = createServer({
+      "llama-3-8b": { cost: { input: 0.2 } },
+    });
+    expect(server.findOverrideForModel("llama")).toBeUndefined();
+  });
+
+  it("should handle single matching key", () => {
+    const server = createServer({
+      qwen: { cost: { input: 0.1, output: 0.3 } },
+    });
+    expect(server.findOverrideForModel("qwen-3-8b")).toEqual({
+      cost: { input: 0.1, output: 0.3 },
+    });
+  });
+
+  it("should handle overlapping but non-prefix matches", () => {
+    const server = createServer({
+      model: { cost: { input: 0.1 } },
+      "model-a": { cost: { input: 0.2 } },
+    });
+    // "model" matches "model-a" and "model-b"
+    // "model-a" matches only "model-a"
+    expect(server.findOverrideForModel("model-a")).toEqual({
+      cost: { input: 0.2 },
+    });
+    expect(server.findOverrideForModel("model-b")).toEqual({
+      cost: { input: 0.1 },
+    });
+  });
+
+  it("should return overrides with capabilities and reasoning", () => {
+    const server = createServer({
+      qwen: { capabilities: ["text", "image"], reasoning: false },
+    });
+    expect(server.findOverrideForModel("qwen-3-8b")).toEqual({
+      capabilities: ["text", "image"],
+      reasoning: false,
+    });
+  });
+});