pi-llama-cpp 0.14.0 → 0.16.0

package/src/utils/credentialResolver.ts

@@ -0,0 +1,110 @@
+import { execSync } from "node:child_process";
+
+import { API_KEY_PLACEHOLDER } from "../constants";
+
+/**
+ * Resolves credential API keys from `auth.json` entries.
+ *
+ * Supports four formats:
+ * - **Literal** — `"sk-abc123"` used as-is
+ * - **Shell command** — `"!cat ~/.secrets/key"` executes and captures stdout
+ * - **Env ref** — `"$VAR"` or `"${VAR}"` resolved from `credential.env` then `process.env`
+ * - **Escape** — `"$$literal"` → `"$literal"`, `"$!bang"` → `"!bang"`
+ */
+export class CredentialResolver {
+  /**
+   * Resolves a credential key to its actual value.
+   *
+   * @param key - The raw key string from the credential
+   * @param env - Optional env map from `credential.env`. Checked before `process.env`.
+   * @returns The resolved API key value, or the placeholder on failure.
+   */
+  resolve(key: string, env?: Record<string, string>): string {
+    if (!key) return API_KEY_PLACEHOLDER;
+
+    if (key.startsWith("!")) return this.resolveShellCommand(key);
+    if (key.startsWith("$$")) return this.resolveEscape(key);
+    if (key.startsWith("$!")) return this.resolveEscape(key);
+    if (!key.startsWith("$")) return key;
+
+    return this.resolveEnvRef(key, env) ?? API_KEY_PLACEHOLDER;
+  }
+
+  /**
+   * Executes a shell command and returns its trimmed stdout.
+   *
+   * Strips the leading `!` and runs the remainder as a shell command.
+   * On failure (non-zero exit or exception), returns the placeholder.
+   *
+   * @param command - The full key string starting with `!` (e.g. `"!cat ~/.secrets/key"`).
+   * @returns The trimmed stdout, or the API key placeholder on failure.
+   *
+   * @example
+   * ```ts
+   * resolveShellCommand("!echo my-secret")    // → "my-secret"
+   * resolveShellCommand("!cat ~/.key")        // → contents of file
+   * resolveShellCommand("!invalid/cmd")       // → API_KEY_PLACEHOLDER
+   * ```
+   */
+  private resolveShellCommand(command: string): string {
+    try {
+      return (
+        execSync(command.slice(1), {
+          encoding: "utf-8",
+          timeout: 10_000,
+        }).trim() || API_KEY_PLACEHOLDER
+      );
+    } catch {
+      return API_KEY_PLACEHOLDER;
+    }
+  }
+
+  /**
+   * Resolves escape sequences: `$$` → literal `$`, `$!` → literal `!`.
+   *
+   * Replaces the leading escape marker with the literal character and
+   * preserves any remaining text.
+   *
+   * @param key - A key string starting with `$$` or `$!`.
+   * @returns The literal character followed by the rest of the string.
+   *
+   * @example
+   * ```ts
+   * resolveEscape("$$literal")   // → "$literal"
+   * resolveEscape("$!bang")      // → "!bang"
+   * ```
+   */
+  private resolveEscape(key: string): string {
+    return key.charAt(1) + key.slice(2);
+  }
+
+  /**
+   * Resolves `$VAR` or `${VAR}` syntax to the corresponding environment value.
+   *
+   * Matches the entire key against `$VAR` or `${VAR}` patterns. Looks up the
+   * variable first in the provided `env` map, then falls back to `process.env`.
+   *
+   * @param key - The key string containing a `$VAR` or `${VAR}` reference.
+   * @param env - Optional env map (e.g. from `credential.env`). Checked before `process.env`.
+   * @returns The resolved environment value, or `undefined` if the var is not found or the format is invalid.
+   *
+   * @example
+   * ```ts
+   * resolveEnvRef("$API_KEY", { API_KEY: "abc" })     // → "abc"
+   * resolveEnvRef("${API_KEY}", process.env)           // → process.env.API_KEY
+   * resolveEnvRef("$UNSET")                            // → undefined
+   * resolveEnvRef("$invalid-var!")                    // → undefined (invalid name)
+   * ```
+   */
+  private resolveEnvRef(
+    key: string,
+    env?: Record<string, string>,
+  ): string | undefined {
+    const match =
+      key.match(/^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/) ??
+      key.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
+    const varName = match?.[1];
+    if (!varName) return undefined;
+    return env?.[varName] ?? process.env[varName];
+  }
+}

package/src/utils/health.ts

@@ -34,8 +34,8 @@ export const checkServerHealth = async (
       signal: AbortSignal.timeout(timeout),
       headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined,
     });
-    const data = (await response.json()) as { status?: string };
-    return data.status === "ok" ? ServerStatus.READY : ServerStatus.UNREACHABLE;
+
+    return response.ok ? ServerStatus.READY : ServerStatus.UNREACHABLE;
   } catch (error) {
     // `AbortSignal.timeout` rejects `fetch` with a `TimeoutError`
     // DOMException (some runtimes surface it as `AbortError` with a

package/src/utils/urlResolver.ts

@@ -14,7 +14,7 @@ export interface UrlResolverDeps {
 }
 
 /**
- * Multi-source llama-server URL resolution chain (see REFACTOR.md #4).
+ * Multi-source llama-server URL resolution chain
  *
  * Resolves URLs in priority order:
  *

package/tests/{commandManager.test.ts → command/commandManager.test.ts}

@@ -2,17 +2,17 @@ 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";
-import { CommandManager } from "../src/managers/command";
-import { ServerManager } from "../src/managers/server";
-import type { LlamaSettingsManager } from "../src/managers/settings";
-import { ServerSettingsList } from "../src/ui/editors/server/serverEditor";
-import { ServerDisplay } from "../src/ui/editors/server/utils";
+import { Action } from "../../src/enums/action";
+import { CommandManager } from "../../src/managers/command";
+import { ServerManager } from "../../src/managers/server";
+import type { LlamaSettingsManager } from "../../src/managers/settings";
+import { ServerSettingsList } from "../../src/ui/editors/server/serverEditor";
+import { ServerDisplay } from "../../src/ui/editors/server/utils";
 import {
   applySettingChange,
   buildSettingsItems,
   formatMs,
-} from "../src/ui/settings";
+} from "../../src/ui/settings";
 import {
   createMockCtx,
   createMockModel,
@@ -20,14 +20,15 @@ import {
   createMockServer,
   makeSettingsStub,
   mockRpc,
-} from "./mocks";
+} from "../mocks";
 
 beforeEach(() => {
   initTheme();
   vi.clearAllMocks();
   mockRpc.mockResolvedValue({ data: [] });
-  // Mock health checks to return "healthy" immediately
+  // Mock health checks and auth probes to return immediately
   vi.spyOn(ServerDisplay, "healthEmoji").mockResolvedValue("🟢");
+  vi.spyOn(ServerDisplay, "authEmoji").mockResolvedValue("");
 });
 
 /**
@@ -163,6 +164,7 @@ describe("CommandManager", () => {
         "sortBy",
         "pollingTimeout",
         "serverTimeout",
+        "showServerUrls",
       ]);
       // Booleans are displayed as on/off
       expect(items[0].values).toEqual(["on", "off"]);
@@ -203,6 +205,18 @@ describe("CommandManager", () => {
         "serverTimeout",
         500,
       );
+
+      await applySettingChange("showServerUrls", "on", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "showServerUrls",
+        true,
+      );
+
+      await applySettingChange("showServerUrls", "off", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "showServerUrls",
+        false,
+      );
     });
   });
 
@@ -564,5 +578,62 @@ describe("CommandManager", () => {
       expect(choices).toHaveLength(2);
       expect(choices[1]).toContain("model-b");
     });
+
+    it("should omit server URLs when showServerUrls is false", async () => {
+      const models = [createMockModel("model-a")];
+      const mockPi = createMockPi();
+      const servers = models.map((model) =>
+        createMockServer({
+          baseUrl: model.serverUrl,
+          models: [model],
+        }),
+      );
+      const settingsStub = makeSettingsStub({
+        resolveServers: vi.fn(async () => servers),
+        resolveShowServerUrls: vi.fn(async () => false),
+      });
+      const serverManager = new ServerManager(settingsStub);
+      const commandManager = new CommandManager(serverManager, settingsStub);
+
+      const ctx = createMockCtx((prompt, options) => {
+        if (prompt.includes("models")) return options[0];
+        return Action.INFO;
+      });
+
+      await commandManager.handleCommand("", ctx as any, mockPi as any);
+
+      const choices = vi.mocked(ctx.ui.select).mock.calls[0][1] as string[];
+      expect(choices).toHaveLength(1);
+      expect(choices[0]).toBe("model-a  ");
+      expect(choices[0]).not.toContain("[Server:");
+    });
+
+    it("should include server URLs when showServerUrls is true", async () => {
+      const models = [createMockModel("model-a")];
+      const mockPi = createMockPi();
+      const servers = models.map((model) =>
+        createMockServer({
+          baseUrl: model.serverUrl,
+          models: [model],
+        }),
+      );
+      const settingsStub = makeSettingsStub({
+        resolveServers: vi.fn(async () => servers),
+        resolveShowServerUrls: vi.fn(async () => true),
+      });
+      const serverManager = new ServerManager(settingsStub);
+      const commandManager = new CommandManager(serverManager, settingsStub);
+
+      const ctx = createMockCtx((prompt, options) => {
+        if (prompt.includes("models")) return options[0];
+        return Action.INFO;
+      });
+
+      await commandManager.handleCommand("", ctx as any, mockPi as any);
+
+      const choices = vi.mocked(ctx.ui.select).mock.calls[0][1] as string[];
+      expect(choices).toHaveLength(1);
+      expect(choices[0]).toContain("[Server: http://127.0.0.1:8080]");
+    });
   });
 });

package/tests/{events.test.ts → events/events.test.ts}

@@ -1,10 +1,10 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { THINKING_BUDGETS } from "../src/constants";
-import { Status } from "../src/enums/status";
-import { EventManager } from "../src/managers/events";
-import { ServerManager } from "../src/managers/server";
-import type { Server } from "../src/server";
-import { createMockModel, createMockServer, makeSettingsStub } from "./mocks";
+import { THINKING_BUDGETS } from "../../src/constants";
+import { Status } from "../../src/enums/status";
+import { EventManager } from "../../src/managers/events";
+import { ServerManager } from "../../src/managers/server";
+import type { Server } from "../../src/server";
+import { createMockModel, createMockServer, makeSettingsStub } from "../mocks";
 
 /**
  * Injected settings stub (EventManager and — in the live-list test — the

package/tests/mocks.ts

@@ -7,6 +7,7 @@ import {
   POLLING_TIMEOUT,
   REACT_TO_MODEL_SELECT,
   SERVER_TIMEOUT,
+  SHOW_SERVER_URLS,
   SORT_BY,
   THINKING_BUDGETS,
 } from "../src/constants";
@@ -40,6 +41,7 @@ export const makeSettingsStub = (
     })),
     resolveServers: vi.fn(async () => []),
     resolveSortBy: vi.fn(async () => SORT_BY),
+    resolveShowServerUrls: vi.fn(async () => SHOW_SERVER_URLS),
     resolveApiKey: vi.fn(() => API_KEY_PLACEHOLDER),
     resolveReactToModelSelect: vi.fn(async () => REACT_TO_MODEL_SELECT),
     resolveAutoloadOnMessage: vi.fn(async () => AUTOLOAD_ON_MESSAGE),
@@ -66,6 +68,8 @@ export const createFakeClients = (): {
     get: (endpoint: string) => mockRpc(endpoint),
     post: (endpoint: string, body?: Record<string, unknown>) =>
       mockRpc(endpoint, body),
+    rawGet: (endpoint: string) => mockRpc(endpoint),
+    rawPost: (endpoint: string) => mockRpc(endpoint),
     clearCache: vi.fn(),
   } as unknown as ApiClient;
   const sseManager = {

package/tests/{legacyModel.test.ts → models/legacyModel.test.ts}

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { FALLBACK_CTX } from "../src/constants";
-import { Mode } from "../src/enums/mode";
-import { DataProperty } from "../src/interfaces/endpoints/models";
-import { LegacyModel } from "../src/models/legacyModel";
-import { createMockServer, mockRpc } from "./mocks";
+import { FALLBACK_CTX } from "../../src/constants";
+import { Mode } from "../../src/enums/mode";
+import { DataProperty } from "../../src/interfaces/endpoints/models";
+import { LegacyModel } from "../../src/models/legacyModel";
+import { createMockServer, mockRpc } from "../mocks";
 
 beforeEach(() => {
   mockRpc.mockReset();

package/tests/models/llamaSwapModel.test.ts

@@ -0,0 +1,327 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Mode } from "../../src/enums/mode";
+import { Status } from "../../src/enums/status";
+import { LlamaSwapModel } from "../../src/models/llamaSwapModel";
+import { createMockServer, mockRpc } from "../mocks";
+
+beforeEach(() => {
+  mockRpc.mockReset();
+});
+
+const createModel = (
+  extra: Partial<Record<string, unknown>> = {},
+  serverOverrides: Parameters<typeof createMockServer>[0] = {},
+): LlamaSwapModel =>
+  new LlamaSwapModel(
+    {
+      id: "test-model",
+      aliases: ["test-alias"],
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+      ...extra,
+    } as any,
+    createMockServer({ baseUrl: "http://127.0.0.1:8080", ...serverOverrides }),
+  );
+
+describe("LlamaSwapModel mode", () => {
+  it("should always return LLAMASWAP mode", () => {
+    const model = createModel();
+    expect(model.mode).toBe(Mode.LLAMASWAP);
+  });
+});
+
+describe("LlamaSwapModel capabilities", () => {
+  beforeEach(() => {
+    mockRpc.mockReset().mockResolvedValue({
+      data: [
+        {
+          id: "test-model",
+          architecture: {
+            input_modalities: ["text", "image"],
+            output_modalities: ["text"],
+          },
+        },
+      ],
+    });
+  });
+
+  it("should detect image capability when input_modalities includes image", async () => {
+    const model = createModel();
+    const { input } = await model.toProviderConfig();
+
+    expect(input).toEqual(["text", "image"]);
+  });
+
+  it("should detect text-only capability when input_modalities only has text", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          architecture: {
+            input_modalities: ["text"],
+            output_modalities: ["text"],
+          },
+        },
+      ],
+    });
+
+    const model = createModel();
+    const { input } = await model.toProviderConfig();
+
+    expect(input).toEqual(["text"]);
+  });
+
+  it("should return text-only when model is not found in fetchModels response", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "other-model",
+          architecture: {
+            input_modalities: ["text", "image"],
+            output_modalities: ["text"],
+          },
+        },
+      ],
+    });
+
+    const model = createModel();
+    const { input } = await model.toProviderConfig();
+
+    expect(input).toEqual(["text"]);
+  });
+
+  it("should return text-only when architecture is undefined", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+        },
+      ],
+    });
+
+    const model = createModel();
+    const { input } = await model.toProviderConfig();
+
+    expect(input).toEqual(["text"]);
+  });
+});
+
+describe("LlamaSwapModel overrides", () => {
+  it("should use contextSize override when set", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [{ id: "test-model" }],
+    });
+
+    const model = createModel(
+      {},
+      {
+        overrides: { "test-model": { contextSize: 65536 } },
+      },
+    );
+
+    const { contextWindow } = await model.toProviderConfig();
+    expect(contextWindow).toBe(65536);
+  });
+
+  it("should use capabilities override when set", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [{ id: "test-model" }],
+    });
+
+    const model = createModel(
+      {},
+      {
+        overrides: { "test-model": { capabilities: ["text"] } },
+      },
+    );
+
+    const { input } = await model.toProviderConfig();
+    expect(input).toEqual(["text"]);
+  });
+
+  it("should fall through to detection when no override matches", async () => {
+    const model = createModel(
+      {},
+      {
+        overrides: { "other-model": { contextSize: 65536 } },
+      },
+    );
+
+    mockRpc
+      .mockResolvedValueOnce({
+        data: [
+          {
+            id: "test-model",
+            architecture: {
+              input_modalities: ["text", "image"],
+              output_modalities: ["text"],
+            },
+          },
+        ],
+      })
+      .mockResolvedValueOnce({
+        data: [
+          {
+            id: "test-model",
+            architecture: {
+              input_modalities: ["text", "image"],
+              output_modalities: ["text"],
+            },
+          },
+        ],
+      });
+
+    const { input } = await model.toProviderConfig();
+    expect(input).toEqual(["text", "image"]);
+  });
+});
+
+describe("LlamaSwapModel status", () => {
+  it("should return LOADED when status.value is 'loaded'", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: {
+            value: "loaded",
+            args: [],
+            preset: "default",
+            failed: false,
+          },
+        },
+      ],
+    });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.LOADED);
+  });
+
+  it("should return UNLOADED when status.value is 'unloaded'", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: {
+            value: "unloaded",
+            args: [],
+            preset: "default",
+            failed: false,
+          },
+        },
+      ],
+    });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.UNLOADED);
+  });
+
+  it("should return UNLOADED when status.value is something other than 'loaded'", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+          status: {
+            value: "loading",
+            args: [],
+            preset: "default",
+            failed: false,
+          },
+        },
+      ],
+    });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.UNLOADED);
+  });
+
+  it("should return UNLOADED when model is not found in fetchModels response", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "other-model",
+          status: {
+            value: "loaded",
+            args: [],
+            preset: "default",
+            failed: false,
+          },
+        },
+      ],
+    });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.UNLOADED);
+  });
+
+  it("should return UNLOADED when status is undefined", async () => {
+    mockRpc.mockResolvedValueOnce({
+      data: [
+        {
+          id: "test-model",
+        },
+      ],
+    });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.UNLOADED);
+  });
+});
+
+describe("LlamaSwapModel load", () => {
+  it("should call GET to /upstream/{id} when model is not loaded", async () => {
+    const model = createModel();
+    // Override getStatus to return UNLOADED so load proceeds
+    model.getStatus = vi.fn().mockResolvedValue(Status.UNLOADED);
+
+    // mockRpc is used by ApiClient; load -> llamaSwapLoad -> apiClient.get
+    mockRpc.mockResolvedValue({});
+
+    await model.load();
+
+    expect(mockRpc).toHaveBeenCalledWith("/upstream/test-model");
+  });
+
+  it("should throw when the GET request fails", async () => {
+    const model = createModel();
+    model.getStatus = vi.fn().mockResolvedValue(Status.UNLOADED);
+
+    mockRpc.mockRejectedValue(new Error("GET failed"));
+
+    await expect(model.load()).rejects.toThrow(
+      "Model loading failed: test-model",
+    );
+  });
+
+  it("should not call fetch when model is already loaded", async () => {
+    const model = createModel();
+    model.getStatus = vi.fn().mockResolvedValue(Status.LOADED);
+
+    await model.load();
+
+    expect(mockRpc).not.toHaveBeenCalled();
+  });
+});
+
+describe("LlamaSwapModel unload", () => {
+  it("should call POST to /api/models/unload/{id}", async () => {
+    const model = createModel();
+
+    mockRpc.mockResolvedValue({});
+
+    await model.unload();
+
+    expect(mockRpc).toHaveBeenCalledWith("/api/models/unload/test-model");
+  });
+});

package/tests/{routerModel.test.ts → models/routerModel.test.ts}

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { FALLBACK_CTX } from "../src/constants";
-import { Mode } from "../src/enums/mode";
-import { DataProperty } from "../src/interfaces/endpoints/models";
-import { RouterModel } from "../src/models/routerModel";
-import { createMockServer, mockRpc } from "./mocks";
+import { FALLBACK_CTX } from "../../src/constants";
+import { Mode } from "../../src/enums/mode";
+import { DataProperty } from "../../src/interfaces/endpoints/models";
+import { RouterModel } from "../../src/models/routerModel";
+import { createMockServer, mockRpc } from "../mocks";
 
 // Helper to create a mock DataProperty
 const createModel = (overrides: Partial<DataProperty> = {}): DataProperty => ({

package/tests/{singleModel.test.ts → models/singleModel.test.ts}

@@ -1,9 +1,9 @@
 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 { SingleModel } from "../src/models/singleModel";
-import { createMockServer, mockRpc } from "./mocks";
+import { Mode } from "../../src/enums/mode";
+import { Status } from "../../src/enums/status";
+import { DataProperty } from "../../src/interfaces/endpoints/models";
+import { SingleModel } from "../../src/models/singleModel";
+import { createMockServer, mockRpc } from "../mocks";
 
 beforeEach(() => {
   mockRpc.mockReset();