pi-llama-cpp 0.15.0 → 0.16.0

package/src/ui/editors/server/serverEditor.ts

@@ -74,7 +74,7 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
 
   // -- abstract hooks -------------------------------------------------------
 
-  protected async buildSettingsList(): Promise<SettingsList> {
+  protected override async buildSettingsList(): Promise<SettingsList> {
     const builder = new ServerItemBuilder(this.dialogs);
     const serverTimeout = this.options.serverTimeout ?? SERVER_TIMEOUT;
     // Run auth + health probes in parallel; ⛔ wins if auth fails,
@@ -131,7 +131,7 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
     });
   }
 
-  protected beginAdd(): void {
+  protected override beginAdd(): void {
     const wizard = new ServerWizard(this.dialogs, (dialog) =>
       this.openDialog(dialog),
     );
@@ -144,7 +144,7 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
     );
   }
 
-  protected deleteSelected(): void {
+  protected override deleteSelected(): void {
     const idx = this.selectedIndex;
     const next = this.options.servers.filter((_, i) => i !== idx);
     void this.persistSnapshot(next, () => {
@@ -152,17 +152,17 @@ export class ServerSettingsList extends ListEditor<ServerSettingsListOptions> {
     });
   }
 
-  protected readonly emptyHintKey = "emptyServers" as const;
+  protected override readonly emptyHintKey = "emptyServers" as const;
 
-  protected getRowId(index: number): string {
+  protected override getRowId(index: number): string {
     return `server-${index}`;
   }
 
-  protected getRowLabel(index: number): string {
+  protected override getRowLabel(index: number): string {
     return this.options.servers[index]?.url ?? "";
   }
 
-  protected get deleteTitle(): string {
+  protected override get deleteTitle(): string {
     return TITLES.deleteServer;
   }
 

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

@@ -1,5 +1,4 @@
 import { ServerStatus } from "../enums/serverStatus";
-import type { HealthEndpoint } from "../interfaces/endpoints/health";
 
 /**
  * Probes a llama-server's `/health` endpoint and classifies the outcome.
@@ -35,8 +34,8 @@ export const checkServerHealth = async (
       signal: AbortSignal.timeout(timeout),
       headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined,
     });
-    const data = (await response.json()) as HealthEndpoint;
-    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/tests/mocks.ts

@@ -68,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/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/server/health.test.ts

@@ -10,7 +10,7 @@ const stubFetch = (
   impl: (url: string, init?: RequestInit) => Promise<unknown>,
 ) => vi.stubGlobal("fetch", vi.fn(impl));
 
-const okResponse = () => ({ json: async () => ({ status: "ok" }) });
+const okResponse = () => ({ ok: true, json: async () => ({ status: "ok" }) });
 
 const URL_ = "http://127.0.0.1:8080";
 
@@ -20,7 +20,7 @@ afterEach(() => {
 
 describe("checkServerHealth", () => {
   it("should return READY when the payload status is ok", async () => {
-    stubFetch(async () => ({ json: async () => ({ status: "ok" }) }));
+    stubFetch(async () => ({ ok: true, json: async () => ({ status: "ok" }) }));
 
     expect(await checkServerHealth(URL_, 1000)).toBe(ServerStatus.READY);
   });

package/tests/server/server.test.ts

@@ -1,6 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { POLLING_TIMEOUT, SERVER_TIMEOUT } from "../../src/constants";
+import { Mode } from "../../src/enums/mode";
 import { ServerStatus } from "../../src/enums/serverStatus";
+import type { PropsEndpoint } from "../../src/interfaces/endpoints/props";
 import type { LlamaSettingsManager } from "../../src/managers/settings";
 import { Server } from "../../src/server";
 import { createMockServer, makeSettingsStub, mockRpc } from "../mocks";
@@ -133,9 +135,57 @@ describe("Server fetchServerProps", () => {
     const server = createMockServer();
     const result = await server.fetchServerProps();
 
-    expect(result.role).toBe("router");
+    // Test mocks return a PropsEndpoint shape
+    expect((result as PropsEndpoint).role).toBe("router");
     expect(mockRpc).toHaveBeenCalledWith("/props?autoload=false");
   });
+
+  it("should return LlamaSwapPropsError shape for llama-swap", async () => {
+    mockRpc.mockResolvedValueOnce({
+      src: "llama-swap",
+      error: {
+        message: "no model id could be identified",
+        type: "invalid_request_error",
+        param: null,
+        code: "not_found",
+      },
+    });
+
+    const server = createMockServer();
+    const result = await server.fetchServerProps();
+
+    expect((result as { src: string }).src).toBe("llama-swap");
+    expect(mockRpc).toHaveBeenCalledWith("/props?autoload=false");
+  });
+});
+
+describe("Server detectServerMode", () => {
+  it("should detect LLAMASWAP mode when /props returns src", async () => {
+    // initialize() calls fetchModels() first, then fetchServerProps()
+    mockRpc
+      .mockResolvedValueOnce({
+        data: [{ id: "test-model" }],
+        object: "list",
+      })
+      .mockResolvedValueOnce({
+        src: "llama-swap",
+        error: {
+          message: "no model id could be identified",
+          type: "invalid_request_error",
+          param: null,
+          code: "not_found",
+        },
+      });
+
+    const server = createMockServer({
+      initialize: async () => {
+        await Server.prototype.initialize.call(server);
+      },
+    });
+    await server.initialize();
+
+    expect(server.models[0].mode).toBe(Mode.LLAMASWAP);
+  });
 });
 
 describe("Server postRequest", () => {
@@ -214,7 +264,7 @@ describe("Server isReady", () => {
   });
 
   it("should return READY when health status is ok", async () => {
-    stubFetch(async () => ({ json: async () => ({ status: "ok" }) }));
+    stubFetch(async () => ({ ok: true, json: async () => ({ status: "ok" }) }));
 
     const server = createMockServer();
     const status = await server.isReady(1000);