evolcore 0.0.10 → 0.0.11

package/dist/core/evolagent-registry.js

@@ -5,7 +5,7 @@ import { logger } from '../utils/logger.js';
 import { agentPersonalDir } from '../paths.js';
 import { invalidateAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
 import { loadAllAgents, ensureAgentDirSkeleton, loadAgent, validateAgentConfig, } from '../config-store.js';
-import { resolveEffective } from '../config/config-manager.js';
+import { ConfigTarget, read as readConfig, resolveEffective } from '../config/config-manager.js';
 // ── Channel Fingerprint ───────────────────────────────────────────────────
 // 用于检测多 agent 之间复用同一外部凭证的冲突（appId、aid、token 等）。
 // 格式：{type}:{primaryKey}
@@ -84,18 +84,20 @@ export class EvolAgentRegistry {
         this.skipped = [];
         const { agents: rawAgents, skipped, invalidAgents = [] } = loadAllAgents({ includeInvalid: true });
         this.skipped = skipped;
-        for (const raw of rawAgents) {
+        for (const expandedRaw of rawAgents) {
             try {
-                const merged = resolveEffective({ self: raw.aid });
+                const raw = readConfig(ConfigTarget.Agent, { self: expandedRaw.aid }, { cache: true }) ?? expandedRaw;
+                const merged = resolveEffective({ self: expandedRaw.aid }, { expand: true });
                 const agent = new EvolAgent(raw, merged);
-                ensureAgentDirSkeleton(raw.aid);
+                ensureAgentDirSkeleton(expandedRaw.aid);
                 this.agents.set(agent.aid, agent);
             }
             catch (e) {
-                logger.warn(`[EvolAgentRegistry] failed to construct agent ${raw.aid}: ${e}`);
+                logger.warn(`[EvolAgentRegistry] failed to construct agent ${expandedRaw.aid}: ${e}`);
             }
         }
-        for (const { agent: raw, reason } of invalidAgents) {
+        for (const { agent: expandedRaw, reason } of invalidAgents) {
+            const raw = readConfig(ConfigTarget.Agent, { self: expandedRaw.aid }, { cache: true }) ?? expandedRaw;
             this.registerErrorAgent(raw, reason);
         }
         this.detectAndFlagConflicts();
@@ -119,7 +121,7 @@ export class EvolAgentRegistry {
     }
     resolveMergedForErrorAgent(raw, reason) {
         try {
-            return resolveEffective({ self: raw.aid });
+            return resolveEffective({ self: raw.aid }, { expand: true });
         }
         catch (e) {
             const message = e instanceof Error ? e.message : String(e);
@@ -225,9 +227,9 @@ export class EvolAgentRegistry {
             logger.info(`[EvolAgentRegistry] agent ${aid} already loaded, skipping`);
             return this.agents.get(aid);
         }
-        let raw = null;
+        let expandedRaw = null;
         try {
-            raw = loadAgent(aid);
+            expandedRaw = loadAgent(aid);
         }
         catch (e) {
             const reason = e instanceof Error ? e.message : String(e);
@@ -239,22 +241,23 @@ export class EvolAgentRegistry {
                 channels: [],
             }, reason);
         }
-        if (!raw) {
+        if (!expandedRaw) {
             logger.warn(`[EvolAgentRegistry] loadNewAgent: ${aid}/config.json not found`);
             return null;
         }
-        const errs = validateAgentConfig(raw);
+        const errs = validateAgentConfig(expandedRaw);
         if (errs.length > 0) {
             const reason = errs.join('; ');
             logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${reason}`);
-            return this.registerErrorAgent(raw, reason);
+            return this.registerErrorAgent(expandedRaw, reason);
         }
-        const conflict = this.checkConflictForReload(raw, aid);
+        const conflict = this.checkConflictForReload(expandedRaw, aid);
         if (conflict) {
             logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${conflict}`);
-            return this.registerErrorAgent(raw, `Channel conflict: ${conflict}`);
+            return this.registerErrorAgent(expandedRaw, `Channel conflict: ${conflict}`);
         }
-        const merged = resolveEffective({ self: aid });
+        const raw = readConfig(ConfigTarget.Agent, { self: aid }, { cache: true }) ?? expandedRaw;
+        const merged = resolveEffective({ self: aid }, { expand: true });
         const agent = new EvolAgent(raw, merged);
         ensureAgentDirSkeleton(aid);
         this.agents.set(aid, agent);
@@ -268,13 +271,14 @@ export class EvolAgentRegistry {
         const oldAgent = this.agents.get(aidOrName);
         if (!oldAgent)
             throw new Error(`Agent "${aidOrName}" not found`);
-        const raw = loadAgent(oldAgent.aid);
-        if (!raw)
+        const expandedRaw = loadAgent(oldAgent.aid);
+        if (!expandedRaw)
             throw new Error(`Agent ${oldAgent.aid}/config.json missing on reload`);
-        const errs = validateAgentConfig(raw);
+        const errs = validateAgentConfig(expandedRaw);
         if (errs.length > 0)
             throw new Error(`Invalid config after edit: ${errs.join('; ')}`);
-        const merged = resolveEffective({ self: raw.aid });
+        const raw = readConfig(ConfigTarget.Agent, { self: oldAgent.aid }, { cache: true }) ?? expandedRaw;
+        const merged = resolveEffective({ self: raw.aid }, { expand: true });
         if (oldAgent.status === 'disabled' && raw.enabled !== false) {
             oldAgent.swapConfig(raw, merged);
             const hotLoad = globalThis.__evolcore_hotLoadAgent;
@@ -289,32 +293,69 @@ export class EvolAgentRegistry {
         }
         if (oldAgent.status !== 'disabled' && raw.enabled === false) {
             let prepared = false;
+            let runnerTransaction;
+            const disconnectedChannels = [];
+            const previousConfig = oldAgent.captureConfigSnapshot();
+            const previousStatus = oldAgent.status;
+            const previousError = oldAgent.error;
             try {
                 await hooks.prepareHandoffReload?.(oldAgent.aid);
                 prepared = true;
+                runnerTransaction = await hooks.stageAgentRunners?.(new EvolAgent(raw, merged));
                 for (const ch of oldAgent.channelInstanceNames()) {
                     try {
                         await hooks.drainChannel(ch);
                     }
                     catch { }
-                    try {
-                        await hooks.disconnectChannel(ch);
-                    }
-                    catch { }
+                    await hooks.disconnectChannel(ch);
+                    disconnectedChannels.push(ch);
                 }
                 oldAgent.swapConfig(raw, merged);
                 oldAgent.status = 'disabled';
                 this.channelIndex.clear();
                 this.buildChannelIndex();
+                runnerTransaction?.commit();
+                try {
+                    await runnerTransaction?.finalize();
+                }
+                catch (error) {
+                    logger.warn(`[Reload] Failed to dispose previous runners after disabling "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+                }
+                prepared = false;
                 logger.info(`[Reload] Agent "${aidOrName}" disabled`);
                 return;
             }
             catch (error) {
+                const rollbackErrors = [];
+                oldAgent.swapConfig(previousConfig.rawAgent, previousConfig.merged);
+                oldAgent.invalidatePersonaCache();
+                oldAgent.status = previousStatus;
+                oldAgent.error = previousError;
+                await runnerTransaction?.rollback().catch(rollbackError => {
+                    rollbackErrors.push(`runners: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                });
+                for (const ch of disconnectedChannels) {
+                    try {
+                        await hooks.startChannel(oldAgent, ch);
+                    }
+                    catch (restartError) {
+                        rollbackErrors.push(`restart ${ch}: ${restartError instanceof Error ? restartError.message : String(restartError)}`);
+                    }
+                }
+                this.channelIndex.clear();
+                this.buildChannelIndex();
                 if (prepared) {
                     try {
                         await hooks.completeHandoffReload?.(oldAgent.aid);
                     }
-                    catch { }
+                    catch (resumeError) {
+                        rollbackErrors.push(`handoff: ${resumeError instanceof Error ? resumeError.message : String(resumeError)}`);
+                    }
+                }
+                if (rollbackErrors.length > 0) {
+                    oldAgent.status = 'error';
+                    oldAgent.error = `Disable failed; rollback incomplete: ${rollbackErrors.join('; ')}`;
+                    logger.error(`[Reload] Disable rollback incomplete for "${aidOrName}": ${rollbackErrors.join('; ')}`);
                 }
                 throw error;
             }
@@ -324,13 +365,18 @@ export class EvolAgentRegistry {
             throw new Error(`Channel conflict: ${conflict}`);
         const removedSuccessfully = [];
         const addedSuccessfully = [];
+        let runnerTransaction;
         let prepared = false;
+        const previousConfig = oldAgent.captureConfigSnapshot();
+        const previousStatus = oldAgent.status;
+        const previousError = oldAgent.error;
         try {
             await hooks.prepareHandoffReload?.(oldAgent.aid);
             prepared = true;
+            runnerTransaction = await hooks.stageAgentRunners?.(new EvolAgent(raw, merged));
             const oldChannels = new Set(oldAgent.channelInstanceNames());
             const aunKey = oldAgent.effectiveChannelName('aun', 'main');
-            const otherKeys = raw.channels.filter(c => c.type !== 'aun').map(c => oldAgent.effectiveChannelName(c.type, c.name));
+            const otherKeys = merged.channels.filter(c => c.type !== 'aun').map(c => oldAgent.effectiveChannelName(c.type, c.name));
             const newChannels = new Set([aunKey, ...otherKeys]);
             const toRemove = [...oldChannels].filter(c => !newChannels.has(c));
             const toAdd = [...newChannels].filter(c => !oldChannels.has(c));
@@ -338,7 +384,7 @@ export class EvolAgentRegistry {
             const credentialsChanged = [];
             for (const ch of kept) {
                 const oldInst = oldAgent.findChannelInstance(ch);
-                const newInst = findInstanceByKey(raw, oldAgent, ch);
+                const newInst = findInstanceByKey(merged, oldAgent, ch);
                 if (oldInst && newInst && JSON.stringify(oldInst) !== JSON.stringify(newInst)) {
                     credentialsChanged.push(ch);
                 }
@@ -360,28 +406,72 @@ export class EvolAgentRegistry {
             oldAgent.status = 'running';
             this.channelIndex.clear();
             this.buildChannelIndex();
-            await hooks.completeHandoffReload?.(oldAgent.aid);
-            prepared = false;
+            runnerTransaction?.commit();
+            try {
+                await hooks.completeHandoffReload?.(oldAgent.aid);
+            }
+            catch (error) {
+                logger.warn(`[Reload] Handoff recovery failed after commit for "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                prepared = false;
+            }
+            try {
+                await hooks.afterReload?.(oldAgent);
+            }
+            catch (error) {
+                logger.warn(`[Reload] Post-reload hook failed after commit for "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                await runnerTransaction?.finalize();
+            }
+            catch (error) {
+                logger.warn(`[Reload] Failed to dispose previous runners for "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         catch (err) {
-            logger.error(`[Reload] Failed: ${err}. Attempting rollback for "${aidOrName}".`);
-            for (const ch of addedSuccessfully) {
+            logger.error(`[Reload] Failed before commit: ${err}. Attempting rollback for "${aidOrName}".`);
+            const rollbackErrors = [];
+            for (const ch of [...addedSuccessfully].reverse()) {
                 try {
                     await hooks.disconnectChannel(ch);
                 }
-                catch { }
+                catch (error) {
+                    rollbackErrors.push(`disconnect ${ch}: ${error instanceof Error ? error.message : String(error)}`);
+                }
             }
+            oldAgent.swapConfig(previousConfig.rawAgent, previousConfig.merged);
+            oldAgent.invalidatePersonaCache();
+            await runnerTransaction?.rollback().catch(error => {
+                rollbackErrors.push(`runners: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            for (const ch of [...new Set(removedSuccessfully)]) {
+                try {
+                    await hooks.startChannel(oldAgent, ch);
+                }
+                catch (error) {
+                    rollbackErrors.push(`restart ${ch}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            this.channelIndex.clear();
+            this.buildChannelIndex();
             if (prepared) {
                 try {
                     await hooks.completeHandoffReload?.(oldAgent.aid);
                 }
                 catch (resumeError) {
-                    logger.error(`[Reload] Failed to resume Handoff dispatcher for "${aidOrName}":`, resumeError);
+                    rollbackErrors.push(`handoff: ${resumeError instanceof Error ? resumeError.message : String(resumeError)}`);
                 }
             }
-            void removedSuccessfully;
-            oldAgent.status = 'error';
-            oldAgent.error = `Reload failed (rollback partial): ${err instanceof Error ? err.message : String(err)}`;
+            if (rollbackErrors.length === 0) {
+                oldAgent.status = previousStatus;
+                oldAgent.error = previousError;
+            }
+            else {
+                oldAgent.status = 'error';
+                oldAgent.error = `Reload failed; rollback incomplete: ${rollbackErrors.join('; ')}`;
+                logger.error(`[Reload] Rollback incomplete for "${aidOrName}": ${rollbackErrors.join('; ')}`);
+            }
             throw err;
         }
     }

package/dist/core/evolagent.js

@@ -52,7 +52,7 @@ export class EvolAgent {
         const ba = this.baseagent;
         // 动态读取配置（基于 fileCache + mtime），使配置变更立即体现在显示中
         try {
-            const effective = resolveEffective({ self: this.aid }, { cache: true });
+            const effective = resolveEffective({ self: this.aid }, { cache: true, expand: true });
             const block = effective.baseagents?.[ba];
             return block?.model;
         }
@@ -66,7 +66,7 @@ export class EvolAgent {
         const ba = this.baseagent;
         // 动态读取配置（基于 fileCache + mtime），使配置变更立即体现在显示中
         try {
-            const effective = resolveEffective({ self: this.aid }, { cache: true });
+            const effective = resolveEffective({ self: this.aid }, { cache: true, expand: true });
             const block = effective.baseagents?.[ba];
             if (ba === 'codex')
                 return block?.effort ?? block?.reasoning;
@@ -257,7 +257,8 @@ export class EvolAgent {
         this.persist();
     }
     setLifecycle(value) {
-        this.rawAgent = withLifecycleForWrite(this.rawAgent, value);
+        const current = cfgRead(ConfigTarget.Agent, { self: this.aid });
+        this.rawAgent = withLifecycleForWrite(current || this.rawAgent, value);
         this.rawAgent.$schema_version = Math.max(this.rawAgent.$schema_version || 0, this.merged.$schema_version || 0);
         this.merged.lifecycle = value;
         delete this.merged.initialized;
@@ -318,6 +319,10 @@ export class EvolAgent {
         this.rawAgent = rawAgent;
         this.merged = merged;
     }
+    /** Reload uses the current object references as an in-memory rollback snapshot. */
+    captureConfigSnapshot() {
+        return { rawAgent: this.rawAgent, merged: this.merged };
+    }
     // ── 内部辅助 ─────────────────────────────────────────────────────────
     /**
      * 找 rawAgent.channels 里的可变实例，用于写入。

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

@@ -1,4 +1,5 @@
 import { normalizeBaseagent, resolveAnthropicDirectConfig, resolveEcagentConfig, resolveOpenaiDirectConfig, } from '../../agents/baseagent.js';
+import { buildModelRequestHeaders } from '../../agents/request-identity.js';
 function apiEndpoint(baseUrl, resource) {
     const configured = baseUrl?.trim();
     if (!configured)
@@ -119,12 +120,25 @@ export class EcagentTextInferenceProvider {
     baseagent = 'ecagent';
     constructor(config) {
         this.config = config;
+        this.config = {
+            ...config,
+            headers: buildModelRequestHeaders({
+                baseagent: 'ecagent',
+                baseUrl: config.baseUrl,
+                agentAid: config.evolcoreAgentAid,
+                configuredHeaders: config.headers,
+            }),
+        };
     }
     async completeText(request) {
         const response = await fetch(apiEndpoint(this.config.baseUrl, 'chat/completions'), {
             method: 'POST',
             signal: request.signal,
-            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.apiKey}` },
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.config.apiKey}`,
+                ...this.config.headers,
+            },
             body: JSON.stringify({
                 model: request.model,
                 messages: [{ role: 'system', content: request.system }, { role: 'user', content: request.input }],
@@ -150,15 +164,35 @@ export function createTextInferenceProvider(baseagent, config) {
     const canonical = normalizeBaseagent(baseagent).canonical;
     if (canonical === 'claude') {
         const resolved = resolveAnthropicDirectConfig(config.baseagents?.claude);
-        return resolved ? new AnthropicTextInferenceProvider(resolved) : undefined;
+        return resolved ? new AnthropicTextInferenceProvider({
+            ...resolved,
+            headers: buildModelRequestHeaders({
+                baseagent: 'claude',
+                baseUrl: resolved.baseUrl,
+                agentAid: config.aid,
+                configuredHeaders: resolved.headers,
+            }),
+        }) : undefined;
     }
     if (canonical === 'codex') {
         const resolved = resolveOpenaiDirectConfig(config.baseagents?.codex);
-        return resolved ? new OpenAITextInferenceProvider(resolved) : undefined;
+        return resolved ? new OpenAITextInferenceProvider({
+            ...resolved,
+            headers: buildModelRequestHeaders({
+                baseagent: 'codex',
+                baseUrl: resolved.baseUrl,
+                agentAid: config.aid,
+                configuredHeaders: resolved.headers,
+            }),
+        }) : undefined;
     }
     if (canonical === 'ecagent') {
         try {
-            const resolved = resolveEcagentConfig({ agents: { ecagent: config.baseagents?.ecagent } }, config.baseagents?.ecagent);
+            const override = {
+                ...(config.baseagents?.ecagent ?? {}),
+                evolcoreAgentAid: config.aid,
+            };
+            const resolved = resolveEcagentConfig({ agents: { ecagent: override } }, override);
             return new EcagentTextInferenceProvider(resolved);
         }
         catch {

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

@@ -760,7 +760,7 @@ export class MessageBridge {
                         channelKey,
                         channelType: msg.channelType || effectiveChannelType,
                         channelId: msg.channelId,
-                        recipientId: actorId,
+                        recipientId: roleDetail.actor.principalId || actorId,
                         recipientName: msg.peerName,
                         source: 'inbound',
                     });

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

@@ -229,6 +229,27 @@ function formatTimestampMs(epochMs) {
 export function messageLogPath(chatDir) {
     return path.join(chatDir, MESSAGE_LOG_FILE);
 }
+export function hasMessageLogOperation(chatDir, operationId) {
+    const file = messageLogPath(chatDir);
+    if (!fs.existsSync(file))
+        return false;
+    try {
+        return fs.readFileSync(file, 'utf-8').split('\n').some(line => {
+            if (!line.trim())
+                return false;
+            try {
+                const entry = JSON.parse(line);
+                return entry?.dir === 'out' && entry.operationId === operationId;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return false;
+    }
+}
 export function resolveChatDir(sessionsDir, channelType, channelId, selfAID) {
     return chatDirPath(sessionsDir, channelType, channelId, selfAID);
 }
@@ -323,6 +344,7 @@ export function buildOutboundEntry(opts) {
         transport: opts.transport,
         peerType: opts.peerType,
         source: opts.source ?? 'daemon',
+        operationId: opts.operationId,
         handoff_trace: opts.handoff_trace,
     };
 }

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

@@ -1361,9 +1361,9 @@ export class MessageQueue {
     isAgentMuted(agentName) {
         return this.mutedAgents.has(agentName);
     }
-    /** 中断指定 agent 所有正在处理中的会话。 */
-    interruptByAgent(agentName) {
+    beginAgentInterrupt(agentName) {
         let interrupted = 0;
+        const barriers = [];
         for (const [queueKey, name] of this.processingAgent) {
             if ((name || DEFAULT_AGENT_NAME) === agentName) {
                 interrupted++;
@@ -1378,11 +1378,26 @@ export class MessageQueue {
                     causation: this.activeBatches.get(queueKey)?.message.causation,
                 });
                 if (this.interruptCallback) {
-                    void this.triggerInterrupt(queueKey, sessionKey, activeState?.baseagent, name, 'stop');
+                    barriers.push(this.triggerInterrupt(queueKey, sessionKey, activeState?.baseagent, name, 'stop'));
                 }
             }
         }
-        return interrupted;
+        return {
+            count: interrupted,
+            barrier: Promise.allSettled(barriers).then(() => undefined),
+        };
+    }
+    /** 中断指定 agent 所有正在处理中的会话。 */
+    interruptByAgent(agentName) {
+        const interruption = this.beginAgentInterrupt(agentName);
+        void interruption.barrier;
+        return interruption.count;
+    }
+    /** 中断指定 agent 的会话，并等待 runner 中断屏障完成。 */
+    async interruptByAgentAndWait(agentName) {
+        const interruption = this.beginAgentInterrupt(agentName);
+        await interruption.barrier;
+        return interruption.count;
     }
     // ── Queue query/management methods ──
     /**