luckytri 1.0.0

package/server/core/api.js

@@ -0,0 +1,564 @@
+import { randomUUID } from "node:crypto";
+import {
+  normalizeModels,
+  publicModel,
+  storedModels,
+  validateModel,
+} from "./model-manager.js";
+import { prompts, PROMPTS } from "./persona-manager.js";
+import { publicSession, parseSessionKey } from "../channels/session-key.js";
+import { qqbotCredentials } from "../channels/qqbot/credentials.js";
+import { wrap } from "../http.js";
+import {
+  parseNewSession,
+  renameSession,
+  setSessionEnabled,
+  upsertSession,
+} from "./sessions.js";
+import {
+  applySpeakerNames,
+  invalidateSpeakerNames,
+  speakerNames,
+} from "./speaker-names.js";
+import { displayNames, displaySession } from "../studio/display-names.js";
+
+export function mountCore(app, system) {
+  const { repo } = system;
+  app.get("/api/core/health", (req, res) => {
+    const row = repo.db
+      .prepare(
+        "SELECT time,status,json_extract(data,'$.error') error FROM core_traces WHERE mode='live' AND status!='running' AND json_array_length(data,'$.calls')>0 ORDER BY rowid DESC LIMIT 1",
+      )
+      .get();
+    res.json({
+      modelError: row?.status === "error" ? row.error : null,
+      time: row?.time || null,
+    });
+  });
+  app.get("/api/core/usage", (req, res) => {
+    const row = repo.db
+      .prepare(
+        `SELECT COUNT(*) calls,
+                COALESCE(SUM(input),0) input,
+                COALESCE(SUM(cached),0) cached,
+                COALESCE(SUM(output),0) output,
+                COALESCE(SUM(estimated),0) estimatedCalls,
+                MIN(time) since,
+                COALESCE(SUM(CASE WHEN estimated=0 THEN input+output ELSE 0 END),0) reportedTokens,
+                COALESCE(SUM(CASE WHEN estimated>0 THEN input+output ELSE 0 END),0) estimatedTokens
+         FROM mind_usage`,
+      )
+      .get();
+    const input = Number(row.input) || 0;
+    const output = Number(row.output) || 0;
+    res.json({
+      total: input + output,
+      input,
+      output,
+      cached: Number(row.cached) || 0,
+      calls: Number(row.calls) || 0,
+      estimatedCalls: Number(row.estimatedCalls) || 0,
+      reportedTokens: Number(row.reportedTokens) || 0,
+      estimatedTokens: Number(row.estimatedTokens) || 0,
+      since: row.since == null ? null : Number(row.since),
+    });
+  });
+  app.get("/api/core/state", (req, res) => {
+    const names = displayNames(repo.db, system.now());
+    res.json({
+      models: normalizeModels(storedModels(repo)).map(publicModel),
+      persona: system.mind.nature.current(),
+      prompts: prompts(repo),
+      sessions: repo.db
+        .prepare("SELECT * FROM sessions")
+        .all()
+        .map((s) => ({
+          ...displaySession(publicSession(s), names),
+          policy: system.policy(s.id),
+        })),
+      revision: repo.store.revision,
+    });
+  });
+  app.post(
+    "/api/core/sessions",
+    wrap((req, res) => {
+      const parsed = parseNewSession(req.body || {}, {
+        qqbotAppId: qqbotCredentials(repo.store).appId,
+      });
+      upsertSession(repo.db, parsed);
+      repo.store.revision++;
+      res.json({ ok: true, sessionId: parsed.sessionId });
+    }),
+  );
+  app.patch(
+    "/api/core/sessions/:id/archive",
+    wrap((req, res) => {
+      const row = repo.db
+        .prepare("SELECT id FROM sessions WHERE id=?")
+        .get(req.params.id);
+      if (!row) throw Error("会话不存在");
+      if (typeof req.body.archived !== "boolean") throw Error("归档开关无效");
+      repo.db
+        // `archived` already makes a session ineligible for processing. Keep
+        // its participation switch untouched so restoring it returns to the
+        // state the user configured before moving it out of the panel.
+        .prepare("UPDATE sessions SET archived=? WHERE id=?")
+        .run(+req.body.archived, req.params.id);
+      repo.store.revision++;
+      res.json({ ok: true });
+    }),
+  );
+  app.patch(
+    "/api/core/sessions/:id",
+    wrap((req, res) => {
+      const { enabled, name } = req.body || {};
+      if (enabled === undefined && name === undefined)
+        throw Error("没有要修改的内容");
+      // The official bot has no way to look up a group's name, so naming a
+      // room is something the person does, here, for either channel.
+      if (name !== undefined) renameSession(repo.db, req.params.id, name);
+      if (enabled !== undefined)
+        setSessionEnabled(repo.db, req.params.id, enabled);
+      repo.store.revision++;
+      res.json({ ok: true });
+    }),
+  );
+  app.delete(
+    "/api/core/sessions/:id",
+    wrap((req, res) => {
+      const id = String(req.params.id || ""),
+        row = repo.db
+          .prepare("SELECT id,archived FROM sessions WHERE id=?")
+          .get(id);
+      if (!row) throw Error("会话不存在");
+      if (!row.archived) throw Error("请先移出面板，再永久删除会话");
+      system.cancelSession(id);
+      repo.db.exec("BEGIN IMMEDIATE");
+      try {
+        const memoryIds = repo.db
+          .prepare("SELECT id FROM core_memories WHERE session_id=?")
+          .all(id)
+          .map((r) => r.id);
+        if (memoryIds.length) {
+          const placeholders = memoryIds.map(() => "?").join(",");
+          repo.db
+            .prepare(
+              `DELETE FROM core_memory_versions WHERE memory_id IN (${placeholders})`,
+            )
+            .run(...memoryIds);
+        }
+        repo.db
+          .prepare(
+            "DELETE FROM reply_feedback WHERE decision_id IN (SELECT id FROM decisions WHERE session_id=?)",
+          )
+          .run(id);
+        // What she lived through only in this conversation leaves with it;
+        // thoughts that also belong to other places stay.
+        repo.db
+          .prepare(
+            "DELETE FROM mind_thoughts WHERE sessions=? OR outreach_session=?",
+          )
+          .run(JSON.stringify([id]), id);
+        repo.db
+          .prepare(
+            "DELETE FROM mind_bond_events WHERE session_id=? OR (subject_kind='group' AND subject_id=?)",
+          )
+          .run(id, id);
+        for (const table of [
+          "mind_attention",
+          "mind_choices",
+          "mind_faces",
+          "mind_affect",
+          "mind_self",
+          "core_topics",
+          "core_memories",
+          "core_stages",
+          "core_context_summaries",
+          "core_cursors",
+          "core_jobs",
+          "core_outbox",
+          "core_references",
+          "core_traces",
+          "core_events",
+          "decisions",
+          "send_attempts",
+          "messages",
+        ])
+          repo.db.prepare(`DELETE FROM ${table} WHERE session_id=?`).run(id);
+        repo.db.prepare("DELETE FROM memory_candidates WHERE scope=?").run(id);
+        repo.db
+          .prepare("DELETE FROM core_config WHERE id=?")
+          .run("session:" + id);
+        repo.db.prepare("DELETE FROM sessions WHERE id=?").run(id);
+        repo.db.exec("COMMIT");
+      } catch (error) {
+        repo.db.exec("ROLLBACK");
+        throw error;
+      }
+      invalidateSpeakerNames(repo.db, id);
+      repo.store.revision++;
+      res.json({ ok: true, deleted: id });
+    }),
+  );
+  app.delete(
+    "/api/core/sessions/:id/context",
+    wrap((req, res) => {
+      const removed = system.clearContext(req.params.id);
+      res.json({ ok: true, removed });
+    }),
+  );
+  app.get(
+    "/api/core/sessions/:id/summaries",
+    wrap((req, res) => {
+      const id = String(req.params.id || "");
+      if (!repo.db.prepare("SELECT id FROM sessions WHERE id=?").get(id))
+        throw Error("会话不存在");
+      res.json(
+        system.compactor.list(id, { timeZone: system.policy(id).timeZone }),
+      );
+    }),
+  );
+  app.put(
+    "/api/core/models",
+    wrap((req, res) => {
+      if (!Array.isArray(req.body.models) || req.body.models.length > 30)
+        throw Error("模型档案数量应为 0–30");
+      const old = storedModels(repo);
+      const profiles = normalizeModels(
+        req.body.models.map((m) =>
+          validateModel({
+            ...m,
+            isDefault: !!m.isDefault,
+            apiKey: m.apiKey || old.find((x) => x.id === m.id)?.apiKey || "",
+          }),
+        ),
+      );
+      if (new Set(profiles.map((m) => m.id)).size !== profiles.length)
+        throw Error("模型 ID 重复");
+      repo.saveConfig("models", profiles);
+      res.json({ ok: true });
+    }),
+  );
+  app.delete(
+    "/api/core/models/:id",
+    wrap((req, res) => {
+      const id = String(req.params.id || "");
+      if (!id) throw Error("模型档案不存在");
+      const old = storedModels(repo);
+      if (!old.some((m) => m.id === id)) throw Error("模型档案不存在");
+      const profiles = normalizeModels(old.filter((m) => m.id !== id));
+      const fallback = profiles.find((m) => m.isDefault)?.id || "";
+      const sessionConfigs = repo.db
+        .prepare("SELECT id,value FROM core_config WHERE id LIKE 'session:%'")
+        .all()
+        .map((row) => ({ id: row.id, value: JSON.parse(row.value) }))
+        .filter(
+          ({ value }) =>
+            value.modelId === id ||
+            value.visionModelId === id ||
+            value.fallbackModelId === id,
+        );
+      repo.db.exec("BEGIN IMMEDIATE");
+      try {
+        repo.db
+          .prepare(
+            "UPDATE core_config SET value=?,version=version+1 WHERE id='models'",
+          )
+          .run(JSON.stringify(profiles));
+        for (const row of sessionConfigs) {
+          const next = { ...row.value };
+          if (next.modelId === id) next.modelId = fallback;
+          if (next.visionModelId === id) delete next.visionModelId;
+          if (
+            next.fallbackModelId === id ||
+            next.fallbackModelId === next.modelId
+          )
+            delete next.fallbackModelId;
+          repo.db
+            .prepare(
+              "UPDATE core_config SET value=?,version=version+1 WHERE id=?",
+            )
+            .run(JSON.stringify(next), row.id);
+        }
+        repo.db.exec("COMMIT");
+      } catch (error) {
+        repo.db.exec("ROLLBACK");
+        throw error;
+      }
+      repo.store.revision++;
+      res.json({
+        ok: true,
+        deleted: id,
+        resetSessions: sessionConfigs.map(({ id: session }) =>
+          session.slice(8),
+        ),
+      });
+    }),
+  );
+  // Kept for scripts written against the old persona API: it records a new
+  // version of her nature.
+  app.put(
+    "/api/core/persona",
+    wrap((req, res) => {
+      const { version: _version, mood: _mood, ...p } = req.body || {};
+      system.mind.nature.save(
+        { ...system.mind.nature.current(), ...p },
+        "通过人格接口修改",
+      );
+      res.json({ ok: true });
+    }),
+  );
+  app.put(
+    "/api/core/prompts",
+    wrap((req, res) => {
+      const next = {};
+      for (const k of Object.keys(PROMPTS)) {
+        if (
+          typeof req.body[k] !== "string" ||
+          !req.body[k].trim() ||
+          req.body[k].length > 50000
+        )
+          throw Error(`${k} Prompt 无效`);
+        next[k] = req.body[k];
+      }
+      repo.saveConfig("prompts-history:" + Date.now(), prompts(repo));
+      repo.saveConfig("prompts", next);
+      res.json({ ok: true });
+    }),
+  );
+  app.get("/api/core/prompt-versions", (req, res) =>
+    res.json(
+      repo.db
+        .prepare(
+          "SELECT id,version FROM core_config WHERE id LIKE 'prompts-history:%' ORDER BY id DESC LIMIT 100",
+        )
+        .all(),
+    ),
+  );
+  app.post(
+    "/api/core/prompt-versions/:id/restore",
+    wrap((req, res) => {
+      if (!req.params.id.startsWith("prompts-history:"))
+        throw Error("版本无效");
+      const v = repo.config(req.params.id);
+      if (!v) throw Error("版本不存在");
+      repo.saveConfig("prompts-history:" + Date.now(), prompts(repo));
+      repo.saveConfig("prompts", v);
+      res.json({ ok: true });
+    }),
+  );
+  app.put(
+    "/api/core/sessions/:id",
+    wrap((req, res) => {
+      if (
+        !repo.db
+          .prepare("SELECT id FROM sessions WHERE id=?")
+          .get(req.params.id)
+      )
+        throw Error("会话不存在");
+      const p = req.body;
+      for (const [k, min, max] of [
+        ["aggregateMs", 0, 30000],
+        ["maxWaitMs", 0, 60000],
+        ["contextMessages", 0, 500],
+        ["maxReply", 1, 2000],
+      ])
+        if (!Number.isInteger(p[k]) || p[k] < min || p[k] > max)
+          throw Error(`${k} 超出范围`);
+      // 0 is what older saves stored; it now means the default window.
+      if (p.contextMessages > 0 && p.contextMessages < 10)
+        throw Error("近期原文条数应在 10–500 之间");
+      if (p.compaction !== undefined && typeof p.compaction !== "boolean")
+        throw Error("上下文压缩开关无效");
+      if (p.maxWaitMs < p.aggregateMs)
+        throw Error("最大聚合时间不能小于基础窗口");
+      for (const retired of [
+        "probability",
+        "cooldown",
+        "comfortOnDistress",
+        "persona",
+      ])
+        if (p[retired] !== undefined)
+          throw Error(
+            "开不开口由 TA 自己决定，会话里不再设置概率、冷却、主动安慰或群人格；TA 在各群的样子见「人际」",
+          );
+      if (
+        p.selectiveVision !== undefined &&
+        typeof p.selectiveVision !== "boolean"
+      )
+        throw Error("节能看图开关无效");
+      if (typeof p.memory !== "boolean" || typeof p.deepCheck !== "boolean")
+        throw Error("开关无效");
+      const primary = system.models.profile(p.modelId);
+      if (p.visionModelId && !system.models.profile(p.visionModelId).vision)
+        throw Error("视觉兼容模型必须开启视觉能力");
+      if (
+        p.fallbackModelId !== undefined &&
+        typeof p.fallbackModelId !== "string"
+      )
+        throw Error("备用模型无效");
+      if (p.fallbackModelId) {
+        if (p.fallbackModelId === "default")
+          throw Error("请从模型库中选择具体的备用模型");
+        if (system.models.profile(p.fallbackModelId).id === primary.id)
+          throw Error("备用模型不能和主模型相同");
+      } else delete p.fallbackModelId;
+      if (p.name !== undefined) renameSession(repo.db, req.params.id, p.name);
+      const {
+        topicBoost: _deprecatedTopicBoost,
+        name: _name,
+        enabled: _enabled,
+        archived: _archived,
+        ...clean
+      } = p;
+      repo.saveConfig("session:" + req.params.id, clean);
+      res.json({ ok: true });
+    }),
+  );
+  app.get(
+    "/api/core/events",
+    wrap((req, res) => {
+      const before = Number(req.query.before) || Number.MAX_SAFE_INTEGER;
+      const session = String(req.query.session || "");
+      const after =
+        req.query.after === undefined ? null : Number(req.query.after);
+      const names = speakerNames(repo.db, [session]);
+      const labels = displayNames(repo.db, system.now());
+      const rows =
+        Number.isSafeInteger(after) && after >= 0
+          ? repo.db
+              .prepare(
+                "SELECT seq,session_id,time,role,payload FROM core_events WHERE session_id=? AND seq>? ORDER BY seq ASC LIMIT 100",
+              )
+              .all(session, after)
+          : repo.db
+              .prepare(
+                "SELECT seq,session_id,time,role,payload FROM core_events WHERE session_id=? AND seq<? ORDER BY seq DESC LIMIT 100",
+              )
+              .all(session, before);
+      res.json(
+        rows.map((r) => {
+          const payload = JSON.parse(r.payload);
+          const label =
+            labels.get(String(payload.userId)) ||
+            names.get(String(payload.userId));
+          if (label) payload.name = label;
+          return { ...r, payload };
+        }),
+      );
+    }),
+  );
+  app.get("/api/core/traces", (req, res) => {
+    const mode = repo.store.settings().demo ? "demo" : "live";
+    const session = String(req.query.session || "");
+    const requestedLimit = Number(req.query.limit);
+    const limit = Number.isSafeInteger(requestedLimit)
+      ? Math.max(1, Math.min(100, requestedLimit))
+      : 100;
+    const compact = req.query.compact === "1";
+    const fields = compact
+      ? "id,session_id,time,mode,status,json_extract(data,'$.reason') reason"
+      : "id,session_id,time,mode,status,json_extract(data,'$.reason') reason,json_extract(data,'$.error') error";
+    const rows = session
+      ? repo.db
+          .prepare(
+            `SELECT ${fields} FROM core_traces WHERE session_id=? AND mode IN (?,'memory','summary','replay') ORDER BY time DESC LIMIT ?`,
+          )
+          .all(session, mode, limit)
+      : repo.db
+          .prepare(
+            `SELECT ${fields} FROM core_traces WHERE mode IN (?,'memory','summary','replay') ORDER BY time DESC LIMIT ?`,
+          )
+          .all(mode, limit);
+    const names = speakerNames(
+      repo.db,
+      rows.map((row) => row.session_id),
+    );
+    res.json(
+      rows.map((row) => ({
+        ...row,
+        reason: row.reason ? applySpeakerNames(row.reason, names) : row.reason,
+      })),
+    );
+  });
+  app.get(
+    "/api/core/traces/:id",
+    wrap((req, res) => {
+      const t = repo.db
+        .prepare("SELECT * FROM core_traces WHERE id=?")
+        .get(req.params.id);
+      if (!t) throw Error("日志不存在");
+      const data = JSON.parse(t.data);
+      const names = speakerNames(repo.db, [t.session_id]);
+      if (typeof data.reason === "string")
+        data.reason = applySpeakerNames(data.reason, names);
+      res.json({ ...t, data });
+    }),
+  );
+  let replaying = false;
+  app.post(
+    "/api/core/replay",
+    wrap(async (req, res) => {
+      if (replaying) throw Error("已有回放正在运行");
+      const { session, from, to } = req.body;
+      if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from > to)
+        throw Error("回放消息序号范围无效");
+      const rows = repo
+        .events(session, to, { simulated: false })
+        .filter((m) => m.seq >= from && m.role === "user");
+      if (!rows.length || rows.length > 100)
+        throw Error("请选择 1–100 条人类消息");
+      replaying = true;
+      try {
+        res.json(await system.process(session, rows, { replay: true }));
+      } finally {
+        replaying = false;
+      }
+    }),
+  );
+  app.post("/api/simulate", async (req, res) => {
+    if (!storeDemo(system))
+      return res.status(400).json({ error: "请先开启模拟模式" });
+    const { sessionId, userId, text, mentioned } = req.body;
+    if (
+      typeof text !== "string" ||
+      !text.trim() ||
+      text.length > 4000 ||
+      typeof userId !== "string" ||
+      !/^[0-9A-Za-z_-]{4,64}$/.test(userId) ||
+      typeof sessionId !== "string" ||
+      !repo.db.prepare("SELECT id FROM sessions WHERE id=?").get(sessionId)
+    )
+      return res
+        .status(400)
+        .json({ error: "请选择会话并输入消息和有效的用户 ID" });
+    const trace = await system.receive({
+      sessionId,
+      kind: (() => {
+        try {
+          return parseSessionKey(sessionId).kind;
+        } catch {
+          return sessionId.split(":")[0];
+        }
+      })(),
+      userId,
+      name: "体验用户",
+      text,
+      mentioned: !!mentioned,
+      eventId: randomUUID(),
+      simulated: true,
+    });
+    res.json({
+      speak: Array.isArray(trace.sent) && trace.sent.length > 0,
+      reply: Array.isArray(trace.sent) ? trace.sent.join("\n") : "",
+      reason: trace.reason || "",
+      choice: trace.decision?.choice || "silent",
+      emotion: trace.decision?.topic || "模拟",
+      status: trace.status,
+    });
+  });
+}
+
+function storeDemo(system) {
+  return system.store.settings().demo;
+}