@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/autonomy/index.js

@@ -0,0 +1,344 @@
+const DEFAULT_MAX_EVENTS = 1200;
+function cloneRunHealthMap(runHealthByRunId) {
+    return Object.fromEntries(Object.entries(runHealthByRunId).map(([runId, health]) => [
+        runId,
+        {
+            ...health,
+            missingSeqs: [...health.missingSeqs],
+        },
+    ]));
+}
+function createEmptyStore() {
+    return {
+        eventsById: {},
+        eventOrder: [],
+        runIndex: {},
+        watermark: null,
+    };
+}
+function cloneAutonomyStore(store) {
+    return {
+        eventsById: { ...store.eventsById },
+        eventOrder: [...store.eventOrder],
+        runIndex: Object.fromEntries(Object.entries(store.runIndex).map(([runId, bySeq]) => [
+            runId,
+            { ...bySeq },
+        ])),
+        watermark: store.watermark,
+    };
+}
+function fallbackDedupKey(event) {
+    if (typeof event.runId !== "string" || event.runId.length === 0)
+        return null;
+    if (typeof event.stream !== "string" || event.stream.length === 0)
+        return null;
+    if (typeof event.seq !== "number" || !Number.isFinite(event.seq))
+        return null;
+    return `${event.runId}:${event.seq}:${event.stream}`;
+}
+function hasRunIdAndSeq(event) {
+    return (typeof event.runId === "string" &&
+        event.runId.length > 0 &&
+        typeof event.seq === "number" &&
+        Number.isFinite(event.seq));
+}
+function ensureRunHealth(runHealthByRunId, runId) {
+    let health = runHealthByRunId[runId];
+    if (!health) {
+        health = {
+            runId,
+            status: "ok",
+            lastSeq: null,
+            missingSeqs: [],
+            gapCount: 0,
+        };
+        runHealthByRunId[runId] = health;
+    }
+    return health;
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((a, b) => a - b);
+}
+function parseEventOrdinal(eventId) {
+    const match = /^evt-(\d+)$/.exec(eventId);
+    if (!match)
+        return null;
+    const value = Number.parseInt(match[1] ?? "", 10);
+    return Number.isFinite(value) ? value : null;
+}
+function nextWatermark(current, candidate) {
+    if (!current)
+        return candidate;
+    if (current === candidate)
+        return current;
+    const currentOrdinal = parseEventOrdinal(current);
+    const candidateOrdinal = parseEventOrdinal(candidate);
+    if (currentOrdinal !== null && candidateOrdinal !== null) {
+        return candidateOrdinal > currentOrdinal ? candidate : current;
+    }
+    return candidate;
+}
+function recomputeWatermark(store) {
+    let watermark = null;
+    for (const eventId of store.eventOrder) {
+        if (!store.eventsById[eventId])
+            continue;
+        watermark = nextWatermark(watermark, eventId);
+    }
+    store.watermark = watermark;
+}
+function indexRunEvent(store, event) {
+    if (!hasRunIdAndSeq(event))
+        return;
+    const runId = event.runId;
+    if (runId === "__proto__" ||
+        runId === "constructor" ||
+        runId === "prototype") {
+        return;
+    }
+    const seq = Math.trunc(event.seq);
+    const bySeq = Object.hasOwn(store.runIndex, runId)
+        ? store.runIndex[runId]
+        : {};
+    bySeq[seq] = event.eventId;
+    store.runIndex[runId] = bySeq;
+}
+function addEventToStore(store, event) {
+    store.eventsById[event.eventId] = event;
+    store.eventOrder.push(event.eventId);
+    indexRunEvent(store, event);
+    store.watermark = nextWatermark(store.watermark, event.eventId);
+}
+function removeEventFromStore(store, eventId) {
+    const event = store.eventsById[eventId];
+    if (!event)
+        return;
+    delete store.eventsById[eventId];
+    if (hasRunIdAndSeq(event)) {
+        const runId = event.runId;
+        if (runId === "__proto__" ||
+            runId === "constructor" ||
+            runId === "prototype") {
+            return;
+        }
+        const seq = Math.trunc(event.seq);
+        const bySeq = Object.hasOwn(store.runIndex, runId)
+            ? store.runIndex[runId]
+            : undefined;
+        if (bySeq && bySeq[seq] === eventId) {
+            delete bySeq[seq];
+            if (Object.keys(bySeq).length === 0) {
+                delete store.runIndex[runId];
+            }
+        }
+    }
+}
+function trimStore(store, maxEvents) {
+    if (store.eventOrder.length <= maxEvents) {
+        recomputeWatermark(store);
+        return;
+    }
+    const removeCount = store.eventOrder.length - maxEvents;
+    const removedIds = store.eventOrder.splice(0, removeCount);
+    for (const eventId of removedIds) {
+        removeEventFromStore(store, eventId);
+    }
+    recomputeWatermark(store);
+}
+function hydrateRunHealthFromStore(runHealthByRunId, store) {
+    for (const [runId, bySeq] of Object.entries(store.runIndex)) {
+        const health = ensureRunHealth(runHealthByRunId, runId);
+        const observedSeqs = uniqueSorted(Object.keys(bySeq)
+            .map((seq) => Number(seq))
+            .filter((seq) => Number.isFinite(seq)));
+        const observedSet = new Set(observedSeqs);
+        const missingFromObserved = [];
+        for (let idx = 1; idx < observedSeqs.length; idx += 1) {
+            const previous = observedSeqs[idx - 1];
+            const current = observedSeqs[idx];
+            if (current <= previous + 1)
+                continue;
+            for (let missing = previous + 1; missing < current; missing += 1) {
+                missingFromObserved.push(missing);
+            }
+        }
+        if (observedSeqs.length > 0) {
+            const observedLastSeq = observedSeqs[observedSeqs.length - 1] ?? null;
+            if (observedLastSeq !== null &&
+                (health.lastSeq === null || observedLastSeq > health.lastSeq)) {
+                health.lastSeq = observedLastSeq;
+            }
+        }
+        const mergedMissing = uniqueSorted([
+            ...health.missingSeqs,
+            ...missingFromObserved,
+        ]).filter((missing) => !observedSet.has(missing));
+        health.missingSeqs = mergedMissing;
+        if (health.missingSeqs.length > 0) {
+            if (health.status === "ok" || health.status === "recovered") {
+                health.status = "gap_detected";
+            }
+            if (missingFromObserved.length > 0) {
+                health.gapCount = Math.max(health.gapCount, 1);
+            }
+        }
+    }
+}
+function buildStoreFromEvents(existingEvents, maxEvents) {
+    const store = createEmptyStore();
+    const seenEventIds = new Set();
+    const seenFallbackKeys = new Set();
+    for (const event of existingEvents) {
+        const key = fallbackDedupKey(event);
+        const duplicate = seenEventIds.has(event.eventId) ||
+            (key ? seenFallbackKeys.has(key) : false);
+        if (duplicate)
+            continue;
+        seenEventIds.add(event.eventId);
+        if (key)
+            seenFallbackKeys.add(key);
+        addEventToStore(store, event);
+    }
+    trimStore(store, maxEvents);
+    return store;
+}
+export function buildAutonomyGapReplayRequests(runHealthByRunId, store) {
+    const requests = [];
+    for (const health of Object.values(runHealthByRunId)) {
+        if (health.missingSeqs.length === 0)
+            continue;
+        const indexedSeqs = store.runIndex[health.runId] ?? {};
+        const unresolved = health.missingSeqs.filter((seq) => indexedSeqs[seq] === undefined);
+        if (unresolved.length === 0)
+            continue;
+        requests.push({
+            runId: health.runId,
+            fromSeq: Math.min(...unresolved),
+            missingSeqs: unresolved,
+        });
+    }
+    return requests.sort((left, right) => left.fromSeq - right.fromSeq);
+}
+export function hasPendingAutonomyGaps(runHealthByRunId) {
+    return Object.values(runHealthByRunId).some((health) => health.missingSeqs.length > 0);
+}
+export function markPendingAutonomyGapsPartial(runHealthByRunId, ts = Date.now()) {
+    const next = cloneRunHealthMap(runHealthByRunId);
+    for (const health of Object.values(next)) {
+        if (health.missingSeqs.length === 0)
+            continue;
+        health.status = "partial";
+        health.partialAt = ts;
+    }
+    return next;
+}
+export function mergeAutonomyEvents({ existingEvents, store, incomingEvents, runHealthByRunId, maxEvents = DEFAULT_MAX_EVENTS, replay = false, }) {
+    const initialStore = store
+        ? cloneAutonomyStore(store)
+        : buildStoreFromEvents(existingEvents ?? [], maxEvents);
+    const nextStore = initialStore;
+    const nextRunHealthByRunId = cloneRunHealthMap(runHealthByRunId);
+    hydrateRunHealthFromStore(nextRunHealthByRunId, nextStore);
+    if (incomingEvents.length === 0 && !replay) {
+        const events = nextStore.eventOrder
+            .map((eventId) => nextStore.eventsById[eventId])
+            .filter((event) => Boolean(event));
+        return {
+            store: nextStore,
+            events,
+            latestEventId: nextStore.watermark,
+            runHealthByRunId: nextRunHealthByRunId,
+            insertedCount: 0,
+            duplicateCount: 0,
+            runsWithNewGaps: [],
+            runsRecovered: [],
+            hasUnresolvedGaps: hasPendingAutonomyGaps(nextRunHealthByRunId),
+        };
+    }
+    const seenEventIds = new Set();
+    const seenFallbackKeys = new Set();
+    for (const eventId of nextStore.eventOrder) {
+        const event = nextStore.eventsById[eventId];
+        if (!event)
+            continue;
+        seenEventIds.add(eventId);
+        const key = fallbackDedupKey(event);
+        if (key)
+            seenFallbackKeys.add(key);
+    }
+    let duplicateCount = 0;
+    let insertedCount = 0;
+    const runsWithNewGaps = new Set();
+    const runsRecovered = new Set();
+    for (const event of incomingEvents) {
+        const key = fallbackDedupKey(event);
+        const duplicate = seenEventIds.has(event.eventId) ||
+            (key ? seenFallbackKeys.has(key) : false);
+        if (duplicate) {
+            duplicateCount += 1;
+            continue;
+        }
+        seenEventIds.add(event.eventId);
+        if (key)
+            seenFallbackKeys.add(key);
+        addEventToStore(nextStore, event);
+        insertedCount += 1;
+        if (!hasRunIdAndSeq(event)) {
+            continue;
+        }
+        const health = ensureRunHealth(nextRunHealthByRunId, event.runId);
+        const seq = Math.trunc(event.seq);
+        const previousLastSeq = health.lastSeq;
+        if (previousLastSeq !== null && seq > previousLastSeq + 1) {
+            const missingSeqs = [];
+            for (let current = previousLastSeq + 1; current < seq; current += 1) {
+                missingSeqs.push(current);
+            }
+            health.missingSeqs = uniqueSorted([
+                ...health.missingSeqs,
+                ...missingSeqs,
+            ]);
+            health.status = "gap_detected";
+            health.gapCount += 1;
+            health.lastGapAt = event.ts;
+            runsWithNewGaps.add(event.runId);
+        }
+        if (health.missingSeqs.length > 0) {
+            health.missingSeqs = health.missingSeqs.filter((missing) => missing !== seq);
+        }
+        if (health.lastSeq === null || seq > health.lastSeq) {
+            health.lastSeq = seq;
+        }
+        if (health.missingSeqs.length === 0 &&
+            (health.status === "gap_detected" || health.status === "partial")) {
+            health.status = "recovered";
+            health.recoveredAt = event.ts;
+            runsRecovered.add(event.runId);
+        }
+    }
+    if (replay) {
+        const replayTs = Date.now();
+        for (const health of Object.values(nextRunHealthByRunId)) {
+            if (health.missingSeqs.length === 0)
+                continue;
+            health.status = "partial";
+            health.partialAt = replayTs;
+        }
+    }
+    trimStore(nextStore, maxEvents);
+    const boundedEvents = nextStore.eventOrder
+        .map((eventId) => nextStore.eventsById[eventId])
+        .filter((event) => Boolean(event));
+    const latestEventId = nextStore.watermark;
+    return {
+        store: nextStore,
+        events: boundedEvents,
+        latestEventId,
+        runHealthByRunId: nextRunHealthByRunId,
+        insertedCount,
+        duplicateCount,
+        runsWithNewGaps: [...runsWithNewGaps],
+        runsRecovered: [...runsRecovered],
+        hasUnresolvedGaps: hasPendingAutonomyGaps(nextRunHealthByRunId),
+    };
+}

package/packages/agent/src/awareness/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./registry.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/awareness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/awareness/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/packages/agent/src/awareness/index.js

@@ -0,0 +1 @@
+export * from "./registry.js";

package/packages/agent/src/awareness/registry.d.ts

@@ -1,27 +1,2 @@
-/**
- * AwarenessRegistry — core orchestration layer for the Self-Awareness System.
- *
- * Manages contributor registration, summary composition (Layer 1),
- * detail retrieval (Layer 2), caching, sanitization, and invalidation.
- *
- * @architecture All public methods are fault-tolerant: individual contributor
- * errors are captured and surfaced as `[{id}: unavailable]` markers — the
- * registry itself NEVER throws from composeSummary / getDetail.
- */
-import type { IAgentRuntime } from "@elizaos/core";
-import { type AwarenessContributor, type AwarenessInvalidationEvent } from "../contracts/awareness";
-export declare function setGlobalAwarenessRegistry(registry: AwarenessRegistry): void;
-export declare function getGlobalAwarenessRegistry(): AwarenessRegistry | null;
-export declare class AwarenessRegistry {
-    private readonly contributors;
-    private readonly contributorIds;
-    private readonly cache;
-    register(contributor: AwarenessContributor): void;
-    composeSummary(runtime: IAgentRuntime): Promise<string>;
-    getDetail(runtime: IAgentRuntime, module: string, level: "brief" | "full"): Promise<string>;
-    invalidate(event: AwarenessInvalidationEvent): void;
-    private getCachedSummary;
-    private applyGlobalBudget;
-    private composeAllDetails;
-}
+export { AwarenessRegistry, getGlobalAwarenessRegistry, setGlobalAwarenessRegistry, } from "@elizaos/shared";
 //# sourceMappingURL=registry.d.ts.map

package/packages/agent/src/awareness/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../src/awareness/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAKhC,MAAM,wBAAwB,CAAC;AA4BhC,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAE5E;AAED,wBAAgB,0BAA0B,IAAI,iBAAiB,GAAG,IAAI,CAErE;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IAEvD,QAAQ,CAAC,WAAW,EAAE,oBAAoB,GAAG,IAAI;IAiB3C,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IA0BvD,SAAS,CACb,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GAAG,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC;IAuBlB,UAAU,CAAC,KAAK,EAAE,0BAA0B,GAAG,IAAI;YAQrC,gBAAgB;IAoB9B,OAAO,CAAC,iBAAiB;YAuCX,iBAAiB;CAuBhC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../src/awareness/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC"}

package/packages/agent/src/awareness/registry.js

@@ -1,161 +1 @@
-import { DEFAULT_CACHE_TTL_MS, SELF_STATUS_SCHEMA_VERSION, SUMMARY_CHAR_LIMIT, SUMMARY_TOTAL_CHAR_LIMIT, } from "../contracts/awareness";
-const SANITIZE_PATTERNS = [
-    /sk-ant-\S+/gi,
-    /sk-\S{20,}/gi,
-    /gsk_\S+/gi,
-    /xai-\S+/gi,
-    /0x[a-fA-F0-9]{64}/gi,
-    /[a-fA-F0-9]{64,}/gi,
-    /ignore\s+(all\s+)?(previous\s+)?instructions/gi,
-    /you are now/gi,
-];
-function sanitize(input) {
-    let output = input;
-    for (const pattern of SANITIZE_PATTERNS) {
-        output = output.replace(pattern, "[REDACTED]");
-    }
-    return output;
-}
-let _globalRegistry = null;
-export function setGlobalAwarenessRegistry(registry) {
-    _globalRegistry = registry;
-}
-export function getGlobalAwarenessRegistry() {
-    return _globalRegistry;
-}
-export class AwarenessRegistry {
-    contributors = [];
-    contributorIds = new Set();
-    cache = new Map();
-    register(contributor) {
-        if (this.contributorIds.has(contributor.id)) {
-            throw new Error(`AwarenessRegistry: duplicate contributor id "${contributor.id}"`);
-        }
-        this.contributorIds.add(contributor.id);
-        const idx = this.contributors.findIndex((c) => c.position > contributor.position);
-        if (idx === -1) {
-            this.contributors.push(contributor);
-        }
-        else {
-            this.contributors.splice(idx, 0, contributor);
-        }
-    }
-    async composeSummary(runtime) {
-        const lines = [];
-        for (const contributor of this.contributors) {
-            let line;
-            try {
-                line = await this.getCachedSummary(contributor, runtime);
-            }
-            catch {
-                line = `[${contributor.id}: unavailable]`;
-            }
-            if (line === "")
-                continue;
-            if (contributor.trusted !== true) {
-                line = sanitize(line);
-            }
-            if (line.length > SUMMARY_CHAR_LIMIT) {
-                line = `${line.slice(0, SUMMARY_CHAR_LIMIT - 3)}...`;
-            }
-            lines.push(line);
-        }
-        const header = `[Self Status v${SELF_STATUS_SCHEMA_VERSION}]`;
-        return this.applyGlobalBudget(lines, header);
-    }
-    async getDetail(runtime, module, level) {
-        if (module === "all") {
-            return this.composeAllDetails(runtime, level);
-        }
-        const contributor = this.contributors.find((c) => c.id === module);
-        if (!contributor) {
-            const available = this.contributors.map((c) => c.id).join(", ");
-            return `[Error: unknown module "${module}". Available: ${available}]`;
-        }
-        if (!contributor.detail) {
-            return `[${contributor.id}: no detail available]`;
-        }
-        try {
-            const detail = await contributor.detail(runtime, level);
-            return contributor.trusted !== true ? sanitize(detail) : detail;
-        }
-        catch {
-            return `[${contributor.id}: unavailable]`;
-        }
-    }
-    invalidate(event) {
-        for (const contributor of this.contributors) {
-            if (contributor.invalidateOn?.includes(event)) {
-                this.cache.delete(contributor.id);
-            }
-        }
-    }
-    async getCachedSummary(contributor, runtime) {
-        const ttl = contributor.cacheTtl ?? DEFAULT_CACHE_TTL_MS;
-        const cached = this.cache.get(contributor.id);
-        const now = Date.now();
-        if (cached && cached.expiresAt > now) {
-            return cached.value;
-        }
-        const value = await contributor.summary(runtime);
-        this.cache.set(contributor.id, {
-            value,
-            expiresAt: now + ttl,
-        });
-        return value;
-    }
-    applyGlobalBudget(lines, header) {
-        const headerLen = header.length + 1;
-        let budget = SUMMARY_TOTAL_CHAR_LIMIT - headerLen;
-        const included = [];
-        let remaining = 0;
-        let bodyLen = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const lineLen = lines[i].length + 1;
-            if (budget >= lineLen) {
-                bodyLen =
-                    included.length === 0
-                        ? lines[i].length
-                        : bodyLen + 1 + lines[i].length;
-                included.push(lines[i]);
-                budget -= lineLen;
-            }
-            else {
-                remaining = lines.length - i;
-                break;
-            }
-        }
-        if (remaining > 0) {
-            let suffix = `\n[+${remaining} more]`;
-            while (bodyLen + suffix.length + headerLen + 1 > SUMMARY_TOTAL_CHAR_LIMIT &&
-                included.length > 1) {
-                const removed = included.pop();
-                bodyLen -= removed.length + 1;
-                remaining++;
-                suffix = `\n[+${remaining} more]`;
-            }
-            return `${header}\n${included.join("\n")}${suffix}`;
-        }
-        return `${header}\n${included.join("\n")}`;
-    }
-    async composeAllDetails(runtime, level) {
-        const parts = [];
-        for (const contributor of this.contributors) {
-            if (!contributor.detail) {
-                parts.push(`[${contributor.id}: no detail available]`);
-                continue;
-            }
-            try {
-                let detail = await contributor.detail(runtime, level);
-                if (contributor.trusted !== true) {
-                    detail = sanitize(detail);
-                }
-                parts.push(detail);
-            }
-            catch {
-                parts.push(`[${contributor.id}: unavailable]`);
-            }
-        }
-        return parts.join("\n");
-    }
-}
+export { AwarenessRegistry, getGlobalAwarenessRegistry, setGlobalAwarenessRegistry, } from "@elizaos/shared";

package/packages/agent/src/bin.js

@@ -1,5 +1,50 @@
 #!/usr/bin/env node
-import { runAutonomousCli } from "./cli";
+// Static import so `Bun.build` pulls the AOSP llama loader into the mobile
+// bundle. The adapter self-gates on `ELIZA_LOCAL_LLAMA=1` and no-ops on
+// every other platform/runtime, so the import is safe everywhere; we only
+// need it bundled so `ensure-local-inference-handler.ts`'s dynamic import of
+// `@elizaos/plugin-aosp-local-inference` resolves on-device. Registration
+// itself happens through that handler, not from this side-effect import.
+//
+// We capture the named export into `globalThis` to defeat Bun.build's
+// tree-shaking — a bare side-effect import would let the bundler drop
+// `registerAospLlamaLoader` because nothing else in this entry references it,
+// which is exactly what we observed empirically (only the source-map comment
+// survived, the symbol did not). Dropping it would silently break the
+// dynamic import path on AOSP. Keep this guard pinned.
+// Static import so `Bun.build` pulls the AOSP local-inference bootstrap
+// into the mobile bundle. The bootstrap runs `ensureAospLocalInferenceHandlers`
+// after `startEliza()` returns the runtime, registering TEXT_SMALL /
+// TEXT_LARGE / TEXT_EMBEDDING handlers backed by the AOSP llama loader.
+// Without this static import + globalThis pin, Bun.build tree-shakes the
+// symbol out (the only consumer is a dynamic import in `cli/index.ts`,
+// which is enough for resolution but not for inclusion in some Bun.build
+// configurations). Mirror the `__elizaAospLlamaLoader` pattern.
+import { registerAospLlamaLoader as __elizaAospLlamaLoader, ensureAospLocalInferenceHandlers as __elizaAospLocalInferenceBootstrap, } from "@elizaos/plugin-aosp-local-inference";
+import { ensureMobileDeviceBridgeInferenceHandlers as __elizaMobileDeviceBridgeBootstrap } from "@elizaos/plugin-capacitor-bridge";
+import { runAutonomousCli } from "./cli/index.js";
+// Pull @elizaos/app-{wifi,contacts,phone}'s runtime plugin adapter into the
+// mobile bundle. The adapter imports each app package's `/plugin` subpath,
+// applies the agent-side hosted-app session gate, and Object.assigns those
+// modules into STATIC_ELIZA_PLUGINS so plugin-resolver.ts picks them up before
+// falling through to a wildcard app plugin import that has no
+// node_modules tree to resolve on-device.
+//
+// Dynamic + try/catch instead of a static `import` so non-mobile builds
+// (the Docker agent server image, desktop CLI on a fresh machine) don't
+// crash at module init when those workspace packages aren't installed.
+// Bun.build still bundles the target because the path is a string
+// literal, so the Android bundle keeps the same behavior.
+try {
+    await import("./runtime/android-app-plugins.js");
+}
+catch {
+    // Android-only app plugins not bundled in this build; plugin-resolver.ts
+    // returns null for these IDs and the rest of the runtime is unaffected.
+}
+globalThis.__elizaAospLlamaLoader = __elizaAospLlamaLoader;
+globalThis.__elizaAospLocalInferenceBootstrap = __elizaAospLocalInferenceBootstrap;
+globalThis.__elizaMobileDeviceBridgeBootstrap = __elizaMobileDeviceBridgeBootstrap;
 runAutonomousCli().catch((error) => {
     console.error("[eliza-autonomous] Failed to start:", error instanceof Error ? (error.stack ?? error.message) : error);
     process.exit(1);

package/packages/agent/src/cli/benchmark.d.ts

@@ -0,0 +1,10 @@
+export interface BenchmarkCommandOptions {
+    task?: string;
+    server?: boolean;
+    timeout: string;
+}
+/**
+ * Entry point for the `benchmark` CLI subcommand.
+ */
+export declare function runBenchmark(opts: BenchmarkCommandOptions): Promise<void>;
+//# sourceMappingURL=benchmark.d.ts.map

package/packages/agent/src/cli/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../../../../src/cli/benchmark.ts"],"names":[],"mappings":"AA4SA,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA0Ef"}