evolcore 0.0.25 → 0.0.27

package/dist/agents/baseagent-availability.js

@@ -1,3 +1,4 @@
+import { normalizeBaseagent } from './baseagent.js';
 import { commandExists } from '../utils/cross-platform.js';
 import { getCodexAppServerAvailability } from './codex-runner.js';
 export const BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini', 'ecagent'];
@@ -46,3 +47,70 @@ export function detectBaseagentDetails(codexAvailability = getCodexAppServerAvai
         },
     ];
 }
+/** Only loaded runners can be switched to; never infer this from PATH/config. */
+export function loadedBaseagentIds(keys, owner) {
+    const result = new Set();
+    for (const key of keys) {
+        if (owner !== undefined && !key.startsWith(`${owner}::`))
+            continue;
+        const separator = key.indexOf('::');
+        result.add(separator < 0 ? key : key.slice(separator + 2));
+    }
+    return [...result];
+}
+function canonical(value) {
+    if (typeof value !== 'string')
+        return null;
+    const id = normalizeBaseagent(value).canonical;
+    return id === 'unknown' ? null : id;
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+/** Safe public projection: credentials and arbitrary backend settings never leave this boundary. */
+export function buildBaseagentSnapshot(config, detections, loaded) {
+    const blocks = new Map();
+    for (const [name, value] of Object.entries(record(config.baseagents))) {
+        const id = canonical(name);
+        if (id)
+            blocks.set(id, record(value));
+    }
+    const active = canonical(config.active_baseagent);
+    const probes = new Map((detections ?? []).map(item => [String(item.id), item]));
+    const loadedIds = loaded === undefined ? null : new Set(loaded);
+    const ids = new Set([
+        ...blocks.keys(),
+        ...(detections ?? []).filter(item => item.detected).map(item => item.id),
+        ...(loaded ?? []),
+        ...(active ? [active] : []),
+    ]);
+    return {
+        active,
+        baseagents: [...ids].map(id => ({
+            id,
+            label: normalizeBaseagent(id).displayName,
+            configured: blocks.has(id),
+            detected: detections === null ? null : probes.get(id)?.detected === true,
+            loaded: loadedIds?.has(id) ?? null,
+            active: id === active,
+            model: text(blocks.get(id)?.model),
+            effort: text(blocks.get(id)?.effort ?? blocks.get(id)?.reasoning),
+            version: probes.get(id)?.version ?? null,
+        })),
+    };
+}
+/** Shared defaults/Agent inventory for menu, slash and local history readers. */
+export async function getBaseagentSnapshot(options = {}) {
+    let config = options.config;
+    if (config === undefined) {
+        const { read, ConfigTarget } = await import('../config/config-manager.js');
+        config = read(ConfigTarget.Defaults, undefined, { cache: false, expand: false }) ?? {};
+    }
+    const detections = options.probe === false
+        ? null
+        : (await import('./baseagent-availability.js')).detectBaseagentDetails();
+    return buildBaseagentSnapshot(config ?? {}, detections, options.loaded);
+}

package/dist/agents/baseagent.js

@@ -14,6 +14,7 @@ import path from 'path';
 import os from 'os';
 import { commandExists, isWindows, resolveProbePath } from '../utils/cross-platform.js';
 import { execFileSync } from 'child_process';
+import { parse as parseToml } from 'smol-toml';
 /** Resolve the installed Codex CLI entrypoint, including npm shims on Windows. */
 export function resolveCodexCliPath() {
     return resolveProbePath('codex');
@@ -185,55 +186,74 @@ export function resolveAnthropicConfig(config, override) {
         || pickExec(config.agents?.claude?.pathToClaudeCodeExecutable);
     return { apiKey, baseUrl, headers, queryParams, model, effort, pathToClaudeCodeExecutable };
 }
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 export function loadCodexSettings() {
+    const configuredHome = process.env.CODEX_HOME?.trim();
+    const codexHome = configuredHome ? path.resolve(configuredHome) : path.join(os.homedir(), '.codex');
+    const authPath = path.join(codexHome, 'auth.json');
+    const configPath = path.join(codexHome, 'config.toml');
+    let authJsonApiKey;
     try {
-        const configuredHome = process.env.CODEX_HOME?.trim();
-        const codexHome = configuredHome ? path.resolve(configuredHome) : path.join(os.homedir(), '.codex');
-        const authPath = path.join(codexHome, 'auth.json');
-        let apiKey;
         if (fs.existsSync(authPath)) {
             const auth = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
-            apiKey = auth.OPENAI_API_KEY;
+            authJsonApiKey = nonEmptyString(auth?.OPENAI_API_KEY);
         }
-        const configPath = path.join(codexHome, 'config.toml');
-        let model;
-        let baseUrl;
-        let provider;
+    }
+    catch {
+        // A corrupt auth.json must not prevent the provider config from loading.
+    }
+    let model;
+    let baseUrl;
+    let provider;
+    let bearerToken;
+    let requiresOpenaiAuth;
+    try {
         if (fs.existsSync(configPath)) {
-            const content = fs.readFileSync(configPath, 'utf-8');
-            const modelMatch = content.match(/^model\s*=\s*"([^"]+)"/m);
-            if (modelMatch)
-                model = modelMatch[1];
-            const providerMatch = content.match(/^model_provider\s*=\s*"([^"]+)"/m);
-            if (providerMatch) {
-                provider = providerMatch[1];
-                baseUrl = readCodexProviderBaseUrl(content, provider);
-            }
+            const parsed = recordValue(parseToml(fs.readFileSync(configPath, 'utf-8')));
+            model = nonEmptyString(parsed?.model);
+            provider = nonEmptyString(parsed?.model_provider);
+            const providers = recordValue(parsed?.model_providers);
+            const selectedProvider = provider ? recordValue(providers?.[provider]) : undefined;
+            baseUrl = nonEmptyString(selectedProvider?.base_url);
+            bearerToken = nonEmptyString(selectedProvider?.experimental_bearer_token);
+            requiresOpenaiAuth = typeof selectedProvider?.requires_openai_auth === 'boolean'
+                ? selectedProvider.requires_openai_auth
+                : undefined;
         }
-        return { apiKey, baseUrl, model, provider };
     }
     catch { }
-    return {};
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function readCodexProviderBaseUrl(content, provider) {
-    const segments = /^[A-Za-z0-9_-]+$/.test(provider)
-        ? [provider, JSON.stringify(provider)]
-        : [JSON.stringify(provider)];
-    for (const segment of segments) {
-        const section = new RegExp(`^\\s*\\[\\s*model_providers\\s*\\.\\s*${escapeRegExp(segment)}\\s*\\]\\s*(?:#.*)?$`, 'm').exec(content);
-        if (!section || section.index === undefined)
-            continue;
-        const tail = content.slice(section.index + section[0].length);
-        const nextSection = tail.search(/^\s*\[/m);
-        const block = nextSection >= 0 ? tail.slice(0, nextSection) : tail;
-        const baseUrl = block.match(/^\s*base_url\s*=\s*"([^"]+)"/m)?.[1];
-        if (baseUrl)
-            return baseUrl;
+    // Codex applies a provider's explicit bearer token before auth.json. Keep
+    // that precedence so EvolCore and the app-server select the same identity.
+    if (bearerToken) {
+        return {
+            apiKey: bearerToken,
+            authType: 'bearerToken',
+            authSource: 'config.toml',
+            baseUrl,
+            model,
+            provider,
+            requiresOpenaiAuth,
+        };
     }
-    return undefined;
+    if (authJsonApiKey) {
+        return {
+            apiKey: authJsonApiKey,
+            authType: 'apiKey',
+            authSource: 'auth.json',
+            baseUrl,
+            model,
+            provider,
+            requiresOpenaiAuth,
+        };
+    }
+    return { baseUrl, model, provider, requiresOpenaiAuth };
 }
 /**
  * Resolve a complete credential/endpoint pair for direct OpenAI HTTP calls.
@@ -248,14 +268,23 @@ export function resolveOpenaiDirectConfig(override) {
             ...normalizeRequestMetadata(override),
         };
     }
-    const environment = directInferencePair(process.env.OPENAI_API_KEY, process.env.OPENAI_BASE_URL);
+    const settings = loadCodexSettings();
+    const configuredBearer = settings.authType === 'bearerToken'
+        ? directInferencePair(settings.apiKey, settings.baseUrl)
+        : undefined;
+    if (configuredBearer) {
+        return {
+            ...configuredBearer,
+            ...normalizeRequestMetadata(override),
+        };
+    }
+    const environment = directInferencePair(process.env.OPENAI_API_KEY || process.env.CODEX_API_KEY, process.env.OPENAI_BASE_URL);
     if (environment) {
         return {
             ...environment,
             ...normalizeRequestMetadata(override),
         };
     }
-    const settings = loadCodexSettings();
     const settingsResolved = directInferencePair(settings.apiKey, settings.baseUrl);
     return settingsResolved
         ? {
@@ -269,12 +298,31 @@ export function resolveOpenaiConfig(config, override, runtime) {
     const isPlaceholder = (v) => !v || v.includes('your-') || v.includes('placeholder');
     const overrideApiKey = isPlaceholder(override?.apiKey) ? undefined : override?.apiKey;
     const globalApiKey = isPlaceholder(config.agents?.codex?.apiKey) ? undefined : config.agents?.codex?.apiKey;
-    const apiKey = overrideApiKey
-        || globalApiKey
-        || process.env.OPENAI_API_KEY
-        || codexSettings.apiKey;
+    const environmentApiKey = [process.env.OPENAI_API_KEY, process.env.CODEX_API_KEY]
+        .map(value => isPlaceholder(value) ? undefined : value)
+        .find((value) => !!value);
+    const configuredBearer = codexSettings.authType === 'bearerToken' ? codexSettings.apiKey : undefined;
+    const storedApiKey = codexSettings.authType === 'apiKey' ? codexSettings.apiKey : undefined;
+    // A selected provider's explicit token is authoritative for that provider.
+    // OPENAI_API_KEY is not used by Codex when the provider declares its own
+    // bearer token, so choosing it here would make EvolCore and app-server use
+    // different credentials.
+    const credential = overrideApiKey
+        ? { apiKey: overrideApiKey, authType: 'apiKey', authSource: 'agent-config' }
+        : globalApiKey
+            ? { apiKey: globalApiKey, authType: 'apiKey', authSource: 'agent-config' }
+            : configuredBearer
+                ? { apiKey: configuredBearer, authType: 'bearerToken', authSource: 'config.toml' }
+                : environmentApiKey
+                    ? { apiKey: environmentApiKey, authType: 'apiKey', authSource: 'environment' }
+                    : storedApiKey
+                        ? { apiKey: storedApiKey, authType: 'apiKey', authSource: 'auth.json' }
+                        : undefined;
+    const apiKey = credential?.apiKey;
+    const authType = credential?.authType;
+    const authSource = credential?.authSource;
     if (!apiKey) {
-        throw new Error('No OpenAI API key found. Set one of: baseagents.codex.apiKey (per-agent or defaults), env OPENAI_API_KEY, or ~/.codex/auth.json');
+        throw new Error('No Codex credential found. Set baseagents.codex.apiKey, env OPENAI_API_KEY/CODEX_API_KEY, ~/.codex/auth.json, or a provider experimental_bearer_token in ~/.codex/config.toml');
     }
     const isPlaceholderUrl = (v) => !v || v.includes('api.openai.com');
     const overrideBaseUrl = isPlaceholderUrl(override?.baseUrl) ? undefined : override?.baseUrl;
@@ -303,6 +351,8 @@ export function resolveOpenaiConfig(config, override, runtime) {
         ?? undefined;
     return {
         apiKey,
+        authType,
+        authSource,
         baseUrl,
         provider: codexSettings.provider,
         headers,