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

package/api/trajectory-fallback-routes.js

@@ -0,0 +1,180 @@
+function sendJson(res, statusCode, body) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+// timeout collapses to the viewer's tri-state "error".
+function normalizeStatus(status) {
+    if (status === "timeout" || status === "error" || status === "terminated") {
+        return "error";
+    }
+    return status === "active" ? "active" : "completed";
+}
+function listItemToUi(item) {
+    return {
+        id: item.id,
+        status: normalizeStatus(item.status),
+        llmCallCount: item.llmCallCount ?? 0,
+        agentId: item.agentId,
+        source: item.source ?? "chat",
+        startTime: item.startTime,
+        endTime: item.endTime ?? null,
+        durationMs: item.durationMs ?? null,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt ?? item.createdAt,
+    };
+}
+// Flatten the recorded steps into the flat UI arrays the viewer's phase
+// classifier (`summarizePhases`) reads: llmCalls keyed by stepType/purpose drive
+// HANDLE/PLAN/EVALUATE; the per-step action drives the ACTION phase.
+function detailToUi(traj) {
+    const id = String(traj.trajectoryId);
+    const llmCalls = [];
+    const providerAccesses = [];
+    const toolEvents = [];
+    const steps = traj.steps ?? [];
+    for (let s = 0; s < steps.length; s++) {
+        const step = steps[s];
+        const stepId = step.stepId ?? `step-${s}`;
+        const calls = step.llmCalls ?? [];
+        for (let i = 0; i < calls.length; i++) {
+            const c = calls[i];
+            llmCalls.push({
+                id: c.callId || `${stepId}-call-${i}`,
+                model: c.model || "unknown",
+                provider: c.provider || "",
+                response: c.response || "",
+                purpose: c.purpose || "",
+                actionType: c.actionType || "",
+                stepType: c.stepType || "",
+            });
+        }
+        const accesses = step.providerAccesses ?? [];
+        for (let k = 0; k < accesses.length; k++) {
+            const p = accesses[k];
+            providerAccesses.push({
+                id: p.providerId || `${stepId}-provider-${k}`,
+                providerName: p.providerName || "unknown",
+                purpose: p.purpose || "",
+            });
+        }
+        const action = step.action;
+        if (action && (action.actionName || action.actionType)) {
+            const failed = action.success === false || Boolean(action.error);
+            toolEvents.push({
+                id: action.attemptId || `${stepId}-action`,
+                type: failed ? "tool_error" : "tool_result",
+                actionName: action.actionName || action.actionType || "action",
+                status: failed ? "failed" : "completed",
+                success: !failed,
+                ...(action.error ? { error: action.error } : {}),
+            });
+        }
+    }
+    const finalStatus = traj.metrics?.finalStatus;
+    const status = finalStatus === "timeout" ||
+        finalStatus === "terminated" ||
+        finalStatus === "error"
+        ? "error"
+        : finalStatus === "completed" ||
+            (typeof traj.endTime === "number" && traj.endTime > 0)
+            ? "completed"
+            : "active";
+    const startTime = typeof traj.startTime === "number" ? traj.startTime : 0;
+    const endTime = typeof traj.endTime === "number" && traj.endTime > 0 ? traj.endTime : null;
+    const durationMs = endTime !== null && startTime > 0 ? Math.max(0, endTime - startTime) : null;
+    return {
+        trajectory: {
+            id,
+            agentId: traj.agentId ?? "",
+            source: "chat",
+            status,
+            startTime,
+            endTime,
+            durationMs,
+            llmCallCount: llmCalls.length,
+            providerAccessCount: providerAccesses.length,
+            createdAt: new Date(startTime > 0 ? startTime : 0).toISOString(),
+        },
+        llmCalls,
+        providerAccesses,
+        toolEvents,
+        evaluationEvents: [],
+    };
+}
+export async function tryHandleTrajectoryFallback(options) {
+    const { pathname, method, url, runtime, res } = options;
+    if (method !== "GET" || !pathname.startsWith("/api/trajectories")) {
+        return false;
+    }
+    // Only the READ routes the viewer needs. Mutations (DELETE, export, config)
+    // remain plugin-training's responsibility; let them 404 where it's absent.
+    const isList = pathname === "/api/trajectories";
+    const isStats = pathname === "/api/trajectories/stats";
+    const idMatch = pathname.match(/^\/api\/trajectories\/([^/]+)$/);
+    const detailId = idMatch && idMatch[1] !== "stats" && idMatch[1] !== "config"
+        ? decodeURIComponent(idMatch[1])
+        : null;
+    if (!isList && !isStats && !detailId) {
+        return false;
+    }
+    const service = runtime?.getService?.("trajectories");
+    // No service at all → empty (200) so the viewer reads "no trajectories yet"
+    // instead of the "unavailable" surface a 404/503 would trigger.
+    if (!service) {
+        if (isList)
+            sendJson(res, 200, { trajectories: [], total: 0 });
+        else if (isStats)
+            sendJson(res, 200, { totalTrajectories: 0 });
+        else
+            sendJson(res, 404, { error: "Trajectory not found" });
+        return true;
+    }
+    try {
+        if (isStats) {
+            const stats = (await service.getStats?.()) ?? { totalTrajectories: 0 };
+            sendJson(res, 200, stats);
+            return true;
+        }
+        if (isList) {
+            const limit = Math.min(500, Math.max(1, Number(url.searchParams.get("limit")) || 50));
+            const offset = Math.max(0, Number(url.searchParams.get("offset")) || 0);
+            const result = (await service.listTrajectories?.({
+                limit,
+                offset,
+                source: url.searchParams.get("source") || undefined,
+                status: url.searchParams.get("status") || undefined,
+                scenarioId: url.searchParams.get("scenarioId") || undefined,
+                batchId: url.searchParams.get("batchId") || undefined,
+                // The SQL reader filters + counts by `search` (id/scenario_id/
+                // batch_id/metadata/steps_json LIKE). On mobile this fallback owns
+                // /api/trajectories, so without forwarding `search` the viewer's
+                // search box returned the full unfiltered list.
+                search: url.searchParams.get("search") || undefined,
+            })) ?? { trajectories: [], total: 0 };
+            sendJson(res, 200, {
+                trajectories: result.trajectories.map(listItemToUi),
+                total: result.total,
+                offset,
+                limit,
+            });
+            return true;
+        }
+        // detail
+        const traj = detailId
+            ? await service.getTrajectoryDetail?.(detailId)
+            : null;
+        if (!traj) {
+            sendJson(res, 404, { error: `Trajectory "${detailId}" not found` });
+            return true;
+        }
+        sendJson(res, 200, detailToUi(traj));
+        return true;
+    }
+    catch (err) {
+        sendJson(res, 500, {
+            error: err instanceof Error ? err.message : "Trajectory read failed",
+        });
+        return true;
+    }
+}

package/api/tx-service.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Ethereum transaction signing and contract interaction layer.
+ *
+ * Provides the missing transaction capability to Eliza's wallet system,
+ * which currently only handles key generation and balance fetching.
+ * Used by the registry and drop services for on-chain operations.
+ */
+import * as ethers from "ethers";
+export interface JsonRpcEndpointProbeResult {
+    ok: boolean;
+    reason?: string;
+}
+export declare function normalizeJsonRpcUrl(rpcUrl: string): string;
+export declare function probeJsonRpcEndpoint(rpcUrl: string, timeoutMs?: number): Promise<JsonRpcEndpointProbeResult>;
+export declare class TxService {
+    private readonly provider;
+    private readonly wallet;
+    private readonly rpcUrl;
+    constructor(rpcUrl: string, privateKey: string);
+    /**
+     * Get fresh nonce for the wallet address.
+     * Always fetches from blockchain using a fresh provider to avoid caching issues.
+     * This ensures we always get the correct nonce even after failed transactions.
+     */
+    getFreshNonce(): Promise<number>;
+    get address(): string;
+    getBalance(): Promise<bigint>;
+    getBalanceFormatted(): Promise<string>;
+    getChainId(): Promise<number>;
+    getContract(address: string, abi: ethers.InterfaceAbi): ethers.Contract;
+    getReadOnlyContract(address: string, abi: ethers.InterfaceAbi): ethers.Contract;
+    estimateGas(tx: ethers.TransactionRequest): Promise<bigint>;
+    getFeeData(): Promise<ethers.FeeData>;
+    /**
+     * Wait for a transaction to be mined and return the receipt.
+     * Throws if the transaction fails or times out.
+     */
+    waitForTransaction(txHash: string, confirmations?: number, timeoutMs?: number): Promise<ethers.TransactionReceipt>;
+    /**
+     * Estimate the gas cost in ETH for a contract call.
+     * Useful for showing users how much gas they'll need.
+     */
+    estimateGasCostEth(tx: ethers.TransactionRequest): Promise<string>;
+    /**
+     * Check whether the wallet has enough balance for a given value + estimated gas.
+     */
+    hasEnoughBalance(value: bigint, gasEstimate: bigint): Promise<boolean>;
+    /**
+     * Log a summary of the tx service state for diagnostics.
+     */
+    logStatus(): Promise<void>;
+}
+//# sourceMappingURL=tx-service.d.ts.map

package/api/tx-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-service.d.ts","sourceRoot":"","sources":["../../src/api/tx-service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAGjC,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAaD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAsB1D;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,SAAS,SAAQ,GAChB,OAAO,CAAC,0BAA0B,CAAC,CAoDrC;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAwB9C;;;;OAIG;IACG,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAsBtC,IAAI,OAAO,IAAI,MAAM,CAEpB;IAEK,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAI7B,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKtC,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAKnC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,QAAQ;IAIvE,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,YAAY,GACvB,MAAM,CAAC,QAAQ;IAIZ,WAAW,CAAC,EAAE,EAAE,MAAM,CAAC,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI3D,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;IAI3C;;;OAGG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAU,EACzB,SAAS,GAAE,MAAgB,GAC1B,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAiCrC;;;OAGG;IACG,kBAAkB,CAAC,EAAE,EAAE,MAAM,CAAC,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAQxE;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ5E;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CASjC"}

package/api/tx-service.js

@@ -0,0 +1,217 @@
+/**
+ * Ethereum transaction signing and contract interaction layer.
+ *
+ * Provides the missing transaction capability to Eliza's wallet system,
+ * which currently only handles key generation and balance fetching.
+ * Used by the registry and drop services for on-chain operations.
+ */
+import { logger } from "@elizaos/core";
+import * as ethers from "ethers";
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability.js";
+/**
+ * Validate that a private key is a valid 32-byte hex string.
+ */
+function isValidPrivateKey(key) {
+    const normalized = key.startsWith("0x") ? key.slice(2) : key;
+    // Must be 64 hex characters (32 bytes)
+    if (normalized.length !== 64)
+        return false;
+    // Must be valid hex
+    return /^[0-9a-fA-F]+$/.test(normalized);
+}
+export function normalizeJsonRpcUrl(rpcUrl) {
+    const trimmed = rpcUrl.trim();
+    if (!trimmed) {
+        throw new Error("EVM JSON-RPC URL is required.");
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error(`Invalid EVM JSON-RPC URL "${trimmed}": expected an http(s) URL.`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Invalid EVM JSON-RPC URL "${trimmed}": expected http: or https:.`);
+    }
+    return parsed.toString();
+}
+export async function probeJsonRpcEndpoint(rpcUrl, timeoutMs = 2_000) {
+    const normalizedRpcUrl = normalizeJsonRpcUrl(rpcUrl);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(normalizedRpcUrl, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "eth_chainId",
+                params: [],
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                reason: `HTTP ${response.status} ${response.statusText}`.trim(),
+            };
+        }
+        const body = (await response.json());
+        if (typeof body.result === "string" &&
+            /^0x[0-9a-fA-F]+$/.test(body.result)) {
+            return { ok: true };
+        }
+        const errorMessage = typeof body.error?.message === "string"
+            ? body.error.message
+            : "missing eth_chainId result";
+        return { ok: false, reason: errorMessage };
+    }
+    catch (err) {
+        const message = err instanceof Error && err.name === "AbortError"
+            ? `timed out after ${timeoutMs}ms`
+            : err instanceof Error
+                ? err.message
+                : String(err);
+        return { ok: false, reason: message };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export class TxService {
+    provider;
+    wallet;
+    rpcUrl;
+    constructor(rpcUrl, privateKey) {
+        // Validate private key before attempting to create wallet
+        if (!isValidPrivateKey(privateKey)) {
+            const preview = privateKey.length > 10
+                ? `${privateKey.slice(0, 6)}...${privateKey.slice(-4)}`
+                : "(empty or too short)";
+            throw new Error(`Invalid EVM_PRIVATE_KEY: expected 64-character hex string, got ${preview}. ` +
+                `Please set a valid private key in your environment or .env file.`);
+        }
+        this.rpcUrl = normalizeJsonRpcUrl(rpcUrl);
+        this.provider = new ethers.JsonRpcProvider(this.rpcUrl);
+        const normalizedKey = privateKey.startsWith("0x")
+            ? privateKey
+            : `0x${privateKey}`;
+        // Create wallet with provider
+        this.wallet = new ethers.Wallet(normalizedKey, this.provider);
+    }
+    /**
+     * Get fresh nonce for the wallet address.
+     * Always fetches from blockchain using a fresh provider to avoid caching issues.
+     * This ensures we always get the correct nonce even after failed transactions.
+     */
+    async getFreshNonce() {
+        const span = createIntegrationTelemetrySpan({
+            boundary: "wallet",
+            operation: "rpc_get_nonce",
+        });
+        // Use a fresh provider for each nonce lookup to avoid ethers.js v6 caching
+        const freshProvider = new ethers.JsonRpcProvider(this.rpcUrl);
+        try {
+            const nonce = await freshProvider.getTransactionCount(this.wallet.address, "pending");
+            span.success();
+            return nonce;
+        }
+        catch (err) {
+            span.failure({ error: err });
+            throw err;
+        }
+        finally {
+            freshProvider.destroy();
+        }
+    }
+    get address() {
+        return this.wallet.address;
+    }
+    async getBalance() {
+        return this.provider.getBalance(this.wallet.address);
+    }
+    async getBalanceFormatted() {
+        const balance = await this.getBalance();
+        return ethers.formatEther(balance);
+    }
+    async getChainId() {
+        const network = await this.provider.getNetwork();
+        return Number(network.chainId);
+    }
+    getContract(address, abi) {
+        return new ethers.Contract(address, abi, this.wallet);
+    }
+    getReadOnlyContract(address, abi) {
+        return new ethers.Contract(address, abi, this.provider);
+    }
+    async estimateGas(tx) {
+        return this.provider.estimateGas(tx);
+    }
+    async getFeeData() {
+        return this.provider.getFeeData();
+    }
+    /**
+     * Wait for a transaction to be mined and return the receipt.
+     * Throws if the transaction fails or times out.
+     */
+    async waitForTransaction(txHash, confirmations = 1, timeoutMs = 120_000) {
+        const span = createIntegrationTelemetrySpan({
+            boundary: "wallet",
+            operation: "rpc_wait_for_transaction",
+            timeoutMs,
+        });
+        let receipt;
+        try {
+            receipt = await this.provider.waitForTransaction(txHash, confirmations, timeoutMs);
+        }
+        catch (err) {
+            span.failure({ error: err });
+            throw err;
+        }
+        if (!receipt) {
+            const err = new Error(`Transaction ${txHash} timed out after ${timeoutMs}ms`);
+            span.failure({ error: err, errorKind: "timeout" });
+            throw err;
+        }
+        if (receipt.status === 0) {
+            const err = new Error(`Transaction ${txHash} reverted`);
+            span.failure({ error: err, errorKind: "tx_reverted" });
+            throw err;
+        }
+        span.success();
+        return receipt;
+    }
+    /**
+     * Estimate the gas cost in ETH for a contract call.
+     * Useful for showing users how much gas they'll need.
+     */
+    async estimateGasCostEth(tx) {
+        const gasLimit = await this.estimateGas(tx);
+        const feeData = await this.getFeeData();
+        const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 0n;
+        const costWei = gasLimit * gasPrice;
+        return ethers.formatEther(costWei);
+    }
+    /**
+     * Check whether the wallet has enough balance for a given value + estimated gas.
+     */
+    async hasEnoughBalance(value, gasEstimate) {
+        const balance = await this.getBalance();
+        const feeData = await this.getFeeData();
+        const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 0n;
+        const gasCost = gasEstimate * gasPrice;
+        return balance >= value + gasCost;
+    }
+    /**
+     * Log a summary of the tx service state for diagnostics.
+     */
+    async logStatus() {
+        const [balance, chainId] = await Promise.all([
+            this.getBalanceFormatted(),
+            this.getChainId(),
+        ]);
+        logger.info(`[tx-service] address=${this.address} chain=${chainId} balance=${balance} ETH`);
+    }
+}

package/api/update-routes.d.ts

@@ -0,0 +1,19 @@
+import type http from "node:http";
+import type { ReadJsonBodyOptions } from "@elizaos/core";
+import type { ElizaConfig } from "../config/config.js";
+export interface UpdateRouteContext {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    method: string;
+    pathname: string;
+    url: URL;
+    state: {
+        config: ElizaConfig;
+    };
+    json: (res: http.ServerResponse, data: unknown, status?: number) => void;
+    error: (res: http.ServerResponse, message: string, status?: number) => void;
+    readJsonBody: <T extends object>(req: http.IncomingMessage, res: http.ServerResponse, options?: ReadJsonBodyOptions) => Promise<T | null>;
+    saveElizaConfig: (config: ElizaConfig) => void;
+}
+export declare function handleUpdateRoutes(ctx: UpdateRouteContext): Promise<boolean>;
+//# sourceMappingURL=update-routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-routes.d.ts","sourceRoot":"","sources":["../../src/api/update-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC;IAC1B,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC;IACT,KAAK,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC;IAC/B,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,KAAK,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5E,YAAY,EAAE,CAAC,CAAC,SAAS,MAAM,EAC7B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,CAAC,EAAE,mBAAmB,KAC1B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACvB,eAAe,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;CAChD;AAMD,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,OAAO,CAAC,CA8ElB"}

package/api/update-routes.js

@@ -0,0 +1,69 @@
+import { PutUpdateChannelRequestSchema } from "@elizaos/shared";
+// ---------------------------------------------------------------------------
+// Route handler
+// ---------------------------------------------------------------------------
+export async function handleUpdateRoutes(ctx) {
+    const { req, res, method, pathname, state, json, error, readJsonBody } = ctx;
+    // ── GET /api/update/status ───────────────────────────────────────────
+    if (method === "GET" && pathname === "/api/update/status") {
+        const { VERSION } = await import("../runtime/version.js");
+        const { resolveChannel, checkForUpdate, fetchAllChannelVersions, CHANNEL_DIST_TAGS, } = await import("../services/update-checker.js");
+        const { isTrustedLocalRequest } = await import("./server-helpers-auth.js");
+        const { detectInstallMethod, getUpdateActionPlan } = await import("../services/self-updater.js");
+        const channel = resolveChannel(state.config.update);
+        const installMethod = detectInstallMethod();
+        const updatePlan = getUpdateActionPlan(installMethod, channel, {
+            remoteDisplay: !isTrustedLocalRequest(req),
+        });
+        const [check, versions] = await Promise.all([
+            checkForUpdate({ force: req.url?.includes("force=true") }),
+            fetchAllChannelVersions(),
+        ]);
+        json(res, {
+            currentVersion: VERSION,
+            channel,
+            installMethod,
+            updateAuthority: updatePlan.authority,
+            nextAction: updatePlan.nextAction,
+            canAutoUpdate: updatePlan.canAutoUpdate,
+            canExecuteUpdate: updatePlan.canExecuteFromContext,
+            remoteDisplay: updatePlan.remoteDisplay,
+            updateCommand: updatePlan.command,
+            updateInstructions: updatePlan.message,
+            updateAvailable: check.updateAvailable,
+            latestVersion: check.latestVersion,
+            channels: {
+                stable: versions.stable,
+                beta: versions.beta,
+                nightly: versions.nightly,
+            },
+            distTags: CHANNEL_DIST_TAGS,
+            lastCheckAt: state.config.update?.lastCheckAt ?? null,
+            error: check.error,
+        });
+        return true;
+    }
+    // ── PUT /api/update/channel ────────────────────────────────────────────
+    if (method === "PUT" && pathname === "/api/update/channel") {
+        const rawCh = await readJsonBody(req, res);
+        if (rawCh === null)
+            return true;
+        const parsedCh = PutUpdateChannelRequestSchema.safeParse(rawCh);
+        if (!parsedCh.success) {
+            error(res, parsedCh.error.issues[0]?.message ??
+                `Invalid channel. Must be stable, beta, or nightly.`);
+            return true;
+        }
+        const ch = parsedCh.data.channel;
+        state.config.update = {
+            ...state.config.update,
+            channel: ch,
+            lastCheckAt: undefined,
+            lastCheckVersion: undefined,
+        };
+        ctx.saveElizaConfig(state.config);
+        json(res, { channel: ch });
+        return true;
+    }
+    return false;
+}

package/api/view-registry-types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared types for the view registry.
+ *
+ * Extracted from views-registry.ts to break the views-registry ↔
+ * views-search-index circular dependency.
+ *
+ * @module api/view-registry-types
+ */
+import type { ViewDeclaration, ViewType } from "@elizaos/core";
+import type { AgentPlatform } from "./platform-detect.js";
+export interface ViewRegistryEntry extends ViewDeclaration {
+    /** Concrete presentation type after applying the default (`gui`). */
+    viewType: ViewType;
+    /** Owning plugin name. */
+    pluginName: string;
+    /** Absolute path to the plugin's package root, if resolvable. */
+    pluginDir?: string;
+    /** Resolved URL served by the agent: `/api/views/<id>/bundle.js`. */
+    bundleUrl?: string;
+    /** Resolved URL served by the agent: `/api/views/<id>/hero`. */
+    heroImageUrl?: string;
+    /**
+     * True when a real hero image asset exists on disk for this view. When false,
+     * `heroImageUrl` still resolves (the route serves a generated fallback),
+     * but the client should render the view's icon instead of that fallback.
+     */
+    hasHeroImage: boolean;
+    /** True when the bundle file exists on disk. */
+    available: boolean;
+    /** Unix timestamp (ms) when this entry was registered. */
+    loadedAt: number;
+    /**
+     * Platform this view is available on. Populated from
+     * `ViewDeclaration.platforms` (first entry) or defaults to "web".
+     * Used by platform-aware route filtering to gate dynamic bundles on
+     * restricted platforms (iOS App Store, Google Play).
+     */
+    platform: AgentPlatform;
+    /** First 12 hex chars of the SHA-256 content hash of the bundle file. */
+    bundleHash?: string;
+    /** Bundle URL with `?v=<hash>` for immutable long-lived caching. */
+    bundleUrlVersioned?: string;
+    /** Bundle file size in bytes. */
+    bundleSize?: number;
+    /**
+     * True for entries registered by the built-in shell itself
+     * (pluginName === "@elizaos/builtin"). These views live in the main
+     * bundle and have no separate bundle file.
+     */
+    builtin?: boolean;
+}
+//# sourceMappingURL=view-registry-types.d.ts.map

package/api/view-registry-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-registry-types.d.ts","sourceRoot":"","sources":["../../src/api/view-registry-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,qEAAqE;IACrE,QAAQ,EAAE,QAAQ,CAAC;IACnB,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,SAAS,EAAE,OAAO,CAAC;IACnB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,EAAE,aAAa,CAAC;IACxB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/api/view-registry-types.js

@@ -0,0 +1,9 @@
+/**
+ * Shared types for the view registry.
+ *
+ * Extracted from views-registry.ts to break the views-registry ↔
+ * views-search-index circular dependency.
+ *
+ * @module api/view-registry-types
+ */
+export {};