@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/protocols/acp/acp-stdio-server.js

@@ -30,6 +30,7 @@
  * backed by client `fs/*` + `session/request_permission`, and MCP passthrough.
  */
 import { randomUUID } from 'crypto';
+import { AcpSessionStore } from './acp-session-store.js';
 export const ACP_PROTOCOL_VERSION = 1;
 function asString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
@@ -56,6 +57,8 @@ export class AcpStdioServer {
     clientRequestTimeoutMs;
     sessions = new Map();
     pendingClientRequests = new Map();
+    store;
+    storeLoaded = false;
     clientCapabilities = {};
     nextClientRequestId = 0;
     buffer = '';
@@ -68,6 +71,7 @@ export class AcpStdioServer {
         this.agentInfo = options.agentInfo ?? { name: 'Code Buddy', title: 'Code Buddy', version: '1.0.0' };
         this.protocolVersion = options.protocolVersion ?? ACP_PROTOCOL_VERSION;
         this.clientRequestTimeoutMs = options.clientRequestTimeoutMs ?? 120_000;
+        this.store = options.store ?? new AcpSessionStore();
     }
     start() {
         if (this.started)
@@ -100,9 +104,45 @@ export class AcpStdioServer {
     sendUpdate(sessionId, update, options = {}) {
         if (options.record !== false) {
             this.sessions.get(sessionId)?.history.push(update);
+            void this.persistSession(sessionId);
         }
         this.write({ jsonrpc: '2.0', method: 'session/update', params: { sessionId, update } });
     }
+    ensureStoreLoaded() {
+        if (this.storeLoaded)
+            return;
+        this.storeLoaded = true;
+        return this.store.listAll().then((loaded) => {
+            for (const s of loaded) {
+                if (!this.sessions.has(s.sessionId)) {
+                    this.sessions.set(s.sessionId, {
+                        cwd: s.cwd,
+                        active: null,
+                        history: s.history,
+                        mcpServers: s.mcpServers,
+                        title: s.title,
+                        updatedAt: s.updatedAt,
+                    });
+                }
+            }
+        }).catch((err) => {
+            this.storeLoaded = false;
+            throw err;
+        });
+    }
+    async persistSession(sessionId) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            return;
+        await this.store.save({
+            sessionId,
+            cwd: s.cwd,
+            history: s.history,
+            mcpServers: s.mcpServers,
+            title: s.title,
+            updatedAt: s.updatedAt,
+        });
+    }
     requestClient(method, params = {}, options = {}) {
         const clientCapabilities = options.clientCapabilities ?? this.clientCapabilities;
         if (!canRequestClientWithCapabilities(method, clientCapabilities)) {
@@ -230,24 +270,32 @@ export class AcpStdioServer {
             });
         }
     }
-    async dispatch(method, params) {
-        switch (method) {
-            case 'initialize':
-                return this.handleInitialize(params);
-            case 'session/new':
-                return this.handleNewSession(params);
-            case 'session/list':
-                return this.handleListSessions(params);
-            case 'session/load':
-                return this.handleLoadSession(params);
-            case 'session/prompt':
-                return this.handlePrompt(params);
-            default: {
-                const error = new Error(`Method not found: ${method}`);
-                error.code = -32601;
-                throw error;
+    dispatch(method, params) {
+        const run = () => {
+            switch (method) {
+                case 'initialize':
+                    return this.handleInitialize(params);
+                case 'session/new':
+                    return this.handleNewSession(params);
+                case 'session/list':
+                    return this.handleListSessions(params);
+                case 'session/load':
+                    return this.handleLoadSession(params);
+                case 'session/prompt':
+                    return this.handlePrompt(params);
+                default: {
+                    const error = new Error(`Method not found: ${method}`);
+                    error.code = -32601;
+                    throw error;
+                }
             }
+        };
+        if (method.startsWith('session/') && !this.storeLoaded) {
+            const p = this.ensureStoreLoaded();
+            if (p)
+                return p.then(run);
         }
+        return run();
     }
     handleInitialize(params) {
         if (params.protocolVersion !== this.protocolVersion) {
@@ -275,8 +323,10 @@ export class AcpStdioServer {
             cwd,
             active: null,
             history: [],
+            mcpServers: params.mcpServers,
             updatedAt: new Date().toISOString(),
         });
+        void this.persistSession(sessionId);
         return { sessionId };
     }
     handleListSessions(params) {
@@ -317,7 +367,10 @@ export class AcpStdioServer {
         const cwd = optionalStringParam(params, 'cwd', 'Invalid session/load cwd');
         if (cwd)
             session.cwd = cwd;
+        if ('mcpServers' in params)
+            session.mcpServers = params.mcpServers;
         session.updatedAt = new Date().toISOString();
+        void this.persistSession(sessionId);
         for (const update of session.history) {
             this.sendUpdate(sessionId, update, { record: false });
         }
@@ -349,6 +402,7 @@ export class AcpStdioServer {
                 sessionId,
                 cwd: session.cwd,
                 clientCapabilities,
+                mcpServers: session.mcpServers,
                 canRequestClient: (method) => canRequestClientWithCapabilities(method, clientCapabilities),
                 prompt,
                 signal: controller.signal,
@@ -359,6 +413,7 @@ export class AcpStdioServer {
                 sendUpdate: (update) => this.sendUpdate(sessionId, update),
             });
             session.updatedAt = new Date().toISOString();
+            void this.persistSession(sessionId);
             return { stopReason: controller.signal.aborted ? 'cancelled' : stopReason };
         }
         catch (err) {

package/dist/providers/active-llm-registry.d.ts

@@ -0,0 +1,37 @@
+import { type RuntimeFallbackProvider } from './provider-fallback.js';
+export type FailoverOrderPolicy = 'resilience' | 'free-first' | 'manual';
+export interface ActiveLlm extends RuntimeFallbackProvider {
+    /** Local runtime (Ollama / LM Studio) — pushed last under the resilience policy. */
+    isLocal: boolean;
+    /** Best-effort: cloud-keyed/OAuth providers are assumed reachable; the reactive
+     * failover loop is the final arbiter, so this is advisory only. */
+    reachable: boolean;
+    /** Catalog priority (lower = preferred). */
+    priority: number;
+    /** Rough $/Mtok input cost for free-first ordering + the `/llm list` display. */
+    costInputUsdPerMtok: number;
+}
+export interface ActiveLlmRegistry {
+    /** Canonical id of the detected primary (never appears in `fallbacks`). */
+    primaryProvider: string | null;
+    /** Other active LLMs, ordered by policy — ready for `fallbackProviders`. */
+    fallbacks: ActiveLlm[];
+    /** Primary + fallbacks, for the `/llm list` surface. */
+    all: ActiveLlm[];
+}
+export interface BuildActiveLlmRegistryOptions {
+    /** The already-resolved session primary (from the index.ts bootstrap). */
+    primary?: {
+        provider?: string;
+        apiKey?: string;
+        baseURL?: string;
+        model?: string;
+    };
+    policy?: FailoverOrderPolicy;
+    manualOrder?: string[];
+    localOnly?: boolean;
+    env?: Record<string, string | undefined>;
+    force?: boolean;
+}
+export declare function orderFallbacks(list: ActiveLlm[], policy: FailoverOrderPolicy, manualOrder?: string[]): ActiveLlm[];
+export declare function buildActiveLlmRegistry(opts?: BuildActiveLlmRegistryOptions): Promise<ActiveLlmRegistry>;

package/dist/providers/active-llm-registry.js

@@ -0,0 +1,186 @@
+/**
+ * Active-LLM registry — the set of providers/models the user is actually
+ * authenticated to (and that are reachable), used to drive auto-failover and
+ * "together" (ensemble) execution.
+ *
+ * This does NOT add new failover logic: it produces a `RuntimeFallbackProvider[]`
+ * that drops straight into `CodeBuddyClient`'s existing `fallbackProviders` slot
+ * (see `src/codebuddy/client.ts` `chatWithProviderFallback`). It joins existing
+ * resolvers — the provider catalog (`resolveProviderFromCatalog`), the ChatGPT /
+ * xAI OAuth credential checks, and the env-configured fallback list — rather than
+ * reinventing detection. The primary provider is passed in by the caller (the
+ * session bootstrap already resolved it) to avoid a circular import on
+ * `getDetectedProvider` in `src/index.ts`.
+ */
+import { getDirectRuntimeProviderCatalog, findRuntimeProvider, resolveProviderFromCatalog, } from './provider-catalog.js';
+import { resolveRuntimeFallbackProviders, } from './provider-fallback.js';
+import { hasCodexCredentials } from './codex-oauth.js';
+import { logger } from '../utils/logger.js';
+/** Rough input $/Mtok for ordering + display. 0 for local runtimes and
+ * subscription-OAuth backends (no per-token metering). */
+const APPROX_COST_USD_PER_MTOK = {
+    chatgpt: 0,
+    ollama: 0,
+    lmstudio: 0,
+    'gemini-cli': 0,
+    grok: 0.5,
+    gemini: 0.3,
+    groq: 0.3,
+    mistral: 1,
+    anthropic: 3,
+    openai: 5,
+};
+function canonicalProviderId(provider) {
+    if (!provider)
+        return undefined;
+    return findRuntimeProvider(provider)?.id ?? provider.trim().toLowerCase();
+}
+/** Local runtimes that actually responded to a probe → their first real
+ * installed model (reuses the fleet capability registry's Ollama/LM Studio
+ * HTTP probes; `probeOllama` sets `id` to the actual model name). */
+async function getReachableLocalModels(force) {
+    const map = new Map();
+    try {
+        const { getLocalCapabilities } = await import('../fleet/capability-registry.js');
+        const caps = await getLocalCapabilities({ force });
+        for (const m of caps.models) {
+            const id = canonicalProviderId(m.provider);
+            if ((id === 'ollama' || id === 'lmstudio') && !map.has(id)) {
+                map.set(id, m.id);
+            }
+        }
+    }
+    catch {
+        /* no local runtimes reachable */
+    }
+    return map;
+}
+/** Resolve the xAI subscription-login bearer when there's no GROK_API_KEY,
+ * mirroring `getDetectedProvider` in src/index.ts. */
+async function resolveXaiOAuthProvider(entry, env) {
+    try {
+        const { hasXaiCredentials, getValidXaiAccessToken } = await import('./xai-oauth.js');
+        if (!hasXaiCredentials())
+            return null;
+        const token = await getValidXaiAccessToken();
+        if (!token)
+            return null;
+        return {
+            provider: 'grok',
+            label: entry.label,
+            apiMode: entry.apiMode,
+            authMode: entry.authMode,
+            apiKey: token,
+            baseURL: 'https://api.x.ai/v1',
+            defaultModel: env.GROK_MODEL || 'grok-4-latest',
+            source: 'override',
+        };
+    }
+    catch (err) {
+        logger.debug('xAI OAuth resolution skipped in active-llm-registry', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+}
+function toActiveLlm(resolved, entry) {
+    const isLocal = (entry?.authMode ?? resolved.authMode) === 'local';
+    return {
+        ...resolved,
+        model: resolved.defaultModel,
+        rawSpec: `active:${resolved.provider}`,
+        fallbackSource: 'environment',
+        isLocal,
+        reachable: true,
+        priority: entry?.priority ?? 500,
+        costInputUsdPerMtok: APPROX_COST_USD_PER_MTOK[resolved.provider] ?? 1,
+    };
+}
+export function orderFallbacks(list, policy, manualOrder) {
+    const sorted = [...list];
+    if (policy === 'free-first') {
+        sorted.sort((a, b) => a.costInputUsdPerMtok - b.costInputUsdPerMtok || a.priority - b.priority);
+    }
+    else if (policy === 'manual' && manualOrder && manualOrder.length > 0) {
+        const rank = (p) => {
+            const i = manualOrder.findIndex((m) => canonicalProviderId(m) === canonicalProviderId(p.provider));
+            return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+        };
+        sorted.sort((a, b) => rank(a) - rank(b));
+    }
+    else {
+        // resilience (default): capable cloud/subscription first (by catalog
+        // priority), local runtimes LAST as a free safety net.
+        sorted.sort((a, b) => Number(a.isLocal) - Number(b.isLocal) || a.priority - b.priority);
+    }
+    return sorted;
+}
+export async function buildActiveLlmRegistry(opts = {}) {
+    const env = opts.env ?? process.env;
+    const policy = opts.policy ?? 'resilience';
+    const hasOAuth = hasCodexCredentials();
+    const primaryProvider = canonicalProviderId(opts.primary?.provider) ?? null;
+    const catalog = getDirectRuntimeProviderCatalog();
+    const reachableLocalModels = await getReachableLocalModels(opts.force);
+    const all = [];
+    const seen = new Set();
+    for (const entry of catalog) {
+        let resolved = resolveProviderFromCatalog({
+            providerOverride: entry.id,
+            env,
+            hasChatGptOAuth: hasOAuth,
+            requireConfigured: true,
+        });
+        // xAI subscription login (no GROK_API_KEY) — the catalog can't see the
+        // OAuth token, so resolve it directly.
+        if (!resolved && entry.id === 'grok') {
+            resolved = await resolveXaiOAuthProvider(entry, env);
+        }
+        if (!resolved)
+            continue;
+        const isLocal = (entry.authMode ?? resolved.authMode) === 'local';
+        if (opts.localOnly && !isLocal)
+            continue;
+        // The catalog reports a local provider as "configured" even when it isn't
+        // running — only keep locals we actually probed as reachable, and use their
+        // real installed model (not the catalog default, which may not be pulled).
+        if (isLocal) {
+            const realModel = reachableLocalModels.get(canonicalProviderId(resolved.provider) ?? '');
+            if (!realModel)
+                continue;
+            resolved = { ...resolved, defaultModel: realModel };
+        }
+        const key = `${canonicalProviderId(resolved.provider)}:${resolved.baseURL.replace(/\/+$/, '')}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        all.push(toActiveLlm(resolved, entry));
+    }
+    // Fallbacks = active set minus the primary provider.
+    const fallbacks = all.filter((p) => canonicalProviderId(p.provider) !== primaryProvider);
+    // Preserve any explicit env-configured fallbacks (CODEBUDDY_FALLBACK_PROVIDERS)
+    // — concat + dedupe so setting the env var never regresses.
+    for (const f of resolveRuntimeFallbackProviders({
+        env,
+        hasChatGptOAuth: hasOAuth,
+        active: opts.primary,
+    })) {
+        const key = `${canonicalProviderId(f.provider)}:${f.baseURL.replace(/\/+$/, '')}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        fallbacks.push({
+            ...f,
+            isLocal: false,
+            reachable: true,
+            priority: 900,
+            costInputUsdPerMtok: APPROX_COST_USD_PER_MTOK[f.provider] ?? 1,
+        });
+    }
+    return {
+        primaryProvider,
+        fallbacks: orderFallbacks(fallbacks, policy, opts.manualOrder),
+        all,
+    };
+}
+//# sourceMappingURL=active-llm-registry.js.map

package/dist/providers/auxiliary-provider.d.ts

@@ -0,0 +1,25 @@
+import { CodeBuddyClient, type ChatOptions } from '../codebuddy/client.js';
+import { type ResolvedRuntimeProvider } from './provider-catalog.js';
+type EnvLike = Record<string, string | undefined>;
+export type RuntimeAuxiliaryTask = 'vision' | 'browser_vision' | 'web_extract' | 'approval' | 'compression' | 'skills_hub' | 'mcp' | 'triage_specifier' | 'session_title';
+export interface RuntimeAuxiliaryMainProvider extends ResolvedRuntimeProvider {
+    model?: string;
+}
+export interface RuntimeAuxiliaryResolveOptions {
+    task: RuntimeAuxiliaryTask;
+    env?: EnvLike;
+    hasChatGptOAuth?: boolean;
+    mainProvider?: RuntimeAuxiliaryMainProvider | null;
+    defaultTimeoutMs?: number;
+}
+export interface ResolvedRuntimeAuxiliaryProvider extends ResolvedRuntimeProvider {
+    task: RuntimeAuxiliaryTask;
+    model: string;
+    timeoutMs: number;
+    providerSetting: string;
+    extraBody?: Record<string, unknown>;
+}
+export declare function resolveRuntimeAuxiliaryProvider(options: RuntimeAuxiliaryResolveOptions): ResolvedRuntimeAuxiliaryProvider | null;
+export declare function createAuxiliaryCodeBuddyClient(provider: ResolvedRuntimeAuxiliaryProvider): CodeBuddyClient;
+export declare function createAuxiliaryChatOptions(provider: ResolvedRuntimeAuxiliaryProvider, overrides?: ChatOptions): ChatOptions;
+export {};

package/dist/providers/auxiliary-provider.js

@@ -0,0 +1,192 @@
+import { CodeBuddyClient, } from '../codebuddy/client.js';
+import { hasCodexCredentials } from './codex-oauth.js';
+import { findRuntimeProvider, resolveProviderFromCatalog, } from './provider-catalog.js';
+const DEFAULT_AUXILIARY_TIMEOUT_MS = {
+    vision: 120_000,
+    browser_vision: 120_000,
+    web_extract: 360_000,
+    approval: 30_000,
+    compression: 120_000,
+    skills_hub: 30_000,
+    mcp: 30_000,
+    triage_specifier: 120_000,
+    session_title: 30_000,
+};
+const OPENROUTER_VISION_MODEL = 'google/gemini-2.5-flash';
+export function resolveRuntimeAuxiliaryProvider(options) {
+    const env = options.env ?? process.env;
+    const config = readAuxiliaryEnvConfig(options.task, env);
+    const providerSetting = (config.provider || 'auto').trim().toLowerCase();
+    const timeoutMs = config.timeoutMs ?? options.defaultTimeoutMs ?? DEFAULT_AUXILIARY_TIMEOUT_MS[options.task];
+    const hasOAuth = options.hasChatGptOAuth ?? hasCodexCredentials();
+    if (providerSetting === 'main') {
+        return resolveFromMainProvider(options, config, timeoutMs, providerSetting);
+    }
+    if (providerSetting === 'auto') {
+        const autoResolved = resolveAutoAuxiliaryProvider(options, config, timeoutMs, hasOAuth);
+        if (autoResolved)
+            return autoResolved;
+        return resolveFromMainProvider(options, config, timeoutMs, providerSetting);
+    }
+    return resolveSpecificAuxiliaryProvider(options.task, providerSetting, env, config, timeoutMs, hasOAuth);
+}
+export function createAuxiliaryCodeBuddyClient(provider) {
+    return new CodeBuddyClient(provider.apiKey, provider.model, provider.baseURL, {
+        enableFallbacks: false,
+    });
+}
+export function createAuxiliaryChatOptions(provider, overrides = {}) {
+    return {
+        ...overrides,
+        model: overrides.model ?? provider.model,
+        timeoutMs: overrides.timeoutMs ?? provider.timeoutMs,
+    };
+}
+function resolveAutoAuxiliaryProvider(options, config, timeoutMs, hasOAuth) {
+    if ((options.task === 'vision' || options.task === 'browser_vision') && hasEnvValue(options.env ?? process.env, 'OPENROUTER_API_KEY')) {
+        return resolveSpecificAuxiliaryProvider(options.task, 'openrouter', options.env ?? process.env, {
+            ...config,
+            model: config.model || OPENROUTER_VISION_MODEL,
+        }, timeoutMs, hasOAuth);
+    }
+    if (options.mainProvider) {
+        return resolveFromMainProvider(options, config, timeoutMs, 'auto');
+    }
+    const resolved = resolveProviderFromCatalog({
+        env: options.env,
+        hasChatGptOAuth: hasOAuth,
+        requireConfigured: true,
+    });
+    if (!resolved)
+        return null;
+    return finalizeAuxiliaryProvider(options.task, resolved, config, timeoutMs, 'auto');
+}
+function resolveFromMainProvider(options, config, timeoutMs, providerSetting) {
+    const mainProvider = options.mainProvider;
+    if (!mainProvider)
+        return null;
+    return finalizeAuxiliaryProvider(options.task, mainProvider, config, timeoutMs, providerSetting);
+}
+function resolveSpecificAuxiliaryProvider(task, providerSetting, env, config, timeoutMs, hasOAuth) {
+    const entry = findRuntimeProvider(providerSetting);
+    if (!entry || entry.runtimeSupport !== 'direct')
+        return null;
+    const envOverlay = { ...env };
+    if (config.apiKey && entry.apiKeyEnvKeys[0]) {
+        envOverlay[entry.apiKeyEnvKeys[0]] = config.apiKey;
+    }
+    if (config.baseURL && entry.baseUrlEnvKeys[0]) {
+        envOverlay[entry.baseUrlEnvKeys[0]] = config.baseURL;
+    }
+    if (config.model && entry.modelEnvKeys[0]) {
+        envOverlay[entry.modelEnvKeys[0]] = config.model;
+    }
+    const resolved = resolveProviderFromCatalog({
+        providerOverride: providerSetting,
+        env: envOverlay,
+        hasChatGptOAuth: hasOAuth,
+        requireConfigured: true,
+    });
+    if (!resolved)
+        return null;
+    return finalizeAuxiliaryProvider(task, resolved, config, timeoutMs, providerSetting);
+}
+function finalizeAuxiliaryProvider(task, provider, config, timeoutMs, providerSetting) {
+    return {
+        ...provider,
+        apiKey: config.apiKey || provider.apiKey,
+        baseURL: (config.baseURL || provider.baseURL).replace(/\/+$/, ''),
+        defaultModel: config.model || provider.model || provider.defaultModel,
+        task,
+        model: config.model || provider.model || provider.defaultModel,
+        timeoutMs,
+        providerSetting,
+        ...(config.extraBody ? { extraBody: config.extraBody } : {}),
+    };
+}
+function readAuxiliaryEnvConfig(task, env) {
+    const taskKey = task.toUpperCase();
+    const provider = readFirstEnv(env, [
+        `CODEBUDDY_AUXILIARY_${taskKey}_PROVIDER`,
+        `AUXILIARY_${taskKey}_PROVIDER`,
+        'CODEBUDDY_AUXILIARY_PROVIDER',
+        'AUXILIARY_PROVIDER',
+    ]);
+    const model = readFirstEnv(env, [
+        `CODEBUDDY_AUXILIARY_${taskKey}_MODEL`,
+        `AUXILIARY_${taskKey}_MODEL`,
+        'CODEBUDDY_AUXILIARY_MODEL',
+        'AUXILIARY_MODEL',
+    ]);
+    const baseURL = readFirstEnv(env, [
+        `CODEBUDDY_AUXILIARY_${taskKey}_BASE_URL`,
+        `AUXILIARY_${taskKey}_BASE_URL`,
+        'CODEBUDDY_AUXILIARY_BASE_URL',
+        'AUXILIARY_BASE_URL',
+    ]);
+    const apiKey = readFirstEnv(env, [
+        `CODEBUDDY_AUXILIARY_${taskKey}_API_KEY`,
+        `AUXILIARY_${taskKey}_API_KEY`,
+        'CODEBUDDY_AUXILIARY_API_KEY',
+        'AUXILIARY_API_KEY',
+    ]);
+    const timeoutEntry = readFirstEnvEntry(env, [
+        `CODEBUDDY_AUXILIARY_${taskKey}_TIMEOUT_MS`,
+        `AUXILIARY_${taskKey}_TIMEOUT_MS`,
+        `AUXILIARY_${taskKey}_TIMEOUT`,
+        'CODEBUDDY_AUXILIARY_TIMEOUT_MS',
+        'AUXILIARY_TIMEOUT_MS',
+    ]);
+    const extraBodyRaw = readFirstEnv(env, [
+        `CODEBUDDY_AUXILIARY_${taskKey}_EXTRA_BODY`,
+        `AUXILIARY_${taskKey}_EXTRA_BODY`,
+        'CODEBUDDY_AUXILIARY_EXTRA_BODY',
+        'AUXILIARY_EXTRA_BODY',
+    ]);
+    return {
+        ...(provider ? { provider } : {}),
+        ...(model ? { model } : {}),
+        ...(baseURL ? { baseURL } : {}),
+        ...(apiKey ? { apiKey } : {}),
+        ...(timeoutEntry ? { timeoutMs: parseTimeoutMs(timeoutEntry.value, timeoutEntry.key.endsWith('_TIMEOUT')) } : {}),
+        ...(extraBodyRaw ? { extraBody: parseExtraBody(extraBodyRaw) } : {}),
+    };
+}
+function readFirstEnv(env, keys) {
+    for (const key of keys) {
+        const value = env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readFirstEnvEntry(env, keys) {
+    for (const key of keys) {
+        const value = env[key]?.trim();
+        if (value)
+            return { key, value };
+    }
+    return undefined;
+}
+function hasEnvValue(env, key) {
+    return readFirstEnv(env, [key]) !== undefined;
+}
+function parseTimeoutMs(value, seconds) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return undefined;
+    return Math.round(seconds ? numeric * 1000 : numeric);
+}
+function parseExtraBody(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+//# sourceMappingURL=auxiliary-provider.js.map

package/dist/providers/codex-oauth.d.ts

@@ -109,7 +109,7 @@ declare function bindCallbackServer(ports: number[], handler: http.RequestListen
  * Returns the parsed `ChatGptAuth` so callers can show the user their
  * email/plan immediately. Throws on failure / timeout (5 minutes).
  */
-export declare function loginInteractive(): Promise<ChatGptAuth>;
+export declare function loginInteractive(openUrl?: (url: string) => void | Promise<void>): Promise<ChatGptAuth>;
 /**
  * Returns the current ChatGptAuth (with claims), refreshing the access
  * token if `last_refresh` is older than 1 hour. Returns `null` when no

package/dist/providers/codex-oauth.js

@@ -35,6 +35,9 @@ import { logger } from '../utils/logger.js';
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 /** OAuth issuer — both authorize and token endpoints live under here. */
 const ISSUER = 'https://auth.openai.com';
+/** Hard ceiling on the token exchange/refresh fetches so a stalled IdP can't
+ *  hang an inline refresh (runs on the first chat call when tokens are stale). */
+const OAUTH_TOKEN_TIMEOUT_MS = 30_000;
 /** Primary callback port. Must match OpenAI's allow-list of registered
  *  redirect URIs for the Codex CLI client_id. */
 const CALLBACK_PORT = 1455;
@@ -189,6 +192,8 @@ async function exchangeCodeForTokens(code, codeVerifier, redirectUri) {
         method: 'POST',
         headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
         body: params.toString(),
+        // Bound the network await so a stalled IdP can't hang the caller indefinitely.
+        signal: AbortSignal.timeout(OAUTH_TOKEN_TIMEOUT_MS),
     });
     if (!response.ok) {
         const body = await response.text().catch(() => '');
@@ -208,6 +213,9 @@ async function refreshTokens(refreshToken) {
             refresh_token: refreshToken,
             client_id: CLIENT_ID,
         }),
+        // A stale-token refresh runs inline on the first chat call; bound it so a
+        // stalled IdP surfaces as a timeout error instead of an indefinite hang.
+        signal: AbortSignal.timeout(OAUTH_TOKEN_TIMEOUT_MS),
     });
     if (!response.ok) {
         const body = await response.text().catch(() => '');
@@ -344,7 +352,7 @@ async function bindCallbackServer(ports, handler) {
  * Returns the parsed `ChatGptAuth` so callers can show the user their
  * email/plan immediately. Throws on failure / timeout (5 minutes).
  */
-export async function loginInteractive() {
+export function loginInteractive(openUrl) {
     const pkce = generatePkce();
     const state = randomState();
     return new Promise((resolve, reject) => {
@@ -433,9 +441,24 @@ export async function loginInteractive() {
             }, 5 * 60 * 1000);
             // Open the browser. If it fails, log the URL so the user can
             // copy-paste manually.
-            open(authUrl).catch(() => {
-                console.error(`Couldn't auto-open the browser. Open this URL manually:\n${authUrl}`);
-            });
+            if (openUrl) {
+                try {
+                    const res = openUrl(authUrl);
+                    if (res instanceof Promise) {
+                        res.catch(() => {
+                            console.error(`Couldn't auto-open the browser. Open this URL manually:\n${authUrl}`);
+                        });
+                    }
+                }
+                catch {
+                    console.error(`Couldn't auto-open the browser. Open this URL manually:\n${authUrl}`);
+                }
+            }
+            else {
+                open(authUrl).catch(() => {
+                    console.error(`Couldn't auto-open the browser. Open this URL manually:\n${authUrl}`);
+                });
+            }
         })
             .catch(reject);
     });

package/dist/providers/index.d.ts

@@ -16,6 +16,9 @@ export { ProviderManager, getProviderManager, resetProviderManager, autoConfigur
 export * from './local-llm-provider.js';
 export { ADDITIONAL_PROVIDERS, getAdditionalProvider, getProviderForModel, listAvailableProviders, listAllProviders, resolveProviderConfig, } from './additional-providers.js';
 export type { ProviderConfig as AdditionalProviderConfig } from './additional-providers.js';
+export * from './provider-catalog.js';
+export * from './provider-fallback.js';
+export * from './auxiliary-provider.js';
 export { ProviderFallbackChain, getFallbackChain, resetFallbackChain, } from './fallback-chain.js';
 export type { FallbackConfig, ProviderHealth, FallbackChainEvents, } from './fallback-chain.js';
 export { SmartModelRouter, getSmartRouter, resetSmartRouter, } from './smart-router.js';