luckytri 1.2.2 → 1.2.4

package/server/core/image-preprocessor.js

@@ -1,6 +1,10 @@
 import sharp from "sharp";
 
 const MIB = 1024 * 1024;
+// Largest picture accepted for understanding; bigger ones are shrunk before
+// any model sees them. VISION_SOURCE_CEILING_MB bounds the OneBot frame.
+export const VISION_SOURCE_DEFAULT_MB = 20;
+export const VISION_SOURCE_CEILING_MB = 64;
 const TYPES = {
   jpeg: "image/jpeg",
   png: "image/png",
@@ -19,7 +23,8 @@ function configured(value, fallback, min, max) {
 export function visionImageLimits(env = process.env) {
   return {
     maxSourceBytes: Math.floor(
-      configured(env.VISION_SOURCE_MAX_MB, 32, 4, 64) * MIB,
+      configured(env.VISION_SOURCE_MAX_MB, VISION_SOURCE_DEFAULT_MB, 1, 64) *
+        MIB,
     ),
     maxModelBytes: Math.floor(
       configured(env.VISION_MODEL_MAX_MB, 4, 1, 4) * MIB,
@@ -33,6 +38,41 @@ export function visionImageLimits(env = process.env) {
   };
 }
 
+// The owner's image-understanding size: the long side and the encoded size
+// a picture is brought down to before a model sees it. A big photo is shrunk
+// and re-encoded rather than refused; many providers reject large images or
+// time out on them.
+export function modelImageLimits({
+  visionMaxSide = 2048,
+  visionMaxMB = 3,
+  visionSourceMaxMB = VISION_SOURCE_DEFAULT_MB,
+} = {}) {
+  const source = Math.min(
+    VISION_SOURCE_CEILING_MB,
+    Math.max(1, Number(visionSourceMaxMB) || VISION_SOURCE_DEFAULT_MB),
+  );
+  const side = Math.min(
+    8192,
+    Math.max(512, Math.floor(Number(visionMaxSide) || 2048)),
+  );
+  const mb = Math.min(4, Math.max(0.5, Number(visionMaxMB) || 3));
+  return {
+    maxDimension: side,
+    maxOutputPixels: side * side,
+    maxModelBytes: Math.floor(mb * MIB),
+    maxSourceBytes: Math.floor(source * MIB),
+  };
+}
+
+// The owner's setting, unless the operator pinned the source size in the
+// environment (VISION_SOURCE_MAX_MB), which then wins everywhere.
+export function ownerImageLimits(settings, env = process.env) {
+  const limits = modelImageLimits(settings);
+  if (env.VISION_SOURCE_MAX_MB != null && env.VISION_SOURCE_MAX_MB !== "")
+    limits.maxSourceBytes = visionImageLimits(env).maxSourceBytes;
+  return limits;
+}
+
 export function imageMime(bytes) {
   if (
     bytes.length >= 3 &&

package/server/core/message-scheduler.js

@@ -16,6 +16,8 @@ export async function deliver(
     // Platform id of an earlier message the first bubble answers, when the
     // conversation has moved past it; the channel may show it as a quote.
     quote = "",
+    // People she chose to @, on her first message only, the way one types.
+    at = [],
   } = {},
 ) {
   const ids = bubbles.map((text, i) => {
@@ -45,10 +47,16 @@ export async function deliver(
         .prepare("UPDATE core_outbox SET status='sending',text=? WHERE id=?")
         .run(outgoing, ids[i]);
       try {
+        const first = i === 0 && (quote || at.length);
         const result = await send(
           message,
           outgoing,
-          i === 0 && quote ? { replyTo: quote } : undefined,
+          first
+            ? {
+                ...(quote ? { replyTo: quote } : {}),
+                ...(at.length ? { at: at.map((p) => p.userId) } : {}),
+              }
+            : undefined,
         );
         repo.db
           .prepare(
@@ -62,7 +70,9 @@ export async function deliver(
             traceId: trace.id,
             replyTargetIds: trace.decision?.targetMessageIds || [],
           },
-          outgoing,
+          i === 0 && at.length
+            ? `${at.map((p) => `@${p.name}`).join(" ")} ${outgoing}`
+            : outgoing,
           result?.message_id,
           now(),
         );

package/server/core/orchestrator.js

@@ -1,3 +1,4 @@
+import { Stickers } from "../stickers/index.js";
 import { settleAftermath } from "../mind/aftermath.js";
 import { randomUUID } from "node:crypto";
 import { Repository } from "./repository.js";
@@ -64,6 +65,11 @@ export class ChatSystem {
         embedding: this.mind.embedding,
       });
     this.compactor = new ContextCompactor(this.repo);
+    this.stickers = new Stickers(this.repo, {
+      models: this.models,
+      embedding: this.mind.embedding,
+      now: () => this.now(),
+    });
     this.topics = new TopicTracker(this.repo);
     this.capabilities = new Capabilities(this.repo, { now });
     this.perceivers = new Perceivers(this.repo.db);
@@ -211,6 +217,14 @@ export class ChatSystem {
         this.store.settings().memoryCandidates !== false
       )
         this.mind.memory.remember({ ...m, ...event });
+      if (!m.simulated)
+        try {
+          this.stickers.observe({ ...m, ...event }, (id) =>
+            this.mind.bonds.name(id),
+          );
+        } catch {
+          // A sticker outcome is a side note; never stop a message for it.
+        }
       // Its vector is made while the batch gathers; the turn finds it cached.
       if (!m.simulated && this.enabled(event.sessionId, { simulated: false }))
         this.mind.recall.arrive(event.seq, this.now()).catch(() => false);

package/server/core/reply-delivery.js

@@ -1,3 +1,5 @@
+import { typedAt } from "../stickers/offer.js";
+import { persistReply } from "./message-manager.js";
 import { PRIVATELY_KNOWN } from "../mind/discretion.js";
 import { replyFocus } from "./conversation-cues.js";
 
@@ -532,6 +534,19 @@ export class ReplyDelivery {
       }
     };
     if (outdated()) return staleExit();
+    if (!turn.bubbles.length && turn.sticker && !turn.crisis?.clear) {
+      // Only a sticker: nothing to check in words, it was chosen from hers.
+      trace.response = { bubbles: [], sticker: turn.sticker.ref };
+      trace.sent = [];
+      const sent = await this.sendSticker(
+        batch.at(-1) || c.anchor,
+        turn,
+        trace,
+        session,
+        isCurrent,
+      );
+      return finish(sent ? "sent" : "cancelled", turn.reason);
+    }
     let response = turn.bubbles.length
       ? normalizeResponse(
           { bubbles: turn.bubbles, reason: turn.reason },
@@ -701,6 +716,10 @@ export class ReplyDelivery {
       this.owner.now(),
       snapshot.inner?.currentLife?.current,
     );
+    // A rewritten or generated reply may type an @ as text; it is made real.
+    const typed = typedAt(response.bubbles, turn.at || [], snapshot);
+    if (typed.bubbles.length)
+      response = { ...response, bubbles: typed.bubbles };
     trace.response = response;
     trace.sent = await deliver(
       this.owner.repo,
@@ -712,6 +731,7 @@ export class ReplyDelivery {
       {
         now: this.owner.now,
         quote: buriedTarget(batch, turn.targetMessageIds, session),
+        at: typed.at,
         prepareBubble: (line) =>
           this.owner.mind.time.reconcile(
             { bubbles: [line] },
@@ -722,6 +742,14 @@ export class ReplyDelivery {
       },
     );
     if (!trace.sent.length && hasRelevantUpdate()) return staleExit();
+    if (trace.sent.length && turn.sticker)
+      await this.sendSticker(
+        batch.at(-1) || c.anchor,
+        turn,
+        trace,
+        session,
+        isCurrent,
+      );
     if (trace.sent.length && !c.simulatedTurn) {
       if (turn.share?.workId) {
         try {
@@ -744,6 +772,50 @@ export class ReplyDelivery {
     }
     return finish(trace.sent.length ? "sent" : "cancelled", turn.reason);
   }
+  // Her sticker, after her words. It is recorded as something she sent, and
+  // the use is kept to learn how it landed with this person.
+  async sendSticker(message, turn, trace, session, isCurrent) {
+    const owner = this.owner;
+    const image = owner.stickers?.library.image(turn.sticker.id);
+    if (!image || !isCurrent()) return false;
+    try {
+      await new Promise((r) => setTimeout(r, owner.stickerPause ?? 600));
+      const result = await owner.send(message, "", {
+        image: {
+          base64: Buffer.from(image.bytes).toString("base64"),
+          sticker: true,
+          summary: "[动画表情]",
+        },
+      });
+      const text = `[表情：${turn.sticker.looks}]`;
+      persistReply(
+        owner.repo,
+        {
+          ...message,
+          traceId: trace.id,
+          replyTargetIds: turn.targetMessageIds || [],
+        },
+        text,
+        result?.message_id,
+        owner.now(),
+      );
+      (trace.sent ||= []).push(text);
+      if (!message?.simulated) {
+        const target = (message && (message.userId ?? message.speaker)) || "";
+        owner.stickers.used({
+          stickerId: turn.sticker.id,
+          session,
+          userId: target,
+          topic: turn.topic || "",
+        });
+      }
+      trace.steps.push(`发了一张表情：${turn.sticker.looks}`);
+      return true;
+    } catch (error) {
+      trace.steps.push(`表情没有发出去：${error.message}`);
+      return false;
+    }
+  }
 }
 
 // In a group, when several other people have spoken since the one message

package/server/core/turn-processor.js

@@ -1,3 +1,6 @@
+import { mediaSettings } from "../stickers/api.js";
+import { ownerImageLimits } from "./image-preprocessor.js";
+import { atCandidates, expressiveChannel } from "../stickers/offer.js";
 import { speechLength } from "./speech-length.js";
 import { parseSessionKey } from "../channels/session-key.js";
 import { initiativeContext, initiativeSnapshot } from "./initiative-context.js";
@@ -455,6 +458,27 @@ export class TurnProcessor {
         snapshot.inner = view.inner;
       }
       lap("context");
+      if (!ownInitiative && this.owner.stickers && expressiveChannel(session)) {
+        // A few stickers that could fit, and who she could @; she decides.
+        snapshot.canAt = atCandidates(snapshot, session);
+        try {
+          const last = snapshot.batch.at(-1) || {};
+          snapshot.stickers = await this.owner.stickers.candidates({
+            session,
+            text: snapshot.batch.map((m) => m.text || "").join("\n"),
+            mood: view.inner?.state || "",
+            addressee: String(last.speaker ?? last.userId ?? ""),
+            memories: (snapshot.memories || [])
+              .map((m) => m.content || m.text || "")
+              .slice(0, 6),
+          });
+        } catch (error) {
+          snapshot.stickers = [];
+          trace.steps.push(`表情候选暂不可用：${error.message}`);
+        }
+        if (!snapshot.canAt.length) delete snapshot.canAt;
+        if (!snapshot.stickers.length) delete snapshot.stickers;
+      }
       const visionModel = model.vision
         ? model
         : this.owner.fallbackFor(null, model).find((item) => item.vision) ||
@@ -474,6 +498,7 @@ export class TurnProcessor {
         ? await this.owner.loadVisionImages(early.pending, {
             sessionId: snapshot.sessionId,
             fetchImage: this.owner.fetchImage,
+            imageLimits: ownerImageLimits(mediaSettings(this.owner.repo)),
           })
         : { images: [], unavailable: [] };
       const planned = classifyLoaded(

package/server/core/turn.js

@@ -1,3 +1,9 @@
+import {
+  chosenAt,
+  chosenSticker,
+  expressionInput,
+  typedAt,
+} from "../stickers/offer.js";
 import { replyFocus } from "./conversation-cues.js";
 import { INITIATIVE_PROMPT } from "../mind/initiative.js";
 import { initiativeContext } from "./initiative-context.js";
@@ -159,6 +165,7 @@ export async function takeTurn(
     ...(recallWording(snapshot) ? { guidance: recallWording(snapshot) } : {}),
     ...(!initiating ? { exchange: currentExchange(snapshot) } : {}),
     ...turnGuides(snapshot),
+    ...expressionInput(snapshot),
   };
   let raw = await models.call(
     profile,
@@ -564,8 +571,8 @@ export function normalizeTurn(raw, snapshot, trace, { speech } = {}) {
       .slice(0, 4),
     crisis: crisis ? { clear: true, messageIds: crisisIds } : { clear: false },
     act: botYield || stopped ? null : normalizeAct(raw.act, trace),
-    bubbles: bubbles.slice(0, bubbleLimit),
     maxBubbles: bubbleLimit,
+    ...expressionChoice(raw, snapshot, choice, bubbles.slice(0, bubbleLimit)),
   };
 }
 
@@ -639,3 +646,20 @@ export function typedSends(text) {
   }
   return sends;
 }
+
+// A sticker and @s are part of what she chose, kept only when they point at
+// something she was actually offered this turn.
+function expressionChoice(raw, snapshot, choice, bubbles) {
+  if (!["speak", "react"].includes(choice)) return { bubbles };
+  const sticker = chosenSticker(raw.sticker, snapshot);
+  const typed = typedAt(
+    bubbles,
+    chosenAt(raw.at, snapshot, snapshot.sessionId, ids(raw.targetMessageIds)),
+    snapshot,
+  );
+  return {
+    bubbles: typed.bubbles,
+    ...(sticker ? { sticker } : {}),
+    ...(typed.at.length ? { at: typed.at } : {}),
+  };
+}

package/server/i18n/errors.js

@@ -2,6 +2,20 @@
 // 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 = {
+  表情开关无效: "Invalid sticker switch",
+  "图片理解尺寸应在 512–8192 像素之间":
+    "Image understanding size must be between 512 and 8192 pixels",
+  "图片理解大小应在 0.5–4 MB 之间":
+    "Image understanding size must be between 0.5 and 4 MB",
+  "可接收的图片大小应在 1–64 MB 之间":
+    "The accepted image size must be between 1 and 64 MB",
+  表情不存在: "The sticker does not exist",
+  文件为空: "The file is empty",
+  "表情超过 2MB，请压缩后再上传":
+    "The sticker is larger than 2 MB; compress it and upload again",
+  "只支持 PNG、JPEG、GIF、WebP 图片":
+    "Only PNG, JPEG, GIF and WebP images are supported",
+  "表情尺寸应在 4096 像素以内": "Stickers must be within 4096 pixels",
   复审超过截止时间: "The reply review passed its deadline",
   "JSON 同一对象含重复字段，不能确定哪份内容有效":
     "A JSON object contains duplicate fields; the intended value is ambiguous",
@@ -382,6 +396,7 @@ export const ERRORS = {
   "插件不支持这个 LuckyTri 版本":
     "The plugin does not support this version of LuckyTri",
   插件网络主机无效: "A plugin network host is invalid",
+  压缩包过大: "The archive is too large",
   压缩包无法读取: "The archive could not be read",
   压缩包文件过多: "The archive has too many files",
   压缩包不能加密: "The archive must not be encrypted",

package/server/plugins/zip.js

@@ -27,7 +27,19 @@ function safeName(name) {
 
 // Reads a zip the way a stranger's file has to be read: only stored and
 // deflate entries, no encryption, no links, no paths that leave the folder.
-export function readZip(buffer) {
+//
+// Options let another caller (the sticker library) take larger archives:
+// maxFiles / maxBytes bound the whole archive; keep(name) skips an entry
+// without inflating it; an entry over maxEntryBytes is reported, not read.
+export function readZip(
+  buffer,
+  {
+    maxFiles = MAX_FILES,
+    maxBytes = MAX_BYTES,
+    maxEntryBytes = Infinity,
+    keep = () => true,
+  } = {},
+) {
   if (!Buffer.isBuffer(buffer) || buffer.length < 22)
     throw new Error("压缩包无法读取");
   const eocd = findEocd(buffer);
@@ -35,7 +47,7 @@ export function readZip(buffer) {
   if (buffer.readUInt16LE(eocd + 4) !== 0)
     throw new Error("压缩包格式不受支持");
   const entries = buffer.readUInt16LE(eocd + 10);
-  if (!entries || entries > MAX_FILES) throw new Error("压缩包文件过多");
+  if (!entries || entries > maxFiles) throw new Error("压缩包文件过多");
   let offset = buffer.readUInt32LE(eocd + 16);
   if (offset >= buffer.length) throw new Error("压缩包无法读取");
   const files = [];
@@ -68,6 +80,11 @@ export function readZip(buffer) {
     if (method !== 0 && method !== 8) throw new Error("压缩包格式不受支持");
     if (name.endsWith("/") || name.endsWith("\\")) continue;
     const fileName = safeName(name);
+    if (!keep(fileName)) continue;
+    if (size > maxEntryBytes) {
+      files.push({ name: fileName, skipped: "too-large" });
+      continue;
+    }
     if (buffer.readUInt32LE(local) !== 0x04034b50)
       throw new Error("压缩包无法读取");
     const dataAt =
@@ -84,16 +101,27 @@ export function readZip(buffer) {
         method === 0
           ? Buffer.from(compressed)
           : inflateRawSync(compressed, {
-              maxOutputLength: MAX_BYTES - total + 1,
+              maxOutputLength: Math.min(maxBytes - total, maxEntryBytes) + 1,
             });
     } catch (error) {
+      if (
+        error?.code === "ERR_BUFFER_TOO_LARGE" &&
+        maxEntryBytes < maxBytes - total
+      ) {
+        files.push({ name: fileName, skipped: "too-large" });
+        continue;
+      }
       if (error?.code === "ERR_BUFFER_TOO_LARGE")
         throw new Error("压缩包解压后过大");
       throw new Error("压缩包无法读取");
     }
     if (size && bytes.length !== size) throw new Error("压缩包内容不完整");
+    if (bytes.length > maxEntryBytes) {
+      files.push({ name: fileName, skipped: "too-large" });
+      continue;
+    }
     total += bytes.length;
-    if (total > MAX_BYTES) throw new Error("压缩包解压后过大");
+    if (total > maxBytes) throw new Error("压缩包解压后过大");
     files.push({ name: fileName, bytes });
   }
   return files;

package/server/stickers/api.js

@@ -0,0 +1,170 @@
+import express from "express";
+import { importStickerZip, stickerZipLimitMb } from "./zip-import.js";
+
+// The owner's sticker library. Uploads arrive as raw bytes, one file per
+// request; everything else is JSON like the rest of the studio API.
+export function mountStickerUpload(app, system) {
+  app.post(
+    "/api/core/stickers/upload",
+    express.raw({ type: "*/*", limit: "3mb" }),
+    async (req, res) => {
+      try {
+        const item = await system.stickers.library.add(req.body, {
+          name: String(req.query.name || "").replace(/\.[a-z0-9]+$/i, ""),
+          category: String(req.query.category || ""),
+        });
+        if (!item.duplicate) queueDescribe(system, item.id);
+        res.json(item);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    },
+  );
+  app.post(
+    "/api/core/stickers/upload-zip",
+    express.raw({ type: "*/*", limit: `${stickerZipLimitMb()}mb` }),
+    async (req, res) => {
+      try {
+        res.json(
+          await importStickerZip(system.stickers.library, req.body, {
+            category: String(req.query.category || ""),
+            folderCategory: req.query.folderCategory === "1",
+            queue: (id) => queueDescribe(system, id),
+          }),
+        );
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    },
+  );
+}
+
+const queue = [];
+let running = false;
+let current = null; // the one being analysed right now still counts as pending
+function queueDescribe(system, id) {
+  queue.push(id);
+  if (running) return;
+  running = true;
+  (async () => {
+    while (queue.length) {
+      const next = queue.shift();
+      current = next;
+      try {
+        await system.stickers.describe(next, { force: true });
+      } catch {
+        // The item records its own failure; the owner can retry.
+      }
+    }
+    current = null;
+    running = false;
+  })();
+}
+
+const MEDIA_DEFAULTS = {
+  visionMaxSide: 2048,
+  visionMaxMB: 3,
+  visionSourceMaxMB: 20,
+};
+export function mediaSettings(repo) {
+  return { ...MEDIA_DEFAULTS, ...(repo.config("media") || {}) };
+}
+
+export function mountStickers(app, system) {
+  const { library } = system.stickers;
+  const wrap = (fn) => async (req, res) => {
+    try {
+      await fn(req, res);
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  };
+  app.get(
+    "/api/core/stickers",
+    wrap((req, res) =>
+      res.json({
+        items: library.list({
+          q: req.query.q || "",
+          category: req.query.category || "",
+        }),
+        categories: library.categories(),
+        settings: system.stickers.settings(),
+        pending: queue.length + (current ? 1 : 0),
+      }),
+    ),
+  );
+  app.get(
+    "/api/core/stickers/:id/image",
+    wrap((req, res) => {
+      const image = library.image(req.params.id);
+      if (!image) return res.status(404).json({ error: "表情不存在" });
+      res.setHeader("Content-Type", image.mime);
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("Cache-Control", "private, max-age=86400");
+      res.end(Buffer.from(image.bytes));
+    }),
+  );
+  app.patch(
+    "/api/core/stickers/:id",
+    wrap((req, res) => res.json(library.update(req.params.id, req.body))),
+  );
+  app.delete(
+    "/api/core/stickers/:id",
+    wrap((req, res) => {
+      library.remove(req.params.id);
+      res.json({ ok: true });
+    }),
+  );
+  app.post(
+    "/api/core/stickers/:id/describe",
+    wrap((req, res) => {
+      if (!library.get(req.params.id)) throw Error("表情不存在");
+      library.update(req.params.id, { status: "pending" });
+      queueDescribe(system, req.params.id);
+      res.json({ ok: true });
+    }),
+  );
+  app.put(
+    "/api/core/stickers-settings",
+    wrap((req, res) => {
+      const { enabled, taggingModelId } = req.body;
+      if (enabled !== undefined && typeof enabled !== "boolean")
+        throw Error("表情开关无效");
+      system.repo.saveConfig("stickers", {
+        ...system.stickers.settings(),
+        ...(enabled !== undefined ? { enabled } : {}),
+        ...(taggingModelId !== undefined
+          ? { taggingModelId: String(taggingModelId || "") }
+          : {}),
+      });
+      res.json(system.stickers.settings());
+    }),
+  );
+  app.get(
+    "/api/core/media-settings",
+    wrap((req, res) => res.json(mediaSettings(system.repo))),
+  );
+  app.put(
+    "/api/core/media-settings",
+    wrap((req, res) => {
+      const side = Number(req.body.visionMaxSide);
+      const mb = Number(req.body.visionMaxMB);
+      const source = Number(
+        req.body.visionSourceMaxMB ??
+          mediaSettings(system.repo).visionSourceMaxMB,
+      );
+      if (!Number.isFinite(source) || source < 1 || source > 64)
+        throw Error("可接收的图片大小应在 1–64 MB 之间");
+      if (!Number.isInteger(side) || side < 512 || side > 8192)
+        throw Error("图片理解尺寸应在 512–8192 像素之间");
+      if (!Number.isFinite(mb) || mb < 0.5 || mb > 4)
+        throw Error("图片理解大小应在 0.5–4 MB 之间");
+      system.repo.saveConfig("media", {
+        visionMaxSide: side,
+        visionMaxMB: mb,
+        visionSourceMaxMB: source,
+      });
+      res.json(mediaSettings(system.repo));
+    }),
+  );
+}