@elizaos/app-core 2.0.0-beta.3 → 2.0.3-beta.3

package/registry/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/registry/schema.ts"],"names":[],"mappings":"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"}

package/registry/schema.js

@@ -1,264 +0,0 @@
-// Registry SoT for apps, plugins, and connectors.
-//
-// Replaces the fragmented surface of:
-//   - plugins.json (97 entries, 5 categories)
-//   - PluginInfo (api/client-types-config.ts)
-//   - ConfigUiHint (types/index.ts)
-//   - RegistryAppInfo (shared/contracts/apps.ts)
-//   - VISIBLE_CONNECTOR_IDS / DEFAULT_ICONS / FEATURE_SUBGROUP / SUBGROUP_DISPLAY_ORDER
-//     (components/pages/plugin-list-utils.ts)
-//   - paramsToSchema() heuristics (PORT/TIMEOUT/MODEL guessing)
-//
-// Static registry only. Runtime overlay (enabled, configured, isActive,
-// validationErrors) lives in RegistryRuntimeOverlay and is merged at API read
-// time — never in the registry files themselves.
-import { z } from "zod";
-// ---------------------------------------------------------------------------
-// Config field schema — replaces PluginParamDef + ConfigUiHint.
-// One field, one place. UI hints are co-located with type info.
-// ---------------------------------------------------------------------------
-const configFieldType = z.enum([
-    "string",
-    "secret",
-    "boolean",
-    "number",
-    "select",
-    "multiselect",
-    "json",
-    "textarea",
-    "url",
-    "file-path",
-]);
-const configFieldOption = z.object({
-    value: z.string(),
-    label: z.string(),
-    description: z.string().optional(),
-    icon: z.string().optional(),
-    disabled: z.boolean().optional(),
-});
-const visibilityCondition = z.object({
-    key: z.string(),
-    equals: z.unknown().optional(),
-    in: z.array(z.unknown()).optional(),
-    notEquals: z.unknown().optional(),
-});
-export const configFieldSchema = z.object({
-    type: configFieldType,
-    required: z.boolean(),
-    sensitive: z.boolean().optional(),
-    default: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
-    label: z.string().optional(),
-    help: z.string().optional(),
-    placeholder: z.string().optional(),
-    group: z.string().optional(),
-    order: z.number().int().optional(),
-    width: z.enum(["full", "half", "third"]).optional(),
-    advanced: z.boolean().optional(),
-    hidden: z.boolean().optional(),
-    readonly: z.boolean().optional(),
-    icon: z.string().optional(),
-    options: z.array(configFieldOption).optional(),
-    pattern: z.string().optional(),
-    patternError: z.string().optional(),
-    min: z.number().optional(),
-    max: z.number().optional(),
-    step: z.number().optional(),
-    unit: z.string().optional(),
-    visible: visibilityCondition.optional(),
-});
-// ---------------------------------------------------------------------------
-// Render hints — replaces VISIBLE_CONNECTOR_IDS / DEFAULT_ICONS /
-// FEATURE_SUBGROUP / SUBGROUP_DISPLAY_ORDER.
-//
-// Surface mapping is implicit:
-//   kind: "connector" → ConnectorsView (primary)
-//   kind: "app"       → AppsView       (primary)
-//   kind: "plugin"    → PluginsView    (primary)
-// Every entry shows in its primary surface unless `visible: false`.
-//
-// Use `pinTo` to ALSO surface an item somewhere it wouldn't appear by default
-// (e.g. promoting an app into the chat quick-launcher). Opt-in only — keeps
-// the common case zero-config.
-// ---------------------------------------------------------------------------
-const renderActionSchema = z.enum([
-    "enable",
-    "configure",
-    "launch",
-    "attach",
-    "detach",
-    "stop",
-    "uninstall",
-    "install",
-    "setup-guide",
-]);
-const secondarySurfaceSchema = z.enum([
-    "chat-apps-section",
-    "companion-shell",
-    "settings-integrations",
-]);
-export const renderSchema = z.object({
-    visible: z.boolean().default(true),
-    pinTo: z.array(secondarySurfaceSchema).default([]),
-    style: z.enum(["card", "setup-panel", "hero-card"]).default("card"),
-    icon: z.string().optional(),
-    heroImage: z.string().optional(),
-    group: z.string(),
-    groupOrder: z.number().int().optional(),
-    actions: z.array(renderActionSchema).default([]),
-});
-// ---------------------------------------------------------------------------
-// External resources (already in plugins.json today).
-// ---------------------------------------------------------------------------
-export const resourcesSchema = z.object({
-    homepage: z.string().url().optional(),
-    repository: z.string().url().optional(),
-    setupGuideUrl: z.string().url().optional(),
-});
-// ---------------------------------------------------------------------------
-// App-only: launch + viewer + session (mirrors RegistryAppInfo).
-// ---------------------------------------------------------------------------
-const appViewerSchema = z.object({
-    url: z.string(),
-    embedParams: z.record(z.string(), z.string()).optional(),
-    postMessageAuth: z.boolean().optional(),
-    sandbox: z.string().optional(),
-});
-const appSessionSchema = z.object({
-    mode: z.enum(["viewer", "spectate-and-steer", "external"]),
-    features: z
-        .array(z.enum(["commands", "telemetry", "pause", "resume", "suggestions"]))
-        .optional(),
-});
-const appSupportsSchema = z.object({
-    v0: z.boolean(),
-    v1: z.boolean(),
-    v2: z.boolean(),
-});
-const appNpmSchema = z.object({
-    package: z.string(),
-    v0Version: z.string().nullable(),
-    v1Version: z.string().nullable(),
-    v2Version: z.string().nullable(),
-});
-const packageRoutePluginSpecifierSchema = z
-    .string()
-    .min(1)
-    .refine((value) => !value.startsWith(".") &&
-    !value.startsWith("/") &&
-    !/(^|\/)(apps|plugins)\//.test(value), "routePlugin.specifier must be a package specifier, not a filesystem path");
-const appRoutePluginSchema = z.object({
-    specifier: packageRoutePluginSpecifierSchema,
-    exportName: z.string().min(1).optional(),
-});
-export const appLaunchSchema = z.object({
-    type: z.enum(["internal-tab", "overlay", "server-launch"]),
-    target: z.string().optional(),
-    url: z.string().nullable().optional(),
-    viewer: appViewerSchema.optional(),
-    session: appSessionSchema.optional(),
-    supports: appSupportsSchema.optional(),
-    npm: appNpmSchema.optional(),
-    capabilities: z.array(z.string()).default([]),
-    uiExtension: z.object({ detailPanelId: z.string() }).optional(),
-    curatedSlug: z.string().optional(),
-    routePlugin: appRoutePluginSchema.optional(),
-    /**
-     * If true, the app declares itself as the default landing tab.
-     * Mirrors `package.json#elizaos.app.mainTab`. Consumed by
-     * `getMainTabApp()` in this package to compute the shell's landing
-     * tab. Exactly one installed app should set this; multiple declarers
-     * are resolved deterministically by alphabetic id.
-     */
-    mainTab: z.boolean().optional(),
-});
-// ---------------------------------------------------------------------------
-// Common fields shared by every entry.
-// ---------------------------------------------------------------------------
-const commonFields = {
-    id: z
-        .string()
-        .min(1)
-        .regex(/^[a-z0-9][a-z0-9-]*$/, "id must be kebab-case ascii"),
-    name: z.string().min(1),
-    description: z.string().optional(),
-    npmName: z.string().optional(),
-    version: z.string().optional(),
-    releaseStream: z.enum(["latest", "beta"]).optional(),
-    source: z.enum(["bundled", "store"]).default("bundled"),
-    tags: z.array(z.string()).default([]),
-    config: z.record(z.string(), configFieldSchema).default({}),
-    render: renderSchema,
-    resources: resourcesSchema.default({}),
-    dependsOn: z.array(z.string()).default([]),
-};
-// ---------------------------------------------------------------------------
-// Discriminated union — three kinds, each with their own constraints.
-// ---------------------------------------------------------------------------
-const pluginSubtype = z.enum([
-    "ai-provider",
-    "feature",
-    "database",
-    "voice",
-    "documents",
-    "blockchain",
-    "media",
-    "agents",
-    "automation",
-    "storage",
-    "gaming",
-    "devtools",
-    "other",
-]);
-const connectorSubtype = z.enum([
-    "messaging",
-    "social",
-    "streaming",
-    "email",
-    "calendar",
-    "other",
-]);
-export const pluginEntrySchema = z.object({
-    ...commonFields,
-    kind: z.literal("plugin"),
-    subtype: pluginSubtype,
-});
-export const connectorEntrySchema = z.object({
-    ...commonFields,
-    kind: z.literal("connector"),
-    subtype: connectorSubtype,
-    auth: z
-        .object({
-        kind: z.enum(["token", "oauth", "credentials", "none"]),
-        credentialKeys: z.array(z.string()).default([]),
-    })
-        .optional(),
-});
-export const appEntrySchema = z.object({
-    ...commonFields,
-    kind: z.literal("app"),
-    subtype: z.enum(["game", "tool", "shell", "marketplace", "trading", "other"]),
-    launch: appLaunchSchema,
-});
-export const registryEntrySchema = z.discriminatedUnion("kind", [
-    pluginEntrySchema,
-    connectorEntrySchema,
-    appEntrySchema,
-]);
-// ---------------------------------------------------------------------------
-// Runtime overlay — never in registry files. Merged at API read time.
-// ---------------------------------------------------------------------------
-export const registryRuntimeOverlaySchema = z.object({
-    id: z.string(),
-    enabled: z.boolean(),
-    configured: z.boolean(),
-    isActive: z.boolean(),
-    loadError: z.string().optional(),
-    validationErrors: z
-        .array(z.object({ field: z.string(), message: z.string() }))
-        .default([]),
-    validationWarnings: z
-        .array(z.object({ field: z.string(), message: z.string() }))
-        .default([]),
-    installedVersion: z.string().optional(),
-    latestVersion: z.string().nullable().optional(),
-});

package/runtime/embedding-manager-support.d.ts

@@ -1,77 +0,0 @@
-/**
- * Callback for reporting download/init progress.
- * @param phase - Current phase: "checking", "downloading", "loading", "ready"
- * @param detail - Human-readable detail (e.g. "45% of 95 MB")
- */
-export type EmbeddingProgressCallback = (phase: "checking" | "downloading" | "loading" | "ready", detail?: string) => void;
-/**
- * Callback for raw download byte progress.
- * @param downloaded - Bytes received so far
- * @param total - Total bytes expected (null if Content-Length unavailable)
- */
-export type DownloadProgressCallback = (downloaded: number, total: number | null) => void;
-export interface EmbeddingManagerConfig {
-    /** GGUF model filename (default: detected hardware preset) */
-    model?: string;
-    /** HuggingFace repo for auto-download (default: detected hardware preset repo) */
-    modelRepo?: string;
-    /** Embedding dimensions (default: detected hardware preset dimensions) */
-    dimensions?: number;
-    /** GPU layers: "auto" | "max" | number (default: detected hardware preset gpuLayers) */
-    gpuLayers?: "auto" | "max" | number;
-    /** Model context window in tokens (default: detected hardware preset contextSize) */
-    contextSize?: number;
-    /** Idle timeout in ms before unloading model (default: 1800000 = 30 min, 0 = never unload) */
-    idleTimeoutMs?: number;
-    /** Models directory (default: ~/.eliza/models) */
-    modelsDir?: string;
-    /** Optional callback for reporting initialization progress phases. */
-    onProgress?: EmbeddingProgressCallback;
-}
-export interface EmbeddingManagerStats {
-    lastUsedAt: number | null;
-    isLoaded: boolean;
-    model: string;
-    gpuLayers: string | number;
-    dimensions: number;
-}
-export declare const DEFAULT_IDLE_TIMEOUT_MS: number;
-export declare const DEFAULT_MODELS_DIR: string;
-export declare const EMBEDDING_META_PATH: string;
-export declare function getLogger(): {
-    info: (...a: unknown[]) => void;
-    warn: (...a: unknown[]) => void;
-    error: (...a: unknown[]) => void;
-    debug: (...a: unknown[]) => void;
-};
-interface EmbeddingMeta {
-    model: string;
-    dimensions: number;
-    lastChanged: string;
-}
-export declare function readEmbeddingMeta(): EmbeddingMeta | null;
-export declare function checkDimensionMigration(model: string, dimensions: number): void;
-export declare function safeUnlink(filepath: string): void;
-export declare function getErrorMessage(error: unknown): string;
-export declare function isCorruptedModelLoadError(error: unknown): boolean;
-/** Known TEXT_EMBEDDING GGUFs the framework may warm up (same filenames as HuggingFace repos). */
-export interface WarmupReuseEmbeddingCandidate {
-    readonly model: string;
-    readonly modelRepo: string;
-    readonly dimensions: number;
-    readonly contextSize: number;
-    readonly gpuLayers: string;
-}
-/** True if a sanitized GGUF with this basename exists under `modelsDir`. */
-export declare function embeddingGgufFilePresent(modelsDir: string, filename: string): boolean;
-/**
- * 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 declare function findExistingEmbeddingModelForWarmupReuse(modelsDir: string): WarmupReuseEmbeddingCandidate | null;
-export declare function isEmbeddingWarmupReuseDisabled(): boolean;
-export declare function ensureModel(modelsDir: string, repo: string, filename: string, force?: boolean, onProgress?: EmbeddingProgressCallback): Promise<string>;
-export {};
-//# sourceMappingURL=embedding-manager-support.d.ts.map

package/runtime/embedding-manager-support.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embedding-manager-support.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/embedding-manager-support.ts"],"names":[],"mappings":"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"}

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"}