pi-llama-cpp 0.9.2 → 0.11.0

package/tests/events.test.ts

@@ -1,37 +1,29 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { DEFAULT_THINKING_BUDGETS } from "../src/constants";
-import { createMockModel, createMockServer } from "./mocks";
-
-// Create a mutable mock object shared across tests
-const mockSettingsManager = {
-  getDefaultThinkingLevel: vi.fn(() => "medium"),
-  getThinkingBudgets: vi.fn<() => Record<string, number> | undefined>(),
-};
-
-vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => {
-  const actual =
-    await importOriginal<typeof import("@earendil-works/pi-coding-agent")>();
-  return {
-    ...actual,
-    SettingsManager: {
-      create: () => mockSettingsManager,
-    },
-  };
-});
-
-let EventManager: typeof import("../src/managers/events").EventManager;
-
-beforeAll(async () => {
-  const mod = await vi.importActual("../src/managers/events");
-  EventManager =
-    mod.EventManager as typeof import("../src/managers/events").EventManager;
-});
+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";
+
+/**
+ * Injected settings stub (EventManager and — in the live-list test — the
+ * real ServerManager). Recreated in `beforeEach` so per-case overrides
+ * (budgets, autoload, …) cannot leak between tests.
+ */
+let settingsStub = makeSettingsStub();
+
+/**
+ * Builds an EventManager on a ServerManager stub exposing `servers`.
+ * (The real ServerManager is exercised in the live-list test below.)
+ */
+const createEventManager = (...servers: Server[]) =>
+  new EventManager({ servers } as unknown as ServerManager, settingsStub);
 
 beforeEach(() => {
   vi.restoreAllMocks();
   EventManager.resetInflightModel();
-  mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
-  mockSettingsManager.getThinkingBudgets.mockReturnValue(undefined);
+  settingsStub = makeSettingsStub();
 });
 
 const createPayload = (modelId: string) => ({
@@ -75,12 +67,14 @@ describe("EventManager.onBeforeProviderRequest", () => {
     ])(
       'level "$level" should return $expected',
       async ({ level, expected }) => {
-        mockSettingsManager.getDefaultThinkingLevel.mockReturnValue(level);
+        vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue(
+          level as any,
+        );
 
         const server = createMockServer({
           models: ["model-a"].map((id) => createMockModel(id)),
         });
-        const eventManager = new EventManager([server]);
+        const eventManager = createEventManager(server);
         const event = { payload: createPayload("model-a") };
 
         const ctx = createMockCtx(level as any);
@@ -95,12 +89,12 @@ describe("EventManager.onBeforeProviderRequest", () => {
     );
 
     it("should preserve original payload fields alongside new ones", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("low");
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("low");
 
       const server = createMockServer({
         models: ["model-b"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = {
         payload: {
           model: "model-b",
@@ -117,7 +111,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
 
       expect(result.messages).toEqual([{ role: "user", content: "test" }]);
       expect(result.temperature).toBe(0.7);
-      expect(result.thinking_budget_tokens).toBe(DEFAULT_THINKING_BUDGETS.low);
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.low);
     });
   });
 
@@ -126,7 +120,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createNonLlamaPayload() };
 
       const ctx = createMockCtx();
@@ -144,7 +138,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: { messages: [] } };
 
       const ctx = createMockCtx();
@@ -159,13 +153,16 @@ describe("EventManager.onBeforeProviderRequest", () => {
 
   describe("user-defined budget overrides", () => {
     it("should use user-defined budgets instead of defaults", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("low");
-      mockSettingsManager.getThinkingBudgets.mockReturnValue({ low: 4096 });
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("low");
+      vi.mocked(settingsStub.resolveThinkingBudgets).mockReturnValue({
+        ...THINKING_BUDGETS,
+        low: 4096,
+      });
 
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createPayload("model-a") };
 
       const ctx = createMockCtx("low");
@@ -178,13 +175,16 @@ describe("EventManager.onBeforeProviderRequest", () => {
     });
 
     it("should merge user budgets with defaults (partial override)", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
-      mockSettingsManager.getThinkingBudgets.mockReturnValue({ low: 4096 });
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("medium");
+      vi.mocked(settingsStub.resolveThinkingBudgets).mockReturnValue({
+        ...THINKING_BUDGETS,
+        low: 4096,
+      });
 
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createPayload("model-a") };
 
       const ctx = createMockCtx("medium");
@@ -194,9 +194,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
       )) as Record<string, unknown>;
 
       // medium uses default since user only overrode low
-      expect(result.thinking_budget_tokens).toBe(
-        DEFAULT_THINKING_BUDGETS.medium,
-      );
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.medium);
     });
   });
 
@@ -204,8 +202,9 @@ describe("EventManager.onBeforeProviderRequest", () => {
 
   describe("edge cases", () => {
     it("should ignore invalid keys in user budgets (they are silently dropped)", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
-      mockSettingsManager.getThinkingBudgets.mockReturnValue({
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("medium");
+      vi.mocked(settingsStub.resolveThinkingBudgets).mockReturnValue({
+        ...THINKING_BUDGETS,
         foo: 999,
         bar: 123,
       } as any);
@@ -213,7 +212,7 @@ describe("EventManager.onBeforeProviderRequest", () => {
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createPayload("model-a") };
 
       const ctx = createMockCtx("medium");
@@ -223,21 +222,20 @@ describe("EventManager.onBeforeProviderRequest", () => {
       )) as Record<string, unknown>;
 
       // Should fall back to default since "medium" is not in user budgets
-      expect(result.thinking_budget_tokens).toBe(
-        DEFAULT_THINKING_BUDGETS.medium,
-      );
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.medium);
     });
 
     it("should not allow overriding 'off' — thinking stays disabled", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("off");
-      mockSettingsManager.getThinkingBudgets.mockReturnValue({
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("off");
+      vi.mocked(settingsStub.resolveThinkingBudgets).mockReturnValue({
+        ...THINKING_BUDGETS,
         off: 99999,
-      } as any);
+      });
 
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createPayload("model-a") };
 
       const ctx = createMockCtx("off");
@@ -253,15 +251,16 @@ describe("EventManager.onBeforeProviderRequest", () => {
     });
 
     it("should not inject budget for 'max' — unlimited reasoning", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("max");
-      mockSettingsManager.getThinkingBudgets.mockReturnValue({
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("max");
+      vi.mocked(settingsStub.resolveThinkingBudgets).mockReturnValue({
+        ...THINKING_BUDGETS,
         max: 1,
-      } as any);
+      });
 
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createPayload("model-a") };
 
       const ctx = createMockCtx("max");
@@ -275,13 +274,16 @@ describe("EventManager.onBeforeProviderRequest", () => {
     });
 
     it("should handle empty user budgets gracefully", async () => {
-      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("high");
-      mockSettingsManager.getThinkingBudgets.mockReturnValue({});
+      vi.mocked(settingsStub.resolveThinkingLevel).mockReturnValue("high");
+      // No user overrides — the resolver returns the default budget table
+      vi.mocked(settingsStub.resolveThinkingBudgets).mockReturnValue({
+        ...THINKING_BUDGETS,
+      });
 
       const server = createMockServer({
         models: ["model-a"].map((id) => createMockModel(id)),
       });
-      const eventManager = new EventManager([server]);
+      const eventManager = createEventManager(server);
       const event = { payload: createPayload("model-a") };
 
       const ctx = createMockCtx("high");
@@ -290,7 +292,170 @@ describe("EventManager.onBeforeProviderRequest", () => {
         ctx,
       )) as Record<string, unknown>;
 
-      expect(result.thinking_budget_tokens).toBe(DEFAULT_THINKING_BUDGETS.high);
+      expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.high);
     });
   });
 });
+
+describe("EventManager.onModelSelect", () => {
+  beforeEach(() => {
+    vi.mocked(settingsStub.resolveReactToModelSelect).mockReturnValue(true);
+  });
+
+  it("should load the model when reactToModelSelect is true", async () => {
+    const server = createMockServer({
+      models: ["model-a"].map((id) => createMockModel(id)),
+    });
+    const eventManager = createEventManager(server);
+    const ctx = createMockCtx();
+
+    const event = {
+      model: { provider: server.providerId, id: "model-a" },
+    } as any;
+
+    await eventManager.onModelSelect(event, ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Loading model-a...", "info");
+  });
+
+  it("should return early when reactToModelSelect is false", async () => {
+    vi.mocked(settingsStub.resolveReactToModelSelect).mockReturnValue(false);
+
+    const server = createMockServer({
+      models: ["model-a"].map((id) => createMockModel(id)),
+    });
+    const eventManager = createEventManager(server);
+    const ctx = createMockCtx();
+
+    const event = {
+      model: { provider: server.providerId, id: "model-a" },
+    } as any;
+
+    await eventManager.onModelSelect(event, ctx);
+
+    expect(ctx.ui.notify).not.toHaveBeenCalled();
+  });
+});
+
+describe("EventManager.autoLoadIfNeeded", () => {
+  it("should load the model when autoloadOnMessage is true and model is UNLOADED", async () => {
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(true);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.UNLOADED),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = createEventManager(server);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).toHaveBeenCalled();
+  });
+
+  it("should not load the model when autoloadOnMessage is false", async () => {
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(false);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.UNLOADED),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = createEventManager(server);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).not.toHaveBeenCalled();
+  });
+
+  it("should not load the model when model is already LOADED", async () => {
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(true);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.LOADED),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = createEventManager(server);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).not.toHaveBeenCalled();
+  });
+
+  it("should not load the model when model is SLEEPING", async () => {
+    vi.mocked(settingsStub.resolveAutoloadOnMessage).mockReturnValue(true);
+
+    const server = createMockServer({
+      models: [
+        createMockModel("model-a", {
+          getStatus: vi.fn().mockResolvedValue(Status.SLEEPING),
+          load: vi.fn().mockResolvedValue(undefined),
+        }),
+      ],
+    });
+    const eventManager = createEventManager(server);
+    const model = server.models[0];
+
+    await (eventManager as any).autoLoadIfNeeded(model);
+
+    expect(model.load).not.toHaveBeenCalled();
+  });
+});
+
+describe("EventManager with a live ServerManager", () => {
+  it("should observe servers added after construction", async () => {
+    const serverA = createMockServer({
+      models: [createMockModel("model-a")],
+    });
+    const serverB = createMockServer({
+      baseUrl: "http://127.0.0.1:8081",
+      models: [
+        createMockModel("model-b", { serverUrl: "http://127.0.0.1:8081" }),
+      ],
+    });
+
+    vi.mocked(settingsStub.resolveServers).mockReturnValue([serverA]);
+    const serverManager = new ServerManager(settingsStub);
+    const mockPi = { registerProvider: vi.fn(), unregisterProvider: vi.fn() };
+    await serverManager.update(mockPi as any);
+
+    const eventManager = new EventManager(serverManager, settingsStub);
+
+    // Second scan adds serverB — no manager re-construction
+    vi.mocked(settingsStub.resolveServers).mockReturnValue([serverA, serverB]);
+    await serverManager.update(mockPi as any);
+
+    // onBeforeProviderRequest sees the new server's models
+    const ctx = createMockCtx("medium");
+    const result = (await eventManager.onBeforeProviderRequest(
+      { payload: createPayload("model-b") } as any,
+      ctx,
+    )) as Record<string, unknown>;
+    expect(result.thinking_budget_tokens).toBe(THINKING_BUDGETS.medium);
+
+    // onModelSelect sees the new server's models too
+    vi.mocked(settingsStub.resolveReactToModelSelect).mockReturnValue(true);
+    const selectCtx = createMockCtx();
+    await eventManager.onModelSelect(
+      { model: { provider: serverB.providerId, id: "model-b" } } as any,
+      selectCtx,
+    );
+    expect(selectCtx.ui.notify).toHaveBeenCalledWith(
+      "Loading model-b...",
+      "info",
+    );
+  });
+});

package/tests/mocks.ts

@@ -1,50 +1,160 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { vi } from "vitest";
+import type { ApiClient } from "../src/api/client";
+import {
+  API_KEY_PLACEHOLDER,
+  AUTOLOAD_ON_MESSAGE,
+  POLLING_TIMEOUT,
+  REACT_TO_MODEL_SELECT,
+  SERVER_TIMEOUT,
+  SORT_BY,
+  THINKING_BUDGETS,
+} from "../src/constants";
 import { Mode } from "../src/enums/mode";
-import { ServerStatus } from "../src/enums/serverStatus";
 import { Status } from "../src/enums/status";
+import type { LlamaServer } from "../src/interfaces/settings";
+import type { LlamaSettingsManager } from "../src/managers/settings";
 import { BaseModel } from "../src/models/baseModel";
 import { Server } from "../src/server";
+import type { SSEManager } from "../src/sse/manager";
 
 /** Shared mock RPC — each test configures it */
 export const mockRpc = vi.fn();
 
-/** Default mock server that assumes everything works */
+/**
+ * Hand-made stub of `LlamaSettingsManager` for constructor injection —
+ * replaces whole-module `vi.mock` blocks and per-case `vi.spyOn` on the
+ * real singleton. Defaults give every consumer-used member a benign value;
+ * a case that cares passes just that member as an override. The single
+ * `as unknown as` cast lives here so test bodies stay cast-free.
+ */
+export const makeSettingsStub = (
+  overrides: Partial<LlamaSettingsManager> = {},
+): LlamaSettingsManager =>
+  ({
+    resolveTimeouts: vi.fn(() => ({
+      pollingTimeout: POLLING_TIMEOUT,
+      serverTimeout: SERVER_TIMEOUT,
+    })),
+    resolveServers: vi.fn((): Server[] => []),
+    resolveSortBy: vi.fn(() => SORT_BY),
+    resolveApiKey: vi.fn(() => API_KEY_PLACEHOLDER),
+    resolveReactToModelSelect: vi.fn(() => REACT_TO_MODEL_SELECT),
+    resolveAutoloadOnMessage: vi.fn(() => AUTOLOAD_ON_MESSAGE),
+    resolveThinkingLevel: vi.fn(() => undefined),
+    resolveThinkingBudgets: vi.fn(() => ({ ...THINKING_BUDGETS })),
+    llamaServers: [] as LlamaServer[],
+    takeWarnings: vi.fn((): string[] => []),
+    setLlamaSetting: vi.fn(() => Promise.resolve()),
+    ...overrides,
+  }) as unknown as LlamaSettingsManager;
+
+/**
+ * Fake `ApiClient`/`SSEManager` pair for injection via `ServerDeps`. The
+ * ApiClient delegates every request to the shared `mockRpc`, keyed by the
+ * endpoint path (and body for POSTs) — the same contract the old hand-rolled
+ * mock server used, so tests keep configuring responses on `mockRpc`. The
+ * SSEManager is inert: `disconnect` is a spy and `probeSSE` resolves false,
+ * steering load flows onto the HTTP polling path.
+ */
+export const createFakeClients = (): {
+  apiClient: ApiClient;
+  sseManager: SSEManager;
+} => {
+  const apiClient = {
+    get: (endpoint: string) => mockRpc(endpoint),
+    post: (endpoint: string, body?: Record<string, unknown>) =>
+      mockRpc(endpoint, body),
+    clearCache: vi.fn(),
+  } as unknown as ApiClient;
+  const sseManager = {
+    disconnect: vi.fn(),
+    probeSSE: vi.fn(async () => false),
+    subscribeToStatus: vi.fn(),
+    subscribeToProgress: vi.fn(() => () => {}),
+  } as unknown as SSEManager;
+  return { apiClient, sseManager };
+};
+
+/**
+ * Overrides for {@link createMockServer}. Identity (`baseUrl`/`customId`/
+ * `customName`), `apiKey` and the timeout getters are constructor wiring
+ * (ServerOptions + a synthesized settings stub) — a real Server has no
+ * assignable properties by those names. Everything else is shadowed onto the
+ * instance as-is (e.g. a custom `initialize`).
+ */
+export type MockServerOverrides = Partial<
+  Omit<
+    Server,
+    | "baseUrl"
+    | "providerId"
+    | "providerName"
+    | "pollingTimeout"
+    | "serverTimeout"
+    | "sseManager"
+    | "models"
+  >
+> & {
+  baseUrl?: string;
+  customId?: string;
+  customName?: string;
+  apiKey?: string;
+  models?: BaseModel[];
+  pollingTimeout?: number;
+  serverTimeout?: number;
+};
+
+/**
+ * Builds a real `Server` wired with fake collaborators (`createFakeClients`),
+ * replacing the old hand-rolled `Partial<Server>` mock whose `isReady` /
+ * `initialize` re-implementations drifted from the real ones.
+ *
+ * Seeded `models` land directly in `server.models`; `initialize` is stubbed
+ * to a no-op so a `ServerManager.update()` scan cannot wipe the seeds with
+ * fetched data — pass an `initialize` override to restore the real flow.
+ */
 export const createMockServer = (
-  overrides: Partial<Server & { apiKey?: string }> = {},
+  overrides: MockServerOverrides = {},
 ): Server => {
-  const models: BaseModel[] = [];
-  const server: Partial<Server> = {
-    baseUrl: "http://127.0.0.1:8080",
+  const {
+    baseUrl,
+    customId,
+    customName,
+    apiKey,
     models,
-    getApiKey: () => Promise.resolve(overrides.apiKey ?? ""),
-    fetchModels: () => mockRpc("/v1/models"),
-    fetchModelProps: (modelId: string) =>
-      mockRpc(`/props?model=${modelId}&autoload=false`),
-    fetchServerHealth: () => mockRpc("/health"),
-    fetchServerProps: () => mockRpc("/props?autoload=false"),
-    postRequest: (resource: "load" | "unload", model: string) =>
-      mockRpc(`/models/${resource}`, { model }),
-    isReady: async (timeout: number) => {
-      try {
-        const r = await mockRpc("/health");
-        return r.status === "ok"
-          ? ServerStatus.READY
-          : ServerStatus.UNREACHABLE;
-      } catch {
-        return ServerStatus.UNREACHABLE;
-      }
+    pollingTimeout,
+    serverTimeout,
+    initialize,
+    ...members
+  } = overrides;
+
+  const settings = makeSettingsStub({
+    ...(apiKey !== undefined && { resolveApiKey: vi.fn(() => apiKey) }),
+    ...((pollingTimeout !== undefined || serverTimeout !== undefined) && {
+      resolveTimeouts: vi.fn(() => ({
+        pollingTimeout: pollingTimeout ?? POLLING_TIMEOUT,
+        serverTimeout: serverTimeout ?? SERVER_TIMEOUT,
+      })),
+    }),
+  });
+
+  const { apiClient, sseManager } = createFakeClients();
+  const server = new Server(
+    settings,
+    {
+      baseUrl: baseUrl ?? "http://127.0.0.1:8080",
+      customId,
+      customName,
     },
-    initialize: async () => {
-      const { data } = (await mockRpc("/v1/models")) as {
-        data: BaseModel[];
-      };
-      models.length = 0;
-      models.push(...(data ?? []));
+    {
+      createApiClient: () => apiClient,
+      createSSEManager: () => sseManager,
     },
-    ...overrides,
-  };
-  return server as Server;
+  );
+  if (models) server.models.push(...models);
+  return Object.assign(server, members, {
+    initialize: initialize ?? (async () => {}),
+  });
 };
 
 /** Helper to create a mock BaseModel */
@@ -72,10 +182,12 @@ export const createMockModel = (
 export const createMockCtx = (
   selectFn: (prompt: string, options: string[]) => string | null,
 ) => ({
+  mode: "tui",
   cwd: "/tmp/test",
   ui: {
     select: vi.fn(selectFn),
     notify: vi.fn(),
+    custom: vi.fn(),
     theme: {
       fg: (color: string, text: string) => text,
     },
@@ -89,6 +201,7 @@ export const createMockCtx = (
 export const createMockPi = () => ({
   setModel: vi.fn(),
   registerProvider: vi.fn(),
+  unregisterProvider: vi.fn(),
 });
 
 /** Create a mock Pi context for EventManager */