@elizaos/ui 2.0.0-alpha.526 → 2.0.0-alpha.528

package/packages/app-core/src/services/account-usage.js

@@ -0,0 +1,179 @@
+/**
+ * Account usage probes + local JSONL counters.
+ *
+ * Two responsibilities:
+ *  1. Probe provider usage APIs (`pollAnthropicUsage`, `pollCodexUsage`)
+ *     to populate the `LinkedAccountUsage` snapshot on each account.
+ *  2. Maintain append-only JSONL counters per `(providerId, accountId, day)`
+ *     so we can answer "calls made today / tokens used / errors" without
+ *     re-reading every trajectory.
+ *
+ * The probes throw on HTTP error so the caller can decide whether to mark
+ * the account as `rate-limited` / `needs-reauth` / `invalid`. The counters
+ * are best-effort and synchronous — at our scale appendFileSync is fine.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const ANTHROPIC_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+function utilizationToPct(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    // Provider returns either 0..1 (legacy) or 0..100 — both are normalized
+    // to percent. Anthropic ships 0..1, so we always multiply.
+    return Math.max(0, Math.min(100, value * 100));
+}
+function normalizeResetTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        // Heuristic: epoch seconds vs ms. Seconds will be ~1.7e9 today; ms is ~1.7e12.
+        return value < 1e12 ? value * 1000 : value;
+    }
+    if (typeof value === "string" && value.length > 0) {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+/**
+ * Probe Anthropic's OAuth usage endpoint.
+ *
+ * Endpoint: `GET https://api.anthropic.com/api/oauth/usage`
+ * Headers : `Authorization: Bearer <accessToken>`,
+ *           `anthropic-beta: oauth-2025-04-20`,
+ *           `Content-Type: application/json`
+ *
+ * Handles both legacy flat (`five_hour_utilization`) and new nested
+ * (`five_hour: { utilization }`) response shapes. Throws on any HTTP
+ * error with the status code included in the message.
+ */
+export async function pollAnthropicUsage(accessToken, fetchImpl = fetch) {
+    const res = await fetchImpl(ANTHROPIC_USAGE_URL, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "anthropic-beta": "oauth-2025-04-20",
+            "Content-Type": "application/json",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Anthropic usage probe failed: HTTP ${res.status}`);
+    }
+    const payload = (await res.json());
+    const fiveHour = payload.five_hour;
+    const sevenDay = payload.seven_day;
+    const sessionPct = utilizationToPct(fiveHour?.utilization) ??
+        utilizationToPct(payload.five_hour_utilization);
+    const weeklyPct = utilizationToPct(sevenDay?.utilization) ??
+        utilizationToPct(payload.seven_day_utilization);
+    const resetsAt = normalizeResetTimestamp(fiveHour?.resets_at) ??
+        normalizeResetTimestamp(payload.five_hour_resets_at);
+    return {
+        refreshedAt: Date.now(),
+        ...(sessionPct !== undefined ? { sessionPct } : {}),
+        ...(weeklyPct !== undefined ? { weeklyPct } : {}),
+        ...(resetsAt !== undefined ? { resetsAt } : {}),
+    };
+}
+/**
+ * Probe Codex / ChatGPT's usage endpoint.
+ *
+ * Endpoint: `GET https://chatgpt.com/backend-api/wham/usage`
+ * Headers : `Authorization: Bearer <accessToken>`,
+ *           `ChatGPT-Account-Id: <openAIAccountId>`,
+ *           `User-Agent: codex-cli`
+ *
+ * `used_percent` is already on the 0..100 scale. `reset_at` is epoch
+ * seconds. Codex has no weekly equivalent, so `weeklyPct` stays undefined.
+ */
+export async function pollCodexUsage(accessToken, accountId, fetchImpl = fetch) {
+    const res = await fetchImpl(CODEX_USAGE_URL, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "ChatGPT-Account-Id": accountId,
+            "User-Agent": "codex-cli",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Codex usage probe failed: HTTP ${res.status}`);
+    }
+    const payload = (await res.json());
+    const primary = payload.rate_limit?.primary_window;
+    let sessionPct;
+    if (typeof primary?.used_percent === "number" &&
+        Number.isFinite(primary.used_percent)) {
+        sessionPct = Math.max(0, Math.min(100, primary.used_percent));
+    }
+    const resetsAt = normalizeResetTimestamp(primary?.reset_at);
+    return {
+        refreshedAt: Date.now(),
+        ...(sessionPct !== undefined ? { sessionPct } : {}),
+        ...(resetsAt !== undefined ? { resetsAt } : {}),
+    };
+}
+// Local JSONL counters.
+function elizaHome() {
+    return process.env.ELIZA_HOME || path.join(os.homedir(), ".eliza");
+}
+function dayStamp(ts = Date.now()) {
+    const d = new Date(ts);
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(d.getUTCDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+}
+function counterFile(providerId, accountId, ts = Date.now()) {
+    return path.join(elizaHome(), "usage", providerId, accountId, `${dayStamp(ts)}.jsonl`);
+}
+/**
+ * Append a usage entry for the given `(providerId, accountId)` pair.
+ * One line per call, written synchronously with mode 0o600. The day
+ * directory is created on demand.
+ */
+export function recordCall(providerId, accountId, entry) {
+    const ts = Date.now();
+    const line = { ts, ...entry };
+    const file = counterFile(providerId, accountId, ts);
+    const dir = path.dirname(file);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    appendFileSync(file, `${JSON.stringify(line)}\n`, {
+        flag: "a",
+        mode: 0o600,
+    });
+}
+/**
+ * Read today's JSONL and aggregate `(calls, tokens, errors)`. Lines that
+ * fail to parse are skipped silently (best-effort).
+ */
+export function readTodayCounters(providerId, accountId) {
+    const file = counterFile(providerId, accountId);
+    if (!existsSync(file)) {
+        return { calls: 0, tokens: 0, errors: 0 };
+    }
+    const raw = readFileSync(file, "utf-8");
+    let calls = 0;
+    let tokens = 0;
+    let errors = 0;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        calls += 1;
+        if (typeof parsed.tokens === "number" && Number.isFinite(parsed.tokens)) {
+            tokens += parsed.tokens;
+        }
+        if (parsed.ok === false) {
+            errors += 1;
+        }
+    }
+    return { calls, tokens, errors };
+}

package/packages/app-core/src/services/local-inference/active-model.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Coordinates which model is currently loaded into the plugin-local-ai
+ * runtime. Milady runs one inference model at a time; switching models
+ * unloads the previous one first so we don't double-allocate VRAM.
+ *
+ * This module *does not* talk to `node-llama-cpp` directly. The plugin
+ * owns the native binding; we ask it to swap via a small runtime service
+ * registered under the name "localInferenceLoader". When the plugin is not
+ * enabled, we still track the user's preferred active model so the
+ * preference survives enabling the plugin later.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { ActiveModelState, InstalledModel } from "./types";
+export interface LocalInferenceLoader {
+    loadModel(args: {
+        modelPath: string;
+    }): Promise<void>;
+    unloadModel(): Promise<void>;
+    currentModelPath(): string | null;
+    /**
+     * Optional generation surface. When a loader implements this, the runtime
+     * handler (`ensure-local-inference-handler.ts`) routes TEXT_SMALL /
+     * TEXT_LARGE requests through it instead of the standalone engine. Mobile
+     * builds populate this via the Capacitor adapter; desktop leaves it
+     * unimplemented and falls back to the `LocalInferenceEngine`.
+     */
+    generate?(args: {
+        prompt: string;
+        stopSequences?: string[];
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<string>;
+    /**
+     * Optional embedding surface. When a loader implements this, the runtime
+     * handler routes `TEXT_EMBEDDING` requests through it. The AOSP bun:ffi
+     * loader populates this directly via `llama_get_embeddings_seq`; the
+     * device-bridge loader populates it by dispatching an `embed` frame to
+     * the connected device. Loaders that cannot embed leave this undefined,
+     * and the runtime falls back to its non-local embedding provider chain.
+     */
+    embed?(args: {
+        input: string;
+    }): Promise<{
+        embedding: number[];
+        tokens: number;
+    }>;
+}
+export declare class ActiveModelCoordinator {
+    private state;
+    private readonly listeners;
+    snapshot(): ActiveModelState;
+    subscribe(listener: (state: ActiveModelState) => void): () => void;
+    private emit;
+    /** Return the loader service from the current runtime, if registered. */
+    private getLoader;
+    switchTo(runtime: AgentRuntime | null, installed: InstalledModel): Promise<ActiveModelState>;
+    unload(runtime: AgentRuntime | null): Promise<ActiveModelState>;
+}
+//# sourceMappingURL=active-model.d.ts.map

package/packages/app-core/src/services/local-inference/active-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-model.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/active-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,IAAI,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,IAAI,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpB;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACvC,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACJ;AAYD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,KAAK,CAIX;IAEF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgD;IAE1E,QAAQ,IAAI,gBAAgB;IAI5B,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI;IAOlE,OAAO,CAAC,IAAI;IAWZ,yEAAyE;IACzE,OAAO,CAAC,SAAS;IAUX,QAAQ,CACZ,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,SAAS,EAAE,cAAc,GACxB,OAAO,CAAC,gBAAgB,CAAC;IA0CtB,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAsBtE"}

package/packages/app-core/src/services/local-inference/active-model.js

@@ -0,0 +1,120 @@
+/**
+ * Coordinates which model is currently loaded into the plugin-local-ai
+ * runtime. Milady runs one inference model at a time; switching models
+ * unloads the previous one first so we don't double-allocate VRAM.
+ *
+ * This module *does not* talk to `node-llama-cpp` directly. The plugin
+ * owns the native binding; we ask it to swap via a small runtime service
+ * registered under the name "localInferenceLoader". When the plugin is not
+ * enabled, we still track the user's preferred active model so the
+ * preference survives enabling the plugin later.
+ */
+import { localInferenceEngine } from "./engine";
+import { touchMiladyModel } from "./registry";
+function isLoader(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.loadModel === "function" &&
+        typeof candidate.unloadModel === "function" &&
+        typeof candidate.currentModelPath === "function");
+}
+export class ActiveModelCoordinator {
+    state = {
+        modelId: null,
+        loadedAt: null,
+        status: "idle",
+    };
+    listeners = new Set();
+    snapshot() {
+        return { ...this.state };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit() {
+        const current = { ...this.state };
+        for (const listener of this.listeners) {
+            try {
+                listener(current);
+            }
+            catch {
+                this.listeners.delete(listener);
+            }
+        }
+    }
+    /** Return the loader service from the current runtime, if registered. */
+    getLoader(runtime) {
+        if (!runtime)
+            return null;
+        const candidate = runtime.getService?.("localInferenceLoader");
+        return isLoader(candidate) ? candidate : null;
+    }
+    async switchTo(runtime, installed) {
+        this.state = {
+            modelId: installed.id,
+            loadedAt: null,
+            status: "loading",
+        };
+        this.emit();
+        // Prefer a runtime-registered loader (plugin-local-ai or equivalent)
+        // when present — it will already have warmed up the right configuration.
+        // Otherwise, fall back to the standalone engine, which is the default
+        // path for users who haven't separately enabled plugin-local-ai.
+        const loader = this.getLoader(runtime);
+        try {
+            if (loader) {
+                await loader.unloadModel();
+                await loader.loadModel({ modelPath: installed.path });
+            }
+            else {
+                await localInferenceEngine.load(installed.path);
+            }
+            this.state = {
+                modelId: installed.id,
+                loadedAt: new Date().toISOString(),
+                status: "ready",
+            };
+            if (installed.source === "milady-download") {
+                await touchMiladyModel(installed.id);
+            }
+        }
+        catch (err) {
+            this.state = {
+                modelId: installed.id,
+                loadedAt: null,
+                status: "error",
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        this.emit();
+        return this.snapshot();
+    }
+    async unload(runtime) {
+        const loader = this.getLoader(runtime);
+        try {
+            if (loader) {
+                await loader.unloadModel();
+            }
+            else {
+                await localInferenceEngine.unload();
+            }
+        }
+        catch (err) {
+            this.state = {
+                modelId: null,
+                loadedAt: null,
+                status: "error",
+                error: err instanceof Error ? err.message : String(err),
+            };
+            this.emit();
+            return this.snapshot();
+        }
+        this.state = { modelId: null, loadedAt: null, status: "idle" };
+        this.emit();
+        return this.snapshot();
+    }
+}

package/packages/app-core/src/services/local-inference/device-bridge.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Device-bridge: agent-side half of the "inference on the user's phone,
+ * agent in a container" architecture.
+ *
+ * Multi-device aware. Any number of devices can dial in; each `generate`
+ * is routed to the highest-scoring connected device at call time. A phone
+ * and a Mac paired to the same agent → requests go to the Mac; when the
+ * Mac disconnects, new requests fall through to the phone automatically.
+ *
+ * Scoring (higher = preferred):
+ *   - desktop / electrobun: 100 base
+ *   - ios / android:        10 base
+ *   - per GB of total RAM:  +2
+ *   - per GB of VRAM:       +5 (dedicated GPU wins big)
+ *   - has loaded the right model already: +50 (avoid a swap)
+ *
+ * Disconnect tolerance
+ * --------------------
+ * A pending request stays in `pendingGenerates` until either (a) a device
+ * (same or different) returns a matching correlation-id, or (b) the
+ * timeout fires. On any device (re)connect we re-route orphaned
+ * generates to the new best device.
+ *
+ * Durability
+ * ----------
+ * Pending requests are best-effort persisted to a JSON log under
+ * `$ELIZA_STATE_DIR/local-inference/pending-requests.json` so a brief
+ * agent restart doesn't lose the queue. Persistence is async and
+ * non-blocking — failures fall back to in-memory only.
+ */
+import type { Server as HttpServer } from "node:http";
+import type { AgentRuntime } from "@elizaos/core";
+interface DeviceCapabilities {
+    platform: "ios" | "android" | "web" | "electrobun" | "desktop";
+    deviceModel: string;
+    totalRamGb: number;
+    cpuCores: number;
+    gpu: {
+        backend: "metal" | "vulkan" | "gpu-delegate" | "cuda";
+        available: boolean;
+        totalVramGb?: number;
+    } | null;
+}
+export interface DeviceSummary {
+    deviceId: string;
+    capabilities: DeviceCapabilities;
+    loadedPath: string | null;
+    connectedSince: string;
+    score: number;
+    activeRequests: number;
+    isPrimary: boolean;
+}
+export interface DeviceBridgeStatus {
+    /** True if any device is currently connected. */
+    connected: boolean;
+    devices: DeviceSummary[];
+    /** Device id of the current best-score device, or null when none. */
+    primaryDeviceId: string | null;
+    /** Total generates/loads/unloads queued (either in-flight or awaiting a device). */
+    pendingRequests: number;
+    deviceId: string | null;
+    capabilities: DeviceCapabilities | null;
+    loadedPath: string | null;
+    connectedSince: string | null;
+}
+export declare class DeviceBridge {
+    private readonly devices;
+    private wss;
+    private restored;
+    private readonly pendingLoads;
+    private readonly pendingUnloads;
+    private readonly pendingGenerates;
+    private readonly pendingEmbeds;
+    private readonly statusListeners;
+    private readonly expectedPairingToken;
+    status(): DeviceBridgeStatus;
+    private countRouted;
+    subscribeStatus(listener: (status: DeviceBridgeStatus) => void): () => void;
+    private emitStatus;
+    attachToHttpServer(server: HttpServer): Promise<void>;
+    private handleConnection;
+    private onDeviceRegistered;
+    private onDeviceDisconnected;
+    private handleDeviceMessage;
+    private sendToDevice;
+    /** Highest-scoring connected device, optionally boosted for an already-loaded model. */
+    private pickBestDevice;
+    loadModel(args: {
+        modelPath: string;
+        contextSize?: number;
+        useGpu?: boolean;
+    }): Promise<void>;
+    unloadModel(): Promise<void>;
+    currentModelPath(): string | null;
+    embed(args: {
+        input: string;
+    }): Promise<{
+        embedding: number[];
+        tokens: number;
+    }>;
+    generate(args: {
+        prompt: string;
+        stopSequences?: string[];
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<string>;
+    private pendingLogPath;
+    /**
+     * Rewrite the pending-generate log. Called after every mutation to the
+     * pendingGenerates map. We only persist `generate` — loads/unloads are
+     * bound to a specific device's current state and aren't safely replayable
+     * across restart.
+     */
+    private persistPendingGenerates;
+    /**
+     * On startup, read persisted pending requests back into memory. Their
+     * promises are gone (the original caller's process is dead) so they can
+     * only be resolved externally — for now we just re-queue them with a
+     * fresh timeout, and the first device that connects will process them.
+     * If nothing consumes them within the timeout they reject quietly.
+     *
+     * Stale entries older than 24h are purged rather than resurrected.
+     */
+    private restorePendingGenerates;
+}
+export declare const deviceBridge: DeviceBridge;
+export declare function registerDeviceBridgeLoader(runtime: AgentRuntime & {
+    registerService?: (name: string, impl: unknown) => unknown;
+}): void;
+export {};
+//# sourceMappingURL=device-bridge.d.ts.map

package/packages/app-core/src/services/local-inference/device-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-bridge.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/device-bridge.ts"],"names":[],"mappings":"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"}