luckytri 1.2.2 → 1.2.4

package/server/stickers/index.js

@@ -0,0 +1,363 @@
+import { prepareVisionImage } from "../core/image-preprocessor.js";
+import { storedModels } from "../core/model-manager.js";
+import { normalize, dot } from "../core/embedding.js";
+import { StickerLibrary, stickerText, cleanTags } from "./library.js";
+
+const DAY = 86400000;
+const OPEN_MS = 15 * 60000;
+const clip = (v, n) =>
+  String(v ?? "")
+    .trim()
+    .slice(0, n);
+const toBlob = (vector) => Buffer.from(normalize(vector).buffer);
+const fromBlob = (blob) =>
+  blob
+    ? new Float32Array(
+        blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength),
+      )
+    : null;
+// Bonds fade unless renewed: an old laugh is not a standing preference.
+export const fadedWeight = (weight, updated, now) =>
+  (Number(weight) || 0) *
+  0.5 ** (Math.max(0, now - (updated || now)) / (60 * DAY));
+
+// How a person answered a sticker she sent. Only a clear warm or cold answer
+// counts; anything else leaves no mark, so sending a lot teaches nothing.
+export function stickerOutcome(text) {
+  const t = String(text || "").trim();
+  if (!t) return null;
+  if (
+    /别发了|别再发|无聊|好尬|尬死|看不懂|什么鬼|烦死|不好笑|没意思|发这个干嘛/.test(
+      t,
+    )
+  )
+    return "cold";
+  if (
+    /^\[(?:动画)?表情\]|^\[图片\]|哈{2,}|笑死|hh{2,}|233|绝了|可爱|好家伙|草{1,3}$|乐|牛|笑疯/i.test(
+      t,
+    )
+  )
+    return "warm";
+  return null;
+}
+
+const SYSTEM = `你在给一张表情包写档案，供以后挑表情时检索。只描述看得见的东西和这张表情在中文网络聊天里的常见用法，不编造出处。输出 JSON：{"description":"画面里是什么（30字内）","words":"图上的文字，没有则空","emotion":"传达的情绪（如 无语、得意、委屈、开心、嘲讽、撒娇）","meaning":"这张表情在聊天里表达的意思或梗（40字内）","scenes":"适合在什么情境发（40字内）","tags":["3到8个短标签"],"category":"一个两到四字的分类，如 开心、无语、撒娇、嘲讽、安慰、问候"}`;
+
+// Her sticker kernel: the library, how each sticker is understood, which
+// few fit this moment, and what using one with someone came to mean.
+export class Stickers {
+  constructor(repo, { models, embedding, now = () => Date.now() } = {}) {
+    this.repo = repo;
+    this.db = repo.db;
+    this.models = models;
+    this.embedding = embedding;
+    this.now = now;
+    this.library = new StickerLibrary(this.db, { now });
+  }
+
+  settings() {
+    return { enabled: true, ...(this.repo.config?.("stickers") || {}) };
+  }
+
+  visionProfile() {
+    const wanted = this.settings().taggingModelId;
+    const all = storedModels(this.repo);
+    const pick =
+      all.find((m) => m.id === wanted && m.vision) || all.find((m) => m.vision);
+    return pick ? this.models.profile(pick.id) : null;
+  }
+
+  // Look at a newly added sticker once and write what it is for. The owner
+  // can edit everything it wrote afterwards.
+  async describe(id, { force = false } = {}) {
+    const item = this.library.get(id);
+    if (!item) throw Error("表情不存在");
+    if (item.status === "ready" && !force) return item;
+    const profile = this.visionProfile();
+    if (!profile) {
+      this.db
+        .prepare("UPDATE sticker_items SET status='manual',error=? WHERE id=?")
+        .run("模型库里还没有开启视觉能力的模型，可以手动填写标签", id);
+      return this.library.get(id);
+    }
+    try {
+      const { bytes } = this.library.image(id);
+      const prepared = await prepareVisionImage(Buffer.from(bytes));
+      const trace = { id: `sticker:${id}`, steps: [], calls: [] };
+      const out = await this.models.call(
+        profile,
+        "vision",
+        SYSTEM,
+        { task: "为这张表情写档案", name: item.name || "" },
+        trace,
+        [
+          {
+            kind: "sticker",
+            messageId: "upload",
+            speaker: "管理台",
+            frameOnly: prepared.frameOnly,
+            url: `data:${prepared.mime};base64,${prepared.bytes.toString("base64")}`,
+          },
+        ],
+      );
+      const filled = (key, n) => (item[key] ? item[key] : clip(out?.[key], n));
+      this.library.update(id, {
+        description: filled("description", 200),
+        words: filled("words", 100),
+        emotion: filled("emotion", 40),
+        meaning: filled("meaning", 200),
+        scenes: filled("scenes", 200),
+        tags: item.tags.length ? item.tags : cleanTags(out?.tags),
+        ...(item.category ? {} : { category: clip(out?.category, 24) }),
+        status: "ready",
+      });
+      this.db.prepare("UPDATE sticker_items SET error=NULL WHERE id=?").run(id);
+    } catch (error) {
+      this.db
+        .prepare("UPDATE sticker_items SET status='failed',error=? WHERE id=?")
+        .run(clip(error.message, 200), id);
+    }
+    await this.embedPending(5);
+    return this.library.get(id);
+  }
+
+  // Vectors for stickers whose meaning is known; skipped quietly when the
+  // embedding service is off, and words still find them.
+  async embedPending(limit = 20) {
+    if (!this.embedding?.enabled?.()) return 0;
+    const rows = this.db
+      .prepare(
+        `SELECT id,description,words,emotion,meaning,scenes,tags FROM sticker_items
+         WHERE status IN ('ready','manual') AND (embedding IS NULL OR embed_signature IS NOT ?) LIMIT ?`,
+      )
+      .all(this.embedding.signature(), limit);
+    if (!rows.length) return 0;
+    try {
+      const vectors = await this.embedding.embed(
+        rows.map((r) =>
+          stickerText({ ...r, tags: JSON.parse(r.tags || "[]") }),
+        ),
+        { purpose: "document" },
+      );
+      const stmt = this.db.prepare(
+        "UPDATE sticker_items SET embedding=?,embed_signature=? WHERE id=?",
+      );
+      rows.forEach((r, i) => {
+        if (vectors[i])
+          stmt.run(toBlob(vectors[i]), this.embedding.signature(), r.id);
+      });
+      return rows.length;
+    } catch {
+      return 0;
+    }
+  }
+
+  // A handful of stickers that could fit this moment, never the library.
+  // Vectors narrow it first, words when vectors are unavailable; what she
+  // and this person shared, and how stickers landed before, reorder it.
+  async candidates({
+    session,
+    text,
+    mood = "",
+    addressee = "",
+    memories = [],
+    limit = 5,
+  }) {
+    if (!this.settings().enabled) return [];
+    const rows = this.db
+      .prepare(
+        `SELECT id,description,words,emotion,meaning,scenes,tags,embedding,animated FROM sticker_items
+         WHERE enabled=1 AND status IN ('ready','manual') AND description<>''`,
+      )
+      .all();
+    if (!rows.length) return [];
+    const now = this.now();
+    // Vectors and old uses are tidied in passing, at most every ten minutes.
+    if (!(this.tidiedAt > now - 600000)) {
+      this.tidiedAt = now;
+      this.prune();
+      this.embedPending().catch(() => 0);
+    }
+    const query = [text, mood && `我此刻的心情：${mood}`]
+      .filter(Boolean)
+      .join("\n");
+    let qv = null;
+    if (this.embedding?.available?.() && rows.some((r) => r.embedding)) {
+      try {
+        [qv] = await this.embedding.embed([query], {
+          purpose: "query",
+          timeoutMs: 2500,
+        });
+        qv = qv && normalize(qv);
+      } catch {
+        qv = null;
+      }
+    }
+    const bonds = new Map();
+    for (const b of this.db
+      .prepare(
+        "SELECT sticker_id,user_id,weight,meaning,updated FROM sticker_bonds WHERE user_id IN (?, '')",
+      )
+      .all(String(addressee || "")))
+      bonds.set(`${b.sticker_id}|${b.user_id}`, b);
+    const recentRows = this.db
+      .prepare(
+        "SELECT sticker_id, MAX(time) time FROM sticker_uses WHERE session_id=? AND time>? GROUP BY sticker_id",
+      )
+      .all(session, now - 2 * 3600000);
+    // Just sent here: not again so soon. Earlier today: a step back.
+    const justUsed = new Set(
+      recentRows
+        .filter((r) => r.time > now - 30 * 60000)
+        .map((r) => r.sticker_id),
+    );
+    const recent = new Set(recentRows.map((r) => r.sticker_id));
+    const grams = (s) => {
+      const out = new Set();
+      const t = String(s || "").replace(/\s+/g, "");
+      for (let i = 0; i < t.length - 1; i++) out.add(t.slice(i, i + 2));
+      return out;
+    };
+    const qGrams = grams(query);
+    const memoryGrams = grams(memories.join("\n"));
+    const overlap = (set, s) => {
+      const g = grams(s);
+      if (!g.size || !set.size) return 0;
+      let n = 0;
+      for (const x of g) if (set.has(x)) n++;
+      return n / Math.sqrt(g.size * set.size);
+    };
+    const scored = rows.map((r) => {
+      const item = { ...r, tags: JSON.parse(r.tags || "[]") };
+      const words = stickerText(item);
+      const v = fromBlob(r.embedding);
+      const fit = qv && v ? dot(qv, v) : overlap(qGrams, words) * 1.6;
+      const personal = bonds.get(`${r.id}|${addressee}`);
+      const own = bonds.get(`${r.id}|`);
+      const shared = personal?.meaning
+        ? Math.max(
+            overlap(qGrams, personal.meaning),
+            overlap(memoryGrams, personal.meaning),
+          )
+        : 0;
+      const score =
+        fit +
+        0.12 * fadedWeight(personal?.weight, personal?.updated, now) +
+        0.06 * fadedWeight(own?.weight, own?.updated, now) +
+        0.5 * shared -
+        (recent.has(r.id) ? 0.35 : 0);
+      return { item, score, fit, personal };
+    });
+    const floor = qv ? 0.3 : 0.12;
+    return scored
+      .filter(
+        (s) =>
+          !justUsed.has(s.item.id) && (s.fit >= floor || s.personal?.meaning),
+      )
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit)
+      .map(({ item, personal }, i) => ({
+        ref: `s${i + 1}`,
+        id: item.id,
+        looks: clip(item.description, 60),
+        ...(item.words ? { says: clip(item.words, 30) } : {}),
+        means: clip(item.meaning || item.emotion, 60),
+        ...(item.scenes ? { fits: clip(item.scenes, 50) } : {}),
+        ...(personal?.meaning
+          ? { withThisPerson: clip(personal.meaning, 60) }
+          : {}),
+      }));
+  }
+
+  // She sent one: remember with whom and about what, to see how it lands.
+  used({ stickerId, session, userId = "", topic = "" }) {
+    this.db
+      .prepare(
+        "INSERT INTO sticker_uses(sticker_id,session_id,user_id,topic,time) VALUES (?,?,?,?,?)",
+      )
+      .run(
+        stickerId,
+        session,
+        String(userId || ""),
+        clip(topic, 40),
+        this.now(),
+      );
+  }
+
+  // Someone spoke after a sticker of hers. A clear warm or cold answer from
+  // the person it was for becomes part of what that sticker means between
+  // them; silence or ordinary talk closes the use without a trace.
+  observe(message, nameOf = (id) => id) {
+    if (!message || message.role === "assistant" || message.simulated) return;
+    const now = this.now();
+    this.db
+      .prepare(
+        "UPDATE sticker_uses SET outcome='flat',outcome_time=? WHERE outcome IS NULL AND time<?",
+      )
+      .run(now, now - OPEN_MS);
+    const open = this.db
+      .prepare(
+        "SELECT * FROM sticker_uses WHERE session_id=? AND outcome IS NULL AND time>? ORDER BY time DESC LIMIT 1",
+      )
+      .get(message.sessionId, now - OPEN_MS);
+    if (!open) return;
+    const from = String(message.userId || "");
+    if (open.user_id && open.user_id !== from) return;
+    const outcome = stickerOutcome(message.text);
+    if (!outcome) return;
+    this.db
+      .prepare(
+        "UPDATE sticker_uses SET outcome=?,outcome_time=?,reply=? WHERE id=?",
+      )
+      .run(outcome, now, clip(message.text, 40), open.id);
+    const bond = (userId, delta, meaning) => {
+      const old = this.db
+        .prepare(
+          "SELECT weight,updated,meaning FROM sticker_bonds WHERE sticker_id=? AND user_id=?",
+        )
+        .get(open.sticker_id, userId);
+      const weight = Math.max(
+        -2,
+        Math.min(2, fadedWeight(old?.weight, old?.updated, now) + delta),
+      );
+      this.db
+        .prepare(
+          `INSERT INTO sticker_bonds(sticker_id,user_id,weight,meaning,updated) VALUES (?,?,?,?,?)
+           ON CONFLICT(sticker_id,user_id) DO UPDATE SET weight=excluded.weight,meaning=excluded.meaning,updated=excluded.updated`,
+        )
+        .run(
+          open.sticker_id,
+          userId,
+          weight,
+          meaning ?? old?.meaning ?? "",
+          now,
+        );
+    };
+    const who = nameOf(from) || "对方";
+    const about = open.topic ? `聊「${open.topic}」时` : "";
+    if (outcome === "warm") {
+      bond(
+        from,
+        0.3,
+        `${about}发给${who}过，${who}回了「${clip(message.text, 16)}」`,
+      );
+      bond("", 0.1);
+    } else {
+      bond(from, -0.5, `${about}发给${who}过，${who}不太买账`);
+      bond("", -0.2);
+    }
+  }
+
+  // Old closed uses that left no mark are dropped; a library of uses must
+  // not grow with every send.
+  prune() {
+    this.db
+      .prepare(
+        "DELETE FROM sticker_uses WHERE time<? AND (outcome IS NULL OR outcome='flat')",
+      )
+      .run(this.now() - 30 * DAY);
+    this.db
+      .prepare("DELETE FROM sticker_uses WHERE time<?")
+      .run(this.now() - 180 * DAY);
+  }
+}

package/server/stickers/library.js

@@ -0,0 +1,199 @@
+import { createHash, randomUUID } from "node:crypto";
+import sharp from "sharp";
+import { imageMime } from "../core/image-preprocessor.js";
+import { ensureStickerSchema } from "./schema.js";
+
+export const STICKER_MAX_BYTES = 2 * 1024 * 1024;
+const ALLOWED = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+const clip = (value, n) =>
+  String(value ?? "")
+    .trim()
+    .slice(0, n);
+export const cleanTags = (tags) =>
+  [
+    ...new Set(
+      (Array.isArray(tags) ? tags : String(tags || "").split(/[,，、\s]+/))
+        .map((t) => clip(t, 16))
+        .filter(Boolean),
+    ),
+  ].slice(0, 16);
+
+// Columns the studio may show; the image bytes are never part of a list.
+const LIST = `id,mime,width,height,animated,size,name,category,tags,description,words,emotion,meaning,scenes,status,error,enabled,created,updated`;
+const row = (r) =>
+  r && {
+    ...r,
+    animated: !!r.animated,
+    enabled: !!r.enabled,
+    tags: JSON.parse(r.tags || "[]"),
+  };
+
+export class StickerLibrary {
+  constructor(db, { now = () => Date.now() } = {}) {
+    this.db = db;
+    this.now = now;
+    ensureStickerSchema(db);
+  }
+
+  // Checks the bytes themselves, never the file name or a claimed type.
+  async add(bytes, { name = "", category = "" } = {}) {
+    if (!Buffer.isBuffer(bytes) || !bytes.length) throw Error("文件为空");
+    if (bytes.length > STICKER_MAX_BYTES)
+      throw Error("表情超过 2MB，请压缩后再上传");
+    const mime = imageMime(bytes);
+    if (!ALLOWED.has(mime)) throw Error("只支持 PNG、JPEG、GIF、WebP 图片");
+    let meta;
+    try {
+      meta = await sharp(bytes, { limitInputPixels: 40_000_000 }).metadata();
+    } catch {
+      throw Error("图片读取失败");
+    }
+    if (!meta.width || !meta.height || meta.width > 4096 || meta.height > 4096)
+      throw Error("表情尺寸应在 4096 像素以内");
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    const existing = this.db
+      .prepare("SELECT id FROM sticker_items WHERE sha256=?")
+      .get(sha256);
+    if (existing) return { ...this.get(existing.id), duplicate: true };
+    const id = randomUUID();
+    const now = this.now();
+    this.db
+      .prepare(
+        `INSERT INTO sticker_items(id,sha256,mime,bytes,width,height,animated,size,name,category,status,created,updated)
+         VALUES (?,?,?,?,?,?,?,?,?,?,'pending',?,?)`,
+      )
+      .run(
+        id,
+        sha256,
+        mime,
+        bytes,
+        meta.width,
+        meta.height,
+        (meta.pages || 1) > 1 ? 1 : 0,
+        bytes.length,
+        clip(name, 60),
+        clip(category, 24),
+        now,
+        now,
+      );
+    return this.get(id);
+  }
+
+  get(id) {
+    return row(
+      this.db.prepare(`SELECT ${LIST} FROM sticker_items WHERE id=?`).get(id),
+    );
+  }
+
+  image(id) {
+    return this.db
+      .prepare("SELECT mime,bytes FROM sticker_items WHERE id=?")
+      .get(id);
+  }
+
+  list({ q = "", category = "", limit = 500 } = {}) {
+    const where = [];
+    const args = [];
+    if (category) {
+      where.push("category=?");
+      args.push(category);
+    }
+    const words = String(q).trim().split(/\s+/).filter(Boolean).slice(0, 5);
+    for (const w of words) {
+      where.push(
+        "(name LIKE ? OR tags LIKE ? OR description LIKE ? OR words LIKE ? OR emotion LIKE ? OR meaning LIKE ? OR scenes LIKE ? OR category LIKE ?)",
+      );
+      args.push(...Array(8).fill(`%${w.replace(/[%_]/g, "")}%`));
+    }
+    return this.db
+      .prepare(
+        `SELECT ${LIST} FROM sticker_items ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY created DESC LIMIT ?`,
+      )
+      .all(...args, Math.min(1000, Number(limit) || 500))
+      .map(row);
+  }
+
+  categories() {
+    return this.db
+      .prepare(
+        "SELECT category, COUNT(*) n FROM sticker_items WHERE category<>'' GROUP BY category ORDER BY n DESC",
+      )
+      .all();
+  }
+
+  // An edit by the owner. Changing what it means invalidates its vector.
+  update(id, patch = {}) {
+    const current = this.get(id);
+    if (!current) throw Error("表情不存在");
+    const next = {
+      name: patch.name !== undefined ? clip(patch.name, 60) : current.name,
+      category:
+        patch.category !== undefined
+          ? clip(patch.category, 24)
+          : current.category,
+      tags: patch.tags !== undefined ? cleanTags(patch.tags) : current.tags,
+      description:
+        patch.description !== undefined
+          ? clip(patch.description, 200)
+          : current.description,
+      words: patch.words !== undefined ? clip(patch.words, 100) : current.words,
+      emotion:
+        patch.emotion !== undefined ? clip(patch.emotion, 40) : current.emotion,
+      meaning:
+        patch.meaning !== undefined
+          ? clip(patch.meaning, 200)
+          : current.meaning,
+      scenes:
+        patch.scenes !== undefined ? clip(patch.scenes, 200) : current.scenes,
+      enabled: patch.enabled !== undefined ? !!patch.enabled : current.enabled,
+    };
+    const semantic = [
+      "tags",
+      "description",
+      "words",
+      "emotion",
+      "meaning",
+      "scenes",
+    ].some((k) => patch[k] !== undefined);
+    this.db
+      .prepare(
+        `UPDATE sticker_items SET name=?,category=?,tags=?,description=?,words=?,emotion=?,meaning=?,scenes=?,enabled=?,updated=?
+         ${semantic ? ",embedding=NULL,embed_signature=NULL" : ""}${patch.status ? ",status=?" : ""} WHERE id=?`,
+      )
+      .run(
+        next.name,
+        next.category,
+        JSON.stringify(next.tags),
+        next.description,
+        next.words,
+        next.emotion,
+        next.meaning,
+        next.scenes,
+        next.enabled ? 1 : 0,
+        this.now(),
+        ...(patch.status ? [patch.status] : []),
+        id,
+      );
+    return this.get(id);
+  }
+
+  remove(id) {
+    this.db.prepare("DELETE FROM sticker_items WHERE id=?").run(id);
+    this.db.prepare("DELETE FROM sticker_bonds WHERE sticker_id=?").run(id);
+    this.db.prepare("DELETE FROM sticker_uses WHERE sticker_id=?").run(id);
+  }
+}
+
+// The text a sticker is found by: what it shows, says and is for.
+export function stickerText(s) {
+  return [
+    s.description,
+    s.words && `图上的字：${s.words}`,
+    s.emotion && `情绪：${s.emotion}`,
+    s.meaning && `意思：${s.meaning}`,
+    s.scenes && `适合：${s.scenes}`,
+    s.tags?.length && `标签：${s.tags.join("、")}`,
+  ]
+    .filter(Boolean)
+    .join("；");
+}

package/server/stickers/offer.js

@@ -0,0 +1,123 @@
+import { isGroupSession, parseSessionKey } from "../channels/session-key.js";
+
+// Only OneBot can carry an @ segment or a sticker image.
+export function expressiveChannel(session) {
+  try {
+    return parseSessionKey(session).channel === "onebot";
+  } catch {
+    return false;
+  }
+}
+
+// Who she could call by name in this group: people who spoke recently. A
+// name nobody here has used is never offered, so an @ cannot land on a
+// stranger or on someone the room has not seen.
+export function atCandidates(snapshot, session) {
+  if (!isGroupSession(session)) return [];
+  const seen = new Map();
+  for (const m of [...(snapshot.messages || [])].reverse().slice(0, 30)) {
+    const id = String(m.speaker ?? m.userId ?? "");
+    if (!id || id === "bot" || m.role === "assistant" || seen.has(id)) continue;
+    if (!/^\d{5,12}$/.test(id)) continue;
+    seen.set(id, { userId: id, name: m.name || id });
+    if (seen.size >= 8) break;
+  }
+  return [...seen.values()];
+}
+
+// The @s she wrote, kept only when they make sense: someone offered, at
+// most two, and not the one person she is already talking with one to one
+// (in a two-person exchange the @ only repeats what the reply says).
+export function chosenAt(raw, snapshot, session, targets = []) {
+  const offered = new Map((snapshot.canAt || []).map((p) => [p.userId, p]));
+  if (!offered.size || !Array.isArray(raw)) return [];
+  let picked = [
+    ...new Set(
+      raw
+        .map((x) => String(x?.userId ?? x ?? ""))
+        .filter((id) => offered.has(id)),
+    ),
+  ].slice(0, 2);
+  // Someone who just called on her will see her answer; an @ back at them
+  // only repeats it. Unless others have spoken since, burying their line.
+  const messages = snapshot.messages || [];
+  const answered = new Set();
+  for (const id of targets) {
+    const at = messages.findIndex((m) => m.id === id);
+    if (at < 0 || messages[at].relation !== "direct") continue;
+    const author = String(messages[at].speaker ?? messages[at].userId ?? "");
+    const later = messages
+      .slice(at + 1)
+      .some(
+        (m) =>
+          m.role !== "assistant" && String(m.speaker ?? m.userId) !== author,
+      );
+    if (!later) answered.add(author);
+  }
+  picked = picked.filter((id) => !answered.has(id));
+  if (picked.length === 1) {
+    const recent = (snapshot.messages || [])
+      .slice(-6)
+      .filter((m) => m.role !== "assistant")
+      .map((m) => String(m.speaker ?? m.userId ?? ""));
+    if (recent.length && recent.every((id) => id === picked[0])) return [];
+  }
+  return picked.map((id) => offered.get(id));
+}
+
+export function chosenSticker(raw, snapshot) {
+  const ref = String(raw?.ref ?? raw?.id ?? raw ?? "").trim();
+  if (!ref) return null;
+  return (
+    (snapshot.stickers || []).find((s) => s.ref === ref || s.id === ref) || null
+  );
+}
+
+// What reaches her about stickers and @ this turn, only when there is
+// something to choose from.
+export function expressionInput(snapshot) {
+  const stickers = snapshot.stickers || [];
+  const canAt = snapshot.canAt || [];
+  if (!stickers.length && !canAt.length) return {};
+  return {
+    expression: {
+      ...(stickers.length
+        ? {
+            stickers: stickers.map(({ id: _id, ...s }) => s),
+            stickerNote:
+              '这些是你收藏的表情里此刻可能合适的几张。真想用时返回 sticker:"ref"（一次最多一张，可以配文字，也可以只发表情，此时 say 留空）；不合适就不用，不必为用而用。withThisPerson 是你和这个人用它的经历。',
+          }
+        : {}),
+      ...(canAt.length
+        ? {
+            canAt,
+            atNote:
+              "群里要叫住某个人、让他注意到这句话时，可返回 at:[userId]，最多两人；正在一对一接话、对方自然会看到时不用@。",
+          }
+        : {}),
+    },
+  };
+}
+
+// "@小红" typed as text is not an @ on QQ. A name she wrote that way for
+// someone offered becomes a real @, and the typed copy is removed so the
+// message does not show the name twice.
+export function typedAt(bubbles, at, snapshot) {
+  const offered = snapshot.canAt || [];
+  const chosen = new Map(at.map((p) => [p.userId, p]));
+  const out = bubbles.map((line, i) => {
+    let text = line;
+    for (const p of offered) {
+      const mark = `@${p.name}`;
+      if (!p.name || !text.includes(mark)) continue;
+      if (i === 0 && chosen.size < 2) chosen.set(p.userId, p);
+      if (chosen.has(p.userId))
+        text = text
+          .split(mark)
+          .join("")
+          .replace(/^[\s，,]+/, "");
+    }
+    return text.trim();
+  });
+  return { bubbles: out.filter(Boolean), at: [...chosen.values()] };
+}