evolcore 0.0.1 → 0.0.3

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

@@ -0,0 +1,76 @@
+/**
+ * 消息处理工具函数
+ *
+ * 从 message-processor.ts 提取的独立工具函数，供 ResponseEngine 和其他模块使用。
+ */
+import { renderCommandCardAsText, renderActionAsText } from '../interaction-router.js';
+/**
+ * 构造出站消息信封
+ */
+export function buildEnvelope(opts) {
+    const taskId = opts.taskId ?? `interaction-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    return {
+        taskId,
+        operationId: opts.operationId ?? taskId,
+        sessionId: opts.sessionId,
+        channel: opts.channel,
+        channelId: opts.channelId,
+        agentName: opts.agentName ?? '<unknown>',
+        chatmode: opts.chatmode ?? 'interactive',
+        replyContext: opts.replyContext,
+        causation: opts.causation,
+        timestamp: opts.timestamp ?? Date.now(),
+    };
+}
+/**
+ * 交互请求的默认回退文本
+ * 当调用方未显式提供时使用，根据交互类型选择合适的渲染器。
+ */
+export function defaultFallbackText(interaction) {
+    const kind = interaction.kind;
+    if (kind.kind === 'command-card') {
+        return renderCommandCardAsText(kind);
+    }
+    if (kind.kind === 'action') {
+        try {
+            return renderActionAsText(interaction);
+        }
+        catch {
+            // ActionInteraction without fallback metadata — produce a minimal hint
+            const action = kind;
+            const lines = [action.title];
+            if (action.body)
+                lines.push(action.body);
+            return lines.join('\n');
+        }
+    }
+    return '';
+}
+/**
+ * 通过统一的 adapter.send 入口发送交互负载
+ *
+ * 通过 adapter.send(envelope, { kind: 'interaction', ... }) 发送交互。
+ * 成功返回 'sent'，失败返回 false。
+ */
+export async function sendInteractionPayload(adapter, envelope, interaction, fallbackText, replyCtx) {
+    const text = fallbackText ?? defaultFallbackText(interaction);
+    const payload = {
+        kind: 'interaction',
+        interaction,
+        fallbackText: text || undefined,
+    };
+    try {
+        const enriched = replyCtx
+            ? { ...envelope, replyContext: replyCtx }
+            : envelope;
+        const receipt = await adapter.send(enriched, payload);
+        if (receipt?.status === 'suppressed')
+            return false;
+        if (receipt?.status === 'sent')
+            return receipt.messages[0]?.messageId || false;
+        return 'sent';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/message/peer-mode.js

@@ -0,0 +1,105 @@
+import { loadSchema } from '../../config/schema-registry.js';
+import { resolveEffective } from '../../config/config-manager.js';
+import { resolveRuntimeStringField } from '../role/runtime-policy.js';
+/** Resolve the effective chat mode from the ConfigManager layering context. */
+export function resolveChatMode(params) {
+    let configured;
+    try {
+        configured = resolveEffective({
+            self: params.self,
+            peerKey: params.peerKey,
+        }, { cache: true }).chatmode;
+    }
+    catch {
+        configured = undefined;
+    }
+    const kind = normalizePeerType(params.peerType);
+    if (kind === 'system' || kind === 'service')
+        return 'interactive';
+    const field = chatmodeFieldForPeer(params.chatType, params.peerType);
+    const decision = resolveRuntimeStringField({
+        selfAid: params.self,
+        role: params.role,
+        field: `chatmode.${field}`,
+        configuredValue: configured?.[field],
+    });
+    const effectiveValue = decision.effectiveValue;
+    return effectiveValue === 'interactive' || effectiveValue === 'proactive'
+        ? effectiveValue
+        : chatmodeFactoryDefaults()[field];
+}
+export function resolveChatModeForField(params) {
+    return resolveChatMode({
+        ...params,
+        chatType: params.field === 'group' ? 'group' : 'private',
+        peerType: params.field === 'nothuman' ? 'agent' : 'human',
+    });
+}
+export function normalizePeerType(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const raw = value.trim();
+    if (!raw)
+        return undefined;
+    const key = raw.toLowerCase();
+    if (key === 'human' || key === 'person' || key === 'user')
+        return 'human';
+    if (key === 'group' || key === 'room' || key === 'venue')
+        return 'group';
+    if (key === 'system' || key === 'trigger' || key === 'scheduler')
+        return 'system';
+    if (key === 'service' || key === 'daemon' || key === 'tool')
+        return 'service';
+    if (key === 'unknown')
+        return 'unknown';
+    return 'agent';
+}
+export function isSystemOrServicePeer(peerType) {
+    const kind = normalizePeerType(peerType);
+    return kind === 'system' || kind === 'service';
+}
+/**
+ * 解析某会话对端的 chatMode。优先级（高→低）：
+ *   1. 运行时硬约束：system/service 对端始终 interactive（非配置项）
+ *   2. 合并后的 chatmode 场景表 `configured`（chatmode.{private|group|nothuman}）——
+ *      关系级与 agent 级同名字典，已由 ConfigManager 按 x-merge:dict 逐键合并
+ *   3. schema 出厂默认表 `chatmodeFactoryDefaults()`
+ *
+ * chatmode 是顶层字典参数（agent 级与关系级形态相同），实际生效值由对端类型选键。
+ * 详见 config-reference.md §三。
+ */
+export function resolveChatModeForPeer(params) {
+    const kind = normalizePeerType(params.peerType);
+    // 运行时硬约束（非配置项）：system/service 对端始终同步交互
+    if (kind === 'system' || kind === 'service')
+        return 'interactive';
+    // 合并后的场景表 → 出厂默认表
+    const field = chatmodeFieldForPeer(params.chatType, params.peerType);
+    return params.configured?.[field] ?? chatmodeFactoryDefaults()[field];
+}
+let _factoryChatmode = null;
+/**
+ * chatMode 出厂默认表 —— 唯一来源是 agent-config schema 的 chatmode.default
+ * （配置数据，非代码分支）。agent 级配置改默认表、关系级按键覆盖，均经
+ * ConfigManager 合并后以 `configured` 传入；此表仅在配置链完全未设值时兜底。
+ */
+export function chatmodeFactoryDefaults() {
+    if (!_factoryChatmode) {
+        const d = loadSchema('agent-config').fields.get('chatmode')?.default;
+        if (!d?.private || !d?.group || !d?.nothuman) {
+            throw new Error('[peer-mode] agent-config schema 缺少 chatmode 出厂默认表（default.private/group/nothuman）');
+        }
+        _factoryChatmode = d;
+    }
+    return _factoryChatmode;
+}
+export function chatmodeFieldForPeer(chatType, peerType) {
+    const kind = normalizePeerType(peerType);
+    if (kind === 'system' || kind === 'service')
+        return 'private';
+    if (chatType === 'group' || kind === 'group')
+        return 'group';
+    if (kind === 'agent' || kind === 'unknown')
+        return 'nothuman';
+    return 'private';
+}

package/dist/core/message/pending-hints.js

@@ -0,0 +1,232 @@
+// 观察者插话：待用提示（pending-hints）存储。
+//
+// owner 经 observer.inject 给「agent↔对端」会话预埋的提示，落盘为 append-only jsonl，
+// 在下一条对端消息到达、渲染该轮 prompt 时一次性消费、注入渲染层。
+// 详见 docs/observer-insert-design.md 第一部分（§1.3 文件生命周期 / §1.4 thread 作用域）。
+//
+// 文件：sessions/<channelType>/<selfAID>/<对端>/pending-hints.jsonl（与 messages.jsonl 同级）
+// 每行一个事件：
+//   { action:'add',    id, text, threadId, ownerAid, ts }
+//   { action:'remove', targetId?, threadId, ts }   // 无 targetId = 撤该 thread 全部
+//
+// 生命周期 = 一个消费周期（按 (对端,thread) 维度）：
+//   - add/remove 追加行（append-only，处理「加了又撤」的竞态：按时间序回放抵消）
+//   - consume（对端消息到达触发）：回放算「该 thread」有效集 → 返回 → 清掉该 thread 的事件。
+//     · 若文件里其它 thread 仍有未消费提示 → 重写文件只留它们（不误删别的 thread）。
+//     · 否则（无其它 thread 残留）→ 删整个文件。
+//   - 因为 consume 一次性用掉该 thread 的全部有效提示，消费后该 thread 有效集必然归零，
+//     未来状态不依赖消费前历史，故消费即清安全，无需 consume 事件行。
+//   - 任何让「整文件」有效集归零的操作都删文件：consume 后无残留即删；remove 把提示全撤光也删。
+import fs from 'fs';
+import path from 'path';
+import { chatDirPath, appendJsonl, readAllJsonlLines } from '../session/session-fs-store.js';
+import { logger } from '../../utils/logger.js';
+const PENDING_HINTS_FILE = 'pending-hints.jsonl';
+function hintsPath(sessionsDir, channelType, channelId, selfAID) {
+    return path.join(chatDirPath(sessionsDir, channelType, channelId, selfAID), PENDING_HINTS_FILE);
+}
+/** 归一 threadId：undefined/null → ''（主线程）。 */
+function normThread(threadId) {
+    return threadId || '';
+}
+/**
+ * 追加一条 add 事件。返回是否写盘成功（供 ack 判定）。
+ * 写盘成功后才回 ack(accepted)——accepted 真正代表"已持久保存"。
+ */
+export function appendHintAdd(sessionsDir, channelType, channelId, selfAID, hint) {
+    try {
+        const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        const ev = {
+            action: 'add', id: hint.id, text: hint.text,
+            threadId: normThread(hint.threadId), ownerAid: hint.ownerAid, ts: hint.ts,
+        };
+        appendJsonl(fp, ev);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] appendHintAdd failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}
+/**
+ * 追加一条 remove 事件。若该操作使 (对端,thread) 有效集归零，则删除整个文件。
+ * 返回是否写盘成功（供 ack 判定）。
+ */
+export function appendHintRemove(sessionsDir, channelType, channelId, selfAID, rm) {
+    try {
+        const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+        if (!fs.existsSync(fp))
+            return true; // 无文件 = 无可撤，幂等成功
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        const ev = {
+            action: 'remove', threadId: normThread(rm.threadId), ts: rm.ts,
+            ...(rm.targetId ? { targetId: rm.targetId } : {}),
+        };
+        appendJsonl(fp, ev);
+        // 撤销后：若全部 thread 的有效集都归零，删文件（不堆死文件）。
+        if (!hasAnyEffective(fp))
+            deleteFile(fp);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] appendHintRemove failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}
+/** 回放整个文件，返回是否还存在任意 thread 的有效提示。 */
+function hasAnyEffective(fp) {
+    const events = readAllJsonlLines(fp);
+    // 按 thread 分组回放
+    const byThread = new Map();
+    for (const ev of events) {
+        const t = normThread(ev.threadId);
+        (byThread.get(t) ?? byThread.set(t, []).get(t)).push(ev);
+    }
+    for (const [, evs] of byThread) {
+        if (replayEffective(evs).length > 0)
+            return true;
+    }
+    return false;
+}
+/** 对单个 thread 的事件序列回放，算出有效提示集（已 add、未被 remove，按 ts 升序）。 */
+function replayEffective(events) {
+    const sorted = events.slice().sort((a, b) => a.ts - b.ts);
+    const active = new Map(); // id → hint，保插入序
+    for (const ev of sorted) {
+        if (ev.action === 'add') {
+            active.set(ev.id, { id: ev.id, text: ev.text, ownerAid: ev.ownerAid, ts: ev.ts });
+        }
+        else {
+            if (ev.targetId)
+                active.delete(ev.targetId);
+            else
+                active.clear(); // 无 targetId = 撤该 thread 全部
+        }
+    }
+    return [...active.values()].sort((a, b) => a.ts - b.ts);
+}
+/**
+ * 消费 (对端, thread) 的有效提示：回放算「该 thread」有效集 → 返回 → 清掉该 thread。
+ *
+ * thread 隔离：只消费传入 threadId（归一后）的提示。若文件里其它 thread 仍有未消费提示，
+ * 重写文件保留它们；只有当整文件再无任何有效提示时才删除文件。
+ * 返回空数组表示该 thread 无有效提示（调用方据此决定是否注入）。
+ */
+export function consumeHints(sessionsDir, channelType, channelId, selfAID, threadId) {
+    const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+    if (!fs.existsSync(fp))
+        return [];
+    let all;
+    try {
+        all = readAllJsonlLines(fp);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] consume read failed: ${e instanceof Error ? e.message : String(e)}`);
+        return [];
+    }
+    const wantThread = normThread(threadId);
+    const sameThread = all.filter(ev => normThread(ev.threadId) === wantThread);
+    const effective = replayEffective(sameThread);
+    // 其它 thread 仍有未消费提示？若有，重写文件只留它们；否则删整个文件。
+    const otherThreadEvents = all.filter(ev => normThread(ev.threadId) !== wantThread);
+    if (otherThreadEvents.length > 0 && hasEffectiveInEvents(otherThreadEvents)) {
+        rewriteFile(fp, otherThreadEvents);
+    }
+    else {
+        deleteFile(fp);
+    }
+    return effective;
+}
+/** events（可能跨多 thread）中是否存在任意有效提示。 */
+function hasEffectiveInEvents(events) {
+    const byThread = new Map();
+    for (const ev of events) {
+        const t = normThread(ev.threadId);
+        (byThread.get(t) ?? byThread.set(t, []).get(t)).push(ev);
+    }
+    for (const [, evs] of byThread) {
+        if (replayEffective(evs).length > 0)
+            return true;
+    }
+    return false;
+}
+function rewriteFile(fp, events) {
+    try {
+        const body = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+        fs.writeFileSync(fp, body);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] rewriteFile failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function deleteFile(fp) {
+    try {
+        if (fs.existsSync(fp))
+            fs.unlinkSync(fp);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] deleteFile failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/** 仅供 watch / 调试：读出当前 (对端,thread) 有效提示，不消费、不删文件。 */
+export function peekHints(sessionsDir, channelType, channelId, selfAID, threadId) {
+    const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+    if (!fs.existsSync(fp))
+        return [];
+    try {
+        const all = readAllJsonlLines(fp);
+        const wantThread = normThread(threadId);
+        return replayEffective(all.filter(ev => normThread(ev.threadId) === wantThread));
+    }
+    catch {
+        return [];
+    }
+}
+// ── 渲染接线纯函数（无 IO，便于单测） ──────────────────────────
+/** 把有效提示转成 owner-hint SubMessage（排在对端真实 item 之前，走 inject 渲染模式）。 */
+export function hintsToSubMessages(hints) {
+    return hints.map(h => ({
+        kind: 'owner-hint',
+        content: h.text,
+        ownerAid: h.ownerAid,
+        injectTime: h.ts,
+        timestamp: h.ts,
+    }));
+}
+/**
+ * 渲染失败兜底：把已消费的 owner-hint（提示已从 pending 删除、不可恢复）以纯文本前缀
+ * 拼到对端原文之前，避免提示被静默丢弃。仅在 renderMessageBody 抛错或产出空时使用。
+ */
+export function composeHintFallback(hintItems, content) {
+    if (!hintItems || hintItems.length === 0)
+        return content;
+    const lines = hintItems.map(h => `‹owner 提示·已验证›（仅你可见，对端无感）\n${h.content}`);
+    return [...lines, content].join('\n\n');
+}
+/**
+ * 解析 observer.inject payload：鉴权（from∈owners）+ 校验（add 需 channel_id+text；remove 需 channel_id）
+ * + 归一字段。纯函数，无副作用——落盘 / ack / watch 由调用方按结果执行。
+ * @param ts 用于 add 缺省 id（`inj-<ts>`）；由调用方传入便于测试确定性。
+ */
+export function parseInjectRequest(payload, fromAid, owners, ts) {
+    const p = (payload && typeof payload === 'object') ? payload : {};
+    const injectId = typeof p.id === 'string' ? p.id : undefined;
+    const action = p.action === 'remove' ? 'remove' : 'add';
+    if (!owners.includes(fromAid)) {
+        return { kind: 'reject', code: 'NOT_OWNER', message: '仅 owner 可插话', action, injectId };
+    }
+    const target = (p.target && typeof p.target === 'object') ? p.target : undefined;
+    const channelId = target && typeof target.channel_id === 'string' ? target.channel_id : undefined;
+    const text = typeof p.text === 'string' ? p.text : '';
+    if (!channelId || (action === 'add' && !text.trim())) {
+        return { kind: 'reject', code: 'INVALID_TARGET', message: 'target.channel_id 必填；add 还需 text', action, injectId };
+    }
+    const chatType = target?.chat_type === 'group' ? 'group' : 'private';
+    const threadId = typeof target?.thread_id === 'string' ? target.thread_id : undefined;
+    const targetId = typeof p.target_id === 'string' ? p.target_id : undefined;
+    if (action === 'remove') {
+        return { kind: 'remove', injectId, channelId, chatType, threadId, targetId };
+    }
+    return { kind: 'add', injectId, id: injectId || `inj-${ts}`, text, channelId, chatType, threadId, ownerAid: fromAid };
+}

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

@@ -0,0 +1,33 @@
+import crypto from 'crypto';
+export function computeTopicHash(content) {
+    const normalized = (content || '').trim().slice(0, 20);
+    return crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 8);
+}
+export function resolveResponseDepth(input) {
+    const content = input.content || '';
+    const topicHash = computeTopicHash(content);
+    const previousRounds = input.topicRounds || 0;
+    const topicRounds = input.lastTopicHash === topicHash ? previousRounds + 1 : 1;
+    const isMentioned = !!input.selfAid && Array.isArray(input.mentionAids) && input.mentionAids.includes(input.selfAid);
+    if (input.chatType !== 'group') {
+        return { depth: 'standard', topicHash, topicRounds, isMentioned };
+    }
+    if (topicRounds >= 3) {
+        return { depth: 'deep', topicHash, topicRounds, isMentioned };
+    }
+    if (isMentioned) {
+        return { depth: 'standard', topicHash, topicRounds, isMentioned };
+    }
+    if (input.mentionMode === 'disabled' && isShortNonQuestion(content)) {
+        return { depth: 'lightweight', topicHash, topicRounds, isMentioned };
+    }
+    return { depth: 'standard', topicHash, topicRounds, isMentioned };
+}
+function isShortNonQuestion(content) {
+    const text = (content || '').trim();
+    if (text.length > 30)
+        return false;
+    if (/[?？]$/.test(text))
+        return false;
+    return !/^(怎么|如何|为什么|为何|哪|谁|什么|是否|能否|可否|how\b|why\b|what\b|when\b|where\b|who\b|which\b|can\b|could\b|should\b|would\b|is\b|are\b|do\b|does\b|did\b)/i.test(text);
+}