@ppagent/memory 0.1.0

package/dist/index.js

@@ -0,0 +1,2876 @@
+// src/memory.manager.ts
+import { v4 as uuidv44 } from "uuid";
+
+// src/config.ts
+function resolveConfig(config) {
+  let embeddingBaseUrl = config.embeddingBaseUrl;
+  let embeddingApiKey = config.embeddingApiKey;
+  if (!embeddingBaseUrl) {
+    console.warn(
+      "[MemoryConfig] embeddingBaseUrl \u672A\u914D\u7F6E\uFF0C\u81EA\u52A8\u56DE\u9000\u4F7F\u7528 llmBaseUrl\uFF1A" + config.llmBaseUrl
+    );
+    embeddingBaseUrl = config.llmBaseUrl;
+  }
+  if (!embeddingApiKey) {
+    console.warn("[MemoryConfig] embeddingApiKey \u672A\u914D\u7F6E\uFF0C\u81EA\u52A8\u56DE\u9000\u4F7F\u7528 llmApiKey\u3002");
+    embeddingApiKey = config.llmApiKey;
+  }
+  return {
+    ...config,
+    embeddingBaseUrl,
+    embeddingApiKey,
+    sessionTokenLimit: config.sessionTokenLimit ?? 16386,
+    historyWindowTokenLimit: config.historyWindowTokenLimit ?? 10240,
+    topicRatio: config.topicRatio ?? [1, 5, 20],
+    detailMaxTokens: config.detailMaxTokens ?? 2048,
+    summaryMaxTokens: config.summaryMaxTokens ?? 512,
+    conciseMaxTokens: config.conciseMaxTokens ?? 128,
+    httpTimeoutMs: config.httpTimeoutMs ?? 6e4,
+    httpMaxRetries: config.httpMaxRetries ?? 2,
+    embeddingBatchSize: config.embeddingBatchSize ?? 20,
+    embeddingConcurrency: config.embeddingConcurrency ?? 2,
+    maxConcurrentCompressions: config.maxConcurrentCompressions ?? 3,
+    entitySimilarityThreshold: config.entitySimilarityThreshold ?? 0.92,
+    defaultSearchLimit: config.defaultSearchLimit ?? 10,
+    recallBoostMs: config.recallBoostMs ?? 36e5,
+    chunkStrategy: config.chunkStrategy ?? "markdown-heading",
+    chunkMaxTokens: config.chunkMaxTokens ?? 800,
+    chunkOverlap: config.chunkOverlap ?? 0,
+    knowledgeTopK: config.knowledgeTopK ?? 8,
+    docCoarseTopK: config.docCoarseTopK ?? 5,
+    buildGraphDefault: config.buildGraphDefault ?? "auto",
+    chunkRedundantIds: config.chunkRedundantIds ?? true,
+    knowledgeGraphTriggerScore: config.knowledgeGraphTriggerScore ?? 0.78,
+    knowledgeGraphEntityTopK: config.knowledgeGraphEntityTopK ?? 10,
+    knowledgeGraphAnchorTopK: config.knowledgeGraphAnchorTopK ?? 3,
+    knowledgeGraphHopLimit: config.knowledgeGraphHopLimit ?? 10,
+    graphExtractConcurrency: config.graphExtractConcurrency ?? 2,
+    graphBuildTimeoutMs: config.graphBuildTimeoutMs ?? 12e4
+  };
+}
+
+// src/constants.ts
+var DEFAULT_NODE_TYPES = [
+  "Person",
+  "Group",
+  "Organization",
+  "Project",
+  "Task",
+  "Decision",
+  "Plan",
+  "Event",
+  "Product",
+  "Technology",
+  "Data",
+  "Document",
+  "Topic",
+  "Concept",
+  "Preference",
+  "Habit",
+  "Goal",
+  "Skill",
+  "Attribute",
+  "Value",
+  "Status",
+  "Time",
+  "Location",
+  "Resource",
+  "Relationship"
+];
+var DEFAULT_RELATION_TYPES = [
+  // 结构类
+  "is_a",
+  "part_of",
+  "belongs_to",
+  "contains",
+  "has_member",
+  // 引用类
+  "mentioned_in",
+  "refers_to",
+  "same_as",
+  "alias_of",
+  // 通用
+  "related_to",
+  "associated_with",
+  // 行为
+  "uses",
+  "creates",
+  "updates",
+  "buys",
+  "owns",
+  "consumes",
+  // 用户
+  "works_on",
+  "prefers",
+  "likes",
+  "dislikes",
+  "interested_in",
+  "favorite",
+  "plans",
+  "decides",
+  "habit_of",
+  "tends_to",
+  "avoids",
+  "skilled_in",
+  "learning",
+  // 人际关系
+  "knows",
+  "friends_with",
+  "married_to",
+  "parent_of",
+  "child_of",
+  "lives_with",
+  // 项目/技术
+  "depends_on",
+  "built_with",
+  "integrates_with",
+  "deployed_on",
+  // 数据/AI
+  "inputs",
+  "outputs",
+  "trained_on",
+  "predicts",
+  // 时间
+  "happens_at",
+  "started_at",
+  "ended_at",
+  // 因果
+  "affects",
+  "causes",
+  "leads_to",
+  "improves",
+  "reduces",
+  // 任务
+  "assigned_to",
+  "executed_by",
+  "blocks",
+  "completes",
+  // 知识
+  "describes",
+  "explains",
+  "references"
+];
+var NODE_TYPES_LIST = DEFAULT_NODE_TYPES.join(", ");
+var RELATION_TYPES_LIST = DEFAULT_RELATION_TYPES.join(", ");
+var DEFAULT_USER_ID = "default";
+var DEFAULT_CHAT_ID = "default";
+var DEFAULT_SESSION_ID = "default";
+var KIND_CONVERSATION = "conversation";
+var KIND_KNOWLEDGE = "knowledge";
+
+// src/db/grafeo.service.ts
+import { GrafeoDB } from "@grafeo-db/js";
+
+// src/llm/embed.service.ts
+import { get_encoding } from "@dqbd/tiktoken";
+
+// src/llm/http.ts
+function backoffDelay(attempt) {
+  return Math.min(1e3 * 2 ** attempt, 8e3);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function postJsonWithRetry(url, headers, body, opts, errorLabel = "HTTP") {
+  let lastErr;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs);
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      lastErr = err;
+      if (attempt < opts.maxRetries) {
+        await sleep(backoffDelay(attempt));
+        continue;
+      }
+      throw err;
+    }
+    clearTimeout(timer);
+    if (res.ok) {
+      return await res.json();
+    }
+    const text = await res.text().catch(() => "");
+    lastErr = new Error(`${errorLabel} error ${res.status}: ${text}`);
+    const retryable = res.status >= 500 || res.status === 429;
+    if (retryable && attempt < opts.maxRetries) {
+      await sleep(backoffDelay(attempt));
+      continue;
+    }
+    throw lastErr;
+  }
+  throw lastErr;
+}
+
+// src/llm/embed.service.ts
+var encoder = null;
+function initEncoder() {
+  if (!encoder) {
+    encoder = get_encoding("cl100k_base");
+  }
+}
+function countTokens(text) {
+  if (!encoder) {
+    encoder = get_encoding("cl100k_base");
+  }
+  return encoder.encode(text).length;
+}
+var EmbedService = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async embed(texts) {
+    const inputs = Array.isArray(texts) ? texts : [texts];
+    const url = `${this.config.embeddingBaseUrl.replace(/\/$/, "")}/embeddings`;
+    const batchSize = Math.max(1, this.config.embeddingBatchSize);
+    const concurrency = Math.max(1, this.config.embeddingConcurrency);
+    const retryOpts = { timeoutMs: this.config.httpTimeoutMs, maxRetries: this.config.httpMaxRetries };
+    const batches = [];
+    for (let i = 0; i < inputs.length; i += batchSize) {
+      batches.push({ index: batches.length, texts: inputs.slice(i, i + batchSize) });
+    }
+    const batchResults = await mapLimit(batches, concurrency, async (batch) => {
+      const data = await postJsonWithRetry(
+        url,
+        { Authorization: `Bearer ${this.config.embeddingApiKey}` },
+        { model: this.config.embeddingModel, input: batch.texts },
+        retryOpts,
+        "Embedding API"
+      );
+      return {
+        index: batch.index,
+        vectors: data.data.sort((a, b) => a.index - b.index).map((d) => d.embedding)
+      };
+    });
+    return batchResults.sort((a, b) => a.index - b.index).flatMap((b) => b.vectors);
+  }
+  async embedOne(text) {
+    const result = await this.embed([text]);
+    return result[0];
+  }
+};
+async function mapLimit(items, limit, mapper) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// src/db/grafeo.service.ts
+var GrafeoService = class {
+  config;
+  db;
+  constructor(config) {
+    this.config = config;
+  }
+  async init() {
+    try {
+      this.db = GrafeoDB.open(this.config.grafeoPath);
+    } catch {
+      this.db = GrafeoDB.create(this.config.grafeoPath);
+    }
+    try {
+      await this.db.createVectorIndex(
+        "Entity",
+        "embedding",
+        this.config.embeddingDimension,
+        "cosine"
+      );
+    } catch {
+    }
+    try {
+      await this.db.createTextIndex("Entity", "name");
+    } catch {
+    }
+  }
+  buildDomainFilter(userId, chatId, kind) {
+    return { userId, chatId, kind };
+  }
+  async findExactEntity(name, userId, chatId, kind) {
+    try {
+      const result = await this.db.execute(
+        `MATCH (n:Entity {name: $name, userId: $userId, chatId: $chatId, kind: $kind}) RETURN n LIMIT 1`,
+        { name, userId, chatId, kind }
+      );
+      const nodes = result.nodes();
+      return nodes.length > 0 ? nodes[0] : null;
+    } catch {
+      return null;
+    }
+  }
+  async findSimilarEntity(embedding, userId, chatId, kind, threshold) {
+    try {
+      const results = await this.db.vectorSearch(
+        "Entity",
+        "embedding",
+        embedding,
+        5,
+        void 0,
+        this.buildDomainFilter(userId, chatId, kind)
+      );
+      for (const [nodeId, distance] of results) {
+        const similarity = 1 - distance;
+        if (similarity >= threshold) {
+          const node = this.db.getNode(nodeId);
+          if (node) return node;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  async findOrCreateEntity(entity, embedding, kind) {
+    const { name, type, meta } = entity;
+    const { userId, chatId } = meta;
+    const threshold = this.config.entitySimilarityThreshold;
+    const exact = await this.findExactEntity(name, userId, chatId, kind);
+    if (exact) return exact.id;
+    const similar = await this.findSimilarEntity(embedding, userId, chatId, kind, threshold);
+    if (similar) return similar.id;
+    const extraProps = Object.fromEntries(
+      Object.entries(meta).filter(
+        ([k]) => ![
+          "userId",
+          "chatId",
+          "sessionId",
+          "kind",
+          "messageId",
+          "messageTime",
+          "docId",
+          "chunkId"
+        ].includes(k)
+      )
+    );
+    if (embedding.length > 0) {
+      const [nodeId] = await this.db.batchCreateNodes("Entity", "embedding", [embedding]);
+      this.db.addNodeLabel(nodeId, type);
+      this.db.setNodeProperty(nodeId, "name", name);
+      this.db.setNodeProperty(nodeId, "userId", userId);
+      this.db.setNodeProperty(nodeId, "chatId", chatId);
+      this.db.setNodeProperty(nodeId, "kind", kind);
+      this.db.setNodeProperty(nodeId, "sessionId", meta.sessionId);
+      for (const [k, v] of Object.entries(extraProps)) {
+        this.db.setNodeProperty(nodeId, k, v);
+      }
+      return nodeId;
+    }
+    const node = this.db.createNode(["Entity", type], {
+      name,
+      userId,
+      chatId,
+      kind,
+      sessionId: meta.sessionId,
+      ...extraProps
+    });
+    return node.id;
+  }
+  async upsertEntitiesAndRelations(entities, relations, embeddings, kind = KIND_CONVERSATION) {
+    const nodeIdMap = /* @__PURE__ */ new Map();
+    for (const entity of entities) {
+      const embedding = embeddings.get(entity.name) ?? [];
+      const nodeId = await this.findOrCreateEntity(entity, embedding, kind);
+      nodeIdMap.set(entity.name, nodeId);
+    }
+    for (const relation of relations) {
+      const fromId = nodeIdMap.get(relation.from);
+      const toId = nodeIdMap.get(relation.to);
+      if (fromId == null || toId == null) continue;
+      const existing = await this.db.execute(
+        `MATCH (a)-[r:${relation.type}]->(b) WHERE id(a) = $fromId AND id(b) = $toId RETURN r LIMIT 1`,
+        { fromId, toId }
+      );
+      if (existing.length === 0) {
+        const props = {
+          userId: relation.meta.userId,
+          chatId: relation.meta.chatId,
+          sessionId: relation.meta.sessionId,
+          kind
+        };
+        if (relation.happenedAt) props.happenedAt = relation.happenedAt;
+        if (relation.meta.messageId) props.messageId = relation.meta.messageId;
+        if (relation.meta.messageTime) props.messageTime = relation.meta.messageTime;
+        if (relation.meta.docId) props.docId = relation.meta.docId;
+        if (relation.meta.chunkId) props.chunkId = relation.meta.chunkId;
+        this.db.createEdge(fromId, toId, relation.type, props);
+      }
+    }
+  }
+  async searchEntities(vector, filter, limit = 10) {
+    try {
+      const domainFilter = {};
+      if (filter.userId) domainFilter.userId = filter.userId;
+      if (filter.chatId) domainFilter.chatId = filter.chatId;
+      if (filter.sessionId) domainFilter.sessionId = filter.sessionId;
+      if (filter.kind) domainFilter.kind = filter.kind;
+      const results = await this.db.vectorSearch(
+        "Entity",
+        "embedding",
+        vector,
+        limit,
+        void 0,
+        Object.keys(domainFilter).length > 0 ? domainFilter : void 0
+      );
+      const searchResults = [];
+      for (const [nodeId, distance] of results) {
+        const node = this.db.getNode(nodeId);
+        if (!node) continue;
+        const props = node.properties();
+        const embedding = props.embedding;
+        const similarity = embedding ? cosineSimilarity(vector, embedding) : 1 - distance;
+        searchResults.push({
+          type: "entity",
+          content: `\u5B9E\u4F53\uFF1A${props.name}\uFF08\u7C7B\u578B\uFF1A${node.labels.filter((l) => l !== "Entity").join(", ")}\uFF09`,
+          score: similarity,
+          meta: { ...props, nodeId }
+        });
+      }
+      return searchResults;
+    } catch {
+      return [];
+    }
+  }
+  async getRelatedEntities(entityName, userId, chatId, limit = 20, kind = KIND_CONVERSATION) {
+    const mapRows = (rows) => rows.map((row) => {
+      const r = row;
+      return {
+        type: "relation",
+        content: `${r["a.name"]} -[${r["type(r)"]}]-> ${r["b.name"]}`,
+        score: 1,
+        meta: { happenedAt: r["r.happenedAt"] }
+      };
+    });
+    try {
+      const result = await this.db.execute(
+        `MATCH (a:Entity {name: $name, userId: $userId, chatId: $chatId, kind: $kind})-[r]->(b)
+         WHERE r.chatId = $chatId AND r.userId = $userId
+         RETURN a.name, type(r), b.name, r.happenedAt LIMIT $limit`,
+        { name: entityName, userId, chatId, kind, limit }
+      );
+      return mapRows(result.toArray());
+    } catch {
+    }
+    try {
+      const result = await this.db.execute(
+        `MATCH (a:Entity {name: $name, userId: $userId, chatId: $chatId, kind: $kind})-[r]->(b)
+         RETURN a.name, type(r), b.name, r.happenedAt LIMIT $limit`,
+        { name: entityName, userId, chatId, kind, limit }
+      );
+      return mapRows(result.toArray());
+    } catch {
+      return [];
+    }
+  }
+  /** 删除某文档的知识图谱痕迹（best-effort：删边按 docId，再清理孤立知识节点）*/
+  async deleteKnowledgeByDoc(docId) {
+    try {
+      await this.db.execute(`MATCH ()-[r]->() WHERE r.docId = $docId DELETE r`, { docId });
+    } catch {
+    }
+    try {
+      await this.db.execute(
+        `MATCH (n:Entity {kind: $kind}) WHERE NOT (n)--() DETACH DELETE n`,
+        { kind: KIND_KNOWLEDGE }
+      );
+    } catch {
+    }
+  }
+  // ── 管理面板用：全量读取实体 / 关系 ────────────────────────────────────────────────
+  /** 全量读取实体节点（管理面板/知识图谱用，剔除体积大的 embedding 字段）*/
+  async getAllEntities(limit = 1e3) {
+    try {
+      const result = await this.db.execute(`MATCH (n:Entity) RETURN n LIMIT $limit`, { limit });
+      const nodes = result.nodes();
+      return nodes.map((node) => {
+        const props = node.properties();
+        const { embedding: _embedding, name, userId, chatId, sessionId, ...rest } = props;
+        const type = (node.labels ?? []).filter((l) => l !== "Entity").join(", ") || "\u672A\u77E5";
+        return {
+          name: String(name ?? ""),
+          type,
+          meta: {
+            userId: String(userId ?? ""),
+            chatId: String(chatId ?? ""),
+            sessionId: String(sessionId ?? ""),
+            ...rest
+          }
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+  /** 全量读取关系边（管理面板/知识图谱用）*/
+  async getAllRelations(limit = 2e3) {
+    try {
+      const result = await this.db.execute(
+        `MATCH (a:Entity)-[r]->(b:Entity)
+         RETURN a.name, type(r), b.name, r.happenedAt, r.userId, r.chatId, r.sessionId LIMIT $limit`,
+        { limit }
+      );
+      return result.toArray().map((row) => {
+        const r = row;
+        return {
+          from: String(r["a.name"] ?? ""),
+          to: String(r["b.name"] ?? ""),
+          type: String(r["type(r)"] ?? ""),
+          happenedAt: r["r.happenedAt"] != null ? Number(r["r.happenedAt"]) : void 0,
+          meta: {
+            userId: String(r["r.userId"] ?? ""),
+            chatId: String(r["r.chatId"] ?? ""),
+            sessionId: String(r["r.sessionId"] ?? "")
+          }
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+};
+
+// src/db/lance.service.ts
+import * as lancedb from "@lancedb/lancedb";
+import { Field, FixedSizeList, Float32, Int32, Int64, Schema, Utf8 } from "apache-arrow";
+
+// src/db/sql.util.ts
+function escLance(value) {
+  return String(value).replace(/'/g, "''");
+}
+function eqFilter(field, value) {
+  return `${field} = '${escLance(value)}'`;
+}
+
+// src/db/lance.service.ts
+var MESSAGES_TABLE = "messages";
+var TOPICS_TABLE = "topics";
+var FACTS_TABLE = "facts";
+var SESSIONS_TABLE = "sessions";
+var DOCUMENTS_TABLE = "documents";
+var CHUNKS_TABLE = "chunks";
+function messagesSchema(dim) {
+  return new Schema([
+    new Field("message_id", new Utf8(), false),
+    new Field("talker_id", new Utf8(), false),
+    new Field("chat_id", new Utf8(), false),
+    new Field("user_id", new Utf8(), false),
+    new Field("session_id", new Utf8(), false),
+    new Field("type", new Utf8(), false),
+    new Field("content", new Utf8(), false),
+    new Field("parts", new Utf8(), true),
+    // nullable，兼容存量数据
+    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
+    new Field("usage", new Int32(), false),
+    new Field("metadata", new Utf8(), false),
+    new Field("created_at", new Int64(), false)
+  ]);
+}
+function topicsSchema(dim) {
+  return new Schema([
+    new Field("summary_id", new Utf8(), false),
+    new Field("session_id", new Utf8(), false),
+    new Field("user_id", new Utf8(), false),
+    new Field("chat_id", new Utf8(), false),
+    new Field("title", new Utf8(), true),
+    // nullable，兼容存量数据
+    new Field("detail", new Utf8(), false),
+    new Field("summary", new Utf8(), false),
+    new Field("concise", new Utf8(), false),
+    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
+    new Field("start_time", new Int64(), false),
+    new Field("end_time", new Int64(), false),
+    new Field("created_at", new Int64(), false),
+    new Field("updated_at", new Int64(), false),
+    new Field("recall_count", new Int32(), false)
+  ]);
+}
+function factsSchema() {
+  return new Schema([
+    new Field("fact_id", new Utf8(), false),
+    new Field("level", new Utf8(), false),
+    new Field("chat_id", new Utf8(), false),
+    new Field("session_id", new Utf8(), false),
+    new Field("user_id", new Utf8(), false),
+    new Field("content", new Utf8(), false),
+    new Field("created_at", new Int64(), false)
+  ]);
+}
+function sessionsSchema() {
+  return new Schema([
+    new Field("session_id", new Utf8(), false),
+    new Field("chat_id", new Utf8(), false),
+    new Field("user_id", new Utf8(), false),
+    new Field("title", new Utf8(), false),
+    new Field("metadata", new Utf8(), false),
+    new Field("created_at", new Int64(), false),
+    new Field("updated_at", new Int64(), false)
+  ]);
+}
+function documentsSchema(dim) {
+  return new Schema([
+    new Field("doc_id", new Utf8(), false),
+    new Field("user_id", new Utf8(), false),
+    new Field("chat_id", new Utf8(), false),
+    new Field("session_id", new Utf8(), false),
+    new Field("title", new Utf8(), false),
+    new Field("source_name", new Utf8(), false),
+    new Field("full_content", new Utf8(), false),
+    new Field("content_hash", new Utf8(), false),
+    new Field("summary", new Utf8(), false),
+    // vector 列存储文档摘要向量（summaryVector），用于文档级粗召回
+    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
+    new Field("chunk_count", new Int32(), false),
+    new Field("has_graph", new Int32(), false),
+    // 0/1 充当布尔
+    new Field("metadata", new Utf8(), false),
+    new Field("created_at", new Int64(), false),
+    new Field("updated_at", new Int64(), false)
+  ]);
+}
+function chunksSchema(dim) {
+  return new Schema([
+    new Field("chunk_id", new Utf8(), false),
+    new Field("doc_id", new Utf8(), false),
+    // user_id/chat_id/session_id：chunkRedundantIds=false 时存空串，仅经 documents join 过滤
+    new Field("user_id", new Utf8(), false),
+    new Field("chat_id", new Utf8(), false),
+    new Field("session_id", new Utf8(), false),
+    new Field("content", new Utf8(), false),
+    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
+    new Field("heading_path", new Utf8(), false),
+    new Field("ordinal", new Int32(), false),
+    new Field("tokens", new Int32(), false),
+    new Field("metadata", new Utf8(), false),
+    new Field("created_at", new Int64(), false)
+  ]);
+}
+function messageToRow(m) {
+  return {
+    message_id: m.messageId,
+    talker_id: m.talkerId,
+    chat_id: m.chatId,
+    user_id: m.userId,
+    session_id: m.sessionId,
+    type: m.type,
+    content: m.content,
+    parts: m.parts ?? "[]",
+    vector: m.vector,
+    usage: m.usage,
+    metadata: m.metadata,
+    created_at: m.createdAt
+  };
+}
+function rowToMessage(r) {
+  return {
+    messageId: r.message_id,
+    talkerId: r.talker_id,
+    chatId: r.chat_id,
+    userId: r.user_id,
+    sessionId: r.session_id,
+    type: r.type,
+    content: r.content,
+    parts: r.parts ?? "[]",
+    // 旧数据无此列时安全降级
+    vector: Array.from(r.vector),
+    usage: Number(r.usage),
+    metadata: r.metadata,
+    createdAt: Number(r.created_at)
+  };
+}
+function topicToRow(t) {
+  return {
+    summary_id: t.summaryId,
+    session_id: t.sessionId,
+    user_id: t.userId,
+    chat_id: t.chatId,
+    title: t.title ?? "",
+    detail: t.detail,
+    summary: t.summary,
+    concise: t.concise,
+    vector: t.vector,
+    start_time: t.startTime,
+    end_time: t.endTime,
+    created_at: t.createdAt,
+    updated_at: t.updatedAt,
+    recall_count: t.recallCount
+  };
+}
+function rowToTopic(r) {
+  return {
+    summaryId: r.summary_id,
+    sessionId: r.session_id,
+    userId: r.user_id,
+    chatId: r.chat_id,
+    title: r.title ?? "",
+    detail: r.detail,
+    summary: r.summary,
+    concise: r.concise,
+    vector: Array.from(r.vector),
+    startTime: Number(r.start_time),
+    endTime: Number(r.end_time),
+    createdAt: Number(r.created_at),
+    updatedAt: Number(r.updated_at),
+    recallCount: Number(r.recall_count)
+  };
+}
+function factToRow(f) {
+  return {
+    fact_id: f.factId,
+    level: f.level,
+    chat_id: f.chatId,
+    session_id: f.sessionId,
+    user_id: f.userId,
+    content: f.content,
+    created_at: f.createdAt
+  };
+}
+function rowToFact(r) {
+  return {
+    factId: r.fact_id,
+    level: r.level,
+    chatId: r.chat_id,
+    sessionId: r.session_id,
+    userId: r.user_id,
+    content: r.content,
+    createdAt: Number(r.created_at)
+  };
+}
+function sessionToRow(s) {
+  return {
+    session_id: s.sessionId,
+    chat_id: s.chatId,
+    user_id: s.userId,
+    title: s.title,
+    metadata: s.metadata,
+    created_at: s.createdAt,
+    updated_at: s.updatedAt
+  };
+}
+function rowToSession(r) {
+  return {
+    sessionId: r.session_id,
+    chatId: r.chat_id,
+    userId: r.user_id,
+    title: r.title,
+    metadata: r.metadata,
+    createdAt: Number(r.created_at),
+    updatedAt: Number(r.updated_at)
+  };
+}
+function documentToRow(d) {
+  return {
+    doc_id: d.docId,
+    user_id: d.userId,
+    chat_id: d.chatId,
+    session_id: d.sessionId,
+    title: d.title,
+    source_name: d.sourceName,
+    full_content: d.fullContent,
+    content_hash: d.contentHash,
+    summary: d.summary,
+    vector: d.summaryVector,
+    chunk_count: d.chunkCount,
+    has_graph: d.hasGraph ? 1 : 0,
+    metadata: JSON.stringify(d.metadata ?? {}),
+    created_at: d.createdAt,
+    updated_at: d.updatedAt
+  };
+}
+function rowToDocument(r) {
+  return {
+    docId: r.doc_id,
+    userId: r.user_id,
+    chatId: r.chat_id,
+    sessionId: r.session_id,
+    title: r.title,
+    sourceName: r.source_name,
+    fullContent: r.full_content,
+    contentHash: r.content_hash,
+    summary: r.summary,
+    summaryVector: Array.from(r.vector),
+    chunkCount: Number(r.chunk_count),
+    hasGraph: Number(r.has_graph) === 1,
+    metadata: safeParseObject(r.metadata),
+    createdAt: Number(r.created_at),
+    updatedAt: Number(r.updated_at)
+  };
+}
+function chunkToRow(c) {
+  return {
+    chunk_id: c.chunkId,
+    doc_id: c.docId,
+    user_id: c.userId,
+    chat_id: c.chatId,
+    session_id: c.sessionId,
+    content: c.content,
+    vector: c.vector,
+    heading_path: c.headingPath,
+    ordinal: c.ordinal,
+    tokens: c.tokens,
+    metadata: JSON.stringify(c.metadata ?? {}),
+    created_at: c.createdAt
+  };
+}
+function rowToChunk(r) {
+  return {
+    chunkId: r.chunk_id,
+    docId: r.doc_id,
+    userId: r.user_id,
+    chatId: r.chat_id,
+    sessionId: r.session_id,
+    content: r.content,
+    vector: Array.from(r.vector),
+    headingPath: r.heading_path,
+    ordinal: Number(r.ordinal),
+    tokens: Number(r.tokens),
+    metadata: safeParseObject(r.metadata),
+    createdAt: Number(r.created_at)
+  };
+}
+function safeParseObject(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+var LanceService = class {
+  config;
+  conn;
+  messagesTable;
+  topicsTable;
+  factsTable;
+  sessionsTable;
+  documentsTable;
+  chunksTable;
+  // Scalar indexes cannot be created on empty tables (LanceDB btree limitation).
+  // These flags defer creation to the first insert.
+  isNewMessagesTable = false;
+  isNewSessionsTable = false;
+  isNewDocumentsTable = false;
+  isNewChunksTable = false;
+  constructor(config) {
+    this.config = config;
+  }
+  async init() {
+    this.conn = await lancedb.connect(this.config.lancedbPath);
+    const dim = this.config.embeddingDimension;
+    const existingTables = await this.conn.tableNames();
+    if (existingTables.includes(MESSAGES_TABLE)) {
+      this.messagesTable = await this.conn.openTable(MESSAGES_TABLE);
+      await this._ensurePartsColumn();
+      await this.ensureScalarIndex(this.messagesTable, "message_id");
+    } else {
+      this.messagesTable = await this.conn.createEmptyTable(
+        MESSAGES_TABLE,
+        messagesSchema(dim)
+      );
+      this.isNewMessagesTable = true;
+    }
+    if (existingTables.includes(TOPICS_TABLE)) {
+      this.topicsTable = await this.conn.openTable(TOPICS_TABLE);
+      await this._ensureTopicTitleColumn();
+    } else {
+      this.topicsTable = await this.conn.createEmptyTable(
+        TOPICS_TABLE,
+        topicsSchema(dim)
+      );
+    }
+    if (existingTables.includes(FACTS_TABLE)) {
+      this.factsTable = await this.conn.openTable(FACTS_TABLE);
+    } else {
+      this.factsTable = await this.conn.createEmptyTable(FACTS_TABLE, factsSchema());
+    }
+    if (existingTables.includes(SESSIONS_TABLE)) {
+      this.sessionsTable = await this.conn.openTable(SESSIONS_TABLE);
+      await this.ensureScalarIndex(this.sessionsTable, "session_id");
+    } else {
+      this.sessionsTable = await this.conn.createEmptyTable(SESSIONS_TABLE, sessionsSchema());
+      this.isNewSessionsTable = true;
+    }
+    if (existingTables.includes(DOCUMENTS_TABLE)) {
+      this.documentsTable = await this.conn.openTable(DOCUMENTS_TABLE);
+      await this.ensureScalarIndex(this.documentsTable, "doc_id");
+    } else {
+      this.documentsTable = await this.conn.createEmptyTable(DOCUMENTS_TABLE, documentsSchema(dim));
+      this.isNewDocumentsTable = true;
+    }
+    if (existingTables.includes(CHUNKS_TABLE)) {
+      this.chunksTable = await this.conn.openTable(CHUNKS_TABLE);
+      await this.ensureScalarIndex(this.chunksTable, "doc_id");
+    } else {
+      this.chunksTable = await this.conn.createEmptyTable(CHUNKS_TABLE, chunksSchema(dim));
+      this.isNewChunksTable = true;
+    }
+    await this.ensureFtsIndexes();
+  }
+  async ensureFtsIndexes() {
+    const ftsTargets = [
+      { table: this.messagesTable, column: "content" },
+      { table: this.messagesTable, column: "metadata" },
+      // 支持 metadata 内容全文检索
+      { table: this.topicsTable, column: "detail" },
+      { table: this.chunksTable, column: "content" }
+      // 知识片段混合检索
+    ];
+    for (const { table, column } of ftsTargets) {
+      try {
+        await table.createIndex(column, { config: lancedb.Index.fts() });
+      } catch {
+      }
+    }
+  }
+  /**
+   * 为存量 messages 表添加 parts 列（如果缺失）。
+   * LanceDB 0.14+ 支持 addColumns；旧版本会 throw，此时 rowToMessage 的 ?? "[]" 兜底。
+   */
+  async _ensurePartsColumn() {
+    try {
+      const schema = await this.messagesTable.schema();
+      const hasPartsCol = schema.fields?.some(
+        (f) => f.name === "parts"
+      );
+      if (!hasPartsCol) {
+        await this.messagesTable.addColumns([
+          { name: "parts", valueSql: "CAST(NULL AS STRING)" }
+        ]);
+      }
+    } catch {
+    }
+  }
+  /**
+   * 为存量 topics 表添加 title 列（如果缺失）。
+   * 旧版本不支持 addColumns 时忽略，读取时 rowToTopic 的 ?? "" 兜底。
+   */
+  async _ensureTopicTitleColumn() {
+    try {
+      const schema = await this.topicsTable.schema();
+      const hasTitleCol = schema.fields?.some(
+        (f) => f.name === "title"
+      );
+      if (!hasTitleCol) {
+        await this.topicsTable.addColumns([
+          { name: "title", valueSql: "CAST(NULL AS STRING)" }
+        ]);
+      }
+    } catch {
+    }
+  }
+  // LanceDB btree scalar indexes require at least one row.
+  // For existing tables (opened in init) this is safe; for new tables we defer via isNew*Table flags.
+  async ensureScalarIndex(table, column) {
+    try {
+      await table.createIndex(column);
+    } catch {
+    }
+  }
+  async addMessages(messages) {
+    if (messages.length === 0) return;
+    await this.messagesTable.add(messages.map(messageToRow));
+    if (this.isNewMessagesTable) {
+      await this.ensureScalarIndex(this.messagesTable, "message_id");
+      this.isNewMessagesTable = false;
+    }
+  }
+  async addTopic(topic) {
+    await this.topicsTable.add([topicToRow(topic)]);
+  }
+  async updateTopicRecallCount(summaryId, count) {
+    await this.topicsTable.update({
+      values: { recall_count: count, updated_at: Date.now() },
+      where: eqFilter("summary_id", summaryId)
+    });
+  }
+  async getRecentTopics(chatId, userId, n1, n2, n3) {
+    const filter = `${eqFilter("chat_id", chatId)} AND ${eqFilter("user_id", userId)}`;
+    const recallBoostMs = this.config.recallBoostMs;
+    const fetchTopics = async (count) => {
+      if (count <= 0) return [];
+      try {
+        const rows = await this.topicsTable.query().where(filter).limit(count * 5).toArray();
+        return rows.sort((a, b) => {
+          const scoreA = Number(a.end_time) + Number(a.recall_count) * recallBoostMs;
+          const scoreB = Number(b.end_time) + Number(b.recall_count) * recallBoostMs;
+          return scoreB - scoreA;
+        }).slice(0, count).map(rowToTopic);
+      } catch {
+        return [];
+      }
+    };
+    const allTopics = await fetchTopics(n1 + n2 + n3);
+    return {
+      detail: allTopics.slice(0, n1),
+      summary: allTopics.slice(n1, n1 + n2),
+      concise: allTopics.slice(n1 + n2, n1 + n2 + n3)
+    };
+  }
+  async getMessagesSince(sessionId, since, limit) {
+    try {
+      const q = this.messagesTable.query().where(`${eqFilter("session_id", sessionId)} AND created_at > ${since}`);
+      if (limit) q.limit(limit);
+      const rows = await q.toArray();
+      return rows.sort((a, b) => Number(a.created_at) - Number(b.created_at)).map(rowToMessage);
+    } catch {
+      return [];
+    }
+  }
+  async getLatestMessages(sessionId, limit) {
+    try {
+      const rows = await this.messagesTable.query().where(eqFilter("session_id", sessionId)).limit(limit * 3).toArray();
+      return rows.sort((a, b) => Number(b.created_at) - Number(a.created_at)).slice(0, limit).reverse().map(rowToMessage);
+    } catch {
+      return [];
+    }
+  }
+  async searchMessages(vector, filter, limit = 10) {
+    const q = this.messagesTable.vectorSearch(vector).limit(limit);
+    if (filter) q.where(filter);
+    const rows = await q.toArray();
+    return rows.map((r) => ({
+      ...rowToMessage(r),
+      _distance: r._distance
+    }));
+  }
+  // 对 messages 表执行混合搜索（BM25 + 向量），用于 topics 搜索无结果时的回退
+  async hybridSearchMessages(query, vector, filter, limit = 10) {
+    try {
+      const q = this.messagesTable.query().fullTextSearch(query).nearestTo(vector).limit(limit);
+      if (filter) q.where(filter);
+      const rows = await q.toArray();
+      return rows.map(rowToMessage);
+    } catch {
+      const rows = await this.searchMessages(vector, filter, limit);
+      return rows.map(({ _distance: _d, ...r }) => r);
+    }
+  }
+  async hybridSearchTopics(query, vector, filter, limit = 10) {
+    const recallBoostMs = this.config.recallBoostMs;
+    try {
+      const q = this.topicsTable.query().fullTextSearch(query).nearestTo(vector).limit(limit);
+      if (filter) q.where(filter);
+      const rows = await q.toArray();
+      if (rows.length > 0) {
+        const total = rows.length;
+        return rows.map((r, idx) => ({
+          row: r,
+          // 位置分（越前越高）+ recall_count 加成
+          score: 1 - idx / total + Math.log1p(Number(r.recall_count)) * 0.1
+        })).sort((a, b) => b.score - a.score).map((x) => rowToTopic(x.row));
+      }
+    } catch {
+    }
+    const msgRows = await this.hybridSearchMessages(query, vector, filter, limit);
+    return msgRows.map((r) => ({
+      summaryId: r.messageId,
+      sessionId: r.sessionId,
+      userId: r.userId,
+      chatId: r.chatId,
+      detail: r.content,
+      summary: r.content,
+      concise: r.content,
+      startTime: r.createdAt,
+      endTime: r.createdAt,
+      createdAt: r.createdAt,
+      updatedAt: r.createdAt,
+      recallCount: 0,
+      vector: r.vector
+    }));
+  }
+  async saveFact(fact) {
+    await this.factsTable.add([factToRow(fact)]);
+  }
+  async getAllFacts() {
+    try {
+      const rows = await this.factsTable.query().toArray();
+      return rows.map(rowToFact);
+    } catch {
+      return [];
+    }
+  }
+  async getAllSessionIds() {
+    try {
+      const rows = await this.messagesTable.query().select(["session_id"]).limit(1e4).toArray();
+      return [...new Set(rows.map((r) => r.session_id))];
+    } catch {
+      return [];
+    }
+  }
+  async insertSession(session) {
+    await this.sessionsTable.add([sessionToRow(session)]);
+    if (this.isNewSessionsTable) {
+      await this.ensureScalarIndex(this.sessionsTable, "session_id");
+      this.isNewSessionsTable = false;
+    }
+  }
+  async upsertSession(session) {
+    await this.sessionsTable.delete(eqFilter("session_id", session.sessionId));
+    await this.sessionsTable.add([sessionToRow(session)]);
+  }
+  async getAllSessions() {
+    try {
+      const rows = await this.sessionsTable.query().toArray();
+      return rows.map(rowToSession);
+    } catch {
+      return [];
+    }
+  }
+  async deleteSession(sessionId) {
+    await this.sessionsTable.delete(eqFilter("session_id", sessionId));
+  }
+  // ── 管理面板用：全量读取 / 删除 / 计数 ──────────────────────────────────────────────
+  /** 全量读取 topics（管理面板列表用，不做 recall 加权排序，按 endTime 倒序）*/
+  async getAllTopics() {
+    try {
+      const rows = await this.topicsTable.query().toArray();
+      return rows.sort((a, b) => Number(b.end_time) - Number(a.end_time)).map(rowToTopic);
+    } catch {
+      return [];
+    }
+  }
+  /** 删除单条 fact */
+  async deleteFact(factId) {
+    await this.factsTable.delete(eqFilter("fact_id", factId));
+  }
+  /** 删除某会话下的全部消息（级联删除会话时使用）*/
+  async deleteMessagesBySession(sessionId) {
+    await this.messagesTable.delete(eqFilter("session_id", sessionId));
+  }
+  /** 删除某会话下的全部 topics（级联删除会话时使用）*/
+  async deleteTopicsBySession(sessionId) {
+    await this.topicsTable.delete(eqFilter("session_id", sessionId));
+  }
+  /** 各表行数统计（概览卡片用）*/
+  async countAll() {
+    const safeCount = async (table) => {
+      try {
+        return await table.countRows();
+      } catch {
+        return 0;
+      }
+    };
+    const [sessions, messages, topics, facts] = await Promise.all([
+      safeCount(this.sessionsTable),
+      safeCount(this.messagesTable),
+      safeCount(this.topicsTable),
+      safeCount(this.factsTable)
+    ]);
+    return { sessions, messages, topics, facts };
+  }
+  /**
+   * 按天聚合最近 days 天的活跃趋势（概览图表用）。
+   * 返回连续日期序列（含无数据的零值天），按本地日期分桶。
+   */
+  async trendDaily(days) {
+    const dayMs = 864e5;
+    const now = /* @__PURE__ */ new Date();
+    const todayMidnight = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+    const startMs = todayMidnight - (days - 1) * dayMs;
+    const fmt = (ts) => {
+      const d = new Date(ts);
+      const mm = String(d.getMonth() + 1).padStart(2, "0");
+      const dd = String(d.getDate()).padStart(2, "0");
+      return `${d.getFullYear()}-${mm}-${dd}`;
+    };
+    const readCreatedAt = async (table) => {
+      try {
+        const rows = await table.query().select(["created_at"]).where(`created_at >= ${startMs}`).limit(1e6).toArray();
+        return rows.map((r) => Number(r.created_at)).filter((n) => Number.isFinite(n));
+      } catch {
+        return [];
+      }
+    };
+    const [sessionTs, messageTs, factTs] = await Promise.all([
+      readCreatedAt(this.sessionsTable),
+      readCreatedAt(this.messagesTable),
+      readCreatedAt(this.factsTable)
+    ]);
+    const buckets = /* @__PURE__ */ new Map();
+    for (let i = 0; i < days; i++) {
+      const key = fmt(startMs + i * dayMs);
+      buckets.set(key, { date: key, sessions: 0, messages: 0, facts: 0 });
+    }
+    const tally = (list, field) => {
+      for (const ts of list) {
+        const b = buckets.get(fmt(ts));
+        if (b) b[field]++;
+      }
+    };
+    tally(sessionTs, "sessions");
+    tally(messageTs, "messages");
+    tally(factTs, "facts");
+    return [...buckets.values()];
+  }
+  // ── 知识库：documents / chunks ─────────────────────────────────────────────
+  async addDocument(doc) {
+    await this.documentsTable.add([documentToRow(doc)]);
+    if (this.isNewDocumentsTable) {
+      await this.ensureScalarIndex(this.documentsTable, "doc_id");
+      this.isNewDocumentsTable = false;
+    }
+  }
+  async addChunks(chunks) {
+    if (chunks.length === 0) return;
+    await this.chunksTable.add(chunks.map(chunkToRow));
+    if (this.isNewChunksTable) {
+      await this.ensureScalarIndex(this.chunksTable, "doc_id");
+      this.isNewChunksTable = false;
+    }
+  }
+  async updateDocumentGraphFlag(docId, hasGraph) {
+    await this.documentsTable.update({
+      values: { has_graph: hasGraph ? 1 : 0, updated_at: Date.now() },
+      where: eqFilter("doc_id", docId)
+    });
+  }
+  async getDocument(docId) {
+    try {
+      const rows = await this.documentsTable.query().where(eqFilter("doc_id", docId)).limit(1).toArray();
+      if (rows.length === 0) return null;
+      return rowToDocument(rows[0]);
+    } catch {
+      return null;
+    }
+  }
+  /** 查找同域同 hash 的文档（去重用）*/
+  async findDocumentByHash(contentHash, filter) {
+    try {
+      const where = filter ? `${eqFilter("content_hash", contentHash)} AND ${filter}` : eqFilter("content_hash", contentHash);
+      const rows = await this.documentsTable.query().where(where).limit(1).toArray();
+      if (rows.length === 0) return null;
+      return rowToDocument(rows[0]);
+    } catch {
+      return null;
+    }
+  }
+  /** 按域过滤返回 docId 列表（chunkRedundantIds=false 时用于 chunk 过滤）*/
+  async getDocIdsByDomain(filter) {
+    try {
+      const q = this.documentsTable.query().select(["doc_id"]).limit(1e5);
+      if (filter) q.where(filter);
+      const rows = await q.toArray();
+      return [...new Set(rows.map((r) => r.doc_id))];
+    } catch {
+      return [];
+    }
+  }
+  /** 文档级粗召回：对摘要向量做向量搜索，定位候选文档 */
+  async searchDocuments(vector, filter, limit = 5) {
+    try {
+      const q = this.documentsTable.vectorSearch(vector).limit(limit);
+      if (filter) q.where(filter);
+      const rows = await q.toArray();
+      return rows.map((r) => ({
+        ...rowToDocument(r),
+        _distance: r._distance
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /** 知识片段混合检索（BM25 + 向量），失败回退纯向量 */
+  async searchChunks(query, vector, filter, limit = 8) {
+    try {
+      const q = this.chunksTable.query().fullTextSearch(query).nearestTo(vector).limit(limit);
+      if (filter) q.where(filter);
+      const rows = await q.toArray();
+      return rows.map(rowToChunk);
+    } catch {
+      try {
+        const q = this.chunksTable.vectorSearch(vector).limit(limit);
+        if (filter) q.where(filter);
+        const rows = await q.toArray();
+        return rows.map(rowToChunk);
+      } catch {
+        return [];
+      }
+    }
+  }
+  async deleteDocument(docId) {
+    await this.documentsTable.delete(eqFilter("doc_id", docId));
+  }
+  async deleteChunksByDoc(docId) {
+    await this.chunksTable.delete(eqFilter("doc_id", docId));
+  }
+  /** 全量读取文档（管理面板用），按更新时间倒序 */
+  async getAllDocuments() {
+    try {
+      const rows = await this.documentsTable.query().toArray();
+      return rows.sort((a, b) => Number(b.updated_at) - Number(a.updated_at)).map(rowToDocument);
+    } catch {
+      return [];
+    }
+  }
+  /** 知识库行数统计 */
+  async countKnowledge() {
+    const safeCount = async (table) => {
+      try {
+        return await table.countRows();
+      } catch {
+        return 0;
+      }
+    };
+    const [documents, chunks] = await Promise.all([
+      safeCount(this.documentsTable),
+      safeCount(this.chunksTable)
+    ]);
+    return { documents, chunks };
+  }
+  /**
+   * 根据 metadata 字段内容构建 SQL LIKE 过滤条件。
+   *
+   * metadata 以 JSON 字符串存储，此方法将键值对转换为 SQL LIKE 表达式，
+   * 可直接传给 searchMessages / hybridSearchTopics 的 filter 参数。
+   *
+   * 示例：buildMetadataFilter({ env: "prod", version: 2 })
+   *   → `metadata LIKE '%"env":"prod"%' AND metadata LIKE '%"version":2%'`
+   *
+   * 注意：仅适合简单标量值（字符串、数字、布尔）的精确匹配。
+   * 复杂嵌套对象或含空格的 JSON 值可能无法可靠匹配。
+   */
+  static buildMetadataFilter(conditions) {
+    return Object.entries(conditions).map(([key, value]) => {
+      const jsonValue = typeof value === "string" ? `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : String(value);
+      return `metadata LIKE '%"${key}":${jsonValue}%'`;
+    }).join(" AND ");
+  }
+};
+
+// src/llm/llm.service.ts
+var ENTITY_EXTRACTOR_TOOL = {
+  type: "function",
+  function: {
+    name: "extract_entities",
+    description: "\u4ECE\u5BF9\u8BDD\u5185\u5BB9\u4E2D\u63D0\u53D6\u547D\u540D\u5B9E\u4F53\u548C\u5173\u7CFB\u3002\u4EC5\u5728\u5BF9\u8BDD\u4E2D\u660E\u786E\u51FA\u73B0\u6709\u610F\u4E49\u7684\u5B9E\u4F53\uFF08\u4EBA\u7269\u3001\u7EC4\u7EC7\u3001\u9879\u76EE\u3001\u5730\u70B9\u3001\u6280\u672F\u7B49\uFF09\u65F6\u8C03\u7528\u6B64\u5DE5\u5177\uFF0C\u5426\u5219\u4E0D\u8C03\u7528\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        entities: {
+          type: "array",
+          description: "\u5BF9\u8BDD\u4E2D\u51FA\u73B0\u7684\u5B9E\u4F53\u5217\u8868",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "\u5B9E\u4F53\u540D\u79F0" },
+              type: {
+                type: "string",
+                enum: [...DEFAULT_NODE_TYPES],
+                description: "\u5B9E\u4F53\u7C7B\u578B"
+              },
+              meta: {
+                type: "object",
+                description: "\u5B9E\u4F53\u9644\u52A0\u5C5E\u6027\uFF08\u5E74\u9F84\u3001\u6027\u522B\u3001\u804C\u4F4D\u7B49\uFF09\uFF0C\u65E0\u5219\u7701\u7565",
+                additionalProperties: true
+              }
+            },
+            required: ["name", "type"]
+          }
+        },
+        relations: {
+          type: "array",
+          description: "\u5BF9\u8BDD\u4E2D\u51FA\u73B0\u7684\u5173\u7CFB\u5217\u8868",
+          items: {
+            type: "object",
+            properties: {
+              from: { type: "string", description: "\u5173\u7CFB\u8D77\u70B9\u5B9E\u4F53\u540D\u79F0" },
+              to: { type: "string", description: "\u5173\u7CFB\u7EC8\u70B9\u5B9E\u4F53\u540D\u79F0" },
+              type: {
+                type: "string",
+                enum: [...DEFAULT_RELATION_TYPES],
+                description: "\u5173\u7CFB\u7C7B\u578B"
+              },
+              happenedAt: {
+                type: "number",
+                description: "\u5173\u7CFB\u53D1\u751F\u65F6\u95F4\uFF08Unix \u6BEB\u79D2\u65F6\u95F4\u6233\uFF09\u3002\u5982\u6709\u65F6\u95F4\u63CF\u8FF0\uFF08\u5982\u300C\u53BB\u5E74\u300D\uFF09\u8BF7\u6839\u636E\u5F53\u524D\u7CFB\u7EDF\u65F6\u95F4\u63A8\u7B97\uFF0C\u65E0\u6CD5\u786E\u5B9A\u5219\u7701\u7565\u6B64\u5B57\u6BB5"
+              },
+              meta: {
+                type: "object",
+                description: "\u5173\u7CFB\u9644\u52A0\u5C5E\u6027",
+                additionalProperties: true
+              }
+            },
+            required: ["from", "to", "type"]
+          }
+        }
+      },
+      required: ["entities", "relations"]
+    }
+  }
+};
+var LlmService = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  // ── 基础请求（不使用工具）──────────────────────────────────────────────────────
+  /**
+   * @param jsonMode 是否要求 JSON 输出（response_format: json_object）。
+   *   仅在提示词明确要求 JSON 时启用；返回自然语言的调用（如 summarizeSearchResults）
+   *   必须传 false，否则部分端点会因 "messages 未含 json 字样" 而 400。
+   */
+  async chatCompletion(systemPrompt, userPrompt, jsonMode = true) {
+    const url = `${this.config.llmBaseUrl.replace(/\/$/, "")}/chat/completions`;
+    const body = {
+      model: this.config.llmModel,
+      stream: false,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ]
+    };
+    if (jsonMode) body.response_format = { type: "json_object" };
+    const data = await postJsonWithRetry(
+      url,
+      { Authorization: `Bearer ${this.config.llmApiKey}` },
+      body,
+      { timeoutMs: this.config.httpTimeoutMs, maxRetries: this.config.httpMaxRetries },
+      "LLM API"
+    );
+    return data.choices[0].message.content ?? "";
+  }
+  // ── 带工具调用的请求 ──────────────────────────────────────────────────────────
+  async chatWithTools(systemPrompt, userPrompt) {
+    const url = `${this.config.llmBaseUrl.replace(/\/$/, "")}/chat/completions`;
+    const data = await postJsonWithRetry(
+      url,
+      { Authorization: `Bearer ${this.config.llmApiKey}` },
+      {
+        model: this.config.llmModel,
+        stream: false,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        tools: [ENTITY_EXTRACTOR_TOOL],
+        tool_choice: "auto"
+      },
+      { timeoutMs: this.config.httpTimeoutMs, maxRetries: this.config.httpMaxRetries },
+      "LLM API"
+    );
+    return data.choices[0].message;
+  }
+  // ── 第一步：生成三级摘要（JSON 输出）──────────────────────────────────────────
+  async summarizeMessages(messages) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const { detailMaxTokens, summaryMaxTokens, conciseMaxTokens } = this.config;
+    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u5BF9\u8BDD\u8BB0\u5FC6\u7BA1\u7406\u52A9\u624B\u3002\u5F53\u524D\u7CFB\u7EDF\u65F6\u95F4\uFF1A${now}\u3002
+\u8BF7\u5BF9\u7ED9\u5B9A\u7684\u5BF9\u8BDD\u5185\u5BB9\u751F\u6210\u4E00\u4E2A\u4E3B\u9898\u6807\u9898\u548C\u4E09\u7EA7\u6458\u8981\u3002
+
+\u8981\u6C42\uFF1A
+- title\uFF1A\u4E3B\u9898\u6807\u9898\uFF0C\u4E00\u53E5\u8BDD\uFF08\u5EFA\u8BAE\u4E0D\u8D85\u8FC7 20 \u5B57\uFF09\uFF0C\u9AD8\u5EA6\u6982\u62EC\u8FD9\u6BB5\u5BF9\u8BDD\u7684\u4E3B\u9898\uFF0C\u7528\u4E8E\u5217\u8868\u5C55\u793A
+- detail\uFF1A\u8BE6\u7EC6\u6458\u8981\uFF0C\u6700\u591A ${detailMaxTokens} tokens\uFF0C\u4FDD\u7559\u5173\u952E\u4E8B\u5B9E\u3001\u4EBA\u7269\u548C\u65F6\u95F4
+- summary\uFF1A\u4E2D\u7B49\u6458\u8981\uFF0C\u6700\u591A ${summaryMaxTokens} tokens
+- concise\uFF1A\u4E00\u4E24\u53E5\u8BDD\u7684\u7B80\u6D01\u6458\u8981\uFF0C\u6700\u591A ${conciseMaxTokens} tokens
+
+\u8F93\u51FA\u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981\u5305\u542B\u4EFB\u4F55 markdown \u6807\u8BB0\uFF0C\u683C\u5F0F\u5982\u4E0B\uFF1A
+{"title": "...", "detail": "...", "summary": "...", "concise": "..."}`;
+    const formatted = messages.map((m) => `[${new Date(m.createdAt).toISOString()}] ${m.talkerId || "user"}: ${m.content}`).join("\n");
+    const raw = await this.chatCompletion(systemPrompt, `\u8BF7\u5BF9\u4EE5\u4E0B\u5BF9\u8BDD\u751F\u6210\u4E3B\u9898\u6807\u9898\u548C\u4E09\u7EA7\u6458\u8981\uFF1A
+
+${formatted}`);
+    const parsed = JSON.parse(raw);
+    return { title: parsed.title ?? "", detail: parsed.detail, summary: parsed.summary, concise: parsed.concise };
+  }
+  // ── 第二步：通过工具调用提取实体和关系 ──────────────────────────────────────
+  async extractEntitiesFromMessages(messages) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u5B9E\u4F53\u5173\u7CFB\u62BD\u53D6\u52A9\u624B\u3002\u5F53\u524D\u7CFB\u7EDF\u65F6\u95F4\uFF1A${now}\u3002
+\u68C0\u67E5\u7ED9\u5B9A\u7684\u5BF9\u8BDD\u5185\u5BB9\uFF0C\u5224\u65AD\u5176\u4E2D\u662F\u5426\u5B58\u5728\u503C\u5F97\u8BB0\u5F55\u7684\u547D\u540D\u5B9E\u4F53\uFF08\u4EBA\u7269\u3001\u7EC4\u7EC7\u3001\u9879\u76EE\u3001\u5730\u70B9\u3001\u6280\u672F\u7B49\uFF09\u548C\u5B83\u4EEC\u4E4B\u95F4\u7684\u5173\u7CFB\u3002
+- \u5982\u679C\u5B58\u5728\u6709\u610F\u4E49\u7684\u5B9E\u4F53\u548C\u5173\u7CFB\uFF0C\u8C03\u7528 extract_entities \u5DE5\u5177\u8FDB\u884C\u62BD\u53D6
+- \u5982\u679C\u5BF9\u8BDD\u5185\u5BB9\u4E2D\u6CA1\u6709\u503C\u5F97\u62BD\u53D6\u7684\u5B9E\u4F53\uFF08\u5982\u53EA\u662F\u65E5\u5E38\u95F2\u804A\uFF09\uFF0C\u5219\u4E0D\u8C03\u7528\u5DE5\u5177\uFF0C\u76F4\u63A5\u56DE\u590D"\u65E0\u9700\u62BD\u53D6"
+- \u8282\u70B9\u7C7B\u578B\u9650\u4E8E\uFF1A${NODE_TYPES_LIST}
+- \u5173\u7CFB\u7C7B\u578B\u9650\u4E8E\uFF1A${RELATION_TYPES_LIST}
+- \u5173\u7CFB\u5982\u6709\u65F6\u95F4\u4FE1\u606F\uFF08\u5982"\u53BB\u5E74"\u3001"\u4E0A\u5468"\uFF09\uFF0C\u8BF7\u6839\u636E\u5F53\u524D\u7CFB\u7EDF\u65F6\u95F4\u63A8\u7B97\u4E3A Unix \u6BEB\u79D2\u65F6\u95F4\u6233`;
+    const formatted = messages.map((m) => `[${new Date(m.createdAt).toISOString()}] ${m.talkerId || "user"}: ${m.content}`).join("\n");
+    try {
+      const message = await this.chatWithTools(
+        systemPrompt,
+        `\u8BF7\u5206\u6790\u4EE5\u4E0B\u5BF9\u8BDD\u5185\u5BB9\uFF0C\u63D0\u53D6\u5176\u4E2D\u7684\u5B9E\u4F53\u548C\u5173\u7CFB\uFF1A
+
+${formatted}`
+      );
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        const toolCall = message.tool_calls[0];
+        if (toolCall.function.name === "extract_entities") {
+          const args = JSON.parse(toolCall.function.arguments);
+          return {
+            entities: args.entities ?? [],
+            relations: args.relations ?? []
+          };
+        }
+      }
+    } catch (err) {
+      console.error("[LlmService] extractEntitiesFromMessages failed:", err);
+    }
+    return { entities: [], relations: [] };
+  }
+  // ── 对外主接口：压缩 + 实体抽取（并发执行两步）────────────────────────────────
+  async compress(messages) {
+    const [summary, extraction] = await Promise.all([
+      this.summarizeMessages(messages),
+      this.extractEntitiesFromMessages(messages)
+    ]);
+    return {
+      title: summary.title,
+      detail: summary.detail,
+      summary: summary.summary,
+      concise: summary.concise,
+      entities: extraction.entities,
+      relations: extraction.relations
+    };
+  }
+  // ── 搜索判断 ──────────────────────────────────────────────────────────────────
+  async judgeNeedsGraphSearch(query) {
+    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u610F\u56FE\u5224\u65AD\u52A9\u624B\u3002\u5224\u65AD\u7528\u6237\u7684\u67E5\u8BE2\u662F\u5426\u6D89\u53CA\u5B9E\u4F53\u5173\u7CFB\u67E5\u8BE2\uFF08\u5982\uFF1A\u67D0\u4EBA\u8BA4\u8BC6\u8C01\u3001\u67D0\u9879\u76EE\u7528\u4E86\u4EC0\u4E48\u6280\u672F\u3001\u8C01\u8D1F\u8D23\u4EC0\u4E48\u4EFB\u52A1\u7B49\uFF09\u3002
+\u53EA\u8F93\u51FA\u5408\u6CD5 JSON\uFF1A{"needsGraph": true} \u6216 {"needsGraph": false}`;
+    try {
+      const raw = await this.chatCompletion(systemPrompt, `\u7528\u6237\u67E5\u8BE2\uFF1A${query}`);
+      const result = JSON.parse(raw);
+      return result.needsGraph === true;
+    } catch {
+      return false;
+    }
+  }
+  // ── 知识库：文档摘要 + 是否值得建图判定 ────────────────────────────────────────
+  /**
+   * 为文档生成摘要，并判定是否值得构建知识图谱。
+   * 一次 LLM 调用同时产出两者，供 addDocument 在 buildGraph="auto" 时使用。
+   */
+  async summarizeDocument(content) {
+    const { summaryMaxTokens } = this.config;
+    const input = content.length > 12e3 ? content.slice(0, 12e3) : content;
+    const systemPrompt = `\u4F60\u662F\u77E5\u8BC6\u5E93\u6587\u6863\u52A9\u624B\u3002\u8BF7\u5BF9\u7ED9\u5B9A\u7684\u6587\u6863\u5185\u5BB9\u5B8C\u6210\u4E24\u4EF6\u4E8B\uFF1A
+1. \u751F\u6210\u4E00\u6BB5\u6458\u8981\uFF08summary\uFF09\uFF0C\u6700\u591A ${summaryMaxTokens} tokens\uFF0C\u6982\u62EC\u6587\u6863\u4E3B\u65E8\u4E0E\u5173\u952E\u4FE1\u606F\uFF0C\u4F9B\u540E\u7EED\u7C97\u53EC\u56DE\u5B9A\u4F4D\u3002
+2. \u5224\u65AD\u8BE5\u6587\u6863\u662F\u5426\u503C\u5F97\u6784\u5EFA\u77E5\u8BC6\u56FE\u8C31\uFF08worthGraph\uFF09\uFF1A\u82E5\u6587\u6863\u5305\u542B\u6709\u4EF7\u503C\u7684\u547D\u540D\u5B9E\u4F53\u53CA\u5176\u5173\u7CFB\uFF08\u4EBA\u7269\u3001\u7EC4\u7EC7\u3001\u9879\u76EE\u3001\u4E8B\u4EF6\u3001\u6280\u672F\u3001\u4EA7\u54C1\u3001\u5730\u70B9\u7B49\u7ED3\u6784\u5316\u77E5\u8BC6\uFF09\u5219\u4E3A true\uFF1B\u82E5\u4E3A\u7EAF\u4EE3\u7801\u3001\u7EAF\u6570\u636E\u8868\u3001\u65E0\u660E\u663E\u5B9E\u4F53\u7684\u6D41\u6C34\u6587\u672C\u6216\u683C\u5F0F\u5316\u65E5\u5FD7\u5219\u4E3A false\u3002
+
+\u53EA\u8F93\u51FA\u5408\u6CD5 JSON\uFF0C\u4E0D\u8981\u4EFB\u4F55 markdown \u6807\u8BB0\uFF1A{"summary": "...", "worthGraph": true}`;
+    try {
+      const raw = await this.chatCompletion(systemPrompt, `\u6587\u6863\u5185\u5BB9\uFF1A
+
+${input}`);
+      const parsed = JSON.parse(raw);
+      return {
+        summary: parsed.summary ?? "",
+        worthGraph: parsed.worthGraph === true
+      };
+    } catch (err) {
+      console.error("[LlmService] summarizeDocument failed:", err);
+      return { summary: "", worthGraph: false };
+    }
+  }
+  /**
+   * 从任意文本（知识片段）中抽取实体和关系，复用 extract_entities 工具。
+   */
+  async extractEntitiesFromText(text) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u5B9E\u4F53\u5173\u7CFB\u62BD\u53D6\u52A9\u624B\u3002\u5F53\u524D\u7CFB\u7EDF\u65F6\u95F4\uFF1A${now}\u3002
+\u68C0\u67E5\u7ED9\u5B9A\u7684\u77E5\u8BC6\u6587\u6863\u7247\u6BB5\uFF0C\u5224\u65AD\u5176\u4E2D\u662F\u5426\u5B58\u5728\u503C\u5F97\u8BB0\u5F55\u7684\u547D\u540D\u5B9E\u4F53\uFF08\u4EBA\u7269\u3001\u7EC4\u7EC7\u3001\u9879\u76EE\u3001\u5730\u70B9\u3001\u6280\u672F\u3001\u4EA7\u54C1\u3001\u4E8B\u4EF6\u7B49\uFF09\u548C\u5B83\u4EEC\u4E4B\u95F4\u7684\u5173\u7CFB\u3002
+- \u5982\u679C\u5B58\u5728\u6709\u610F\u4E49\u7684\u5B9E\u4F53\u548C\u5173\u7CFB\uFF0C\u8C03\u7528 extract_entities \u5DE5\u5177\u8FDB\u884C\u62BD\u53D6
+- \u5982\u679C\u7247\u6BB5\u4E2D\u6CA1\u6709\u503C\u5F97\u62BD\u53D6\u7684\u5B9E\u4F53\uFF0C\u5219\u4E0D\u8C03\u7528\u5DE5\u5177\uFF0C\u76F4\u63A5\u56DE\u590D"\u65E0\u9700\u62BD\u53D6"
+- \u8282\u70B9\u7C7B\u578B\u9650\u4E8E\uFF1A${NODE_TYPES_LIST}
+- \u5173\u7CFB\u7C7B\u578B\u9650\u4E8E\uFF1A${RELATION_TYPES_LIST}
+- \u5173\u7CFB\u5982\u6709\u65F6\u95F4\u4FE1\u606F\uFF0C\u8BF7\u6839\u636E\u5F53\u524D\u7CFB\u7EDF\u65F6\u95F4\u63A8\u7B97\u4E3A Unix \u6BEB\u79D2\u65F6\u95F4\u6233`;
+    try {
+      const message = await this.chatWithTools(
+        systemPrompt,
+        `\u8BF7\u5206\u6790\u4EE5\u4E0B\u77E5\u8BC6\u7247\u6BB5\uFF0C\u63D0\u53D6\u5176\u4E2D\u7684\u5B9E\u4F53\u548C\u5173\u7CFB\uFF1A
+
+${text}`
+      );
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        const toolCall = message.tool_calls[0];
+        if (toolCall.function.name === "extract_entities") {
+          const args = JSON.parse(toolCall.function.arguments);
+          return {
+            entities: args.entities ?? [],
+            relations: args.relations ?? []
+          };
+        }
+      }
+    } catch (err) {
+      console.error("[LlmService] extractEntitiesFromText failed:", err);
+    }
+    return { entities: [], relations: [] };
+  }
+  // ── ask 结果总结 ──────────────────────────────────────────────────────────────
+  async summarizeSearchResults(query, results, maxChars) {
+    const limitHint = maxChars ? `\u56DE\u7B54\u4E0D\u8D85\u8FC7 ${maxChars} \u5B57\u3002` : "";
+    const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u8BB0\u5FC6\u95EE\u7B54\u52A9\u624B\u3002\u6839\u636E\u63D0\u4F9B\u7684\u8BB0\u5FC6\u7247\u6BB5\uFF0C\u7B80\u6D01\u51C6\u786E\u5730\u56DE\u7B54\u7528\u6237\u95EE\u9898\u3002${limitHint}`;
+    const context = results.map((r, i) => `[${i + 1}] ${r.content}`).join("\n");
+    return this.chatCompletion(systemPrompt, `\u95EE\u9898\uFF1A${query}
+
+\u76F8\u5173\u8BB0\u5FC6\uFF1A
+${context}`, false);
+  }
+};
+
+// src/manager/compress.manager.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/manager/semaphore.ts
+var Semaphore = class {
+  count;
+  queue = [];
+  constructor(max) {
+    this.count = max;
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  acquire() {
+    if (this.count > 0) {
+      this.count--;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.count++;
+    }
+  }
+};
+
+// src/manager/compress.manager.ts
+var CompressManager = class {
+  config;
+  lance;
+  grafeo;
+  llm;
+  embed;
+  sessionCache;
+  semaphore;
+  sessionChain = /* @__PURE__ */ new Map();
+  constructor(config, lance, grafeo, llm, embed, sessionCache) {
+    this.config = config;
+    this.lance = lance;
+    this.grafeo = grafeo;
+    this.llm = llm;
+    this.embed = embed;
+    this.sessionCache = sessionCache;
+    this.semaphore = new Semaphore(config.maxConcurrentCompressions);
+  }
+  triggerCompress(sessionId, force = false, waitGraph = false) {
+    const chain = this.sessionChain.get(sessionId) ?? Promise.resolve();
+    const next = chain.then(
+      () => this.semaphore.run(() => this.doCompress(sessionId, force, waitGraph))
+    );
+    this.sessionChain.set(sessionId, next.catch(() => {
+    }));
+    return next;
+  }
+  async doCompress(sessionId, force, waitGraph) {
+    const messages = this.sessionCache.getSessionMessages(sessionId);
+    if (messages.length === 0) return;
+    const entry = this.sessionCache.getEntry(sessionId);
+    if (!entry) return;
+    if (!force && entry.totalTokens < this.config.sessionTokenLimit) return;
+    const { chatId, userId } = entry.ids;
+    const startTime = messages[0].createdAt;
+    const endTime = messages[messages.length - 1].createdAt;
+    let summary;
+    try {
+      summary = await this.llm.summarizeMessages(messages);
+    } catch (err) {
+      console.error(`[CompressManager] LLM compress failed for session ${sessionId}:`, err);
+      return;
+    }
+    const { title, detail, summary: summaryText, concise } = summary;
+    const topicTextForEmbed = [detail, summaryText, concise].find((t) => t.length > 0) ?? "";
+    let topicVector = [];
+    try {
+      topicVector = await this.embed.embedOne(topicTextForEmbed);
+    } catch (err) {
+      console.error(`[CompressManager] Embed topic failed:`, err);
+    }
+    const topic = {
+      summaryId: uuidv4(),
+      sessionId,
+      userId,
+      chatId,
+      title,
+      detail,
+      summary: summaryText,
+      concise,
+      startTime,
+      endTime,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      recallCount: 0,
+      vector: topicVector
+    };
+    try {
+      await this.lance.addTopic(topic);
+    } catch (err) {
+      console.error(`[CompressManager] Save topic failed:`, err);
+    }
+    this.sessionCache.clearMessages(sessionId, endTime);
+    const [n1, n2, n3] = this.config.topicRatio;
+    try {
+      const topicGroups = await this.lance.getRecentTopics(chatId, userId, n1, n2, n3);
+      this.sessionCache.buildHistoryWindow(sessionId, topicGroups);
+    } catch (err) {
+      console.error(`[CompressManager] Rebuild history window failed:`, err);
+    }
+    const graphTask = this.extractAndPersistGraph(messages, sessionId, chatId, userId, endTime);
+    if (waitGraph) {
+      await withTimeout(graphTask, this.config.graphBuildTimeoutMs, "flushChat graph build");
+    } else {
+      graphTask.catch((err) => {
+        console.error(`[CompressManager] Background graph persist failed:`, err);
+      });
+    }
+  }
+  async extractAndPersistGraph(messages, sessionId, chatId, userId, endTime) {
+    const { entities, relations } = await this.llm.extractEntitiesFromMessages(messages);
+    if (entities.length === 0 && relations.length === 0) return;
+    await this.persistGraph(entities, relations, sessionId, chatId, userId, endTime);
+  }
+  async persistGraph(rawEntities, rawRelations, sessionId, chatId, userId, messageTime) {
+    const entities = rawEntities.map((e) => ({
+      name: e.name,
+      type: e.type,
+      meta: {
+        sessionId,
+        chatId,
+        userId,
+        messageTime,
+        ...e.meta
+      }
+    }));
+    const relations = rawRelations.map((r) => ({
+      from: r.from,
+      to: r.to,
+      type: r.type,
+      happenedAt: r.happenedAt ?? void 0,
+      meta: {
+        sessionId,
+        chatId,
+        userId,
+        messageTime,
+        ...r.meta
+      }
+    }));
+    const allNames = [.../* @__PURE__ */ new Set([...entities.map((e) => e.name), ...relations.flatMap((r) => [r.from, r.to])])];
+    const embeddings = /* @__PURE__ */ new Map();
+    try {
+      const vecs = await this.embed.embed(allNames);
+      allNames.forEach((name, i) => embeddings.set(name, vecs[i]));
+    } catch (err) {
+      console.error(`[CompressManager] Embed entity names failed:`, err);
+      return;
+    }
+    try {
+      await this.grafeo.upsertEntitiesAndRelations(entities, relations, embeddings);
+    } catch (err) {
+      console.error(`[CompressManager] Upsert entities/relations failed:`, err);
+    }
+  }
+};
+function withTimeout(promise, timeoutMs, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+// src/manager/fact.cache.ts
+import { v4 as uuidv42 } from "uuid";
+var FactCache = class {
+  lance;
+  cache = /* @__PURE__ */ new Map();
+  constructor(lance) {
+    this.lance = lance;
+  }
+  async init() {
+    const facts = await this.lance.getAllFacts();
+    for (const fact of facts) {
+      const key = this.key(fact.level, fact.level === "user" ? fact.userId : fact.chatId);
+      const existing = this.cache.get(key) ?? [];
+      existing.push(fact);
+      this.cache.set(key, existing);
+    }
+  }
+  key(level, id) {
+    return `${level}:${id}`;
+  }
+  async add(content, level, userId, chatId, sessionId = "default") {
+    const fact = {
+      factId: uuidv42(),
+      level,
+      chatId,
+      sessionId,
+      userId,
+      content,
+      createdAt: Date.now()
+    };
+    await this.lance.saveFact(fact);
+    const id = level === "user" ? userId : chatId;
+    const k = this.key(level, id);
+    const existing = this.cache.get(k) ?? [];
+    existing.push(fact);
+    this.cache.set(k, existing);
+  }
+  get(level, id) {
+    return this.cache.get(this.key(level, id)) ?? [];
+  }
+  /** 全部 fact（管理面板列表用）*/
+  all() {
+    return [...this.cache.values()].flat();
+  }
+  /** 删除单条 fact：同步从 LanceDB 与内存缓存中移除。返回是否命中。*/
+  async remove(factId) {
+    let hit = false;
+    for (const [k, facts] of this.cache) {
+      const idx = facts.findIndex((f) => f.factId === factId);
+      if (idx >= 0) {
+        facts.splice(idx, 1);
+        if (facts.length === 0) this.cache.delete(k);
+        else this.cache.set(k, facts);
+        hit = true;
+        break;
+      }
+    }
+    await this.lance.deleteFact(factId);
+    return hit;
+  }
+  toString(level, id) {
+    const facts = this.get(level, id);
+    if (facts.length === 0) return "";
+    return facts.sort((a, b) => a.createdAt - b.createdAt).map((f) => `${new Date(f.createdAt).toISOString()}\uFF1A${f.content}`).join("\n");
+  }
+};
+
+// src/manager/knowledge.manager.ts
+import { createHash } from "node:crypto";
+import { v4 as uuidv43 } from "uuid";
+
+// src/manager/chunker.ts
+var HEADING_RE = /^(#{1,6})\s+(.*)$/;
+function chunkMarkdown(markdown, opts) {
+  const lines = markdown.split(/\r?\n/);
+  const sections = [];
+  const headingStack = [];
+  let current = null;
+  const pathFromStack = () => headingStack.map((h) => h.title).join(" / ");
+  for (const line of lines) {
+    const m = HEADING_RE.exec(line);
+    if (m) {
+      const level = m[1].length;
+      const title = m[2].trim();
+      while (headingStack.length > 0 && headingStack[headingStack.length - 1].level >= level) {
+        headingStack.pop();
+      }
+      headingStack.push({ level, title });
+      current = { headingPath: pathFromStack(), bodyLines: [] };
+      sections.push(current);
+    } else {
+      if (!current) {
+        current = { headingPath: "", bodyLines: [] };
+        sections.push(current);
+      }
+      current.bodyLines.push(line);
+    }
+  }
+  const pieces = [];
+  let ordinal = 0;
+  for (const section of sections) {
+    const body = section.bodyLines.join("\n").trim();
+    const baseText = body || section.headingPath;
+    if (!baseText) continue;
+    for (const text of splitToMaxTokens(baseText, opts.maxTokens, opts.overlap)) {
+      const content = text.trim();
+      if (!content) continue;
+      pieces.push({
+        content,
+        headingPath: section.headingPath,
+        ordinal: ordinal++,
+        tokens: countTokens(content)
+      });
+    }
+  }
+  if (pieces.length === 0 && markdown.trim()) {
+    const content = markdown.trim();
+    return [{ content, headingPath: "", ordinal: 0, tokens: countTokens(content) }];
+  }
+  return pieces;
+}
+function splitToMaxTokens(text, maxTokens, overlap) {
+  if (!text) return [];
+  if (countTokens(text) <= maxTokens) return [text];
+  const paragraphs = text.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
+  const units = [];
+  for (const p of paragraphs) {
+    if (countTokens(p) <= maxTokens) units.push(p);
+    else units.push(...splitLongUnit(p, maxTokens));
+  }
+  const chunks = [];
+  let buf = [];
+  let bufTokens = 0;
+  const flush = () => {
+    if (buf.length === 0) return;
+    const joined = buf.join("\n\n");
+    chunks.push(joined);
+    if (overlap > 0) {
+      const tail = takeTailTokens(joined, overlap);
+      buf = tail ? [tail] : [];
+      bufTokens = tail ? countTokens(tail) : 0;
+    } else {
+      buf = [];
+      bufTokens = 0;
+    }
+  };
+  for (const u of units) {
+    const ut = countTokens(u);
+    if (bufTokens + ut > maxTokens && buf.length > 0) flush();
+    buf.push(u);
+    bufTokens += ut;
+  }
+  if (buf.length > 0) chunks.push(buf.join("\n\n"));
+  return chunks;
+}
+function splitLongUnit(text, maxTokens) {
+  const sentences = text.split(/(?<=[。！？!?\n])/).filter((s) => s.length > 0);
+  const out = [];
+  let buf = "";
+  for (const s of sentences) {
+    if (buf && countTokens(buf + s) > maxTokens) {
+      out.push(buf);
+      buf = "";
+    }
+    if (countTokens(s) > maxTokens) {
+      out.push(...hardSplit(s, maxTokens));
+      buf = "";
+    } else {
+      buf += s;
+    }
+  }
+  if (buf) out.push(buf);
+  return out;
+}
+function hardSplit(text, maxTokens) {
+  const out = [];
+  let buf = "";
+  for (const ch of text) {
+    if (buf && countTokens(buf + ch) > maxTokens) {
+      out.push(buf);
+      buf = "";
+    }
+    buf += ch;
+  }
+  if (buf) out.push(buf);
+  return out;
+}
+function takeTailTokens(text, overlapTokens) {
+  if (overlapTokens <= 0) return "";
+  const chars = [...text];
+  let tail = "";
+  for (let i = chars.length - 1; i >= 0; i--) {
+    tail = chars[i] + tail;
+    if (countTokens(tail) >= overlapTokens) break;
+  }
+  return tail;
+}
+
+// src/manager/knowledge.manager.ts
+var KnowledgeManager = class {
+  config;
+  lance;
+  grafeo;
+  llm;
+  embed;
+  semaphore;
+  constructor(config, lance, grafeo, llm, embed) {
+    this.config = config;
+    this.lance = lance;
+    this.grafeo = grafeo;
+    this.llm = llm;
+    this.embed = embed;
+    this.semaphore = new Semaphore(config.maxConcurrentCompressions);
+  }
+  // ── 摄入 ───────────────────────────────────────────────────────────────────────
+  async addDocument(opts) {
+    const userId = opts.userId ?? DEFAULT_USER_ID;
+    const chatId = opts.chatId ?? DEFAULT_CHAT_ID;
+    const sessionId = opts.sessionId ?? DEFAULT_SESSION_ID;
+    const buildGraph = opts.buildGraph ?? this.config.buildGraphDefault;
+    const now = Date.now();
+    const content = opts.content;
+    const contentHash = createHash("sha256").update(content).digest("hex");
+    const domainFilter = `user_id = '${esc(userId)}' AND chat_id = '${esc(chatId)}' AND session_id = '${esc(sessionId)}'`;
+    const existing = await this.lance.findDocumentByHash(contentHash, domainFilter);
+    if (existing) return { docId: existing.docId };
+    const pieces = chunkMarkdown(content, {
+      maxTokens: this.config.chunkMaxTokens,
+      overlap: this.config.chunkOverlap
+    });
+    const { summary, worthGraph } = await this.llm.summarizeDocument(content);
+    const shouldBuildGraph = buildGraph === "auto" ? worthGraph : buildGraph === true;
+    let summaryVector = [];
+    try {
+      summaryVector = await this.embed.embedOne(summary || content.slice(0, 2e3));
+    } catch (err) {
+      console.error("[KnowledgeManager] embed summary failed:", err);
+    }
+    const docId = uuidv43();
+    const title = opts.title ?? inferTitle(content) ?? opts.sourceName ?? "\u672A\u547D\u540D\u6587\u6863";
+    const doc = {
+      docId,
+      userId,
+      chatId,
+      sessionId,
+      title,
+      sourceName: opts.sourceName ?? "",
+      fullContent: content,
+      contentHash,
+      summary,
+      summaryVector,
+      chunkCount: pieces.length,
+      hasGraph: false,
+      metadata: opts.metadata ?? {},
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.lance.addDocument(doc);
+    const chunkIngest = this.semaphore.run(() => this.ingestChunks(doc, pieces));
+    const graphBuild = chunkIngest.then((chunks) => {
+      if (!shouldBuildGraph) return;
+      return this.buildDocumentGraph(doc, chunks);
+    });
+    if (opts.wait || opts.waitGraph) {
+      await chunkIngest;
+    } else {
+      chunkIngest.catch((err) => {
+        console.error("[KnowledgeManager] background chunk ingest failed:", err);
+      });
+    }
+    if (opts.waitGraph) {
+      await withTimeout2(graphBuild, this.config.graphBuildTimeoutMs, "document graph build");
+    } else {
+      graphBuild.catch((err) => {
+        console.error("[KnowledgeManager] background graph build failed:", err);
+      });
+    }
+    return { docId };
+  }
+  async ingestChunks(doc, pieces) {
+    if (pieces.length === 0) return [];
+    const redundant = this.config.chunkRedundantIds;
+    const embedInputs = pieces.map(
+      (p) => p.headingPath ? `${p.headingPath}
+${p.content}` : p.content
+    );
+    let vectors;
+    try {
+      vectors = await this.embed.embed(embedInputs);
+    } catch (err) {
+      console.error("[KnowledgeManager] embed chunks failed:", err);
+      return [];
+    }
+    const chunks = pieces.map((p, i) => ({
+      chunkId: uuidv43(),
+      docId: doc.docId,
+      userId: redundant ? doc.userId : "",
+      chatId: redundant ? doc.chatId : "",
+      sessionId: redundant ? doc.sessionId : "",
+      content: p.content,
+      vector: vectors[i],
+      headingPath: p.headingPath,
+      ordinal: p.ordinal,
+      tokens: p.tokens,
+      metadata: {},
+      createdAt: doc.createdAt
+    }));
+    await this.lance.addChunks(chunks);
+    return chunks;
+  }
+  async buildDocumentGraph(doc, chunks) {
+    const extracted = await mapLimit2(chunks, this.config.graphExtractConcurrency, async (chunk) => {
+      const { entities: rawEntities, relations: rawRelations } = await this.llm.extractEntitiesFromText(chunk.content);
+      if (rawEntities.length === 0 && rawRelations.length === 0) return null;
+      const meta = {
+        userId: doc.userId,
+        chatId: doc.chatId,
+        sessionId: doc.sessionId,
+        docId: doc.docId,
+        chunkId: chunk.chunkId,
+        messageTime: doc.createdAt
+      };
+      const entities2 = rawEntities.map((e) => ({
+        name: e.name,
+        type: e.type,
+        meta: { ...meta, ...e.meta }
+      }));
+      const relations2 = rawRelations.map((r) => ({
+        from: r.from,
+        to: r.to,
+        type: r.type,
+        happenedAt: r.happenedAt ?? void 0,
+        meta: { ...meta, ...r.meta }
+      }));
+      return { entities: entities2, relations: relations2 };
+    });
+    const entities = extracted.flatMap((item) => item?.entities ?? []);
+    const relations = extracted.flatMap((item) => item?.relations ?? []);
+    if (entities.length === 0 && relations.length === 0) return;
+    const allNames = [
+      .../* @__PURE__ */ new Set([
+        ...entities.map((e) => e.name),
+        ...relations.flatMap((r) => [r.from, r.to])
+      ])
+    ];
+    if (allNames.length === 0) return;
+    const embeddings = /* @__PURE__ */ new Map();
+    try {
+      const vecs = await this.embed.embed(allNames);
+      allNames.forEach((name, i) => embeddings.set(name, vecs[i]));
+    } catch (err) {
+      console.error("[KnowledgeManager] embed entity names failed:", err);
+      return;
+    }
+    await this.grafeo.upsertEntitiesAndRelations(
+      entities,
+      relations,
+      embeddings,
+      KIND_KNOWLEDGE
+    );
+    await this.lance.updateDocumentGraphFlag(doc.docId, true).catch((err) => {
+      console.error(`[KnowledgeManager] Failed to update graph flag for doc ${doc.docId}:`, err);
+    });
+  }
+  // ── 检索 ───────────────────────────────────────────────────────────────────────
+  async searchKnowledge(opts) {
+    const empty = { chunks: [], documents: [], graphHits: [] };
+    if (!opts.query.trim()) return empty;
+    const scope = opts.scope ?? "all";
+    const scopeId = opts.scopeId;
+    const mode = opts.mode ?? "auto";
+    const limit = opts.limit ?? this.config.knowledgeTopK;
+    const vector = await this.embed.embedOne(opts.query);
+    const docFilter = buildDomainSql(scope, scopeId);
+    let candidateDocIds;
+    const docTitleMap = /* @__PURE__ */ new Map();
+    if (this.config.docCoarseTopK > 0) {
+      const coarse = await this.lance.searchDocuments(vector, docFilter, this.config.docCoarseTopK);
+      if (coarse.length > 0) {
+        candidateDocIds = coarse.map((d) => d.docId);
+        for (const d of coarse) docTitleMap.set(d.docId, d.title);
+      }
+    }
+    const chunkFilter = await this.buildChunkFilter(scope, scopeId, candidateDocIds);
+    if (chunkFilter === NO_MATCH) return empty;
+    const rawChunks = await this.lance.searchChunks(opts.query, vector, chunkFilter, limit);
+    const scored = rawChunks.map((c) => ({
+      chunkId: c.chunkId,
+      docId: c.docId,
+      content: c.content,
+      headingPath: c.headingPath,
+      score: cosineSimilarity(vector, c.vector)
+    })).sort((a, b) => b.score - a.score).slice(0, limit);
+    const docCount = /* @__PURE__ */ new Map();
+    for (const c of scored) docCount.set(c.docId, (docCount.get(c.docId) ?? 0) + 1);
+    const documents = await Promise.all(
+      [...docCount.entries()].map(async ([docId, matchedChunkCount]) => {
+        let title = docTitleMap.get(docId);
+        if (title === void 0) {
+          const d = await this.lance.getDocument(docId);
+          title = d?.title ?? "";
+        }
+        return { docId, title, matchedChunkCount };
+      })
+    );
+    const graphHits = await this.searchGraph(mode, vector, scope, scopeId, scored);
+    return { chunks: scored, documents, graphHits };
+  }
+  async searchGraph(mode, vector, scope, scopeId, topChunks) {
+    if (mode === "fast") return [];
+    if (mode === "auto") {
+      const top = topChunks[0];
+      if (!top || top.score < this.config.knowledgeGraphTriggerScore) return [];
+    }
+    const grafeoFilter = {
+      kind: KIND_KNOWLEDGE
+    };
+    if (scope === "user" && scopeId) grafeoFilter.userId = scopeId;
+    if (scope === "chat" && scopeId) grafeoFilter.chatId = scopeId;
+    if (scope === "session" && scopeId) grafeoFilter.sessionId = scopeId;
+    const entities = await this.grafeo.searchEntities(vector, grafeoFilter, this.config.knowledgeGraphEntityTopK).catch(() => []);
+    if (entities.length === 0) return entities;
+    const anchorCount = Math.min(this.config.knowledgeGraphAnchorTopK, entities.length);
+    const relatedArrays = await Promise.all(
+      entities.slice(0, anchorCount).map((e) => {
+        const name = e.meta?.name ?? "";
+        if (!name) return Promise.resolve([]);
+        return this.grafeo.getRelatedEntities(
+          name,
+          grafeoFilter.userId ?? e.meta?.userId ?? "",
+          grafeoFilter.chatId ?? e.meta?.chatId ?? "",
+          this.config.knowledgeGraphHopLimit,
+          KIND_KNOWLEDGE
+        ).catch(() => []);
+      })
+    );
+    return dedupByContent([...entities, ...relatedArrays.flat()]);
+  }
+  /**
+   * 构建片段表的过滤条件。
+   * - chunkRedundantIds=true：直接在 chunks 行的 user_id/chat_id/session_id 上过滤
+   * - false：先按域查 documents 得到 docId，再用 doc_id IN(...) 过滤
+   * 返回 undefined 表示不过滤；返回 NO_MATCH 表示无候选（应直接返回空结果）。
+   */
+  async buildChunkFilter(scope, scopeId, candidateDocIds) {
+    const parts = [];
+    if (this.config.chunkRedundantIds) {
+      const domainSql = buildDomainSql(scope, scopeId);
+      if (domainSql) parts.push(domainSql);
+      if (candidateDocIds) parts.push(inSql("doc_id", candidateDocIds));
+    } else {
+      let docIds = candidateDocIds;
+      if (scope !== "all") {
+        const domainSql = buildDomainSql(scope, scopeId);
+        const domainDocIds = await this.lance.getDocIdsByDomain(domainSql);
+        docIds = docIds ? domainDocIds.filter((id) => docIds.includes(id)) : domainDocIds;
+      }
+      if (docIds) {
+        if (docIds.length === 0) return NO_MATCH;
+        parts.push(inSql("doc_id", docIds));
+      }
+    }
+    return parts.length > 0 ? parts.join(" AND ") : void 0;
+  }
+  // ── 读取 / 删除 ─────────────────────────────────────────────────────────────────
+  async getDocument(docId) {
+    return this.lance.getDocument(docId);
+  }
+  async deleteDocument(docId) {
+    const existing = await this.lance.getDocument(docId);
+    if (!existing) return false;
+    await this.lance.deleteDocument(docId);
+    await this.lance.deleteChunksByDoc(docId).catch((err) => {
+      console.error(`[KnowledgeManager] Failed to delete chunks for doc ${docId}:`, err);
+    });
+    await this.grafeo.deleteKnowledgeByDoc(docId).catch((err) => {
+      console.error(`[KnowledgeManager] Failed to delete knowledge graph for doc ${docId}:`, err);
+    });
+    return true;
+  }
+  async listDocuments(filter) {
+    let docs = await this.lance.getAllDocuments();
+    if (filter?.userId) docs = docs.filter((d) => d.userId === filter.userId);
+    if (filter?.chatId) docs = docs.filter((d) => d.chatId === filter.chatId);
+    if (filter?.sessionId) docs = docs.filter((d) => d.sessionId === filter.sessionId);
+    return docs;
+  }
+};
+var NO_MATCH = Symbol("no-match");
+function dedupByContent(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    if (seen.has(item.content)) continue;
+    seen.add(item.content);
+    out.push(item);
+  }
+  return out;
+}
+function esc(value) {
+  return value.replace(/'/g, "''");
+}
+function buildDomainSql(scope, scopeId) {
+  if (scope === "session" && scopeId) return `session_id = '${esc(scopeId)}'`;
+  if (scope === "chat" && scopeId) return `chat_id = '${esc(scopeId)}'`;
+  if (scope === "user" && scopeId) return `user_id = '${esc(scopeId)}'`;
+  return void 0;
+}
+function inSql(column, values) {
+  const list = values.map((v) => `'${esc(v)}'`).join(", ");
+  return `${column} IN (${list})`;
+}
+function inferTitle(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  for (const line of lines) {
+    const m = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (m && m[2].trim()) return m[2].trim().slice(0, 120);
+  }
+  for (const line of lines) {
+    const t = line.trim();
+    if (t) return t.slice(0, 120);
+  }
+  return void 0;
+}
+async function mapLimit2(items, limit, mapper) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(Math.max(1, limit), items.length) }, async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function withTimeout2(promise, timeoutMs, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+// src/manager/session.cache.ts
+var SessionCache = class {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  historyWindows = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  getEntry(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  getOrCreateEntry(sessionId, chatId, userId) {
+    let entry = this.sessions.get(sessionId);
+    if (!entry) {
+      entry = { messages: [], totalTokens: 0, ids: { chatId, userId } };
+      this.sessions.set(sessionId, entry);
+    }
+    return entry;
+  }
+  addMessages(sessionId, messages, chatId, userId) {
+    const entry = this.getOrCreateEntry(sessionId, chatId, userId);
+    entry.messages.push(...messages);
+    entry.totalTokens += messages.reduce((sum, m) => sum + m.usage, 0);
+    return entry.totalTokens >= this.config.sessionTokenLimit;
+  }
+  clearMessages(sessionId, keepAfter) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return;
+    if (keepAfter != null) {
+      entry.messages = entry.messages.filter((m) => m.createdAt > keepAfter);
+      entry.totalTokens = entry.messages.reduce((sum, m) => sum + m.usage, 0);
+    } else {
+      entry.messages = [];
+      entry.totalTokens = 0;
+    }
+  }
+  getSessionMessages(sessionId) {
+    return this.sessions.get(sessionId)?.messages ?? [];
+  }
+  getAllSessionIds() {
+    return [...this.sessions.keys()];
+  }
+  buildHistoryWindow(sessionId, topicGroups) {
+    const { topicRatio, historyWindowTokenLimit } = this.config;
+    const [n1, n2, n3] = topicRatio;
+    let remaining = historyWindowTokenLimit;
+    const parts = [];
+    const addTopics = (topics, field, max) => {
+      let count = 0;
+      for (const t of topics) {
+        if (count >= max || remaining <= 0) break;
+        const text = t[field];
+        const tokens = countTokens(text);
+        if (tokens > remaining) break;
+        parts.push(text);
+        remaining -= tokens;
+        count++;
+      }
+    };
+    addTopics(topicGroups.detail, "detail", n1);
+    addTopics(topicGroups.summary, "summary", n2);
+    addTopics(topicGroups.concise, "concise", n3);
+    this.historyWindows.set(sessionId, parts.join("\n\n"));
+  }
+  getHistoryWindow(sessionId) {
+    return this.historyWindows.get(sessionId) ?? "";
+  }
+  setHistoryWindow(sessionId, content) {
+    this.historyWindows.set(sessionId, content);
+  }
+};
+
+// src/memory.manager.ts
+var MemoryManager = class {
+  config;
+  lance;
+  grafeo;
+  embed;
+  llm;
+  sessionCache;
+  factCache;
+  compressManager;
+  knowledgeManager;
+  sessionMap = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = resolveConfig(config);
+    this.lance = new LanceService(this.config);
+    this.grafeo = new GrafeoService(this.config);
+    this.embed = new EmbedService(this.config);
+    this.llm = new LlmService(this.config);
+    this.sessionCache = new SessionCache(this.config);
+    this.factCache = new FactCache(this.lance);
+    this.compressManager = new CompressManager(
+      this.config,
+      this.lance,
+      this.grafeo,
+      this.llm,
+      this.embed,
+      this.sessionCache
+    );
+    this.knowledgeManager = new KnowledgeManager(
+      this.config,
+      this.lance,
+      this.grafeo,
+      this.llm,
+      this.embed
+    );
+  }
+  async init() {
+    initEncoder();
+    await this.lance.init();
+    await this.grafeo.init();
+    await this.factCache.init();
+    const allSessions = await this.lance.getAllSessions();
+    for (const s of allSessions) {
+      this.sessionMap.set(s.sessionId, this.deserializeSession(s));
+    }
+    await this.restoreFromStorage();
+  }
+  async restoreFromStorage() {
+    const [n1, n2, n3] = this.config.topicRatio;
+    const sessionIds = await this.lance.getAllSessionIds();
+    if (sessionIds.length === 0) return;
+    for (const sessionId of sessionIds) {
+      const recentMessages = await this.lance.getLatestMessages(sessionId, 1);
+      if (recentMessages.length === 0) continue;
+      const { chatId, userId } = recentMessages[0];
+      const topicGroups = await this.lance.getRecentTopics(chatId, userId, n1, n2, n3);
+      const n1EndTime = topicGroups.detail.length > 0 ? topicGroups.detail[topicGroups.detail.length - 1].endTime : 0;
+      const rawMessages = n1EndTime > 0 ? await this.lance.getMessagesSince(sessionId, n1EndTime) : await this.lance.getLatestMessages(sessionId, 100);
+      if (rawMessages.length > 0) {
+        this.sessionCache.addMessages(sessionId, rawMessages, chatId, userId);
+      }
+      if (topicGroups.detail.length + topicGroups.summary.length + topicGroups.concise.length > 0) {
+        this.sessionCache.buildHistoryWindow(sessionId, topicGroups);
+      } else {
+        this.sessionCache.setHistoryWindow(sessionId, "");
+      }
+    }
+  }
+  async updateChat(messages, opts) {
+    if (messages.length === 0) return;
+    const userId = opts?.userId ?? DEFAULT_USER_ID;
+    const chatId = opts?.chatId ?? DEFAULT_CHAT_ID;
+    const sessionId = opts?.sessionId ?? DEFAULT_SESSION_ID;
+    const now = Date.now();
+    const withUsage = messages.map((m) => ({
+      messageId: m.messageId ?? uuidv44(),
+      talkerId: m.talkerId ?? "user",
+      chatId: m.chatId ?? chatId,
+      userId: m.userId ?? userId,
+      sessionId: m.sessionId ?? sessionId,
+      type: m.type ?? "text",
+      content: m.content,
+      parts: JSON.stringify(m.parts ?? []),
+      usage: m.usage ?? countTokens(m.content),
+      metadata: JSON.stringify(m.metadata ?? {}),
+      createdAt: m.createdAt ?? now
+    }));
+    let vectors;
+    try {
+      vectors = await this.embed.embed(withUsage.map((m) => m.content));
+    } catch (err) {
+      console.error("[MemoryManager] Embedding failed:", err);
+      throw err;
+    }
+    const stored = withUsage.map((m, i) => ({
+      messageId: m.messageId,
+      talkerId: m.talkerId,
+      chatId: m.chatId,
+      userId: m.userId,
+      sessionId: m.sessionId,
+      type: m.type,
+      content: m.content,
+      parts: m.parts,
+      usage: m.usage,
+      metadata: m.metadata,
+      vector: vectors[i],
+      createdAt: m.createdAt
+    }));
+    await this.lance.addMessages(stored);
+    if (!this.sessionMap.has(sessionId)) {
+      const session = {
+        sessionId,
+        chatId,
+        userId,
+        title: opts?.sessionTitle ?? "",
+        metadata: JSON.stringify(opts?.sessionMetadata ?? {}),
+        createdAt: now,
+        updatedAt: now
+      };
+      this.sessionMap.set(sessionId, this.deserializeSession(session));
+      this.lance.insertSession(session).catch((err) => {
+        console.error("[MemoryManager] Failed to insert session:", err);
+      });
+    } else {
+      const view = this.sessionMap.get(sessionId);
+      view.updatedAt = now;
+      this.lance.upsertSession(this.serializeSession(view)).catch((err) => {
+        console.error(`[MemoryManager] Failed to upsert session ${sessionId}:`, err);
+      });
+    }
+    (async () => {
+      const overLimit = this.sessionCache.addMessages(sessionId, stored, chatId, userId);
+      if (overLimit) {
+        await this.compressManager.triggerCompress(sessionId).catch((err) => {
+          console.error("[MemoryManager] Background compress failed:", err);
+        });
+      }
+    })();
+  }
+  async flushChat(sessionId, opts) {
+    const sid = sessionId ?? DEFAULT_SESSION_ID;
+    const promise = this.compressManager.triggerCompress(sid, true, opts?.waitGraph === true);
+    if (opts?.wait) await promise;
+  }
+  async updateFacts(content, level, userId, chatId, sessionId) {
+    await this.factCache.add(content, level, userId, chatId, sessionId);
+  }
+  async updateEntity(entities, relations, context) {
+    if (entities.length === 0 && relations.length === 0) return;
+    const sessionId = context?.sessionId ?? DEFAULT_SESSION_ID;
+    const chatId = context?.chatId ?? DEFAULT_CHAT_ID;
+    const userId = context?.userId ?? DEFAULT_USER_ID;
+    const allNames = [
+      .../* @__PURE__ */ new Set([
+        ...entities.map((e) => e.name),
+        ...relations.flatMap((r) => [r.from, r.to])
+      ])
+    ];
+    const vecs = await this.embed.embed(allNames);
+    const embeddings = /* @__PURE__ */ new Map();
+    allNames.forEach((name, i) => embeddings.set(name, vecs[i]));
+    const enrichedEntities = entities.map((e) => ({
+      ...e,
+      meta: { sessionId, chatId, userId, ...e.meta }
+    }));
+    const enrichedRelations = relations.map((r) => ({
+      ...r,
+      meta: { sessionId, chatId, userId, ...r.meta }
+    }));
+    await this.grafeo.upsertEntitiesAndRelations(enrichedEntities, enrichedRelations, embeddings);
+  }
+  async search(opts) {
+    const {
+      query,
+      scope = "all",
+      scopeId,
+      mode = "auto",
+      limit = this.config.defaultSearchLimit
+    } = opts;
+    if (!query.trim()) return [];
+    const vector = await this.embed.embedOne(query);
+    const filter = this.buildLanceFilter(scope, scopeId);
+    let useGraph = false;
+    if (mode === "all") {
+      useGraph = true;
+    } else if (mode === "auto") {
+      useGraph = await this.llm.judgeNeedsGraphSearch(query).catch(() => false);
+    }
+    const tasks = [
+      this.lance.hybridSearchTopics(query, vector, filter, limit).then(
+        (topics) => topics.map((t) => ({
+          type: "topic",
+          content: t.detail,
+          score: 1,
+          meta: {
+            summaryId: t.summaryId,
+            sessionId: t.sessionId,
+            chatId: t.chatId,
+            userId: t.userId
+          }
+        }))
+      ).catch(() => [])
+    ];
+    if (useGraph) {
+      const grafeoFilter = { kind: KIND_CONVERSATION };
+      if (scope === "user" && scopeId) grafeoFilter.userId = scopeId;
+      if (scope === "chat" && scopeId) grafeoFilter.chatId = scopeId;
+      if (scope === "session" && scopeId) grafeoFilter.sessionId = scopeId;
+      tasks.push(
+        this.grafeo.searchEntities(vector, grafeoFilter, limit).catch(() => [])
+      );
+    }
+    const allResults = (await Promise.all(tasks)).flat();
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = allResults.filter((r) => {
+      if (seen.has(r.content)) return false;
+      seen.add(r.content);
+      return true;
+    });
+    return deduped.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  async ask(opts) {
+    const { maxChars, includeKnowledge, ...searchOpts } = opts;
+    const results = await this.search(searchOpts);
+    if (includeKnowledge) {
+      const kb = await this.knowledgeManager.searchKnowledge({
+        query: searchOpts.query,
+        scope: searchOpts.scope,
+        scopeId: searchOpts.scopeId,
+        mode: searchOpts.mode
+      }).catch(() => null);
+      if (kb) {
+        for (const c of kb.chunks) {
+          results.push({ type: "topic", content: c.content, score: c.score, meta: { docId: c.docId } });
+        }
+        results.push(...kb.graphHits);
+      }
+    }
+    if (results.length === 0) return "\u672A\u627E\u5230\u76F8\u5173\u8BB0\u5FC6\u3002";
+    return this.llm.summarizeSearchResults(opts.query, results, maxChars);
+  }
+  async getFacts(level, id) {
+    return this.factCache.toString(level, id);
+  }
+  /**
+   * 按层级语义取「上下文相关」的 facts 拼接字符串。
+   *
+   * scope 是层级包含的：user ⊃ chat ⊃ session。因此在某个 chat/session 上下文中，
+   * 既要看到该 chat 级的 facts，也要看到所属 user 级的 facts。
+   * 返回 user 级(userId) ∪ chat 级(chatId)，按时间正序拼接。
+   */
+  async getFactsForContext(userId, chatId) {
+    const merged = [
+      ...this.factCache.get("user", userId),
+      ...this.factCache.get("chat", chatId)
+    ].sort((a, b) => a.createdAt - b.createdAt);
+    if (merged.length === 0) return "";
+    return merged.map((f) => `${new Date(f.createdAt).toISOString()}\uFF1A${f.content}`).join("\n");
+  }
+  getHistoryWindow(sessionId) {
+    return this.sessionCache.getHistoryWindow(sessionId);
+  }
+  buildLanceFilter(scope, scopeId) {
+    if (scope === "session" && scopeId) return `session_id = '${scopeId}'`;
+    if (scope === "chat" && scopeId) return `chat_id = '${scopeId}'`;
+    if (scope === "user" && scopeId) return `user_id = '${scopeId}'`;
+    return void 0;
+  }
+  deserializeSession(s) {
+    return { ...s, metadata: JSON.parse(s.metadata) };
+  }
+  serializeSession(v) {
+    return { ...v, metadata: JSON.stringify(v.metadata) };
+  }
+  // ── Message queries ──────────────────────────────────────────────────────────
+  async getRecentMessages(sessionId, limit) {
+    return this.lance.getLatestMessages(sessionId, limit);
+  }
+  // ── Session queries (in-memory) ──────────────────────────────────────────────
+  getSession(sessionId) {
+    return this.sessionMap.get(sessionId) ?? null;
+  }
+  getSessionsByUserId(userId, opts) {
+    const results = [...this.sessionMap.values()].filter((s) => s.userId === userId).sort((a, b) => b.updatedAt - a.updatedAt);
+    return opts?.limit ? results.slice(0, opts.limit) : results;
+  }
+  getSessionsByChatId(chatId, opts) {
+    const results = [...this.sessionMap.values()].filter((s) => s.chatId === chatId).sort((a, b) => b.updatedAt - a.updatedAt);
+    return opts?.limit ? results.slice(0, opts.limit) : results;
+  }
+  searchSessions(opts) {
+    let results = [...this.sessionMap.values()];
+    if (opts.userId) results = results.filter((s) => s.userId === opts.userId);
+    if (opts.chatId) results = results.filter((s) => s.chatId === opts.chatId);
+    if (opts.title) {
+      const q = opts.title.toLowerCase();
+      results = results.filter((s) => s.title.toLowerCase().includes(q));
+    }
+    results.sort((a, b) => b.updatedAt - a.updatedAt);
+    return opts.limit ? results.slice(0, opts.limit) : results;
+  }
+  // ── Session mutations ────────────────────────────────────────────────────────
+  async updateSession(sessionId, opts) {
+    const existing = this.sessionMap.get(sessionId);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...opts.title !== void 0 && { title: opts.title },
+      ...opts.metadata !== void 0 && { metadata: opts.metadata },
+      updatedAt: Date.now()
+    };
+    this.sessionMap.set(sessionId, updated);
+    await this.lance.upsertSession(this.serializeSession(updated));
+    return updated;
+  }
+  async deleteSession(sessionId) {
+    if (!this.sessionMap.has(sessionId)) return false;
+    this.sessionMap.delete(sessionId);
+    await this.lance.deleteSession(sessionId);
+    await this.lance.deleteMessagesBySession(sessionId).catch((err) => {
+      console.error(`[MemoryManager] Failed to delete messages for session ${sessionId}:`, err);
+    });
+    await this.lance.deleteTopicsBySession(sessionId).catch((err) => {
+      console.error(`[MemoryManager] Failed to delete topics for session ${sessionId}:`, err);
+    });
+    return true;
+  }
+  // ── 管理面板门面 API ───────────────────────────────────────────────────────────
+  /** 概览统计：各类记忆数据的总量 */
+  async stats() {
+    const [counts, knowledge, entities, relations] = await Promise.all([
+      this.lance.countAll(),
+      this.lance.countKnowledge(),
+      this.grafeo.getAllEntities(),
+      this.grafeo.getAllRelations()
+    ]);
+    return {
+      ...counts,
+      ...knowledge,
+      entities: entities.length,
+      relations: relations.length
+    };
+  }
+  /** 按天聚合最近 days 天的活跃趋势（概览图表用，含零值天）。days 默认 30，范围 1~365。 */
+  async trend(days = 30) {
+    const n = Math.min(365, Math.max(1, Math.floor(days)));
+    return this.lance.trendDaily(n);
+  }
+  /** 列出会话，可选按 userId / chatId 过滤，按更新时间倒序 */
+  listSessions(filter) {
+    let results = [...this.sessionMap.values()];
+    if (filter?.userId) results = results.filter((s) => s.userId === filter.userId);
+    if (filter?.chatId) results = results.filter((s) => s.chatId === filter.chatId);
+    return results.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /** 列出会话内的消息（按时间正序）*/
+  async listMessages(sessionId, limit = 100) {
+    return this.lance.getLatestMessages(sessionId, limit);
+  }
+  /** 列出主题/摘要，可选按 sessionId / userId / chatId 过滤 */
+  async listTopics(filter) {
+    let topics = await this.lance.getAllTopics();
+    if (filter?.sessionId) topics = topics.filter((t) => t.sessionId === filter.sessionId);
+    if (filter?.userId) topics = topics.filter((t) => t.userId === filter.userId);
+    if (filter?.chatId) topics = topics.filter((t) => t.chatId === filter.chatId);
+    return topics;
+  }
+  /**
+   * 列出事实，按创建时间倒序。过滤遵循 scope 层级包含语义：
+   * - 按 chatId 过滤时，除该 chat 级 facts 外，还包含该 chat 所属 user 的 user 级 facts
+   *   （user 级对其下所有 chat/session 生效）。
+   * - 按 userId 过滤时，返回该 user 名下全部 facts（两级都带 userId）。
+   * - level 过滤在层级过滤之后再叠加。
+   */
+  listFacts(filter) {
+    let facts = this.factCache.all();
+    if (filter?.chatId) {
+      const chatId = filter.chatId;
+      const ownerUserId = filter.userId ?? this.resolveChatOwner(chatId);
+      facts = facts.filter(
+        (f) => f.level === "chat" && f.chatId === chatId || f.level === "user" && ownerUserId != null && f.userId === ownerUserId
+      );
+    } else if (filter?.userId) {
+      facts = facts.filter((f) => f.userId === filter.userId);
+    }
+    if (filter?.level) facts = facts.filter((f) => f.level === filter.level);
+    return facts.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  /** 由 chatId 反查所属 userId：优先用会话表映射，兜底用 chat 级 fact 自身。 */
+  resolveChatOwner(chatId) {
+    for (const s of this.sessionMap.values()) {
+      if (s.chatId === chatId) return s.userId;
+    }
+    return this.factCache.all().find((f) => f.chatId === chatId)?.userId;
+  }
+  /** 手动新增一条事实 */
+  async addFact(content, level, userId, chatId, sessionId) {
+    await this.factCache.add(content, level, userId, chatId, sessionId);
+  }
+  /** 删除单条事实，返回是否命中 */
+  async deleteFact(factId) {
+    return this.factCache.remove(factId);
+  }
+  /** 列出全部实体（知识图谱节点）*/
+  async listEntities() {
+    return this.grafeo.getAllEntities();
+  }
+  /** 列出全部关系（知识图谱边）*/
+  async listRelations() {
+    return this.grafeo.getAllRelations();
+  }
+  // ── 知识库 API ────────────────────────────────────────────────────────────────
+  /** 摄入一个文档（markdown）。document 落库即返回，切块/embedding/图谱后台执行（wait=true 可等待）。*/
+  async addDocument(opts) {
+    return this.knowledgeManager.addDocument(opts);
+  }
+  /** 检索知识库片段，返回命中片段、涉及文档与图谱命中。*/
+  async searchKnowledge(opts) {
+    return this.knowledgeManager.searchKnowledge(opts);
+  }
+  /** 获取文档（含原文）。*/
+  async getDocument(docId) {
+    return this.knowledgeManager.getDocument(docId);
+  }
+  /** 删除文档（级联删除其片段与知识图谱痕迹），返回是否命中。*/
+  async deleteDocument(docId) {
+    return this.knowledgeManager.deleteDocument(docId);
+  }
+  /** 列出文档，可选按 userId / chatId / sessionId 过滤，按更新时间倒序。*/
+  async listDocuments(filter) {
+    return this.knowledgeManager.listDocuments(filter);
+  }
+  destroy() {
+    this.grafeo.close();
+  }
+};
+export {
+  DEFAULT_NODE_TYPES,
+  DEFAULT_RELATION_TYPES,
+  KIND_CONVERSATION,
+  KIND_KNOWLEDGE,
+  LanceService,
+  MemoryManager
+};