@selesai/code 0.13.13 → 0.13.14

package/dist/core/llama/huggingface.js

@@ -0,0 +1,140 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DEFAULT_HUGGING_FACE_URL = "https://huggingface.co";
+const QUANTIZATION_PATTERN = /(?:^|[-_.])((?:UD-)?(?:IQ\d(?:_[A-Z0-9]+)+|Q\d(?:_[A-Z0-9]+)+|BF16|F16|F32|MXFP\d(?:_[A-Z0-9]+)*))$/iu;
+const SHARD_SUFFIX_PATTERN = /-\d{5}-of-\d{5}$/u;
+function payloadError(payload, fallback) {
+    if (typeof payload !== "object" || payload === null)
+        return fallback;
+    const error = payload.error;
+    return typeof error === "string" && error ? error : fallback;
+}
+function parseRateLimitDelay(value) {
+    const match = value?.match(/(?:^|;)t=(\d+)/u);
+    return match ? Number(match[1]) : undefined;
+}
+async function readToken(path) {
+    try {
+        const token = (await readFile(path, "utf8")).trim();
+        return token || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function findHuggingFaceToken(env = process.env) {
+    const fromEnvironment = env.HF_TOKEN?.trim();
+    if (fromEnvironment)
+        return fromEnvironment;
+    const paths = [
+        env.HF_TOKEN_PATH,
+        env.HF_HOME ? join(env.HF_HOME, "token") : undefined,
+        env.XDG_CACHE_HOME ? join(env.XDG_CACHE_HOME, "huggingface", "token") : undefined,
+        join(homedir(), ".cache", "huggingface", "token"),
+    ].filter((path) => Boolean(path));
+    for (const path of new Set(paths)) {
+        const token = await readToken(path);
+        if (token)
+            return token;
+    }
+    return undefined;
+}
+export class HuggingFaceClient {
+    token;
+    baseUrl;
+    constructor(token, baseUrl = DEFAULT_HUGGING_FACE_URL) {
+        this.token = token;
+        this.baseUrl = baseUrl.replace(/\/+$/u, "");
+    }
+    async request(path, signal) {
+        const headers = new Headers();
+        if (this.token)
+            headers.set("Authorization", `Bearer ${this.token}`);
+        const timeout = AbortSignal.timeout(15_000);
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            headers,
+            signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+        });
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            payload = undefined;
+        }
+        if (!response.ok) {
+            const fallback = `Hugging Face returned HTTP ${response.status}`;
+            if (response.status === 429) {
+                const delay = Number(response.headers.get("retry-after")) || parseRateLimitDelay(response.headers.get("ratelimit"));
+                throw new Error(delay ? `Hugging Face rate limit reached; retry in ${delay}s` : "Hugging Face rate limit reached");
+            }
+            throw new Error(payloadError(payload, fallback));
+        }
+        return payload;
+    }
+    async search(query, signal) {
+        const params = new URLSearchParams({
+            search: query,
+            filter: "gguf",
+            sort: "downloads",
+            direction: "-1",
+            limit: "20",
+        });
+        const payload = await this.request(`/api/models?${params}`, signal);
+        if (!Array.isArray(payload))
+            throw new Error("Hugging Face returned invalid search results");
+        return payload.flatMap((value) => {
+            if (typeof value !== "object" || value === null || typeof value.id !== "string")
+                return [];
+            const model = value;
+            return [{ id: model.id, downloads: typeof model.downloads === "number" ? model.downloads : 0 }];
+        });
+    }
+    async details(id, signal) {
+        const encodedId = id.split("/").map(encodeURIComponent).join("/");
+        const payload = await this.request(`/api/models/${encodedId}?blobs=true`, signal);
+        if (typeof payload !== "object" || payload === null) {
+            throw new Error("Hugging Face returned invalid model details");
+        }
+        const model = payload;
+        const sizes = new Map();
+        if (Array.isArray(model.siblings)) {
+            for (const value of model.siblings) {
+                if (typeof value !== "object" || value === null)
+                    continue;
+                const file = value;
+                if (typeof file.rfilename !== "string" || !file.rfilename.toLowerCase().endsWith(".gguf"))
+                    continue;
+                const filename = file.rfilename.split("/").at(-1);
+                if (filename.toLowerCase().startsWith("mmproj"))
+                    continue;
+                const stem = filename.slice(0, -5).replace(SHARD_SUFFIX_PATTERN, "");
+                const quantization = stem.match(QUANTIZATION_PATTERN)?.[1]?.toUpperCase();
+                if (!quantization)
+                    continue;
+                const current = sizes.get(quantization) ?? { total: 0, complete: true };
+                if (typeof file.size === "number")
+                    current.total += file.size;
+                else
+                    current.complete = false;
+                sizes.set(quantization, current);
+            }
+        }
+        const quantizations = [...sizes]
+            .map(([name, size]) => ({ name, size: size.complete ? size.total : undefined }))
+            .sort((left, right) => {
+            if (left.name === "Q4_K_M")
+                return -1;
+            if (right.name === "Q4_K_M")
+                return 1;
+            return ((left.size ?? Number.MAX_SAFE_INTEGER) - (right.size ?? Number.MAX_SAFE_INTEGER) ||
+                left.name.localeCompare(right.name));
+        });
+        return {
+            id: typeof model.id === "string" ? model.id : id,
+            gated: model.gated === "auto" || model.gated === "manual" ? model.gated : false,
+            quantizations,
+        };
+    }
+}

package/dist/core/llama/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "../../core/extensions/types.ts";
+export default function llamaExtension(pi: ExtensionAPI): void;

package/dist/core/llama/index.js

@@ -0,0 +1,207 @@
+import { formatBytes, LlamaClient, normalizeLlamaServerUrl } from "./client.js";
+import { findHuggingFaceToken, HuggingFaceClient } from "./huggingface.js";
+import { createLlamaProvider, LLAMA_PROVIDER_ID } from "./provider.js";
+import { runWithProgress, showLlamaUi } from "./ui.js";
+function modelIsLoaded(model) {
+    return model.status.value === "loaded" || model.status.value === "sleeping";
+}
+function isConnectionError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = `${error.name} ${error.message}`.toLowerCase();
+    return message.includes("fetch failed") || message.includes("timeout") || message.includes("network");
+}
+function connectionErrorMessage(error) {
+    if (isConnectionError(error))
+        return "Could not connect to the server.";
+    return error instanceof Error ? error.message : String(error);
+}
+function parseHuggingFaceModel(value) {
+    const colon = value.indexOf(":", value.indexOf("/") + 1);
+    return colon < 0
+        ? { repository: value }
+        : { repository: value.slice(0, colon), quantization: value.slice(colon + 1) };
+}
+async function configuredClient(ctx) {
+    const result = await ctx.modelRegistry.getProviderAuth(LLAMA_PROVIDER_ID);
+    if (!result) {
+        ctx.ui.notify(`Configure llama.cpp with /login ${LLAMA_PROVIDER_ID}`, "warning");
+        return undefined;
+    }
+    const configuredUrl = result.env?.LLAMA_BASE_URL;
+    const serverUrl = normalizeLlamaServerUrl(typeof configuredUrl === "string" && configuredUrl ? configuredUrl : (result.auth.baseUrl ?? ""));
+    return new LlamaClient(serverUrl, result.auth.apiKey);
+}
+export default function llamaExtension(pi) {
+    const provider = createLlamaProvider();
+    pi.registerProvider(provider.provider);
+    const syncCatalog = async (ctx, client, catalog) => {
+        const current = catalog ?? (await client.list());
+        provider.setCatalog(current, client.serverUrl);
+        await ctx.modelRegistry.refresh();
+        return current;
+    };
+    const loadModel = async (ctx, ui, client, catalog, target) => {
+        const loaded = catalog.filter((model) => model.id !== target.id && modelIsLoaded(model));
+        let replace = false;
+        if (loaded.length > 0) {
+            const choice = await ui.select(`${loaded.length} model${loaded.length === 1 ? " is" : "s are"} loaded`, [
+                "Unload all and load",
+                "Keep loaded and load",
+                "Cancel",
+            ]);
+            if (!choice || choice === "Cancel")
+                return;
+            replace = choice === "Unload all and load";
+        }
+        const restoreLoaded = async () => {
+            ctx.ui.notify("Restoring previously loaded models");
+            for (const model of loaded)
+                await client.loadAndWait(model.id, () => { });
+            await syncCatalog(ctx, client);
+        };
+        if (replace) {
+            for (const model of loaded)
+                await client.unloadAndWait(model.id);
+        }
+        try {
+            const result = await runWithProgress(ui, {
+                title: "Loading model",
+                model: target.id,
+                initialMessage: "Starting…",
+                cancelTitle: "Stop loading?",
+                cancelMessage: target.id,
+                run: (signal, update) => client.loadAndWait(target.id, update, signal),
+                cancel: () => client.unload(target.id),
+            });
+            if (result.cancelled) {
+                if (replace)
+                    await restoreLoaded();
+                return;
+            }
+            const refreshed = await syncCatalog(ctx, client);
+            const loadedModel = refreshed.find((model) => model.id === target.id);
+            ctx.ui.notify(loadedModel?.status.value === "loaded" ? `Loaded ${target.id}` : `Load started for ${target.id}`);
+        }
+        catch (error) {
+            if (replace) {
+                try {
+                    await restoreLoaded();
+                }
+                catch {
+                    // Preserve the original load error.
+                }
+            }
+            throw error;
+        }
+    };
+    const unloadModel = async (ctx, ui, client, model) => {
+        if (!(await ui.confirm("Unload model?", model.id)))
+            return;
+        await client.unloadAndWait(model.id);
+        await syncCatalog(ctx, client);
+        ctx.ui.notify(`Unloaded ${model.id}`);
+    };
+    const downloadModel = async (ctx, ui, client) => {
+        const huggingFace = new HuggingFaceClient(await findHuggingFaceToken());
+        const selected = await ui.searchModels((query, signal) => huggingFace.search(query, signal));
+        if (!selected)
+            return;
+        const parsed = parseHuggingFaceModel(selected);
+        ui.showStatus("Loading model details", parsed.repository);
+        const details = await huggingFace.details(parsed.repository);
+        if (details.gated) {
+            const approval = details.gated === "manual" ? "Manual approval is required" : "Accept the access terms";
+            const choice = await ui.select(`Hugging Face access required\n${details.id}\n\n${approval} at:\nhttps://huggingface.co/${details.id}\n\nThe llama.cpp server needs HF_TOKEN with access.`, ["Continue", "Back"]);
+            if (choice !== "Continue")
+                return;
+        }
+        let quantization = parsed.quantization;
+        if (!quantization && details.quantizations.length > 0) {
+            const options = details.quantizations.map((entry) => {
+                const detail = [
+                    entry.size === undefined ? undefined : formatBytes(entry.size),
+                    entry.name === "Q4_K_M" ? "recommended" : undefined,
+                ]
+                    .filter((value) => Boolean(value))
+                    .join(" · ");
+                return detail ? `${entry.name} · ${detail}` : entry.name;
+            });
+            const choice = await ui.select(`Select quantization\n${details.id}`, options);
+            if (!choice)
+                return;
+            quantization = details.quantizations[options.indexOf(choice)]?.name;
+            if (!quantization)
+                return;
+        }
+        const model = quantization ? `${details.id}:${quantization}` : details.id;
+        const result = await runWithProgress(ui, {
+            title: "Downloading model",
+            model,
+            initialMessage: "Starting…",
+            cancelTitle: "Stop download?",
+            cancelMessage: model,
+            run: (signal, update) => client.downloadAndWait(model, update, signal),
+            cancel: () => client.unload(model),
+        });
+        if (result.cancelled)
+            return;
+        await syncCatalog(ctx, client, result.value);
+        ctx.ui.notify(`Downloaded ${model}`);
+    };
+    pi.registerCommand("llama", {
+        description: "Manage llama.cpp router models",
+        handler: async (_args, ctx) => {
+            if (ctx.mode !== "tui") {
+                ctx.ui.notify("/llama is available in interactive mode", "warning");
+                return;
+            }
+            const client = await configuredClient(ctx);
+            if (!client)
+                return;
+            await showLlamaUi(ctx, async (ui) => {
+                const readCatalog = async () => {
+                    while (true) {
+                        try {
+                            return await syncCatalog(ctx, client);
+                        }
+                        catch (error) {
+                            if ((await ui.connectionError(client.serverUrl, connectionErrorMessage(error))) === "close") {
+                                return undefined;
+                            }
+                        }
+                    }
+                };
+                let catalog = await readCatalog();
+                if (!catalog)
+                    return;
+                while (true) {
+                    const action = await ui.showModels(client.serverUrl, catalog);
+                    if (action.type === "close")
+                        return;
+                    let actionError;
+                    try {
+                        if (action.type === "download")
+                            await downloadModel(ctx, ui, client);
+                        else if (modelIsLoaded(action.model))
+                            await unloadModel(ctx, ui, client, action.model);
+                        else if (action.model.status.value === "unloaded")
+                            await loadModel(ctx, ui, client, catalog, action.model);
+                        else
+                            ctx.ui.notify(`${action.model.id} is ${action.model.status.value}`, "warning");
+                    }
+                    catch (error) {
+                        actionError = error;
+                    }
+                    const refreshed = await readCatalog();
+                    if (!refreshed)
+                        return;
+                    catalog = refreshed;
+                    if (actionError && !isConnectionError(actionError)) {
+                        ctx.ui.notify(actionError instanceof Error ? actionError.message : String(actionError), "error");
+                    }
+                }
+            });
+        },
+    });
+}

package/dist/core/llama/provider.d.ts

@@ -0,0 +1,11 @@
+import type { Provider } from "@earendil-works/pi-ai";
+import { type LlamaModelInfo } from "./client.ts";
+export declare const LLAMA_PROVIDER_ID = "llama.cpp";
+export declare const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
+export interface LlamaProviderController {
+    provider: Provider<"openai-completions">;
+    setCatalog(models: readonly LlamaModelInfo[], serverUrl: string, options?: {
+        routerAutoload?: boolean;
+    }): void;
+}
+export declare function createLlamaProvider(): LlamaProviderController;

package/dist/core/llama/provider.js

@@ -0,0 +1,143 @@
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import { LlamaClient, llamaInferenceUrl, normalizeLlamaServerUrl } from "./client.js";
+export const LLAMA_PROVIDER_ID = "llama.cpp";
+export const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
+function credentialServerUrl(credential) {
+    const value = credential?.env?.LLAMA_BASE_URL;
+    return typeof value === "string" && value.trim() ? normalizeLlamaServerUrl(value) : undefined;
+}
+async function resolveServerUrl(ctx, credential) {
+    const configured = credentialServerUrl(credential) ?? (await ctx.env("LLAMA_BASE_URL"))?.trim();
+    return configured ? normalizeLlamaServerUrl(configured) : undefined;
+}
+function modelIsSelectable(model, routerAutoload) {
+    if (model.status.value === "loaded")
+        return true;
+    // Unloaded presets are routable only when llama.cpp router autoload can load them on first use.
+    return routerAutoload && model.status.value === "unloaded" && !model.status.failed && model.source === "preset";
+}
+async function routerAutoloadEnabled(client, catalog, signal) {
+    if (!catalog.some((model) => model.status.value === "unloaded" && model.source === "preset"))
+        return false;
+    try {
+        return (await client.props({ signal })).models_autoload === true;
+    }
+    catch {
+        return false;
+    }
+}
+function toPiModel(model, serverUrl) {
+    const reportedContextWindow = model.meta?.n_ctx ?? model.meta?.n_ctx_train;
+    const contextWindow = reportedContextWindow && reportedContextWindow > 0 ? reportedContextWindow : 128000;
+    return {
+        id: model.id,
+        name: model.id,
+        api: "openai-completions",
+        provider: LLAMA_PROVIDER_ID,
+        baseUrl: llamaInferenceUrl(serverUrl),
+        reasoning: false,
+        input: model.architecture?.input_modalities?.includes("image") ? ["text", "image"] : ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow,
+        maxTokens: contextWindow,
+        compat: {
+            supportsStore: false,
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: false,
+            supportsUsageInStreaming: true,
+            supportsStrictMode: false,
+            maxTokensField: "max_tokens",
+        },
+    };
+}
+export function createLlamaProvider() {
+    let models = [];
+    const setCatalog = (catalog, serverUrl, options = {}) => {
+        models = catalog
+            .filter((model) => modelIsSelectable(model, options.routerAutoload === true))
+            .map((model) => toPiModel(model, serverUrl));
+    };
+    const provider = {
+        id: LLAMA_PROVIDER_ID,
+        name: "llama.cpp",
+        baseUrl: llamaInferenceUrl(DEFAULT_LLAMA_SERVER_URL),
+        auth: {
+            apiKey: {
+                name: "llama.cpp server",
+                login: async (interaction) => {
+                    const enteredUrl = await interaction.prompt({
+                        type: "text",
+                        message: "llama.cpp server URL",
+                        placeholder: process.env.LLAMA_BASE_URL ?? DEFAULT_LLAMA_SERVER_URL,
+                    });
+                    const serverUrl = normalizeLlamaServerUrl(enteredUrl.trim() || process.env.LLAMA_BASE_URL || DEFAULT_LLAMA_SERVER_URL);
+                    const apiKey = (await interaction.prompt({
+                        type: "secret",
+                        message: "API key (optional)",
+                    })).trim();
+                    await new LlamaClient(serverUrl, apiKey || undefined).list({ signal: interaction.signal });
+                    return {
+                        type: "api_key",
+                        key: apiKey || undefined,
+                        env: { LLAMA_BASE_URL: serverUrl },
+                    };
+                },
+                check: async ({ ctx, credential }) => {
+                    const serverUrl = await resolveServerUrl(ctx, credential);
+                    return serverUrl
+                        ? { type: "api_key", source: credential ? "stored credential" : "LLAMA_BASE_URL" }
+                        : undefined;
+                },
+                resolve: async ({ ctx, credential }) => {
+                    const serverUrl = await resolveServerUrl(ctx, credential);
+                    if (!serverUrl)
+                        return undefined;
+                    const apiKey = credential?.key ?? (await ctx.env("LLAMA_API_KEY")) ?? "local";
+                    return {
+                        auth: { apiKey, baseUrl: llamaInferenceUrl(serverUrl) },
+                        env: { ...credential?.env, LLAMA_BASE_URL: serverUrl },
+                        source: credential ? "stored credential" : "LLAMA_BASE_URL",
+                    };
+                },
+            },
+        },
+        getModels: () => models,
+        refreshModels: async (context) => {
+            const stored = context.stored;
+            const restored = stored
+                ? stored.models.filter((model) => model.provider === LLAMA_PROVIDER_ID && model.api === "openai-completions")
+                : [];
+            if (!(await context.publish({
+                update: () => {
+                    models = restored;
+                },
+            }))) {
+                return;
+            }
+            if (!context.allowNetwork || context.signal.aborted || context.credential?.type !== "api_key")
+                return;
+            const serverUrl = credentialServerUrl(context.credential);
+            if (!serverUrl)
+                return;
+            const client = new LlamaClient(serverUrl, context.credential.key);
+            const catalog = await client.list({ signal: context.signal });
+            if (context.signal.aborted)
+                return;
+            const routerAutoload = await routerAutoloadEnabled(client, catalog, context.signal);
+            if (context.signal.aborted)
+                return;
+            const refreshed = catalog
+                .filter((model) => modelIsSelectable(model, routerAutoload))
+                .map((model) => toPiModel(model, serverUrl));
+            await context.publish({
+                persist: { models: refreshed, checkedAt: Date.now() },
+                update: () => {
+                    models = refreshed;
+                },
+            });
+        },
+        stream: (model, context, options) => stream(model, context, options),
+        streamSimple: (model, context, options) => streamSimple(model, context, options),
+    };
+    return { provider, setCatalog };
+}

package/dist/core/llama/ui.d.ts

@@ -0,0 +1,41 @@
+import type { ExtensionCommandContext } from "../../core/extensions/types.ts";
+import type { LlamaModelInfo, LlamaProgress } from "./client.ts";
+import type { HuggingFaceModel } from "./huggingface.ts";
+export type LlamaManagerAction = {
+    type: "model";
+    model: LlamaModelInfo;
+} | {
+    type: "download";
+} | {
+    type: "close";
+};
+interface ProgressState extends LlamaProgress {
+    title: string;
+    model: string;
+}
+export interface LlamaUi {
+    showModels(serverUrl: string, models: LlamaModelInfo[]): Promise<LlamaManagerAction>;
+    select(title: string, options: string[]): Promise<string | undefined>;
+    confirm(title: string, message: string): Promise<boolean>;
+    connectionError(serverUrl: string, message: string): Promise<"retry" | "close">;
+    searchModels(search: (query: string, signal: AbortSignal) => Promise<HuggingFaceModel[]>): Promise<string | undefined>;
+    showStatus(title: string, message: string): void;
+    progress(state: ProgressState): Promise<void>;
+    updateProgress(state: ProgressState): void;
+}
+export declare function showLlamaUi(ctx: ExtensionCommandContext, run: (ui: LlamaUi) => Promise<void>): Promise<void>;
+export declare function runWithProgress<T>(ui: LlamaUi, options: {
+    title: string;
+    model: string;
+    initialMessage: string;
+    cancelTitle: string;
+    cancelMessage: string;
+    run(signal: AbortSignal, update: (progress: LlamaProgress) => void): Promise<T>;
+    cancel(): Promise<void>;
+}): Promise<{
+    cancelled: true;
+} | {
+    cancelled: false;
+    value: T;
+}>;
+export {};