@elizaos/agent 2.0.0-beta.2 → 2.0.3-beta.3

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

@@ -0,0 +1,50 @@
+/**
+ * Pure helper functions for bounded in-memory data structures.
+ *
+ * @module
+ */
+interface RateLimitEntry {
+    count: number;
+    resetAt: number;
+}
+/**
+ * Evict expired entries from a rate-limit map when it exceeds `threshold`.
+ * Safe to call during iteration (Map spec permits deletion during for-of).
+ */
+export declare function sweepExpiredEntries(map: Map<string, RateLimitEntry>, now: number, threshold: number): void;
+interface ConversationLike {
+    updatedAt: string;
+}
+/**
+ * Evict the oldest conversation (by `updatedAt`) when the map exceeds `cap`.
+ * Returns the evicted key, or null if no eviction was needed.
+ */
+export declare function evictOldestConversation<T extends ConversationLike>(map: Map<string, T>, cap: number): string | null;
+/**
+ * Push an entry to a bounded buffer and batch-evict when the high-water
+ * mark is reached.  Returns the current buffer length.
+ *
+ * @param buffer   - The array to push into.
+ * @param entry    - The item to append.
+ * @param highWater - Trigger eviction when `buffer.length` exceeds this.
+ * @param evictCount - Number of oldest entries to remove on eviction.
+ */
+export declare function pushWithBatchEvict<T>(buffer: T[], entry: T, highWater: number, evictCount: number): number;
+interface CachedFile {
+    body: Buffer;
+    mtimeMs: number;
+}
+/**
+ * Retrieve a file from a bounded cache, reading from disk on miss.
+ * Files larger than `fileSizeLimit` are never cached.
+ *
+ * @param cache         - The Map serving as the LRU-ish cache.
+ * @param filePath      - Absolute path to the file.
+ * @param mtimeMs       - File's last-modified time (for invalidation).
+ * @param readFile      - Callback that reads the file (injected for testing).
+ * @param maxEntries    - Maximum number of cached files.
+ * @param fileSizeLimit - Maximum file size (bytes) eligible for caching.
+ */
+export declare function getOrReadCachedFile(cache: Map<string, CachedFile>, filePath: string, mtimeMs: number, readFile: (p: string) => Buffer, maxEntries: number, fileSizeLimit: number): Buffer;
+export {};
+//# sourceMappingURL=memory-bounds.d.ts.map

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;;;;GAIG;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-bounds.js

@@ -0,0 +1,80 @@
+/**
+ * Pure helper functions for bounded in-memory data structures.
+ *
+ * @module
+ */
+/**
+ * Evict expired entries from a rate-limit map when it exceeds `threshold`.
+ * Safe to call during iteration (Map spec permits deletion during for-of).
+ */
+export function sweepExpiredEntries(map, now, threshold) {
+    if (map.size <= threshold)
+        return;
+    for (const [k, v] of map) {
+        if (now > v.resetAt)
+            map.delete(k);
+    }
+}
+/**
+ * Evict the oldest conversation (by `updatedAt`) when the map exceeds `cap`.
+ * Returns the evicted key, or null if no eviction was needed.
+ */
+export function evictOldestConversation(map, cap) {
+    if (map.size <= cap)
+        return null;
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [k, v] of map) {
+        const t = new Date(v.updatedAt).getTime();
+        if (t < oldestTime) {
+            oldestTime = t;
+            oldestKey = k;
+        }
+    }
+    if (oldestKey)
+        map.delete(oldestKey);
+    return oldestKey;
+}
+// ── Log buffer batch eviction ─────────────────────────────────────────
+/**
+ * Push an entry to a bounded buffer and batch-evict when the high-water
+ * mark is reached.  Returns the current buffer length.
+ *
+ * @param buffer   - The array to push into.
+ * @param entry    - The item to append.
+ * @param highWater - Trigger eviction when `buffer.length` exceeds this.
+ * @param evictCount - Number of oldest entries to remove on eviction.
+ */
+export function pushWithBatchEvict(buffer, entry, highWater, evictCount) {
+    buffer.push(entry);
+    if (buffer.length > highWater) {
+        buffer.splice(0, evictCount);
+    }
+    return buffer.length;
+}
+/**
+ * Retrieve a file from a bounded cache, reading from disk on miss.
+ * Files larger than `fileSizeLimit` are never cached.
+ *
+ * @param cache         - The Map serving as the LRU-ish cache.
+ * @param filePath      - Absolute path to the file.
+ * @param mtimeMs       - File's last-modified time (for invalidation).
+ * @param readFile      - Callback that reads the file (injected for testing).
+ * @param maxEntries    - Maximum number of cached files.
+ * @param fileSizeLimit - Maximum file size (bytes) eligible for caching.
+ */
+export function getOrReadCachedFile(cache, filePath, mtimeMs, readFile, maxEntries, fileSizeLimit) {
+    const cached = cache.get(filePath);
+    if (cached && cached.mtimeMs === mtimeMs)
+        return cached.body;
+    const body = readFile(filePath);
+    if (body.length <= fileSizeLimit) {
+        if (cache.size >= maxEntries) {
+            const firstKey = cache.keys().next().value;
+            if (firstKey !== undefined)
+                cache.delete(firstKey);
+        }
+        cache.set(filePath, { body, mtimeMs });
+    }
+    return body;
+}

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