luckytri 1.0.0

package/server/i18n/models.js

@@ -0,0 +1,111 @@
+// English for the model library: provider names, tiers, thinking levels and the
+// notes beside each preset. Product and model names stay as the vendors write
+// them; only the Chinese around them is translated.
+const STANDARD_TAIL = "输入超过 272K 整单按长上下文计价。";
+const STANDARD_TAIL_EN =
+  "Input over 272K is billed entirely at the long-context rate.";
+const FLAT_TAIL = "1M 内同一价格，没有分档。";
+const FLAT_TAIL_EN = "One price within 1M, no tiers.";
+
+export const MODEL_LABELS = {
+  // tiers
+  "标准（输入 ≤272K）": "Standard (input ≤272K)",
+  "百万（1.05M）": "Million (1.05M)",
+
+  // thinking levels
+  关闭: "Off",
+  极低: "Minimal",
+  低: "Low",
+  中: "Medium",
+  高: "High",
+  极高: "Extra high",
+  最深: "Deepest",
+
+  // providers and labels
+  火山方舟: "Volcengine Ark",
+  "火山方舟 Coding Plan": "Volcengine Ark Coding Plan",
+  "方舟自动路由（ark-code-latest）": "Ark auto-routing (ark-code-latest)",
+  "GLM 最新别名（glm-latest）": "GLM latest alias (glm-latest)",
+  "小米 MiMo": "Xiaomi MiMo",
+  "智谱 GLM": "Zhipu GLM",
+  通义千问: "Qwen",
+  "亚马逊 Bedrock": "Amazon Bedrock",
+  自定义: "Custom",
+  自定义兼容接口: "Custom compatible API",
+  "OpenRouter · 自选模型": "OpenRouter · your own model",
+
+  // notes
+  "控制台管理的动态模型入口；实际使用哪一个模型由 Coding Plan 控制台选择，切换通常数分钟后生效。支持图片理解。":
+    "A dynamic model entry managed in the console; which model is actually used is chosen in the Coding Plan console, and a switch usually takes a few minutes. Supports image understanding.",
+  [`当前主力。思考默认开启（high），可关闭；支持看图。${FLAT_TAIL}`]: `The current mainstay. Thinking is on by default (high) and can be turned off; supports images. ${FLAT_TAIL_EN}`,
+  [`V4-Pro-0813。思考默认开启（high），可关闭；仅文本。${FLAT_TAIL}`]: `V4-Pro-0813. Thinking is on by default (high) and can be turned off; text only. ${FLAT_TAIL_EN}`,
+  [`旗舰。思考默认开启，可关闭；支持图片、视频、音频输入。${FLAT_TAIL}`]: `Flagship. Thinking is on by default and can be turned off; accepts image, video and audio input. ${FLAT_TAIL_EN}`,
+  [`高频调用。思考默认开启，可关闭；支持图片、视频、音频输入。${FLAT_TAIL}`]: `For frequent calls. Thinking is on by default and can be turned off; accepts image, video and audio input. ${FLAT_TAIL_EN}`,
+  [`旗舰。思考不能关闭，默认 max；仅文本。${FLAT_TAIL}`]: `Flagship. Thinking cannot be turned off and defaults to max; text only. ${FLAT_TAIL_EN}`,
+  [`原生多模态。思考不能关闭，默认 max；支持图片、视频。${FLAT_TAIL}`]: `Natively multimodal. Thinking cannot be turned off and defaults to max; supports images and video. ${FLAT_TAIL_EN}`,
+  "旗舰。思考不能关闭，默认 max；支持看图。1M 内同一价格；输出和输入共用窗口，官方默认输出 128K。":
+    "Flagship. Thinking cannot be turned off and defaults to max; supports images. One price within 1M; output and input share the window, with a vendor default output of 128K.",
+  "通用模型。思考默认开启，可关闭；支持看图。输出和输入共用 256K 窗口，官方默认输出 32K。":
+    "General-purpose. Thinking is on by default and can be turned off; supports images. Output and input share a 256K window, with a vendor default output of 32K.",
+  [`最强旗舰。思考不能关闭，官方未写默认档，预填 medium；支持看图。${STANDARD_TAIL}`]: `The strongest flagship. Thinking cannot be turned off; the vendor states no default level, so medium is prefilled; supports images. ${STANDARD_TAIL_EN}`,
+  [`复杂编码与智能体。思考默认 medium，可关闭；支持看图。${STANDARD_TAIL}`]: `Complex coding and agents. Thinking defaults to medium and can be turned off; supports images. ${STANDARD_TAIL_EN}`,
+  [`高频轻量。思考默认 medium，可关闭；支持看图。${STANDARD_TAIL}`]: `Lightweight for frequent calls. Thinking defaults to medium and can be turned off; supports images. ${STANDARD_TAIL_EN}`,
+  "OpenRouter 路由 · openai/gpt-6-astra。1.05M 上下文、128K 最大输出；支持图片、结构化输出和工具调用。":
+    "OpenRouter route · openai/gpt-6-astra. 1.05M context, 128K max output; supports images, structured output and tool calls.",
+  "OpenRouter 路由 · openai/gpt-6-sol。1.05M 上下文、128K 最大输出；支持图片、结构化输出和工具调用。":
+    "OpenRouter route · openai/gpt-6-sol. 1.05M context, 128K max output; supports images, structured output and tool calls.",
+  "OpenRouter 路由 · openai/gpt-6-luna。1.05M 上下文、128K 最大输出；支持图片、结构化输出和工具调用。":
+    "OpenRouter route · openai/gpt-6-luna. 1.05M context, 128K max output; supports images, structured output and tool calls.",
+  "OpenRouter 路由 · z-ai/glm-5.3-flash。1,310,720 上下文、131,072 最大输出；支持图片、结构化输出和工具调用。":
+    "OpenRouter route · z-ai/glm-5.3-flash. 1,310,720 context, 131,072 max output; supports images, structured output and tool calls.",
+  [`上一代旗舰，别名 gpt-5.6。思考默认 medium，可关闭；支持看图。${STANDARD_TAIL}`]: `Previous-generation flagship, alias gpt-5.6. Thinking defaults to medium and can be turned off; supports images. ${STANDARD_TAIL_EN}`,
+  [`上一代均衡款。思考默认 medium，可关闭；支持看图。${STANDARD_TAIL}`]: `Previous-generation balanced model. Thinking defaults to medium and can be turned off; supports images. ${STANDARD_TAIL_EN}`,
+  [`上一代高性价比。思考默认 medium，可关闭；支持看图。${STANDARD_TAIL}`]: `Previous-generation value model. Thinking defaults to medium and can be turned off; supports images. ${STANDARD_TAIL_EN}`,
+  [`旗舰，快照 qwen3.8-max-0902。思考默认开启（xhigh），可关闭；支持图片、视频。${FLAT_TAIL}`]: `Flagship, snapshot qwen3.8-max-0902. Thinking is on by default (xhigh) and can be turned off; supports images and video. ${FLAT_TAIL_EN}`,
+  [`轻量。思考默认开启（xhigh），可关闭；支持图片、视频。${FLAT_TAIL}`]: `Lightweight. Thinking is on by default (xhigh) and can be turned off; supports images and video. ${FLAT_TAIL_EN}`,
+  [`美国跨区推理。思考不能关闭，预填 medium；支持看图。runtime 不支持结构化输出，已关闭 JSON 输出。${STANDARD_TAIL}`]: `US cross-region inference. Thinking cannot be turned off and medium is prefilled; supports images. The runtime has no structured output, so JSON output is turned off. ${STANDARD_TAIL_EN}`,
+  [`AWS 模型卡尚未发布，模型 ID 取自 OpenAI 的 Bedrock 指南，JSON 输出先关闭。思考默认 medium，可关闭；支持看图。${STANDARD_TAIL}`]: `The AWS model card is not published yet; the model ID comes from OpenAI's Bedrock guide, and JSON output is off for now. Thinking defaults to medium and can be turned off; supports images. ${STANDARD_TAIL_EN}`,
+  "OpenCode Zen · GPT-6 系列旗舰 · Responses 接口。":
+    "OpenCode Zen · GPT-6 series flagship · Responses API.",
+  "OpenCode Zen · GPT-6 均衡款 · Responses 接口。":
+    "OpenCode Zen · GPT-6 balanced · Responses API.",
+  "OpenCode Zen · GPT-6 轻量款 · Responses 接口。":
+    "OpenCode Zen · GPT-6 lightweight · Responses API.",
+  "OpenCode Zen · 快速推理 · Chat Completions 接口。":
+    "OpenCode Zen · fast inference · Chat Completions API.",
+  "OpenCode Zen · DeepSeek V4 旗舰 · Chat Completions 接口。":
+    "OpenCode Zen · DeepSeek V4 flagship · Chat Completions API.",
+  "OpenCode Zen · 轻量高速 · Chat Completions 接口。":
+    "OpenCode Zen · lightweight and fast · Chat Completions API.",
+  "OpenCode Zen · 智谱轻量多模态 · Chat Completions 接口。":
+    "OpenCode Zen · Zhipu lightweight multimodal · Chat Completions API.",
+  "OpenCode Zen · 智谱旗舰 · Chat Completions 接口。":
+    "OpenCode Zen · Zhipu flagship · Chat Completions API.",
+  "OpenCode Zen · Kimi 旗舰 · Chat Completions 接口。":
+    "OpenCode Zen · Kimi flagship · Chat Completions API.",
+  "OpenCode Zen · 通义千问轻量多模态 · Anthropic Messages 接口。":
+    "OpenCode Zen · Qwen lightweight multimodal · Anthropic Messages API.",
+  "OpenCode Zen · MiniMax 主力模型 · Chat Completions 接口。":
+    "OpenCode Zen · MiniMax main model · Chat Completions API.",
+  "OpenCode Zen · 当前限时免费 · Chat Completions 接口。参考 OpenRouter Space Bunny Alpha 规格：1M 上下文、最高 524K 输出，支持图像/视频、推理、工具和 JSON；其匿名第三方提供方可能保留提示和回答。LuckyTri 默认输入 128K、输出 8K、低推理；当前图片链路可用，视频链路未支持。Zen 路由能力与数据政策可能不同。":
+    "OpenCode Zen · free for a limited time · Chat Completions API. Modeled on the OpenRouter Space Bunny Alpha spec: 1M context, up to 524K output, image/video, reasoning, tools and JSON; its anonymous third-party providers may keep prompts and replies. LuckyTri defaults to 128K input, 8K output and low reasoning; images work today, video is not supported. Zen routes may differ in ability and data policy.",
+  "OpenAI 兼容接口。上下文先按 128K 填，思考档可按供应商再改。":
+    "OpenAI-compatible API. Context is prefilled at 128K; the thinking level can be changed per provider.",
+  "已填好 OpenRouter API 地址。请自行填写模型 ID、API Key，并按所选模型设置上下文、输出和能力参数。":
+    "The OpenRouter API URL is filled in. Enter the model ID and API key yourself, and set the context, output and ability parameters for the chosen model.",
+};
+
+export const MODEL_PATTERNS = [
+  [
+    "OpenCode Go · {0} · {1} 接口。默认上下文和输出预算为保守起始值，可按账户实际模型上限调整。",
+    "OpenCode Go · {0} · {1} API. Default context and output budgets are conservative starting values; adjust them to your account's real model limits.",
+  ],
+  [
+    "Coding Plan 专属 Responses 接口 · 上下文 {0} · 官方最大输出 {1} · 支持图片理解。默认中等推理；Kimi K2.8 Preview 在 LuckyTri 中预留 64K 输出预算以保留长上下文。",
+    "Coding Plan–only Responses API · context {0} · vendor max output {1} · supports image understanding. Medium reasoning by default; Kimi K2.8 Preview reserves a 64K output budget in LuckyTri to keep the long context.",
+  ],
+  [
+    "Coding Plan 专属 Responses 接口 · 上下文 {0} · 官方最大输出 {1} · 文本模型。默认中等推理；Kimi K2.8 Preview 在 LuckyTri 中预留 64K 输出预算以保留长上下文。",
+    "Coding Plan–only Responses API · context {0} · vendor max output {1} · text model. Medium reasoning by default; Kimi K2.8 Preview reserves a 64K output budget in LuckyTri to keep the long context.",
+  ],
+];

package/server/index.js

@@ -0,0 +1,102 @@
+import { claimServer, clearStarting } from "./startup-lock.js";
+import { createStore } from "./storage/store.js";
+import { ChatSystem } from "./core/orchestrator.js";
+import { Life } from "./mind/life/index.js";
+import { createApp } from "./app.js";
+import { createChannelHub, createChannels } from "./channels/index.js";
+import { createBackupScheduler } from "./storage/backup-scheduler.js";
+import { createBackupCleanup } from "./storage/backup-cleanup.js";
+import { PluginHost } from "./plugins/host.js";
+
+claimServer();
+process.on("exit", clearStarting);
+const store = createStore();
+// One channel at a time connects her to QQ; the rest of the system only ever
+// talks to the hub.
+const channel = createChannelHub(store, createChannels(store));
+const chatSystem = new ChatSystem(store, channel.send, {
+  fetchQuoted: (message) => channel.fetchQuoted(message),
+  fetchImage: (file, sessionId) => channel.fetchImage(file, sessionId),
+});
+const life = new Life(chatSystem, {
+  online: () => channel.online(),
+  canReach: (session) => channel.canReach(session),
+});
+life.start();
+const plugins = new PluginHost({ store, chat: chatSystem, channel, life });
+chatSystem.mind.embody(() => plugins.aware());
+plugins
+  .start()
+  .catch((error) => console.error(`插件没有启动：${error.message}`));
+const backups = createBackupScheduler();
+const cleanup = createBackupCleanup({ store, backup: backups });
+const host = process.env.HOST || "127.0.0.1";
+if (
+  !["127.0.0.1", "localhost", "::1"].includes(host) &&
+  !process.env.ADMIN_TOKEN
+)
+  throw new Error("绑定外网地址前必须设置 ADMIN_TOKEN");
+
+let stopping = false;
+function shutdown() {
+  if (stopping) return;
+  stopping = true;
+  backups.stop();
+  plugins.close();
+  life.close();
+  chatSystem.close();
+  channel.close();
+  store.revision++;
+  clearInterval(maintenance);
+  const finish = () => {
+    try {
+      store.db.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  server.close(finish);
+  setTimeout(finish, 3000).unref();
+}
+
+const app = createApp({
+  store,
+  chatSystem,
+  life,
+  plugins,
+  runtime: {
+    connection: () => channel.status(),
+    syncChannel: () => channel.sync(),
+    backup: () => backups.status(),
+    cleanup,
+    shutdown,
+  },
+});
+const server = app.listen(Number(process.env.PORT || 3210), host, () => {
+  console.log(`LuckyTri 管理台 http://${host}:${process.env.PORT || 3210}`);
+});
+channel.attach(server, chatSystem);
+function runMaintenance() {
+  store.maintenance();
+  try {
+    chatSystem.maintain();
+  } catch (error) {
+    console.error(`后台维护失败：${error.message}`);
+  }
+  try {
+    if (!cleanup.running) backups.tick();
+  } catch (error) {
+    console.error(`自动备份调度失败：${error.message}`);
+  }
+  try {
+    cleanup.tick();
+  } catch (error) {
+    console.error(`定时备份整理调度失败：${error.message}`);
+  }
+  channel.refreshDirectory().catch(() => {});
+}
+runMaintenance();
+const maintenance = setInterval(runMaintenance, 60000);
+maintenance.unref();
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);

package/server/knowledge/api.js

@@ -0,0 +1,342 @@
+import { randomUUID } from "node:crypto";
+import { wrap } from "../http.js";
+import { prompts } from "../core/persona-manager.js";
+import { indexMemory } from "./schema.js";
+import {
+  publicEmbeddingProfile,
+  saveEmbeddingProfile,
+  resolveEmbeddingProfile,
+  embedBatches,
+} from "./embedding-profile.js";
+import {
+  applySpeakerNames,
+  presentMemory,
+  speakerNames,
+} from "../core/speaker-names.js";
+
+export function mountKnowledge(app, system) {
+  const { repo } = system;
+  app.get(
+    "/api/core/memories/:id/permissions",
+    wrap((req, res) => res.json(system.memory.permissions(req.params.id))),
+  );
+  app.patch(
+    "/api/core/memories/:id/permissions",
+    wrap((req, res) =>
+      res.json(system.memory.setPermission(req.params.id, req.body)),
+    ),
+  );
+  app.get("/api/core/knowledge/embedding", (req, res) =>
+    res.json(publicEmbeddingProfile(repo)),
+  );
+  app.patch(
+    "/api/core/knowledge/embedding",
+    wrap((req, res) => res.json(saveEmbeddingProfile(repo, req.body))),
+  );
+  app.post(
+    "/api/core/knowledge/embedding/test",
+    wrap(async (req, res) => {
+      const { profile } = resolveEmbeddingProfile(repo, system.models);
+      if (!profile.embedding) throw Error("知识向量未启用");
+      const vectors = await embedBatches(system.models, profile, [
+        "星空与时间",
+      ]);
+      res.json({ ok: true, dimensions: vectors[0].length });
+    }),
+  );
+  app.post(
+    "/api/core/knowledge/documents/:id/reembed",
+    wrap(async (req, res) =>
+      res.json(await system.knowledge.reembedDocument(req.params.id)),
+    ),
+  );
+  app.get("/api/core/memories", (req, res) => {
+    const session = String(req.query.session || "");
+    if (!session) {
+      const rows = repo.db
+        .prepare("SELECT * FROM core_memories ORDER BY updated DESC LIMIT 500")
+        .all();
+      const names = speakerNames(
+        repo.db,
+        rows.map((row) => row.session_id),
+      );
+      return res.json(rows.map((row) => presentMemory(row, names)));
+    }
+    const scopes = system.memory.scopes(session);
+    const placeholders = scopes.map(() => "?").join(",");
+    const rows = repo.db
+      .prepare(
+        `SELECT * FROM core_memories WHERE session_id IN (${placeholders}) ORDER BY updated DESC LIMIT 500`,
+      )
+      .all(...scopes);
+    const names = speakerNames(repo.db, [session, ...scopes]);
+    res.json(rows.map((row) => presentMemory(row, names)));
+  });
+  app.post(
+    "/api/core/memories",
+    wrap((req, res) => {
+      const { session, subject, content } = req.body;
+      if (
+        typeof subject !== "string" ||
+        !/^[0-9A-Za-z_-]{1,64}$/.test(subject) ||
+        typeof content !== "string" ||
+        !content.trim() ||
+        content.length > 4000 ||
+        !repo.db.prepare("SELECT id FROM sessions WHERE id=?").get(session)
+      )
+        throw Error("请选择会话、用户 ID 并填写记忆");
+      const discretion = ["open", "private", "secret"].includes(
+        req.body.discretion,
+      )
+        ? req.body.discretion
+        : /private/.test(session)
+          ? "private"
+          : "open";
+      const id = randomUUID(),
+        now = Date.now();
+      repo.db
+        .prepare(
+          "INSERT INTO core_memories(id,session_id,subject,content,type,confidence,importance,status,sources,created,updated,discretion) VALUES (?,?,?,?,'manual',1,1,'confirmed','[]',?,?,?)",
+        )
+        .run(id, session, subject, content, now, now, discretion);
+      indexMemory(repo.db, id, content);
+      repo.store.revision++;
+      res.json({ id });
+    }),
+  );
+  app.post(
+    "/api/core/memories/batch-delete",
+    wrap((req, res) => {
+      const { session, ids, all } = req.body || {};
+      const result = system.memory.deleteBatch(session, ids, {
+        all: all === true,
+      });
+      res.json({ ok: true, ...result });
+    }),
+  );
+  app.get(
+    "/api/core/memory-summary",
+    wrap((req, res) => {
+      const session = String(req.query.session || "");
+      if (!session) throw Error("请选择会话");
+      const rows = repo.db
+        .prepare(
+          "SELECT id,first_seq,last_seq,time,data FROM core_stages WHERE session_id=? ORDER BY last_seq DESC LIMIT 3",
+        )
+        .all(session);
+      const stages = rows
+        .map((row) => {
+          try {
+            const data = JSON.parse(row.data);
+            return {
+              id: row.id,
+              firstSeq: row.first_seq,
+              lastSeq: row.last_seq,
+              time: row.time,
+              summary:
+                typeof data.summary === "string" ? data.summary.trim() : "",
+            };
+          } catch {
+            return null;
+          }
+        })
+        .filter((row) => row && row.summary);
+      const names = speakerNames(repo.db, [session]);
+      const summary = applySpeakerNames(
+        stages.length
+          ? stages
+              .map((stage) => stage.summary)
+              .join(" ")
+              .slice(0, 5000)
+          : "这个会话还没有阶段性记忆总结。消息积累后会自动整理，也可以点击“立即整理”。",
+        names,
+      );
+      res.json({
+        session,
+        summary,
+        updated: stages[0]?.time || null,
+        source: stages.length ? "stage" : "empty",
+        stages: stages.map((stage) => ({
+          ...stage,
+          summary: applySpeakerNames(stage.summary, names),
+        })),
+        participants: [...names.entries()].map(([id, name]) => ({ id, name })),
+      });
+    }),
+  );
+  app.get("/api/core/stages", (req, res) =>
+    res.json(
+      repo.db
+        .prepare(
+          "SELECT * FROM core_stages WHERE session_id=? ORDER BY last_seq DESC LIMIT 100",
+        )
+        .all(String(req.query.session || ""))
+        .map((r) => ({ ...r, data: JSON.parse(r.data) })),
+    ),
+  );
+  app.get("/api/core/memories/:id/versions", (req, res) =>
+    res.json(
+      repo.db
+        .prepare(
+          "SELECT * FROM core_memory_versions WHERE memory_id=? ORDER BY id DESC",
+        )
+        .all(req.params.id),
+    ),
+  );
+  app.patch(
+    "/api/core/memories/:id",
+    wrap((req, res) => {
+      const allowed = {};
+      for (const k of [
+        "content",
+        "status",
+        "locked",
+        "confidence",
+        "importance",
+        "expires",
+        "discretion",
+      ])
+        if (k in req.body) allowed[k] = req.body[k];
+      if (
+        "content" in allowed &&
+        (typeof allowed.content !== "string" ||
+          !allowed.content.trim() ||
+          allowed.content.length > 4000)
+      )
+        throw Error("记忆内容无效");
+      if (
+        "status" in allowed &&
+        !["candidate", "confirmed", "disputed", "deleted", "expired"].includes(
+          allowed.status,
+        )
+      )
+        throw Error("记忆状态无效");
+      for (const k of ["confidence", "importance"])
+        if (
+          k in allowed &&
+          (!Number.isFinite(allowed[k]) || allowed[k] < 0 || allowed[k] > 1)
+        )
+          throw Error("置信度与重要性应在0–1");
+      if (
+        "expires" in allowed &&
+        allowed.expires !== null &&
+        (!Number.isSafeInteger(allowed.expires) || allowed.expires < 0)
+      )
+        throw Error("过期时间无效");
+      if ("locked" in allowed && typeof allowed.locked !== "boolean")
+        throw Error("锁定状态无效");
+      system.memory.update(req.params.id, allowed);
+      res.json({ ok: true });
+    }),
+  );
+  app.post(
+    "/api/core/memories/merge",
+    wrap((req, res) => {
+      const { ids, content } = req.body;
+      if (
+        !Array.isArray(ids) ||
+        ids.length !== 2 ||
+        ids[0] === ids[1] ||
+        typeof content !== "string" ||
+        !content.trim()
+      )
+        throw Error("选择两条记忆并输入合并内容");
+      const rows = ids.map((id) =>
+        repo.db.prepare("SELECT * FROM core_memories WHERE id=?").get(id),
+      );
+      if (
+        rows.some((r) => !r || r.locked) ||
+        rows[0].session_id !== rows[1].session_id ||
+        rows[0].subject !== rows[1].subject
+      )
+        throw Error("只能合并同范围同用户的未锁定记忆");
+      repo.db.exec("BEGIN IMMEDIATE");
+      try {
+        system.memory.update(ids[0], {
+          content,
+          sources: JSON.stringify(rows.flatMap((r) => JSON.parse(r.sources))),
+        });
+        system.memory.update(ids[1], { status: "deleted" });
+        repo.db.exec("COMMIT");
+      } catch (e) {
+        repo.db.exec("ROLLBACK");
+        throw e;
+      }
+      res.json({ ok: true });
+    }),
+  );
+  app.post(
+    "/api/core/memory/consolidate",
+    wrap(async (req, res) => {
+      const id = req.body.session;
+      const t = repo.trace(id, "memory");
+      try {
+        await system.memory.consolidate(
+          id,
+          system.models.profile(),
+          prompts(repo).memory,
+          t,
+          { force: true },
+        );
+        repo.finish(t, "complete");
+        res.json({ ok: true });
+      } catch (e) {
+        t.error = e.message;
+        repo.finish(t, "error");
+        throw e;
+      }
+    }),
+  );
+  app.get("/api/core/knowledge/collections", (req, res) =>
+    res.json(system.knowledge.collections(String(req.query.session || ""))),
+  );
+  app.post(
+    "/api/core/knowledge/collections",
+    wrap((req, res) => {
+      res.json(system.knowledge.createCollection(req.body || {}));
+    }),
+  );
+  app.get("/api/core/knowledge/documents", (req, res) =>
+    res.json(system.knowledge.documents(String(req.query.collection || ""))),
+  );
+  app.post(
+    "/api/core/knowledge/documents",
+    wrap(async (req, res) => {
+      const { collectionId, title, text, source, embed } = req.body || {};
+      res.json(
+        await system.knowledge.ingest({
+          collectionId,
+          title,
+          text,
+          source,
+          embed: embed !== false,
+        }),
+      );
+    }),
+  );
+  app.delete(
+    "/api/core/knowledge/documents/:id",
+    wrap((req, res) => {
+      system.knowledge.removeDocument(req.params.id);
+      res.json({ ok: true });
+    }),
+  );
+  app.post(
+    "/api/core/knowledge/search",
+    wrap(async (req, res) => {
+      const { session, text } = req.body || {};
+      if (typeof text !== "string" || !text.trim() || text.length > 4000)
+        throw Error("请输入 1–4000 字检索内容");
+      if (
+        session &&
+        !repo.db.prepare("SELECT id FROM sessions WHERE id=?").get(session)
+      )
+        throw Error("会话不存在");
+      res.json(
+        await system.knowledge.retrieveWithEmbed(session || "", [
+          { text: text.trim(), userId: "probe" },
+        ]),
+      );
+    }),
+  );
+}

package/server/knowledge/embedding-profile.js

@@ -0,0 +1,114 @@
+import { createHash } from "node:crypto";
+
+const CONFIG = "embedding-profile";
+export const EMBEDDING_DEFAULTS = {
+  enabled: false,
+  label: "知识向量",
+  baseUrl: "",
+  model: "",
+  apiKey: "",
+  dimensions: 0,
+  batchSize: 32,
+  timeoutMs: 90000,
+};
+
+export function embeddingSignature(profile) {
+  return createHash("sha256")
+    .update(
+      JSON.stringify([
+        profile.baseUrl || "",
+        profile.embeddingModel || profile.model || "",
+        profile.dimensions || 0,
+      ]),
+    )
+    .digest("hex");
+}
+
+export function publicEmbeddingProfile(repo) {
+  const saved = repo.config(CONFIG, null);
+  const { apiKey, ...profile } = { ...EMBEDDING_DEFAULTS, ...saved };
+  return {
+    ...profile,
+    configured: !!saved,
+    hasApiKey: !!(apiKey || process.env.EMBEDDING_API_KEY),
+  };
+}
+
+export function saveEmbeddingProfile(repo, input) {
+  const old = { ...EMBEDDING_DEFAULTS, ...repo.config(CONFIG, {}) };
+  const next = Object.fromEntries(
+    Object.keys(EMBEDDING_DEFAULTS).map((key) => [key, input[key] ?? old[key]]),
+  );
+  if (typeof next.enabled !== "boolean") throw Error("向量开关无效");
+  if (typeof next.apiKey !== "string") throw Error("密钥格式无效");
+  if (!next.apiKey) next.apiKey = old.apiKey;
+  next.label = String(next.label).trim().slice(0, 100);
+  next.model = String(next.model).trim().slice(0, 200);
+  next.baseUrl = String(next.baseUrl).trim().replace(/\/$/, "");
+  if (next.baseUrl) {
+    const url = new URL(next.baseUrl);
+    if (
+      !["http:", "https:"].includes(url.protocol) ||
+      url.username ||
+      url.password ||
+      url.search ||
+      url.hash
+    )
+      throw Error("向量 API 地址无效");
+  }
+  if (next.enabled && (!next.baseUrl || !next.model))
+    throw Error("启用向量需要独立地址和模型名");
+  for (const [key, min, max] of [
+    ["dimensions", 0, 65536],
+    ["batchSize", 1, 128],
+    ["timeoutMs", 1000, 300000],
+  ])
+    if (!Number.isSafeInteger(next[key]) || next[key] < min || next[key] > max)
+      throw Error(`${key} 超出范围`);
+  repo.saveConfig(CONFIG, next);
+  return publicEmbeddingProfile(repo);
+}
+
+export function resolveEmbeddingProfile(repo, models) {
+  const saved = repo.config(CONFIG, null);
+  if (saved) {
+    const profile = {
+      ...EMBEDDING_DEFAULTS,
+      ...saved,
+      id: "embedding",
+      embedding: saved.enabled,
+      embeddingModel: saved.model,
+      isolatedEmbeddingKey: true,
+    };
+    return { profile, signature: embeddingSignature(profile), legacy: false };
+  }
+  // Existing installations remain compatible until an independent profile is saved.
+  const profile = models.profile("default");
+  return { profile, signature: embeddingSignature(profile), legacy: true };
+}
+
+export async function embedBatches(models, profile, texts) {
+  if (!profile.embedding) return [];
+  const vectors = [];
+  const size = profile.batchSize || 32;
+  let dimension = profile.dimensions || 0;
+  for (let start = 0; start < texts.length; start += size) {
+    const batch = texts.slice(start, start + size);
+    const result = await models.embed(profile, batch);
+    if (!Array.isArray(result) || result.length !== batch.length)
+      throw Error("向量数量与输入不一致");
+    for (const vector of result) {
+      if (
+        !Array.isArray(vector) ||
+        !vector.length ||
+        !vector.every(Number.isFinite) ||
+        !vector.some((value) => value !== 0)
+      )
+        throw Error("向量内容无效");
+      dimension ||= vector.length;
+      if (vector.length !== dimension) throw Error("向量维度不一致");
+      vectors.push(vector);
+    }
+  }
+  return vectors;
+}

package/server/knowledge/index.js

@@ -0,0 +1,13 @@
+export { KnowledgeManager } from "./manager.js";
+export { indexChunk, indexMemory, migrateKnowledge } from "./schema.js";
+export {
+  asPlainDocument,
+  chunkText,
+  cosine,
+  ftsMatchQuery,
+  ftsTokens,
+  lexicalTerms,
+  overlapScore,
+  packVector,
+  unpackVector,
+} from "./retrieval.js";