luckytri 1.2.1 → 1.2.3

package/scripts/update-instance.js

@@ -5,6 +5,7 @@ import {
   writeFileSync,
   readFileSync,
   realpathSync,
+  writeSync,
 } from "node:fs";
 import { dirname, join, delimiter } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -23,6 +24,21 @@ import {
   writeUpdateJob,
 } from "../server/runtime/update-manager.js";
 import { updateRoot } from "../server/runtime/installation.js";
+import {
+  npmFailureCode,
+  updateError,
+} from "../server/runtime/update-errors.js";
+
+export function requireUpdateNode(version = process.versions.node) {
+  const [major, minor] = String(version).split(".").map(Number);
+  if (
+    !Number.isInteger(major) ||
+    !Number.isInteger(minor) ||
+    major < 24 ||
+    (major === 24 && minor < 5)
+  )
+    throw updateError("NODE_UNSUPPORTED");
+}
 
 export function installEnvironment(env) {
   const kept = {};
@@ -35,11 +51,11 @@ export function installEnvironment(env) {
       kept[key] = value;
   return kept;
 }
-export function findNpmCli(env = process.env) {
+export function findNpmCli(env = process.env, execPath = process.execPath) {
   const candidates = [
     env.npm_execpath,
-    join(dirname(process.execPath), "node_modules/npm/bin/npm-cli.js"),
-    join(dirname(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js"),
+    join(dirname(execPath), "node_modules/npm/bin/npm-cli.js"),
+    join(dirname(execPath), "../lib/node_modules/npm/bin/npm-cli.js"),
     ...String(env.PATH || env.Path || "")
       .split(delimiter)
       .flatMap((dir) => [
@@ -60,31 +76,73 @@ export function findNpmCli(env = process.env) {
       /* Try the next native Node/npm installation location. */
     }
   }
-  throw Error("未找到 npm");
+  throw updateError("NPM_NOT_FOUND");
 }
-function command(args, { cwd, env = process.env, timeout = 600000, log } = {}) {
+export function runUpdateCommand(
+  args,
+  {
+    cwd,
+    env = process.env,
+    timeout = 600000,
+    log,
+    failureCode = "STEP_FAILED",
+    npmInstall = false,
+  } = {},
+) {
   return new Promise((resolve, reject) => {
     const fd = log ? openSync(log, "a", 0o600) : null;
-    const child = spawn(process.execPath, args, {
-      cwd,
-      env,
-      windowsHide: true,
-      stdio: fd === null ? "ignore" : ["ignore", fd, fd],
-    });
-    if (fd !== null) closeSync(fd);
-    let timedOut = false;
-    const timer = setTimeout(() => {
+    let timer,
+      child,
+      settled = false,
+      timedOut = false,
+      outputError,
+      tail = "";
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        if (fd !== null) closeSync(fd);
+      } catch (closeError) {
+        error ||= closeError;
+      }
+      if (error) reject(error);
+      else resolve();
+    };
+    try {
+      child = spawn(process.execPath, args, {
+        cwd,
+        env,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch (error) {
+      finish(error);
+      return;
+    }
+    const capture = (chunk) => {
+      if (settled) return;
+      tail = (tail + chunk.toString("utf8")).slice(-16384);
+      try {
+        if (fd !== null) writeSync(fd, chunk);
+      } catch (error) {
+        outputError = error;
+        // Wait for exit before rollback can rename a migration database.
+        child.kill("SIGKILL");
+      }
+    };
+    child.stdout.on("data", capture);
+    child.stderr.on("data", capture);
+    timer = setTimeout(() => {
       timedOut = true;
-      child.kill();
+      child.kill("SIGKILL");
     }, timeout);
-    child.once("error", (e) => {
-      clearTimeout(timer);
-      reject(e);
-    });
-    child.once("exit", (code) => {
-      clearTimeout(timer);
-      if (timedOut) reject(Error("更新步骤超时"));
-      else code === 0 ? resolve() : reject(Error("更新程序校验失败"));
+    child.once("error", finish);
+    child.once("close", (code) => {
+      if (outputError) finish(outputError);
+      else if (timedOut) finish(updateError("STEP_TIMEOUT"));
+      else if (code === 0) finish();
+      else finish(updateError(npmInstall ? npmFailureCode(tail) : failureCode));
     });
   });
 }
@@ -94,10 +152,11 @@ export function updateExecution(paths) {
   const pause = () => new Promise((r) => setTimeout(r, 250));
   return {
     async install(slot, version) {
+      requireUpdateNode();
       const cli = findNpmCli();
       const userconfig = join(updateRoot(paths.home), "install.npmrc");
       writeFileSync(userconfig, "", { mode: 0o600 });
-      await command(
+      await runUpdateCommand(
         [
           cli,
           "install",
@@ -112,20 +171,26 @@ export function updateExecution(paths) {
           "--engine-strict",
           `luckytri@${version}`,
         ],
-        { cwd: slot, env: installEnvironment(process.env), log: paths.log },
+        {
+          cwd: slot,
+          env: installEnvironment(process.env),
+          log: paths.log,
+          npmInstall: true,
+        },
       );
     },
     async check(root, version) {
       const script = `import fs from 'node:fs';import {createRequire} from 'node:module';const p=JSON.parse(fs.readFileSync(${JSON.stringify(join(root, "package.json"))},'utf8'));if(p.version!==${JSON.stringify(version)})process.exit(1);await import(${JSON.stringify(pathToFileURL(join(root, "server/app.js")).href)});const sharp=createRequire(${JSON.stringify(pathToFileURL(join(root, "package.json")).href)})('sharp');await sharp({create:{width:1,height:1,channels:3,background:'#fff'}}).png().toBuffer();`;
-      await command(["--input-type=module", "-e", script], {
+      await runUpdateCommand(["--input-type=module", "-e", script], {
         cwd: root,
         env: installEnvironment(process.env),
         timeout: 30000,
         log: paths.log,
+        failureCode: "PACKAGE_CHECK_FAILED",
       });
     },
     async migrate(root, database, { previous, version, databaseId }) {
-      await command(
+      await runUpdateCommand(
         [
           join(root, "scripts", "migrate-instance.js"),
           database,
@@ -138,6 +203,7 @@ export function updateExecution(paths) {
           env: installEnvironment(process.env),
           timeout: 3600000,
           log: paths.log,
+          failureCode: "MIGRATION_FAILED",
         },
       );
     },

package/server/app.js

@@ -1,3 +1,4 @@
+import { mountStickerUpload, mountStickers } from "./stickers/api.js";
 import express from "express";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
@@ -42,7 +43,11 @@ export function createApp({
     if (
       ["POST", "PATCH", "PUT"].includes(req.method) &&
       (!req.body || typeof req.body !== "object" || Array.isArray(req.body)) &&
-      !["/plugins/import/upload", "/storage/transfer/upload"].includes(req.path)
+      ![
+        "/plugins/import/upload",
+        "/storage/transfer/upload",
+        "/core/stickers/upload",
+      ].includes(req.path)
     )
       return res.status(400).json({ error: "请提交 JSON 对象" });
     next();
@@ -61,6 +66,7 @@ export function createApp({
   app.use("/api", objectBody);
   mountUpdates(app, updates, runtime.updater);
   mountDataTransfer(app, runtime.transfer);
+  if (chatSystem?.stickers) mountStickerUpload(app, chatSystem);
   if (plugins) {
     app.post(
       "/api/plugins/import/upload",
@@ -74,6 +80,7 @@ export function createApp({
       },
     );
   }
+  if (chatSystem?.stickers) mountStickers(app, chatSystem);
   mountStudio(app, store, runtime, chatSystem);
   mountManagement(app, store, chatSystem);
   mountCore(app, chatSystem);

package/server/channels/onebot/adapter.js

@@ -131,8 +131,32 @@ export const onebot = {
     const reply = /^\d+$/.test(String(options?.replyTo || ""))
       ? [{ type: "reply", data: { id: String(options.replyTo) } }]
       : [];
+    // A sticker goes as an image of its own, its bytes inline so the QQ client
+    // needs no path or URL on this machine.
+    const body = options?.image
+      ? [
+          {
+            type: "image",
+            data: {
+              file: `base64://${options.image.base64}`,
+              sub_type: options.image.sticker ? 1 : 0,
+              ...(options.image.summary
+                ? { summary: options.image.summary }
+                : {}),
+            },
+          },
+        ]
+      : [
+          ...(Array.isArray(options?.at) ? options.at : [])
+            .filter((id) => /^\d{5,12}$/.test(String(id)))
+            .flatMap((id) => [{ type: "at", data: { qq: String(id) } }]),
+          {
+            type: "text",
+            data: { text: options?.at?.length ? ` ${text}` : text },
+          },
+        ];
     return {
-      message: [...reply, { type: "text", data: { text } }],
+      message: [...reply, ...body],
       [parsed.kind === "group" ? "group_id" : "user_id"]:
         parsed.kind === "group"
           ? Number(message.raw?.group_id ?? parsed.nativeId)

package/server/channels/onebot/index.js

@@ -6,7 +6,8 @@ import { defineChannel } from "../contract.js";
 import { parseSessionKey } from "../session-key.js";
 import { applyDirectoryNames } from "../../core/sessions.js";
 import { saveAccountNames } from "../../studio/display-names.js";
-import { visionImageLimits } from "../../core/image-preprocessor.js";
+import { ownerImageLimits } from "../../core/image-preprocessor.js";
+import { mediaSettings } from "../../stickers/api.js";
 
 const EVENT_MAX_BYTES = 1024 * 1024;
 const IMAGE_TIMEOUT_MS = 30000;
@@ -168,7 +169,9 @@ export function createOneBotChannel(
     // Only authenticated OneBot clients reach this server. get_image may carry
     // base64 rather than a URL, so its frame must fit the source-image budget.
     // Ordinary events still have the smaller independent limit below.
-    const imageBytes = visionImageLimits().maxSourceBytes;
+    const imageBytes = ownerImageLimits(
+      chatSystem?.repo ? mediaSettings(chatSystem.repo) : {},
+    ).maxSourceBytes;
     wss = new WebSocketServer({
       noServer: true,
       maxPayload: Math.ceil(imageBytes / 3) * 4 + EVENT_MAX_BYTES,

package/server/core/dialogue-contract.js

@@ -20,7 +20,7 @@ export const DIALOGUE_TASK = `读懂眼前这轮聊天，再用自己的话回
 长短和口吻来自你自己：inner.ownVoice 是你自己一直以来打字的样子，inner.state 是此刻的心情和精力，再加上你和眼前这个人的关系、刚发生的事；别人怎么打字只是在场的情况，不去模仿。像在 QQ 里随手打一句，不写组织好的书面段落；答案不省，意思说够就停，不为活跃气氛加问题。问过的细节对方没接，就回应他继续说的内容，不立刻换词再问。如果这段对话里的人明确要求一段发完，同一话题后续都收进一条消息。列点也可以放在一条消息里换行。被明确要求停止就停止，新的实际问题仍可回应。
 若一轮里同时有人提出表达偏好、另一人分享新内容，先简短确认偏好，再回应新内容；不能让确认格式代替对内容的回应。
 停止的范围按对方原话理解：不要方案，就停止给方案；不要纠结某个细节，就放下那个细节，不把整个话题或交流关掉。对方明确说一条旁枝不是他问的，简短承认后回到主线；不要说“我没理清楚”或“先不乱说”，除非那条信息确实是回答主问题所必需的。
-输出 JSON：{"understanding":{"kind":"question|proposal|feeling|sharing|correction|greeting|closing|other","messageIds":[本轮回应的序号],"point":"对方此刻的具体意思","tone":"serious|joking|teasing|ironic|venting","stance":"fact|guess|opinion|joke|hearsay"},"contribution":{"kind":"answer|reaction|question|idea|correction|none","point":"自己这次实际说出的意思，不是收住/接住之类动作"},"choice":"speak|react|decline|silent","targetMessageIds":[batchIds中的序号],"topic":"当前话题","say":"实际说的话","appraisal":"这件事对自己的实际影响，没有则空","reason":"为何这样选择，用名字不用QQ号","feelings":[{"feeling":"两三个字","intensity":0到1,"valence":-1到1,"arousal":0到1,"cause":[消息序号]}],"bonds":[{"userId":"speaker","change":"warmer|closer|trust_up|trust_down|friction|repair|distance","why":"具体变化","evidence":[消息序号]}],"crisis":{"clear":false,"messageIds":[]}}。silent 时 say 为空；react 是一句很短的话；say 是你在输入框里打的字，换行就是按了发送、另起一条消息，说多少、发几次由你此刻想说什么决定；若对方已要求同一段发完，则把连贯补充收在一条消息里，列点也可在同一条里换行。真实自伤危机认真回应眼前安全，crisis.clear=true。understanding 里的 tone 和 stance 可选：所回应的话是认真、玩笑、调侃、反话还是发泄，说的是事实、猜测、观点、玩笑还是转述；拿不准就不写这两项。working.reading 只是字面提示，以前后文为准。choice、targetMessageIds 等其余字段仍在最外层。`;
+输出 JSON：{"understanding":{"kind":"question|proposal|feeling|sharing|correction|greeting|closing|other","messageIds":[本轮回应的序号],"point":"对方此刻的具体意思","tone":"serious|joking|teasing|ironic|venting","stance":"fact|guess|opinion|joke|hearsay"},"contribution":{"kind":"answer|reaction|question|idea|correction|none","point":"自己这次实际说出的意思，不是收住/接住之类动作"},"choice":"speak|react|decline|silent","targetMessageIds":[batchIds中的序号],"topic":"当前话题","say":"实际说的话","at":["可选，只从 expression.canAt 选 userId"],"sticker":"可选，expression.stickers 里的 ref","appraisal":"这件事对自己的实际影响，没有则空","reason":"为何这样选择，用名字不用QQ号","feelings":[{"feeling":"两三个字","intensity":0到1,"valence":-1到1,"arousal":0到1,"cause":[消息序号]}],"bonds":[{"userId":"speaker","change":"warmer|closer|trust_up|trust_down|friction|repair|distance","why":"具体变化","evidence":[消息序号]}],"crisis":{"clear":false,"messageIds":[]}}。silent 时 say 为空；react 是一句很短的话；say 是你在输入框里打的字，换行就是按了发送、另起一条消息，说多少、发几次由你此刻想说什么决定；若对方已要求同一段发完，则把连贯补充收在一条消息里，列点也可在同一条里换行。真实自伤危机认真回应眼前安全，crisis.clear=true。understanding 里的 tone 和 stance 可选：所回应的话是认真、玩笑、调侃、反话还是发泄，说的是事实、猜测、观点、玩笑还是转述；拿不准就不写这两项。working.reading 只是字面提示，以前后文为准。choice、targetMessageIds 等其余字段仍在最外层。`;
 
 export const DIALOGUE_REWRITE = `重新核对 exchange.current 和引用，修改 draft 中被指出的具体问题。decision.understanding 可能也有误，以原话为准。保留成立的内容，直接说这轮真正想说的话；不要把修改写成新的认错套话或内部状态报告。self.livingFor 只作背景，不必提起。输出 {"bubbles":["实际内容"],"reason":"为何这样说"}。`;
 

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 } : {}),
+  };
+}