@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/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/dist/packages/agent/src/auth/openai-codex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenAI Codex (ChatGPT Plus/Pro subscription) OAuth flow
+ *
+ * Uses inlined OAuth (vendored helpers).
+ * Handles local callback server + manual code paste fallback.
+ */
+import type { OAuthCredentials } from "./types.ts";
+export interface CodexFlow {
+    authUrl: string;
+    state: string;
+    /** Submit a manually-pasted code/URL */
+    submitCode: (code: string) => void;
+    /** Wait for credentials (either via callback server or manual code) */
+    credentials: Promise<OAuthCredentials>;
+    /** Close the callback server */
+    close: () => void;
+}
+/**
+ * Start the OpenAI Codex OAuth flow.
+ * Starts a local callback server on port 1455 and returns the auth URL.
+ */
+export declare function startCodexLogin(): Promise<CodexFlow>;
+/**
+ * Refresh an expired OpenAI Codex token.
+ */
+export declare function refreshCodexToken(refreshToken: string): Promise<OAuthCredentials>;
+//# sourceMappingURL=openai-codex.d.ts.map

package/dist/packages/agent/src/auth/openai-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-codex.d.ts","sourceRoot":"","sources":["../../../../../src/auth/openai-codex.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMnD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACvC,gCAAgC;IAChC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAsDpD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAO3B"}

package/dist/packages/agent/src/auth/openai-codex.js

@@ -0,0 +1,76 @@
+/**
+ * OpenAI Codex (ChatGPT Plus/Pro subscription) OAuth flow
+ *
+ * Uses inlined OAuth (vendored helpers).
+ * Handles local callback server + manual code paste fallback.
+ */
+import { logger } from "@elizaos/core";
+import { loginOpenAICodex, refreshOpenAICodexToken, } from "./vendor/pi-oauth/openai-codex-login.js";
+/**
+ * Start the OpenAI Codex OAuth flow.
+ * Starts a local callback server on port 1455 and returns the auth URL.
+ */
+export function startCodexLogin() {
+    return new Promise((resolveFlow, rejectFlow) => {
+        let authUrl = "";
+        let flowState = "";
+        let resolveManual = null;
+        let closeServer = null;
+        let credentials;
+        const manualPromise = new Promise((resolve) => {
+            resolveManual = resolve;
+        });
+        try {
+            credentials = loginOpenAICodex({
+                onAuth: ({ url }) => {
+                    authUrl = url;
+                    try {
+                        const parsed = new URL(url);
+                        flowState = parsed.searchParams.get("state") || "";
+                    }
+                    catch {
+                        /* */
+                    }
+                    resolveFlow({
+                        get authUrl() {
+                            return authUrl;
+                        },
+                        state: flowState,
+                        submitCode: (code) => resolveManual?.(code),
+                        credentials,
+                        close: () => closeServer?.(),
+                    });
+                },
+                onPrompt: async () => manualPromise,
+                onManualCodeInput: () => manualPromise,
+                onProgress: () => { },
+                originator: "eliza",
+            }).then((creds) => ({
+                access: creds.access,
+                refresh: creds.refresh,
+                expires: creds.expires,
+            }));
+            void credentials.catch((err) => {
+                logger.warn(`[auth] OpenAI Codex credential flow failed: ${err}`);
+            });
+        }
+        catch (err) {
+            rejectFlow(err);
+            return;
+        }
+        closeServer = () => {
+            resolveManual?.("");
+        };
+    });
+}
+/**
+ * Refresh an expired OpenAI Codex token.
+ */
+export async function refreshCodexToken(refreshToken) {
+    const refreshed = await refreshOpenAICodexToken(refreshToken);
+    return {
+        access: refreshed.access,
+        refresh: refreshed.refresh,
+        expires: refreshed.expires,
+    };
+}

package/dist/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/dist/packages/agent/src/auth/refresh-mutex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh-mutex.d.ts","sourceRoot":"","sources":["../../../../../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/dist/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/dist/packages/agent/src/auth/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Subscription auth types for eliza.
+ */
+export interface OAuthCredentials {
+    access: string;
+    refresh: string;
+    expires: number;
+}
+export type SubscriptionProvider = "anthropic-subscription" | "openai-codex" | "gemini-cli" | "zai-coding" | "kimi-coding" | "deepseek-coding";
+export type OAuthSubscriptionProvider = "anthropic-subscription" | "openai-codex";
+export type CodingPlanKeySubscriptionProvider = "zai-coding" | "kimi-coding";
+export type ExternalCliSubscriptionProvider = "gemini-cli";
+export type UnavailableSubscriptionProvider = "deepseek-coding";
+export type DirectAccountProvider = "anthropic-api" | "openai-api" | "deepseek-api" | "zai-api" | "moonshot-api";
+export type AccountCredentialProvider = SubscriptionProvider | DirectAccountProvider;
+export declare const SUBSCRIPTION_PROVIDER_IDS: readonly ["anthropic-subscription", "openai-codex", "gemini-cli", "zai-coding", "kimi-coding", "deepseek-coding"];
+export declare const OAUTH_SUBSCRIPTION_PROVIDER_IDS: readonly ["anthropic-subscription", "openai-codex"];
+export declare const CODING_PLAN_KEY_SUBSCRIPTION_PROVIDER_IDS: readonly ["zai-coding", "kimi-coding"];
+export declare const EXTERNAL_CLI_SUBSCRIPTION_PROVIDER_IDS: readonly ["gemini-cli"];
+export declare const UNAVAILABLE_SUBSCRIPTION_PROVIDER_IDS: readonly ["deepseek-coding"];
+export declare const DIRECT_ACCOUNT_PROVIDER_IDS: readonly ["anthropic-api", "openai-api", "deepseek-api", "zai-api", "moonshot-api"];
+export declare const ACCOUNT_CREDENTIAL_PROVIDER_IDS: readonly ["anthropic-subscription", "openai-codex", "gemini-cli", "zai-coding", "kimi-coding", "deepseek-coding", "anthropic-api", "openai-api", "deepseek-api", "zai-api", "moonshot-api"];
+export declare function isSubscriptionProvider(value: unknown): value is SubscriptionProvider;
+export declare function isOAuthSubscriptionProvider(value: unknown): value is OAuthSubscriptionProvider;
+export declare function isCodingPlanKeySubscriptionProvider(value: unknown): value is CodingPlanKeySubscriptionProvider;
+export declare function isExternalCliSubscriptionProvider(value: unknown): value is ExternalCliSubscriptionProvider;
+export declare function isUnavailableSubscriptionProvider(value: unknown): value is UnavailableSubscriptionProvider;
+export declare function isAccountCredentialProvider(value: unknown): value is AccountCredentialProvider;
+export declare const DIRECT_ACCOUNT_PROVIDER_ENV: Record<DirectAccountProvider, string>;
+/** Maps subscription provider IDs to their model provider short names. */
+export declare const SUBSCRIPTION_PROVIDER_MAP: Record<SubscriptionProvider, string>;
+export declare const CODING_PLAN_PROVIDER_BASE_URL: Record<CodingPlanKeySubscriptionProvider, string>;
+export type SubscriptionProviderAuthMode = "oauth" | "external-cli" | "coding-plan-key" | "unavailable";
+export type SubscriptionProviderBillingMode = "subscription-coding-plan" | "subscription-coding-cli";
+export type SubscriptionProviderAvailability = "available" | "external" | "unavailable";
+export interface SubscriptionProviderMetadata {
+    providerId: SubscriptionProvider;
+    displayName: string;
+    selectionIds: readonly string[];
+    allowedClient: string;
+    billingMode: SubscriptionProviderBillingMode;
+    authMode: SubscriptionProviderAuthMode;
+    availability: SubscriptionProviderAvailability;
+    setupHint: string;
+    directProviderId?: DirectAccountProvider;
+    defaultBaseUrl?: string;
+    probePath?: string;
+    availabilityReason?: string;
+}
+export declare const SUBSCRIPTION_PROVIDER_METADATA: Record<SubscriptionProvider, SubscriptionProviderMetadata>;
+export declare function getSubscriptionProviderMetadata(provider: SubscriptionProvider): SubscriptionProviderMetadata;
+export interface StoredCredentials {
+    provider: AccountCredentialProvider;
+    credentials: OAuthCredentials;
+    createdAt: number;
+    updatedAt: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/packages/agent/src/auth/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/auth/types.ts"],"names":[],"mappings":"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"}