evolcore 0.0.3 → 0.0.4

package/dist/core/handoff/runtime.js

@@ -5,6 +5,10 @@ import { KeyedFairMutex } from './mutex.js';
 import { HandoffStore } from './store.js';
 import { createRootCausation, deriveCausation, normalizeCausation } from '../causation/context.js';
 import { recordCausationSpan } from '../causation/audit.js';
+import { logger } from '../../utils/logger.js';
+const HANDOFF_STALE_WARN_MS = 72 * 60 * 60 * 1000;
+const HANDOFF_LARGE_AGGREGATE_COUNT = 10;
+const HANDOFF_LARGE_AGGREGATE_CHARS = 50_000;
 export class HandoffTargetBlockedError extends Error {
     blockingHandoffId;
     attentionReason;
@@ -25,6 +29,20 @@ export class HandoffDeliveryFailedError extends Error {
         this.name = 'HandoffDeliveryFailedError';
     }
 }
+export class HandoffReturnPolicyRequiredError extends Error {
+    code = 'HANDOFF_RETURN_POLICY_REQUIRED';
+    constructor() {
+        super('跨会话 ec msg/group send 必须显式指定 --return none|required');
+        this.name = 'HandoffReturnPolicyRequiredError';
+    }
+}
+export class TriggerHandoffRequiredForbiddenError extends Error {
+    code = 'TRIGGER_HANDOFF_REQUIRED_FORBIDDEN';
+    constructor() {
+        super('Trigger 的跨会话 ec msg/group send 只允许 --return none，不能使用 required');
+        this.name = 'TriggerHandoffRequiredForbiddenError';
+    }
+}
 export class HandoffRuntime {
     sessionManager;
     messageQueue;
@@ -32,6 +50,8 @@ export class HandoffRuntime {
     mutexes = new KeyedFairMutex();
     dispatcher;
     now;
+    staleWarned = new Set();
+    largeAggregateWarned = new Set();
     constructor(sessionManager, messageQueue, sender, store = new HandoffStore(), options = {}) {
         this.sessionManager = sessionManager;
         this.messageQueue = messageQueue;
@@ -56,6 +76,11 @@ export class HandoffRuntime {
         if (target.id === origin.id) {
             return { crossSession: false, targetSession: target };
         }
+        if (!input.explicitReturnPolicy)
+            throw new HandoffReturnPolicyRequiredError();
+        if (input.explicitReturnPolicy === 'required' && input.causation?.trigger?.path.length) {
+            throw new TriggerHandoffRequiredForbiddenError();
+        }
         await this.dispatcher.expireTargetQueued(input.selfAid, target.id);
         throwIfAborted(input.signal);
         const head = this.store.listByTarget(input.selfAid, target.id, 'queued')[0];
@@ -91,7 +116,8 @@ export class HandoffRuntime {
     }
     hasOpenTarget(selfAid, targetSessionId) {
         return this.store.listByTarget(selfAid, targetSessionId)
-            .some(instance => instance.state === 'target_sent' || instance.state === 'return_pending');
+            .some(instance => instance.state === 'target_sent'
+            || (instance.state === 'return_pending' && instance.return_policy === 'required'));
     }
     async bindReply(input) {
         const key = `${input.selfAid}\u0000${input.targetSessionId}`;
@@ -105,6 +131,8 @@ export class HandoffRuntime {
                 responseMessageId: input.responseMessageId,
                 refMessageId: input.refMessageId,
             });
+            for (const instance of attached)
+                this.warnIfStale(instance);
             const handoffIds = attached.map(instance => instance.handoff_id);
             return {
                 candidate: handoffIds.length > 0,
@@ -157,6 +185,7 @@ export class HandoffRuntime {
             messageId,
             timestamp: Date.now(),
             source: 'handoff',
+            boundSessionId: origin.id,
             causation: instance.return_causation
                 ? deriveCausation(instance.return_causation)
                 : instance.causation
@@ -186,55 +215,120 @@ export class HandoffRuntime {
         }
     }
     buildPromptItem(message) {
-        const delivery = message.handoffDelivery;
-        const selfAid = message.selfAID;
-        if (!delivery || !selfAid)
-            return null;
-        const instance = this.store.get(selfAid, delivery.handoffId);
-        if (!instance)
-            return null;
-        if (delivery.direction === 'target' && instance.state !== 'return_pending')
-            return null;
-        if (delivery.direction === 'origin' && instance.state !== 'origin_delivered')
-            return null;
-        return {
-            kind: 'handoff',
-            peerId: message.peerId,
-            peerName: message.peerName,
-            peerType: message.peerType,
-            content: message.content,
-            timestamp: message.timestamp,
-            causation: message.causation,
-            handoff: {
-                kind: delivery.direction === 'target' ? 'request_to_target' : 'response_to_origin',
-                handoffId: instance.handoff_id,
-                previousContent: this.requestSummary(instance),
-                previousMessageId: instance.target_message_id,
-                returnPolicy: instance.return_policy,
-            },
-        };
+        return this.buildPromptItems(message)[0] ?? null;
     }
     buildPromptItems(message) {
         const delivery = message.handoffDelivery;
-        if (!delivery)
+        const selfAid = message.selfAID;
+        if (!delivery || !selfAid)
             return [];
         const ids = delivery.handoffIds?.length ? delivery.handoffIds : [delivery.handoffId];
-        const items = [];
+        const instances = [];
         for (const handoffId of ids) {
-            const item = this.buildPromptItem({
-                ...message,
-                handoffDelivery: { direction: delivery.direction, handoffId },
-            });
-            if (item)
-                items.push(item);
+            const instance = this.store.get(selfAid, handoffId);
+            if (!instance || instance.attention_required)
+                continue;
+            if (delivery.direction === 'target') {
+                const expectedState = instance.return_policy === 'none'
+                    ? 'target_context_pending'
+                    : 'return_pending';
+                if (instance.state !== expectedState)
+                    continue;
+            }
+            else if (instance.state !== 'origin_delivered') {
+                continue;
+            }
+            instances.push(instance);
+        }
+        if (instances.length === 0)
+            return [];
+        if (delivery.direction === 'origin') {
+            this.warnIfLargeAggregate(message, instances, 'origin');
+            const first = instances[0];
+            return [{
+                    kind: 'handoff',
+                    peerId: message.peerId,
+                    peerName: message.peerName,
+                    peerType: message.peerType,
+                    content: message.content,
+                    timestamp: message.timestamp,
+                    causation: message.causation,
+                    handoff: {
+                        kind: 'response_to_origin',
+                        handoffId: first.handoff_id,
+                        handoffIds: instances.map(instance => instance.handoff_id),
+                        originEntries: instances.map(instance => ({
+                            previousContent: this.requestSummary(instance),
+                            responseContent: instance.return_content ?? '',
+                            previousMessageId: instance.target_message_id,
+                        })),
+                        previousContent: this.requestSummary(first),
+                        previousMessageId: first.target_message_id,
+                        returnPolicy: first.return_policy,
+                    },
+                }];
         }
-        return items;
+        const requiredEntries = instances
+            .filter(instance => instance.return_policy === 'required')
+            .map(instance => ({
+            handoffId: instance.handoff_id,
+            previousContent: this.requestSummary(instance),
+            previousMessageId: instance.target_message_id,
+        }));
+        const contextEntries = instances
+            .filter(instance => instance.return_policy === 'none')
+            .map(instance => ({
+            previousContent: this.requestSummary(instance),
+            previousMessageId: instance.target_message_id,
+        }));
+        this.warnIfLargeAggregate(message, instances, 'target');
+        const first = instances[0];
+        return [{
+                kind: 'handoff',
+                peerId: message.peerId,
+                peerName: message.peerName,
+                peerType: message.peerType,
+                content: message.content,
+                timestamp: message.timestamp,
+                causation: message.causation,
+                handoff: {
+                    kind: 'request_to_target',
+                    handoffId: first.handoff_id,
+                    handoffIds: instances.map(instance => instance.handoff_id),
+                    requiredEntries,
+                    contextEntries,
+                    previousContent: this.requestSummary(first),
+                    previousMessageId: first.target_message_id,
+                    returnPolicy: requiredEntries.length > 0 ? 'required' : 'none',
+                },
+            }];
     }
     completeOriginContext(selfAid, handoffId) {
         const instance = this.store.get(selfAid, handoffId);
         if (instance?.state === 'origin_delivered')
             this.store.completeOriginContext(selfAid, handoffId);
     }
+    completeTargetContext(selfAid, handoffId) {
+        const instance = this.store.get(selfAid, handoffId);
+        if (instance?.state === 'target_context_pending' && instance.return_policy === 'none') {
+            this.store.completeTargetContext(selfAid, handoffId);
+        }
+    }
+    validateTargetSessionBinding(selfAid, handoffIds, executionSessionId) {
+        const invalidHandoffIds = [];
+        for (const handoffId of handoffIds) {
+            const instance = this.store.get(selfAid, handoffId);
+            if (!instance
+                || instance.target_session_id !== executionSessionId
+                || instance.consumed_target_session_id !== executionSessionId) {
+                invalidHandoffIds.push(handoffId);
+                if (instance && !instance.attention_required) {
+                    this.store.markAttention(selfAid, handoffId, 'HANDOFF_SESSION_BINDING_MISMATCH');
+                }
+            }
+        }
+        return { ok: invalidHandoffIds.length === 0, invalidHandoffIds };
+    }
     status(selfAid, handoffId) {
         return this.store.status(selfAid, handoffId);
     }
@@ -276,6 +370,10 @@ export class HandoffRuntime {
     async recover(selfAids) {
         const originEnqueues = [];
         for (const selfAid of selfAids) {
+            // v1 initially represented return=none as return_pending and required an
+            // empty manual return. It has already been shown to a target turn, so
+            // finish it before version reconciliation instead of prompting again.
+            this.store.migrateLegacyNonePending(selfAid, this.now?.());
             this.expireQueued([selfAid]);
             const events = this.store.events(selfAid);
             const lastSendEvent = new Map();
@@ -285,6 +383,7 @@ export class HandoffRuntime {
                 }
             }
             for (const instance of this.store.list(selfAid)) {
+                this.warnIfStale(instance);
                 const versionedEvents = events.filter(event => event.handoff_id === instance.handoff_id && event.to_version !== undefined);
                 const latestEventVersion = versionedEvents.reduce((latest, event) => Math.max(latest, event.to_version ?? 0), 0);
                 if (latestEventVersion !== instance.version) {
@@ -313,6 +412,32 @@ export class HandoffRuntime {
         }
         await Promise.all(originEnqueues);
     }
+    warnIfStale(instance) {
+        if (instance.state !== 'target_sent' && instance.state !== 'return_pending')
+            return;
+        const ageMs = (this.now?.() ?? Date.now()) - instance.created_at;
+        const key = instance.handoff_id;
+        if (ageMs < HANDOFF_STALE_WARN_MS || this.staleWarned.has(key))
+            return;
+        this.staleWarned.add(key);
+        logger.warn(`[Handoff] stale open handoff id=${instance.handoff_id}`
+            + ` state=${instance.state} returnPolicy=${instance.return_policy}`
+            + ` ageHours=${Math.floor(ageMs / 3_600_000)}`
+            + ` originSession=${instance.origin_session_id} targetSession=${instance.target_session_id}`);
+    }
+    warnIfLargeAggregate(message, instances, direction) {
+        const chars = message.content.length
+            + instances.reduce((total, instance) => total + this.requestSummary(instance).length, 0);
+        if (instances.length < HANDOFF_LARGE_AGGREGATE_COUNT && chars < HANDOFF_LARGE_AGGREGATE_CHARS)
+            return;
+        const key = `${message.messageId ?? '<none>'}:${instances.map(instance => instance.handoff_id).join(',')}`;
+        if (this.largeAggregateWarned.has(key))
+            return;
+        this.largeAggregateWarned.add(key);
+        logger.warn(`[Handoff] large prompt aggregate direction=${direction}`
+            + ` session=${direction === 'target' ? instances[0].target_session_id : instances[0].origin_session_id}`
+            + ` count=${instances.length} chars=${chars} responseMessage=${message.messageId ?? '<none>'}`);
+    }
     requestSummary(instance) {
         return classifyAunPayloadForLog(instance.request.payload).content || '[payload]';
     }

package/dist/core/handoff/store.js

@@ -272,7 +272,8 @@ export class HandoffStore {
     }
     attachSessionContext(input) {
         const open = this.listByTarget(input.selfAid, input.targetSessionId)
-            .filter(item => (item.state === 'target_sent' || item.state === 'return_pending') && !item.attention_required)
+            .filter(item => (item.state === 'target_sent'
+            || (item.state === 'return_pending' && item.return_policy === 'required')) && !item.attention_required)
             .sort((left, right) => {
             const leftRef = input.refMessageId && left.target_message_id === input.refMessageId ? 0 : 1;
             const rightRef = input.refMessageId && right.target_message_id === input.refMessageId ? 0 : 1;
@@ -283,7 +284,9 @@ export class HandoffStore {
             const previousVersion = instance.version;
             const firstAttachment = instance.state === 'target_sent';
             if (firstAttachment) {
-                instance.state = 'return_pending';
+                instance.state = instance.return_policy === 'none'
+                    ? 'target_context_pending'
+                    : 'return_pending';
                 instance.response_message_id = input.responseMessageId;
                 instance.consumed_at = now;
                 instance.consumed_target_session_id = input.targetSessionId;
@@ -308,6 +311,47 @@ export class HandoffStore {
     bindExactReply(input) {
         return this.attachSessionContext(input)[0] ?? null;
     }
+    completeTargetContext(selfAid, handoffId, now = Date.now()) {
+        const instance = this.requireState(selfAid, handoffId, 'target_context_pending');
+        if (instance.return_policy !== 'none') {
+            throw new Error('target context auto-completion requires return=none');
+        }
+        const previous = instance.version;
+        instance.state = 'completed';
+        instance.version++;
+        instance.updated_at = now;
+        instance.completed_at = now;
+        this.appendEvent(selfAid, 'target_context_consumed', handoffId, {
+            operationKey: instance.response_message_id ?? undefined,
+            fromVersion: previous,
+            toVersion: instance.version,
+            now,
+        });
+        this.write(selfAid, instance);
+        return instance;
+    }
+    migrateLegacyNonePending(selfAid, now = Date.now()) {
+        const migrated = [];
+        for (const instance of this.list(selfAid)) {
+            if (instance.return_policy !== 'none' || instance.state !== 'return_pending')
+                continue;
+            const previous = instance.version;
+            instance.state = 'completed';
+            instance.version++;
+            instance.updated_at = now;
+            instance.completed_at = now;
+            this.appendEvent(selfAid, 'target_context_consumed', instance.handoff_id, {
+                operationKey: instance.response_message_id ?? undefined,
+                fromVersion: previous,
+                toVersion: instance.version,
+                details: { migration: true, previous_state: 'return_pending' },
+                now,
+            });
+            this.write(selfAid, instance);
+            migrated.push(instance);
+        }
+        return migrated;
+    }
     returnHandoff(input) {
         const selected = this.selectReturnCandidate(input);
         if ('ok' in selected)

package/dist/core/handoff/types.js

@@ -3,6 +3,7 @@ export const HANDOFF_STATES = [
     'queued',
     'failed',
     'target_sent',
+    'target_context_pending',
     'return_pending',
     'origin_queued',
     'origin_delivered',

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

@@ -1,10 +1,9 @@
-import { createHash } from 'crypto';
-import { resolveAnthropicConfig, resolveOpenaiConfig, } from '../../agents/baseagent.js';
-const MODEL_LIST_TTL_MS = 5 * 60 * 1000;
-const MODEL_LIST_MAX_PAGES = 20;
-const anthropicModelListCache = new Map();
-function apiEndpoint(baseUrl, defaultBaseUrl, resource) {
-    const base = (baseUrl || defaultBaseUrl).replace(/\/+$/, '');
+import { normalizeBaseagent, resolveAnthropicDirectConfig, resolveOpenaiDirectConfig, } from '../../agents/baseagent.js';
+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}`;
 }
 async function parseError(response) {
@@ -28,53 +27,8 @@ export class AnthropicTextInferenceProvider {
     constructor(config) {
         this.config = config;
     }
-    async listModels(signal) {
-        const cacheKey = this.modelListCacheKey();
-        const cached = anthropicModelListCache.get(cacheKey);
-        if (cached && Date.now() - cached.fetchedAt < MODEL_LIST_TTL_MS)
-            return [...cached.models];
-        const models = [];
-        const seen = new Set();
-        let afterId;
-        for (let page = 0; page < MODEL_LIST_MAX_PAGES; page++) {
-            const endpoint = new URL(apiEndpoint(this.config.baseUrl, 'https://api.anthropic.com', 'models'));
-            endpoint.searchParams.set('limit', '100');
-            if (afterId)
-                endpoint.searchParams.set('after_id', afterId);
-            const response = await fetch(endpoint, {
-                method: 'GET',
-                signal,
-                headers: this.headers(),
-            });
-            if (!response.ok)
-                throw await parseError(response);
-            const body = await response.json();
-            const entries = Array.isArray(body.data)
-                ? body.data
-                : (Array.isArray(body.models) ? body.models : []);
-            for (const entry of entries) {
-                const id = typeof entry === 'string'
-                    ? entry
-                    : entry?.id || entry?.name || entry?.model;
-                if (typeof id !== 'string' || !id.trim() || seen.has(id))
-                    continue;
-                seen.add(id);
-                models.push(id);
-            }
-            if (body.has_more !== true)
-                break;
-            const next = typeof body.last_id === 'string' && body.last_id ? body.last_id : undefined;
-            if (!next || next === afterId)
-                throw new Error('Claude model list pagination returned no next cursor');
-            afterId = next;
-        }
-        if (models.length === 0)
-            throw new Error('Claude model list API returned no models');
-        anthropicModelListCache.set(cacheKey, { models, fetchedAt: Date.now() });
-        return [...models];
-    }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'https://api.anthropic.com', 'messages'), {
+        const response = await fetch(apiEndpoint(this.config.baseUrl, 'messages'), {
             method: 'POST',
             signal: request.signal,
             headers: this.headers(),
@@ -83,6 +37,7 @@ export class AnthropicTextInferenceProvider {
                 max_tokens: 256,
                 system: request.system,
                 messages: [{ role: 'user', content: request.input }],
+                ...(request.effort ? { output_config: { effort: request.effort } } : {}),
             }),
         });
         if (!response.ok)
@@ -106,14 +61,6 @@ export class AnthropicTextInferenceProvider {
             Authorization: `Bearer ${this.config.apiKey}`,
         };
     }
-    modelListCacheKey() {
-        const endpoint = apiEndpoint(this.config.baseUrl, 'https://api.anthropic.com', 'models');
-        const credential = createHash('sha256').update(this.config.apiKey).digest('hex');
-        return `${endpoint}\0${credential}`;
-    }
-}
-export function _resetTextInferenceModelCacheForTests() {
-    anthropicModelListCache.clear();
 }
 export class OpenAITextInferenceProvider {
     config;
@@ -122,7 +69,7 @@ export class OpenAITextInferenceProvider {
         this.config = config;
     }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'https://api.openai.com', 'responses'), {
+        const response = await fetch(apiEndpoint(this.config.baseUrl, 'responses'), {
             method: 'POST',
             signal: request.signal,
             headers: {
@@ -155,19 +102,14 @@ export class OpenAITextInferenceProvider {
     }
 }
 export function createTextInferenceProvider(baseagent, config) {
-    if (baseagent === 'claude') {
-        const override = config.baseagents?.claude;
-        if (!override)
-            return undefined;
-        const synthetic = { agents: { claude: override } };
-        return new AnthropicTextInferenceProvider(resolveAnthropicConfig(synthetic, override));
+    const canonical = normalizeBaseagent(baseagent).canonical;
+    if (canonical === 'claude') {
+        const resolved = resolveAnthropicDirectConfig(config.baseagents?.claude);
+        return resolved ? new AnthropicTextInferenceProvider(resolved) : undefined;
     }
-    if (baseagent === 'codex') {
-        const override = config.baseagents?.codex;
-        if (!override)
-            return undefined;
-        const synthetic = { agents: { codex: override } };
-        return new OpenAITextInferenceProvider(resolveOpenaiConfig(synthetic, override));
+    if (canonical === 'codex') {
+        const resolved = resolveOpenaiDirectConfig(config.baseagents?.codex);
+        return resolved ? new OpenAITextInferenceProvider(resolved) : undefined;
     }
     return undefined;
 }

package/dist/core/message/file-markers.js

@@ -0,0 +1,7 @@
+/**
+ * A file marker may contain surrounding whitespace inside its brackets so
+ * formatted responses such as `[ SEND_FILE:./report.md ]` remain actionable.
+ */
+export function createSendFileMarkerPattern() {
+    return /\[\s*SEND_FILE:(?:(\w+):)?([^\]]*?\S[^\]]*?)\s*\]/g;
+}

package/dist/core/message/im-renderer.js

@@ -1,6 +1,6 @@
 import { logger } from '../../utils/logger.js';
 import { summarizeToolInput } from '../../utils/tool-summary.js';
-import { CONTEXT_TOO_LONG_PATTERN, getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
+import { getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
 import fs from 'fs';
 import path from 'path';
 import { resolvePaths } from '../../paths.js';
@@ -289,6 +289,22 @@ export class IMRenderer {
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
+    /** interactive 下，以普通非最终文本发送用户需要看到的运行状态。 */
+    async sendOperationalNoticeAsText(text) {
+        if (!this.opts.operationalNoticesAsText || this.opts.envelope.chatmode === 'proactive' || !text)
+            return false;
+        // 保持与流式正文的到达顺序：先发出已缓冲的正文，再投影运行状态。
+        await this.flushText();
+        const payload = { kind: 'result.text', text, isFinal: false };
+        this.sentContent = true;
+        this.sendChain = this.sendChain
+            .then(() => this.opts.send(payload))
+            .catch(e => logger.warn('[IMRenderer] notice text send failed:', e));
+        await this.sendChain;
+        this.lastFlush = Date.now();
+        this.flushCount++;
+        return true;
+    }
     // ── 内部：interactive 模式聚合窗口 ──
     synthCallId() {
         return `synth-${this.opts.envelope.taskId}-${++this.syntheticCallSeq}`;
@@ -387,18 +403,6 @@ export class IMRenderer {
                     item.text = item.text.replace(this.opts.fileMarkerPattern, '');
             }
         }
-        if (isFinal) {
-            // 上下文错误短语过滤：剔除错误关键词本身，保留前后内容。
-            // 只在最终 flush 清理，避免中间定时 flush trim 掉 Markdown 块级换行。
-            const ctxErrPattern = new RegExp(CONTEXT_TOO_LONG_PATTERN.source, 'gi');
-            const stripCtxErr = (s) => s.replace(ctxErrPattern, '').trim();
-            this.textBuffer = stripCtxErr(this.textBuffer);
-            this.allText = stripCtxErr(this.allText);
-            for (const item of this.itemsQueue) {
-                if (item.kind === 'text')
-                    item.text = stripCtxErr(item.text);
-            }
-        }
         // 清掉空 text items
         const items = this.itemsQueue.filter(it => {
             if (it.kind === 'text')
@@ -419,7 +423,7 @@ export class IMRenderer {
             });
         }
         // 1. interactive 模式下：不发 text items（由 result.text 统一发送最终文本）
-        let itemsForBatch = this.suppressActivityItems() ? [] : items.filter(it => it.kind !== 'text');
+        const itemsForBatch = this.suppressActivityItems() ? [] : items.filter(it => it.kind !== 'text');
         if (itemsForBatch.length > 0) {
             const payload = { kind: 'activity.batch', items: itemsForBatch };
             this.sentContent = true;