@jack200714/mafw 4.5.1

package/gateway/dist/media/pi-adapter.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixMediaPayload = fixMediaPayload;
+exports.createPiPromptAdapter = createPiPromptAdapter;
+const auth_1 = require("../runtime/auth");
+/**
+ * Pi media adapter — implements the gateway's PromptFn abstraction with
+ * pi-coding-agent as the media analysis engine.
+ *
+ * Flow (path A, verified POC):
+ *   media file part (data URL) → PiAiImage carrier ({type:'image', data, mimeType})
+ *   → pi's openai-completions serializer turns non-text parts into image_url
+ *   → fixMediaPayload (onPayload hook) rewrites the wire format:
+ *       video/* → { type:'video_url', video_url:{url} }        (Xiaomi video format)
+ *       audio/* → { type:'input_audio', input_audio:{data:url} } (Xiaomi audio format)
+ *   → the configured model (e.g. xiaomi/mimo-v2.5) receives the media natively.
+ *
+ * Credentials are reused from opencode's auth.json (the provider must be
+ * connected in opencode, e.g. `xiaomi`); the key is injected at runtime via
+ * setRuntimeApiKey and never persisted by pi.
+ *
+ * The fixer is derived from pi-multimodal-proxy's fixVideoAudioPayload (MIT);
+ * the audio branch was changed to input_audio per the Xiaomi MiMo API docs.
+ */
+function fixMediaPayload(payload) {
+    if (!payload || typeof payload !== 'object')
+        return undefined;
+    const p = payload;
+    const messages = p.messages;
+    if (!Array.isArray(messages))
+        return undefined;
+    let modified = false;
+    for (const msg of messages) {
+        if (!msg || typeof msg !== 'object')
+            continue;
+        const m = msg;
+        const content = m.content;
+        if (!Array.isArray(content))
+            continue;
+        for (let i = 0; i < content.length; i++) {
+            const block = content[i];
+            if (!block || typeof block !== 'object')
+                continue;
+            const b = block;
+            if (b.type === 'image_url' && b.image_url && typeof b.image_url === 'object') {
+                const iu = b.image_url;
+                const url = iu.url;
+                if (typeof url === 'string' && url.startsWith('data:')) {
+                    const mimeMatch = url.match(/^data:([^;]+);/);
+                    if (mimeMatch) {
+                        const mime = mimeMatch[1].toLowerCase();
+                        if (mime.startsWith('video/')) {
+                            content[i] = { type: 'video_url', video_url: { url } };
+                            modified = true;
+                        }
+                        else if (mime.startsWith('audio/')) {
+                            // Xiaomi MiMo audio format: input_audio with the full data URI.
+                            content[i] = { type: 'input_audio', input_audio: { data: url } };
+                            modified = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return modified ? p : undefined;
+}
+function createPiPromptAdapter(deps = {}) {
+    const authPath = deps.authPath ?? (0, auth_1.DEFAULT_AUTH_PATH)();
+    const timeoutMs = deps.timeoutMs ?? 180_000;
+    let runtimePromise;
+    function runtime() {
+        if (!runtimePromise) {
+            // pi-coding-agent is ESM-only and this gateway package compiles to CJS.
+            // A static import (and even a tsc-compiled dynamic import) becomes a
+            // require() of an ESM package and throws, so load it through a runtime
+            // dynamic import() that tsc cannot rewrite.
+            runtimePromise = (async () => {
+                const imp = new Function('spec', 'return import(spec)');
+                const { ModelRuntime } = await imp('@earendil-works/pi-coding-agent');
+                const mr = await ModelRuntime.create({ signal: AbortSignal.timeout(30_000) });
+                return mr;
+            })();
+            runtimePromise.catch(() => { runtimePromise = undefined; });
+        }
+        return runtimePromise;
+    }
+    async function modelFor(provider, model) {
+        if (deps.getModel) {
+            const m = deps.getModel(provider, model);
+            if (!m)
+                throw new Error(`Model ${provider}/${model} not found`);
+            return m;
+        }
+        const mr = await runtime();
+        const m = mr.getModel(provider, model);
+        if (!m)
+            throw new Error(`Model ${provider}/${model} not found in pi registry`);
+        return m;
+    }
+    return async function piPrompt(parts, opts) {
+        const apiKey = deps.getApiKey
+            ? deps.getApiKey(opts.providerID)
+            : deps.credentials?.getApiKey(opts.providerID)
+                ?? (0, auth_1.readOpencodeAuth)(authPath)[opts.providerID]?.key;
+        if (!apiKey) {
+            throw new Error(`No API key for provider "${opts.providerID}" — connect it in opencode first (auth.json)`);
+        }
+        const filePart = parts.find((p) => p.type === 'file');
+        const textPart = parts.find((p) => p.type === 'text');
+        const model = await modelFor(opts.providerID, opts.modelID);
+        const content = [];
+        if (textPart && typeof textPart.text === 'string' && textPart.text.trim()) {
+            content.push({ type: 'text', text: textPart.text });
+        }
+        if (filePart && typeof filePart.url === 'string' && filePart.url.startsWith('data:')) {
+            const dataUrl = filePart.url;
+            const mime = filePart.mime || dataUrl.match(/^data:([^;]+);/)?.[1] || 'image/png';
+            const data = dataUrl.includes(',') ? dataUrl.split(',')[1] || '' : '';
+            // PiAiImage carrier — pi serializes it as image_url, fixMediaPayload
+            // rewrites the wire format to video_url / input_audio.
+            content.push({ type: 'image', data, mimeType: mime });
+        }
+        if (content.length === 0) {
+            throw new Error('Pi adapter requires at least one text or file part');
+        }
+        const mr = await runtime();
+        await mr.setRuntimeApiKey(opts.providerID, apiKey);
+        const logger = await import('../core/utils/logger.js');
+        try {
+            const response = await mr.complete(model, {
+                systemPrompt: 'You are a precise media analysis assistant. Answer the user\'s question about the attached media concisely and factually.',
+                messages: [
+                    {
+                        role: 'user',
+                        content,
+                        timestamp: Date.now(),
+                    },
+                ],
+            }, {
+                apiKey,
+                onPayload: deps.fixPayload ?? fixMediaPayload,
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            if (response.stopReason === 'error' || response.stopReason === 'aborted') {
+                throw new Error(response.errorMessage || `Media analysis failed (${response.stopReason})`);
+            }
+            return (response.content || [])
+                .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                .map((c) => c.text)
+                .join('\n')
+                .trim();
+        }
+        catch (err) {
+            logger.log.error(`[PiAdapter] ${opts.providerID}/${opts.modelID} baseUrl=${model.baseUrl} failed: ${err?.message || String(err)}`);
+            throw err;
+        }
+    };
+}

package/gateway/dist/media/plugin-context.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMediaPluginContext = createMediaPluginContext;
+const config_1 = require("../config");
+const logger_1 = require("../core/utils/logger");
+const auth_1 = require("../runtime/auth");
+function createMediaPluginContext(pluginName, credentials) {
+    return {
+        apiKey: (name) => (0, auth_1.getProviderApiKey)(name, undefined, credentials) ?? null,
+        fetch: (url, opts) => fetch(url, { ...opts, signal: opts?.signal ?? AbortSignal.timeout(60_000) }),
+        pluginConfig: (name) => config_1.config.raw.media?.pluginConfig?.[name] ?? null,
+        log: logger_1.log,
+    };
+}

package/gateway/dist/media/tts-service.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTS_VOICES = exports.TTS_DEFAULT_VOICE = exports.TTS_DEFAULT_MODEL = exports.TTS_DEFAULT_BASE_URL = void 0;
+exports.resolveVoice = resolveVoice;
+exports.createTtsService = createTtsService;
+const auth_1 = require("../runtime/auth");
+/**
+ * TtsService — MiMo-V2.5-TTS 语音合成客户端（直连小米 OpenAI 兼容端点）。
+ *
+ * 官方约束（speech-synthesis-v2.5）：
+ *   - 目标合成文本必须放在 role=assistant 的消息中（不可放 user）
+ *   - user 消息可选：风格指令（自然语言控制）
+ *   - audio.format: 'wav'（非流式）/ 'pcm16'（流式，24kHz mono）
+ *   - audio.voice: 预置音色 ID
+ *   - 响应：choices[0].message.audio.data（base64 音频）
+ *
+ * 认证复用 opencode auth.json 的 xiaomi provider key（与 pi-adapter 同源）。
+ */
+exports.TTS_DEFAULT_BASE_URL = 'https://api.xiaomimimo.com/v1';
+exports.TTS_DEFAULT_MODEL = 'mimo-v2.5-tts';
+exports.TTS_DEFAULT_VOICE = '茉莉';
+/** 预置音色（9 个 ID；mimo_default 集群相关，下拉建议用命名音色）。 */
+exports.TTS_VOICES = [
+    { id: 'mimo_default', label: 'MiMo-默认（集群相关）', lang: 'auto' },
+    { id: '冰糖', label: '冰糖', lang: 'zh' },
+    { id: '茉莉', label: '茉莉', lang: 'zh' },
+    { id: '苏打', label: '苏打', lang: 'zh' },
+    { id: '白桦', label: '白桦', lang: 'zh' },
+    { id: 'Mia', label: 'Mia', lang: 'en' },
+    { id: 'Chloe', label: 'Chloe', lang: 'en' },
+    { id: 'Milo', label: 'Milo', lang: 'en' },
+    { id: 'Dean', label: 'Dean', lang: 'en' },
+];
+/** 校验并取有效音色（非法/未配置时回退默认）。 */
+function resolveVoice(cfg, voice) {
+    if (voice && voice.trim())
+        return voice.trim();
+    return cfg.defaultVoice || exports.TTS_DEFAULT_VOICE;
+}
+function createTtsService(deps) {
+    const authPath = deps.authPath;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const provider = () => deps.config().media?.provider || 'xiaomi';
+    const ttsCfg = () => deps.config().media?.tts ?? {};
+    async function synthesize(input) {
+        const cfg = ttsCfg();
+        const key = (0, auth_1.getProviderApiKey)(provider(), authPath, deps.credentials);
+        if (!key) {
+            throw new Error(`No API key for provider "${provider()}" — connect it in opencode first (auth.json)`);
+        }
+        const text = (input.text || '').trim();
+        if (!text)
+            throw new Error('TTS requires non-empty text');
+        if (text.length > 2000)
+            throw new Error(`TTS text too long (${text.length} > 2000 chars)`);
+        const voice = resolveVoice(cfg, input.voice);
+        const baseUrl = (cfg.baseUrl || exports.TTS_DEFAULT_BASE_URL).replace(/\/+$/, '');
+        const model = cfg.model || exports.TTS_DEFAULT_MODEL;
+        const messages = [];
+        if (input.style && input.style.trim()) {
+            messages.push({ role: 'user', content: input.style.trim() });
+        }
+        // 官方约束：目标文本必须在 assistant 消息。
+        messages.push({ role: 'assistant', content: text });
+        const res = await fetchImpl(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages,
+                audio: { format: 'wav', voice },
+            }),
+            signal: AbortSignal.timeout(120_000),
+        });
+        if (!res.ok) {
+            const detail = await res.text().catch(() => '');
+            throw new Error(`TTS HTTP ${res.status}: ${detail.slice(0, 300)}`);
+        }
+        const parsed = await res.json();
+        const data = parsed?.choices?.[0]?.message?.audio?.data;
+        if (typeof data !== 'string' || !data) {
+            const err = parsed?.error?.message || JSON.stringify(parsed).slice(0, 300);
+            throw new Error(`TTS empty audio response: ${err}`);
+        }
+        return {
+            audioDataUrl: `data:audio/wav;base64,${data}`,
+            mime: 'audio/wav',
+            voice,
+        };
+    }
+    /**
+     * 流式 TTS：pcm16（24kHz mono）分块输出。返回 async generator，每项是
+     * base64 编码的 PCM 块（chunk 边界可能切半个 sample，消费端需保留残余字节）。
+     * 调用方负责把块转 SSE 推给客户端。
+     */
+    async function* synthesizeStream(input, opts) {
+        const cfg = ttsCfg();
+        const key = (0, auth_1.getProviderApiKey)(provider(), authPath, deps.credentials);
+        if (!key) {
+            throw new Error(`No API key for provider "${provider()}" — connect it in opencode first (auth.json)`);
+        }
+        const text = (input.text || '').trim();
+        if (!text)
+            throw new Error('TTS requires non-empty text');
+        if (text.length > 2000)
+            throw new Error(`TTS text too long (${text.length} > 2000 chars)`);
+        const voice = resolveVoice(cfg, input.voice);
+        const baseUrl = (cfg.baseUrl || exports.TTS_DEFAULT_BASE_URL).replace(/\/+$/, '');
+        const model = cfg.model || exports.TTS_DEFAULT_MODEL;
+        const messages = [];
+        if (input.style && input.style.trim()) {
+            messages.push({ role: 'user', content: input.style.trim() });
+        }
+        messages.push({ role: 'assistant', content: text });
+        const res = await fetchImpl(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages,
+                audio: { format: 'pcm16', voice },
+                stream: true,
+            }),
+            signal: AbortSignal.any([opts?.signal ?? new AbortController().signal, AbortSignal.timeout(120_000)]),
+        });
+        if (!res.ok || !res.body) {
+            const detail = await res.text().catch(() => '');
+            throw new Error(`TTS stream HTTP ${res.status}: ${detail.slice(0, 300)}`);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                const lines = buf.split('\n');
+                buf = lines.pop() || '';
+                for (const line of lines) {
+                    const t = line.trim();
+                    if (!t.startsWith('data:'))
+                        continue;
+                    const payload = t.slice(5).trim();
+                    if (payload === '[DONE]')
+                        continue;
+                    try {
+                        const chunk = JSON.parse(payload);
+                        const delta = chunk?.choices?.[0]?.delta;
+                        const audioData = delta?.audio?.data;
+                        if (typeof audioData === 'string' && audioData) {
+                            yield { data: audioData, voice };
+                        }
+                    }
+                    catch {
+                        /* 跳过无法解析的块 */
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    return { synthesize, synthesizeStream };
+}

package/gateway/dist/memory/abstraction-matcher.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchAbstraction = matchAbstraction;
+const derived_terms_1 = require("./derived-terms");
+const AUTO_THRESHOLD = 0.5;
+const CONFLICT_THRESHOLD = 0.2;
+function matchAbstraction(a, b) {
+    const tokensA = (0, derived_terms_1.tokenize)(a);
+    const tokensB = (0, derived_terms_1.tokenize)(b);
+    if (tokensA.length === 0 || tokensB.length === 0) {
+        return { similarity: 0, level: 'none' };
+    }
+    const wordsA = tokensA.filter(t => t.length > 2);
+    const wordsB = tokensB.filter(t => t.length > 2);
+    if (wordsA.length === 0 || wordsB.length === 0) {
+        return { similarity: 0, level: 'none' };
+    }
+    const setA = new Set(wordsA);
+    const setB = new Set(wordsB);
+    const intersection = new Set([...setA].filter(x => setB.has(x)));
+    const union = new Set([...setA, ...setB]);
+    const similarity = intersection.size / union.size;
+    if (similarity >= AUTO_THRESHOLD)
+        return { similarity, level: 'auto' };
+    if (similarity >= CONFLICT_THRESHOLD)
+        return { similarity, level: 'conflict' };
+    return { similarity, level: 'none' };
+}

package/gateway/dist/memory/consolidation-service.js

@@ -0,0 +1,209 @@
+"use strict";
+// P2: Memora-style memory consolidation.
+//
+// After a memory unit is written, recall embedding candidates above a cosine
+// threshold; if any exist, an LLM judge decides UPDATE (merge into a single
+// canonical entry) vs CREATE (keep separate). UPDATE merges the incoming unit
+// with the older target (new content wins), soft-supersedes the target, and
+// drops the stale vector — mirroring MinHash merge semantics but at the
+// semantic level (cosine 0.8+ recall catches paraphrases char-level MinHash
+// cannot see).
+//
+// The judge is a single OpenAI-compatible chat call reusing the worker-model
+// transport (same resolution as IndexScan). All failures are fail-open: the
+// unit simply stays as its own entry (never blocks or destroys writes).
+//
+// update-ratio stats (updated / judged) surface consolidation health — the
+// Memora paper's sweet spot is ~16-22% (over-consolidation degrades quality).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsolidationService = void 0;
+const logger_1 = require("../core/utils/logger");
+const vector_store_1 = require("./vector-store");
+const JUDGE_SYSTEM = `You are a memory management assistant. Given a NEW memory entry and similar existing entries, decide whether the new entry should UPDATE (merge into) an existing entry or be CREATEd as a separate memory.
+
+Rules:
+- UPDATE when both entries describe the same underlying subject/entity/topic with overlapping or complementary details (e.g. evolving state of the same project, updated preferences, new facts about the same person).
+- CREATE when the subjects are merely similar in wording but refer to different entities, events, or aspects.
+Respond with ONLY a JSON object:
+{"action":"update","target_id":"<id of the entry to merge into>"} or {"action":"create"}`;
+class ConsolidationService {
+    store;
+    vectors;
+    provider;
+    llm;
+    minCosine;
+    maxCandidates;
+    stats = { judged: 0, updates: 0, creates: 0 };
+    constructor(deps) {
+        this.store = deps.store;
+        this.vectors = deps.vectors;
+        this.provider = deps.provider;
+        this.llm = deps.llm;
+        this.minCosine = deps.minCosine ?? 0.8;
+        this.maxCandidates = deps.maxCandidates ?? 3;
+    }
+    getStats() {
+        const judged = this.stats.updates + this.stats.creates;
+        return {
+            ...this.stats,
+            updateRatio: judged === 0 ? 0 : this.stats.updates / judged,
+        };
+    }
+    /**
+     * Serial enqueue wrapper for the write path (onMemoryWritten). Errors are
+     * swallowed — consolidation must never break memory writes.
+     */
+    async enqueue(unit) {
+        try {
+            await this.consolidate(unit);
+        }
+        catch (err) {
+            logger_1.log.warn(`[Consolidation] enqueue error for ${unit?.id}: ${err?.message || err}`);
+        }
+    }
+    async consolidate(unit) {
+        if (!unit?.id)
+            return { action: 'skip', reason: 'no-unit' };
+        // Recursion guard: never re-consolidate merge products.
+        if (unit.merged_from && unit.merged_from.length > 0) {
+            return { action: 'skip', reason: 'merged-product' };
+        }
+        let vector = this.vectors.get(unit.id);
+        if (!vector) {
+            // The async indexer may not have flushed yet — embed on demand so the
+            // judge sees this unit in vector space immediately.
+            try {
+                const text = vector_store_1.EmbeddingIndexer.documentText(unit);
+                if (!text)
+                    return { action: 'skip', reason: 'no-vector' };
+                const [vec] = await this.provider.embed([text], 'document');
+                if (!vec)
+                    return { action: 'skip', reason: 'no-vector' };
+                this.vectors.upsert(unit.id, vec);
+                vector = vec;
+            }
+            catch (err) {
+                logger_1.log.warn(`[Consolidation] on-demand embed failed for ${unit.id}: ${err?.message || err}`);
+                return { action: 'skip', reason: 'embed-failed' };
+            }
+        }
+        const hits = this.vectors.searchByCosine(vector, this.maxCandidates + 1);
+        const candidateIds = [];
+        for (const h of hits) {
+            if (h.id === unit.id)
+                continue;
+            if (h.cosine < this.minCosine)
+                continue;
+            candidateIds.push(h.id);
+            if (candidateIds.length >= this.maxCandidates)
+                break;
+        }
+        if (candidateIds.length === 0)
+            return { action: 'create' };
+        if (!this.llm)
+            return { action: 'skip', reason: 'no-judge' };
+        this.stats.judged++;
+        const verdict = await this.judge(unit, candidateIds);
+        if (!verdict)
+            return { action: 'skip', reason: 'judge-error' };
+        if (verdict.action === 'create') {
+            this.stats.creates++;
+            return { action: 'create' };
+        }
+        const targetId = verdict.target_id && candidateIds.includes(verdict.target_id)
+            ? verdict.target_id
+            : undefined;
+        if (!targetId) {
+            // Judge hallucinated a target — not a valid decision, skip (no stats).
+            return { action: 'skip', reason: 'invalid-target' };
+        }
+        const merged = await this.mergeIntoNewer(unit, targetId);
+        this.stats.updates++;
+        return { action: 'update', targetId, mergedId: merged.id };
+    }
+    async mergeIntoNewer(incoming, targetId) {
+        const target = await this.store.read(targetId);
+        if (!target) {
+            // Target vanished mid-flight — nothing to merge.
+            return incoming;
+        }
+        const merged = {
+            ...incoming,
+            memory_value: `${incoming.memory_value}\n---\n[Updated ${new Date().toISOString()}] ${target.memory_value}`,
+            cue_anchors: dedupeCap([...(incoming.cue_anchors || []), ...(target.cue_anchors || [])], 8),
+            merged_from: [...(incoming.merged_from || []), target.id],
+            energy: Math.min(1, (incoming.energy ?? 0.8) + 0.15),
+            updated_at: new Date().toISOString(),
+        };
+        await this.store.write(merged, undefined, { skipMerge: true });
+        await this.store.markSuperseded(targetId, merged.id);
+        this.vectors.remove(targetId);
+        this.vectors.flush();
+        logger_1.log.info(`[Consolidation] merged ${targetId} into ${merged.id} (cosine candidate)`);
+        return merged;
+    }
+    async judge(unit, candidateIds) {
+        const llm = this.llm;
+        const candidatesBlock = [];
+        for (const id of candidateIds) {
+            const target = await this.store.read(id);
+            if (!target)
+                continue;
+            candidatesBlock.push(`EXISTING ENTRY:\nID: ${target.id}\nIndex: ${target.primary_abstraction}\nValue: ${target.memory_value}`);
+        }
+        if (candidatesBlock.length === 0)
+            return { action: 'create' };
+        const user = `NEW MEMORY ENTRY:\nID: ${unit.id}\nIndex: ${unit.primary_abstraction}\nValue: ${unit.memory_value}\n\n${candidatesBlock.join('\n\n')}\n\nShould the new entry UPDATE one of the existing entries, or be CREATEd separately?`;
+        const fetchFn = llm.fetchFn ?? globalThis.fetch.bind(globalThis);
+        const timeoutMs = llm.timeoutMs ?? 30_000;
+        try {
+            const resp = await Promise.race([
+                fetchFn(llm.baseUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${llm.apiKey}` },
+                    body: JSON.stringify({
+                        model: llm.model,
+                        messages: [
+                            { role: 'system', content: JUDGE_SYSTEM },
+                            { role: 'user', content: user },
+                        ],
+                        temperature: 0,
+                        max_tokens: 200,
+                    }),
+                }),
+                new Promise((_, reject) => {
+                    const timer = setTimeout(() => reject(new Error('judge timeout')), timeoutMs);
+                    timer.unref?.();
+                }),
+            ]);
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status}`);
+            const data = await resp.json();
+            const content = data?.choices?.[0]?.message?.content ?? '';
+            const jsonText = content.replace(/```json|```/g, '').trim();
+            const start = jsonText.indexOf('{');
+            const end = jsonText.lastIndexOf('}');
+            if (start === -1 || end === -1)
+                return { action: 'create' };
+            const parsed = JSON.parse(jsonText.slice(start, end + 1));
+            if (parsed?.action !== 'update' && parsed?.action !== 'create')
+                return { action: 'create' };
+            return parsed;
+        }
+        catch (err) {
+            logger_1.log.warn(`[Consolidation] judge failed: ${err?.message || err}`);
+            return null;
+        }
+    }
+}
+exports.ConsolidationService = ConsolidationService;
+function dedupeCap(items, cap) {
+    const out = [];
+    for (const item of items) {
+        if (item && !out.includes(item))
+            out.push(item);
+        if (out.length >= cap)
+            break;
+    }
+    return out;
+}

package/gateway/dist/memory/derived-terms.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+exports.extractDerivedTerms = extractDerivedTerms;
+function tokenize(text) {
+    const tokens = [];
+    let i = 0;
+    while (i < text.length) {
+        if (/[\u4e00-\u9fff]/.test(text[i])) {
+            if (i + 1 < text.length && /[\u4e00-\u9fff]/.test(text[i + 1])) {
+                tokens.push(text[i] + text[i + 1]);
+            }
+            else {
+                tokens.push(text[i]);
+            }
+            i++;
+        }
+        else if (/[a-zA-Z0-9]/.test(text[i])) {
+            let word = '';
+            while (i < text.length && /[a-zA-Z0-9]/.test(text[i])) {
+                word += text[i];
+                i++;
+            }
+            if (word.length > 0)
+                tokens.push(word.toLowerCase());
+            if (word.length > 1) {
+                for (let j = 0; j < word.length - 1; j++) {
+                    tokens.push(word.slice(j, j + 2).toLowerCase());
+                }
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return [...new Set(tokens)];
+}
+function extractDerivedTerms(text, topK = 3) {
+    const terms = [];
+    const linkRegex = /\[\[([^\]]+)\]\]/g;
+    let match;
+    while ((match = linkRegex.exec(text)) !== null) {
+        terms.push(match[1]);
+    }
+    const entityRegex = /[A-Z][a-z]+[A-Z][a-z]+|[A-Z]{2,}[a-z]+[A-Z]|[a-z]+_[a-z]+/g;
+    while ((match = entityRegex.exec(text)) !== null) {
+        terms.push(match[0]);
+    }
+    return [...new Set(terms)].slice(0, topK);
+}