pi-llama-cpp 0.5.1 → 0.7.0

package/src/commands/models.ts

@@ -1,228 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
-  SessionBeforeSwitchEvent,
-} from "@earendil-works/pi-coding-agent";
-import { PROVIDER_ID, PROVIDER_NAME, READABLE_TIMEOUT } from "../constants";
-import { Action } from "../enums/action";
-import { Mode } from "../enums/mode";
-import { Status } from "../enums/status";
-import { BaseModel } from "../models/baseModel";
-import { resolveUrl } from "../tools/resolver";
-
-// In-flight model reference — handler gates on this.
-let inflightModel: BaseModel | null = null;
-
-export const resetInflightModel = () => (inflightModel = null);
-
-/**
- * Session-switch handler. Registered once at extension init.
- * Only notifies if a model load is actually in-flight.
- */
-export const onSessionBeforeSwitch = async (
-  _event: SessionBeforeSwitchEvent,
-  ctx: ExtensionContext,
-) => {
-  if (!inflightModel) return;
-
-  const messages = [
-    `Session change detected while model '${inflightModel.name}' was still loading.`,
-    "Model load will continue in the background, but UI might not update.",
-    "",
-    "Verify that your new model is loaded, or use /models to re-select it afterwards.",
-  ];
-  ctx.ui.notify(messages.join("\n"), "warning");
-
-  // Show the notification for a reasonable amount of time
-  await new Promise((r) => setTimeout(r, READABLE_TIMEOUT));
-};
-
-/**
- * Select a model from the list. Returns null if user cancels.
- *
- * @param ctx Pi context
- * @param models A list of models
- * @returns The selected model
- */
-const selectModel = async (
-  ctx: ExtensionCommandContext,
-  models: BaseModel[],
-): Promise<BaseModel | null> => {
-  const labels = await Promise.all(models.map((m) => m.getLabel()));
-  const choice = await ctx.ui.select(`${PROVIDER_NAME} models:`, labels);
-  if (!choice) return null;
-  const idx = labels.indexOf(choice);
-  return models[idx];
-};
-
-/**
- * Get available actions for a model based on its mode and status.
- *
- * @param model The selected model
- * @returns The array of available actions for the given model status
- */
-const getActionsForModel = async (model: BaseModel): Promise<Array<Action>> => {
-  const routerModeActions: Record<Status, Array<Action>> = {
-    [Status.LOADED]: [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL],
-    [Status.LOADING]: [Action.INFO, Action.CANCEL],
-    [Status.FAILED]: [Action.RETRY, Action.CANCEL],
-    [Status.SLEEPING]: [
-      Action.SWITCH,
-      Action.UNLOAD,
-      Action.INFO,
-      Action.CANCEL,
-    ],
-    [Status.UNLOADED]: [Action.LOAD, Action.CANCEL],
-  };
-
-  const singleModeActions: Record<Status, Array<Action>> = {
-    [Status.LOADED]: [Action.INFO, Action.CANCEL],
-    [Status.LOADING]: [Action.CANCEL],
-    [Status.FAILED]: [Action.CANCEL],
-    [Status.SLEEPING]: [Action.INFO, Action.CANCEL],
-    [Status.UNLOADED]: [Action.CANCEL],
-  };
-
-  const allActions =
-    model.mode === Mode.ROUTER ? routerModeActions : singleModeActions;
-
-  const status = await model.getStatus();
-  return allActions[status];
-};
-
-/**
- * Selects an action for a model.
- *
- * @param ctx Pi context
- * @param model The selected model
- * @param actions Possible actions to execute
- * @returns The action, or null if user cancels
- */
-const selectAction = async (
-  ctx: ExtensionCommandContext,
-  model: BaseModel,
-  actions: Array<Action>,
-): Promise<Action | null> => {
-  const labels = actions.map((a) => String(a));
-  const choice = await ctx.ui.select(`${model.name}`, labels);
-  if (!choice) return null;
-
-  const idx = labels.indexOf(choice);
-  return actions[idx];
-};
-
-/**
- * Handles the menu for model selection
- * Loops: select model → select action → handle action.
- *
- * Escape on actions menu goes back to model selection.
- * Escape on model selection exits.
- *
- * @param ctx Pi context
- * @returns The action and model, if detected
- */
-const modelSelectionHandler = async (
-  ctx: ExtensionCommandContext,
-  models: BaseModel[],
-): Promise<{ action: Action; model: BaseModel } | null> => {
-  while (true) {
-    // Select the model
-    const model = await selectModel(ctx, models);
-    if (!model) return null;
-
-    // Select the action
-    const actions = await getActionsForModel(model);
-    const action = await selectAction(ctx, model, actions);
-    if (action === null) {
-      // Escape key pressed => back to model selection
-      continue;
-    }
-
-    // Return the selected action and model
-    return { action, model };
-  }
-};
-
-/**
- * Handles the /models command when the server is unreachable.
- *
- * @param ctx The context used by Pi
- */
-export const notFoundCommand = async (
-  ctx: ExtensionCommandContext,
-): Promise<void> => {
-  const url = await resolveUrl(ctx.cwd);
-  ctx.ui.notify(`${PROVIDER_NAME} unreachable at ${url}`, "error");
-};
-
-/**
- * Handles the /models command
- *
- * @param args Arguments passed to the command
- * @param ctx The context used by Pi
- * @param pi The Pi extension
- * @param models List of available models
- */
-export const modelsCommand = async (
-  ctx: ExtensionCommandContext,
-  pi: ExtensionAPI,
-  models: BaseModel[],
-): Promise<void> => {
-  const event = await modelSelectionHandler(ctx, models);
-  if (!event) return;
-
-  // Detect the model
-  const { action, model } = event;
-
-  // Action: Cancel
-  if (!action || action === Action.CANCEL) return;
-
-  // Action: Info
-  if (action === Action.INFO) {
-    const info = await model.getInfo();
-    ctx.ui.notify(`${info}`, "info");
-    return;
-  }
-
-  // Action: Unload
-  if (action === Action.UNLOAD) {
-    await model.unload();
-    ctx.ui.notify(`Unloaded ${model.name}`, "info");
-    return;
-  }
-
-  // Actions: Load/Switch/Retry
-  const loadActions = [Action.LOAD, Action.SWITCH, Action.RETRY];
-  if (loadActions.includes(action)) {
-    ctx.ui.notify(`Loading ${model.name}...`, "info");
-    inflightModel = model;
-
-    const onSuccess = async () => {
-      const piModel = ctx.modelRegistry.find(PROVIDER_ID, model.id);
-      if (!piModel) {
-        throw new Error(`Cannot find model ${model.name} in pi registry`);
-      }
-
-      if ((await model.getStatus()) === Status.FAILED) {
-        throw new Error(`Failed to load model ${model.name}`);
-      }
-
-      await pi.setModel(piModel);
-      ctx.ui.notify(`Model ${model.name} ready`, "info");
-    };
-
-    const onFailure = (err: any) => {
-      const message = err instanceof Error ? err.message : String(err);
-
-      try {
-        ctx.ui.notify(message, "error");
-      } catch {
-        // ctx went stale between error and notification
-      }
-    };
-
-    // Load the model without blocking the UI
-    model.load().then(onSuccess).catch(onFailure).finally(resetInflightModel);
-  }
-};

package/src/events.ts

@@ -1,26 +0,0 @@
-import { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { PROVIDER_ID } from "./constants";
-import { ModelSelectEvent } from "./interfaces/events";
-import { listModels } from "./tools/retriever";
-
-/**
- * Reacts to a new model event triggered by Pi
- * @param event Model selection event
- * @param ctx Pi context
- */
-export const onModelSelect = async (
-  event: ModelSelectEvent,
-  ctx: ExtensionContext,
-) => {
-  if (event.model.provider !== PROVIDER_ID) return;
-
-  const models = await listModels();
-  const model = models.find((m) => m.id === event.model.id);
-  if (!model) return;
-
-  ctx.ui.notify(`Loading ${model.name}...`, "info");
-  await model
-    .load()
-    .then(() => ctx.ui.notify(`Model ${model.name} ready`, "info"))
-    .catch(() => ctx.ui.notify(`Failed to load model ${model.name}`, "error"));
-};

package/src/manager.ts

@@ -1,96 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ProviderModelConfig,
-} from "@earendil-works/pi-coding-agent";
-import { modelsCommand, notFoundCommand } from "./commands/models";
-import {
-  DEFAULT_LLAMA_SERVER_URL,
-  PROVIDER_ID,
-  PROVIDER_NAME,
-} from "./constants";
-import { BaseModel } from "./models/baseModel";
-import { resolveApiKey, resolveUrl } from "./tools/resolver";
-import { isServerReady, listModels } from "./tools/retriever";
-
-export class CommandManager {
-  private baseUrl: string = DEFAULT_LLAMA_SERVER_URL;
-  private serverModels: BaseModel[] = [];
-
-  constructor(private readonly pi: ExtensionAPI) {}
-
-  /**
-   * Sets up the initial state of the provider
-   */
-  async initialize() {
-    if (await isServerReady()) {
-      await this.update();
-    } else {
-      await this.register([]);
-    }
-  }
-
-  /**
-   * Ensures the models are up-to-date with the server
-   */
-  async update() {
-    this.baseUrl = `${await resolveUrl(process.cwd())}`;
-
-    this.serverModels = await listModels();
-    const modelConfigs = await Promise.all(
-      this.serverModels.map((m) => m.toProviderConfig()),
-    );
-
-    await this.register(modelConfigs);
-  }
-
-  /**
-   * Registers the provider in Pi with the given configurations
-   * Note: Registrations overload previous provider
-   *
-   * @param models Provider configurations for the models
-   */
-  async register(models: ProviderModelConfig[]) {
-    this.pi.registerProvider(PROVIDER_ID, {
-      name: PROVIDER_NAME,
-      baseUrl: this.baseUrl,
-      api: "openai-completions",
-      apiKey: await resolveApiKey(),
-      models,
-    });
-  }
-
-  /**
-   * Dispatches the /models command
-   *
-   * @param args Arguments passed to the command
-   * @param ctx The context used by Pi
-   * @param pi The Pi extension
-   */
-  async run(args: string, ctx: ExtensionCommandContext) {
-    if (!(await isServerReady())) {
-      return await notFoundCommand(ctx);
-    }
-
-    // Refresh the model list from the server
-    await this.update();
-
-    // Command: `/models info`
-    if (args === "info") {
-      const info = await Promise.all(this.serverModels.map((m) => m.getInfo()));
-      const message = ctx.ui.theme.fg("accent", info.join("\n"));
-      ctx.ui.notify(message, "info");
-      return;
-    }
-
-    // Command: `/models unload`
-    if (args === "unload") {
-      await Promise.all(this.serverModels.map((m) => m.unload()));
-      ctx.ui.notify(`Unloaded all ${PROVIDER_NAME} models`, "info");
-      return;
-    }
-
-    // Command: `/models` (interactive menu)
-    return await modelsCommand(ctx, this.pi, this.serverModels);
-  }
-}

package/src/tools/resolver.ts

@@ -1,136 +0,0 @@
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { access, constants, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import {
-  API_KEY_PLACEHOLDER,
-  DEFAULT_LLAMA_SERVER_URL,
-  PROVIDER_ID,
-} from "../constants";
-import { AuthFile } from "../interfaces/auth";
-
-// The URL is detected once, to reuse forever
-let resolvedUrl: string | undefined;
-
-/**
- * Detects if a particular file is present
- * @param filePath The path
- * @returns True if exists
- */
-const fileExists = async (filePath: string): Promise<boolean> => {
-  try {
-    await access(filePath, constants.F_OK);
-    return true;
-  } catch (error) {
-    return false;
-  }
-};
-
-/**
- * Reads and parses the contents of a file as JSON
- * @param filePath The path to the file
- * @returns The parsed content, or null if parsing fails
- */
-const readContents = async <T>(filePath: string): Promise<T | null> => {
-  const raw = await readFile(filePath, "utf-8");
-
-  try {
-    const contents = JSON.parse(raw);
-    return contents;
-  } catch (err) {
-    return null;
-  }
-};
-
-/**
- * Reads a value from a JSON config file by key
- * @param filePath Path to the JSON config file
- * @param key Key to extract from the parsed JSON
- * @returns The value at the given key, or null if file/key missing or invalid
- */
-const readConfigValue = async <T>(
-  filePath: string,
-  key: keyof T,
-): Promise<T[keyof T] | null> => {
-  const cfg = await readContents<T>(filePath);
-  return cfg?.[key] ?? null;
-};
-
-/**
- * Reads API key from Pi's auth file
- * @returns The API key, as defined by the auth.json file
- */
-export const resolveApiKey = async (): Promise<string> => {
-  const authPath = join(getAgentDir(), "settings.json");
-  if (!(await fileExists(authPath))) return API_KEY_PLACEHOLDER;
-
-  const cfg = await readConfigValue<AuthFile>(authPath, PROVIDER_ID);
-  return cfg?.key ?? API_KEY_PLACEHOLDER;
-};
-
-/**
- * Resolves the llama-server url by searching for it in the global settings.json file
- * @returns The URL, if found.
- */
-const resolveGlobalUrl = async (): Promise<string | null> => {
-  const globalPath = join(getAgentDir(), "settings.json");
-  if (!(await fileExists(globalPath))) return null;
-
-  return readConfigValue<Record<string, string>>(globalPath, "llamaServerUrl");
-};
-
-/**
- * Resolves the llama-server url by searching for it in the project's .pi/llama-server.json file
- * @param cwd The current working directory
- * @returns The URL, if found.
- */
-const resolveProjectUrl = async (cwd: string): Promise<string | null> => {
-  const projectPath = join(cwd, ".pi", "llama-server.json");
-
-  if (!(await fileExists(projectPath))) return null;
-  return readConfigValue<Record<string, string>>(projectPath, "url");
-};
-
-/**
- * Resolves the llama-server url by searching for it in the environment
- * @returns The URL, if found.
- */
-const resolveEnvUrl = async (): Promise<string | null> => {
-  return process.env.LLAMA_SERVER_URL ?? null;
-};
-
-/**
- * Tries all possible ways to retrieve the llama-server URL
- * @param cwd The current working directory
- * @returns The URL, or a default if not found
- */
-const resolveUrlWithFallbacks = async (cwd: string): Promise<string> => {
-  // 1. per-project config
-  let response = await resolveProjectUrl(cwd);
-  if (response) return response;
-
-  // 2. env
-  response = await resolveEnvUrl();
-  if (response) return response;
-
-  // 3. global settings: ~/.pi/agent/settings.json
-  response = await resolveGlobalUrl();
-  if (response) return response;
-
-  // 4. default
-  return DEFAULT_LLAMA_SERVER_URL;
-};
-
-/**
- * Resolves the URL where llama-server is running
- * @param cwd The current working directory
- * @returns The URL, or a default if not found
- */
-export const resolveUrl = async (cwd: string): Promise<string> => {
-  if (resolvedUrl) return resolvedUrl;
-  const result = await resolveUrlWithFallbacks(cwd);
-
-  // Strip trailing slashes
-  resolvedUrl = result.replace(/\/+$/, "");
-
-  return resolvedUrl;
-};

package/src/tools/retriever.ts

@@ -1,71 +0,0 @@
-import { HealthEndpoint } from "../interfaces/endpoints/health";
-import { ModelsEndpoint } from "../interfaces/endpoints/models";
-import { BaseModel } from "../models/baseModel";
-import { RouterModel } from "../models/routerModel";
-import { SingleModel } from "../models/singleModel";
-import { resolveApiKey, resolveUrl } from "./resolver";
-
-/**
- * Detects if the server is ready
- * @returns True if it's ready to work
- */
-export const isServerReady = async (): Promise<boolean> => {
-  try {
-    const { status } = await rpc<HealthEndpoint>("/health");
-    return status === "ok";
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Makes an HTTP request to the llama-server and returns the parsed JSON response
- *
- * @param endpoint The endpoint path to fetch (e.g. "/health")
- * @param body The optional request body for POST requests
- * @returns The parsed JSON response from the server
- */
-export const rpc = async <T>(
-  endpoint: string,
-  body?: Record<string, unknown>,
-): Promise<T> => {
-  const base = await resolveUrl(process.cwd());
-  const url = `${base}${endpoint}`;
-
-  const data = {
-    method: body ? "POST" : "GET",
-    headers: body ? { "Content-Type": "application/json" } : undefined,
-    body: body ? JSON.stringify(body) : undefined,
-  };
-
-  const apiKey = await resolveApiKey();
-  const res = await fetch(url, {
-    ...data,
-    headers: {
-      ...data.headers,
-      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-    },
-  });
-
-  const response: T = await res.json();
-  return response;
-};
-
-/**
- * Retrieves a list of available models from llama-server
- * @param base Base URL to use
- * @returns The list of models
- */
-export const listModels = async (): Promise<BaseModel[]> => {
-  const { models, data } = await rpc<ModelsEndpoint>("/models");
-
-  if (models) {
-    return data.map((m) => new SingleModel(m));
-  }
-
-  const response = data
-    .map((m) => new RouterModel(m))
-    .sort((a, b) => (a.id > b.id ? 1 : a.id === b.id ? 0 : -1));
-
-  return response;
-};