evolcore 0.0.7 → 0.0.9

package/dist/core/inference/text-inference.js

@@ -3,8 +3,20 @@ function apiEndpoint(baseUrl, resource) {
     const configured = baseUrl?.trim();
     if (!configured)
         throw new Error('Direct text inference baseUrl is not configured');
-    const base = configured.replace(/\/+$/, '');
-    return base.endsWith('/v1') ? `${base}/${resource}` : `${base}/v1/${resource}`;
+    const parsed = new URL(configured);
+    const pathname = parsed.pathname.replace(/\/+$/, '');
+    parsed.pathname = pathname.endsWith('/v1')
+        ? `${pathname}/${resource}`
+        : `${pathname}/v1/${resource}`;
+    return parsed.toString();
+}
+function withQueryParams(url, queryParams) {
+    if (!queryParams || Object.keys(queryParams).length === 0)
+        return url;
+    const parsed = new URL(url);
+    for (const [name, value] of Object.entries(queryParams))
+        parsed.searchParams.set(name, value);
+    return parsed.toString();
 }
 async function parseError(response) {
     let raw = '';
@@ -28,10 +40,10 @@ export class AnthropicTextInferenceProvider {
         this.config = config;
     }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'messages'), {
+        const response = await fetch(withQueryParams(apiEndpoint(this.config.baseUrl, 'messages'), this.config.queryParams), {
             method: 'POST',
             signal: request.signal,
-            headers: this.headers(),
+            headers: { ...this.headers(), ...this.config.headers },
             body: JSON.stringify({
                 model: request.model,
                 max_tokens: 256,
@@ -69,12 +81,13 @@ export class OpenAITextInferenceProvider {
         this.config = config;
     }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'responses'), {
+        const response = await fetch(withQueryParams(apiEndpoint(this.config.baseUrl, 'responses'), this.config.queryParams), {
             method: 'POST',
             signal: request.signal,
             headers: {
                 'Content-Type': 'application/json',
                 Authorization: `Bearer ${this.config.apiKey}`,
+                ...this.config.headers,
             },
             body: JSON.stringify({
                 model: request.model,

package/dist/core/message/message-bridge.js

@@ -627,6 +627,7 @@ export class MessageBridge {
                 const menuControl = resolvedChannelType === 'aun'
                     ? parseMenuControl(content)
                     : { isMenu: false };
+                let menuResponseWarning;
                 if (menuControl.isMenu) {
                     this.logMenuInbound(channelName, msg, menuControl);
                     if (!hasValidMenuId(menuControl)) {
@@ -649,7 +650,7 @@ export class MessageBridge {
                         await this.sendMenuResponse(adapter, channelName, msg, menuFailure(header, {
                             code: 'MENU_TOKEN_ENCRYPTION_REQUIRED',
                             message: 'Menu 请求必须使用 E2EE',
-                        }), true);
+                        }));
                         return;
                     }
                     if (!isTokenRequest) {
@@ -666,6 +667,13 @@ export class MessageBridge {
                             }));
                             return;
                         }
+                        if (!menuTokenRequired && tokenSupplied && !tokenValid) {
+                            this.logMenuDiagnostic('token-invalid-optional', channelName, msg, menuControl, 'MENU_TOKEN_INVALID');
+                            menuResponseWarning = {
+                                code: 'MENU_TOKEN_INVALID',
+                                message: 'Menu token 无效，请重新申请',
+                            };
+                        }
                     }
                     const validationError = validateMenuRequest(menuControl.request);
                     if (validationError) {
@@ -712,7 +720,7 @@ export class MessageBridge {
                 });
                 const identity = authSubject.identity;
                 if (menuControl.isMenu) {
-                    await this.handleMenuControl(menuControl, channelName, resolvedChannelType, msg, adapter, authSubject);
+                    await this.handleMenuControl(menuControl, channelName, resolvedChannelType, msg, adapter, authSubject, menuResponseWarning);
                     return;
                 }
                 // 普通消息保留原始日志；控制 payload 使用脱敏元数据日志。
@@ -1074,7 +1082,7 @@ export class MessageBridge {
             throw { code: 'NOT_SUPPORTED', message: `Unsupported menu name: ${name}` };
         return mapped;
     }
-    async handleMenuControl(parsed, channel, channelType, msg, adapter, authSubject) {
+    async handleMenuControl(parsed, channel, channelType, msg, adapter, authSubject, responseWarning) {
         if (!hasValidMenuId(parsed))
             return;
         const header = { id: parsed.id, ...(parsed.name?.trim() ? { name: parsed.name } : {}) };
@@ -1122,7 +1130,10 @@ export class MessageBridge {
         }
         if (deduped.replayed)
             this.logMenuDiagnostic('request-replay', channel, msg, parsed);
-        await this.sendMenuResponse(adapter, channel, msg, deduped.value, isTokenRequest);
+        const response = responseWarning && 'data' in deduped.value
+            ? { ...deduped.value, warning: responseWarning }
+            : deduped.value;
+        await this.sendMenuResponse(adapter, channel, msg, response);
         const deferredEffect = afterResponse;
         if (!deduped.replayed && deferredEffect) {
             try {
@@ -1191,7 +1202,7 @@ export class MessageBridge {
             return menuFailure(header, normalizeMenuError(error));
         }
     }
-    async sendMenuResponse(adapter, channel, msg, response, forceEncryption = false) {
+    async sendMenuResponse(adapter, channel, msg, response) {
         if (!adapter?.send) {
             this.logMenuDiagnostic('transport-unavailable', channel, msg, {
                 isMenu: true,
@@ -1208,7 +1219,7 @@ export class MessageBridge {
             ...(msg.replyContext ?? {}),
             metadata: {
                 ...(msg.replyContext?.metadata ?? {}),
-                ...evolMenuResponseTransportMetadata(forceEncryption ? true : msg.encrypted),
+                ...evolMenuResponseTransportMetadata(),
             },
         };
         const envelope = buildEnvelope({

package/dist/core/message/response-engine.js

@@ -890,6 +890,16 @@ export class ResponseEngine {
             return;
         renderer.addNotice(text, severity, subtype, true);
     }
+    async cancelStaleRunnerStart(agent, sessionId, streamKey, turnLease, taskId) {
+        if (this.turnCoordinator.isCurrent(turnLease))
+            return false;
+        logger.info(`[ResponseEngine] Stale turn detected after agent.runQuery start; cancelling unconsumed stream: session=${sessionId} task=${taskId}`);
+        await agent.interrupt(sessionId).catch(interruptError => {
+            logger.warn(`[ResponseEngine] Failed to cancel stale runner start: session=${sessionId} task=${taskId} error=${interruptError instanceof Error ? interruptError.message : String(interruptError)}`);
+        });
+        agent.cleanupStream(streamKey);
+        return true;
+    }
     async retryAfterContextRecovery(prompt, opts) {
         const { streamKey, renderer, agent, session, absoluteProjectPath, effectiveSystemPrompt, modelOverride, runtimeEnv, resetTimer, shouldSuppress, proactive, turnLease, } = opts;
         if (!session.agentSessionId || !canCompactAgent(agent)) {
@@ -911,6 +921,9 @@ export class ResponseEngine {
             await this.emitOperationalNotice(renderer, '✅ 压缩完成，继续处理...', 'info', 'compact-retry');
             await renderer.flush();
             const retryStream = await agent.runQuery(session.id, prompt, absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
+            if (await this.cancelStaleRunnerStart(agent, session.id, streamKey, turnLease, turnLease.taskId)) {
+                throw new Error('RUNNER_START_SUPERSEDED');
+            }
             agent.registerStream(streamKey, retryStream);
             return await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress, proactive, undefined, // 重试分支不调插件钩子
             undefined, turnLease);
@@ -2331,7 +2344,7 @@ export class ResponseEngine {
                 try {
                     const selector = { self: selfAid || undefined, peerKey };
                     const modelResolution = resolveEffectiveFieldWithSource(`baseagents.${normalizedBaseagent.canonical}.model`, selector, { cache: true });
-                    const effortResolution = resolveEffectiveFieldWithSource(`baseagents.${normalizedBaseagent.canonical}.${normalizedBaseagent.canonical === 'codex' ? 'reasoning' : 'effort'}`, selector, { cache: true });
+                    const effortResolution = resolveEffectiveFieldWithSource(`baseagents.${normalizedBaseagent.canonical}.effort`, selector, { cache: true });
                     const modelDecision = constrainResolvedModelForRole({
                         role: peerRole,
                         baseagent: normalizedBaseagent.canonical,
@@ -2342,7 +2355,7 @@ export class ResponseEngine {
                         selfAid: selfAid || undefined,
                     });
                     const model = modelDecision.model;
-                    const effortField = `baseagents.${normalizedBaseagent.canonical}.${normalizedBaseagent.canonical === 'codex' ? 'reasoning' : 'effort'}`;
+                    const effortField = `baseagents.${normalizedBaseagent.canonical}.effort`;
                     const effortDecision = resolveRuntimeStringField({
                         selfAid: selfAid || undefined,
                         role: peerRole,
@@ -2389,7 +2402,7 @@ export class ResponseEngine {
                         effectiveModelSource = triggerModelDecision.constrained ? 'role' : 'trigger';
                     }
                     if (triggerEffortOverride) {
-                        const effortField = `baseagents.${normalizedBaseagent.canonical}.${normalizedBaseagent.canonical === 'codex' ? 'reasoning' : 'effort'}`;
+                        const effortField = `baseagents.${normalizedBaseagent.canonical}.effort`;
                         const triggerEffortDecision = resolveRuntimeStringField({
                             selfAid: selfAid || undefined,
                             role: peerRole,
@@ -2766,6 +2779,12 @@ export class ResponseEngine {
                     try {
                         logger.info(`[ResponseEngine] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${runAttempt} apiRetries=${retryScheduler.apiRetryAttemptsMade} agentSessionId=${session.agentSessionId ?? 'none'}`);
                         const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, renderResult?.images.length ? renderResult.images : message.images, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
+                        // The turn may be superseded while the runner is still creating its
+                        // backend query. Replay the interrupt after runQuery resolves, when
+                        // every runner is required to have an addressable cancellation handle.
+                        if (await this.cancelStaleRunnerStart(agent, session.id, streamKey, turnLease, taskId)) {
+                            throw new Error('RUNNER_START_SUPERSEDED');
+                        }
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
                         if (shouldTimeoutRetryAttempt) {

package/dist/core/model/config-scope.js

@@ -82,9 +82,9 @@ export function activeBaseagent(self) {
     catch { /* fall through */ }
     return 'claude';
 }
-/** codex 的推理强度字段名是 reasoning，其余是 effort。 */
-function effortField(ba) {
-    return ba === 'codex' ? 'reasoning' : 'effort';
+/** 所有 baseagent 统一使用 effort 表达推理强度。 */
+function effortField(_ba) {
+    return 'effort';
 }
 // ── 写：单作用域 ──────────────────────────────────────────────────────
 /** 写入指定作用域。patch 中 undefined 不动；显式 null 删除字段。 */

package/dist/core/permission/tool-policy.js

@@ -169,6 +169,17 @@ function isOwnerOrAdminRole(role) {
 function hasNodeProcessTarget(command) {
     return /\bnode(?:js|\.exe)?\b/i.test(command);
 }
+// 包发布命令：npm/pnpm/yarn/bun publish。
+// 排除 --dry-run（不产生实际发布），保留 --provenance 等真实发布参数。
+function isPackagePublishCommand(parsed) {
+    const runners = ['npm', 'pnpm', 'yarn', 'bun', 'npx'];
+    if (!runners.includes(parsed.executable))
+        return false;
+    const words = parsed.args.filter(arg => !arg.startsWith('-')).map(arg => arg.toLowerCase());
+    if (words[0] !== 'publish')
+        return false;
+    return !parsed.args.some(arg => arg === '--dry-run' || arg.startsWith('--dry-run='));
+}
 function classifyHostProcessArgv(argv) {
     const executable = commandName(argv[0]);
     if (['ps', 'pgrep', 'pidof'].includes(executable)) {
@@ -279,6 +290,13 @@ function classifyStructuredCommand(command, depth = 0) {
                 matches.push({ kind: 'git-push', reason: 'Git push 会修改远端仓库', approvalScope: 'request' });
             }
         }
+        if (isPackagePublishCommand(parsed)) {
+            matches.push({
+                kind: 'package-publish',
+                reason: '发布软件包到公共 registry，发布后无法替换同版本',
+                approvalScope: 'all',
+            });
+        }
         if (['kill', 'pkill', 'killall'].includes(parsed.executable) && hasNodeProcessTarget(parsed.raw)) {
             matches.push({ kind: 'process-kill', reason: '终止 Node.js 运行时进程', approvalScope: 'request' });
         }

package/dist/core/protected-paths.js

@@ -322,9 +322,20 @@ export function buildCodexHClassFilesystemRules(root = resolveRoot()) {
     };
 }
 export function buildCodexProtectedFilesystemRules(root = resolveRoot()) {
+    const lClassRules = {};
+    for (const target of getExistingLClassReadOnlyTargets(root)) {
+        if (target.kind === 'directory') {
+            if (path.basename(target.path) === 'triggers')
+                lClassRules[target.path] = 'read';
+            lClassRules[path.join(target.path, '**')] = 'read';
+        }
+        else {
+            lClassRules[target.path] = 'read';
+        }
+    }
     return {
         ...buildCodexHClassFilesystemRules(root),
-        ...Object.fromEntries(getLClassWritePatterns(root).map(pattern => [pattern, 'read'])),
+        ...lClassRules,
     };
 }
 export function hClassGrantIncludesProtectedPath(value, options = {}) {