evolcore 0.0.25 → 0.0.26

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,

package/dist/agents/claude-runner.js

@@ -25,12 +25,13 @@ import { sanitizeSessionTitle } from '../core/session/session-title.js';
 import { resolveClaudeCapabilityRunOptionsForProject } from '../core/capability/capability-manager.js';
 import { normalizeExecutionPermissionMode, normalizePermissionMode, resolvePhaseOneExecutionSandbox } from '../core/permission/mode.js';
 import { buildClaudeProtectedFilesystem, containsHClassReference, containsLClassReference, isHClassPath, isLClassPath, isSameOrDescendant, resolveProtectedCandidate, } from '../core/permission/protected-paths.js';
-import { buildHClassGuardCommand, collectSandboxGuardDiagnostics, createSandboxInitializationError, getActiveSandboxInitializationFailure, isSandboxInitializationFailure, recordSandboxInitializationFailure, SANDBOX_INITIALIZATION_COOLDOWN_MS, SANDBOX_INITIALIZATION_FAILED, ensureClaudeGitWorktreeConfig, prependExecutableDirectory, resolveBubblewrapPath, summarizeBubblewrapArgsForLog, summarizeSandboxGuardDiagnostics, shouldFailIfClaudeSandboxUnavailable, shouldLogSandboxCircuitNotice, } from '../core/permission/sandbox-runtime.js';
+import { buildHClassGuardCommand, collectSandboxGuardDiagnostics, createSandboxInitializationError, getActiveSandboxInitializationFailure, isSandboxInitializationFailure, isSandboxInitializationToolResult, recordSandboxInitializationFailure, SANDBOX_INITIALIZATION_COOLDOWN_MS, SANDBOX_INITIALIZATION_FAILED, ensureClaudeGitWorktreeConfig, prependExecutableDirectory, resolveBubblewrapPath, summarizeBubblewrapArgsForLog, summarizeSandboxGuardDiagnostics, shouldFailIfClaudeSandboxUnavailable, shouldLogSandboxCircuitNotice, } from '../core/permission/sandbox-runtime.js';
 import { buildClaudeUnixSocketAllowlist } from '../core/permission/unix-socket-policy.js';
 import { auditToolInfrastructureFailure, auditToolPreflightDenial } from '../core/auth/authorization-audit.js';
 import { getManagedTaskTempDir, isManagedSessionRuntimeDir } from '../cli/task-context.js';
 import { hasTrustedFullAccessContext } from './runner-types.js';
-import { contextTokensForUsage, usageForContext, isClaudeContextUsageModel, isOneMillionContextModel, realContextWindowForModel, autoCompactWindowForModel } from './runner-types.js';
+import { contextTokensForUsage, usageForContext, isClaudeContextUsageModel, isOneMillionContextModel, realContextWindowForModel, autoCompactWindowForModel, sdkAutoCompactWindowForModel } from './runner-types.js';
+import { hasContextWindowSuffix, stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 const resolveModule = createRequire(import.meta.url);
 /**
  * Resolve the platform package explicitly instead of relying on the SDK's
@@ -409,11 +410,18 @@ async function refreshGatewayPricing(baseUrl, apiKey, requestHeaders) {
 }
 /**
  * 为支持 1M 上下文的模型追加 `[1m]` 后缀——仅在交给 SDK query() 时调用。
- * 目录与校验层始终使用不带后缀的基础 ID，避免与网关 /models 返回值（无 `[1m]`）冲突。
+ *
+ * 若网关把窗口变体作为独立条目下发（目录里同时有 `claude-opus-5` 与
+ * `claude-opus-5[1m]`），裸 ID 就是用户明确选的非 1M 变体，不能擅自升级，
+ * 否则两条列表项的实际效果无法区分。只有目录未提供任何窗口变体时，才沿用
+ * 按本地名单补 `[1m]` 的旧行为。
  */
-function applyContextWindow(modelId) {
-    if (/\[1m\]$/.test(modelId))
-        return modelId; // 已带后缀
+function applyContextWindow(modelId, catalog) {
+    if (hasContextWindowSuffix(modelId))
+        return modelId; // 窗口已显式指定
+    const variantListed = catalog?.models.some(m => hasContextWindowSuffix(m.id) && stripContextWindowSuffix(m.id) === modelId);
+    if (variantListed)
+        return modelId;
     if (isOneMillionContextModel(modelId))
         return `${modelId}[1m]`;
     return modelId;
@@ -500,9 +508,9 @@ export class AgentRunner {
     /** 每个 session 最近的子进程 stderr 行（环形缓冲），用于子进程崩溃时还原真正原因 */
     recentStderr = new Map();
     static STDERR_BUFFER_MAX = 80;
-    async recordSandboxInfrastructureFailure(sessionId, inputId, permissionMode, error, stderr = []) {
+    async recordSandboxInfrastructureFailure(sessionId, inputId, permissionMode, error, stderr = [], scope = 'process') {
         const detail = createSandboxInitializationError(error, stderr);
-        const circuit = recordSandboxInitializationFailure(detail, stderr);
+        const circuit = recordSandboxInitializationFailure(detail, stderr, Date.now(), scope === 'session' ? sessionId : undefined);
         const context = this.permissionContexts.get(sessionId);
         auditToolInfrastructureFailure({
             toolName: 'Bash',
@@ -1343,6 +1351,7 @@ export class AgentRunner {
         const taskMetadata = new Map();
         // tool_use_id → tool_name 映射，用于从 SDKUserMessage 的 tool_result 块中还原工具名
         const toolUseNames = new Map();
+        const sandboxedBashCalls = new Set();
         const emittedToolResultIds = new Set();
         let turnCount = 0;
         const seenMessageIds = new Set();
@@ -1617,6 +1626,10 @@ export class AgentRunner {
                         if (content.type === 'tool_use') {
                             if (content.id)
                                 toolUseNames.set(content.id, content.name);
+                            if (content.id && content.name === 'Bash' && content.input?.dangerouslyDisableSandbox !== true
+                                && resolvePhaseOneExecutionSandbox(permissionMode, this.permissionContexts.get(sessionId)?.role).state !== 'off') {
+                                sandboxedBashCalls.add(content.id);
+                            }
                             yield { type: 'tool_use', name: content.name, input: content.input, callId: content.id, turn: turnCount, outputTokens: turnOutputChars, assistantUuid: event.uuid };
                         }
                         else if (content.type === 'text' && content.text) {
@@ -1635,6 +1648,31 @@ export class AgentRunner {
                                 : block.content != null ? JSON.stringify(block.content) : '';
                             if (block.tool_use_id)
                                 emittedToolResultIds.add(block.tool_use_id);
+                            if (sandboxedBashCalls.delete(block.tool_use_id) && block.is_error === true
+                                && isSandboxInitializationToolResult(block.content)) {
+                                const { detail } = await this.recordSandboxInfrastructureFailure(sessionId, block.tool_use_id, permissionMode, new Error(resultContent), [], 'session');
+                                // Stop this SDK query before another model/tool retry. Do not use
+                                // interrupt(), which waits for this very generator to finish.
+                                this.activeMessageStreams.get(sessionId)?.end();
+                                const query = sdkStream;
+                                try {
+                                    await query.close?.();
+                                }
+                                catch (error) {
+                                    logger.warn(`[ClaudeSandbox] failed to close sandbox-failed query: ${error}`);
+                                }
+                                yield {
+                                    type: 'tool_result', name: toolName, result: resultContent, isError: true,
+                                    error: detail.message, errorCode: 'CAPABILITY_UNAVAILABLE', callId: block.tool_use_id,
+                                    correlationId: block.tool_use_id, decision: 'error', decisionSource: 'infrastructure',
+                                    policyCode: SANDBOX_INITIALIZATION_FAILED, executed: false, executionState: 'blocked',
+                                };
+                                yield {
+                                    type: 'complete', isError: true, subtype: 'infrastructure',
+                                    terminalReason: SANDBOX_INITIALIZATION_FAILED, errors: [detail.message], queryFinal: true,
+                                };
+                                return;
+                            }
                             yield {
                                 type: 'tool_result',
                                 name: toolName,
@@ -1992,7 +2030,7 @@ export class AgentRunner {
         const executionSandbox = resolvePhaseOneExecutionSandbox(callPermissionMode, runPermissionContext?.role);
         const inputId = modelOverride?.turn?.inputId ?? crypto.randomUUID();
         if (executionSandbox.state !== 'off') {
-            const activeSandboxFailure = getActiveSandboxInitializationFailure();
+            const activeSandboxFailure = getActiveSandboxInitializationFailure(undefined, undefined, sessionId);
             if (activeSandboxFailure) {
                 const detail = createSandboxInitializationError(new Error(`sandbox bootstrap circuit open; firstObservedAt=${activeSandboxFailure.openedAt} ` +
                     `occurrences=${activeSandboxFailure.occurrences}; ${activeSandboxFailure.detail}`));
@@ -2469,7 +2507,7 @@ export class AgentRunner {
         else {
             logger.info(`[AgentRunner] systemPromptAppend: none`);
         }
-        const sdkModel = applyContextWindow(resolveCatalogModel(runCatalog, callModel));
+        const sdkModel = applyContextWindow(resolveCatalogModel(runCatalog, callModel), runCatalog);
         const capabilityOptions = await this.resolveCapabilityRunOptions(projectPath);
         const managedSettings = callPermissionMode === 'fullaccess'
             ? undefined
@@ -2552,7 +2590,7 @@ export class AgentRunner {
             ...(executionSandbox.state === 'off' && callPermissionMode !== 'fullaccess' && process.platform === 'linux' ? {
                 spawnClaudeCodeProcess: (options) => spawnClaudeWithHClassGuard(options, resolvePaths().root, handleClaudeStderr),
             } : {}),
-            autoCompactWindow: autoCompactWindowForModel(sdkModel),
+            autoCompactWindow: sdkAutoCompactWindowForModel(sdkModel),
             advisorModel: 'haiku',
             canUseTool: canUseToolCallback,
             permissionMode: sdkPermissionMode,
@@ -2891,7 +2929,7 @@ export class AgentRunner {
             prompt,
             options: {
                 cwd: projectPath,
-                ...(catalog && callModel ? { model: applyContextWindow(resolveCatalogModel(catalog, callModel)) } : {}),
+                ...(catalog && callModel ? { model: applyContextWindow(resolveCatalogModel(catalog, callModel), catalog) } : {}),
                 resume: agentSessionId,
                 maxTurns: 1,
                 tools: [],

package/dist/agents/codex/app-server-client.js

@@ -232,7 +232,7 @@ export class CodexAppServerClient {
                     : { sandbox: options?.sandbox ?? null }),
             config: this.buildThreadConfig(effort, options?.config),
             excludeTurns: false,
-            persistExtendedHistory: false,
+            ...(options?.lastTurnId ? { lastTurnId: options.lastTurnId } : {}),
         });
         const forkedThreadId = response.thread?.id;
         if (title && forkedThreadId) {
@@ -252,16 +252,19 @@ export class CodexAppServerClient {
         await this.request('thread/compact/start', { threadId });
         return true;
     }
-    async threadTurnsList(threadId, limit) {
+    async threadTurnsList(threadId, limit, cursor) {
         return this.request('thread/turns/list', {
             threadId,
             ...(limit ? { limit } : {}),
-            sortDirection: 'asc',
+            ...(cursor ? { cursor } : {}),
+            // The app-server defaults to newest-first. `nextCursor` then walks
+            // toward older turns, which is the direction needed to hydrate history.
+            sortDirection: 'desc',
             itemsView: 'full',
         });
     }
     async threadTurnsItemsList(threadId, turnId, limit) {
-        return this.request('thread/turns/items/list', {
+        return this.request('thread/items/list', {
             threadId,
             turnId,
             ...(limit ? { limit } : {}),
@@ -643,7 +646,12 @@ export class CodexAppServerClient {
                 logger.warn(`[CodexAppServer] managed runtime lock directory unavailable: ${runtimeLockDir}`);
             }
         }
-        env.CODEX_API_KEY = this.options.apiKey;
+        if (this.options.authType === 'bearerToken') {
+            delete env.CODEX_API_KEY;
+        }
+        else {
+            env.CODEX_API_KEY = this.options.apiKey;
+        }
         env.EVOLCORE_INSTANCE_SOCKET = resolvePaths().instanceSocket;
         for (const [name, value] of Object.entries(this.options.headers ?? {})) {
             env[codexHeaderEnvName(name)] = value;

package/dist/agents/codex/catalog.js

@@ -28,7 +28,7 @@ export async function codexNativeCatalog(context) {
     if (context.baseagent !== 'codex')
         return null;
     const client = new CodexAppServerClient({
-        apiKey: context.apiKey ?? '', baseUrl: context.baseUrl, provider: context.provider,
+        apiKey: context.apiKey ?? '', authType: context.authType, baseUrl: context.baseUrl, provider: context.provider,
         headers: context.headers, queryParams: context.queryParams,
     });
     let timer;

package/dist/agents/codex/diagnostics.js

@@ -179,6 +179,39 @@ function realDirectoryState(directory) {
         return 'unavailable';
     }
 }
+/** Read back the package root that managedHookLauncher() embedded. */
+function launcherPackageRoot(launcher) {
+    const match = /^\s*const packageRoot = ("(?:[^"\\]|\\.)*")\s*;/m.exec(launcher);
+    if (!match)
+        return null;
+    try {
+        const value = JSON.parse(match[1]);
+        return typeof value === 'string' && value ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A `npm link` install reaches the package through a symlinked global path, so
+ * the launcher and the running CLI legitimately spell the same package root
+ * differently. Compare the resolved targets instead of the literal strings;
+ * a launcher pointing at a genuinely different package still fails closed.
+ */
+function samePackageRoot(embedded, expected) {
+    if (!embedded)
+        return false;
+    const normalize = (value) => path.normalize(value).replace(/[\\/]+$/, '').toLowerCase();
+    const resolved = (value) => {
+        try {
+            return normalize(fs.realpathSync(value));
+        }
+        catch {
+            return normalize(value);
+        }
+    };
+    return normalize(embedded) === normalize(expected) || resolved(embedded) === resolved(expected);
+}
 /** Read-only inspection of the machine-wide Windows Codex managed hook. */
 export function inspectCodexManagedHook(options = {}) {
     const paths = codexManagedHookPaths(options);
@@ -252,7 +285,7 @@ export function inspectCodexManagedHook(options = {}) {
     const normalized = (value) => path.normalize(String(value || '')).toLowerCase();
     const expectedPackageRoot = path.resolve(options.packageRoot || process.cwd());
     const launcherValid = launcher.includes('EVOLCORE_MANAGED_HOOK_LAUNCHER')
-        && launcher.toLowerCase().includes(JSON.stringify(expectedPackageRoot).toLowerCase());
+        && samePackageRoot(launcherPackageRoot(launcher), expectedPackageRoot);
     const configuredDir = config.hooks?.windows_managed_dir ?? config.hooks?.managed_dir;
     const groups = config.hooks?.PreToolUse;
     const canonicalCommand = (value) => {