evolcore 0.0.1 → 0.0.3

package/dist/response-system/engines/v1/proactive-flow.js

@@ -0,0 +1,137 @@
+/**
+ * V1 引擎 —— 主动流（proactive）
+ *
+ * 行为自合并前的 modes/proactive（ProactiveMode）下沉，语义不变：
+ * 工具调用才回复，普通文本作为思考过程（thought 投影）；含首发表态、
+ * 工具汇报提醒、队列未读提醒、Unknown skill 兜底。
+ *
+ * flow 是无状态单例：per-message 运行时状态存 ctx.state['proactive']，
+ * 依赖全部由调用点显式传入。
+ */
+const STATE_KEY = 'proactive';
+const TOOL_REPORT_INTERVAL = 10;
+function isHumanFacingMessage(message) {
+    if (message.source === 'trigger')
+        return false;
+    if (message.chatType === 'group')
+        return true;
+    return message.chatType === 'private' && message.peerType === 'human';
+}
+function buildState(message, cfg) {
+    // 默认值不在此硬编码：候选/出厂默认由模式 schema 声明，宿主组装 modeConfig 时注入
+    // （coordinator.schemaDefaults）。此处只读注入后的布尔——键缺失即视为关闭。
+    const preTool1stMsgChk = cfg.pre_tool_1stmsgchk === true;
+    const toolUseReminder = cfg.tool_use_reminder === true;
+    const humanFacing = isHumanFacingMessage(message);
+    return {
+        firstToolDone: false,
+        toolCount: 0,
+        lastQueueReminderLen: 0,
+        chatType: message.chatType,
+        peerType: message.peerType,
+        preTool1stMsgChk,
+        toolUseReminder,
+        firstSendRequired: preTool1stMsgChk && humanFacing,
+        toolReportRequired: toolUseReminder && humanFacing,
+        toolReportInterval: TOOL_REPORT_INTERVAL,
+        toolReportPending: false,
+    };
+}
+export const proactiveFlow = {
+    chatMode: 'proactive',
+    // ─── 入站决策：构造 runtimeState ───
+    handleInbound(message, ctx) {
+        ctx.logger.debug('[V1Engine] proactive inbound chatType=' + message.chatType + ' peerId=' + message.peerId);
+        const state = buildState(message, ctx.modeConfig ?? {});
+        return {
+            action: 'process',
+            queueBehavior: 'enqueue',
+            runtimeState: { proactive: state },
+        };
+    },
+    // ─── 出站决策：activity.batch → thought 投影 ───
+    handleOutbound(payload, ctx) {
+        ctx.logger.debug('[V1Engine] proactive outbound kind=' + (payload.kind ?? 'unknown'));
+        if (payload.kind === 'activity.batch') {
+            if (!ctx.channel.capabilities.supportsThought) {
+                return { method: 'suppress', reason: 'channel does not support thought' };
+            }
+            return { method: 'direct', type: 'thought' };
+        }
+        return { method: 'direct', type: 'message' };
+    },
+    // ─── beforeProcess：把 runtimeState 落入 ctx.state，供后续钩子共享 ───
+    beforeProcess(ctx) {
+        const state = buildState(ctx.message, ctx.modeConfig ?? {});
+        ctx.state.set(STATE_KEY, state);
+    },
+    // ─── configureRun：policyHook 首工具表态 ───
+    configureRun(ctx) {
+        const state = ctx.state.get(STATE_KEY);
+        if (!state || (!state.firstSendRequired && !state.toolReportRequired))
+            return undefined;
+        return {
+            policyHook: (toolName, toolInput) => {
+                const isSendCommand = ctx.isSendCommand(toolName, toolInput);
+                if (state.firstSendRequired && !state.firstToolDone) {
+                    if (!isSendCommand) {
+                        const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
+                        const target = state.chatType === 'group' ? '群里' : '对方';
+                        return { block: true, reason: `请先用 ${cmdHint} 向${target}说明你的意图，再执行其他工具` };
+                    }
+                    state.firstToolDone = true;
+                }
+                if (state.toolReportPending) {
+                    if (!isSendCommand) {
+                        const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
+                        const target = state.chatType === 'group' ? '群里' : '对方';
+                        return { block: true, reason: `工具调用已达到 ${state.toolCount} 次，请先用 ${cmdHint} 向${target}汇报当前情况和下一步意图，再执行其他工具` };
+                    }
+                    state.toolReportPending = false;
+                }
+                return undefined;
+            },
+        };
+    },
+    // ─── onToolUse：队列未读提醒 + 工具汇报提醒 ───
+    onToolUse(ctx) {
+        const state = ctx.state.get(STATE_KEY);
+        if (!state || !state.toolUseReminder)
+            return;
+        // 队列未读变化提醒
+        const queueLen = ctx.getQueueLength();
+        if (queueLen !== state.lastQueueReminderLen) {
+            state.lastQueueReminderLen = queueLen;
+            if (queueLen > 0) {
+                const queueMsg = queueLen >= 5
+                    ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
+                    : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
+                ctx.injectToModel(queueMsg);
+            }
+        }
+        // 工具计数（排除表态命令白名单）
+        const isAllowedTool = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
+        if (state.toolReportRequired && !isAllowedTool)
+            state.toolCount++;
+        // 每 N 次工具调用警告
+        if (state.toolReportRequired && state.toolCount > 0 && state.toolCount % state.toolReportInterval === 0) {
+            state.toolReportPending = true;
+            const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
+            const target = state.chatType === 'group' ? '群里' : '对方';
+            ctx.injectToModel(`⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`);
+        }
+    },
+    // ─── onComplete：标志位检查 ───
+    async onComplete(ctx) {
+        if (/\[PROACTIVE:REPLY_CONFIRMED_(SENT|NONE)\]/.test(ctx.lastReplyText)) {
+            await ctx.updateSessionMeta({ lastProactiveFlag: true });
+        }
+    },
+    // ─── afterProcess：Unknown skill 兜底 ───
+    async afterProcess(ctx) {
+        if (!ctx.streamResult.hasReceivedText && /^Unknown skill:\s+\S+/i.test(ctx.fullText.trim())) {
+            // SDK 本地兜底：直接发送绕过 silent renderer
+            await ctx.send({ kind: 'result.text', text: ctx.fullText, isFinal: true });
+        }
+    },
+};

package/dist/response-system/engines/v1/types.js

@@ -0,0 +1 @@
+export {};

package/dist/response-system/extensions.js

@@ -0,0 +1,41 @@
+/**
+ * Response Mode System - Extension Capabilities
+ *
+ * 扩展能力接口：采用可选接口模式（方案 B）
+ * - 简单模式不需要实现用不到的方法
+ * - 通过类型守卫判断能力（'methodName' in mode）
+ * - 接口职责单一，符合接口隔离原则
+ */
+// ============================================================================
+// 类型守卫工具
+// ============================================================================
+/**
+ * 检查模式是否支持辅助会话
+ */
+export function hasAuxiliarySession(mode) {
+    return typeof mode === 'object' && mode !== null && 'getAuxiliarySession' in mode;
+}
+/**
+ * 检查模式是否支持线索跟踪
+ */
+export function hasThreadTracking(mode) {
+    return typeof mode === 'object' && mode !== null && 'getThreadManager' in mode;
+}
+/**
+ * 检查模式是否支持工作流
+ */
+export function hasWorkflow(mode) {
+    return typeof mode === 'object' && mode !== null && 'getWorkflowEngine' in mode;
+}
+/**
+ * 检查模式是否支持批量处理
+ */
+export function hasBatchProcessing(mode) {
+    return typeof mode === 'object' && mode !== null && 'processBatch' in mode;
+}
+/**
+ * 检查模式是否支持状态持久化
+ */
+export function hasStatePersistence(mode) {
+    return typeof mode === 'object' && mode !== null && 'saveState' in mode;
+}

package/dist/response-system/index.js

@@ -0,0 +1,6 @@
+/**
+ * Response Mode System - Public API
+ *
+ * 统一导出响应系统的所有公共接口
+ */
+export { hasAuxiliarySession, hasThreadTracking, hasWorkflow, hasBatchProcessing, hasStatePersistence, } from './extensions.js';

package/dist/response-system/modes/index.js

@@ -0,0 +1,7 @@
+import { SingleSessionMode } from './single-session/index.js';
+export function registerBuiltinModes(registry) {
+    // single-session 为首选响应模式（responseMode 解析链的最终兜底）。
+    // 合并了原 interactive/proactive——投递方式由 chatMode 参数决定，不再是独立模式。
+    registry.registerBuiltin(new SingleSessionMode(), true);
+}
+export { SingleSessionMode } from './single-session/index.js';

package/dist/response-system/modes/single-session/index.js

@@ -0,0 +1,72 @@
+import { FIFOQueue } from '../../queues/fifo-queue.js';
+import { flowForChatMode } from '../../engines/v1/index.js';
+import { loadSchema } from '../../../config/schema-registry.js';
+/**
+ * 模式桶 schema —— 候选值与默认值的**唯一事实源**，从 kits/schemas/single-session.schema.1.json
+ * 读取（随包分发、config schema 子命令可展示、write 时桶专项校验共用同一份）。
+ * `default` 即运行时出厂默认，由宿主组装 modeConfig 时提取注入（coordinator.schemaDefaults），
+ * flow 不再硬编码默认。chatMode 无 default——由宿主按 chatmode 场景表解析后强制注入。
+ */
+const CONFIG_SCHEMA = loadSchema('single-session').raw;
+/**
+ * 单会话响应模式（architecture.md §4.1）—— 合并原 interactive / proactive。
+ *
+ * 本层是薄包装：不含处理行为，全部钩子委托 V1 引擎的 flow。chatMode 决定用哪个
+ * flow（interactive / proactive），取值来自 modeConfig.chatMode（宿主按配置层级
+ * 解析后注入，见 implementation-plan.md §三；无 auto 值）。
+ */
+export class SingleSessionMode {
+    id = 'single-session';
+    displayName = '单会话模式';
+    description = '单会话直接响应，按 chatMode 决定投递方式。';
+    type = 'builtin';
+    applicableScenes = ['private', 'group'];
+    configSchema = CONFIG_SCHEMA;
+    queue = new FIFOQueue();
+    context;
+    async initialize(context) {
+        this.context = context;
+        context.logger.debug('[ResponseSystem] single-session initialized chatMode=' + this.chatMode());
+    }
+    async cleanup() { await this.queue.clear(); }
+    /**
+     * 本会话生效的 chatmode——从 modeConfig 读取；缺省 interactive（宿主注入前的兜底）。
+     * 大小写不敏感：宿主注入的是小写 `chatmode`，但兼容历史/外部注入的 `chatMode`
+     * （二者语义同一，不应同时存在）。
+     */
+    chatMode() {
+        const cfg = this.context?.modeConfig;
+        const value = cfg?.chatmode ?? cfg?.chatMode;
+        return value === 'proactive' ? 'proactive' : 'interactive';
+    }
+    flow() {
+        return flowForChatMode(this.chatMode());
+    }
+    async handleInbound(message) {
+        if (!this.context)
+            throw new Error('[single-session] not initialized');
+        return this.flow().handleInbound(message, this.context);
+    }
+    async handleOutbound(payload) {
+        if (!this.context)
+            throw new Error('[single-session] not initialized');
+        return this.flow().handleOutbound(payload, this.context);
+    }
+    getQueue() { return this.queue; }
+    // ─── 处理流程钩子：存在才委托（proactive flow 提供全套，interactive 仅 afterProcess）───
+    beforeProcess(ctx) {
+        return this.flow().beforeProcess?.(ctx);
+    }
+    configureRun(ctx) {
+        return this.flow().configureRun?.(ctx);
+    }
+    onToolUse(ctx) {
+        return this.flow().onToolUse?.(ctx);
+    }
+    onComplete(ctx) {
+        return this.flow().onComplete?.(ctx);
+    }
+    afterProcess(ctx) {
+        return this.flow().afterProcess?.(ctx);
+    }
+}

package/dist/response-system/queues/fifo-queue.js

@@ -0,0 +1,44 @@
+/**
+ * FIFO Queue - First In First Out
+ *
+ * 最简单的队列实现，按入队顺序出队
+ */
+export class FIFOQueue {
+    queue = [];
+    async enqueue(message, priority) {
+        this.queue.push(message);
+    }
+    async dequeue() {
+        return this.queue.shift();
+    }
+    dequeueSync() {
+        return this.queue.shift();
+    }
+    async peek() {
+        return this.queue[0];
+    }
+    peekSync() {
+        return this.queue[0];
+    }
+    size() {
+        return this.queue.length;
+    }
+    async clear() {
+        this.queue = [];
+    }
+    async reorder(strategy) {
+        if (strategy === 'fifo') {
+            // Already FIFO, no-op
+            return;
+        }
+        else if (strategy === 'lifo') {
+            // Reverse the queue
+            this.queue.reverse();
+        }
+        else if (strategy === 'priority') {
+            // Sort by messageId (simple priority: earlier messageId = higher priority)
+            // TODO: 实际应该根据 priority 字段排序，但当前 InboundMessage 没有该字段
+            // 这里先按入队顺序保持不变（等价于 FIFO）
+        }
+    }
+}

package/dist/response-system/queues/index.js

@@ -0,0 +1,6 @@
+/**
+ * Response Mode Queues - Export
+ */
+export { FIFOQueue } from './fifo-queue.js';
+export { LIFOQueue } from './lifo-queue.js';
+export { PriorityQueue } from './priority-queue.js';

package/dist/response-system/queues/lifo-queue.js

@@ -0,0 +1,42 @@
+/**
+ * LIFO Queue - Last In First Out (Stack)
+ *
+ * 后入先出，最新的消息优先处理
+ */
+export class LIFOQueue {
+    queue = [];
+    async enqueue(message, priority) {
+        this.queue.push(message);
+    }
+    async dequeue() {
+        return this.queue.pop(); // ← 从队尾取，实现后进先出
+    }
+    dequeueSync() {
+        return this.queue.pop();
+    }
+    async peek() {
+        return this.queue[this.queue.length - 1];
+    }
+    peekSync() {
+        return this.queue[this.queue.length - 1];
+    }
+    size() {
+        return this.queue.length;
+    }
+    async clear() {
+        this.queue = [];
+    }
+    async reorder(strategy) {
+        if (strategy === 'lifo') {
+            // Already LIFO, no-op
+            return;
+        }
+        else if (strategy === 'fifo') {
+            // Reverse to FIFO order
+            this.queue.reverse();
+        }
+        else if (strategy === 'priority') {
+            // Keep current order (no priority info)
+        }
+    }
+}

package/dist/response-system/queues/priority-queue.js

@@ -0,0 +1,63 @@
+/**
+ * Priority Queue - Priority-based ordering
+ *
+ * 按优先级排序，高优先级优先处理
+ */
+export class PriorityQueue {
+    queue = [];
+    insertCounter = 0;
+    async enqueue(message, priority = 0) {
+        const item = {
+            message,
+            priority,
+            insertOrder: this.insertCounter++,
+        };
+        // 插入排序：按优先级降序，同优先级按插入顺序升序
+        let insertIndex = this.queue.length;
+        for (let i = 0; i < this.queue.length; i++) {
+            if (this.queue[i].priority < priority ||
+                (this.queue[i].priority === priority && this.queue[i].insertOrder > item.insertOrder)) {
+                insertIndex = i;
+                break;
+            }
+        }
+        this.queue.splice(insertIndex, 0, item);
+    }
+    async dequeue() {
+        const item = this.queue.shift();
+        return item?.message;
+    }
+    dequeueSync() {
+        const item = this.queue.shift();
+        return item?.message;
+    }
+    async peek() {
+        return this.queue[0]?.message;
+    }
+    peekSync() {
+        return this.queue[0]?.message;
+    }
+    size() {
+        return this.queue.length;
+    }
+    async clear() {
+        this.queue = [];
+        this.insertCounter = 0;
+    }
+    async reorder(strategy) {
+        if (strategy === 'priority') {
+            // Already priority-sorted, no-op
+            return;
+        }
+        // Extract messages
+        const messages = this.queue.map(item => item.message);
+        if (strategy === 'fifo') {
+            // Sort by insert order (ascending)
+            this.queue.sort((a, b) => a.insertOrder - b.insertOrder);
+        }
+        else if (strategy === 'lifo') {
+            // Sort by insert order (descending)
+            this.queue.sort((a, b) => b.insertOrder - a.insertOrder);
+        }
+    }
+}

package/dist/response-system/registry.js

@@ -0,0 +1,97 @@
+/**
+ * Response Mode Registry
+ *
+ * 响应模式注册表：管理所有已注册的响应模式（内置 + 扩展）。
+ *
+ * 设计：
+ *   - 内置模式（builtin）：随包发布，在启动时注册
+ *   - 扩展模式（extension）：用户自定义，运行时注册
+ *   - 扩展不可覆盖内置（id 冲突时拒绝）
+ */
+export class ResponseModeRegistry {
+    modes = new Map();
+    /** 首选响应模式 id：当关系级/agent 级均未配 responseMode 时的兜底。 */
+    preferredId;
+    /**
+     * 注册内置模式（type 必须为 'builtin'）
+     * @param preferred 标记为首选响应模式（注册表默认）；仅允许一个，重复设置以最后一次为准
+     */
+    registerBuiltin(mode, preferred = false) {
+        if (mode.type !== 'builtin') {
+            throw new Error(`[Registry] registerBuiltin requires type='builtin', got '${mode.type}' for mode '${mode.id}'`);
+        }
+        if (this.modes.has(mode.id)) {
+            throw new Error(`[Registry] mode id '${mode.id}' already registered`);
+        }
+        this.modes.set(mode.id, mode);
+        if (preferred)
+            this.preferredId = mode.id;
+    }
+    /**
+     * 首选响应模式（responseMode 解析链的最终兜底：关系级 > agent 级 > 此项）。
+     * @throws 若从未标记首选模式（启动注册应保证存在）
+     */
+    getPreferred() {
+        if (!this.preferredId) {
+            throw new Error('[Registry] no preferred response mode registered — a builtin must be registered with preferred=true at startup');
+        }
+        const mode = this.modes.get(this.preferredId);
+        if (!mode) {
+            throw new Error(`[Registry] preferred mode '${this.preferredId}' not found in registry`);
+        }
+        return mode;
+    }
+    /** 首选响应模式 id（未设置返回 undefined）。 */
+    getPreferredId() {
+        return this.preferredId;
+    }
+    /**
+     * 注册扩展模式（type 必须为 'extension'，不可覆盖内置）
+     */
+    registerExtension(mode) {
+        if (mode.type !== 'extension') {
+            throw new Error(`[Registry] registerExtension requires type='extension', got '${mode.type}' for mode '${mode.id}'`);
+        }
+        const existing = this.modes.get(mode.id);
+        if (existing) {
+            if (existing.type === 'builtin') {
+                throw new Error(`[Registry] extension '${mode.id}' cannot override builtin mode`);
+            }
+            throw new Error(`[Registry] extension id '${mode.id}' already registered`);
+        }
+        this.modes.set(mode.id, mode);
+    }
+    /**
+     * 注销扩展模式（内置模式不可注销）
+     */
+    unregister(id) {
+        const mode = this.modes.get(id);
+        if (!mode)
+            return;
+        if (mode.type === 'builtin') {
+            throw new Error(`[Registry] cannot unregister builtin mode '${id}'`);
+        }
+        this.modes.delete(id);
+    }
+    /**
+     * 获取指定模式（不存在返回 undefined）
+     */
+    get(id) {
+        return this.modes.get(id);
+    }
+    /**
+     * 列出所有模式（可选按场景过滤）
+     */
+    list(scene) {
+        const all = Array.from(this.modes.values());
+        if (!scene)
+            return all;
+        return all.filter(m => m.applicableScenes.includes(scene));
+    }
+    /**
+     * 是否存在指定模式
+     */
+    has(id) {
+        return this.modes.has(id);
+    }
+}

package/dist/response-system/resolver.js

@@ -0,0 +1,37 @@
+/**
+ * Response Mode Resolver
+ *
+ * 模式解析：决定某个会话该用哪个响应模式。
+ *
+ * responseMode 是**标量**参数，走特殊路线（不同于 chatmode/mentionMode/model 的普通配置链）：
+ * 候选清单与默认值来自**注册表**，不来自 schema。解析优先级（高→低）：
+ *   1. 关系级 responseMode（$RELATIONS_DIR/<peerKey>/config.json）
+ *   2. agent 级 responseMode（$AGENT_DIR/config.json）
+ *   3. 注册表首选响应模式（registry.getPreferred()，当前为 single-session）
+ *
+ * 关系级 > agent 级由 ConfigManager 按 `x-merge: scalar` 合并完成，因此本解析器
+ * 收到的是**合并后的标量值**；只需「有值用值、无值用注册表首选」。
+ *
+ * 注：旧的 response_modes 块（default_private/default_group/configs/overrides）已废除。
+ *    chatMode 从顶层 chatmode 字典读、与选模式正交；模式特有参数从顶层 config 块读。
+ */
+export class ResponseModeResolver {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /**
+     * 解析会话的响应模式。
+     *
+     * @param responseModeId 合并后的标量 responseMode（关系级>agent级，可空）
+     */
+    resolve(responseModeId) {
+        if (responseModeId) {
+            const mode = this.registry.get(responseModeId);
+            if (mode)
+                return { mode, source: 'config' };
+            // 配了不存在的模式：不抛错（避免单个坏配置卡死会话），回落注册表首选
+        }
+        return { mode: this.registry.getPreferred(), source: 'preferred' };
+    }
+}

package/dist/response-system/selector.js

@@ -0,0 +1,23 @@
+/**
+ * New response-system selector. It is intentionally small while V1 migration is
+ * in progress; V2 modes can be added without changing user-facing mode ids.
+ */
+export class ResponseModeSelector {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async select(modeId, context) {
+        const mode = this.registry.get(modeId);
+        if (!mode) {
+            throw new Error(`[ResponseModeSelector] mode not found: ${modeId}`);
+        }
+        await mode.initialize(context);
+        context.logger.debug('[ResponseSystem] selector selected mode=' + mode.id + ' engine=' + (mode.engineType ?? 'v1'));
+        return {
+            id: mode.id,
+            engineType: mode.engineType ?? 'v1',
+            mode,
+        };
+    }
+}

package/dist/response-system/types.js

@@ -0,0 +1,7 @@
+/**
+ * Response Mode System - Core Types
+ *
+ * 响应模式插件化系统的核心类型定义。
+ * 所有响应模式必须实现 ResponseMode 接口。
+ */
+export {};