@caupulican/pi-adaptative 0.81.15 → 0.81.17

package/dist/core/models/local-runtime.js

@@ -1,8 +1,10 @@
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
+import { createWriteStream, existsSync, mkdirSync, rmSync } from "node:fs";
 import { homedir, arch as osArch, platform as osPlatform } from "node:os";
 import { delimiter, join } from "node:path";
+import { pipeline } from "node:stream/promises";
 import * as nodeZlib from "node:zlib";
+import { getBundledResourcesDir } from "../../config.js";
 import { spawnProcess, spawnProcessSync, waitForChildProcess } from "../../utils/child-process.js";
 /**
  * `spawnProcess(..., { stdio: ["pipe", "pipe", "pipe"] })` always yields a non-null `stdin` at
@@ -45,6 +47,65 @@ const DEFAULT_BASE_URL = "http://127.0.0.1:11434";
 const HEALTH_TIMEOUT_MS = 2_000;
 const START_POLL_ATTEMPTS = 20;
 const START_POLL_INTERVAL_MS = 500;
+const TRANSFORMERS_PORT_BASE = 18_100;
+const TRANSFORMERS_PORT_SPAN = 1_000;
+const TRANSFORMERS_START_POLL_ATTEMPTS = 240;
+const TRANSFORMERS_RUNTIME_DIR_NAME = "hf-transformers";
+const TRANSFORMERS_VENV_DIR_NAME = "venv";
+const TRANSFORMERS_SERVER_RELATIVE_PATH = join("runtimes", "hf-transformers-openai-server.py");
+const TRANSFORMERS_PINNED_PACKAGES = ["transformers==5.13.0", "huggingface-hub==1.22.0", "safetensors==0.8.0"];
+const TORCH_PINNED_VERSION = "2.12.1";
+async function runCommandDefault(command, args, options = {}) {
+    try {
+        const proc = spawnProcess(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: options.env ? { ...process.env, ...options.env } : process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.setEncoding("utf8");
+        proc.stderr.setEncoding("utf8");
+        proc.stdout.on("data", (chunk) => {
+            stdout += chunk;
+            options.onOutput?.(chunk);
+        });
+        proc.stderr.on("data", (chunk) => {
+            stderr += chunk;
+            options.onOutput?.(chunk);
+        });
+        const code = await waitForChildProcess(proc);
+        return {
+            ok: code === 0,
+            stdout,
+            stderr,
+            code,
+            ...(code === 0 ? {} : { error: stderr.trim() || stdout.trim() || `exit code ${code ?? "unknown"}` }),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: "",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function sanitizeCommandOutput(value) {
+    return value?.trim().split("\n").slice(-3).join("\n") || "unknown error";
+}
+function hashString(value) {
+    let hash = 2_166_136_261;
+    for (let index = 0; index < value.length; index++) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16_777_619) >>> 0;
+    }
+    return hash;
+}
+export function resolveTransformersBaseUrl(modelId) {
+    const port = TRANSFORMERS_PORT_BASE + (hashString(modelId) % TRANSFORMERS_PORT_SPAN);
+    return `http://127.0.0.1:${port}`;
+}
 export class OllamaRuntime {
     _agentDir;
     _baseUrl;
@@ -246,8 +307,6 @@ export class OllamaRuntime {
     }
     async _extractZip(input, destDir) {
         // Zip's central directory needs seekable file access — buffer to a temp file first.
-        const { createWriteStream } = await import("node:fs");
-        const { pipeline } = await import("node:stream/promises");
         const zipPath = join(destDir, "..", `ollama-download-${process.pid}-${Date.now()}.zip`);
         await pipeline(input, createWriteStream(zipPath));
         try {
@@ -262,7 +321,6 @@ export class OllamaRuntime {
         }
         finally {
             try {
-                const { rmSync } = await import("node:fs");
                 rmSync(zipPath, { force: true });
             }
             catch {
@@ -304,6 +362,7 @@ export class OllamaRuntime {
             OLLAMA_FLASH_ATTENTION: "1",
             OLLAMA_KV_CACHE_TYPE: "q8_0",
             OLLAMA_NUM_PARALLEL: "1",
+            OLLAMA_KEEP_ALIVE: "30m",
             OLLAMA_MAX_LOADED_MODELS: "3",
         });
     }
@@ -324,6 +383,7 @@ export class OllamaRuntime {
             OLLAMA_FLASH_ATTENTION: "1",
             OLLAMA_KV_CACHE_TYPE: "q8_0",
             OLLAMA_NUM_PARALLEL: "1",
+            OLLAMA_KEEP_ALIVE: "30m",
             OLLAMA_MAX_LOADED_MODELS: "3",
         });
     }
@@ -349,6 +409,47 @@ export class OllamaRuntime {
             .filter((model) => typeof model.name === "string")
             .map((model) => ({ name: model.name, sizeBytes: model.size ?? 0 }));
     }
+    async show(ref) {
+        try {
+            const response = await this._fetch(`${this._baseUrl}/api/show`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ model: ref }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok) {
+                return {
+                    ok: false,
+                    error: `show failed: HTTP ${response.status} ${await response.text().catch(() => "")}`,
+                };
+            }
+            const data = (await response.json());
+            return { ok: true, info: { modelInfo: data.model_info ?? {} } };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async createFromModelfile(args) {
+        try {
+            const response = await this._fetch(`${this._baseUrl}/api/create`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ model: args.name, modelfile: args.modelfile, stream: false }),
+                signal: AbortSignal.timeout(60_000),
+            });
+            if (!response.ok) {
+                return {
+                    ok: false,
+                    error: `create failed: HTTP ${response.status} ${await response.text().catch(() => "")}`,
+                };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     /** Pull a model through the server API (weights land in the SERVER's models dir). */
     async pull(ref, onProgress) {
         try {
@@ -428,4 +529,237 @@ export class OllamaRuntime {
         }
     }
 }
+export class TransformersRuntime {
+    _agentDir;
+    _modelId;
+    _baseUrl;
+    _fetch;
+    _spawn;
+    _exists;
+    _sleep;
+    _platform;
+    _runCommand;
+    _serverScriptPath;
+    _proc;
+    constructor(args) {
+        this._agentDir = args.agentDir;
+        this._modelId = args.modelId;
+        this._baseUrl = args.baseUrl?.replace(/\/$/, "") ?? resolveTransformersBaseUrl(args.modelId);
+        this._fetch = args.deps?.fetchFn ?? fetch;
+        this._spawn = args.deps?.spawnFn ?? ((command, argv, options) => spawn(command, argv, { env: options.env }));
+        this._exists = args.deps?.existsFn ?? existsSync;
+        this._sleep = args.deps?.sleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+        this._platform = args.deps?.platform ?? osPlatform;
+        this._runCommand = args.deps?.runCommand ?? runCommandDefault;
+        this._serverScriptPath =
+            args.deps?.transformersServerScriptPath ?? join(getBundledResourcesDir(), TRANSFORMERS_SERVER_RELATIVE_PATH);
+    }
+    get baseUrl() {
+        return this._baseUrl;
+    }
+    get modelId() {
+        return this._modelId;
+    }
+    get runtimeDir() {
+        return join(this._agentDir, "runtimes", TRANSFORMERS_RUNTIME_DIR_NAME);
+    }
+    get venvDir() {
+        return join(this.runtimeDir, TRANSFORMERS_VENV_DIR_NAME);
+    }
+    get cacheDir() {
+        return join(this._agentDir, "models", "huggingface");
+    }
+    get pythonPath() {
+        return this._platform() === "win32"
+            ? join(this.venvDir, "Scripts", "python.exe")
+            : join(this.venvDir, "bin", "python");
+    }
+    get serverPort() {
+        const parsed = new URL(this._baseUrl);
+        return parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+    }
+    get serverHost() {
+        return new URL(this._baseUrl).hostname;
+    }
+    runtimeEnv() {
+        const venvBin = this._platform() === "win32" ? join(this.venvDir, "Scripts") : join(this.venvDir, "bin");
+        return {
+            ...process.env,
+            VIRTUAL_ENV: this.venvDir,
+            PATH: `${venvBin}${delimiter}${process.env.PATH ?? ""}`,
+            PYTHONNOUSERSITE: "1",
+            HF_HOME: this.cacheDir,
+            HUGGINGFACE_HUB_CACHE: join(this.cacheDir, "hub"),
+            TRANSFORMERS_CACHE: join(this.cacheDir, "transformers"),
+            HF_HUB_DISABLE_TELEMETRY: "1",
+        };
+    }
+    async serverUp() {
+        try {
+            const response = await this._fetch(`${this._baseUrl}/health`, {
+                signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+            });
+            if (!response.ok)
+                return false;
+            const body = (await response.json().catch(() => undefined));
+            return body?.model === this._modelId;
+        }
+        catch {
+            return false;
+        }
+    }
+    async detect() {
+        return {
+            runtimeInstalled: this._exists(this.pythonPath),
+            serverUp: await this.serverUp(),
+            baseUrl: this._baseUrl,
+            modelId: this._modelId,
+            venvDir: this.venvDir,
+            cacheDir: this.cacheDir,
+            serverScriptPath: this._serverScriptPath,
+        };
+    }
+    pythonCandidates() {
+        return this._platform() === "win32"
+            ? [
+                { command: "py", args: ["-3"] },
+                { command: "python", args: [] },
+            ]
+            : [
+                { command: "python3", args: [] },
+                { command: "python", args: [] },
+            ];
+    }
+    async findPython() {
+        for (const candidate of this.pythonCandidates()) {
+            const result = await this._runCommand(candidate.command, [...candidate.args, "--version"]);
+            if (result.ok)
+                return candidate;
+        }
+        return undefined;
+    }
+    torchInstallArgs() {
+        if (this._platform() === "darwin") {
+            return ["-m", "pip", "install", `torch==${TORCH_PINNED_VERSION}`];
+        }
+        return [
+            "-m",
+            "pip",
+            "install",
+            `torch==${TORCH_PINNED_VERSION}+cpu`,
+            "--index-url",
+            "https://download.pytorch.org/whl/cpu",
+        ];
+    }
+    async runPython(args, onProgress) {
+        return this._runCommand(this.pythonPath, args, {
+            env: this.runtimeEnv(),
+            onOutput: onProgress
+                ? (chunk) => {
+                    const line = chunk.trim();
+                    if (line)
+                        onProgress(line);
+                }
+                : undefined,
+        });
+    }
+    async installManaged(onProgress) {
+        mkdirSync(this.runtimeDir, { recursive: true });
+        mkdirSync(this.cacheDir, { recursive: true });
+        if (!this._exists(this.pythonPath)) {
+            const python = await this.findPython();
+            if (!python)
+                return { ok: false, error: "python-missing" };
+            onProgress?.(`creating isolated Python venv at ${this.venvDir}`);
+            const venv = await this._runCommand(python.command, [...python.args, "-m", "venv", this.venvDir]);
+            if (!venv.ok)
+                return { ok: false, error: `venv-fail: ${sanitizeCommandOutput(venv.error ?? venv.stderr)}` };
+        }
+        if (!this._exists(this.pythonPath)) {
+            return { ok: false, error: `venv-fail: ${this.pythonPath} was not created` };
+        }
+        onProgress?.("upgrading pip inside pi-managed venv");
+        const pip = await this.runPython(["-m", "pip", "install", "--upgrade", "pip"], onProgress);
+        if (!pip.ok)
+            return { ok: false, error: `pip-upgrade-fail: ${sanitizeCommandOutput(pip.error ?? pip.stderr)}` };
+        onProgress?.("installing pinned Transformers runtime packages");
+        const transformers = await this.runPython(["-m", "pip", "install", ...TRANSFORMERS_PINNED_PACKAGES], onProgress);
+        if (!transformers.ok) {
+            return {
+                ok: false,
+                error: `transformers-install-fail: ${sanitizeCommandOutput(transformers.error ?? transformers.stderr)}`,
+            };
+        }
+        onProgress?.("installing pinned CPU PyTorch backend");
+        const torch = await this.runPython(this.torchInstallArgs(), onProgress);
+        if (!torch.ok)
+            return { ok: false, error: `torch-install-fail: ${sanitizeCommandOutput(torch.error ?? torch.stderr)}` };
+        const verify = await this.runPython([
+            "-c",
+            "import torch, transformers, huggingface_hub; print(transformers.__version__)",
+        ]);
+        if (!verify.ok)
+            return { ok: false, error: `verify-fail: ${sanitizeCommandOutput(verify.error ?? verify.stderr)}` };
+        return { ok: true };
+    }
+    async downloadModel(onProgress) {
+        if (!this._exists(this.pythonPath))
+            return { ok: false, error: "runtime-missing" };
+        if (!this._exists(this._serverScriptPath))
+            return { ok: false, error: `server-script-missing: ${this._serverScriptPath}` };
+        mkdirSync(this.cacheDir, { recursive: true });
+        onProgress?.(`downloading ${this._modelId} into ${this.cacheDir}`);
+        const result = await this.runPython([this._serverScriptPath, "--model-id", this._modelId, "--cache-dir", this.cacheDir, "--download-only"], onProgress);
+        return result.ok
+            ? { ok: true }
+            : { ok: false, error: `download-fail: ${sanitizeCommandOutput(result.error ?? result.stderr)}` };
+    }
+    async start() {
+        if (await this.serverUp())
+            return { started: false, reason: "already_running" };
+        if (!this._exists(this.pythonPath))
+            return { started: false, reason: "runtime_missing" };
+        if (!this._exists(this._serverScriptPath))
+            return { started: false, reason: "server_script_missing" };
+        mkdirSync(this.cacheDir, { recursive: true });
+        const env = this.runtimeEnv();
+        this._proc = this._spawn(this.pythonPath, [
+            this._serverScriptPath,
+            "--model-id",
+            this._modelId,
+            "--host",
+            this.serverHost,
+            "--port",
+            this.serverPort,
+            "--cache-dir",
+            this.cacheDir,
+        ], { env });
+        this._proc.unref?.();
+        for (let attempt = 0; attempt < TRANSFORMERS_START_POLL_ATTEMPTS; attempt++) {
+            if (await this.serverUp())
+                return { started: true, reason: "started" };
+            await this._sleep(START_POLL_INTERVAL_MS);
+        }
+        this.stop();
+        return { started: false, reason: "health_check_timeout" };
+    }
+    stop() {
+        if (!this._proc)
+            return { stopped: false };
+        this._proc.kill();
+        this._proc = undefined;
+        return { stopped: true };
+    }
+    installGuide() {
+        return [
+            "Hugging Face Transformers runtime is not installed for this model.",
+            `Pi can install it into its own venv at ${this.venvDir} and cache weights under ${this.cacheDir}.`,
+            "Manual equivalent:",
+            `  python3 -m venv ${this.venvDir}`,
+            `  ${this.pythonPath} -m pip install --upgrade pip`,
+            `  ${this.pythonPath} -m pip install ${TRANSFORMERS_PINNED_PACKAGES.join(" ")}`,
+            `  ${this.pythonPath} ${this.torchInstallArgs().join(" ")}`,
+        ];
+    }
+}
 //# sourceMappingURL=local-runtime.js.map