@elizaos/agent 2.0.0-alpha.413 → 2.0.0-alpha.415

package/packages/agent/src/auth/oauth-flow.js

@@ -0,0 +1,349 @@
+/**
+ * OAuth flow orchestration registry.
+ *
+ * Wraps the provider-specific programmatic OAuth helpers
+ * (`startAnthropicOAuthFlowRaw` from
+ * `vendor/pi-oauth/anthropic-login.ts` and the loopback-listener flow
+ * in `openai-codex.ts`) with:
+ *
+ *   - a 5-minute timeout per flow,
+ *   - automatic `saveAccount(...)` after token exchange,
+ *   - an in-memory registry keyed by `sessionId` so the HTTP API can
+ *     stream progress over SSE and the CLI can `await` completion,
+ *   - garbage collection 10 minutes after a flow reaches a terminal
+ *     state.
+ *
+ * Both the CLI and the new accounts-routes HTTP endpoints drive flows
+ * through this module — there is no direct caller of the vendor-level
+ * OAuth helpers anymore.
+ */
+import crypto from "node:crypto";
+import { logger } from "@elizaos/core";
+import { saveAccount, } from "./account-storage.js";
+import { startCodexLogin } from "./openai-codex.js";
+import { startAnthropicOAuthFlowRaw, } from "./vendor/pi-oauth/anthropic-login.js";
+const FLOW_TIMEOUT_MS = 5 * 60 * 1000;
+const FLOW_GC_MS = 10 * 60 * 1000;
+const flows = new Map();
+function newSessionId() {
+    return crypto.randomUUID();
+}
+function emit(entry) {
+    for (const listener of entry.listeners) {
+        listener(entry.state);
+    }
+}
+function scheduleGc(sessionId) {
+    const entry = flows.get(sessionId);
+    if (!entry)
+        return;
+    if (entry.gcTimer)
+        clearTimeout(entry.gcTimer);
+    entry.gcTimer = setTimeout(() => {
+        flows.delete(sessionId);
+    }, FLOW_GC_MS);
+}
+function resolveAccountId(opts) {
+    return opts.accountId?.trim() || crypto.randomUUID();
+}
+/**
+ * Build an `AccountCredentialRecord` and persist it via `saveAccount`.
+ * Returns the canonical record (with `createdAt`/`updatedAt` filled).
+ */
+function persistAccount(args) {
+    const now = Date.now();
+    const record = {
+        id: args.accountId,
+        providerId: args.providerId,
+        label: args.label,
+        source: "oauth",
+        credentials: {
+            access: args.access,
+            refresh: args.refresh,
+            expires: args.expires,
+        },
+        createdAt: now,
+        updatedAt: now,
+        ...(args.organizationId ? { organizationId: args.organizationId } : {}),
+        ...(args.email ? { email: args.email } : {}),
+    };
+    saveAccount(record);
+    return record;
+}
+// Anthropic.
+/**
+ * Start a programmatic Anthropic OAuth flow. Anthropic's redirect URI
+ * is hardcoded to `console.anthropic.com/oauth/code/callback` — the
+ * UI must surface the auth URL, prompt the user to copy the
+ * `code#state` blob, and call `submitCode()` with it. Once the code is
+ * submitted, the token exchange runs and the account is persisted.
+ */
+export function startAnthropicOAuthFlow(opts) {
+    return startGenericFlow({
+        providerId: "anthropic-subscription",
+        opts,
+        needsCodeSubmission: true,
+        begin: async () => {
+            const raw = await startAnthropicOAuthFlowRaw();
+            const completion = (async () => {
+                const creds = await raw.completion;
+                return { creds };
+            })();
+            return {
+                authUrl: raw.authUrl,
+                completion,
+                submitCode: raw.submitCode,
+                cancel: raw.cancel,
+            };
+        },
+    });
+}
+// Codex (OpenAI ChatGPT subscription).
+/**
+ * Start a programmatic Codex OAuth flow. Codex has a loopback listener
+ * on :1455, so the user just signs in in the browser and the listener
+ * picks up the redirect — `submitCode()` is a no-op. The accountId
+ * baked into the JWT is preserved on `LinkedAccountConfig.organizationId`
+ * (used by the Codex usage probe via the `ChatGPT-Account-Id` header).
+ */
+export function startCodexOAuthFlow(opts) {
+    return startGenericFlow({
+        providerId: "openai-codex",
+        opts,
+        needsCodeSubmission: false,
+        begin: async () => {
+            const flow = await startCodexLogin();
+            const completion = (async () => {
+                const creds = await flow.credentials;
+                return { creds, codexFlow: flow };
+            })();
+            return {
+                authUrl: flow.authUrl,
+                completion,
+                submitCode: (code) => flow.submitCode(code),
+                cancel: () => flow.close(),
+            };
+        },
+    });
+}
+async function startGenericFlow(args) {
+    const { providerId, opts, needsCodeSubmission, begin } = args;
+    const sessionId = newSessionId();
+    const accountId = resolveAccountId(opts);
+    const vendor = await begin();
+    const startedAt = Date.now();
+    const initialState = {
+        sessionId,
+        providerId,
+        status: "pending",
+        authUrl: vendor.authUrl,
+        needsCodeSubmission,
+        startedAt,
+    };
+    let resolveCompletion;
+    let rejectCompletion;
+    const completion = new Promise((resolve, reject) => {
+        resolveCompletion = resolve;
+        rejectCompletion = reject;
+    });
+    const entry = {
+        state: initialState,
+        handle: {}, // filled below
+        listeners: new Set(),
+    };
+    flows.set(sessionId, entry);
+    const setTerminal = (next) => {
+        if (entry.state.status !== "pending")
+            return;
+        entry.state = {
+            ...entry.state,
+            ...next,
+            endedAt: Date.now(),
+        };
+        emit(entry);
+        scheduleGc(sessionId);
+    };
+    const timer = setTimeout(() => {
+        const err = new Error("OAuth flow timed out after 5 minutes");
+        try {
+            vendor.cancel("timeout");
+        }
+        catch (cancelErr) {
+            logger.debug(`[oauth-flow] cancel during timeout failed: ${String(cancelErr)}`);
+        }
+        setTerminal({ status: "timeout", error: err.message });
+        rejectCompletion(err);
+    }, FLOW_TIMEOUT_MS);
+    // Drive the vendor completion through to account-save and listener emit.
+    void (async () => {
+        try {
+            const { creds } = await vendor.completion;
+            clearTimeout(timer);
+            let organizationId;
+            // Codex bakes the account_id into the JWT — pull it back out for
+            // the usage probe header.
+            if (providerId === "openai-codex") {
+                const codexAccountId = extractCodexAccountId(creds.access);
+                if (codexAccountId)
+                    organizationId = codexAccountId;
+            }
+            const record = persistAccount({
+                providerId,
+                accountId,
+                label: opts.label,
+                access: creds.access,
+                refresh: creds.refresh,
+                expires: creds.expires,
+                ...(organizationId ? { organizationId } : {}),
+            });
+            if (opts.onAccountSaved) {
+                await opts.onAccountSaved(record);
+            }
+            setTerminal({ status: "success", account: record });
+            resolveCompletion({ account: record });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            const message = err instanceof Error ? err.message : String(err);
+            setTerminal({ status: "error", error: message });
+            rejectCompletion(err instanceof Error ? err : new Error(message));
+        }
+    })();
+    const handle = {
+        sessionId,
+        authUrl: vendor.authUrl,
+        needsCodeSubmission,
+        completion,
+        submitCode: (code) => {
+            vendor.submitCode(code);
+        },
+        cancel: (reason = "Cancelled") => {
+            if (entry.state.status !== "pending")
+                return;
+            try {
+                vendor.cancel(reason);
+            }
+            catch (err) {
+                logger.debug(`[oauth-flow] vendor cancel failed: ${String(err)}`);
+            }
+            clearTimeout(timer);
+            const error = new Error(reason);
+            setTerminal({ status: "cancelled", error: reason });
+            rejectCompletion(error);
+        },
+    };
+    entry.handle = handle;
+    emit(entry);
+    return handle;
+}
+// Registry surface used by the SSE / cancel routes.
+export function getFlowState(sessionId) {
+    const entry = flows.get(sessionId);
+    return entry ? entry.state : null;
+}
+export function getFlowHandle(sessionId) {
+    const entry = flows.get(sessionId);
+    return entry ? entry.handle : null;
+}
+/**
+ * Subscribe to status updates for a flow. Replays the current state
+ * synchronously so SSE consumers always receive an immediate frame.
+ * Returns an unsubscribe function.
+ */
+export function subscribeFlow(sessionId, listener) {
+    const entry = flows.get(sessionId);
+    if (!entry)
+        return () => { };
+    entry.listeners.add(listener);
+    // Replay current state.
+    listener(entry.state);
+    return () => {
+        entry.listeners.delete(listener);
+    };
+}
+export function cancelFlow(sessionId, reason) {
+    const entry = flows.get(sessionId);
+    if (!entry)
+        return false;
+    if (entry.state.status !== "pending")
+        return false;
+    entry.handle.cancel(reason);
+    return true;
+}
+export function submitFlowCode(sessionId, code) {
+    const entry = flows.get(sessionId);
+    if (!entry)
+        return false;
+    if (entry.state.status !== "pending")
+        return false;
+    if (!entry.state.needsCodeSubmission)
+        return false;
+    entry.handle.submitCode(code);
+    return true;
+}
+/**
+ * Remove every flow from the registry. Tests use this to reset
+ * between cases without resetting the whole module.
+ */
+export function _resetFlowRegistry() {
+    for (const entry of flows.values()) {
+        if (entry.gcTimer)
+            clearTimeout(entry.gcTimer);
+    }
+    flows.clear();
+}
+/**
+ * Test-only helper to seed a synthetic flow without going through the
+ * vendor layer. Used by `accounts-routes.test.ts` to assert the SSE
+ * surface streams `success` / `error` payloads correctly.
+ */
+export function _registerSyntheticFlow(args) {
+    const sessionId = args.sessionId ?? newSessionId();
+    const state = {
+        sessionId,
+        providerId: args.providerId,
+        status: "pending",
+        authUrl: args.authUrl,
+        needsCodeSubmission: Boolean(args.needsCodeSubmission),
+        startedAt: Date.now(),
+    };
+    const entry = {
+        state,
+        handle: {
+            sessionId,
+            authUrl: args.authUrl,
+            needsCodeSubmission: Boolean(args.needsCodeSubmission),
+            completion: new Promise(() => undefined),
+            submitCode: () => undefined,
+            cancel: () => undefined,
+        },
+        listeners: new Set(),
+    };
+    flows.set(sessionId, entry);
+    const complete = (next) => {
+        entry.state = { ...next, endedAt: next.endedAt ?? Date.now() };
+        emit(entry);
+        scheduleGc(sessionId);
+    };
+    return { sessionId, complete };
+}
+/** OpenAI Codex JWT carries `chatgpt_account_id` under a vendor claim. */
+function extractCodexAccountId(accessToken) {
+    try {
+        const parts = accessToken.split(".");
+        if (parts.length !== 3)
+            return null;
+        const payload = parts[1];
+        const decoded = JSON.parse(Buffer.from(payload, "base64").toString("utf-8"));
+        const claim = decoded["https://api.openai.com/auth"];
+        if (!claim || typeof claim !== "object")
+            return null;
+        const accountId = claim.chatgpt_account_id;
+        return typeof accountId === "string" && accountId.length > 0
+            ? accountId
+            : null;
+    }
+    catch {
+        return null;
+    }
+}

package/packages/agent/src/auth/vendor/pi-oauth/anthropic-login.d.ts

@@ -1,15 +1,47 @@
 /**
  * Anthropic OAuth (Claude Pro/Max) — authorization code + PKCE.
  * Inlined OAuth flow (MIT) — vendored to avoid a runtime dependency.
+ *
+ * Anthropic's OAuth uses a fixed redirect URI on `console.anthropic.com`
+ * that displays the auth code on completion — there's no loopback
+ * listener. The flow surfaces an `authUrl` plus a `submitCode()` hook
+ * the UI / CLI calls once the user has copied the code.
  */
 export interface AnthropicOAuthCredentials {
     refresh: string;
     access: string;
     expires: number;
 }
+/**
+ * Programmatic Anthropic OAuth flow.
+ *
+ * `authUrl` is ready immediately. The caller MUST eventually call
+ * either `submitCode(code)` (after the user has pasted the
+ * `code#state` blob from the redirect page) or `cancel()`. The
+ * `completion` promise rejects if the flow is cancelled.
+ */
+export interface AnthropicOAuthFlowHandle {
+    authUrl: string;
+    /** Pass `code#state` from the redirect page. */
+    submitCode: (code: string) => void;
+    /** Resolves with credentials once `submitCode` lands and the token exchange succeeds. */
+    completion: Promise<AnthropicOAuthCredentials>;
+    cancel: (reason?: string) => void;
+}
+/**
+ * Start an Anthropic OAuth flow. Returns immediately with the auth
+ * URL and a `submitCode` hook. The token exchange happens inside
+ * `completion` once the caller submits the code.
+ */
+export declare function startAnthropicOAuthFlowRaw(): Promise<AnthropicOAuthFlowHandle>;
 /**
  * @param onAuthUrl - Receives the browser authorization URL
  * @param onPromptCode - Resolves with pasted code (format: code#state)
+ *
+ * Thin compatibility wrapper around `startAnthropicOAuthFlowRaw` for
+ * the CLI entrypoint and any older callers. New code should use
+ * `startAnthropicOAuthFlowRaw` (or the higher-level
+ * `startAnthropicOAuthFlow` in `auth/oauth-flow.ts`) directly.
  */
 export declare function loginAnthropic(onAuthUrl: (url: string) => void, onPromptCode: () => Promise<string>): Promise<AnthropicOAuthCredentials>;
 export declare function refreshAnthropicToken(refreshToken: string): Promise<AnthropicOAuthCredentials>;

package/packages/agent/src/auth/vendor/pi-oauth/anthropic-login.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-login.d.ts","sourceRoot":"","sources":["../../../../../../../src/auth/vendor/pi-oauth/anthropic-login.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EAChC,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAClC,OAAO,CAAC,yBAAyB,CAAC,CA6CpC;AAED,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,yBAAyB,CAAC,CAwBpC"}
+{"version":3,"file":"anthropic-login.d.ts","sourceRoot":"","sources":["../../../../../../../src/auth/vendor/pi-oauth/anthropic-login.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAWH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,yFAAyF;IACzF,UAAU,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAC/C,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED;;;;GAIG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,wBAAwB,CAAC,CA6DpF;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EAChC,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAClC,OAAO,CAAC,yBAAyB,CAAC,CAMpC;AAED,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,yBAAyB,CAAC,CAwBpC"}

package/packages/agent/src/auth/vendor/pi-oauth/anthropic-login.js

@@ -1,6 +1,11 @@
 /**
  * Anthropic OAuth (Claude Pro/Max) — authorization code + PKCE.
  * Inlined OAuth flow (MIT) — vendored to avoid a runtime dependency.
+ *
+ * Anthropic's OAuth uses a fixed redirect URI on `console.anthropic.com`
+ * that displays the auth code on completion — there's no loopback
+ * listener. The flow surfaces an `authUrl` plus a `submitCode()` hook
+ * the UI / CLI calls once the user has copied the code.
  */
 import { generatePKCE } from "./pkce.js";
 const decode = (s) => atob(s);
@@ -10,10 +15,11 @@ const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
 const REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
 const SCOPES = "org:create_api_key user:profile user:inference";
 /**
- * @param onAuthUrl - Receives the browser authorization URL
- * @param onPromptCode - Resolves with pasted code (format: code#state)
+ * Start an Anthropic OAuth flow. Returns immediately with the auth
+ * URL and a `submitCode` hook. The token exchange happens inside
+ * `completion` once the caller submits the code.
  */
-export async function loginAnthropic(onAuthUrl, onPromptCode) {
+export async function startAnthropicOAuthFlowRaw() {
     const { verifier, challenge } = await generatePKCE();
     const authParams = new URLSearchParams({
         code: "true",
@@ -26,35 +32,64 @@ export async function loginAnthropic(onAuthUrl, onPromptCode) {
         state: verifier,
     });
     const authUrl = `${AUTHORIZE_URL}?${authParams.toString()}`;
-    onAuthUrl(authUrl);
-    const authCode = await onPromptCode();
-    const splits = authCode.split("#");
-    const code = splits[0];
-    const state = splits[1];
-    const tokenResponse = await fetch(TOKEN_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            grant_type: "authorization_code",
-            client_id: CLIENT_ID,
-            code,
-            state,
-            redirect_uri: REDIRECT_URI,
-            code_verifier: verifier,
-        }),
+    let resolveCode = null;
+    let rejectCode = null;
+    const codePromise = new Promise((resolve, reject) => {
+        resolveCode = resolve;
+        rejectCode = reject;
     });
-    if (!tokenResponse.ok) {
-        const errText = await tokenResponse.text();
-        throw new Error(`Token exchange failed: ${errText}`);
-    }
-    const tokenData = (await tokenResponse.json());
-    const expiresAt = Date.now() + tokenData.expires_in * 1000 - 5 * 60 * 1000;
+    const completion = (async () => {
+        const authCode = await codePromise;
+        const splits = authCode.split("#");
+        const code = splits[0];
+        const state = splits[1];
+        const tokenResponse = await fetch(TOKEN_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                grant_type: "authorization_code",
+                client_id: CLIENT_ID,
+                code,
+                state,
+                redirect_uri: REDIRECT_URI,
+                code_verifier: verifier,
+            }),
+        });
+        if (!tokenResponse.ok) {
+            const errText = await tokenResponse.text();
+            throw new Error(`Token exchange failed: ${errText}`);
+        }
+        const tokenData = (await tokenResponse.json());
+        const expiresAt = Date.now() + tokenData.expires_in * 1000 - 5 * 60 * 1000;
+        return {
+            refresh: tokenData.refresh_token,
+            access: tokenData.access_token,
+            expires: expiresAt,
+        };
+    })();
     return {
-        refresh: tokenData.refresh_token,
-        access: tokenData.access_token,
-        expires: expiresAt,
+        authUrl,
+        submitCode: (code) => resolveCode?.(code),
+        completion,
+        cancel: (reason = "Cancelled") => rejectCode?.(new Error(reason)),
     };
 }
+/**
+ * @param onAuthUrl - Receives the browser authorization URL
+ * @param onPromptCode - Resolves with pasted code (format: code#state)
+ *
+ * Thin compatibility wrapper around `startAnthropicOAuthFlowRaw` for
+ * the CLI entrypoint and any older callers. New code should use
+ * `startAnthropicOAuthFlowRaw` (or the higher-level
+ * `startAnthropicOAuthFlow` in `auth/oauth-flow.ts`) directly.
+ */
+export async function loginAnthropic(onAuthUrl, onPromptCode) {
+    const handle = await startAnthropicOAuthFlowRaw();
+    onAuthUrl(handle.authUrl);
+    const code = await onPromptCode();
+    handle.submitCode(code);
+    return handle.completion;
+}
 export async function refreshAnthropicToken(refreshToken) {
     const response = await fetch(TOKEN_URL, {
         method: "POST",

package/packages/agent/src/config/schema.js

@@ -413,7 +413,7 @@ const FIELD_HELP = {
     "diagnostics.cacheTrace.includePrompt": "Include prompt text in trace output (default: true).",
     "diagnostics.cacheTrace.includeSystem": "Include system prompt in trace output (default: true).",
     "tools.exec.applyPatch.enabled": "Experimental. Enables apply_patch for OpenAI models when allowed by tool policy.",
-    "tools.exec.applyPatch.allowModels": 'Optional allowlist of model ids (e.g. "gpt-5.4" or "openai/gpt-5.4").',
+    "tools.exec.applyPatch.allowModels": 'Optional allowlist of model ids (e.g. "gpt-5.5" or "openai/gpt-5.5").',
     "tools.exec.notifyOnExit": "When true (default), backgrounded exec sessions enqueue a system event and request a heartbeat on exit.",
     "tools.exec.pathPrepend": "Directories to prepend to PATH for exec runs (gateway/sandbox).",
     "tools.exec.safeBins": "Allow stdin-only safe binaries to run without explicit allowlist entries.",

package/packages/agent/src/config/types.messages.d.ts

@@ -123,7 +123,7 @@ export type MessagesConfig = {
      * - special value: `"auto"` derives `[{agents.list[].identity.name}]` for the routed agent (when set)
      *
      * Supported template variables (case-insensitive):
-     * - `{model}` - short model name (e.g., `claude-opus-4-7`, `gpt-5.4`)
+     * - `{model}` - short model name (e.g., `claude-opus-4-7`, `gpt-5.5`)
      * - `{modelFull}` - full model identifier (e.g., `anthropic/claude-opus-4.7`)
      * - `{provider}` - provider name (e.g., `anthropic`, `openai`)
      * - `{thinkingLevel}` or `{think}` - current thinking level (`high`, `low`, `off`)

package/packages/agent/src/config/types.tools.d.ts

@@ -141,7 +141,7 @@ export type ExecToolConfig = {
         enabled?: boolean;
         /**
          * Optional allowlist of model ids that can use apply_patch.
-         * Accepts either raw ids (e.g. "gpt-5.4") or full ids (e.g. "openai/gpt-5.4").
+         * Accepts either raw ids (e.g. "gpt-5.5") or full ids (e.g. "openai/gpt-5.5").
          */
         allowModels?: string[];
     };

package/packages/agent/src/providers/page-scoped-context.js

@@ -9,7 +9,7 @@ const PAGE_SCOPE_BRIEF = {
     "page-browser": "The user is in the Browser view. Tabs are grouped into User Tabs, Agent Tabs, and App Tabs. User Tabs are writable: the user can open them, navigate URLs, refresh pages, capture snapshots, show or hide tabs, and close tabs there. Agent Tabs and App Tabs are read-only context: inspect and explain them, but do not navigate, click, type into, refresh, close, or otherwise mutate them. Action vocabulary the agent can rely on includes openBrowserWorkspaceTab, navigateBrowserWorkspaceTab, snapshotBrowserWorkspaceTab, showBrowserWorkspaceTab, hideBrowserWorkspaceTab, closeBrowserWorkspaceTab. When the user asks what to do, explain the available browser actions, recommend the next action from live tab and bridge state, and offer to answer questions about tabs, forms, current pages, or setup. Do not invent tabs or URLs.",
     "page-character": "The user is in the Character view. The Character hub is organized into Overview, Personality, Knowledge, Experience, and Relationships. Name, voice, and system prompt live in Settings > Identity; Personality focuses on bio, style rules, message examples, and evolution history; Knowledge holds uploaded and learned knowledge; Experience surfaces durable learnings the agent recorded; Relationships shows the full relationship graph, facts, memories, and user-scoped personality preferences. When the user asks what to do, explain the relevant hub section, recommend the next improvement from live state, and offer to draft exact copy. Guide the user to the relevant section rather than fabricate a generic setter action.",
     "page-automations": "The user is in the Automations view. They can create coordinator-text triggers, one-off tasks, recurring tasks, and n8n workflows; set cron or interval schedules; configure wake mode (inject_now / schedule_at / interval), max-runs, and enabled state; browse templates; inspect existing automations; and troubleshoot failed runs. Action vocabulary: createTriggerTaskAction, updateTriggerTaskAction, deleteTriggerTaskAction, runTriggerNowAction, createWorkflowAction, deleteWorkflowAction, toggleWorkflowActiveAction, promoteTaskToWorkflowAction, manageTasksAction. When the user asks what to do, recommend trigger vs task vs workflow based on the event, schedule, and desired result. Triggers and workflows already in the system are listed in live state below; reference them by display name when answering.",
-    "page-apps": "The user is in the Apps view. They can browse and compare catalog apps, launch apps, stop running apps, open attached live viewers, inspect run health and summaries, and manage favorites or recent apps. Action vocabulary: launchAppAction, stopAppAction. When the user asks what to do, recommend an app or run-management action from the live catalog and running app state. Refer to apps by display name and never invent app names.",
+    "page-apps": "The user is in the Apps view. They can browse and compare catalog apps, launch apps, stop running apps, open attached live viewers, inspect run health and summaries, and manage favorites or recent apps. Action vocabulary: APP with mode launch, relaunch, list, load_from_directory, or create. When the user asks what to do, recommend an app or run-management action from the live catalog and running app state. Refer to apps by display name and never invent app names.",
     "page-connectors": "The user is in the Connectors view. They can inspect connector availability, authentication state, setup requirements, webhook readiness, and integration health. When the user asks what to do, recommend the smallest connector setup or troubleshooting action that fits the visible state. Never invent connected accounts, permissions, webhook state, or delivery results.",
     "page-plugins": "The user is in the Plugins view. They can inspect installed plugins, registry plugins, configuration readiness, plugin health, and runtime capability gaps. When the user asks what to do, recommend the smallest plugin setup or troubleshooting action that fits the visible state. Never invent installed plugins, credentials, or enabled capabilities.",
     "page-lifeops": "The user is in the LifeOps view. They can inspect the overview, goals, reminders, calendar, messages, mail, sleep, screen time, social context, connector setup, capability readiness, and LifeOps settings. The LifeOps app provider and actions are the authoritative execution path for creating or changing personal workflows, reminders, goals, schedules, inbox drafts, connector setup, and executive-assistant follow-through. When the user asks what to do, recommend capability readiness and overview review first, then suggest the smallest concrete LifeOps action. Reference only live LifeOps state below; never invent reminders, messages, calendar events, goals, or connector status.",

package/packages/agent/src/runtime/eliza-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eliza-plugin.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/eliza-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAiB,MAAM,EAAgB,MAAM,eAAe,CAAC;AA2GzE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAsMpE"}
+{"version":3,"file":"eliza-plugin.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/eliza-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAiB,MAAM,EAAgB,MAAM,eAAe,CAAC;AA0GzE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAoMpE"}

package/packages/agent/src/runtime/eliza-plugin.js

@@ -6,7 +6,6 @@
  * Memory search/get actions are superseded by plugin-clipboard.
  */
 import { AgentEventService } from "@elizaos/core";
-import { launchAppAction, stopAppAction } from "../actions/app-control.js";
 import { browserSessionAction } from "../actions/browser-session.js";
 import { executeDatabaseQueryAction, getTableDataAction, listDatabaseTablesAction, searchVectorsAction, } from "../actions/database.js";
 import { getRelationshipActivityAction, linkEntityAction, readEntityAction, resolveMergeCandidateAction, searchEntityAction, } from "../actions/entity-actions.js";
@@ -167,8 +166,6 @@ export function createElizaPlugin(config) {
         evaluators: [lateJoinWhitelistEvaluator],
         actions: [
             restartAction,
-            launchAppAction,
-            stopAppAction,
             sendAdminMessageAction,
             terminalAction,
             createTriggerTaskAction,

package/packages/agent/src/runtime/eliza.js

@@ -464,8 +464,8 @@ function isLikelyOpenAiTextModel(value) {
  * Normalize known-bad provider compatibility shims before plugin resolution.
  *
  * A common failure mode is routing the OpenAI plugin through Groq's
- * OpenAI-compatible base URL while leaving OpenAI defaults (`gpt-5.4`,
- * `gpt-5.4-mini`) in place. Structured XML/object generation then fails during
+ * OpenAI-compatible base URL while leaving OpenAI defaults (`gpt-5.5`,
+ * `gpt-5.5-mini`) in place. Structured XML/object generation then fails during
  * message handling because Groq does not serve those model IDs.
  *
  * When we can confidently detect that state, rewrite the effective runtime
@@ -1036,7 +1036,7 @@ export function applyCloudConfigToEnv(config) {
     const llmText = resolveServiceRoutingInConfig(config)?.llmText;
     const models = config.models;
     if (effectivelyEnabled) {
-        const nano = llmText?.nanoModel || models?.nano || "openai/gpt-5.4-nano";
+        const nano = llmText?.nanoModel || models?.nano || "openai/gpt-5.5-nano";
         const small = llmText?.smallModel || models?.small || "minimax/minimax-m2.7";
         const medium = llmText?.mediumModel || models?.medium || small;
         const large = llmText?.largeModel || models?.large || "anthropic/claude-opus-4-7";

package/packages/agent/src/runtime/plugin-collector.js

@@ -391,10 +391,9 @@ export function collectPluginNames(config, reasons) {
     if (shellPluginDisabled) {
         pluginsToLoad.delete("@elizaos/plugin-shell");
     }
-    for (const optionalCore of OPTIONAL_CORE_PLUGINS) {
-        const resolved = resolvePluginPackageAlias(optionalCore);
-        if (isPluginExplicitlyDisabled(resolved)) {
-            pluginsToLoad.delete(resolved);
+    for (const pluginName of Array.from(pluginsToLoad)) {
+        if (isPluginExplicitlyDisabled(pluginName)) {
+            pluginsToLoad.delete(pluginName);
         }
     }
     return pluginsToLoad;

package/packages/app-core/src/components/conversations/conversation-utils.js

@@ -104,10 +104,10 @@ export function isNonChatModelLabel(model) {
 export function estimateTokenCost(promptTokens, completionTokens, model) {
     const normalizedModel = (model ?? "").toLowerCase();
     const pricingByMillion = {
-        "gpt-5.4-pro": [30.0, 180.0],
-        "gpt-5.4-mini": [0.75, 4.5],
-        "gpt-5.4-nano": [0.2, 1.25],
-        "gpt-5.4": [2.5, 15.0],
+        "gpt-5.5-pro": [30.0, 180.0],
+        "gpt-5.5-mini": [0.75, 4.5],
+        "gpt-5.5-nano": [0.2, 1.25],
+        "gpt-5.5": [2.5, 15.0],
         "gpt-4.1": [2.0, 8.0],
         "gpt-4o": [2.5, 10.0],
         "gpt-4": [30.0, 60.0],

package/packages/app-core/src/components/pages/page-scoped-conversations.js

@@ -37,7 +37,7 @@ export const PAGE_SCOPE_COPY = {
     "page-apps": {
         title: "Apps chat",
         body: "Use me to browse the catalog, compare apps, launch an app, stop a running app, open a live viewer, inspect run health, and manage favorites or recent apps. Recommended: describe the outcome you want, and I'll suggest the right app or launch it. Ask me about any catalog item or running app.",
-        systemAddendum: "You are answering inside the Apps view. The user can browse the catalog, compare apps by category and capability, launch apps, stop running apps, open attached live viewers, inspect run health and summaries, and manage favorites or recent apps. Recommend the best app or next run-management action based on live catalog and run state. Use launchAppAction and stopAppAction when the request is concrete. Refer to apps by display name and never invent app names.",
+        systemAddendum: "You are answering inside the Apps view. The user can browse the catalog, compare apps by category and capability, launch apps, stop running apps, open attached live viewers, inspect run health and summaries, and manage favorites or recent apps. Recommend the best app or next run-management action based on live catalog and run state. Use APP with mode launch, relaunch, list, load_from_directory, or create when the request is concrete. Refer to apps by display name and never invent app names.",
     },
     "page-connectors": {
         title: "Connectors chat",

package/packages/app-core/src/components/settings/ProviderSwitcher.js

@@ -168,7 +168,7 @@ export function ProviderSwitcher(props = {}) {
                 const providerId = getOnboardingProviderOption(llmText?.backend)?.id;
                 const elizaCloudEnabledCfg = llmText?.transport === "cloud-proxy" && providerId === "elizacloud";
                 const defaults = {
-                    nano: "openai/gpt-5.4-nano",
+                    nano: "openai/gpt-5.5-nano",
                     small: "minimax/minimax-m2.7",
                     medium: "anthropic/claude-sonnet-4.6",
                     large: "moonshotai/kimi-k2.5",