@elizaos/app-core 2.0.0-beta.3 → 2.0.11-beta.6

package/runtime/embedding-manager-support.js

@@ -1,309 +0,0 @@
-import fs from "node:fs";
-import https from "node:https";
-import os from "node:os";
-import path from "node:path";
-import { formatByteSize, getLogPrefix } from "@elizaos/shared";
-import { EMBEDDING_PRESETS } from "./embedding-presets.js";
-export const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
-export const DEFAULT_MODELS_DIR = path.join(os.homedir(), ".eliza", "models");
-const EMBEDDING_META_DIR = process.env.ELIZA_EMBEDDING_META_DIR ??
-    path.join(os.homedir(), ".eliza", "state");
-export const EMBEDDING_META_PATH = process.env.ELIZA_EMBEDDING_META_PATH ??
-    path.join(EMBEDDING_META_DIR, "embedding-meta.json");
-let _logger;
-export function getLogger() {
-    if (_logger)
-        return _logger;
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const core = require("@elizaos/core");
-        if (core?.logger) {
-            _logger = core.logger;
-            return _logger;
-        }
-    }
-    catch {
-        // Fallback below
-    }
-    _logger = console;
-    return _logger;
-}
-export function readEmbeddingMeta() {
-    try {
-        if (!fs.existsSync(EMBEDDING_META_PATH))
-            return null;
-        return JSON.parse(fs.readFileSync(EMBEDDING_META_PATH, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function writeEmbeddingMeta(meta) {
-    try {
-        fs.mkdirSync(EMBEDDING_META_DIR, { recursive: true });
-        fs.writeFileSync(EMBEDDING_META_PATH, JSON.stringify(meta, null, 2));
-    }
-    catch (err) {
-        getLogger().warn(`${getLogPrefix()} Failed to write embedding metadata: ${err}`);
-    }
-}
-export function checkDimensionMigration(model, dimensions) {
-    const log = getLogger();
-    const stored = readEmbeddingMeta();
-    if (stored && stored.dimensions !== dimensions) {
-        log.warn(`${getLogPrefix()} Embedding dimensions changed (${stored.dimensions} → ${dimensions}). ` +
-            "Existing memory embeddings will be re-indexed on next access.");
-    }
-    writeEmbeddingMeta({
-        model,
-        dimensions,
-        lastChanged: new Date().toISOString(),
-    });
-}
-export function safeUnlink(filepath) {
-    try {
-        if (fs.existsSync(filepath))
-            fs.unlinkSync(filepath);
-    }
-    catch {
-        // best-effort cleanup
-    }
-}
-export function getErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    if (typeof error === "string")
-        return error;
-    if (error != null &&
-        typeof error === "object" &&
-        "message" in error &&
-        typeof error.message === "string") {
-        return error.message;
-    }
-    return String(error);
-}
-export function isCorruptedModelLoadError(error) {
-    const message = getErrorMessage(error).toLowerCase();
-    return (message.includes("failed to load model") ||
-        message.includes("data is not within the file bounds") ||
-        (message.includes("tensor") && message.includes("is corrupted")) ||
-        message.includes("model is corrupted"));
-}
-function parseContentLength(contentLength) {
-    if (!contentLength || Array.isArray(contentLength))
-        return null;
-    const parsed = Number.parseInt(contentLength, 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
-}
-function isAllowedDownloadHost(hostname) {
-    return (hostname === "huggingface.co" ||
-        hostname.endsWith(".huggingface.co") ||
-        hostname === "hf.co" ||
-        hostname.endsWith(".hf.co"));
-}
-function validateDownloadUrl(rawUrl) {
-    let parsed;
-    try {
-        parsed = new URL(rawUrl);
-    }
-    catch {
-        throw new Error(`Download failed: invalid URL "${rawUrl}"`);
-    }
-    if (parsed.protocol !== "https:") {
-        throw new Error("Download failed: only https:// URLs are allowed");
-    }
-    if (!isAllowedDownloadHost(parsed.hostname.toLowerCase())) {
-        throw new Error(`Download failed: host "${parsed.hostname}" is not allowed`);
-    }
-    return parsed;
-}
-function sanitizeModelRepo(repo) {
-    const trimmed = repo.trim();
-    if (!/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(trimmed)) {
-        throw new Error(`Invalid embedding model repo: ${repo}`);
-    }
-    return trimmed;
-}
-function sanitizeModelFilename(filename) {
-    const trimmed = filename.trim();
-    if (!/^[A-Za-z0-9._-]+\.gguf$/i.test(trimmed)) {
-        throw new Error(`Invalid embedding model filename: ${filename}`);
-    }
-    return trimmed;
-}
-function resolveModelPath(modelsDir, filename) {
-    const resolvedDir = path.resolve(modelsDir);
-    const resolvedPath = path.resolve(resolvedDir, filename);
-    if (resolvedPath !== resolvedDir &&
-        !resolvedPath.startsWith(`${resolvedDir}${path.sep}`)) {
-        throw new Error("Invalid embedding model path");
-    }
-    return resolvedPath;
-}
-function warmupReuseEmbeddingCandidates() {
-    return [
-        {
-            model: EMBEDDING_PRESETS.performance.model,
-            modelRepo: EMBEDDING_PRESETS.performance.modelRepo,
-            dimensions: EMBEDDING_PRESETS.performance.dimensions,
-            contextSize: EMBEDDING_PRESETS.performance.contextSize,
-            gpuLayers: String(EMBEDDING_PRESETS.performance.gpuLayers),
-        },
-    ];
-}
-/** True if a sanitized GGUF with this basename exists under `modelsDir`. */
-export function embeddingGgufFilePresent(modelsDir, filename) {
-    try {
-        const safe = sanitizeModelFilename(filename);
-        return fs.existsSync(resolveModelPath(modelsDir, safe));
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * When the configured embedding file is missing, reuse only the compact,
- * SQL-safe embedding GGUF already on disk. The framework intentionally avoids
- * reviving legacy larger defaults from MODELS_DIR because they would reintroduce
- * dimension mismatches and unnecessary RAM/download cost.
- */
-export function findExistingEmbeddingModelForWarmupReuse(modelsDir) {
-    const dir = path.resolve(modelsDir);
-    if (!fs.existsSync(dir)) {
-        return null;
-    }
-    for (const c of warmupReuseEmbeddingCandidates()) {
-        if (embeddingGgufFilePresent(dir, c.model)) {
-            return c;
-        }
-    }
-    return null;
-}
-export function isEmbeddingWarmupReuseDisabled() {
-    const raw = process.env.ELIZA_EMBEDDING_WARMUP_NO_REUSE?.trim().toLowerCase() ?? "";
-    return raw === "1" || raw === "true" || raw === "yes";
-}
-/** Alias for the shared byte-size formatter with precision tuned for download progress. */
-function formatBytes(bytes) {
-    return formatByteSize(bytes, {
-        kbPrecision: 0,
-        mbPrecision: 1,
-        gbPrecision: 2,
-    });
-}
-function downloadFile(url, dest, maxRedirects = 5, onProgress) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let redirectCount = 0;
-        const request = (reqUrl) => {
-            let validatedUrl;
-            try {
-                validatedUrl = validateDownloadUrl(reqUrl);
-            }
-            catch (error) {
-                reject(error instanceof Error ? error : new Error("Invalid download URL"));
-                return;
-            }
-            const file = fs.createWriteStream(dest);
-            let bytesReceived = 0;
-            let expectedBytes = null;
-            let lastProgressPercent = -1;
-            const settleError = (err) => {
-                if (settled)
-                    return;
-                settled = true;
-                file.close();
-                safeUnlink(dest);
-                reject(err);
-            };
-            const settleSuccess = () => {
-                if (settled)
-                    return;
-                if (expectedBytes != null && bytesReceived !== expectedBytes) {
-                    settleError(new Error(`${getLogPrefix()} Download failed: bytes received (${bytesReceived}) ` +
-                        `does not match Content-Length (${expectedBytes})`));
-                    return;
-                }
-                settled = true;
-                file.close();
-                resolve();
-            };
-            https
-                .get(validatedUrl.toString(), { headers: { "User-Agent": "eliza" } }, (res) => {
-                expectedBytes = parseContentLength(res.headers["content-length"]);
-                if (res.statusCode &&
-                    res.statusCode >= 300 &&
-                    res.statusCode < 400 &&
-                    res.headers.location) {
-                    res.resume();
-                    file.close();
-                    safeUnlink(dest);
-                    redirectCount += 1;
-                    if (redirectCount > maxRedirects) {
-                        settleError(new Error(`Download failed: too many redirects (>${maxRedirects})`));
-                        return;
-                    }
-                    let next;
-                    try {
-                        next = new URL(res.headers.location, validatedUrl.toString()).toString();
-                    }
-                    catch {
-                        settleError(new Error(`Download failed: malformed redirect URL "${res.headers.location}"`));
-                        return;
-                    }
-                    request(next);
-                    return;
-                }
-                if (res.statusCode !== 200) {
-                    settleError(new Error(`Download failed: HTTP ${res.statusCode} for ${validatedUrl.toString()}`));
-                    return;
-                }
-                res.on("data", (chunk) => {
-                    bytesReceived += chunk.length;
-                    if (onProgress) {
-                        // Throttle callbacks to every 2% to avoid excessive updates
-                        const pct = expectedBytes
-                            ? Math.floor((bytesReceived / expectedBytes) * 50)
-                            : -1;
-                        if (pct !== lastProgressPercent) {
-                            lastProgressPercent = pct;
-                            onProgress(bytesReceived, expectedBytes);
-                        }
-                    }
-                });
-                res.pipe(file);
-                file.on("finish", settleSuccess);
-                file.on("error", settleError);
-            })
-                .on("error", settleError);
-        };
-        request(url);
-    });
-}
-export async function ensureModel(modelsDir, repo, filename, force, onProgress) {
-    const safeRepo = sanitizeModelRepo(repo);
-    const safeFilename = sanitizeModelFilename(filename);
-    const modelPath = resolveModelPath(modelsDir, safeFilename);
-    if (force)
-        safeUnlink(modelPath);
-    onProgress?.("checking", safeFilename);
-    if (fs.existsSync(modelPath)) {
-        onProgress?.("ready", "model already downloaded");
-        return modelPath;
-    }
-    const log = getLogger();
-    fs.mkdirSync(path.resolve(modelsDir), { recursive: true });
-    const url = `https://huggingface.co/${safeRepo}/resolve/main/${safeFilename}`;
-    log.info(`${getLogPrefix()} Downloading TEXT_EMBEDDING / memory vector model (not chat LLM): ${safeFilename} from ${safeRepo}`);
-    onProgress?.("downloading", `${safeFilename} — TEXT_EMBEDDING for memory, not chat · ${safeRepo}`);
-    const downloadOnProgress = onProgress
-        ? (downloaded, total) => {
-            const totalStr = total ? formatBytes(total) : "unknown size";
-            const pct = total ? Math.round((downloaded / total) * 100) : 0;
-            onProgress("downloading", `${safeFilename} ${pct}% of ${totalStr}`);
-        }
-        : undefined;
-    await downloadFile(url, modelPath, 5, downloadOnProgress);
-    log.info(`${getLogPrefix()} Embedding model downloaded: ${modelPath}`);
-    return modelPath;
-}

package/runtime/embedding-presets.d.ts

@@ -1,5 +0,0 @@
-import { detectEmbeddingTier, EMBEDDING_PRESETS as upstreamEmbeddingPresets } from "@elizaos/agent";
-export { detectEmbeddingTier };
-export declare const EMBEDDING_PRESETS: typeof upstreamEmbeddingPresets;
-export declare function detectEmbeddingPreset(): import("@elizaos/agent").EmbeddingPreset;
-//# sourceMappingURL=embedding-presets.d.ts.map

package/runtime/embedding-presets.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embedding-presets.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/embedding-presets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,IAAI,wBAAwB,EAC9C,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,mBAAmB,EAAE,CAAC;AA8B/B,eAAO,MAAM,iBAAiB,EAAE,OAAO,wBAgBtC,CAAC;AAEF,wBAAgB,qBAAqB,6CAGpC"}

package/runtime/embedding-presets.js

@@ -1,47 +0,0 @@
-import { detectEmbeddingTier, EMBEDDING_PRESETS as upstreamEmbeddingPresets, } from "@elizaos/agent";
-export { detectEmbeddingTier };
-/**
- * Upstream presets plus a local override of the `performance` preset so the
- * large E5-Mistral **embedding** GGUF is not mistaken for a chat LLM (the
- * filename contains `instruct` from the E5 family).
- *
- * CYCLE-BREAK NOTE: an `agent ↔ app-core` ESM cycle was crashing the bench
- * server boot with `Cannot access 'upstreamEmbeddingPresets' before
- * initialization` (TDZ at the module-load eager spread). Defer the spread
- * until first read via a lazy-init Proxy. By the time anything READS
- * `EMBEDDING_PRESETS.fallback`, the upstream module has fully initialized,
- * so the spread succeeds.
- */
-let _embeddingPresetsCache = null;
-function _computeEmbeddingPresets() {
-    if (_embeddingPresetsCache)
-        return _embeddingPresetsCache;
-    _embeddingPresetsCache = {
-        ...upstreamEmbeddingPresets,
-        performance: {
-            ...upstreamEmbeddingPresets.performance,
-            label: "Efficient (compact text embedding)",
-            description: "384-dim compact text-embedding model (~133MB). Powers memory / knowledge vectors only — not chat. " +
-                "The framework keeps the default SQL-safe and fast instead of auto-selecting a multi-GB embedding GGUF.",
-        },
-    };
-    return _embeddingPresetsCache;
-}
-export const EMBEDDING_PRESETS = new Proxy({}, {
-    get(_t, prop) {
-        return Reflect.get(_computeEmbeddingPresets(), prop);
-    },
-    has(_t, prop) {
-        return Reflect.has(_computeEmbeddingPresets(), prop);
-    },
-    ownKeys() {
-        return Reflect.ownKeys(_computeEmbeddingPresets());
-    },
-    getOwnPropertyDescriptor(_t, prop) {
-        return Reflect.getOwnPropertyDescriptor(_computeEmbeddingPresets(), prop);
-    },
-});
-export function detectEmbeddingPreset() {
-    const tier = detectEmbeddingTier();
-    return _computeEmbeddingPresets()[tier];
-}

package/runtime/embedding-warmup-policy.d.ts

@@ -1,13 +0,0 @@
-/**
- * Whether to prefetch the local GGUF embedding model before runtime boot.
- *
- * Chat/inference provider (what you pick in onboarding) is separate from
- * **embeddings** (vector memory / RAG). By default The framework keeps
- * `@elizaos/plugin-local-embedding` loaded because API-based model plugins do
- * not implement TEXT_EMBEDDING — so a local model was historically always
- * warmed up. When Eliza Cloud is connected with **cloud embeddings** enabled,
- * the cloud plugin handles embeddings instead; skipping warmup avoids a large
- * download unrelated to “local inference” for chat.
- */
-export declare function shouldWarmupLocalEmbeddingModel(): boolean;
-//# sourceMappingURL=embedding-warmup-policy.d.ts.map

package/runtime/embedding-warmup-policy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embedding-warmup-policy.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/embedding-warmup-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,wBAAgB,+BAA+B,IAAI,OAAO,CAmBzD"}

package/runtime/embedding-warmup-policy.js

@@ -1,33 +0,0 @@
-/**
- * Whether to prefetch the local GGUF embedding model before runtime boot.
- *
- * Chat/inference provider (what you pick in onboarding) is separate from
- * **embeddings** (vector memory / RAG). By default The framework keeps
- * `@elizaos/plugin-local-embedding` loaded because API-based model plugins do
- * not implement TEXT_EMBEDDING — so a local model was historically always
- * warmed up. When Eliza Cloud is connected with **cloud embeddings** enabled,
- * the cloud plugin handles embeddings instead; skipping warmup avoids a large
- * download unrelated to “local inference” for chat.
- */
-function isTruthyEnv(...names) {
-    for (const name of names) {
-        const v = process.env[name]?.trim().toLowerCase();
-        if (v === "1" || v === "true" || v === "yes")
-            return true;
-    }
-    return false;
-}
-export function shouldWarmupLocalEmbeddingModel() {
-    if (isTruthyEnv("ELIZA_DISABLE_LOCAL_EMBEDDINGS")) {
-        return false;
-    }
-    const cloudEmbeddingsRoutedLocally = isTruthyEnv("ELIZA_CLOUD_EMBEDDINGS_DISABLED");
-    if (cloudEmbeddingsRoutedLocally) {
-        // User turned off cloud for embeddings — local plugin must serve TEXT_EMBEDDING.
-        return true;
-    }
-    if (isTruthyEnv("ELIZAOS_CLOUD_USE_EMBEDDINGS")) {
-        return false;
-    }
-    return true;
-}

package/runtime/ensure-local-inference-handler.d.ts

@@ -1,25 +0,0 @@
-/**
- * Registers the standalone llama.cpp engine as the runtime handler for
- * `ModelType.TEXT_SMALL` and `ModelType.TEXT_LARGE`.
- *
- * Priority is 0 — same band as cloud and direct provider plugins. Tie-breaks
- * between local and cloud are owned by the routing-policy layer
- * (`router-handler.ts` + `routing-policy.ts`), not by this priority value:
- * the router sits at MAX_SAFE_INTEGER and consults the user's policy
- * (manual / cheapest / fastest / prefer-local / round-robin) on every call.
- *
- * Until the cuttlefish smoke landed this was -1 to "let cloud win by default,"
- * but that conflated routing-policy (a user preference) with handler
- * priority (a registration ordinal). The runtime's getModel() returns
- * undefined when no priority-0 handler is registered, which manifested as
- * "No handler found for delegate type: TEXT_SMALL" on AOSP builds where
- * the AOSP local inference loader is the only provider. Both cloud-only and
- * local-only deployments now have a registered priority-0 handler; the
- * router decides which one fires per request.
- *
- * Parallels `ensure-text-to-speech-handler.ts` — same shape, same guards.
- */
-import { type AgentRuntime } from "@elizaos/core";
-export declare function shouldRegisterLocalInferenceHandlers(mode: string): boolean;
-export declare function ensureLocalInferenceHandler(runtime: AgentRuntime): Promise<void>;
-//# sourceMappingURL=ensure-local-inference-handler.d.ts.map

package/runtime/ensure-local-inference-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ensure-local-inference-handler.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/ensure-local-inference-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,KAAK,YAAY,EAMlB,MAAM,eAAe,CAAC;AAoEvB,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1E;AAiSD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CA+Jf"}