localpi 0.1.0

package/dist/src/localpi/provider-registry.js

@@ -0,0 +1,121 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { asObject, optionalString } from "../common/json.js";
+import { normalizeBaseUrl } from "../llm/openai.js";
+import { llamaBaseUrl } from "./llama-server.js";
+export async function providerConfigs(options) {
+    switch (options.runtime) {
+        case "auto":
+            return autoProviderConfigs(options, await configuredProviderConfigs(options));
+        case "lmstudio":
+            return [lmStudioProvider(options.baseUrl)];
+        case "vllm":
+            return [vllmProvider(options.baseUrl)];
+        case "openai-compatible": {
+            const providerId = options.provider ?? options.customProviderId;
+            return [
+                {
+                    id: providerId,
+                    name: providerId,
+                    type: "openai-compatible",
+                    baseUrl: requiredBaseUrl(options),
+                    discover: true
+                }
+            ];
+        }
+        case "llama-server":
+            return [managedLlamaProvider()];
+    }
+}
+function autoProviderConfigs(options, configured) {
+    const managedBaseUrl = llamaBaseUrl(options);
+    return dedupeProviderConfigs([
+        lmStudioProvider(),
+        vllmProvider(),
+        ...configured,
+        managedLlamaProvider()
+    ]).filter((config) => shouldProbeProvider(config, managedBaseUrl));
+}
+function shouldProbeProvider(config, managedBaseUrl) {
+    return (config.type === "managed-llama-server" ||
+        config.baseUrl === undefined ||
+        normalizeBaseUrl(config.baseUrl) !== managedBaseUrl);
+}
+function lmStudioProvider(baseUrl = "http://127.0.0.1:1234/v1") {
+    return {
+        id: "lmstudio",
+        name: "LM Studio",
+        type: "openai-compatible",
+        baseUrl: normalizeBaseUrl(baseUrl),
+        discover: true
+    };
+}
+function vllmProvider(baseUrl = "http://127.0.0.1:8000/v1") {
+    return {
+        id: "vllm",
+        name: "vLLM",
+        type: "openai-compatible",
+        baseUrl: normalizeBaseUrl(baseUrl),
+        discover: true
+    };
+}
+function managedLlamaProvider() {
+    return {
+        id: "llama-server",
+        name: "llama-server",
+        type: "managed-llama-server",
+        discover: true
+    };
+}
+async function configuredProviderConfigs(options) {
+    const configPath = configuredProvidersPath(options);
+    if (configPath === undefined) {
+        return [];
+    }
+    const raw = await readFile(expandHome(configPath), "utf8");
+    const root = asObject(JSON.parse(raw), "provider registry");
+    const providers = root["providers"];
+    if (providers === undefined) {
+        return [];
+    }
+    return Object.entries(asObject(providers, "provider registry providers")).map(([id, value]) => configuredProvider(id, value));
+}
+function configuredProvider(id, value) {
+    const entry = asObject(value, `provider ${id}`);
+    const type = optionalString(entry["type"]);
+    if (type !== "openai-compatible") {
+        throw new Error(`provider ${id} type must be openai-compatible`);
+    }
+    const baseUrl = optionalString(entry["baseUrl"]);
+    if (baseUrl === undefined) {
+        throw new Error(`provider ${id} must define baseUrl`);
+    }
+    return {
+        id,
+        name: optionalString(entry["name"]) ?? id,
+        type,
+        baseUrl: normalizeBaseUrl(baseUrl),
+        discover: entry["discover"] !== false
+    };
+}
+function configuredProvidersPath(options) {
+    return options.providersFile ?? process.env["LOCALPI_MODELS_FILE"];
+}
+function dedupeProviderConfigs(configs) {
+    const byId = new Map();
+    for (const config of configs) {
+        byId.set(config.id, config);
+    }
+    return [...byId.values()];
+}
+function requiredBaseUrl(options) {
+    if (options.baseUrl === undefined) {
+        throw new Error("--runtime openai-compatible requires --base-url");
+    }
+    return options.baseUrl;
+}
+function expandHome(value) {
+    const home = os.homedir();
+    return value === "~" || value.startsWith("~/") ? path.join(home, value.slice(2)) : value;
+}

package/dist/src/localpi/runtime-connection.js

@@ -0,0 +1,75 @@
+import { managedModelSupportsReasoning } from "./catalog.js";
+export function connectionStatus(connection) {
+    return ([
+        `runtime: ${connection.runtime}`,
+        `provider: ${connection.providerId}`,
+        `base url: ${connection.baseUrl}`,
+        `model: ${connection.model}`,
+        `available models: ${connection.availableModels.join(", ")}`,
+        `context window: ${String(connection.contextWindow ?? "unspecified")}`,
+        ...connection.warnings.map((warning) => `warning: ${warning}`)
+    ].join("\n") + "\n");
+}
+export function statusModelList(models) {
+    return models.length === 0
+        ? "none"
+        : models.map((model) => `${model.providerId}/${model.modelId}`).join(", ");
+}
+export function catalogRuntimeConnection(options, selected, catalog) {
+    const providerModels = catalog.models.filter((model) => model.providerId === selected.providerId && model.availability === "loaded");
+    return {
+        runtime: connectionRuntimeName(selected),
+        providerId: selected.providerId,
+        providerName: selected.providerName,
+        baseUrl: selected.baseUrl,
+        model: selected.modelId,
+        availableModels: providerModels.map((model) => model.modelId),
+        catalogModels: catalog.models.filter((model) => model.availability === "loaded"),
+        warnings: catalog.warnings,
+        ...optionalContextWindow(options.contextWindow ?? selected.contextWindow)
+    };
+}
+export function catalogModelFromModelInfo(providerId, providerName, runtime, baseUrl, model, options, contextWindow) {
+    return {
+        providerId,
+        providerName,
+        runtime,
+        baseUrl,
+        modelId: model.id,
+        aliases: [],
+        displayName: `${providerName} / ${model.id}`,
+        maxTokens: options.maxTokens,
+        ...(runtime === "managed-llama-server"
+            ? { reasoning: managedModelSupportsReasoning(model.id) }
+            : {}),
+        capabilities: ["text"],
+        availability: "loaded",
+        ...optionalContextWindow(contextWindow ?? model.contextWindow)
+    };
+}
+export function connectionCatalogModels(providerId, providerName, runtime, baseUrl, modelIds, options, contextWindow) {
+    return modelIds.map((modelId) => catalogModelFromModelInfo(providerId, providerName, runtime, baseUrl, contextWindow === undefined ? { id: modelId } : { id: modelId, contextWindow }, options, contextWindow));
+}
+export function replaceManagedLoadedModels(models, selected, loaded) {
+    return [
+        ...models.filter((model) => model !== selected &&
+            !(model.providerId === "llama-server" && model.availability === "loaded")),
+        ...loaded
+    ];
+}
+export function modelChoiceList(models) {
+    return models
+        .map((model) => `  ${model.providerId}/${model.modelId} (${model.displayName})`)
+        .join("\n");
+}
+export function optionalContextWindow(contextWindow) {
+    return contextWindow === undefined ? {} : { contextWindow };
+}
+function connectionRuntimeName(selected) {
+    if (selected.runtime === "managed-llama-server") {
+        return "llama-server";
+    }
+    return selected.providerId === "lmstudio" || selected.providerId === "vllm"
+        ? selected.providerId
+        : selected.runtime;
+}

package/dist/src/localpi/runtime-selection.js

@@ -0,0 +1,75 @@
+import { customPathCatalogModel } from "./managed-runtime.js";
+import { defaultLlamaModelName } from "./models.js";
+import { modelChoiceList } from "./runtime-connection.js";
+export async function selectCatalogModel(options, catalog) {
+    const selection = normalizedSelection(options, catalog.models);
+    const providerFiltered = modelsForProvider(catalog.models, selection.provider);
+    if (providerFiltered.length === 0) {
+        const customPath = await customPathCatalogModel(options, selection.provider, selection.model);
+        if (customPath !== undefined) {
+            return customPath;
+        }
+        if (selection.provider !== undefined) {
+            throw new Error(`provider ${selection.provider} did not report usable models`);
+        }
+    }
+    if (selection.model !== "auto") {
+        return selectExplicitCatalogModel(options, providerFiltered, selection.provider, selection.model);
+    }
+    return selectAutomaticCatalogModel(providerFiltered, catalog.warnings);
+}
+async function selectExplicitCatalogModel(options, models, provider, requested) {
+    const matches = matchingCatalogModels(models, requested);
+    const [onlyMatch] = matches;
+    if (onlyMatch !== undefined && matches.length === 1) {
+        return onlyMatch;
+    }
+    if (matches.length > 1) {
+        throw new Error(`model ${requested} is available from multiple providers; choose one with --provider:\n${modelChoiceList(matches)}`);
+    }
+    const customPath = await customPathCatalogModel(options, provider, requested);
+    if (customPath !== undefined) {
+        return customPath;
+    }
+    throw new Error(`model ${requested} is not available; choices:\n${modelChoiceList(models)}`);
+}
+function selectAutomaticCatalogModel(models, warnings) {
+    const loaded = models.filter((model) => model.availability === "loaded");
+    const [onlyLoaded] = loaded;
+    if (onlyLoaded !== undefined) {
+        return onlyLoaded;
+    }
+    const fallback = startableFallback(models);
+    if (fallback !== undefined) {
+        return fallback;
+    }
+    throw new Error(`no loaded models available${warnings.length === 0 ? "" : `; ${warnings.join("; ")}`}`);
+}
+function modelsForProvider(models, provider) {
+    return provider === undefined ? models : models.filter((model) => model.providerId === provider);
+}
+function normalizedSelection(options, models) {
+    const requested = options.model ?? "auto";
+    if (options.provider !== undefined || requested === "auto" || isGgufFilePathRequest(requested)) {
+        return { provider: options.provider, model: requested };
+    }
+    const separator = requested.indexOf("/");
+    if (separator <= 0) {
+        return { provider: options.provider, model: requested };
+    }
+    const provider = requested.slice(0, separator);
+    if (!models.some((model) => model.providerId === provider)) {
+        return { provider: options.provider, model: requested };
+    }
+    return { provider, model: requested.slice(separator + 1) };
+}
+function matchingCatalogModels(models, requested) {
+    return models.filter((model) => model.modelId === requested || model.aliases.includes(requested));
+}
+function isGgufFilePathRequest(value) {
+    return value.toLowerCase().endsWith(".gguf") || value.includes("\\");
+}
+function startableFallback(models) {
+    const startable = models.filter((model) => model.availability === "startable");
+    return (startable.find((model) => model.aliases.includes(defaultLlamaModelName()) || model.modelId === defaultLlamaModelName()) ?? startable[0]);
+}

package/dist/src/localpi/runtime-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/localpi/runtime.js

@@ -0,0 +1,89 @@
+import { discoverModelCatalog } from "./catalog.js";
+import { llamaBaseUrl, llamaServerStatus, stopManagedLlamaServer } from "./llama-server.js";
+import { listModelAliases } from "./models.js";
+import { catalogRuntimeConnection, connectionStatus, statusModelList } from "./runtime-connection.js";
+import { resolveLlamaRuntime, resolveSelectedLlamaRuntime } from "./managed-runtime.js";
+import { selectCatalogModel } from "./runtime-selection.js";
+export { connectionStatus } from "./runtime-connection.js";
+export async function resolveRuntime(options) {
+    if (options.runtime === "auto") {
+        return resolveCatalogRuntime(options);
+    }
+    switch (options.runtime) {
+        case "llama-server":
+            return resolveLlamaRuntime(options);
+        case "lmstudio":
+            return resolveCatalogRuntime(options);
+        case "vllm":
+            return resolveCatalogRuntime(options);
+        case "openai-compatible":
+            return resolveCatalogRuntime(options);
+    }
+}
+export async function stopRuntime(options) {
+    if (options.runtime === "lmstudio" ||
+        options.runtime === "vllm" ||
+        options.runtime === "openai-compatible") {
+        return `runtime ${options.runtime} is externally managed; nothing stopped`;
+    }
+    return stopManagedLlamaServer(options);
+}
+export async function statusOutput(options) {
+    if (options.runtime === "llama-server") {
+        return `${await llamaServerStatus(options)}\n${await aliasListOutput()}`;
+    }
+    if (statusShouldUseCatalog(options)) {
+        return catalogStatusOutput(options);
+    }
+    const connection = await resolveRuntime(options);
+    return connectionStatus(connection);
+}
+export async function aliasListOutput() {
+    const aliases = await listModelAliases();
+    return aliases
+        .map((alias) => {
+        const context = alias.contextWindow === undefined ? "" : ` ctx=${String(alias.contextWindow)}`;
+        return `${alias.name}: id=${alias.id}${context}\n  ${alias.paths.join("\n  ")}`;
+    })
+        .join("\n");
+}
+export function effectiveBaseUrl(options) {
+    if (options.runtime === "llama-server") {
+        return llamaBaseUrl(options);
+    }
+    if (options.runtime === "openai-compatible") {
+        return requiredOpenAiBaseUrl(options);
+    }
+    return options.baseUrl ?? defaultExternalBaseUrl(options.runtime);
+}
+async function resolveCatalogRuntime(options) {
+    const catalog = await discoverModelCatalog(options);
+    const selected = await selectCatalogModel(options, catalog);
+    if (selected.runtime === "managed-llama-server") {
+        return resolveSelectedLlamaRuntime(options, selected, catalog);
+    }
+    return catalogRuntimeConnection(options, selected, catalog);
+}
+function statusShouldUseCatalog(options) {
+    return options.runtime === "auto" || options.model === undefined || options.model === "auto";
+}
+async function catalogStatusOutput(options) {
+    const catalog = await discoverModelCatalog(options);
+    const loaded = catalog.models.filter((model) => model.availability === "loaded");
+    const startable = catalog.models.filter((model) => model.availability === "startable");
+    return ([
+        `runtime: ${options.runtime}`,
+        `loaded models: ${statusModelList(loaded)}`,
+        `startable models: ${statusModelList(startable)}`,
+        ...catalog.warnings.map((warning) => `warning: ${warning}`)
+    ].join("\n") + "\n");
+}
+function requiredOpenAiBaseUrl(options) {
+    if (options.baseUrl === undefined) {
+        throw new Error("--runtime openai-compatible requires --base-url");
+    }
+    return options.baseUrl;
+}
+function defaultExternalBaseUrl(runtime) {
+    return runtime === "vllm" ? "http://127.0.0.1:8000/v1" : "http://127.0.0.1:1234/v1";
+}

package/dist/src/pi/config.js

@@ -0,0 +1,108 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function writeRuntimeConfig(options, connection) {
+    const configDir = path.join(options.stateDir, "pi-config-runtime");
+    await mkdir(configDir, { recursive: true });
+    const modelsPath = path.join(configDir, "models.json");
+    const settingsPath = path.join(configDir, "settings.json");
+    await writeFile(modelsPath, `${JSON.stringify(modelsConfig(options, connection), null, 2)}\n`);
+    await writeFile(settingsPath, `${JSON.stringify(settingsConfig(options, connection), null, 2)}\n`);
+    return { configDir, modelsPath, settingsPath };
+}
+function modelsConfig(options, connection) {
+    const models = connection.catalogModels.length === 0 ? fallbackCatalog(connection) : connection.catalogModels;
+    return {
+        providers: Object.fromEntries(groupedByProvider(models).map((entry) => [
+            entry.providerId,
+            providerConfig(options, connection, entry)
+        ]))
+    };
+}
+function groupedByProvider(models) {
+    const groups = new Map();
+    for (const model of models) {
+        const existing = groups.get(model.providerId);
+        groups.set(model.providerId, existing === undefined
+            ? { providerId: model.providerId, baseUrl: model.baseUrl, models: [model] }
+            : { ...existing, models: [...existing.models, model] });
+    }
+    return [...groups.values()];
+}
+function providerConfig(options, connection, group) {
+    return {
+        baseUrl: group.baseUrl,
+        api: "openai-completions",
+        apiKey: "local",
+        compat: {
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: false
+        },
+        models: group.models.map((model) => modelConfig(options, connection, model))
+    };
+}
+function modelConfig(options, connection, model) {
+    return withoutUndefined({
+        id: model.modelId,
+        name: model.displayName,
+        reasoning: model.reasoning ?? false,
+        compat: model.thinkingFormat === undefined ? undefined : { thinkingFormat: model.thinkingFormat },
+        input: ["text"],
+        contextWindow: modelContextWindow(options, model),
+        maxTokens: model.maxTokens ?? options.maxTokens,
+        cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0
+        }
+    });
+}
+function modelContextWindow(options, model) {
+    if (options.contextWindow !== undefined) {
+        return options.contextWindow;
+    }
+    return model.contextWindow;
+}
+function fallbackCatalog(connection) {
+    return [
+        {
+            providerId: connection.providerId,
+            providerName: connection.providerName,
+            runtime: connection.runtime.startsWith("llama-server")
+                ? "managed-llama-server"
+                : "openai-compatible",
+            baseUrl: connection.baseUrl,
+            modelId: connection.model,
+            aliases: [],
+            displayName: `Local model (${connection.model})`,
+            reasoning: false,
+            capabilities: ["text"],
+            availability: "loaded",
+            ...(connection.contextWindow === undefined ? {} : { contextWindow: connection.contextWindow })
+        }
+    ];
+}
+function withoutUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}
+function settingsConfig(options, connection) {
+    const contextWindow = options.contextWindow ?? connection.contextWindow;
+    return {
+        defaultProvider: connection.providerId,
+        defaultModel: connection.model,
+        defaultThinkingLevel: options.thinking,
+        enableInstallTelemetry: false,
+        quietStartup: true,
+        compaction: compactionConfig(contextWindow)
+    };
+}
+function compactionConfig(contextWindow) {
+    if (contextWindow === undefined) {
+        return { enabled: false };
+    }
+    return {
+        enabled: true,
+        reserveTokens: Math.max(256, Math.min(16384, Math.floor(contextWindow / 4))),
+        keepRecentTokens: Math.max(512, Math.min(20000, Math.floor(contextWindow / 2)))
+    };
+}