pi-llama-cpp 0.6.0 → 0.7.1

package/README.md

@@ -12,6 +12,7 @@ A [Pi Coding Agent](https://pi.dev/) extension that integrates with running [lla
 - **Flexible URL resolution** — configures the server URL via project config, environment variable, or global settings
 - **Auth support** — allows to login into a llama.cpp server that was secured with an API key
 - **Multiple server support** — connect to multiple llama.cpp servers simultaneously by separating URLs with semicolons
+- **Thinking budget support** — configurable token budgets for model reasoning/thinking, mapped to Pi's thinking levels
 
 ### Status Indicators
 
@@ -48,11 +49,11 @@ pi install https://github.com/gsanhueza/pi-llama-cpp
 
 The extension resolves the llama.cpp server URL(s) using the following priority order:
 
-1. **Per-project config** — `.pi/llama-server.json` in your project root:
+1. **Per-project config** — `.pi/settings.json` in your project root:
 
    ```json
    {
-     "url": "http://127.0.0.1:8080"
+     "llamaServerUrl": "http://127.0.0.1:8080"
    }
    ```
 
@@ -127,7 +128,7 @@ The extension determines the context size as follows:
 
 - **Router mode**
   - When loaded, reads `meta.n_ctx` from the `/models` endpoint
-  - When not loaded, reads `--ctx-size` and/or `--fit-ctx` from the server arguments, or `ctx-size` and/or `fit-ctx` keys from the **presets.ini** file.
+  - When not loaded, reads `--ctx-size` and/or `--fit-ctx` from the server arguments (which can also originate from the **presets.ini** file the llama.cpp server uses to load its models).
 - **Single mode** — reads `meta.n_ctx` from the `/models` endpoint
 - **Legacy mode** — reads `max_model_len` from `/models`, falling back to `n_ctx` from `/props`
 - Falls back to `128000` if not available
@@ -140,6 +141,8 @@ The extension determines the context size as follows:
 | `/models info`   | Show detailed information for all available models at once.                        |
 | `/models unload` | Unload all loaded models at once.                                                  |
 
+> **Note:** When a llama.cpp server is slow to respond, it will be skipped at startup with a warning. Run `/models` to retry without timeout and see all models.
+
 > **Note:** When a llama.cpp server is unreachable, `/models` displays an error notification with the configured server URL, but healthy servers continue to show their models.
 
 > **Note:** The `/models unload` command only makes sense in router mode.
@@ -157,12 +160,44 @@ When browsing models via the `/models` command, you can:
 
 > **Note:** In single-model and legacy-model mode, **Unload** is not available, since there is only one model on the server.
 
+### Thinking Budgets
+
+The extension supports configurable **thinking budgets** that control how many tokens the model allocates to its reasoning/thinking process.
+This is tied to Pi's thinking level selector (off, minimal, low, medium, high, xhigh).
+
+| Level     | Tokens | Description                  |
+| --------- | ------ | ---------------------------- |
+| `off`     | 0      | Thinking disabled            |
+| `minimal` | 1,024  | Short reasoning steps        |
+| `low`     | 2,048  | Light reasoning              |
+| `medium`  | 8,192  | Balanced reasoning (default) |
+| `high`    | 16,384 | Extended reasoning           |
+| `xhigh`   | -1     | Unlimited reasoning          |
+
+User-defined budgets can override the defaults by adding a `thinkingBudgets` object to `~/.pi/agent/settings.json` (global) or `.pi/settings.json` (per-project):
+
+```json
+{
+  "thinkingBudgets": {
+    "minimal": 256,
+    "low": 1024,
+    "medium": 2048,
+    "high": 4096
+  }
+}
+```
+
+Only `minimal`, `low`, `medium`, and `high` are configurable — `off` (0) and `xhigh` (-1, unlimited) are fixed.
+The extension automatically injects the appropriate `thinking_budget_tokens` into each request payload based on the selected level.
+
 ### Model Selection Event
 
 When you switch models via Pi's model picker (instead of using the `/models` command), the extension listens for the `model_select` event, which also loads the requested model before the conversation begins.
 
 This keeps the server in sync with the active model in Pi, regardless of how the switch was initiated — you don't need to manually load models before using them.
 
+> **Note:** If you switch sessions while a model load is in-flight, you'll see a warning, but the load continues in the background. Use `/models` in the new session to verify the model status.
+
 ### Loading Models
 
 When you trigger a load, switch, or retry action, the extension polls the server to track progress. If a model takes longer than **60 seconds** to load, the polling times out with an error.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-llama-cpp",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Pi extension for llama.cpp integration. Supports router, single and legacy models. Supports multiple servers.",
   "keywords": [
     "pi",
@@ -36,7 +36,7 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
+    "@types/node": "^25.9.3",
     "prettier-plugin-organize-imports": "^4.3.0",
     "vitest": "^4.1.8"
   }

package/src/constants.ts

@@ -39,6 +39,23 @@ export const POLLING_INTERVAL = 500;
 export const POLLING_TIMEOUT = 60000;
 
 /**
- * Reasonable time to read notifications if context goes stale
+ * Reasonable time (ms) to read notifications if context goes stale
  */
 export const READABLE_TIMEOUT = 15000;
+
+/**
+ * Timeout (ms) for server verification before assuming failure
+ */
+export const SERVER_TIMEOUT = 1000;
+
+/**
+ * Thinking budgets to send to the server, depending on user-selected level in Pi.
+ */
+export const DEFAULT_THINKING_BUDGETS = {
+  off: 0,
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16384,
+  xhigh: -1,
+};

package/src/enums/serverStatus.ts

@@ -0,0 +1,6 @@
+/** The possible states of a llama.cpp server */
+export enum ServerStatus {
+  READY = "ready",
+  TIMEOUT = "timeout",
+  UNREACHABLE = "unreachable",
+}

package/src/index.ts

@@ -1,8 +1,10 @@
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
-  SessionBeforeSwitchEvent,
+import {
+  type BeforeProviderRequestEvent,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  type SessionBeforeSwitchEvent,
+  type SessionStartEvent,
 } from "@earendil-works/pi-coding-agent";
 import { PROVIDER_NAME } from "./constants";
 import { ModelSelectEvent } from "./interfaces/events";
@@ -14,7 +16,7 @@ import { Server } from "./server";
 
 export default async function (pi: ExtensionAPI) {
   const resolver = new ConfigResolver();
-  const urls = await resolver.resolveUrls(process.cwd());
+  const urls = await resolver.resolveUrls();
   const servers = urls.map((url) => new Server(url));
 
   const eventManager = new EventManager(servers);
@@ -22,7 +24,7 @@ export default async function (pi: ExtensionAPI) {
   const commandManager = new CommandManager(serverManager);
 
   // Register providers once at startup
-  await serverManager.registerAllProviders(pi);
+  await serverManager.initialize(pi);
 
   // Single global /models command
   pi.registerCommand("models", {
@@ -34,6 +36,21 @@ export default async function (pi: ExtensionAPI) {
   });
 
   // Events
+  pi.on("session_start", (event: SessionStartEvent, ctx: ExtensionContext) => {
+    if (event.reason !== "startup") return;
+    for (const warning of serverManager.getWarnings())
+      ctx.ui.notify(warning, "warning");
+
+    for (const warning of resolver.getWarnings())
+      ctx.ui.notify(warning, "warning");
+  });
+
+  pi.on(
+    "before_provider_request",
+    async (event: BeforeProviderRequestEvent) =>
+      await eventManager.onBeforeProviderRequest(event),
+  );
+
   pi.on(
     "model_select",
     async (event: ModelSelectEvent, ctx: ExtensionContext) =>

package/src/interfaces/levels.ts

@@ -0,0 +1,7 @@
+export type ThinkingLevel =
+  | "off"
+  | "minimal"
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh";

package/src/managers/command.ts

@@ -50,7 +50,7 @@ export class CommandManager {
     pi: ExtensionAPI,
   ) {
     // Re-register providers so Pi sees updated model states
-    await this.serverManager.registerAllProviders(pi);
+    await this.serverManager.update(pi);
 
     // Notify about unreachable servers
     for (const url of this.serverManager.failedUrls) {

package/src/managers/events.ts

@@ -1,7 +1,11 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  type BeforeProviderRequestEvent,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import { READABLE_TIMEOUT } from "../constants";
 import { ModelSelectEvent } from "../interfaces/events";
 import { BaseModel } from "../models/baseModel";
+import { ConfigResolver } from "../resolver";
 import { Server } from "../server";
 
 export class EventManager {
@@ -9,6 +13,13 @@ export class EventManager {
 
   constructor(private readonly servers: Server[]) {}
 
+  /**
+   * Resets the in-flight model reference.
+   */
+  static resetInflightModel() {
+    EventManager.inflightModel = null;
+  }
+
   /**
    * Reacts to a new model event triggered by Pi
    *
@@ -55,9 +66,36 @@ export class EventManager {
   }
 
   /**
-   * Resets the in-flight model reference.
+   * Intercepts the request to add extra information, useful to llama.cpp.
+   * Adds a custom thinking budget to the request payload.
+   *
+   * @param event Request event
+   * @returns Updated payload
    */
-  static resetInflightModel() {
-    EventManager.inflightModel = null;
+  async onBeforeProviderRequest(event: BeforeProviderRequestEvent) {
+    const payload = event.payload as { model?: string };
+    const { model } = payload;
+    if (!model) return payload;
+
+    // Check if this model belongs to one of our servers
+    const isLlamaCpp = this.servers.some((s) =>
+      s.models.some((m) => m.id === model),
+    );
+
+    if (!isLlamaCpp) return payload;
+
+    // Retrieve pi's current thinking level, so we can setup a budget
+    const resolver = new ConfigResolver();
+    const level = resolver.resolveThinkingLevel() ?? "medium";
+    const budgets = resolver.resolveThinkingBudgets();
+    const thinking_budget_tokens = budgets[level];
+
+    // Setup payload
+    if (level === "off")
+      return { ...payload, chat_template_kwargs: { enable_thinking: false } };
+
+    if (level === "xhigh") return payload;
+
+    return { ...payload, thinking_budget_tokens };
   }
 }

package/src/managers/server.ts

@@ -1,42 +1,97 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { API_TYPE } from "../constants";
+import { API_TYPE, PROVIDER_NAME, SERVER_TIMEOUT } from "../constants";
+import { ServerStatus } from "../enums/serverStatus";
 import { BaseModel } from "../models/baseModel";
 import { Server } from "../server";
 
 export class ServerManager {
   readonly failedUrls: string[] = [];
+  private readonly warnings: string[] = [];
 
   constructor(private readonly servers: Server[]) {}
 
+  /**
+   * Verifies reachability of servers and registers the providers
+   *
+   * @param pi The Pi extension API
+   */
+  async initialize(pi: ExtensionAPI) {
+    // Register the providers with a timeout first
+    await this.update(pi, SERVER_TIMEOUT);
+  }
+
   /**
    * Registers one provider per server in Pi with their model configurations.
-   * Call this after the servers have been initialized.
    * The manual awaiting per-server is deliberate (we want them in order)
    *
-   * @param pi The Pi extension
+   * @param pi The Pi extension API
+   * @param timeout (Optional) Timeout before assuming server has failed
    */
-  async registerAllProviders(pi: ExtensionAPI) {
+  async update(pi: ExtensionAPI, timeout?: number) {
     this.failedUrls.length = 0;
 
-    for (const server of this.servers) {
-      await this.registerProvider(server, pi);
+    const registrableServers = timeout
+      ? await this.findRegistrableServers(timeout)
+      : this.servers;
+
+    // Initialization and registration
+    for (const server of registrableServers) {
+      try {
+        await server.initialize();
+        await this.registerProvider(server, pi);
+      } catch {
+        this.failedUrls.push(server.baseUrl);
+        continue;
+      }
     }
   }
 
+  /**
+   * Runs concurrent health checks and returns only healthy servers.
+   *
+   * @param timeout Maximum time to wait for each server
+   * @returns Array of servers that passed the health check
+   */
+  private async findRegistrableServers(timeout: number): Promise<Server[]> {
+    const healthResults = await Promise.all(
+      this.servers.map(async (server) => {
+        const status = await server.isReady(timeout);
+        return { server, status };
+      }),
+    );
+
+    const response: Server[] = [];
+    for (const { server, status } of healthResults) {
+      if (status === ServerStatus.READY) {
+        response.push(server);
+      } else if (status === ServerStatus.TIMEOUT) {
+        const message = [
+          "[pi-llama-cpp]",
+          `${PROVIDER_NAME} server initialization for '${server.baseUrl}' took more than ${SERVER_TIMEOUT} ms, so it has been skipped.`,
+          "Run `/models` to retry without timeout and see all models.",
+        ].join("\n");
+        this.warnings.push(message);
+        this.failedUrls.push(server.baseUrl);
+      } else {
+        const message = [
+          "[pi-llama-cpp]",
+          `${PROVIDER_NAME} server at '${server.baseUrl}' is unreachable.`,
+          "Check the URL and try again. Run `/models` to retry.",
+        ].join("\n");
+        this.warnings.push(message);
+        this.failedUrls.push(server.baseUrl);
+      }
+    }
+
+    return response;
+  }
+
   /**
    * Creates a Pi provider for the given server
    *
    * @param server The server
    */
   private async registerProvider(server: Server, pi: ExtensionAPI) {
-    try {
-      await server.initialize();
-    } catch {
-      this.failedUrls.push(server.baseUrl);
-      return;
-    }
-
-    // Setup the Pi registration
     const { baseUrl, models, providerId, providerName } = server;
     const apiKey = await server.getApiKey();
     const modelConfigs = await Promise.all(
@@ -52,6 +107,16 @@ export class ServerManager {
     });
   }
 
+  /**
+   * Returns warnings collected during initialization.
+   */
+  getWarnings(): string[] {
+    const warnings = [...this.warnings];
+    this.warnings.length = 0;
+
+    return warnings;
+  }
+
   /**
    * Returns all models from all servers.
    *

package/src/models/baseModel.ts

@@ -172,6 +172,13 @@ export abstract class BaseModel {
       id: this.id,
       name: this.name,
       reasoning: this.reasoning,
+      thinkingLevelMap: {
+        minimal: "minimal",
+        low: "low",
+        medium: "medium",
+        high: "high",
+        xhigh: "xhigh",
+      },
       input: await this.getCapabilities(),
       contextWindow: await this.getContextSize(),
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

package/src/resolver.ts

@@ -1,66 +1,65 @@
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { access, constants, readFile } from "node:fs/promises";
+import {
+  AuthStorage,
+  getAgentDir,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { API_KEY_PLACEHOLDER, DEFAULT_LLAMA_SERVER_URL } from "./constants";
-import { AuthFile } from "./interfaces/auth";
+import {
+  API_KEY_PLACEHOLDER,
+  DEFAULT_LLAMA_SERVER_URL,
+  DEFAULT_THINKING_BUDGETS,
+} from "./constants";
+import { ThinkingLevel } from "./interfaces/levels";
 
 export class ConfigResolver {
+  private warnings: string[] = [];
+
   private cachedUrls: string[] = [];
+  private authStorage = AuthStorage.create(join(getAgentDir(), "auth.json"));
+  private settingsManager = SettingsManager.create(
+    process.cwd(),
+    getAgentDir(),
+  );
 
   /**
-   * Detects if a particular file is present
+   * Resolves the llama-server URL by searching in the global settings.json
    */
-  private async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await access(filePath, constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
+  private async resolveGlobalUrl(): Promise<string | null> {
+    const settings = this.settingsManager.getGlobalSettings();
+    const { llamaServerUrl = null } = settings as Record<string, string>;
+
+    return llamaServerUrl;
   }
 
   /**
-   * Reads and parses the contents of a file as JSON
+   * Resolves the llama-server URL by searching in the project's .pi/settings.json
    */
-  private async readJson<T>(filePath: string): Promise<T | null> {
-    const raw = await readFile(filePath, "utf-8");
+  private async resolveProjectUrl(): Promise<string | null> {
+    // Warn the user for deprecation
     try {
-      return JSON.parse(raw) as T;
+      const filePath = join(process.cwd(), ".pi", "llama-server.json");
+      const { url = null } = JSON.parse(await readFile(filePath, "utf-8"));
+
+      const messages = [
+        "[pi-llama-cpp]",
+        "The project-level `.pi/llama-server.json` file has been deprecated.",
+        "It will work for now, but you must follow these instructions as soon as possible:",
+        '- Move your url to the project-level `.pi/settings.json` file as {"llamaServerUrl": "<url>"}.',
+        "- Remove the old `.pi/llama-server.json` file.",
+      ];
+
+      this.warnings.push(messages.join("\n"));
+
+      return url;
     } catch {
-      return null;
+      // No old file available, continue as normal
     }
-  }
 
-  /**
-   * Reads a value from a JSON config file by key
-   */
-  private async readConfigValue<T>(
-    filePath: string,
-    key: keyof T,
-  ): Promise<T[keyof T] | null> {
-    const cfg = await this.readJson<T>(filePath);
-    return cfg?.[key] ?? null;
-  }
+    const settings = this.settingsManager.getProjectSettings();
+    const { llamaServerUrl = null } = settings as Record<string, string>;
 
-  /**
-   * Resolves the llama-server URL by searching in the global settings.json
-   */
-  private async resolveGlobalUrl(): Promise<string | null> {
-    const globalPath = join(getAgentDir(), "settings.json");
-    if (!(await this.fileExists(globalPath))) return null;
-    return this.readConfigValue<Record<string, string>>(
-      globalPath,
-      "llamaServerUrl",
-    );
-  }
-
-  /**
-   * Resolves the llama-server URL by searching in the project's .pi/llama-server.json
-   */
-  private async resolveProjectUrl(cwd: string): Promise<string | null> {
-    const projectPath = join(cwd, ".pi", "llama-server.json");
-    if (!(await this.fileExists(projectPath))) return null;
-    return this.readConfigValue<Record<string, string>>(projectPath, "url");
+    return llamaServerUrl;
   }
 
   /**
@@ -73,9 +72,9 @@ export class ConfigResolver {
   /**
    * Tries all possible ways to retrieve the llama-server URL(s)
    */
-  private async extractJoinedUrls(cwd: string): Promise<string> {
+  private async extractJoinedUrls(): Promise<string> {
     // 1. per-project config
-    let response = await this.resolveProjectUrl(cwd);
+    let response = await this.resolveProjectUrl();
     if (response) return response;
 
     // 2. env
@@ -93,10 +92,10 @@ export class ConfigResolver {
   /**
    * Resolves URLs where llama-servers are running (cached)
    */
-  async resolveUrls(cwd: string): Promise<string[]> {
+  async resolveUrls(): Promise<string[]> {
     if (this.cachedUrls.length > 0) return this.cachedUrls;
 
-    const raw = await this.extractJoinedUrls(cwd);
+    const raw = await this.extractJoinedUrls();
     const urls = raw
       .split(";")
       .map((u) => u.trim())
@@ -108,16 +107,46 @@ export class ConfigResolver {
   }
 
   /**
-   * Resolves API key for the provider ID using Pi's auth.json
-   * Deliberately not cached, to react to changes in the file
+   * Resolves API key for the provider ID using Pi's AuthStorage
    */
   async resolveApiKey(providerId: string): Promise<string> {
-    const authPath = join(getAgentDir(), "auth.json");
-    if (!(await this.fileExists(authPath))) return API_KEY_PLACEHOLDER;
+    this.authStorage.reload();
+    const apiKey = await this.authStorage.getApiKey(providerId);
+
+    return apiKey ?? API_KEY_PLACEHOLDER;
+  }
+
+  /**
+   * Returns warnings collected during URL resolution.
+   */
+  getWarnings(): string[] {
+    const warnings = [...this.warnings];
+    this.warnings.length = 0;
+
+    return warnings;
+  }
 
-    const auth = await this.readJson<AuthFile>(authPath);
-    const apiKey = auth?.[providerId]?.key ?? API_KEY_PLACEHOLDER;
+  /*
+   * Resolves the current thinking level from Pi.
+   *
+   * @returns Selected level
+   */
+  resolveThinkingLevel(): ThinkingLevel | undefined {
+    return this.settingsManager.getDefaultThinkingLevel();
+  }
 
-    return apiKey;
+  /**
+   * Resolves the effective thinking budgets from settings
+   *
+   * @returns Thinking budgets
+   */
+  resolveThinkingBudgets(): Record<ThinkingLevel, number> {
+    const settingsBudgets = this.settingsManager.getThinkingBudgets() ?? {};
+    const availableBudgets = {
+      ...DEFAULT_THINKING_BUDGETS,
+      ...settingsBudgets,
+    };
+
+    return availableBudgets;
   }
 }

package/src/server.ts

@@ -1,5 +1,6 @@
 import { PROVIDER_NAME, PROVIDER_PREFIX } from "./constants";
 import { Mode } from "./enums/mode";
+import { ServerStatus } from "./enums/serverStatus";
 import { HealthEndpoint } from "./interfaces/endpoints/health";
 import { ModelsEndpoint } from "./interfaces/endpoints/models";
 import { PropsEndpoint } from "./interfaces/endpoints/props";
@@ -10,7 +11,8 @@ import { SingleModel } from "./models/singleModel";
 import { ConfigResolver } from "./resolver";
 
 export class Server {
-  readonly models: BaseModel[] = [];
+  public readonly models: BaseModel[] = [];
+  private configResolver = new ConfigResolver();
 
   constructor(readonly baseUrl: string) {}
 
@@ -33,7 +35,7 @@ export class Server {
    * @returns The API key
    */
   async getApiKey(): Promise<string> {
-    return await new ConfigResolver().resolveApiKey(this.providerId);
+    return await this.configResolver.resolveApiKey(this.providerId);
   }
 
   /**
@@ -73,15 +75,29 @@ export class Server {
   }
 
   /**
-   * Detects if the server is ready
-   * @returns True if it's ready to work
+   * Checks if the server is ready, with a timeout.
+   *
+   * @param timeout Maximum time to wait for the health check
+   * @returns The server status
    */
-  async isReady(): Promise<boolean> {
+  async isReady(timeout: number): Promise<ServerStatus> {
     try {
-      const { status } = await this.fetchServerHealth();
-      return status === "ok";
-    } catch {
-      return false;
+      const timeoutPromise = new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("timeout")), timeout),
+      );
+      const health = await Promise.race([
+        this.fetchServerHealth(),
+        timeoutPromise,
+      ]);
+      if (health.status === "ok") {
+        return ServerStatus.READY;
+      }
+      return ServerStatus.UNREACHABLE;
+    } catch (error) {
+      if (error instanceof Error && error.message === "timeout") {
+        return ServerStatus.TIMEOUT;
+      }
+      return ServerStatus.UNREACHABLE;
     }
   }
 

package/tests/events.test.ts

@@ -0,0 +1,256 @@
+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;
+});
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+  EventManager.resetInflightModel();
+  mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
+  mockSettingsManager.getThinkingBudgets.mockReturnValue(undefined);
+});
+
+const createPayload = (modelId: string) => ({
+  model: modelId,
+  messages: [{ role: "user", content: "hello" }],
+});
+
+const createNonLlamaPayload = () => ({
+  model: "gpt-4",
+  messages: [{ role: "user", content: "hello" }],
+});
+
+describe("EventManager.onBeforeProviderRequest", () => {
+  describe("normal usage — each thinking level", () => {
+    it.each([
+      {
+        level: "off",
+        expected: { chat_template_kwargs: { enable_thinking: false } },
+      },
+      { level: "minimal", expected: { thinking_budget_tokens: 1024 } },
+      { level: "low", expected: { thinking_budget_tokens: 2048 } },
+      { level: "medium", expected: { thinking_budget_tokens: 8192 } },
+      { level: "high", expected: { thinking_budget_tokens: 16384 } },
+      { level: "xhigh", expected: {} },
+    ])(
+      'level "$level" should return $expected',
+      async ({ level, expected }) => {
+        mockSettingsManager.getDefaultThinkingLevel.mockReturnValue(level);
+
+        const server = createMockServer({
+          models: ["model-a"].map((id) => createMockModel(id)),
+        });
+        const eventManager = new EventManager([server]);
+        const event = { payload: createPayload("model-a") };
+
+        const result = (await eventManager.onBeforeProviderRequest(
+          event as any,
+        )) as Record<string, unknown>;
+
+        expect(result.model).toBe("model-a");
+        expect(result).toMatchObject(expected);
+      },
+    );
+
+    it("should preserve original payload fields alongside new ones", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("low");
+
+      const server = createMockServer({
+        models: ["model-b"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = {
+        payload: {
+          model: "model-b",
+          messages: [{ role: "user", content: "test" }],
+          temperature: 0.7,
+        },
+      };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) as Record<string, unknown>;
+
+      expect(result.messages).toEqual([{ role: "user", content: "test" }]);
+      expect(result.temperature).toBe(0.7);
+      expect(result.thinking_budget_tokens).toBe(DEFAULT_THINKING_BUDGETS.low);
+    });
+  });
+
+  describe("non-llama.cpp models", () => {
+    it("should return the payload unchanged for unknown models", async () => {
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createNonLlamaPayload() };
+
+      const result = await eventManager.onBeforeProviderRequest(event as any);
+
+      expect(result).toEqual(createNonLlamaPayload());
+    });
+  });
+
+  describe("missing model in payload", () => {
+    it("should return the payload unchanged when model is absent", async () => {
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: { messages: [] } };
+
+      const result = await eventManager.onBeforeProviderRequest(event as any);
+
+      expect(result).toEqual({ messages: [] });
+    });
+  });
+
+  describe("user-defined budget overrides", () => {
+    it("should use user-defined budgets instead of defaults", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("low");
+      mockSettingsManager.getThinkingBudgets.mockReturnValue({ low: 4096 });
+
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createPayload("model-a") };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) as Record<string, unknown>;
+
+      expect(result.thinking_budget_tokens).toBe(4096);
+    });
+
+    it("should merge user budgets with defaults (partial override)", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
+      mockSettingsManager.getThinkingBudgets.mockReturnValue({ low: 4096 });
+
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createPayload("model-a") };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) as Record<string, unknown>;
+
+      // medium uses default since user only overrode low
+      expect(result.thinking_budget_tokens).toBe(
+        DEFAULT_THINKING_BUDGETS.medium,
+      );
+    });
+  });
+
+  // ─── Edge cases ─────────────────────────────────────────────────────
+
+  describe("edge cases", () => {
+    it("should ignore invalid keys in user budgets (they are silently dropped)", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("medium");
+      mockSettingsManager.getThinkingBudgets.mockReturnValue({
+        foo: 999,
+        bar: 123,
+      } as any);
+
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createPayload("model-a") };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) 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,
+      );
+    });
+
+    it("should not allow overriding 'off' — thinking stays disabled", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("off");
+      mockSettingsManager.getThinkingBudgets.mockReturnValue({
+        off: 99999,
+      } as any);
+
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createPayload("model-a") };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) as Record<string, unknown>;
+
+      expect(result).toMatchObject({
+        chat_template_kwargs: { enable_thinking: false },
+      });
+      expect(result).not.toHaveProperty("thinking_budget_tokens");
+    });
+
+    it("should not allow overriding 'xhigh' — no budget is injected", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("xhigh");
+      mockSettingsManager.getThinkingBudgets.mockReturnValue({
+        xhigh: 1,
+      } as any);
+
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createPayload("model-a") };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) as Record<string, unknown>;
+
+      expect(result).toEqual(createPayload("model-a"));
+      expect(result).not.toHaveProperty("thinking_budget_tokens");
+    });
+
+    it("should handle empty user budgets gracefully", async () => {
+      mockSettingsManager.getDefaultThinkingLevel.mockReturnValue("high");
+      mockSettingsManager.getThinkingBudgets.mockReturnValue({});
+
+      const server = createMockServer({
+        models: ["model-a"].map((id) => createMockModel(id)),
+      });
+      const eventManager = new EventManager([server]);
+      const event = { payload: createPayload("model-a") };
+
+      const result = (await eventManager.onBeforeProviderRequest(
+        event as any,
+      )) as Record<string, unknown>;
+
+      expect(result.thinking_budget_tokens).toBe(DEFAULT_THINKING_BUDGETS.high);
+    });
+  });
+});

package/tests/mocks.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { vi } from "vitest";
 import { Mode } from "../src/enums/mode";
+import { ServerStatus } from "../src/enums/serverStatus";
 import { Status } from "../src/enums/status";
 import { BaseModel } from "../src/models/baseModel";
 import { Server } from "../src/server";
@@ -24,12 +25,14 @@ export const createMockServer = (
     fetchServerProps: () => mockRpc("/props?autoload=false"),
     postRequest: (resource: "load" | "unload", model: string) =>
       mockRpc(`/models/${resource}`, { model }),
-    isReady: async () => {
+    isReady: async (timeout: number) => {
       try {
         const r = await mockRpc("/health");
-        return r.status === "ok";
+        return r.status === "ok"
+          ? ServerStatus.READY
+          : ServerStatus.UNREACHABLE;
       } catch {
-        return false;
+        return ServerStatus.UNREACHABLE;
       }
     },
     initialize: async () => {

package/tests/resolver.test.ts

@@ -4,26 +4,46 @@ import {
   DEFAULT_LLAMA_SERVER_URL,
 } from "../src/constants";
 
-// Mock getAgentDir before importing resolver
+// Hoisted mock instances — survives vi.resetModules()
+const mockAuthStorage = vi.hoisted(() => ({
+  reload: vi.fn(),
+  getApiKey: vi.fn(),
+}));
+
+const mockSettingsManager = vi.hoisted(() => ({
+  getProjectSettings: vi.fn(),
+  getGlobalSettings: vi.fn(),
+}));
+
+// Mock getAgentDir, AuthStorage, and SettingsManager before importing resolver
 vi.mock("@earendil-works/pi-coding-agent", () => ({
   getAgentDir: vi.fn().mockReturnValue("/fake/agent/dir"),
+  AuthStorage: {
+    create: vi.fn().mockReturnValue(mockAuthStorage),
+  },
+  SettingsManager: {
+    create: vi.fn().mockReturnValue(mockSettingsManager),
+  },
 }));
 
 vi.mock("node:fs/promises", () => ({
-  access: vi.fn(),
-  constants: { F_OK: 0 },
   readFile: vi.fn(),
 }));
 
 // Import mocked modules
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { access, readFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { ConfigResolver } from "../src/resolver";
 
 describe("URL resolution fallback chain", () => {
-  const mockAccess = vi.mocked(access);
   const mockReadFile = vi.mocked(readFile);
   const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
 
   afterEach(() => {
     delete process.env.LLAMA_SERVER_URL;
@@ -33,115 +53,89 @@ describe("URL resolution fallback chain", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    // Default: no files exist
-    mockAccess.mockRejectedValue(new Error("ENOENT"));
-    mockReadFile.mockResolvedValue("");
+    // Default: no settings found
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
   });
 
   it("should return default URL when no config is found", async () => {
     const resolver = new ConfigResolver();
-    const result = await resolver.resolveUrls("/tmp/test-project");
+    const result = await resolver.resolveUrls();
 
     expect(result).toEqual([DEFAULT_LLAMA_SERVER_URL]);
   });
 
   it("should prioritize project config over env variable", async () => {
-    mockAccess.mockImplementation(async (_path: unknown) => {
-      if (typeof _path === "string" && _path.includes("llama-server.json"))
-        return undefined;
-      throw new Error("ENOENT");
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://localhost:9999",
     });
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({ url: "http://localhost:9999" }),
-    );
-
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
     const resolver = new ConfigResolver();
-    const result = await resolver.resolveUrls("/tmp/test-project");
+    const result = await resolver.resolveUrls();
 
     expect(result).toEqual(["http://localhost:9999"]);
   });
 
   it("should use env variable when no project config exists", async () => {
+    mockGetProjectSettings.mockReturnValue({});
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
     const resolver = new ConfigResolver();
-    const result = await resolver.resolveUrls("/tmp/test-project");
+    const result = await resolver.resolveUrls();
 
     expect(result).toEqual(["http://env-url:8080"]);
   });
 
   it("should use global settings when no project config or env exists", async () => {
-    mockAccess.mockImplementation(async (_path: unknown) => {
-      if (typeof _path === "string" && _path.includes("settings.json"))
-        return undefined;
-      throw new Error("ENOENT");
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({
+      llamaServerUrl: "http://global:8080",
     });
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({ llamaServerUrl: "http://global:8080" }),
-    );
 
     const resolver = new ConfigResolver();
-    const result = await resolver.resolveUrls("/tmp/test-project");
+    const result = await resolver.resolveUrls();
 
     expect(result).toEqual(["http://global:8080"]);
   });
 
   it("should strip trailing slashes from resolved URL", async () => {
-    mockAccess.mockImplementation(async (_path: unknown) => {
-      if (typeof _path === "string" && _path.includes("llama-server.json"))
-        return undefined;
-      throw new Error("ENOENT");
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://localhost:8080/",
     });
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({ url: "http://localhost:8080/" }),
-    );
 
     const resolver = new ConfigResolver();
-    const result = await resolver.resolveUrls("/tmp/test-project");
+    const result = await resolver.resolveUrls();
 
     expect(result).toEqual(["http://localhost:8080"]);
   });
 
   it("should cache the resolved URL on subsequent calls", async () => {
-    mockAccess.mockImplementation(async (_path: unknown) => {
-      if (typeof _path === "string" && _path.includes("llama-server.json"))
-        return undefined;
-      throw new Error("ENOENT");
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://first:8080",
     });
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({ url: "http://first:8080" }),
-    );
 
     const resolver = new ConfigResolver();
-    const result1 = await resolver.resolveUrls("/tmp/project1");
-    const result2 = await resolver.resolveUrls("/tmp/project2");
+    const result1 = await resolver.resolveUrls();
+    const result2 = await resolver.resolveUrls();
 
     expect(result1).toEqual(["http://first:8080"]);
     expect(result2).toEqual(["http://first:8080"]);
   });
 
   it("should handle multiple URLs separated by semicolons", async () => {
-    mockAccess.mockImplementation(async (_path: unknown) => {
-      if (typeof _path === "string" && _path.includes("llama-server.json"))
-        return undefined;
-      throw new Error("ENOENT");
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://first:8080;http://second:9090/",
     });
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({ url: "http://first:8080;http://second:9090/" }),
-    );
 
     const resolver = new ConfigResolver();
-    const result = await resolver.resolveUrls("/tmp/test-project");
+    const result = await resolver.resolveUrls();
 
     expect(result).toEqual(["http://first:8080", "http://second:9090"]);
   });
 });
 
 describe("API key resolution", () => {
-  const mockAccess = vi.mocked(access);
-  const mockReadFile = vi.mocked(readFile);
   const mockGetAgentDir = vi.mocked(getAgentDir);
 
   afterEach(() => {
@@ -151,11 +145,13 @@ describe("API key resolution", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAgentDir.mockReturnValue("/fake/agent/dir");
-    mockAccess.mockRejectedValue(new Error("ENOENT"));
-    mockReadFile.mockResolvedValue("");
+    mockAuthStorage.reload.mockReturnValue(undefined);
+    mockAuthStorage.getApiKey.mockResolvedValue(undefined);
   });
 
   it("should return placeholder when auth file does not exist", async () => {
+    mockAuthStorage.getApiKey.mockResolvedValue(undefined);
+
     const resolver = new ConfigResolver();
     const result = await resolver.resolveApiKey(
       "llama-server=http://127.0.0.1:8080",
@@ -165,10 +161,7 @@ describe("API key resolution", () => {
   });
 
   it("should return placeholder when provider key is missing", async () => {
-    mockAccess.mockResolvedValue(undefined);
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({ "other-provider": { key: "other-key" } }),
-    );
+    mockAuthStorage.getApiKey.mockResolvedValue(undefined);
 
     const resolver = new ConfigResolver();
     const result = await resolver.resolveApiKey(
@@ -179,12 +172,7 @@ describe("API key resolution", () => {
   });
 
   it("should return the provider key when present", async () => {
-    mockAccess.mockResolvedValue(undefined);
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({
-        "llama-server=http://127.0.0.1:8080": { key: "test-api-key" },
-      }),
-    );
+    mockAuthStorage.getApiKey.mockResolvedValue("test-api-key");
 
     const resolver = new ConfigResolver();
     const result = await resolver.resolveApiKey(
@@ -194,23 +182,13 @@ describe("API key resolution", () => {
     expect(result).toEqual("test-api-key");
   });
 
-  it("should cache the auth file and reuse the key", async () => {
-    mockAccess.mockResolvedValue(undefined);
-    mockReadFile.mockResolvedValue(
-      JSON.stringify({
-        "llama-server=http://127.0.0.1:8080": { key: "cached-key" },
-      }),
-    );
+  it("should call reload before each getApiKey", async () => {
+    mockAuthStorage.getApiKey.mockResolvedValue("cached-key");
 
     const resolver = new ConfigResolver();
-    const result1 = await resolver.resolveApiKey(
-      "llama-server=http://127.0.0.1:8080",
-    );
-    const result2 = await resolver.resolveApiKey(
-      "llama-server=http://127.0.0.1:8080",
-    );
+    await resolver.resolveApiKey("llama-server=http://127.0.0.1:8080");
+    await resolver.resolveApiKey("llama-server=http://127.0.0.1:8080");
 
-    expect(result1).toBe("cached-key");
-    expect(result2).toBe("cached-key");
+    expect(mockAuthStorage.reload).toHaveBeenCalledTimes(2);
   });
 });

package/tests/server.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
+import { ServerStatus } from "../src/enums/serverStatus";
 import { Server } from "../src/server";
 import { createMockServer, mockRpc } from "./mocks";
 
@@ -146,30 +147,30 @@ describe("Server postRequest", () => {
 });
 
 describe("Server isReady", () => {
-  it("should return true when health status is ok", async () => {
+  it("should return READY when health status is ok", async () => {
     mockRpc.mockResolvedValueOnce({ status: "ok" });
 
     const server = createMockServer();
-    const ready = await server.isReady();
+    const status = await server.isReady(1000);
 
-    expect(ready).toBe(true);
+    expect(status).toBe(ServerStatus.READY);
   });
 
-  it("should return false when health check fails", async () => {
+  it("should return UNREACHABLE when health check fails", async () => {
     mockRpc.mockRejectedValueOnce(new Error("connection refused"));
 
     const server = createMockServer();
-    const ready = await server.isReady();
+    const status = await server.isReady(1000);
 
-    expect(ready).toBe(false);
+    expect(status).toBe(ServerStatus.UNREACHABLE);
   });
 
-  it("should return false when health status is not ok", async () => {
+  it("should return UNREACHABLE when health status is not ok", async () => {
     mockRpc.mockResolvedValueOnce({ status: "error" });
 
     const server = createMockServer();
-    const ready = await server.isReady();
+    const status = await server.isReady(1000);
 
-    expect(ready).toBe(false);
+    expect(status).toBe(ServerStatus.UNREACHABLE);
   });
 });

package/tests/serverManager.test.ts

@@ -12,7 +12,14 @@ const mockPi = {
 
 beforeEach(() => {
   vi.clearAllMocks();
-  mockRpc.mockResolvedValue({});
+  mockRpc.mockImplementation((endpoint: string, fallback?: unknown) => {
+    const defaults: Record<string, unknown> = {
+      "/health": { status: "ok" },
+      "/props?autoload=false": { role: "router" },
+      "/v1/models": { data: [], object: "list" },
+    };
+    return Promise.resolve(defaults[endpoint] ?? fallback ?? {});
+  });
 });
 
 describe("Server", () => {
@@ -44,9 +51,15 @@ describe("ServerManager", () => {
       id: "test-model",
       toProviderConfig: vi.fn().mockResolvedValue({ id: "test-model" }),
     } as unknown as BaseModel;
-    mockRpc.mockResolvedValue({
-      data: [mockModel],
-      object: "list",
+    mockRpc.mockImplementation((endpoint: string, fallback?: unknown) => {
+      if (endpoint === "/v1/models") {
+        return Promise.resolve({ data: [mockModel], object: "list" });
+      }
+      const defaults: Record<string, unknown> = {
+        "/health": { status: "ok" },
+        "/props?autoload=false": { role: "router" },
+      };
+      return Promise.resolve(defaults[endpoint] ?? fallback ?? {});
     });
 
     const server1 = createMockServer({
@@ -63,7 +76,7 @@ describe("ServerManager", () => {
     });
     const manager = new ServerManager([server1, server2] as any);
 
-    await manager.registerAllProviders(mockPi as any);
+    await manager.initialize(mockPi as any);
 
     expect(mockPi.registerProvider).toHaveBeenCalledTimes(2);
     expect(mockPi.registerProvider).toHaveBeenCalledWith(