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

package/runtime/vault-profile-resolver.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Per-agent vault profile resolver.
+ *
+ * Walks every vault entry that has profile metadata, asks the vault's
+ * routing layer which profile applies for the current agent, and pumps
+ * the resolved value into `process.env[KEY]`. Runtime hot paths read
+ * env vars synchronously (`process.env.OPENROUTER_API_KEY`, etc.), so
+ * we resolve once at agent boot rather than instrumenting every call
+ * site.
+ *
+ * Scope:
+ *   - Only `agent` scope rules apply; the runtime knows agentId.
+ *   - `app` and `skill` scope rules are persisted for call sites that
+ *     provide that context; this boot resolver has only agent context.
+ *
+ * Idempotent: re-running for the same agent overwrites with the same
+ * value. Opt-out via `ELIZA_DISABLE_VAULT_PROFILE_RESOLVER=1`.
+ */
+import { type Vault } from "@elizaos/vault";
+export interface ResolveProfilesResult {
+    /** Number of keys whose env value was overridden. */
+    readonly overridden: number;
+    /** Keys that had profiles but every candidate profile was empty. */
+    readonly skipped: ReadonlyArray<string>;
+    /** Keys where resolution failed (vault read error). */
+    readonly failed: ReadonlyArray<string>;
+}
+/**
+ * For each inventory entry that has `hasProfiles === true`, resolve
+ * the active value for `agentId` and write it into `process.env[KEY]`.
+ *
+ * Keys without profiles are left alone — `process.env` already holds
+ * whatever the legacy hydration path put there (config.env, eliza.json,
+ * direct env). This resolver is purely additive.
+ */
+export declare function applyVaultProfilesForAgent(vault: Vault, agentId: string): Promise<ResolveProfilesResult>;
+//# sourceMappingURL=vault-profile-resolver.d.ts.map

package/runtime/vault-profile-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-profile-resolver.d.ts","sourceRoot":"","sources":["../../src/runtime/vault-profile-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAGL,KAAK,KAAK,EAEX,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,qBAAqB;IACpC,qDAAqD;IACrD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,CAAC,CA0DhC"}

package/runtime/vault-profile-resolver.js

@@ -0,0 +1,79 @@
+/**
+ * Per-agent vault profile resolver.
+ *
+ * Walks every vault entry that has profile metadata, asks the vault's
+ * routing layer which profile applies for the current agent, and pumps
+ * the resolved value into `process.env[KEY]`. Runtime hot paths read
+ * env vars synchronously (`process.env.OPENROUTER_API_KEY`, etc.), so
+ * we resolve once at agent boot rather than instrumenting every call
+ * site.
+ *
+ * Scope:
+ *   - Only `agent` scope rules apply; the runtime knows agentId.
+ *   - `app` and `skill` scope rules are persisted for call sites that
+ *     provide that context; this boot resolver has only agent context.
+ *
+ * Idempotent: re-running for the same agent overwrites with the same
+ * value. Opt-out via `ELIZA_DISABLE_VAULT_PROFILE_RESOLVER=1`.
+ */
+import { logger } from "@elizaos/core";
+import { listVaultInventory, resolveActiveValue, } from "@elizaos/vault";
+/**
+ * For each inventory entry that has `hasProfiles === true`, resolve
+ * the active value for `agentId` and write it into `process.env[KEY]`.
+ *
+ * Keys without profiles are left alone — `process.env` already holds
+ * whatever the legacy hydration path put there (config.env, eliza.json,
+ * direct env). This resolver is purely additive.
+ */
+export async function applyVaultProfilesForAgent(vault, agentId) {
+    if (process.env.ELIZA_DISABLE_VAULT_PROFILE_RESOLVER === "1") {
+        return { overridden: 0, skipped: [], failed: [] };
+    }
+    let entries;
+    try {
+        entries = await listVaultInventory(vault);
+    }
+    catch (err) {
+        logger.warn(`[vault-profile-resolver] inventory listing failed for agent="${agentId}": ${err instanceof Error ? err.message : String(err)}`);
+        return { overridden: 0, skipped: [], failed: [] };
+    }
+    let overridden = 0;
+    const skipped = [];
+    const failed = [];
+    for (const entry of entries) {
+        if (!entry.hasProfiles)
+            continue;
+        if (entry.kind === "reference") {
+            // Reference entries resolve through their backing password
+            // manager, not through profiles. Skip — but only after auditing
+            // we'd actually have a profile blob to read.
+            continue;
+        }
+        try {
+            const value = await resolveActiveValue(vault, entry.key, { agentId });
+            if (typeof value !== "string" || value.length === 0) {
+                skipped.push(entry.key);
+                continue;
+            }
+            process.env[entry.key] = value;
+            overridden += 1;
+        }
+        catch (err) {
+            // resolveActiveValue throws when no profile and no bare value
+            // resolves. Don't try to fall back to legacy env — the user
+            // explicitly declared profiles for this key, so an unresolvable
+            // active profile is a real failure they should see.
+            failed.push(entry.key);
+            logger.warn(`[vault-profile-resolver] failed to resolve agent="${agentId}" key="${entry.key}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (overridden > 0 || failed.length > 0) {
+        logger.info(`[vault-profile-resolver] agent="${agentId}" overridden=${overridden} skipped=${skipped.length} failed=${failed.length}`);
+    }
+    return {
+        overridden,
+        skipped: Object.freeze(skipped),
+        failed: Object.freeze(failed),
+    };
+}

package/runtime/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/runtime/version.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,QAAuC,CAAC"}

package/runtime/view-action-affinity.d.ts

@@ -0,0 +1,156 @@
+/**
+ * View-scoped action affinity.
+ *
+ * When the user is looking at a plugin view, the actions relevant to that view
+ * should be weighted up in the planner's tool catalogue — kept at full
+ * parameter detail so they can be invoked reliably — even when the user's
+ * message contains no intent keyword (e.g. "do it" while staring at the wallet).
+ *
+ * This complements the intent-based weighting in prompt-compaction.ts: intent
+ * looks at *what the user said*, this looks at *where the user is*. Both feed
+ * the same full-param action set the planner sees.
+ *
+ * The active view is reported by the shell via POST /api/views/:id/navigate and
+ * stored here (set by views-routes) so the prompt-optimization layer can read
+ * it without importing the HTTP route module.
+ */
+/**
+ * One addressable element in the active view, as reported by the shell's
+ * agent-surface registry (POST /api/views/:id/elements). Mirrors the
+ * list-elements snapshot shape so the planner can act on an element by id
+ * (agent-click / agent-fill / agent-focus) without a list-elements round-trip.
+ */
+export interface ActiveViewElement {
+    id: string;
+    role: string;
+    label: string;
+    value?: string;
+    focused?: boolean;
+}
+/** Cap on elements rendered into the awareness block to bound prompt growth. */
+export declare const ACTIVE_VIEW_ELEMENT_RENDER_CAP = 40;
+/** Minimal description of the view the shell is currently showing. */
+export interface ActiveViewContext {
+    viewId: string;
+    viewLabel: string;
+    viewType: "gui" | "tui" | "xr";
+    viewPath: string | null;
+    /**
+     * Live snapshot of the view's addressable elements, when the shell has
+     * reported one. Absent until a report arrives (and re-cleared on navigation),
+     * so the awareness block degrades gracefully to "use list-elements".
+     */
+    elements?: readonly ActiveViewElement[];
+    /**
+     * ISO timestamp of the most recent switch INTO this view, and who drove it.
+     * Carried from the navigate route so Stage-1 can acknowledge a just-happened
+     * switch (#8788). Absent when the view was not freshly switched.
+     */
+    switchedAt?: string;
+    source?: "agent" | "user";
+}
+/**
+ * A view switch is "fresh" (worth acknowledging on the immediately-following
+ * turn) for this window. Kept in lockstep with VIEW_SWITCH_FRESH_MS in
+ * `views-routes.ts`.
+ */
+export declare const ACTIVE_VIEW_SWITCH_FRESH_MS = 15000;
+export declare function setActiveViewContext(view: ActiveViewContext | null): void;
+export declare function getActiveViewContext(): ActiveViewContext | null;
+export declare function clearActiveViewContext(): void;
+/**
+ * Update the element snapshot for the active view. Gated on `viewId` matching
+ * the current active view so a stale or background view's report (the shell may
+ * have several mounted surfaces) can never overwrite the foreground view's
+ * elements. Returns false when no view is active or the id differs.
+ */
+export declare function setActiveViewElements(viewId: string, elements: readonly ActiveViewElement[]): boolean;
+/**
+ * Map viewId → runtime action names that get full param detail while that view
+ * is active. Names must match registered Action.name strings; verify before
+ * adding. Kept deliberately conservative — only high-confidence, stable action
+ * names belong here (validated against the live runtime by
+ * `validateViewActionMap`). Universal element control in any view is handled by
+ * the agent-surface view-interact capabilities (list-elements / agent-click /
+ * agent-fill), which are not runtime actions and so do not appear here.
+ *
+ * Verified action names (2026-05-31):
+ *   TASKS      — plugin-agent-orchestrator tasks action (coding/orchestration)
+ *   PLAY_EMOTE — plugin-companion/src/actions/emote.ts
+ *   RUNTIME    — packages/agent/src/actions/runtime.ts (restart/config ops)
+ *
+ * Verified action names + view ids (2026-06-02) — view id from each plugin's
+ * ViewDeclaration, action `name:` from that plugin's (or a thematically paired
+ * plugin's) action source. Actions are plugin-conditional: when the owning
+ * plugin is not loaded the name is simply not registered and the weighting is a
+ * missing-plugin skip (no error). Sources:
+ *   wallet      — view plugins/plugin-wallet-ui; actions plugins/plugin-wallet
+ *                 (chains/evm/actions swap+transfer, chains generated specs)
+ *   polymarket  — plugins/plugin-polymarket-app/src/actions.ts (POLYMARKET_STATUS)
+ *   hyperliquid — plugins/plugin-hyperliquid-app/src/actions/perpetual-market.ts
+ *   steward     — plugin-steward-app re-exports plugin-wallet's WALLET action
+ *   facewear    — plugins/plugin-facewear/src/index.ts (FACEWEAR_, SMARTGLASSES_, XR_ actions)
+ *
+ * Verified action names + view ids (2026-06-18) — each LifeOps/utility view's
+ * own domain actions, so they are emphasised (not just universally
+ * element-controllable) when that view is the foreground surface. Names
+ * confirmed registered in each plugin's actions/ source; plugin-conditional like
+ * the rest (a missing-plugin skip when not loaded). Sources:
+ *   calendar  — PA-registered calendar actions backed by plugin-calendar
+ *   health    — PA-registered actions built from plugin-health factories
+ *   focus     — PA-registered BLOCK umbrella backed by plugin-blocker;
+ *               list_active / release are subactions of it, not standalone actions)
+ *   finances  — PA-registered OWNER_FINANCES backed by plugin-finances
+ *   inbox     — plugins/plugin-inbox/src/actions/inbox (literal name: "INBOX")
+ *   goals     — plugin-goals owns OWNER_GOALS; PA owns routines/reminders/alarms
+ *   todos     — plugins/plugin-personal-assistant/src/actions/owner-surfaces (OWNER_TODOS)
+ *   lifeops   — plugins/plugin-personal-assistant/src/actions (PERSONAL_ASSISTANT)
+ *   relationships — plugins/plugin-relationships/src/actions/entity.ts
+ *              (literal name: "ENTITY"; RelationshipsView reads the entity /
+ *              relationship graph via GET /api/lifeops/{entities,relationships})
+ */
+export declare const VIEW_ACTION_MAP: Record<string, readonly string[]>;
+/**
+ * Resolve the set of action names to keep at full param detail for the active
+ * view. Returns an empty set when no view is active or the view has no mapped
+ * actions (control still works through agent-surface capabilities).
+ */
+export declare function viewScopedActionNames(viewId: string | null | undefined): Set<string>;
+/**
+ * Validate VIEW_ACTION_MAP against the runtime's registered actions, mirroring
+ * validateIntentActionMap. Logs a warning for any mapped name that no longer
+ * exists so drift is caught at startup rather than silently dropped.
+ */
+export declare function validateViewActionMap(registeredActions: string[], logger?: {
+    warn: (msg: string) => void;
+}): void;
+/**
+ * Completeness sibling of {@link validateViewActionMap}: where that flags a
+ * mapped action name that no longer exists, this flags a *registered view* that
+ * has neither a VIEW_ACTION_MAP entry nor any declared `ViewCapability`. It only
+ * warns (the universal agent-surface still reaches every control), but surfaces
+ * the affinity gap so domain actions for new views are not silently unweighted.
+ * (#8798)
+ *
+ * @param registeredViewIds every view id the registry currently knows about.
+ * @param viewsWithCapabilities view ids that declare a `ViewCapability[]`.
+ */
+export declare function validateViewCoverage(registeredViewIds: Iterable<string>, viewsWithCapabilities: Iterable<string>, logger?: {
+    warn: (msg: string) => void;
+}): string[];
+/**
+ * Render a compact "Active View" awareness block for the planner. Describes the
+ * surface the user is looking at and reminds the agent it can drive every
+ * element through the view-interact capabilities. Exposed for the planner /
+ * context-renderer to inject; pure so it is trivially testable.
+ */
+export declare function renderActiveViewContextBlock(view: ActiveViewContext): string;
+/**
+ * Inject the active-view awareness block into a planner prompt. Idempotent
+ * (skips if the block is already present) and leaves the prompt unchanged when
+ * no view is active. Placed just before the "# Available Actions" header so
+ * view context sits next to the tool catalogue; falls back to prepending when
+ * that header is absent.
+ */
+export declare function applyActiveViewAwareness(prompt: string, view: ActiveViewContext | null | undefined): string;
+//# sourceMappingURL=view-action-affinity.d.ts.map

package/runtime/view-action-affinity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-action-affinity.d.ts","sourceRoot":"","sources":["../../src/runtime/view-action-affinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,gFAAgF;AAChF,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAEjD,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;IAC/B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACxC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAWlD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAEzE;AAED,wBAAgB,oBAAoB,IAAI,iBAAiB,GAAG,IAAI,CAE/D;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,OAAO,CAIT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAgD7D,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,GAAG,CAAC,MAAM,CAAC,CAGb;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GACvC,IAAI,CAWN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,EACnC,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvC,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GACvC,MAAM,EAAE,CAYV;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAoD5E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,GACzC,MAAM,CAQR"}

package/runtime/view-action-affinity.js

@@ -0,0 +1,254 @@
+/**
+ * View-scoped action affinity.
+ *
+ * When the user is looking at a plugin view, the actions relevant to that view
+ * should be weighted up in the planner's tool catalogue — kept at full
+ * parameter detail so they can be invoked reliably — even when the user's
+ * message contains no intent keyword (e.g. "do it" while staring at the wallet).
+ *
+ * This complements the intent-based weighting in prompt-compaction.ts: intent
+ * looks at *what the user said*, this looks at *where the user is*. Both feed
+ * the same full-param action set the planner sees.
+ *
+ * The active view is reported by the shell via POST /api/views/:id/navigate and
+ * stored here (set by views-routes) so the prompt-optimization layer can read
+ * it without importing the HTTP route module.
+ */
+/** Cap on elements rendered into the awareness block to bound prompt growth. */
+export const ACTIVE_VIEW_ELEMENT_RENDER_CAP = 40;
+/**
+ * A view switch is "fresh" (worth acknowledging on the immediately-following
+ * turn) for this window. Kept in lockstep with VIEW_SWITCH_FRESH_MS in
+ * `views-routes.ts`.
+ */
+export const ACTIVE_VIEW_SWITCH_FRESH_MS = 15_000;
+function isActiveViewSwitchFresh(view) {
+    if (!view.switchedAt)
+        return false;
+    const at = Date.parse(view.switchedAt);
+    if (Number.isNaN(at))
+        return false;
+    return Date.now() - at <= ACTIVE_VIEW_SWITCH_FRESH_MS;
+}
+let activeView = null;
+export function setActiveViewContext(view) {
+    activeView = view;
+}
+export function getActiveViewContext() {
+    return activeView;
+}
+export function clearActiveViewContext() {
+    activeView = null;
+}
+/**
+ * Update the element snapshot for the active view. Gated on `viewId` matching
+ * the current active view so a stale or background view's report (the shell may
+ * have several mounted surfaces) can never overwrite the foreground view's
+ * elements. Returns false when no view is active or the id differs.
+ */
+export function setActiveViewElements(viewId, elements) {
+    if (!activeView || activeView.viewId !== viewId)
+        return false;
+    activeView = { ...activeView, elements };
+    return true;
+}
+/**
+ * Map viewId → runtime action names that get full param detail while that view
+ * is active. Names must match registered Action.name strings; verify before
+ * adding. Kept deliberately conservative — only high-confidence, stable action
+ * names belong here (validated against the live runtime by
+ * `validateViewActionMap`). Universal element control in any view is handled by
+ * the agent-surface view-interact capabilities (list-elements / agent-click /
+ * agent-fill), which are not runtime actions and so do not appear here.
+ *
+ * Verified action names (2026-05-31):
+ *   TASKS      — plugin-agent-orchestrator tasks action (coding/orchestration)
+ *   PLAY_EMOTE — plugin-companion/src/actions/emote.ts
+ *   RUNTIME    — packages/agent/src/actions/runtime.ts (restart/config ops)
+ *
+ * Verified action names + view ids (2026-06-02) — view id from each plugin's
+ * ViewDeclaration, action `name:` from that plugin's (or a thematically paired
+ * plugin's) action source. Actions are plugin-conditional: when the owning
+ * plugin is not loaded the name is simply not registered and the weighting is a
+ * missing-plugin skip (no error). Sources:
+ *   wallet      — view plugins/plugin-wallet-ui; actions plugins/plugin-wallet
+ *                 (chains/evm/actions swap+transfer, chains generated specs)
+ *   polymarket  — plugins/plugin-polymarket-app/src/actions.ts (POLYMARKET_STATUS)
+ *   hyperliquid — plugins/plugin-hyperliquid-app/src/actions/perpetual-market.ts
+ *   steward     — plugin-steward-app re-exports plugin-wallet's WALLET action
+ *   facewear    — plugins/plugin-facewear/src/index.ts (FACEWEAR_, SMARTGLASSES_, XR_ actions)
+ *
+ * Verified action names + view ids (2026-06-18) — each LifeOps/utility view's
+ * own domain actions, so they are emphasised (not just universally
+ * element-controllable) when that view is the foreground surface. Names
+ * confirmed registered in each plugin's actions/ source; plugin-conditional like
+ * the rest (a missing-plugin skip when not loaded). Sources:
+ *   calendar  — PA-registered calendar actions backed by plugin-calendar
+ *   health    — PA-registered actions built from plugin-health factories
+ *   focus     — PA-registered BLOCK umbrella backed by plugin-blocker;
+ *               list_active / release are subactions of it, not standalone actions)
+ *   finances  — PA-registered OWNER_FINANCES backed by plugin-finances
+ *   inbox     — plugins/plugin-inbox/src/actions/inbox (literal name: "INBOX")
+ *   goals     — plugin-goals owns OWNER_GOALS; PA owns routines/reminders/alarms
+ *   todos     — plugins/plugin-personal-assistant/src/actions/owner-surfaces (OWNER_TODOS)
+ *   lifeops   — plugins/plugin-personal-assistant/src/actions (PERSONAL_ASSISTANT)
+ *   relationships — plugins/plugin-relationships/src/actions/entity.ts
+ *              (literal name: "ENTITY"; RelationshipsView reads the entity /
+ *              relationship graph via GET /api/lifeops/{entities,relationships})
+ */
+export const VIEW_ACTION_MAP = {
+    companion: ["PLAY_EMOTE"],
+    "task-coordinator": ["TASKS"],
+    orchestrator: ["TASKS"],
+    "trajectory-logger": ["TASKS"],
+    training: ["RUNTIME"],
+    "plugins-page": ["RUNTIME"],
+    settings: ["RUNTIME"],
+    wallet: [
+        "WALLET",
+        "EVM_SWAP",
+        "EVM_TRANSFER",
+        "SOLANA_SWAP",
+        "SOLANA_TRANSFER",
+        "CROSS_CHAIN_TRANSFER",
+        "BIRDEYE_WALLET_PORTFOLIO",
+    ],
+    steward: ["WALLET"],
+    polymarket: ["POLYMARKET_STATUS"],
+    hyperliquid: ["PERPETUAL_MARKET"],
+    facewear: [
+        "FACEWEAR_CONNECT",
+        "FACEWEAR_DEBUG",
+        "SMARTGLASSES_CONTROL",
+        "SMARTGLASSES_STATUS",
+        "SMARTGLASSES_DISPLAY_TEXT",
+        "SMARTGLASSES_MICROPHONE",
+        "XR_OPEN_VIEW",
+        "XR_CLOSE_VIEW",
+        "XR_SWITCH_VIEW",
+        "XR_LIST_VIEWS",
+        "XR_RESIZE_VIEW",
+        "XR_QUERY_VISION",
+    ],
+    calendar: ["CALENDAR", "CONFLICT_DETECT"],
+    health: ["OWNER_HEALTH", "OWNER_SCREENTIME"],
+    focus: ["BLOCK"],
+    finances: ["OWNER_FINANCES"],
+    inbox: ["INBOX"],
+    goals: ["OWNER_GOALS", "OWNER_ALARMS", "OWNER_REMINDERS", "OWNER_ROUTINES"],
+    todos: ["OWNER_TODOS"],
+    lifeops: ["PERSONAL_ASSISTANT"],
+    relationships: ["ENTITY"],
+    // documents — PA-registered OWNER_DOCUMENTS backed by plugin-documents routes
+    //   (umbrella action "OWNER_DOCUMENTS"; DocumentsView reads/uploads via the
+    //   docs-and-portals domain). Added so a contextual "pull up my documents"
+    //   switch upweights the domain action while the view is foreground (#8798).
+    documents: ["OWNER_DOCUMENTS"],
+};
+/**
+ * Resolve the set of action names to keep at full param detail for the active
+ * view. Returns an empty set when no view is active or the view has no mapped
+ * actions (control still works through agent-surface capabilities).
+ */
+export function viewScopedActionNames(viewId) {
+    if (!viewId)
+        return new Set();
+    return new Set(VIEW_ACTION_MAP[viewId] ?? []);
+}
+/**
+ * Validate VIEW_ACTION_MAP against the runtime's registered actions, mirroring
+ * validateIntentActionMap. Logs a warning for any mapped name that no longer
+ * exists so drift is caught at startup rather than silently dropped.
+ */
+export function validateViewActionMap(registeredActions, logger) {
+    const registered = new Set(registeredActions.map((a) => a.toUpperCase()));
+    for (const [viewId, actions] of Object.entries(VIEW_ACTION_MAP)) {
+        for (const action of actions) {
+            if (!registered.has(action.toUpperCase())) {
+                logger?.warn(`[eliza] VIEW_ACTION_MAP["${viewId}"] references "${action}" which is not a registered action — may be renamed or removed upstream`);
+            }
+        }
+    }
+}
+/**
+ * Completeness sibling of {@link validateViewActionMap}: where that flags a
+ * mapped action name that no longer exists, this flags a *registered view* that
+ * has neither a VIEW_ACTION_MAP entry nor any declared `ViewCapability`. It only
+ * warns (the universal agent-surface still reaches every control), but surfaces
+ * the affinity gap so domain actions for new views are not silently unweighted.
+ * (#8798)
+ *
+ * @param registeredViewIds every view id the registry currently knows about.
+ * @param viewsWithCapabilities view ids that declare a `ViewCapability[]`.
+ */
+export function validateViewCoverage(registeredViewIds, viewsWithCapabilities, logger) {
+    const mapped = new Set(Object.keys(VIEW_ACTION_MAP));
+    const withCaps = new Set(viewsWithCapabilities);
+    const uncovered = [];
+    for (const viewId of registeredViewIds) {
+        if (mapped.has(viewId) || withCaps.has(viewId))
+            continue;
+        uncovered.push(viewId);
+        logger?.warn(`[eliza] view "${viewId}" has no VIEW_ACTION_MAP entry and declares no ViewCapability — its domain actions are not weighted while it is foreground (agent-surface element control still works)`);
+    }
+    return uncovered;
+}
+/**
+ * Render a compact "Active View" awareness block for the planner. Describes the
+ * surface the user is looking at and reminds the agent it can drive every
+ * element through the view-interact capabilities. Exposed for the planner /
+ * context-renderer to inject; pure so it is trivially testable.
+ */
+export function renderActiveViewContextBlock(view) {
+    const scoped = [...viewScopedActionNames(view.viewId)];
+    const lines = [
+        "# Active View",
+        `The user is looking at the "${view.viewLabel}" view (id: ${view.viewId}, ${view.viewType}${view.viewPath ? `, path ${view.viewPath}` : ""}).`,
+    ];
+    // Turn-scoped acknowledgement of a just-happened switch (#8788): only on the
+    // immediately-following turn (freshness decays after 15s), so it never lingers.
+    if (isActiveViewSwitchFresh(view)) {
+        lines.push(`The user just switched into this view${view.source === "agent" ? " (you navigated here)" : ""} — briefly acknowledge the switch in your reply before doing anything else.`);
+    }
+    lines.push("You can inspect and drive everything in it through the view-interact capabilities:", "- list-elements — enumerate addressable controls/data (id, role, label, value, focus).", "- get-agent-state — read the whole view snapshot, including the focused element.", "- agent-click {id} / agent-fill {id,value} / agent-focus {id} / agent-scroll-to {id} — act on an element by its id.", "Prefer acting directly on the view over describing what the user should click.");
+    if (scoped.length > 0) {
+        lines.push(`Actions most relevant while on this view (prefer these when the request fits): ${scoped.join(", ")}.`);
+    }
+    const elements = view.elements ?? [];
+    if (elements.length > 0) {
+        // Focused element first, then declared order; cap to bound prompt growth.
+        const ordered = [...elements].sort((a, b) => Number(b.focused ?? false) - Number(a.focused ?? false));
+        const shown = ordered.slice(0, ACTIVE_VIEW_ELEMENT_RENDER_CAP);
+        lines.push("Addressable elements currently in this view (act on these by id — no list-elements call needed):");
+        for (const el of shown) {
+            const value = typeof el.value === "string" && el.value.length > 0
+                ? ` = ${JSON.stringify(el.value)}`
+                : "";
+            const focused = el.focused ? " (focused)" : "";
+            lines.push(`- ${el.id} [${el.role}] ${JSON.stringify(el.label)}${value}${focused}`);
+        }
+        if (elements.length > shown.length) {
+            lines.push(`- …and ${elements.length - shown.length} more — call list-elements for the rest.`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Inject the active-view awareness block into a planner prompt. Idempotent
+ * (skips if the block is already present) and leaves the prompt unchanged when
+ * no view is active. Placed just before the "# Available Actions" header so
+ * view context sits next to the tool catalogue; falls back to prepending when
+ * that header is absent.
+ */
+export function applyActiveViewAwareness(prompt, view) {
+    if (!view)
+        return prompt;
+    if (prompt.includes("# Active View"))
+        return prompt;
+    const block = renderActiveViewContextBlock(view);
+    const header = "\n# Available Actions";
+    const idx = prompt.indexOf(header);
+    if (idx === -1)
+        return `${block}\n\n${prompt}`;
+    return `${prompt.slice(0, idx)}\n\n${block}\n${prompt.slice(idx + 1)}`;
+}

package/runtime/web-search-tools.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Server-side web search injection for every provider that supports it.
+ *
+ * Monkey-patches the Vercel AI SDK's `generateText`/`streamText` to attach a
+ * provider's native, server-executed web search tool whenever a call targets a
+ * supporting provider and carries no tools of its own. Server-side search is
+ * zero-plumbing: the provider runs the search and grounds its own answer — no
+ * Tavily/Serper key, no extra application round-trips.
+ *
+ * Supported providers (matched against the AI SDK `model.provider` string):
+ *   anthropic.messages    → @ai-sdk/anthropic  webSearch_*
+ *   google.generative-ai  → @ai-sdk/google     googleSearch
+ *   openai.responses      → @ai-sdk/openai      webSearch
+ *
+ * OpenAI's Chat Completions API (`openai.chat`) silently drops provider tools,
+ * so it is intentionally not matched here — the OpenAI plugin routes text
+ * through the Responses API (`openai.responses`) when the endpoint is genuine
+ * OpenAI, which is what makes the `openai.responses` branch fire.
+ *
+ * Controlled by:
+ *   ELIZA_WEB_SEARCH=0|false|off         — disable every web-search surface
+ *   ELIZA_SERVER_WEB_SEARCH=1|true|on    — enable provider-native injection
+ */
+export declare function isServerSideWebSearchEnabled(): boolean;
+export declare function __shouldSkipServerSideWebSearchForTests(params: Record<string, unknown>): boolean;
+/**
+ * Enable server-side web search across all supported providers.
+ *
+ * The patch is global and idempotent — provider selection happens per call
+ * from the model's `provider` string, so a single install covers every agent
+ * and every provider on the runtime. Call after plugins are registered.
+ */
+export declare function installServerSideWebSearch(): void;
+//# sourceMappingURL=web-search-tools.d.ts.map

package/runtime/web-search-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-search-tools.d.ts","sourceRoot":"","sources":["../../src/runtime/web-search-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAmBH,wBAAgB,4BAA4B,IAAI,OAAO,CAGtD;AAiGD,wBAAgB,uCAAuC,CACrD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAET;AAsFD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAQjD"}