luckytri 1.0.0

package/server/core/orchestrator.js

@@ -0,0 +1,569 @@
+import { randomUUID } from "node:crypto";
+import { Repository } from "./repository.js";
+import {
+  ModelManager,
+  backupModels,
+  isTransientModelFailure,
+  storedModels,
+  withFallback,
+} from "./model-manager.js";
+import { KnowledgeManager } from "../knowledge/manager.js";
+import { ConversationManager } from "./conversation-manager.js";
+import { persistIncoming, messageEnvelope } from "./message-manager.js";
+import { prompts } from "./persona-manager.js";
+import {
+  ContextCompactor,
+  contextKeep,
+  DEFAULT_CONTEXT_MESSAGES,
+} from "./context-compactor.js";
+import { loadVisionImages } from "./vision-manager.js";
+import { deliver } from "./message-scheduler.js";
+import { TopicTracker } from "./topic-tracker.js";
+import { invalidateSpeakerNames } from "./speaker-names.js";
+import { demoReply } from "./local-demo.js";
+import { Mind } from "../mind/index.js";
+import { attend, interestTerms } from "../mind/attention.js";
+import { crisisSignal } from "../mind/guard.js";
+const TRACE_PRUNE_INTERVAL_MS = 3600000;
+const BATCH_LIMIT = 30;
+const BACKLOG_RECHECK_MS = 10 * 60000;
+import { TurnProcessor } from "./turn-processor.js";
+import { ReplyDelivery } from "./reply-delivery.js";
+import { Capabilities } from "./capabilities.js";
+import { Perceivers } from "./perceivers.js";
+
+export class ChatSystem {
+  constructor(
+    store,
+    send,
+    {
+      models,
+      knowledge,
+      localDemo = demoReply,
+      fetchQuoted,
+      fetchImage,
+      loadVisionImages: loadImages = loadVisionImages,
+      now = Date.now,
+    } = {},
+  ) {
+    this.now = now;
+    this.store = store;
+    this.repo = new Repository(store);
+    this.repo.db
+      .prepare(
+        "UPDATE core_jobs SET status='interrupted' WHERE status IN ('pending','running')",
+      )
+      .run();
+    this.models = models || new ModelManager(this.repo);
+    this.mind = new Mind(this.repo, { models: this.models });
+    this.memory = this.mind.memory;
+    this.knowledge = knowledge || new KnowledgeManager(this.repo, this.models);
+    this.compactor = new ContextCompactor(this.repo);
+    this.topics = new TopicTracker(this.repo);
+    this.capabilities = new Capabilities(this.repo, { now });
+    this.perceivers = new Perceivers(this.repo.db);
+    this.send = send;
+    this.localDemo = localDemo;
+    this.fetchQuoted = fetchQuoted;
+    this.fetchImage = fetchImage;
+    this.loadVisionImages = loadImages;
+    this.clearEpoch = new Map();
+    // A model service that was out of reach for a moment should not leave
+    // someone who spoke to her directly without an answer until they write
+    // again: a few later tries, then it is left as it is.
+    this.retryDelays = [30000, 120000];
+    this.retried = new Map();
+    // Batches already put back once because the person kept talking.
+    this.settled = new Set();
+    this.tracePruneDue = 0;
+    this.backlogChecked = new Map();
+    this.queue = new ConversationManager((id, batch) =>
+      this.process(id, batch),
+    );
+    this.turnProcessor = new TurnProcessor(this);
+    this.replyDelivery = new ReplyDelivery(this);
+  }
+  policy(session) {
+    const {
+      topicBoost: _topicBoost,
+      comfortOnDistress: _comfort,
+      persona: _persona,
+      ...saved
+    } = this.repo.config("session:" + session, {});
+    const policy = {
+      timeZone: this.mind.timeZone(),
+      aggregateMs: 1200,
+      maxWaitMs: 4000,
+      contextMessages: DEFAULT_CONTEXT_MESSAGES,
+      maxReply: 180,
+      memory: true,
+      deepCheck: true,
+      selectiveVision: false,
+      compaction: true,
+      ...saved,
+    };
+    // Older saves used 0 for "fill the whole model window".
+    policy.contextMessages = contextKeep(policy);
+    return policy;
+  }
+  // What a reply was generated against. Her own inner changes, other
+  // sessions and background jobs do not discard a reply; configuration does.
+  sessionState(session) {
+    const settings = this.store.settings();
+    return JSON.stringify([
+      this.repo.config("session:" + session, null),
+      this.mind.nature.version(),
+      this.repo.config("prompts", null),
+      storedModels(this.repo).map(({ apiKey: _apiKey, ...model }) => model),
+      [settings.name, settings.aliases, settings.enabled, settings.demo],
+      this.clearEpoch.get(session) || 0,
+    ]);
+  }
+  // While the room was being read (waiting in the queue, describing images),
+  // the person she is about to answer may have kept talking. Spending a whole
+  // turn on the older words only to throw the answer away is waste, and it
+  // makes them wait for it: put the batch back, once, and answer everything
+  // together. Never for a crisis, and only if there is a place to put it back.
+  batchMovedOn(session, batch, snapshot, privateChat) {
+    if (!batch.length) return false;
+    if (batch.some((m) => m.role !== "assistant" && crisisSignal(m.text)))
+      return false;
+    const key = `${session}:${batch[0].seq}`;
+    if (this.settled.has(key)) return false;
+    const speaker = (m) => String(m.speaker ?? m.userId);
+    const asked = snapshot.batch.filter((m) => m.relation === "direct");
+    const focus = new Set(
+      (asked.length ? asked : snapshot.batch.slice(-1)).map(speaker),
+    );
+    const moved = this.repo
+      .eventsAfter(session, batch.at(-1).seq, { simulated: false })
+      .some(
+        (m) =>
+          m.role === "user" &&
+          (privateChat ||
+            focus.has(String(m.userId)) ||
+            (m.replyId &&
+              snapshot.batch.some((b) => b.platformId === m.replyId))),
+      );
+    if (!moved || !this.queue.retain(session, batch)) return false;
+    if (this.settled.size > 500) this.settled.clear();
+    this.settled.add(key);
+    return true;
+  }
+  // Ask again later for a batch that was spoken to her directly, when the model
+  // service was only briefly unavailable. Not for a missing balance or a
+  // rejected request, and not when she has already answered since.
+  retryAfterOutage(session, batch, error, trace) {
+    if (!batch.length || !isTransientModelFailure(error)) return false;
+    const now = this.now();
+    for (const [key, entry] of this.retried)
+      if (now - entry.at > 60 * 60000) this.retried.delete(key);
+    const key = `${session}:${batch[0].seq}`;
+    const tried = this.retried.get(key)?.count ?? 0;
+    if (tried >= this.retryDelays.length) return false;
+    this.retried.set(key, { count: tried + 1, at: now });
+    const delay = this.retryDelays[tried];
+    const last = batch.at(-1).seq;
+    trace.steps.push(
+      `模型服务暂时不可用，${Math.round(delay / 1000)} 秒后再试（第 ${tried + 1} 次）`,
+    );
+    this.queue.retryLater(
+      session,
+      batch,
+      delay,
+      () =>
+        this.enabled(session, { simulated: false }) &&
+        !this.repo
+          .eventsAfter(session, last, { simulated: false })
+          .some((m) => m.role === "assistant"),
+    );
+    return true;
+  }
+  fallbackFor(_policy, primary, trace) {
+    const chain = [];
+    for (const model of backupModels(storedModels(this.repo), primary?.id)) {
+      try {
+        const profile = this.models.profile(model.id);
+        if (profile && profile.id !== primary?.id) chain.push(profile);
+      } catch {
+        trace?.steps?.push("有一个备用模型档案不存在，已跳过");
+      }
+    }
+    return chain;
+  }
+  receive(m) {
+    const event = persistIncoming(this.repo, m);
+    if (event) {
+      this.repo.db
+        .prepare("INSERT INTO core_jobs VALUES (?,?,'pending',NULL,?)")
+        .run(event.seq, event.sessionId, this.now());
+      if (
+        !m.simulated &&
+        this.enabled(event.sessionId, { simulated: false }) &&
+        this.policy(event.sessionId).memory &&
+        this.store.settings().memoryEnabled !== false &&
+        this.store.settings().memoryCandidates !== false
+      )
+        this.mind.memory.remember({ ...m, ...event });
+      if (m.simulated)
+        return this.process(event.sessionId, [event], { simulated: true });
+      this.queue.enqueue(event, this.policy(event.sessionId));
+    }
+    return { queued: !!event };
+  }
+  enabled(session, { simulated = false } = {}) {
+    const settings = this.store.settings();
+    const row = this.repo.db
+      .prepare("SELECT enabled,archived FROM sessions WHERE id=?")
+      .get(session);
+    if (!settings.enabled || !row?.enabled || row.archived) return false;
+    if (settings.demo) return !!simulated;
+    return !simulated;
+  }
+  cancelSession(session) {
+    this.clearEpoch.set(session, (this.clearEpoch.get(session) || 0) + 1);
+    this.queue.clear(session);
+  }
+  clearContext(session) {
+    if (
+      !this.repo.db.prepare("SELECT id FROM sessions WHERE id=?").get(session)
+    )
+      throw Error("会话不存在");
+    this.cancelSession(session);
+    const count = (table) =>
+      this.repo.db
+        .prepare(`SELECT COUNT(*) n FROM ${table} WHERE session_id=?`)
+        .get(session).n;
+    const removed = {
+      events: count("core_events"),
+      messages: count("messages"),
+      references: count("core_references"),
+      stages: count("core_stages"),
+      summaries: count("core_context_summaries"),
+      jobs: count("core_jobs"),
+      outbox: count("core_outbox"),
+    };
+    this.repo.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const table of [
+        "core_events",
+        "core_references",
+        "core_stages",
+        "core_context_summaries",
+        "core_jobs",
+        "core_outbox",
+        "messages",
+        "core_vision_cache",
+        "core_perceptions",
+        "core_cursors",
+        "mind_attention",
+      ])
+        this.repo.db
+          .prepare(`DELETE FROM ${table} WHERE session_id=?`)
+          .run(session);
+      this.repo.db.exec("COMMIT");
+    } catch (error) {
+      this.repo.db.exec("ROLLBACK");
+      throw error;
+    }
+    this.compactor.clear(session);
+    invalidateSpeakerNames(this.repo.db, session);
+    this.store.revision++;
+    return removed;
+  }
+  // Whether she reads this batch now. Deterministic, and cheap: no model call.
+  gate(session, batch, resolved, now, nature) {
+    const bySeq = new Map(resolved.map((m) => [m.seq, m]));
+    const unread = this.mind.unread(session, { now });
+    const seqs = [
+      ...new Set([...unread.map((m) => m.seq), ...batch.map((m) => m.seq)]),
+    ]
+      .sort((a, b) => a - b)
+      .slice(-BATCH_LIMIT);
+    const rows = seqs.map((seq) => bySeq.get(seq)).filter(Boolean);
+    const affect = this.mind.affect.state(now, { nature, room: session });
+    const interests = interestTerms(nature.interests || []);
+    const here = (thread) => this.mind.meetings.stays(thread, session);
+    const livingThread = this.mind.self.living({
+      before: now,
+      now,
+      room: session,
+    });
+    const living = interestTerms(livingThread ? [livingThread.content] : []);
+    const wishRows = this.mind.meetings.ownWishes(session, now);
+    const wishes = wishRows.map((row) => interestTerms([row.content]));
+    const curiosities = interestTerms(
+      this.mind.self
+        .active({ before: now, limit: 12 })
+        .filter(
+          (t) =>
+            ["interest", "curiosity", "care", "intention"].includes(t.kind) &&
+            here(t),
+        )
+        .map((t) => t.content),
+    );
+    const closeness = new Map(
+      rows.map((m) => [
+        String(m.userId),
+        this.mind.bonds.person(m.userId, now)?.closeness || 0,
+      ]),
+    );
+    const speakers = rows
+      .filter((m) => m.role !== "assistant")
+      .map((m) => m.userId);
+    const held = new Set();
+    for (const row of wishRows)
+      for (const id of this.mind.meetings.touchedPeople(
+        session,
+        speakers,
+        now,
+        row.thread,
+      ))
+        held.add(id);
+    const decision = attend({
+      batch: rows,
+      unread: seqs.length,
+      lastLookAt: this.mind.attention(session).looked_at,
+      lastSpokeAt:
+        resolved
+          .filter((m) => m.role === "assistant" && !m.referenceOnly)
+          .at(-1)?.time || null,
+      belongs: (() => {
+        const spoke = resolved
+          .filter((m) => m.role === "assistant" && !m.referenceOnly)
+          .at(-1)?.time;
+        return (
+          !!(spoke && now - spoke < 6 * 60 * 60000) ||
+          !!this.mind.faces.current(session, now)
+        );
+      })(),
+      phase: affect.phase,
+      energy: affect.energy,
+      interests,
+      curiosities,
+      living,
+      wishes,
+      held,
+      closeness,
+      pressure: this.mind.budget.pressure("conversation", now),
+      initiative: nature.initiative,
+      now,
+    });
+    return { ...decision, rows };
+  }
+  async restoreQuotes(session, batch, trace) {
+    if (!this.fetchQuoted) return;
+    for (const message of batch.filter((m) => m.replyId)) {
+      const found = this.repo.db
+        .prepare(
+          "SELECT seq FROM core_events WHERE session_id=? AND platform_id=? AND account_id=?",
+        )
+        .get(session, message.replyId, message.accountId);
+      if (found) continue;
+      try {
+        const quoted = await this.fetchQuoted(message);
+        if (!quoted) continue;
+        this.repo.db
+          .prepare(
+            "INSERT OR IGNORE INTO core_references(session_id,platform_id,account_id,payload) VALUES (?,?,?,?)",
+          )
+          .run(
+            session,
+            message.replyId,
+            message.accountId,
+            JSON.stringify(messageEnvelope(quoted)),
+          );
+      } catch {
+        trace.steps.push("引用消息未能恢复，保留 unknown，不认领对象");
+      }
+    }
+  }
+
+  async process(...args) {
+    const options = args[2] || {};
+    if (
+      options.replay ||
+      options.preview ||
+      options.simulated ||
+      args[1]?.some((m) => m.simulated)
+    )
+      return this.turnProcessor.process(...args);
+    return this.mind.time.attention.chat(() =>
+      this.turnProcessor.process(...args),
+    );
+  }
+
+  async speak(...args) {
+    return this.replyDelivery.speak(...args);
+  }
+  async offline(session, batch, trace, finish, context, preview, state) {
+    const local = this.localDemo(this.store.settings(), {
+      message: batch.at(-1),
+      direct: true,
+      context,
+    });
+    if (!local.speak) return finish("silent", local.reason);
+    trace.response = { bubbles: [local.reply || "嗯"], reason: local.reason };
+    if (preview) return finish("previewed", local.reason);
+    const isCurrent = () =>
+      !this.queue.closed &&
+      this.enabled(session, { simulated: true }) &&
+      (!state || this.sessionState(session) === state);
+    if (!isCurrent()) return finish("stale", "生成期间语境已更新，旧稿未发送");
+    trace.sent = await deliver(
+      this.repo,
+      batch.at(-1),
+      trace.response.bubbles,
+      trace,
+      this.send,
+      isCurrent,
+      { now: this.now },
+    );
+    return finish(trace.sent.length ? "sent" : "cancelled", local.reason);
+  }
+  // A dry run through the real pipeline: reads her mind as it is now (or a
+  // draft nature), writes nothing to it and sends nothing.
+  async preview({ text, history = [], nature = null, viewSession = "" }) {
+    const session = `preview:${randomUUID()}`;
+    const base = this.now() - (history.length + 1) * 1000;
+    const append = (row, i) =>
+      this.repo.append({
+        eventId: `${session}:${i}`,
+        sessionId: session,
+        kind: "private",
+        userId: row.role === "assistant" ? "bot" : "preview",
+        name:
+          row.role === "assistant"
+            ? this.mind.nature.current().name
+            : "试聊的人",
+        text: row.text,
+        role: row.role,
+        time: base + i * 1000,
+        platformId: String(i + 1),
+        accountId: "preview",
+        mentions: [],
+        attachments: [],
+        simulated: true,
+      });
+    history.forEach(append);
+    const seq = append({ role: "user", text }, history.length);
+    try {
+      const event = this.repo.eventsAfter(session, seq - 1).at(-1);
+      return await this.process(session, [event], {
+        preview: { nature, viewSession: viewSession || null },
+      });
+    } finally {
+      for (const table of [
+        "core_events",
+        "core_jobs",
+        "core_outbox",
+        "core_topics",
+      ])
+        this.repo.db
+          .prepare(`DELETE FROM ${table} WHERE session_id=?`)
+          .run(session);
+      invalidateSpeakerNames(this.repo.db, session);
+    }
+  }
+  // A turn she starts herself: waking up to messages, or deciding to say
+  // something to someone she has been thinking about.
+  async initiate(session, occasion, batch = []) {
+    if (!this.enabled(session, { simulated: false })) return null;
+    if (this.queue.lanes.has(session)) return null;
+    const anchor =
+      batch.at(-1) ||
+      this.repo
+        .recentEvents(session, 1, { simulated: false, role: "user" })
+        .at(-1);
+    if (!anchor) return null;
+    return this.process(session, batch, { occasion, anchor });
+  }
+  // Memory consolidation and context compaction after a live turn. Both run
+  // detached so they never hold the conversational lane.
+  backgroundWork(session, policy, now = this.now()) {
+    if (!policy.memory && policy.compaction === false) return;
+    if (!this.enabled(session, { simulated: false })) return;
+    if (!this.mind.budget.allows("upkeep")) return;
+    let profile;
+    try {
+      profile = this.models.profile();
+    } catch {
+      return;
+    }
+    const models = withFallback(this.models, this.fallbackFor(policy, profile));
+    const memory = this.mind.memory;
+    if (
+      policy.memory &&
+      this.store.settings().memoryEnabled !== false &&
+      memory.due(session, now).due &&
+      !memory.busy.has(session) &&
+      now - (memory.lastAttempt.get(session) || 0) >= 60000
+    ) {
+      const t = this.repo.trace(session, "memory");
+      memory
+        .consolidate(session, profile, prompts(this.repo).memory, t, {
+          models,
+          now,
+        })
+        .then(() => this.finishQuietly(t, "complete"))
+        .catch((e) => {
+          t.error = e.message;
+          this.finishQuietly(t, "error");
+        });
+    }
+    if (policy.compaction !== false)
+      this.scheduleCompaction(session, policy, profile, models);
+  }
+  scheduleCompaction(session, policy, profile, models) {
+    const prompt = prompts(this.repo);
+    return this.compactor.schedule(session, {
+      models,
+      profile,
+      keep: contextKeep(policy),
+      timeZone: policy.timeZone,
+      self: this.mind.nature.current().name,
+      system: prompt.system + "\n" + prompt.summary,
+      mergeSystem: prompt.system + "\n" + prompt.summaryMerge,
+    });
+  }
+  // Runs on the server maintenance timer: finishes interrupted compaction,
+  // trims old traces hourly, and lets her glance back at conversations that
+  // went on while she was not looking.
+  maintain(now = this.now()) {
+    if (this.queue.closed) return;
+    if (now >= this.tracePruneDue) {
+      const { more } = this.repo.pruneTraces(now);
+      this.tracePruneDue = more ? now : now + TRACE_PRUNE_INTERVAL_MS;
+    }
+    for (const { id } of this.repo.db
+      .prepare("SELECT id FROM sessions WHERE enabled=1 AND archived=0")
+      .all()) {
+      if (!this.enabled(id, { simulated: false })) continue;
+      const policy = this.policy(id);
+      this.backgroundWork(id, policy, now);
+      this.checkBacklog(id, now);
+    }
+  }
+  checkBacklog(session, now = this.now()) {
+    if (this.queue.lanes.has(session)) return null;
+    if (now - (this.backlogChecked.get(session) || 0) < BACKLOG_RECHECK_MS)
+      return null;
+    const unread = this.mind.unread(session, { now });
+    // Still flowing: the next batch will be read with them.
+    if (!unread.length || now - unread.at(-1).time < 3 * 60000) return null;
+    this.backlogChecked.set(session, now);
+    return this.process(session, unread, { backlog: true }).catch(() => null);
+  }
+  finishQuietly(trace, status) {
+    try {
+      this.repo.finish(trace, status);
+    } catch {
+      // The database may already be closed during shutdown.
+    }
+  }
+  close() {
+    this.mind.time.attention.close();
+    this.queue.close();
+    this.compactor.close();
+  }
+}

package/server/core/perceivers.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { text } from "../mind/util.js";
+
+// A plugin reads one attachment she is actually looking at (a voice message,
+// a file) and hands back words. The words are cached, so a replay never asks
+// again, and they stay data: never an instruction.
+export class Perceivers {
+  constructor(db) {
+    this.db = db;
+    this.handlers = new Map();
+  }
+  register(type, pluginId, run) {
+    const key = String(type || "").slice(0, 40);
+    if (!key || typeof run !== "function") throw Error("感知类型无效");
+    const list = this.handlers.get(key) || [];
+    list.push({ pluginId, run });
+    this.handlers.set(key, list);
+  }
+  unregister(pluginId) {
+    for (const [type, list] of this.handlers) {
+      const next = list.filter((item) => item.pluginId !== pluginId);
+      if (next.length) this.handlers.set(type, next);
+      else this.handlers.delete(type);
+    }
+  }
+  async apply(snapshot, { replay = false, now = Date.now() } = {}) {
+    if (!this.handlers.size) return;
+    const batch = new Set(snapshot.batchIds || []);
+    for (const message of snapshot.messages || []) {
+      if (!batch.has(message.id)) continue;
+      const notes = [];
+      for (const attachment of message.attachments || []) {
+        const list = this.handlers.get(attachment?.type) || [];
+        for (const handler of list) {
+          const key = createHash("sha256")
+            .update(
+              JSON.stringify([
+                handler.pluginId,
+                attachment.type,
+                attachment.file || attachment.url || "",
+                message.id,
+              ]),
+            )
+            .digest("hex");
+          const cached = this.db
+            .prepare("SELECT text FROM core_perceptions WHERE cache_key=?")
+            .get(key);
+          if (cached) {
+            notes.push(cached.text);
+            continue;
+          }
+          if (replay) continue;
+          let result = null;
+          try {
+            result = await Promise.race([
+              Promise.resolve().then(() =>
+                handler.run({
+                  attachment,
+                  messageId: message.id,
+                  sessionId: snapshot.sessionId,
+                }),
+              ),
+              new Promise((_, reject) =>
+                setTimeout(() => reject(Error("感知超时")), 15000),
+              ),
+            ]);
+          } catch {
+            continue;
+          }
+          const line = text(result?.text, 400);
+          if (!line) continue;
+          this.db
+            .prepare(
+              "INSERT OR IGNORE INTO core_perceptions(cache_key,session_id,message_id,plugin_id,type,text,created) VALUES (?,?,?,?,?,?,?)",
+            )
+            .run(
+              key,
+              snapshot.sessionId,
+              message.id,
+              handler.pluginId,
+              attachment.type,
+              line,
+              now,
+            );
+          notes.push(line);
+        }
+      }
+      if (notes.length) message.perceived = notes.slice(0, 4);
+    }
+  }
+}

package/server/core/person-name.js

@@ -0,0 +1,22 @@
+import { readableName } from "./speaker-names.js";
+
+// Only a person's own explicit request supplies a preferred form of address.
+export function requestedName(value) {
+  const words = String(value || "").trim();
+  if (/不要记|别记|不许记|不要叫我|别叫我|忘掉/.test(words)) return "";
+  const match = words.match(
+    /(?:^|[，,。！!；;\s])(?:以后|今后|请(?:你)?|麻烦|你(?:就|可以)?|记住[，,：:\s]*)*(?:叫我|称呼我(?:为)?|(?:记住[，,：:\s]*)?我的(?:名字|昵称)(?:是|叫)|记住[，,：:\s]*我叫)[\s：:]*[“"「『]?([^，,。！!？?；;\n”"」』]{1,32})/u,
+  );
+  if (!match) return "";
+  const name = match[1]
+    .trim()
+    .replace(/(?:就好|就行|即可|好吗|吧|哦|呀|啦)$/, "")
+    .trim();
+  if (
+    /^(?:group|private|onebot):|^(?:群聊|私聊)\s*\d|^(?:去|来|帮|把|别|先|等|做|打开|关掉|回答|发消息)|叫你|不要|记住/.test(
+      name,
+    )
+  )
+    return "";
+  return readableName(name, "");
+}