luckytri 1.1.2 → 1.2.0

package/server/core/turn-processor.js

@@ -1,7 +1,9 @@
+import { speechLength } from "./speech-length.js";
 import { parseSessionKey } from "../channels/session-key.js";
 import { initiativeContext, initiativeSnapshot } from "./initiative-context.js";
 import { withFallback } from "./model-manager.js";
 import { activityRecallCue } from "../mind/time/activity-recall.js";
+import { withRecallContext } from "../mind/recall/cue.js";
 import { replyPrompt, prompts } from "./persona-manager.js";
 import { buildContext, perceive } from "./context-builder.js";
 import {
@@ -323,12 +325,14 @@ export class TurnProcessor {
           /* An unparseable destination has no person to infer. */
         }
       }
+      // A short follow-up is recalled together with the line it leans on.
+      const recallBatch = withRecallContext(batch, resolved);
       lap("perceive");
       // Replays exclude mutable memory so later corrections cannot leak into
       // the past; her inner state is folded as of the replayed moment.
       const memories =
         policy.memory && !replay && !ownInitiative
-          ? await this.owner.mind.recall.memories(session, batch, now, {
+          ? await this.owner.mind.recall.memories(session, recallBatch, now, {
               people,
               touch: live,
               forSpeech: true,
@@ -371,7 +375,7 @@ export class TurnProcessor {
       lap("summaries");
       const meant =
         !replay && !ownInitiative
-          ? await this.owner.mind.recall.relatedOwn(session, batch, now)
+          ? await this.owner.mind.recall.relatedOwn(session, recallBatch, now)
           : null;
       const view = this.owner.mind.view({
         session: preview?.viewSession || session,
@@ -402,13 +406,18 @@ export class TurnProcessor {
             activityCue,
           }),
         );
+      let recollected = [];
       if (policy.memory && !replay && !ownInitiative) {
         const recollections = await this.owner.mind.recall.recollect(
           session,
-          batch,
+          recallBatch,
           now,
-          { people },
+          {
+            people,
+            exclude: new Set((view.recalled || []).map((r) => r.id)),
+          },
         );
+        recollected = recollections;
         if (recollections.length)
           view.inner.recollections = {
             note: RECOLLECTION_NOTE,
@@ -485,7 +494,7 @@ export class TurnProcessor {
       if (!replay)
         snapshot.topics = this.owner.topics.recent(session, watermark, now);
       if (!ownInitiative) {
-        await this.addWorkingMemory(session, snapshot, batch, now, {
+        await this.addWorkingMemory(session, snapshot, recallBatch, now, {
           replay,
           zone: policy.timeZone,
         });
@@ -622,6 +631,7 @@ export class TurnProcessor {
         return finish("stale", "读房间时又有新话，并入下一批");
       }
       lap("checks");
+      const speech = speechLength(nature);
       let turn;
       try {
         turn = normalizeTurn(
@@ -644,6 +654,7 @@ export class TurnProcessor {
           ),
           snapshot,
           trace,
+          { speech },
         );
         if (generationImages.length)
           markVisionSeen(
@@ -716,6 +727,7 @@ export class TurnProcessor {
           reason: choice === turn.choice ? turn.reason : "没发出去",
           watermark,
           occasion: occasion?.type || null,
+          recalled: whatCameToMind(memories, recollected, view, trace),
           time: now,
         });
       };
@@ -798,3 +810,24 @@ export class TurnProcessor {
     }
   }
 }
+
+// The past that was in front of her this turn, for the permanent record next
+// to her choice. A failure here must never cost the turn.
+function whatCameToMind(memories, recollected, view, trace) {
+  try {
+    return [
+      ...(memories || []).map((m) => ({
+        id: `fact:${m.id}`,
+        why: m.whySelected,
+      })),
+      ...(recollected || []).flatMap((r) => [
+        { id: r.ref, why: r.why },
+        ...(r.linked || []).map((id) => ({ id, why: "linked" })),
+      ]),
+      ...(view?.recalled || []),
+    ];
+  } catch (error) {
+    trace?.steps?.push(`没能记下这轮想起了什么：${error.message}`);
+    return [];
+  }
+}

package/server/core/turn.js

@@ -11,6 +11,8 @@ import {
   explicitStop,
 } from "./dialogue-context.js";
 import { readerQuestions } from "./reader-check.js";
+import { conversationNeeds } from "./conversation-needs.js";
+import { BOT_GUIDE, CREATIVE_GUIDE } from "./dialogue-contract.js";
 import {
   botExchange,
   CONTRIBUTION_CHECK,
@@ -41,9 +43,11 @@ const LEGACY = {
   SILENT: "silent",
 };
 
-export function maxBubbles(choice, snapshot) {
+// A ceiling on how many messages one turn may send, never a target. The
+// owner's length setting moves it; someone here asking for one message wins.
+export function maxBubbles(choice, snapshot, speech) {
   if (choice !== "speak") return 1;
-  return prefersSingleBubble(snapshot || {}) ? 1 : 3;
+  return prefersSingleBubble(snapshot || {}) ? 1 : speech?.maxBubbles || 3;
 }
 
 export function joinBubbleParts(parts) {
@@ -154,6 +158,7 @@ export async function takeTurn(
     ...(extra.pressure ? { pressure: extra.pressure } : {}),
     ...(recallWording(snapshot) ? { guidance: recallWording(snapshot) } : {}),
     ...(!initiating ? { exchange: currentExchange(snapshot) } : {}),
+    ...turnGuides(snapshot),
   };
   let raw = await models.call(
     profile,
@@ -163,6 +168,7 @@ export async function takeTurn(
     trace,
     images,
   );
+  raw = withSaidMessages(raw);
   const words = (
     Array.isArray(raw?.bubbles) ? raw.bubbles : [raw?.bubbles]
   ).filter((word) => typeof word === "string");
@@ -235,18 +241,20 @@ export async function takeTurn(
       if (review.hasContribution === false && review.shouldRepair === true) {
         trace?.steps?.push("新问题或新段落被上一稿漏接，按当前内容重新想一次");
         try {
-          const repaired = await models.call(
-            profile,
-            "turn",
-            `${turnSystem}\n${CONTRIBUTION_REPAIR}`,
-            {
-              ...turnInput,
-              contributionRepair: {
-                previousReply: raw.bubbles || [],
+          const repaired = withSaidMessages(
+            await models.call(
+              profile,
+              "turn",
+              `${turnSystem}\n${CONTRIBUTION_REPAIR}`,
+              {
+                ...turnInput,
+                contributionRepair: {
+                  previousReply: raw.bubbles || [],
+                },
               },
-            },
-            trace,
-            images,
+              trace,
+              images,
+            ),
           );
           const repairedExchange = botExchange(snapshot, repaired);
           if (
@@ -343,7 +351,7 @@ function liftMisplaced(raw, trace) {
   return out;
 }
 
-export function normalizeTurn(raw, snapshot, trace) {
+export function normalizeTurn(raw, snapshot, trace, { speech } = {}) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw))
     throw SyntaxError("回合输出不是 JSON 对象");
   const known = new Set((snapshot.messages || []).map((m) => m.id));
@@ -393,13 +401,21 @@ export function normalizeTurn(raw, snapshot, trace) {
       "这是一句完整回应，按正常发言保留，不为短反应标签改写原意",
     );
   }
-  const bubbleLimit = maxBubbles(choice, snapshot);
+  const bubbleLimit = maxBubbles(choice, snapshot, speech);
   if (bubbles.length > bubbleLimit) {
     if (choice === "speak" && bubbleLimit === 1) {
       bubbles = [joinBubbleParts(bubbles)];
       trace?.steps?.push("根据对方的偏好，把连续补充合成一条完整消息");
     } else {
-      bubbles = bubbles.slice(0, bubbleLimit);
+      // Fold the overflow into the last allowed message instead of losing
+      // what she meant to say.
+      bubbles =
+        choice === "speak"
+          ? [
+              ...bubbles.slice(0, bubbleLimit - 1),
+              joinBubbleParts(bubbles.slice(bubbleLimit - 1)),
+            ]
+          : bubbles.slice(0, bubbleLimit);
       trace?.steps?.push(
         choice === "react"
           ? "简短反应只留第一条气泡"
@@ -430,6 +446,15 @@ export function normalizeTurn(raw, snapshot, trace) {
     !crisis &&
     !snapshot.initiative &&
     (grounding.botLoop ||
+      // She read the other AI's line as a goodbye herself; answering a
+      // goodbye from a bot only starts another round of goodbyes.
+      // Who is saying goodbye matters, not how long the bots have talked.
+      (raw.understanding?.kind === "closing" &&
+        grounding.botMessageIds.length > 0 &&
+        batch
+          .filter((m) => m.role === "user")
+          .every((m) => grounding.botMessageIds.includes(m.id)) &&
+        !batch.some((m) => m.relation === "direct")) ||
       (raw.contribution?.kind === "none" &&
         !raw.act &&
         !raw.share &&
@@ -556,3 +581,32 @@ export function wordingNotes(turn, snapshot) {
     .filter(Boolean)
     .join("\n");
 }
+
+// Writing or bot-conversation guidance, only when the conversation is about
+// those things. How the room types is deliberately not given: her voice comes
+// from her own state and past words, not from imitating the people here.
+function turnGuides(snapshot) {
+  const needs = conversationNeeds(snapshot);
+  return {
+    ...(needs.creative ? { creativeGuide: CREATIVE_GUIDE } : {}),
+    ...(needs.bots ? { botGuide: BOT_GUIDE } : {}),
+  };
+}
+
+// She writes what she would type as one piece of text; a blank line is where
+// she would press send and start another message. Writing one message is the
+// natural default of typing, so how many she sends is a choice she makes,
+// not a list she is handed to fill. An older reply with "bubbles" still works.
+export function saidMessages(text) {
+  return String(text)
+    .split(/\n[ \t\u3000]*\n+/)
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+export function withSaidMessages(raw) {
+  if (!raw || typeof raw !== "object" || typeof raw.say !== "string")
+    return raw;
+  const { say, ...rest } = raw;
+  return { ...rest, bubbles: saidMessages(say) };
+}

package/server/i18n/errors.js

@@ -2,6 +2,7 @@
 // key, exactly as the code writes it. `{0}` stands for a value the code puts
 // into the message; patterns are used when a message carries one.
 export const ERRORS = {
+  复审超过截止时间: "The reply review passed its deadline",
   "JSON 同一对象含重复字段，不能确定哪份内容有效":
     "A JSON object contains duplicate fields; the intended value is ambiguous",
   "写日记期间关系记录已变化，本次旧稿未保存，下次按新认识整理":
@@ -33,6 +34,23 @@ export const ERRORS = {
     "The update did not complete. The original program and data were retained. Check the runtime log before trying again.",
   "自动恢复未完成，更新前的校验备份已保留，请查看运行日志并手动恢复。":
     "Automatic recovery did not complete. The verified pre-update backup was retained. Check the runtime log and recover manually.",
+  "缺少候选版本的数据迁移器，已停止更新":
+    "The candidate release has no data migrator. The update was stopped.",
+  迁移目标不是现有的绝对路径数据库文件:
+    "The migration target must be an existing database at an absolute path",
+  迁移目标版本与候选程序不一致:
+    "The migration target version does not match the candidate release",
+  迁移目标数据库与更新前备份不匹配:
+    "The migration database does not match the pre-update backup",
+  数据库未迁移到候选版本要求的结构:
+    "The database was not migrated to the schema required by the candidate release",
+  迁移后数据库身份发生变化: "The database identity changed during migration",
+  "迁移后的数据库仍有未关闭的 SQLite 事务":
+    "The migrated database still has an open SQLite transaction",
+  "旧数据库仍被占用，无法安全切换":
+    "The old database is still in use and cannot be switched safely",
+  "数据库仍有未关闭的 SQLite 事务文件，请重试更新":
+    "SQLite transaction files are still open. Try the update again.",
   修改机会需要明确的记录与原因:
     "An edit opportunity needs an explicit record and reason",
   修改机会记录无效: "Invalid edit opportunity record",
@@ -283,6 +301,8 @@ export const ERRORS = {
   向量数量与输入不一致: "The vector count does not match the input",
   向量内容无效: "The vector content is invalid",
   向量维度不一致: "The vector dimensions are inconsistent",
+  "向量服务不支持自动长度，已改用模型自己的长度":
+    "The vector service does not support the automatic length; using the model's own length",
   知识库名称无效: "The collection name is invalid",
   知识库不存在: "The collection does not exist",
   "文档内容应为 1–400000 字": "The document must be 1–400000 characters",
@@ -550,7 +570,17 @@ export const ERRORS = {
 // Messages that carry a value. `{0}`, `{1}` are filled with what the code put
 // in; the values are passed through the dictionaries again.
 export const ERROR_PATTERNS = [
+  ["记忆索引重建失败：{0}", "Memory index rebuild failed: {0}"],
+  ["迁移后缺少原数据表：{0}", "The migration is missing original table: {0}"],
+  [
+    "迁移后 {0} 记录数减少（{1} → {2}），已停止更新",
+    "The migration reduced {0} rows ({1} → {2}); the update was stopped",
+  ],
   ["删除失败（{0}）", "Removal failed ({0})"],
+  [
+    "向量维度不一致：接口返回 {0} 维，应为 {1} 维",
+    "The vector dimensions are inconsistent: the service returned {0}, expected {1}",
+  ],
   ["清理工作异常结束：{0}", "Cleanup ended unexpectedly: {0}"],
   ["{0} Prompt 无效", "{0} prompt is invalid"],
   ["模型请求失败 HTTP {0}：{1}", "The model request failed with HTTP {0}: {1}"],

package/server/i18n/labels.js

@@ -145,6 +145,11 @@ export const LABELS = {
   刚才: "just now",
   今天早些时候: "earlier today",
   好几天前: "several days ago",
+  一周前: "a week ago",
+  两三周前: "two or three weeks ago",
+  一个多月前: "over a month ago",
+  几个月前: "a few months ago",
+  一年多前: "over a year ago",
   很久以前: "a long time ago",
   还未相遇: "Not met yet",
   "还没有真实聊天，时间暂时没有可以延续的落点。":

package/server/index.js

@@ -15,6 +15,8 @@ import { openSync, closeSync } from "node:fs";
 import { join } from "node:path";
 import { UpdateChecker } from "./studio/updates.js";
 import { InstanceUpdater } from "./runtime/update-manager.js";
+import { migrateReleaseData } from "./runtime/data-migration.js";
+import { VERSION } from "./version.js";
 
 claimServer();
 process.on("exit", clearStarting);
@@ -32,6 +34,7 @@ const chatSystem = new ChatSystem(store, channel.send, {
   fetchQuoted: (message) => channel.fetchQuoted(message),
   fetchImage: (file, sessionId) => channel.fetchImage(file, sessionId),
 });
+await migrateReleaseData(chatSystem.mind, { version: VERSION });
 const life = new Life(chatSystem, {
   online: () => channel.online(),
   canReach: (session) => channel.canReach(session),

package/server/knowledge/embedding-profile.js

@@ -16,37 +16,94 @@ export const EMBEDDING_DEFAULTS = {
 };
 export const EMBEDDING_PROTOCOLS = new Set(["openai", "multimodal"]);
 
-// Defaults when the user gives an address and a key. Dimension 0 means the
-// request does not name a length, so the model returns its own. For
-// doubao-embedding-vision that is 2048. The model name is filled in only
-// when the address is Volcengine Ark.
-export function suggestEmbedding(chat = {}, address = "") {
-  const given = String(address || "")
-    .trim()
-    .replace(/\/$/, "");
-  const chatBase = String(chat.baseUrl || "")
+// Embeddings are any OpenAI-compatible /embeddings endpoint: an address, a
+// model name and a key. Presets only fill in what the user left empty for
+// providers known to need it; none of them is what "embedding" means.
+// `chat: true` keeps the chat address, because that plan's key works only
+// there (an Agent Plan key is refused by the ordinary /api/v3 address).
+export const EMBEDDING_PRESETS = [
+  {
+    id: "volcengine-agent-plan",
+    label: "火山方舟 Agent Plan",
+    match: /volces\.com\/api\/plan\//i,
+    chat: true,
+    model: "doubao-embedding-vision",
+  },
+  {
+    id: "volcengine-ark",
+    label: "火山方舟",
+    match: /volces\.com|volcengine/i,
+    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+    model: "doubao-embedding-vision",
+  },
+];
+
+const trimUrl = (value) =>
+  String(value || "")
     .trim()
     .replace(/\/$/, "");
+export const embeddingPreset = (address) =>
+  EMBEDDING_PRESETS.find((preset) => preset.match.test(trimUrl(address))) ||
+  null;
+
+// Defaults when the user gives an address and a key. Dimension 0 means
+// automatic: see automaticLength below. Without a preset the address is the
+// chat one and the model must be named.
+export function suggestEmbedding(chat = {}, address = "") {
+  const given = trimUrl(address);
+  const chatBase = trimUrl(chat.baseUrl);
   const base = given || chatBase;
-  const ark = /volces\.com|volcengine/i.test(base);
+  const preset = embeddingPreset(base);
   return {
     protocol: "openai",
     dimensions: 0,
     batchSize: 10,
     timeoutMs: 90000,
-    baseUrl:
-      given || (ark ? "https://ark.cn-beijing.volces.com/api/v3" : chatBase),
-    model: ark ? "doubao-embedding-vision" : String(chat.embeddingModel || ""),
+    baseUrl: given || (preset && !preset.chat ? preset.baseUrl : chatBase),
+    model: preset?.model || String(chat.embeddingModel || ""),
+    preset: preset?.id || "",
   };
 }
 
+// What "automatic" (dimension 0) asks a model for, per model rather than per
+// provider. Every model is asked for nothing and keeps its own length unless
+// an entry here names a shorter `automatic` one. doubao-embedding-vision has
+// no such entry: on the recall benchmark with real vectors (2026-10-12) 1024
+// ranked slightly worse than its own 2048 (one more miss and one more fact
+// attributed to the wrong person in 59 cases), and a shorter default would
+// make every install that already has 2048 vectors embed everything again.
+// `native` says which explicit length is the same space as asking nothing.
+export const MODEL_LENGTHS = [
+  { model: /doubao-embedding-vision/i, native: 2048 },
+];
+const LENGTHS = MODEL_LENGTHS;
+// Providers seen to refuse or ignore the automatic length, by address and
+// model. Saving the profile again clears it.
+const NATIVE = "embedding-native-length";
+
+const modelOf = (profile) => profile.embeddingModel || profile.model || "";
+const lengthsOf = (profile) =>
+  LENGTHS.find((entry) => entry.model.test(modelOf(profile)));
+const nativeKey = (profile) => `${profile.baseUrl || ""}|${modelOf(profile)}`;
+
+// The length actually requested. 0 means "do not name one".
+export function automaticLength(profile, refused = {}) {
+  if (profile.dimensions) return profile.dimensions;
+  if (refused[nativeKey(profile)]) return 0;
+  return lengthsOf(profile)?.automatic || 0;
+}
+
+// Asking for the length a model returns anyway is the same space as not
+// asking, so both share one signature: typing 2048 for doubao finds the
+// vectors made with 0 instead of paying to embed everything twice.
 export function embeddingSignature(profile) {
+  const length = profile.dimensions || 0;
   return createHash("sha256")
     .update(
       JSON.stringify([
         profile.baseUrl || "",
-        profile.embeddingModel || profile.model || "",
-        profile.dimensions || 0,
+        modelOf(profile),
+        length === lengthsOf(profile)?.native ? 0 : length,
         ...(profile.protocol === "multimodal" ? ["multimodal"] : []),
       ]),
     )
@@ -96,25 +153,35 @@ export function saveEmbeddingProfile(repo, input) {
     if (!Number.isSafeInteger(next[key]) || next[key] < min || next[key] > max)
       throw Error(`${key} 超出范围`);
   repo.saveConfig(CONFIG, next);
+  repo.saveConfig(NATIVE, {});
   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 };
+  const base = saved
+    ? {
+        ...EMBEDDING_DEFAULTS,
+        ...saved,
+        id: "embedding",
+        embedding: saved.enabled,
+        embeddingModel: saved.model,
+        isolatedEmbeddingKey: true,
+      }
+    : models.profile("default");
+  const refused = repo.config(NATIVE, {}) || {};
+  const dimensions = automaticLength(base, refused);
+  const profile = { ...base, dimensions };
+  if (!base.dimensions && dimensions)
+    // A provider that refuses the length, or answers another, is remembered;
+    // the next request goes back to the model's own length and signature.
+    profile.refuseLength = (reason) =>
+      repo.saveConfig(NATIVE, {
+        ...(repo.config(NATIVE, {}) || {}),
+        [nativeKey(base)]: { at: Date.now(), reason: String(reason) },
+      });
+  return { profile, signature: embeddingSignature(profile), legacy: !saved };
 }
 
 // A provider may accept fewer inputs per request than configured; its own
@@ -142,6 +209,8 @@ export async function embedBatches(models, profile, texts, options = {}) {
         batchLimits.set(limitKey, size);
         continue;
       }
+      if (profile.refuseLength && Number(error?.status) === 400)
+        await refusedLength(models, profile, batch, options, error);
       throw error;
     }
     start += batch.length;
@@ -156,9 +225,37 @@ export async function embedBatches(models, profile, texts, options = {}) {
       )
         throw Error("向量内容无效");
       dimension ||= vector.length;
-      if (vector.length !== dimension) throw Error("向量维度不一致");
+      if (vector.length !== dimension) {
+        if (profile.refuseLength && vector.length !== profile.dimensions) {
+          profile.refuseLength(`answered ${vector.length}`);
+          throw lengthChanged();
+        }
+        throw Error(
+          `向量维度不一致：接口返回 ${vector.length} 维，应为 ${dimension} 维`,
+        );
+      }
       vectors.push(vector);
     }
   }
   return vectors;
 }
+
+const lengthChanged = () =>
+  Object.assign(Error("向量服务不支持自动长度，已改用模型自己的长度"), {
+    lengthChanged: true,
+  });
+
+// A 400 may be the length or anything else (a bad key arrives as 400 too).
+// One request without the length tells which. Vectors already made under
+// the old signature must not be saved, so the caller still gets an error
+// and asks again under the new one.
+async function refusedLength(models, profile, batch, options, error) {
+  try {
+    const { refuseLength, beforeBatch, ...plain } = profile;
+    await models.embed({ ...plain, dimensions: 0 }, batch.slice(0, 1), options);
+  } catch {
+    return;
+  }
+  profile.refuseLength(error.detail || error.message);
+  throw lengthChanged();
+}