pi-llama-cpp 0.11.0 → 0.12.0

package/tests/settings.test.ts

@@ -7,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";
 
@@ -35,10 +36,12 @@ 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);
@@ -66,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]);
   });
@@ -77,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"]);
   });
@@ -85,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"]);
   });
@@ -95,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"]);
   });
@@ -105,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"]);
   });
@@ -113,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"]);
   });
@@ -121,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"]);
@@ -131,7 +134,7 @@ 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"]);
   });
@@ -139,7 +142,7 @@ describe("URL resolution fallback chain", () => {
   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 = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual([LLAMA_SERVER_URL]);
     expect(settings.takeWarnings()).toEqual([
@@ -155,7 +158,7 @@ describe("URL resolution fallback chain", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://good:8080"]);
     expect(settings.takeWarnings()).toEqual([
@@ -196,7 +199,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual([
       "http://project-server:8080",
@@ -216,7 +219,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://project:8080"]);
   });
@@ -228,7 +231,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://global:8080"]);
   });
@@ -241,7 +244,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://env:8080"]);
   });
@@ -253,7 +256,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://server:9090"]);
   });
@@ -266,7 +269,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://server:9090"]);
   });
@@ -279,7 +282,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://legacy:8080"]);
   });
@@ -291,7 +294,7 @@ describe("llamaSettings.servers resolution", () => {
       },
     });
 
-    const result = settings.resolveUrls();
+    const result = await settings.resolveUrls();
 
     expect(result).toEqual(["http://localhost:8080"]);
   });
@@ -438,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);
   });
@@ -446,7 +449,7 @@ 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);
   });
@@ -454,7 +457,7 @@ describe("reactToModelSelect and autoloadOnMessage fallbacks", () => {
   it("should return 'asc' when sortBy is not set", async () => {
     const { settings } = await import("../src/managers/settings");
 
-    const result = settings.resolveSortBy();
+    const result = await settings.resolveSortBy();
 
     expect(result).toBe("asc");
   });
@@ -469,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);
   });
 });
 
@@ -495,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: [
@@ -504,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");
@@ -514,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: [
@@ -536,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");
@@ -544,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" }],
@@ -552,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");
@@ -569,7 +572,7 @@ describe("resolveServers", () => {
       },
     });
 
-    const result = settings.resolveServers();
+    const result = await settings.resolveServers();
 
     // env variable takes precedence via resolveUrls
     expect(result).toHaveLength(1);
@@ -585,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,
@@ -602,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);
@@ -617,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);
@@ -633,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,
@@ -697,12 +700,20 @@ describe("setLlamaSetting", () => {
   const mockReadFile = vi.mocked(readFile);
   const mockWriteFile = vi.mocked(writeFile);
   const mockRename = vi.mocked(rename);
+  const mockAccess = vi.mocked(access);
 
-  const SETTINGS_PATH = "/fake/agent/dir/settings.json";
+  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);
@@ -711,7 +722,72 @@ describe("setLlamaSetting", () => {
     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 } },
@@ -720,11 +796,12 @@ describe("setLlamaSetting", () => {
       ),
     );
 
+    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(`${SETTINGS_PATH}.tmp`);
+    expect(tmpPath).toBe(`${GLOBAL_SETTINGS_PATH}.tmp`);
     expect(encoding).toBe("utf-8");
     const parsed = JSON.parse(written as string);
     expect(parsed).toEqual({
@@ -732,12 +809,16 @@ describe("setLlamaSetting", () => {
       llamaSettings: { reactToModelSelect: true, sortBy: "desc" },
     });
     expect(mockRename).toHaveBeenCalledWith(
-      `${SETTINGS_PATH}.tmp`,
-      SETTINGS_PATH,
+      `${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({
@@ -745,14 +826,17 @@ describe("setLlamaSetting", () => {
       });
     });
 
+    const { settings } = await import("../src/managers/settings");
     await settings.setLlamaSetting("sortBy", "desc");
 
-    expect(settings.resolveSortBy()).toBe("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",
     );
@@ -760,8 +844,10 @@ describe("setLlamaSetting", () => {
   });
 
   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/,
     );
@@ -770,6 +856,8 @@ describe("setLlamaSetting", () => {
   });
 
   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];
@@ -791,3 +879,361 @@ describe("setLlamaSetting", () => {
     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,
+    });
+  });
+});