@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/api/media-store.js

@@ -0,0 +1,461 @@
+/**
+ * Local content-addressed media store for chat attachments.
+ *
+ * Bytes uploaded by the user or generated by the agent are written under
+ * `${STATE_DIR}/media/<sha256>.<ext>` and referenced by a served
+ * `/api/media/<sha256>.<ext>` URL. Content addressing gives free
+ * de-duplication: the same image attached twice is stored once and reuses its
+ * description cache (keyed on the same hash), and only a compact served URL —
+ * never raw base64 — lands in the message record or the agent's context.
+ *
+ * The sha256 filename is an unguessable capability, so media is served before
+ * the auth gate (like static assets); `<img>`/`<audio>` requests carry no auth
+ * header. `serveMediaFile` only ever serves names matching the strict
+ * content-addressed pattern from the dedicated media directory.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { resolveStateDir } from "../config/paths.js";
+import { generateThumbnailBytes } from "./media-thumbnail.js";
+const EXT_BY_MIME = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/webp": "webp",
+    "image/gif": "gif",
+    "image/avif": "avif",
+    "image/bmp": "bmp",
+    "image/svg+xml": "svg",
+    "audio/mpeg": "mp3",
+    "audio/mp3": "mp3",
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "audio/wave": "wav",
+    "audio/ogg": "ogg",
+    "audio/webm": "weba",
+    "audio/mp4": "m4a",
+    "audio/aac": "aac",
+    "audio/flac": "flac",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/quicktime": "mov",
+    "video/ogg": "ogv",
+    "application/pdf": "pdf",
+    "text/plain": "txt",
+    "text/csv": "csv",
+    "text/markdown": "md",
+    "application/json": "json",
+};
+const MIME_BY_EXT = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+    avif: "image/avif",
+    bmp: "image/bmp",
+    svg: "image/svg+xml",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    oga: "audio/ogg",
+    weba: "audio/webm",
+    m4a: "audio/mp4",
+    aac: "audio/aac",
+    flac: "audio/flac",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime",
+    ogv: "video/ogg",
+    pdf: "application/pdf",
+    txt: "text/plain; charset=utf-8",
+    csv: "text/csv; charset=utf-8",
+    md: "text/markdown; charset=utf-8",
+    json: "application/json; charset=utf-8",
+    bin: "application/octet-stream",
+};
+/** Strict content-addressed name: 64-hex sha256 + short alphanumeric extension. */
+const MEDIA_FILE_NAME = /^[a-f0-9]{64}\.[a-z0-9]{1,8}$/;
+const MEDIA_URL_PREFIX = "/api/media/";
+let cachedMediaDir = null;
+function mediaDir() {
+    if (cachedMediaDir)
+        return cachedMediaDir;
+    const dir = path.join(resolveStateDir(), "media");
+    fs.mkdirSync(dir, { recursive: true });
+    cachedMediaDir = dir;
+    return dir;
+}
+function extForMime(mimeType) {
+    return EXT_BY_MIME[mimeType.trim().toLowerCase()] ?? "bin";
+}
+// ---------------------------------------------------------------------------
+// Size-capped eviction
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_STORE_BYTES = 2 * 1024 * 1024 * 1024; // 2 GB
+const EVICT_INTERVAL_MS = 30_000;
+let lastEvictAt = 0;
+function maxStoreBytes() {
+    const raw = process.env.ELIZA_MEDIA_STORE_MAX_BYTES;
+    const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    return Number.isFinite(parsed) && parsed > 0
+        ? parsed
+        : DEFAULT_MAX_STORE_BYTES;
+}
+/**
+ * Pure eviction policy: given the current files and a byte cap, return the
+ * names to delete (oldest-by-mtime first) so the store drops to 90% of the
+ * cap. Returns [] when already within budget. Exported for unit tests.
+ */
+export function selectMediaToEvict(files, cap) {
+    let total = files.reduce((sum, file) => sum + file.size, 0);
+    if (total <= cap)
+        return [];
+    const target = Math.floor(cap * 0.9);
+    const oldestFirst = [...files].sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const evict = [];
+    for (const file of oldestFirst) {
+        if (total <= target)
+            break;
+        evict.push(file.name);
+        total -= file.size;
+    }
+    return evict;
+}
+/**
+ * Best-effort FIFO eviction so the local media store never grows without
+ * bound. Throttled to once per {@link EVICT_INTERVAL_MS}; when the directory
+ * exceeds the cap it deletes oldest-by-mtime files down to 90% of the cap.
+ * Content is immutable + content-addressed, so an evicted file simply re-saves
+ * if the same bytes are uploaded again. A message that references evicted media
+ * renders a broken tile — the cap defaults to 2 GB so this only bites under
+ * heavy use, and is tunable via `ELIZA_MEDIA_STORE_MAX_BYTES`.
+ */
+function maybeEvict() {
+    const now = Date.now();
+    if (now - lastEvictAt < EVICT_INTERVAL_MS)
+        return;
+    lastEvictAt = now;
+    try {
+        const dir = mediaDir();
+        const files = [];
+        for (const name of fs.readdirSync(dir)) {
+            try {
+                const stat = fs.statSync(path.join(dir, name));
+                if (!stat.isFile())
+                    continue;
+                files.push({ name, size: stat.size, mtimeMs: stat.mtimeMs });
+            }
+            catch {
+                // file vanished mid-scan — ignore
+            }
+        }
+        const evict = selectMediaToEvict(files, maxStoreBytes());
+        let evicted = 0;
+        for (const name of evict) {
+            try {
+                fs.unlinkSync(path.join(dir, name));
+                evicted += 1;
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (evicted > 0) {
+            logger.info(`[media-store] evicted ${evicted} file(s) over size cap`);
+        }
+    }
+    catch (err) {
+        logger.warn(`[media-store] eviction scan failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/** Write bytes to the content-addressed store (idempotent) and return the served URL. */
+export function persistMediaBytes(buffer, mimeType) {
+    const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+    const fileName = `${hash}.${extForMime(mimeType)}`;
+    const filePath = path.join(mediaDir(), fileName);
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, buffer);
+        maybeEvict();
+    }
+    return { url: `${MEDIA_URL_PREFIX}${fileName}`, hash, fileName };
+}
+const DATA_URL_RE = /^data:([^;,]*)(;base64)?,([\s\S]*)$/;
+/** Persist a `data:` URL's bytes to the store; returns null for non-data URLs. */
+export function persistDataUrl(dataUrl) {
+    const match = DATA_URL_RE.exec(dataUrl.trim());
+    if (!match)
+        return null;
+    const mimeType = match[1] || "application/octet-stream";
+    const isBase64 = Boolean(match[2]);
+    const payload = match[3] ?? "";
+    let buffer;
+    try {
+        buffer = isBase64
+            ? Buffer.from(payload, "base64")
+            : Buffer.from(decodeURIComponent(payload), "utf8");
+    }
+    catch {
+        return null;
+    }
+    if (buffer.length === 0)
+        return null;
+    return persistMediaBytes(buffer, mimeType);
+}
+/** True when a URL already points at this store (no need to re-persist). */
+export function isStoredMediaUrl(url) {
+    return url.startsWith(MEDIA_URL_PREFIX);
+}
+/** Extract the stored filename (`<sha256>.<ext>`) from a served media URL, else null. */
+export function mediaFileNameFromUrl(url) {
+    if (typeof url !== "string" || !url.startsWith(MEDIA_URL_PREFIX))
+        return null;
+    const name = url.slice(MEDIA_URL_PREFIX.length).split(/[?#]/)[0] ?? "";
+    return MEDIA_FILE_NAME.test(name) ? name : null;
+}
+// Orphan GC grace: never delete files younger than this, so media that was just
+// persisted but not yet referenced by a saved message (or just served) survives.
+const GC_MIN_AGE_MS = 60 * 60 * 1000;
+/**
+ * Delete stored media files not referenced by any live attachment. `referenced`
+ * is the set of `<sha256>.<ext>` filenames still in use (built from message
+ * attachment URLs via {@link mediaFileNameFromUrl}). Files younger than the
+ * grace window are kept. Best-effort; returns counts.
+ */
+export function gcUnreferencedMedia(referenced) {
+    let removed = 0;
+    let scanned = 0;
+    try {
+        const dir = mediaDir();
+        const now = Date.now();
+        for (const name of fs.readdirSync(dir)) {
+            if (!MEDIA_FILE_NAME.test(name))
+                continue;
+            scanned += 1;
+            if (referenced.has(name))
+                continue;
+            try {
+                const stat = fs.statSync(path.join(dir, name));
+                if (now - stat.mtimeMs < GC_MIN_AGE_MS)
+                    continue; // grace window
+                fs.unlinkSync(path.join(dir, name));
+                removed += 1;
+            }
+            catch {
+                // ignore individual file errors
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`[media-store] GC scan failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (removed > 0) {
+        logger.info(`[media-store] GC removed ${removed} unreferenced file(s) of ${scanned}`);
+    }
+    return { removed, scanned };
+}
+function mimeForFile(fileName) {
+    const ext = fileName.split(".").pop()?.toLowerCase() ?? "bin";
+    return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+// Touch-on-serve → LRU: bump the file's mtime when it's served so eviction
+// (oldest-mtime-first) keeps frequently-viewed media and drops the truly cold
+// files. Throttled per file so a burst of range requests doesn't thrash the fs.
+const TOUCH_THROTTLE_MS = 60_000;
+const lastTouchedAt = new Map();
+function touchOnServe(filePath) {
+    const now = Date.now();
+    if (now - (lastTouchedAt.get(filePath) ?? 0) < TOUCH_THROTTLE_MS)
+        return;
+    lastTouchedAt.set(filePath, now);
+    try {
+        const stamp = new Date(now);
+        fs.utimesSync(filePath, stamp, stamp);
+    }
+    catch {
+        // best-effort — atime/mtime updates can fail on some filesystems
+    }
+}
+/**
+ * Validate a `/api/media/<name>` path and stat the file, bumping its mtime for
+ * LRU. Returns the resolved file or an HTTP status (400 bad name, 404 missing).
+ * Shared by the HTTP serve path and the in-process (iOS IPC) route handler.
+ */
+function resolveMediaFile(pathname) {
+    let name;
+    try {
+        name = decodeURIComponent(pathname.slice(MEDIA_URL_PREFIX.length));
+    }
+    catch {
+        return { error: 400 };
+    }
+    if (!MEDIA_FILE_NAME.test(name))
+        return { error: 400 };
+    const filePath = path.join(mediaDir(), name);
+    // Defence in depth against traversal — name is already pattern-validated.
+    if (path.dirname(filePath) !== mediaDir())
+        return { error: 400 };
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+        if (!stat.isFile())
+            throw new Error("not a file");
+    }
+    catch {
+        return { error: 404 };
+    }
+    touchOnServe(filePath);
+    return { filePath, size: stat.size, contentType: mimeForFile(name) };
+}
+/**
+ * Serve a media file for the IN-PROCESS route path (iOS, where no HTTP server
+ * runs and requests are dispatched over `runtime.routes`). Returns a
+ * RouteHandlerResult-shaped object with a `Buffer` body; the native bridge
+ * base64-encodes it losslessly. No Range support — the in-process path buffers
+ * the whole file, which is fine for local on-device media.
+ */
+export function handleMediaRouteRequest(pathname, method) {
+    const TEXT = { "Content-Type": "text/plain; charset=utf-8" };
+    if (method !== "GET" && method !== "HEAD") {
+        return {
+            status: 405,
+            headers: TEXT,
+            body: Buffer.from("Method not allowed"),
+        };
+    }
+    const resolved = resolveMediaFile(pathname);
+    if ("error" in resolved) {
+        return {
+            status: resolved.error,
+            headers: TEXT,
+            body: Buffer.from(resolved.error === 400 ? "Bad media name" : "Not found"),
+        };
+    }
+    const headers = {
+        "Content-Type": resolved.contentType,
+        "Cache-Control": "public, max-age=31536000, immutable",
+        "Content-Length": String(resolved.size),
+    };
+    if (method === "HEAD")
+        return { status: 200, headers };
+    return { status: 200, headers, body: fs.readFileSync(resolved.filePath) };
+}
+/**
+ * Serve a stored media file for `GET/HEAD /api/media/<name>`. Returns true when
+ * the request was handled (including 404/400). Supports HTTP Range so `<video>`
+ * / `<audio>` seeking works. Bytes are immutable (content-addressed) so they
+ * carry a long immutable Cache-Control.
+ */
+export function serveMediaFile(req, res, pathname) {
+    if (!pathname.startsWith(MEDIA_URL_PREFIX))
+        return false;
+    const method = req.method ?? "GET";
+    if (method !== "GET" && method !== "HEAD")
+        return false;
+    const resolved = resolveMediaFile(pathname);
+    if ("error" in resolved) {
+        res.writeHead(resolved.error, {
+            "Content-Type": "text/plain; charset=utf-8",
+        });
+        res.end(resolved.error === 400 ? "Bad media name" : "Not found");
+        return true;
+    }
+    const { filePath, size, contentType } = resolved;
+    const baseHeaders = {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=31536000, immutable",
+        "Accept-Ranges": "bytes",
+    };
+    const range = req.headers.range;
+    if (range && method === "GET") {
+        const match = /^bytes=(\d*)-(\d*)$/.exec(range.trim());
+        if (match) {
+            const startRaw = match[1];
+            const endRaw = match[2];
+            let start = startRaw ? Number.parseInt(startRaw, 10) : 0;
+            let end = endRaw ? Number.parseInt(endRaw, 10) : size - 1;
+            if (!startRaw && endRaw) {
+                // suffix range: last N bytes
+                start = Math.max(0, size - Number.parseInt(endRaw, 10));
+                end = size - 1;
+            }
+            if (Number.isNaN(start) ||
+                Number.isNaN(end) ||
+                start > end ||
+                start >= size) {
+                res.writeHead(416, {
+                    "Content-Range": `bytes */${size}`,
+                    "Content-Type": "text/plain; charset=utf-8",
+                });
+                res.end("Range not satisfiable");
+                return true;
+            }
+            end = Math.min(end, size - 1);
+            res.writeHead(206, {
+                ...baseHeaders,
+                "Content-Range": `bytes ${start}-${end}/${size}`,
+                "Content-Length": end - start + 1,
+            });
+            fs.createReadStream(filePath, { start, end }).pipe(res);
+            return true;
+        }
+    }
+    res.writeHead(200, { ...baseHeaders, "Content-Length": size });
+    if (method === "HEAD") {
+        res.end();
+        return true;
+    }
+    fs.createReadStream(filePath).pipe(res);
+    return true;
+}
+/**
+ * Generate a downscaled thumbnail from raw image bytes and persist it as its
+ * own store entry. Returns the thumbnail's served URL, or null when the image
+ * isn't thumbnailable / already small / the resizer is unavailable. Best-effort.
+ */
+export async function persistImageThumbnail(source, srcMimeType) {
+    try {
+        const thumb = await generateThumbnailBytes(source, srcMimeType);
+        if (!thumb)
+            return null;
+        return persistMediaBytes(thumb.buffer, thumb.mimeType).url;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Pre-compute a thumbnail for an already-stored image file (e.g. an
+ * agent-generated image just persisted from a data: URL). Reads the stored
+ * bytes, downscales, and persists the thumbnail. Returns its served URL or null.
+ */
+export async function ensureThumbnailForStoredFile(fileName) {
+    if (!MEDIA_FILE_NAME.test(fileName))
+        return null;
+    const srcMime = mimeForFile(fileName);
+    if (!srcMime.startsWith("image/"))
+        return null;
+    let buffer;
+    try {
+        buffer = fs.readFileSync(path.join(mediaDir(), fileName));
+    }
+    catch {
+        return null;
+    }
+    return persistImageThumbnail(buffer, srcMime);
+}
+/** Best-effort: convert a `data:` URL on an attachment to a stored served URL. */
+export function persistAttachmentUrlIfInline(url) {
+    if (!url.startsWith("data:"))
+        return url;
+    try {
+        const persisted = persistDataUrl(url);
+        return persisted?.url ?? url;
+    }
+    catch (err) {
+        logger.warn(`[media-store] failed to persist inline data URL: ${err instanceof Error ? err.message : String(err)}`);
+        return url;
+    }
+}

package/api/media-thumbnail.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Portable server-side image thumbnailing — pure-JS (pngjs + jpeg-js), no
+ * native `sharp` (which can't load in the mobile JS bundle) and no jimp (whose
+ * `@jimp/*` sub-packages don't resolve cleanly under bun's hoisting). The two
+ * codecs are dynamically imported behind an indirected specifier so the mobile
+ * bundler doesn't pull them in and every failure path returns null — callers
+ * degrade gracefully to serving the full image.
+ *
+ * Covers PNG + JPEG, which is what agent-generated / connector-ingested images
+ * are; browser/webview uploads already thumbnail client-side via `<canvas>` and
+ * cover every other format (webp, etc.).
+ */
+/**
+ * Downscale a PNG/JPEG buffer to a ≤512px JPEG thumbnail. Returns null when the
+ * input isn't a supported raster, is already within bounds, the codecs are
+ * unavailable, or decoding fails.
+ */
+export declare function generateThumbnailBytes(source: Buffer, srcMimeType: string): Promise<{
+    buffer: Buffer;
+    mimeType: string;
+} | null>;
+//# sourceMappingURL=media-thumbnail.d.ts.map

package/api/media-thumbnail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-thumbnail.d.ts","sourceRoot":"","sources":["../../src/api/media-thumbnail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAmGH;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAiCtD"}

package/api/media-thumbnail.js

@@ -0,0 +1,121 @@
+/**
+ * Portable server-side image thumbnailing — pure-JS (pngjs + jpeg-js), no
+ * native `sharp` (which can't load in the mobile JS bundle) and no jimp (whose
+ * `@jimp/*` sub-packages don't resolve cleanly under bun's hoisting). The two
+ * codecs are dynamically imported behind an indirected specifier so the mobile
+ * bundler doesn't pull them in and every failure path returns null — callers
+ * degrade gracefully to serving the full image.
+ *
+ * Covers PNG + JPEG, which is what agent-generated / connector-ingested images
+ * are; browser/webview uploads already thumbnail client-side via `<canvas>` and
+ * cover every other format (webp, etc.).
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { logger } from "@elizaos/core";
+/** Longest edge (px) of a generated thumbnail — matches the client-side bound. */
+const THUMBNAIL_MAX_DIM = 512;
+const THUMBNAILABLE_MIME = /^image\/(png|jpe?g)$/i;
+const PNGJS_MODULE_ID = "pngjs";
+const JPEGJS_MODULE_ID = "jpeg-js";
+let codecs = null;
+let codecLoadAttempted = false;
+async function loadCodecs() {
+    if (codecLoadAttempted)
+        return codecs;
+    codecLoadAttempted = true;
+    try {
+        const pngMod = (await import(__rewriteRelativeImportExtension(PNGJS_MODULE_ID)));
+        const jpegModRaw = (await import(__rewriteRelativeImportExtension(JPEGJS_MODULE_ID)));
+        const PNG = pngMod.PNG;
+        const jpeg = (jpegModRaw.default ?? jpegModRaw);
+        if (PNG?.sync?.read &&
+            typeof jpeg?.decode === "function" &&
+            typeof jpeg?.encode === "function") {
+            codecs = { png: PNG, jpeg };
+        }
+        else {
+            codecs = null;
+        }
+    }
+    catch {
+        codecs = null;
+    }
+    return codecs;
+}
+/** Area-average downscale of an RGBA buffer (good quality for shrinking). */
+function downscaleRGBA(src, sw, sh, tw, th) {
+    const out = Buffer.alloc(tw * th * 4);
+    for (let ty = 0; ty < th; ty++) {
+        const sy0 = Math.floor((ty * sh) / th);
+        const sy1 = Math.max(sy0 + 1, Math.floor(((ty + 1) * sh) / th));
+        for (let tx = 0; tx < tw; tx++) {
+            const sx0 = Math.floor((tx * sw) / tw);
+            const sx1 = Math.max(sx0 + 1, Math.floor(((tx + 1) * sw) / tw));
+            let r = 0;
+            let g = 0;
+            let b = 0;
+            let a = 0;
+            let n = 0;
+            for (let sy = sy0; sy < sy1 && sy < sh; sy++) {
+                for (let sx = sx0; sx < sx1 && sx < sw; sx++) {
+                    const i = (sy * sw + sx) * 4;
+                    r += src[i];
+                    g += src[i + 1];
+                    b += src[i + 2];
+                    a += src[i + 3];
+                    n++;
+                }
+            }
+            const o = (ty * tw + tx) * 4;
+            out[o] = Math.round(r / n);
+            out[o + 1] = Math.round(g / n);
+            out[o + 2] = Math.round(b / n);
+            out[o + 3] = Math.round(a / n);
+        }
+    }
+    return out;
+}
+/**
+ * Downscale a PNG/JPEG buffer to a ≤512px JPEG thumbnail. Returns null when the
+ * input isn't a supported raster, is already within bounds, the codecs are
+ * unavailable, or decoding fails.
+ */
+export async function generateThumbnailBytes(source, srcMimeType) {
+    if (!THUMBNAILABLE_MIME.test(srcMimeType))
+        return null;
+    const loaded = await loadCodecs();
+    if (!loaded)
+        return null;
+    try {
+        const isPng = /png/i.test(srcMimeType);
+        const decoded = isPng
+            ? loaded.png.sync.read(source)
+            : loaded.jpeg.decode(source, { useTArray: true, formatAsRGBA: true });
+        const { width, height, data } = decoded;
+        const longest = Math.max(width, height);
+        if (!longest || longest <= THUMBNAIL_MAX_DIM)
+            return null;
+        const scale = THUMBNAIL_MAX_DIM / longest;
+        const tw = Math.max(1, Math.round(width * scale));
+        const th = Math.max(1, Math.round(height * scale));
+        const resized = downscaleRGBA(data, width, height, tw, th);
+        const encoded = loaded.jpeg.encode({ width: tw, height: th, data: resized }, 72);
+        const buffer = Buffer.isBuffer(encoded.data)
+            ? encoded.data
+            : Buffer.from(encoded.data);
+        if (buffer.length === 0)
+            return null;
+        return { buffer, mimeType: "image/jpeg" };
+    }
+    catch (err) {
+        logger.debug(`[media-thumbnail] generation failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/api/memory-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-bounds.d.ts","sourceRoot":"","sources":["../../src/api/memory-bounds.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,EAChC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GAChB,IAAI,CAKN;AAID,UAAU,gBAAgB;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,gBAAgB,EAChE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EACnB,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,IAAI,CAcf;AAID;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,CAAC,EAAE,EACX,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,MAAM,CAMR;AAID,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAC/B,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,GACpB,MAAM,CAaR"}

package/api/memory-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-routes.d.ts","sourceRoot":"","sources":["../../src/api/memory-routes.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EASlB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAgC3D,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAkSD,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,OAAO,CAAC,CA8VlB"}