@elizaos/ui 2.0.0-alpha.411 → 2.0.0-alpha.414

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/refresh-mutex.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Async mutex keyed by string. Single in-flight operation per key.
+ *
+ * Used to serialize OAuth refresh attempts per `{providerId}:{accountId}`
+ * pair so concurrent `getAccessToken` calls don't race on file writes
+ * (and don't burn refresh-token grants).
+ */
+export declare class KeyedMutex {
+    private readonly inflight;
+    /**
+     * Run `fn` while holding the lock for `key`. Concurrent callers with
+     * the same key wait for the in-flight promise to settle, then run
+     * their own attempt — they do NOT share the result. The caller is
+     * expected to re-check state (e.g. re-read credentials) after acquire.
+     */
+    acquire<T>(key: string, fn: () => Promise<T>): Promise<T>;
+}
+export declare const accountRefreshMutex: KeyedMutex;
+//# sourceMappingURL=refresh-mutex.d.ts.map

package/packages/agent/src/auth/refresh-mutex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh-mutex.d.ts","sourceRoot":"","sources":["../../../../../../agent/src/auth/refresh-mutex.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuC;IAEhE;;;;;OAKG;IACG,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAehE;AAED,eAAO,MAAM,mBAAmB,YAAmB,CAAC"}

package/packages/agent/src/auth/refresh-mutex.js

@@ -0,0 +1,33 @@
+/**
+ * Async mutex keyed by string. Single in-flight operation per key.
+ *
+ * Used to serialize OAuth refresh attempts per `{providerId}:{accountId}`
+ * pair so concurrent `getAccessToken` calls don't race on file writes
+ * (and don't burn refresh-token grants).
+ */
+export class KeyedMutex {
+    inflight = new Map();
+    /**
+     * Run `fn` while holding the lock for `key`. Concurrent callers with
+     * the same key wait for the in-flight promise to settle, then run
+     * their own attempt — they do NOT share the result. The caller is
+     * expected to re-check state (e.g. re-read credentials) after acquire.
+     */
+    async acquire(key, fn) {
+        const previous = this.inflight.get(key);
+        if (previous) {
+            await previous.catch(() => { });
+        }
+        const next = (async () => fn())();
+        this.inflight.set(key, next);
+        try {
+            return await next;
+        }
+        finally {
+            if (this.inflight.get(key) === next) {
+                this.inflight.delete(key);
+            }
+        }
+    }
+}
+export const accountRefreshMutex = new KeyedMutex();

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":["../../../../../../../../agent/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":["../../../../../../../../agent/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.eliza.d.ts

@@ -1,6 +1,6 @@
 import type { RolesConfig, SessionConfig, SessionSendPolicyConfig } from "@elizaos/core";
 import type { CustomActionDef, DatabaseProviderType, MediaConfig, ReleaseChannel } from "../contracts/config.js";
-import type { DeploymentTargetConfig, LinkedAccountsConfig, ServiceRoutingConfig } from "../contracts/service-routing.js";
+import type { DeploymentTargetConfig, LinkedAccountFlagsConfig, ServiceRoutingConfig } from "../contracts/service-routing.js";
 import type { AgentBinding, AgentsConfig } from "./types.agents.js";
 import type { DiscoveryConfig, GatewayConfig, TalkConfig } from "./types.gateway.js";
 import type { HooksConfig } from "./types.hooks.js";
@@ -649,8 +649,13 @@ export type ElizaConfig = {
     };
     /** Deployment target for the current agent runtime. */
     deploymentTarget?: DeploymentTargetConfig;
-    /** Linked external accounts that can be used by routing decisions. */
-    linkedAccounts?: LinkedAccountsConfig;
+    /**
+     * Legacy linked-account flags persisted in `milady.json` (e.g.
+     * `linkedAccounts.elizacloud.status === "linked"`). Per-account
+     * credential records live under `~/.eliza/auth/{providerId}/...`
+     * and are surfaced via the WS3 accounts API, not this config.
+     */
+    linkedAccounts?: LinkedAccountFlagsConfig;
     /** Canonical per-capability routing for AI and cloud-backed services. */
     serviceRouting?: ServiceRoutingConfig;
     /** CUA (Computer Use Agent) cloud sandbox configuration. */