koishi-plugin-satori-ai 1.3.7 → 1.3.9

package/lib/index.d.ts

@@ -35,7 +35,7 @@ export declare class SAT extends Sat {
         content: string;
         error: boolean;
     }>;
-    getChatResponse(user: User, messages: Sat.Msg[]): Promise<{
+    getChatResponse(user: User, messages: Sat.Msg[], prompt: string): Promise<{
         content: string;
         error: boolean;
     }>;
@@ -47,9 +47,10 @@ export declare class SAT extends Sat {
     getWarningList(session: Session): Promise<void>;
     private clearSession;
     private addCommonSense;
+    addGroupCommonSense(session: Session, content: string, groupId: string): Promise<string>;
     private handleUserLevel;
     private handleUserUsage;
-    handleRandomMiddleware(session: Session, prompt: string): Promise<string>;
+    handleRandomMiddleware(session: Session): Promise<string>;
     handleNickNameMiddleware(session: Session, prompt: string): Promise<string>;
     handleChannelMemoryManager(session: Session): Promise<void>;
 }

package/lib/index.js

@@ -46,8 +46,8 @@ __export(src_exports, {
   refreshPuppeteer: () => refreshPuppeteer
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi14 = require("koishi");
-var path7 = __toESM(require("path"));
+var import_koishi13 = require("koishi");
+var path6 = __toESM(require("path"));
 
 // src/api.ts
 var import_koishi2 = require("koishi");
@@ -258,25 +258,36 @@ function processPrompt(prompt) {
   return prompt.trim();
 }
 __name(processPrompt, "processPrompt");
-function filterResponse(prompt, words) {
-  const parts = prompt.split(/([（\[【《(][^）)]*[）\]】》)])/g);
-  const filtered = parts.map((part) => {
-    if (part.startsWith("（") && part.endsWith("）") || part.startsWith("(") && part.endsWith(")") || part.startsWith("[") && part.endsWith("]") || part.startsWith("【") && part.endsWith("】") || part.startsWith("《") && part.endsWith("》")) {
-      return words.some((word) => part.includes(word)) ? "" : part;
-    }
-    return part;
-  }).join("");
-  const cleaned = filtered.replace(/\s+/g, "");
-  const answerRegex = /<p>((?!<\/?p>)[\s\S])*?<\/p/g;
-  const answerRegex2 = /<doubaothinking>((?!<\/?doubaothinking>)[\s\S])*?<\/p/g;
+function filterResponse(prompt, words, options) {
+  const applyBracketFilter = options?.applyBracketFilter ?? true;
+  const applyTagFilter = options?.applyTagFilter ?? true;
+  let working = prompt;
+  if (applyBracketFilter) {
+    const parts = working.split(/([（\[【《(][^）)]*[）\]】》)])/g);
+    const filtered = parts.map((part) => {
+      if (part.startsWith("（") && part.endsWith("）") || part.startsWith("(") && part.endsWith(")") || part.startsWith("[") && part.endsWith("]") || part.startsWith("【") && part.endsWith("】") || part.startsWith("《") && part.endsWith("》")) {
+        return words.some((word) => part.includes(word)) ? "" : part;
+      }
+      return part;
+    }).join("");
+    working = filtered.replace(/\s+/g, "");
+    if (!working) {
+      working = prompt;
+    }
+  }
+  if (!applyTagFilter) {
+    return working ? { content: working, error: false } : { content: "有点问题，请重置对话", error: true };
+  }
+  const answerRegex = /<p>((?!<\/?p>)[\s\S])*?<\/p>/g;
+  const answerRegex2 = /<doubaothinking>((?!<\/?doubaothinking>)[\s\S])*?<\/p>/g;
   const answerRegex3 = /<doubaothinking>((?!<\/?doubaothinking>)[\s\S])*?<\/doubaothinking>/g;
   const answerRegex4 = /<answer>((?!<\/?answer>)[\s\S])*?<\/answer>/g;
   const answerRegex5 = /<doubaothinking>((?!<\/?doubaothinking>)[\s\S])*?<\/answer>/g;
-  const answerMatches = cleaned.match(answerRegex);
-  const answerMatches2 = cleaned.match(answerRegex2);
-  const answerMatches3 = cleaned.match(answerRegex3);
-  const answerMatches4 = cleaned.match(answerRegex4);
-  const answerMatches5 = cleaned.match(answerRegex5);
+  const answerMatches = working.match(answerRegex);
+  const answerMatches2 = working.match(answerRegex2);
+  const answerMatches3 = working.match(answerRegex3);
+  const answerMatches4 = working.match(answerRegex4);
+  const answerMatches5 = working.match(answerRegex5);
   const lastAnswer = answerMatches ? answerMatches[answerMatches.length - 1] : null;
   const lastDoubao = answerMatches2 ? answerMatches2[answerMatches2.length - 1] : null;
   const lastAnswer3 = answerMatches3 ? answerMatches3[answerMatches3.length - 1] : null;
@@ -347,6 +358,12 @@ function countCommonChars(str1, str2) {
     const count2 = chars2.get(char) || 0;
     commonCount += Math.min(count1, count2);
   }
+  const countDigits = /* @__PURE__ */ __name((s) => (s.match(/\d/g) || []).length, "countDigits");
+  const digits1 = countDigits(str1);
+  const digits2 = countDigits(str2);
+  if (digits1 >= 3 || digits2 >= 3) {
+    return Math.max(commonCount, 2);
+  }
   return commonCount;
 }
 __name(countCommonChars, "countCommonChars");
@@ -451,7 +468,7 @@ var APIClient = class {
         if (i == this.config.maxRetryTimes) {
           return this.handleAPIError(error);
         }
-        await new Promise((resolve3) => setTimeout(resolve3, this.config.retry_delay_time || 5e3));
+        await new Promise((resolve2) => setTimeout(resolve2, this.config.retry_delay_time || 5e3));
         logger2.warn(`生成画像时API请求失败(${error})，重试(第${i}次)中...`);
         continue;
       }
@@ -508,7 +525,7 @@ var APIClient = class {
         if (i == this.config.maxRetryTimes) {
           return this.handleAPIError(error);
         }
-        await new Promise((resolve3) => setTimeout(resolve3, this.config.retry_delay_time || 5e3));
+        await new Promise((resolve2) => setTimeout(resolve2, this.config.retry_delay_time || 5e3));
         logger2.warn(`API请求失败(${error})，重试(第${i}次)中...`);
         continue;
       }
@@ -582,7 +599,7 @@ var MemoryManager = class {
   }
   channelMemories = /* @__PURE__ */ new Map();
   channelDialogues = /* @__PURE__ */ new Map();
-  charactersToRemove = ["的", "一", "是", "了", "什", "么", "我", "谁", "不", "人", "在", "他", "有", "这", "个", "上", "们", "来", "到", "时", "大", "地", "为", "子", "中", "你", "说", "生", "国", "年", "着", "就", "那", "和", "要", "她", "出", "也", "得", "里", "后", "自", "以", "会", "id=", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"];
+  charactersToRemove = ["的", "一", "是", "了", "什", "么", "我", "谁", "不", "人", "在", "他", "有", "这", "个", "上", "们", "来", "到", "时", "大", "地", "为", "子", "中", "你", "说", "生", "国", "年", "着", "就", "那", "和", "要", "她", "出", "也", "得", "里", "后", "自", "以", "会", "id="];
   MAX_MEMORY_LENGTH = 5e3;
   // 更新记忆
   async updateMemories(session, prompt, config, response) {
@@ -617,7 +634,7 @@ var MemoryManager = class {
     if (!this.config.channel_dialogues)
       return "";
     const Dialogue = this.channelDialogues[session.channelId]?.join("\n") || "";
-    const result = "以下是群聊内群友最近的聊天记录，当用户话题涉及其中内容时你可以参考这些信息：{\n" + Dialogue + "\n}\n";
+    const result = "以下是群聊内最近的包括所有人的聊天记录，当当前对话涉及其中内容时你可以参考这些信息，但是要注意分辨发言人是谁：{\n" + Dialogue + "\n}\n";
     return result;
   }
   // 括号引号过滤
@@ -712,11 +729,14 @@ var MemoryManager = class {
   async searchMemories(session, prompt, type = "user") {
     const filePathMap = {
       "user": this.getUserMemoryPath(session.userId),
-      "common": path2.join(this.config.dataDir, "common_sense.txt")
+      "common": path2.join(this.config.dataDir, "common_sense.txt"),
+      "group": path2.join(this.config.dataDir, "group_sense", `${session.channelId}.txt`)
     };
     const topNMap = {
       "user": this.config.dailogues_topN,
-      "common": this.config.common_topN
+      "common": this.config.common_topN,
+      "group": this.config.common_topN
+      // 群常识和常识使用同样的topN
     };
     const filePath = filePathMap[type];
     if (!fs2.existsSync(filePath)) {
@@ -753,7 +773,8 @@ var MemoryManager = class {
   formatMatches(matched, type, topN = 5) {
     const prefixMap = {
       "common": "这是你可能用到的信息：",
-      "user": "以下是较久之前用户说过的话和对话时间："
+      "user": "以下是较久之前用户说过的话和对话时间：",
+      "group": "以下是本群聊你可能需要知道的信息："
     };
     const time = `时段：${getTimeOfDay((/* @__PURE__ */ new Date()).getHours())}`;
     const date = `当前日期和时间：${(/* @__PURE__ */ new Date()).toLocaleString()} ${time}`;
@@ -766,11 +787,17 @@ ${date}
 }
 `;
         return result;
-      } else {
+      } else if (type === "user") {
         matched.forEach((entry) => entry.content = entry.content + (entry.role === "user" ? "(未记录时间)" : entry.role));
         const result = `${prefixMap[type]}{
 ${matched.map((entry) => entry.content).join("\n")}
 }
+`;
+        return result;
+      } else if (type === "group") {
+        const result = `${prefixMap[type]}{
+${matched.map((entry) => entry.content).join("\n")}
+}
 `;
         return result;
       }
@@ -919,6 +946,8 @@ async function handleFavorabilitySystem(ctx, session, config) {
 }
 __name(handleFavorabilitySystem, "handleFavorabilitySystem");
 function getFavorabilityLevel(user, config) {
+  if (user.favorability >= config.favorability_div_3 && user?.items["镇定贴"]?.count > 0 && user?.items["镇定贴"]?.description && user?.items["镇定贴"]?.description == "on")
+    return "朋友";
   if (user?.items["订婚戒指"]?.count > 0 && user?.items["订婚戒指"]?.description && user?.items["订婚戒指"]?.description == "已使用")
     return "夫妻";
   if (user.favorability < config.favorability_div_1)
@@ -1068,7 +1097,7 @@ function createMiddleware(ctx, sat, config) {
       return await handleNickNameMessage(sat, session);
     }
     if (shouldRandomTrigger(session, config)) {
-      return await sat.handleRandomMiddleware(session, session.content);
+      return await sat.handleRandomMiddleware(session);
     }
     return next();
   };
@@ -1139,6 +1168,7 @@ var Sat = class extends import_koishi5.Service {
         import_koishi5.Schema.transform(String, (value) => [value])
       ]).default([]).role("secret").description("深度思考模型api_key"),
       appointModel: import_koishi5.Schema.string().default("deepseek-reasoner").description("深度思考模型"),
+      enhanceReasoningProtection: import_koishi5.Schema.boolean().default(true).description("是否增强思维链保护（开启后会强制输出内容带有限制标签，极大防止思维链溢出问题）"),
       not_reasoner_LLM_URL: import_koishi5.Schema.string().default("https://api.deepseek.com").description("非深度思考模型请求地址"),
       not_reasoner_LLM: import_koishi5.Schema.string().default("deepseek-chat").description("非深度思考模型(用于节省成本"),
       not_reasoner_LLM_key: import_koishi5.Schema.union([
@@ -1182,7 +1212,7 @@ var Sat = class extends import_koishi5.Service {
       dataDir: import_koishi5.Schema.string().default("./data/satori_ai").description("聊天记录保存位置（长期记忆）"),
       memory_block_words: import_koishi5.Schema.array(String).default(["好感"]).description("记忆屏蔽词"),
       remember_min_length: import_koishi5.Schema.number().description("触发保存到记忆的长度").default(20),
-      common_topN: import_koishi5.Schema.number().default(5).description("常识记忆检索最大匹配数"),
+      common_topN: import_koishi5.Schema.number().default(5).description("群常识、常识记忆检索最大匹配数"),
       dailogues_topN: import_koishi5.Schema.number().default(5).description("对话记忆检索最大匹配数"),
       enable_fixed_dialogues: import_koishi5.Schema.boolean().default(false).description("是否启用固定对话（在dataDir中的fixed_dialogues.json修改）")
     }).description("记忆设置"),
@@ -1197,6 +1227,7 @@ var Sat = class extends import_koishi5.Service {
       duplicateDialogueCheck: import_koishi5.Schema.boolean().default(true).description("是否检查重复对话"),
       enable_online_user_check: import_koishi5.Schema.boolean().default(true).description("在未回答而再次提问时是否提示用户有未完成的对话"),
       random_min_tokens: import_koishi5.Schema.number().default(20).description("随机触发对话的最小长度"),
+      enable_random_without_favorability: import_koishi5.Schema.boolean().default(true).description("是否启用随机触发对话无视高好感度（即使用户好感度很高也会最多视为朋友）"),
       randnum: import_koishi5.Schema.number().role("slider").min(0).max(1).step(0.01).default(0).description("在群聊中随机触发对话的概率，如需关闭可设置为 0"),
       sentences_divide: import_koishi5.Schema.boolean().default(true).description("是否分句发送"),
       min_sentences_length: import_koishi5.Schema.number().default(10).description("每个分句的最小长度"),
@@ -1255,9 +1286,6 @@ var Sat = class extends import_koishi5.Service {
     import_koishi5.Schema.object({
       enable_game: import_koishi5.Schema.boolean().default(false).description("是否开启游戏模块"),
       game_block_channel: import_koishi5.Schema.array(String).description("不提供游戏的频道id"),
-      enable_gobang: import_koishi5.Schema.boolean().default(false).description("是否开启五子棋游戏（需要puppeteer支持）"),
-      channel_id_for_gobang: import_koishi5.Schema.array(String).description("启用五子棋的游戏频道id（不建议太多，第一个会被公示）"),
-      cd_for_gobang: import_koishi5.Schema.number().default(3600).description("每人五子棋游戏cd时间（秒）"),
       enable_OneTouch: import_koishi5.Schema.boolean().default(false).description("是否开启一碰一游戏（需要puppeteer支持）"),
       cd_for_OneTouch: import_koishi5.Schema.number().default(600).description("每人一碰一游戏cd时间（秒）"),
       enable_fencing: import_koishi5.Schema.boolean().default(false).description("是否开启击剑游戏(无效，开发中)")
@@ -1309,7 +1337,7 @@ var UserPortraitManager = class {
     });
     fs5.writeFileSync(memoryPath, JSON.stringify(replacedContent, null, 2));
     const validEntries = replacedContent.filter((entry) => entry.role !== "user").map((entry) => {
-      const timeMatch = entry.role.match(/对话日期和时间：(\d{4}\/\d{1,2}\/\d{1,2} \d{2}:\d{2}:\d{2})/);
+      const timeMatch = entry.role.match(/对话日期和时间：(\d{1,2}\/\d{1,2}\/\d{4}), (\d{1,2}:\d{2}:\d{2} [AP]M)/);
       if (!timeMatch)
         return null;
       return {
@@ -1323,11 +1351,11 @@ var UserPortraitManager = class {
     return validEntries.slice(0, maxEntries).map((entry) => `${entry.content}${entry.role}`);
   }
   // 生成提示词模板
-  buildMessage(level, history, existingPortrait, user) {
+  buildFirstMessage(level, history, user) {
     return [{
       role: "user",
-      content: `你是一个角色扮演智能体工作流中的一环，请根据以下信息更新用户画像。需包括：
-1. 基本信息（性别、年龄、生日等，不要遗漏或改动已有的信息）
+      content: `你是一个角色扮演智能体工作流中的一环，请根据以下信息生成户画像。可选内容包括：
+1. 基本信息（性别、年龄、生日等）
 2. 生活习惯（作息等）
 3. 反感点（如有）
 4. 对AI的期望（从对话历史中推断）
@@ -1335,21 +1363,47 @@ var UserPortraitManager = class {
 
 用户名：${user.usersname}
 你与用户的关系：${level}
-历史画像：
-${existingPortrait ? "无" : existingPortrait}
-
 近期的用户发言记录：
 ${history}
 
 注意事项：
+·没有涉及到的信息注为无
 ·用户一定是人类，其他情况是角色扮演
-·根据发言修正历史画像内容，但是历史画像中与发言无关的部分必须保留
 ·尤其注意用户说“记住”的部分，可能是用户希望记录的信息
 ·因为在角色扮演中，用户可能会说出不符合事实的信息，需要根据事实推断，避免盲目相信或主观臆测
 ·使用尽可能简洁的表达
 ·保留不确定性的表述（如"可能"、"似乎"、"用户自称"）
 ·保持中立和客观，避免带有个人情感色彩的描述，不要添加评价或建议
 ·仅给出画像内容，不要添加额外的描述、建议、评价、注解等任何内容
+·不使用markdown等标记语言，直接书写即可`
+    }];
+  }
+  buildSecondMessage(level, NewPortrait, existingPortrait, user) {
+    return [{
+      role: "user",
+      content: `你是一个角色扮演智能体工作流中的一环，请根据以下信息合并用户画像。内容包括：
+1. 基本信息（性别、年龄、生日等，不要遗漏或改动已有的信息）
+2. 生活习惯（作息等）
+3. 反感点（如有）
+4. 对AI的期望（从对话历史中推断）
+5. 用户希望记住的信息（如有）
+
+用户名：${user.usersname}
+你与用户的关系：${level}
+已有画像：
+${existingPortrait ? "无" : existingPortrait}
+
+新补充信息：
+${NewPortrait}
+
+注意事项：
+·用户一定是人类，其他情况是角色扮演
+·根据已有画像，补充新信息，避免重复，并且不要遗漏你认为重要信息
+·你认为不太重要的信息可以删除
+·使用尽可能简洁的表达
+·保留不确定性的表述（如"可能"、"似乎"、"用户自称"）
+·保持中立和客观，避免带有个人情感色彩的描述，不要添加评价或建议
+·仅给出画像内容，不要添加额外的描述、建议、评价、注解等任何内容
 ·不使用markdown等标记语言，直接书写即可`
     }];
   }
@@ -1364,10 +1418,12 @@ ${history}
     const dialogues = await this.getDialogues(user);
     const existing = this.readPortrait(user.userid);
     const userlevel = getFavorabilityLevel(user, this.getFavorabilityConfig());
-    const messages = this.buildMessage(userlevel, dialogues.join("\n"), existing, user);
     logger5.info(`用户 ${user.userid} 画像生成中...`);
     try {
-      const response = await apiClient.generateUserPortrait(user, messages);
+      const FirstMessages = this.buildFirstMessage(userlevel, dialogues.join("\n"), user);
+      const NewPortrait = await apiClient.generateUserPortrait(user, FirstMessages);
+      const SecondMessages = this.buildSecondMessage(userlevel, NewPortrait.content, existing, user);
+      const response = await apiClient.generateUserPortrait(user, SecondMessages);
       if (response && !response.error) {
         this.savePortrait(user, response.content);
         if (user.usage > this.config.portrait_usage - 1)
@@ -1647,9 +1703,9 @@ ${this.config.mood_prompt_2}
 };
 
 // src/game.ts
-var import_koishi12 = require("koishi");
+var import_koishi11 = require("koishi");
 
-// src/gamegobang.ts
+// src/gamefencing.ts
 var import_koishi9 = require("koishi");
 
 // src/abstractGame.ts
@@ -1753,270 +1809,8 @@ var abstractGame = class {
   }
 };
 
-// src/gamegobang.ts
-var import_child_process = require("child_process");
-var path6 = __toESM(require("path"));
-var logger8 = new import_koishi9.Logger("satori-game-gobang");
-var BOARD_SIZE = 14;
-var inspireSearchLength = 10;
-var Coordinate = class {
-  static {
-    __name(this, "Coordinate");
-  }
-  x;
-  y;
-  score;
-  constructor(a = 0, b = 0, s = 0) {
-    this.x = a;
-    this.y = b;
-    this.score = s;
-  }
-};
-async function wrapInHTML(str) {
-  if (!puppeteer) {
-    logger8.warn("puppeteer未就绪");
-    return "出现错误，请联系管理员";
-  }
-  return puppeteer.render(`<html><body>${str.replaceAll(/\n/g, "<BR>")}</body>
-          <style>
-          body {
-            padding: 10px;
-            display: inline-block;
-           }
-          </style>
-          </html>`);
-}
-__name(wrapInHTML, "wrapInHTML");
-var goBangSingleGame = class extends abstractGameSingleGame {
-  static {
-    __name(this, "goBangSingleGame");
-  }
-  playerFlag;
-  // 玩家棋子颜色（1: 黑棋，2: 白棋）
-  winningFlag = 4 /* pending */;
-  // 当前胜负状态
-  level;
-  // AI 难度等级
-  board = [];
-  // BOARD_SIZExBOARD_SIZE 棋盘状态
-  lastScore = 0;
-  // 上次评分
-  turnsCount = 0;
-  // 回合数
-  constructor(disposeListener, session) {
-    super(disposeListener, session);
-  }
-  // 初始化棋盘，随机决定玩家先手
-  startGame = () => {
-    super.startGame();
-    this.board = Array.from({ length: BOARD_SIZE }, () => Array(BOARD_SIZE).fill(0));
-    this.turnsCount = 0;
-    this.playerFlag = Math.round(Math.random()) + 1;
-    const getCornerCoordinate = /* @__PURE__ */ __name((i) => {
-      const quarter = i < 0.5 ? 0.2 : 0.7;
-      const base = Math.round(BOARD_SIZE * quarter);
-      return base;
-    }, "getCornerCoordinate");
-    for (let i = 0; i <= 1; i++) {
-      for (let j = 0; j <= 1; j++) {
-        const randomX = getCornerCoordinate(i) + 1 - 2 * i;
-        const randomY = getCornerCoordinate(j);
-        const player = Math.round(Math.random()) + 1;
-        this.board[randomX][randomY] = player;
-        this.board[randomX + i * 2 - 1][randomY - j * 2 + 1] = 3 - player;
-      }
-    }
-    if (this.playerFlag === 1) {
-      this.board[BOARD_SIZE / 2][BOARD_SIZE / 2] = 1;
-      this.board[BOARD_SIZE / 2 + (Math.round(Math.random()) ? -1 : 1)][BOARD_SIZE / 2 + (Math.round(Math.random()) ? -1 : 1)] = 2;
-      return wrapInHTML("游戏开始，你随机到了先手(黑)\n输入两个数字以下棋，先行后列，例如：“0 13”\n" + this.printBoard());
-    } else {
-      this.board[BOARD_SIZE / 2][BOARD_SIZE / 2] = 1;
-      this.board[BOARD_SIZE / 2 + (Math.round(Math.random()) ? -1 : 1)][BOARD_SIZE / 2 + (Math.round(Math.random()) ? -1 : 1)] = 2;
-      this.board[BOARD_SIZE / 2][BOARD_SIZE / 2 + (Math.round(Math.random()) ? -1 : 1)] = 1;
-      return wrapInHTML("游戏开始，你随机到了后手(白)\n输入两个数字以下棋，先行后列，例如：“0 13”\n" + this.printBoard());
-    }
-  };
-  // 结束游戏，返回结果
-  endGame = async () => {
-    super.endGame();
-    let bonusLevel = this.level;
-    if (this.winningFlag === 1 /* win */ && this.playerFlag === 1) {
-      bonusLevel -= 1;
-    } else if (this.winningFlag === 2 /* lose */ && this.playerFlag === 1) {
-      bonusLevel += 1;
-    }
-    return { message: `${bonusLevel}`, win: this.winningFlag, gameName: "五子棋", playerID: this.session.userId };
-  };
-  /**
-   * 处理玩家输入（落子坐标）
-   * @param str 输入内容，格式为 "x y"
-   */
-  async processInput(str) {
-    const [x, y] = str.split(" ").map((a) => {
-      return parseInt(a);
-    });
-    if (isNaN(x) || isNaN(y))
-      return;
-    if (x < 0 || x >= BOARD_SIZE || y < 0 || y >= BOARD_SIZE)
-      return "坐标超出范围了";
-    if (this.board[x][y] !== 0)
-      return "这个位置已经有棋子了，别想耍赖";
-    if (this.winningFlag !== 4 /* pending */)
-      return "游戏已结束";
-    this.lastActionTime = Date.now();
-    this.board[x][y] = this.playerFlag;
-    logger8.info(`level: ${this.level}, player: x: ${x}, y: ${y}`);
-    if (this.checkWin(x, y))
-      return wrapInHTML(this.printBoard() + "\n游戏已结束，发送结束游戏退出");
-    const starttime = Date.now();
-    const aiMove = this.getAIMove();
-    const endtime = Date.now();
-    if (aiMove.x === -1 || aiMove.y === -1) {
-      this.winningFlag = 3 /* draw */;
-      return "计算失败，视为平局，发送结束游戏退出";
-    }
-    if (this.turnsCount > 50) {
-      this.winningFlag = 3 /* draw */;
-      return "平局，发送结束游戏退出";
-    }
-    logger8.info(`AI 落子坐标: ${aiMove.x} ${aiMove.y}，得分: ${aiMove.score}，AI 落子耗时: ${endtime - starttime}ms`);
-    this.board[aiMove.x][aiMove.y] = 3 - this.playerFlag;
-    if (this.turnsCount > 5) {
-      setTimeout(() => {
-        this.session.send(this.generateChat(aiMove.score));
-      }, 1e3);
-    }
-    this.lastScore = aiMove.score;
-    this.turnsCount++;
-    if (this.checkWin(aiMove.x, aiMove.y))
-      return wrapInHTML(this.printBoard() + "\n游戏已结束，发送结束游戏退出");
-    return wrapInHTML(this.printBoard() + "\n我这一步下在这里哦(" + aiMove.x + " " + aiMove.y + " 用时" + (endtime - starttime) + "ms)");
-  }
-  getAIMove() {
-    try {
-      const boardStr = this.board.map((row) => row.join(" ")).join(" ");
-      const exePath = path6.resolve(__dirname, "../lib/gobang_ai.exe");
-      const level = this.turnsCount > 3 ? this.level : Math.min(5, this.level);
-      const stdout = (0, import_child_process.execSync)(
-        `"${exePath}" "${boardStr}" ${this.playerFlag} ${level} ${inspireSearchLength}`,
-        { timeout: 18e5 }
-        // 设置1800秒超时
-      ).toString().trim();
-      const [x, y, score] = stdout.split(" ").map(Number);
-      return new Coordinate(x, y, score);
-    } catch (error) {
-      logger8.error(`AI计算失败: ${error}`);
-    }
-    return new Coordinate(-1, -1, -1);
-  }
-  // 检查是否连成五子
-  checkWin(x, y) {
-    const directions = [[1, 0], [0, 1], [1, 1], [1, -1]];
-    for (const [dx, dy] of directions) {
-      let count = 1;
-      for (let i = 1; i < 5; i++) {
-        if (this.checkDirection(x, y, dx, dy, i))
-          count++;
-        else
-          break;
-      }
-      for (let i = 1; i < 5; i++) {
-        if (this.checkDirection(x, y, -dx, -dy, i))
-          count++;
-        else
-          break;
-      }
-      if (count >= 5) {
-        this.winningFlag = this.board[x][y] === this.playerFlag ? 1 /* win */ : 2 /* lose */;
-        return true;
-      }
-    }
-    return false;
-  }
-  // 辅助方法：检查指定方向是否有连续棋子
-  checkDirection(x, y, dx, dy, step) {
-    const nx = x + dx * step, ny = y + dy * step;
-    return nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && this.board[nx][ny] === this.board[x][y];
-  }
-  // 生成带表情符号的棋盘字符串
-  printBoard() {
-    const numberEmojis = ["0️⃣", "1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣", "6️⃣", "7️⃣", "8️⃣", "9️⃣", "🔟", "🔢", "🔢", "🔢", "🔢"];
-    let res = "🟨" + numberEmojis.slice(0, BOARD_SIZE).join("") + "🟨\n";
-    for (let i = 0; i < BOARD_SIZE; i++) {
-      res += numberEmojis[i];
-      for (let j = 0; j < BOARD_SIZE; j++) {
-        res += this.board[i][j] === 0 ? "🟨" : this.board[i][j] === 1 ? "⚫" : "⚪";
-      }
-      res += numberEmojis[i];
-      res += "\n";
-    }
-    res += "🟨" + numberEmojis.slice(0, BOARD_SIZE).join("") + "🟨\n";
-    return res;
-  }
-  generateChat(Score) {
-    if (this.lastScore < 5e6 && Score > 5e6 && this.level > 3) {
-      return "我觉得你要输了哦~";
-    }
-    if (this.lastScore < 1e6 && Score > 1e6) {
-      return "只能下在这里了~";
-    }
-    if (4e3 <= Score && Score < 1e4) {
-      return "这招怎么样？";
-    }
-    if (2e3 <= Score && Score < 4e3 && Math.random() < 0.5) {
-      return {
-        0: "有点意思哦~",
-        1: "真是焦灼的局面",
-        2: "势均力敌呢~",
-        3: "你在想什么呢？",
-        4: "走这里会不会太冒险了？"
-      }[Math.floor(Math.random() * 5)];
-    }
-    if (Score < -1e6) {
-      return "好猛烈的攻击啊~";
-    }
-    if (Score < 0 && Math.random() < 0.5) {
-      return "你还真是厉害呢~";
-    }
-    if (Score < 100) {
-      return "出乎意料的一手啊";
-    }
-  }
-};
-var goBang = class extends abstractGame {
-  static {
-    __name(this, "goBang");
-  }
-  constructor() {
-    super(goBangSingleGame);
-  }
-  // 启动游戏时可传入难度参数
-  async startGame(session, ctx, args) {
-    let level;
-    if (!isNaN(parseInt(args[0])))
-      level = parseInt(args[0]);
-    else {
-      setTimeout(() => {
-        session.send("未输入难度等级(2-6)，默认设为3");
-      }, 500);
-      level = 3;
-    }
-    if (level < 2 || level > 6) {
-      level = level < 2 ? 2 : 6;
-      setTimeout(() => {
-        session.send("难度等级必须在2到6之间,已调整为" + level);
-      }, 500);
-    }
-    const game = await super.startGame(session, ctx, args);
-    game.level = level;
-    return game;
-  }
-};
-
 // src/gamefencing.ts
-var import_koishi10 = require("koishi");
-var logger9 = new import_koishi10.Logger("satori-game-fencing");
+var logger8 = new import_koishi9.Logger("satori-game-fencing");
 var fencingSingleGame = class _fencingSingleGame extends abstractGameSingleGame {
   static {
     __name(this, "fencingSingleGame");
@@ -2198,8 +1992,8 @@ var fencing = class extends abstractGame {
 };
 
 // src/gameOneTouch.ts
-var import_koishi11 = require("koishi");
-var logger10 = new import_koishi11.Logger("satori-game-onetouch");
+var import_koishi10 = require("koishi");
+var logger9 = new import_koishi10.Logger("satori-game-onetouch");
 var SKILL_MAP = {
   // 基础技能
   "-1": {},
@@ -2290,7 +2084,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       hp: this.baseHP,
       status: 0 /* Normal */
     };
-    return await wrapInHTML2(`游戏开始！
+    return await wrapInHTML(`游戏开始！
 对方的手势：左${this.ai.left} 右${this.ai.right}
 你的手势：左${this.player.left} 右${this.player.right}
 输入格式"左 右"选择要触碰的手
@@ -2340,9 +2134,9 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   }
   async processInput(input) {
     if (input === "游戏规则")
-      return await wrapInHTML2(this.instuction);
+      return await wrapInHTML(this.instuction);
     if (input === "技能列表")
-      return await wrapInHTML2(this.skillList);
+      return await wrapInHTML(this.skillList);
     if (this.turnCount === 0)
       this.initState(this.level);
     this.turnCount++;
@@ -2383,7 +2177,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       statusIcon(this.player.vulnerablility, "💔"),
       this.player.status === 1 /* Stunned */ ? "💫 眩晕" : ""
     ].filter(Boolean).join(" | ");
-    return wrapInHTML2(`▶️你的行动：${result}
+    return wrapInHTML(`▶️你的行动：${result}
 
 ▶️我的行动：${aiResult}
 
@@ -2768,7 +2562,7 @@ ${bonusMessage}` : "");
         bestMove = move;
       }
     }
-    logger10.info(`AI选择的动作：${bestMove[0]}碰${bestMove[1]}, 分数：${bestScore}`);
+    logger9.info(`AI选择的动作：${bestMove[0]}碰${bestMove[1]}, 分数：${bestScore}`);
     if (this.turnCount > 5)
       this.session.sendQueued(this.generateChat(bestScore), 1e3);
     this.lastScore = bestScore;
@@ -2994,9 +2788,9 @@ var OneTouchGame = class extends abstractGame {
     return game;
   }
 };
-async function wrapInHTML2(str) {
+async function wrapInHTML(str) {
   if (!puppeteer) {
-    logger10.warn("puppeteer未就绪");
+    logger9.warn("puppeteer未就绪");
     return "出现错误，请联系管理员";
   }
   return puppeteer.render(`<html><body>${str.replaceAll(/\n/g, "<BR>")}</body>
@@ -3008,15 +2802,15 @@ async function wrapInHTML2(str) {
           </style>
           </html>`);
 }
-__name(wrapInHTML2, "wrapInHTML");
+__name(wrapInHTML, "wrapInHTML");
 
 // src/game.ts
-var logger11 = new import_koishi12.Logger("satori-game");
+var logger10 = new import_koishi11.Logger("satori-game");
 var Game = class {
   static {
     __name(this, "Game");
   }
-  GAMES = ["五子棋", "击剑", "一碰一"];
+  GAMES = ["一碰一"];
   // 支持的游戏列表
   channelGames = /* @__PURE__ */ new Map();
   // 频道ID到游戏名称的映射
@@ -3030,9 +2824,6 @@ var Game = class {
     this.context = ctx;
     this.config = cfg;
     this.sat = sat;
-    if (this.config.enable_gobang) {
-      this.availableGames.set("五子棋", new goBang());
-    }
     if (this.config.enable_fencing) {
       this.availableGames.set("击剑", new fencing());
     }
@@ -3051,8 +2842,6 @@ var Game = class {
   }
   // 启动指定游戏
   async startGame(session, gameName, args) {
-    if (this.config.game_block_channel.includes(session.channelId))
-      return "本群不支持游戏哦" + (this.config.channel_id_for_gobang[0] ? ",想玩请加群" + this.config.channel_id_for_gobang[0] : "");
     if (this.channelGames.get(session.channelId))
       return "当前频道已经有游戏在进行中";
     if (gameName == "")
@@ -3062,9 +2851,6 @@ var Game = class {
     const game = this.availableGames.get(gameName);
     if (!game)
       return "没有这个游戏哦";
-    if (gameName === "五子棋" && !this.config.channel_id_for_gobang.includes(session.channelId)) {
-      return "本群不支持五子棋哦,想玩请加群" + this.config.channel_id_for_gobang[0];
-    }
     const user = await ensureUserExists(this.context, session.userId, session.username);
     const lastUsage = this.userUsage.get(`${session.userId}-${gameName}`);
     if (lastUsage && user.userlevel < 4) {
@@ -3079,7 +2865,7 @@ var Game = class {
     refreshPuppeteer(this.context);
     game.startGame(session, this.context, args);
     this.channelGames.set(session.channelId, gameName);
-    logger11.info(`游戏${gameName}已开始于${session.channelId}`);
+    logger10.info(`游戏${gameName}已开始于${session.channelId}`);
   }
   // 结束当前游戏
   async endGame(session) {
@@ -3088,7 +2874,7 @@ var Game = class {
       return "当前频道没有游戏在进行中";
     if (await this.availableGames.get(gameName).endGame(session, this.context)) {
       this.channelGames.delete(session.channelId);
-      logger11.info(`${session.channelId}的游戏已结束`);
+      logger10.info(`${session.channelId}的游戏已结束`);
     }
   }
   async chat(session, gameName, prompt) {
@@ -3101,8 +2887,6 @@ var Game = class {
   }
   getGameCd(gameName) {
     switch (gameName) {
-      case "五子棋":
-        return this.config.cd_for_gobang;
       case "一碰一":
         return this.config.cd_for_OneTouch;
       default:
@@ -3114,7 +2898,7 @@ var Game = class {
     this.GAMES.forEach((game) => {
       list += game + "\n";
     });
-    logger11.info(list);
+    logger10.info(list);
     return list;
   }
   async resultJudge(result, ctx, session) {
@@ -3160,8 +2944,8 @@ var Game = class {
 };
 
 // src/broadcast.ts
-var import_koishi13 = require("koishi");
-var logger12 = new import_koishi13.Logger("satori-ai-broadcast");
+var import_koishi12 = require("koishi");
+var logger11 = new import_koishi12.Logger("satori-ai-broadcast");
 var BroadcastManager = class {
   static {
     __name(this, "BroadcastManager");
@@ -3191,16 +2975,16 @@ var BroadcastManager = class {
     const id = `broadcast-${this.idCounter++}`;
     const broadcast = new broadcastMessage(this.ctx, this.config, message, img);
     this.broadcastMessages.set(id, broadcast);
-    logger12.info(`广播已创建 ID: ${id}`);
+    logger11.info(`广播已创建 ID: ${id}`);
     return `广播已创建 ID: ${id}`;
   }
   async deleteBroadcast(id) {
     if (this.broadcastMessages.has(id)) {
       this.broadcastMessages.delete(id);
-      logger12.info(`广播已删除 ID: ${id}`);
+      logger11.info(`广播已删除 ID: ${id}`);
       return "已删除广播：" + id;
     } else {
-      logger12.warn(`未找到广播 ID: ${id}`);
+      logger11.warn(`未找到广播 ID: ${id}`);
       return "未找到该广播";
     }
   }
@@ -3208,7 +2992,7 @@ var BroadcastManager = class {
     for (const [id, broadcast] of this.broadcastMessages.entries()) {
       if (broadcast.setTime.getTime() + 1e3 * 60 * this.config.waiting_time < Date.now()) {
         this.broadcastMessages.delete(id);
-        logger12.info(`广播已过期 ID: ${id}`);
+        logger11.info(`广播已过期 ID: ${id}`);
         continue;
       }
       await broadcast.sendMessage(session);
@@ -3236,7 +3020,7 @@ ${alreadySentChannels}
       }
     }
     const result = list.length > 0 ? list.join("\n") : null;
-    return result ? wrapInHTML3(result) : null;
+    return result ? wrapInHTML2(result) : null;
   }
 };
 var broadcastMessage = class {
@@ -3267,13 +3051,13 @@ var broadcastMessage = class {
     try {
       this.alreadySentChannels.add(channelId);
       if (this.img) {
-        session.send(await wrapInHTML3(this.message));
+        session.send(await wrapInHTML2(this.message));
       } else {
         session.send(this.message);
       }
-      logger12.info(`向群 ${channelId} 广播: ${this.message}`);
+      logger11.info(`向群 ${channelId} 广播: ${this.message}`);
     } catch (error) {
-      logger12.error(`广播失败 ${channelId}: ${error}`);
+      logger11.error(`广播失败 ${channelId}: ${error}`);
     }
   }
   getAlreadySentChannels() {
@@ -3281,9 +3065,9 @@ var broadcastMessage = class {
     return alreadySentChannels.length > 0 ? alreadySentChannels.join("\n") : "无";
   }
 };
-async function wrapInHTML3(str) {
+async function wrapInHTML2(str) {
   if (!puppeteer) {
-    logger12.warn("puppeteer未就绪");
+    logger11.warn("puppeteer未就绪");
     return str;
   }
   return puppeteer.render(`<html><body>${str.replaceAll(/\n/g, "<BR>")}</body>
@@ -3295,16 +3079,17 @@ async function wrapInHTML3(str) {
           </style>
           </html>`);
 }
-__name(wrapInHTML3, "wrapInHTML");
+__name(wrapInHTML2, "wrapInHTML");
 
 // src/index.tsx
-var logger13 = new import_koishi14.Logger("satori-ai");
+var logger12 = new import_koishi13.Logger("satori-ai");
+var randomPrompt = "根据群聊内最近的包括所有人的聊天记录，锐评一下群聊中的话题";
 var puppeteer = null;
 function refreshPuppeteer(ctx) {
   if (ctx.puppeteer) {
     puppeteer = ctx.puppeteer;
   } else {
-    logger13.warn("puppeteer未就绪");
+    logger12.warn("puppeteer未就绪");
   }
 }
 __name(refreshPuppeteer, "refreshPuppeteer");
@@ -3433,7 +3218,8 @@ var SAT = class extends Sat {
   registerCommands(ctx) {
     ctx.command("sat <text:text>", { authority: this.config.authority }).alias(...this.config.alias).action(async ({ session }, prompt) => this.handleSatCommand(session, prompt));
     ctx.command("sat.clear", "清空会话").option("global", "-g").action(({ session, options }) => this.clearSession(session, options.global));
-    ctx.command("sat.common_sense <text:text>", "添加常识").action(async ({ session }, prompt) => this.addCommonSense(session, prompt));
+    ctx.command("sat.common_sense <text:text>", "添加常识", { authority: 4 }).alias("添加常识").action(async ({ session }, prompt) => this.addCommonSense(session, prompt));
+    ctx.command("sat.group_sense <text:text>", "添加群常识", { authority: 3 }).alias("添加群常识").option("id", "-i <id:string>", { authority: 3 }).action(async ({ session, options }, prompt) => this.addGroupCommonSense(session, prompt, options.id));
     ctx.command("sat.update_user_level", "更新用户等级", { authority: 2 }).alias("更新用户").option("id", "-i <id:string>", { authority: 4 }).option("level", "-l <level:number>", { authority: 4 }).action(async ({ session, options }) => this.handleUserLevel(session, options));
     ctx.command("sat.user_usage", "查看用户使用次数").alias("查询次数").action(async ({ session }) => this.handleUserUsage(session));
     ctx.command("sat.add_output_censor <text:text>", "添加输出敏感词", { authority: 4 }).alias("添加输出屏蔽词").action(async ({ session }, word) => addOutputCensor(session, word, this.config.dataDir));
@@ -3492,9 +3278,9 @@ var SAT = class extends Sat {
       const messages = generateAuxiliaryPrompt(prompt, response.content, user, this.getFavorabilityConfig());
       const result = await this.apiClient.auxiliaryChat(messages);
       if (result.error) {
-        logger13.error(`辅助判断失败：${result.content}`);
+        logger12.error(`辅助判断失败：${result.content}`);
       } else {
-        logger13.info(`辅助判断：${result.content}`);
+        logger12.info(`辅助判断：${result.content}`);
         return handleAuxiliaryResult(this.ctx, session, this.getFavorabilityConfig(), result.content);
       }
     }
@@ -3581,81 +3367,111 @@ var SAT = class extends Sat {
       await inputContentCheck(this.ctx, censored, session.userId, this.getFavorabilityConfig(), session, this.moodManager);
     }
     if (this.config.log_ask_response)
-      logger13.info(`用户 ${session.username}：${processedPrompt}`);
+      logger12.info(`用户 ${session.username}：${processedPrompt}`);
     return censored;
   }
   // 生成回复
   async generateResponse(session, prompt) {
     if (this.getChannelParallelCount(session) > this.config.max_parallel_count) {
-      logger13.info(`频道 ${session.channelId} 并发数过高(${this.getChannelParallelCount(session)})，${session.username}等待中...`);
+      logger12.info(`频道 ${session.channelId} 并发数过高(${this.getChannelParallelCount(session)})，${session.username}等待中...`);
     }
     while (this.getChannelParallelCount(session) > this.config.max_parallel_count) {
       this.updateChannelParallelCount(session, -1);
-      await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
       this.updateChannelParallelCount(session, 1);
     }
     const messages = await this.buildMessages(session, prompt);
-    logger13.info(`频道 ${session.channelId} 处理：${session.userId},剩余${this.getChannelParallelCount(session)}并发`);
+    logger12.info(`频道 ${session.channelId} 处理：${session.userId},剩余${this.getChannelParallelCount(session)}并发`);
     const user = await getUser(this.ctx, session.userId);
-    let response = await this.getChatResponse(user, messages);
+    let response = await this.getChatResponse(user, messages, prompt);
     if (response.error)
-      response = await this.getChatResponse(user, messages);
+      response = await this.getChatResponse(user, messages, prompt);
     if (response.error)
       updateUserUsage(this.ctx, user, -1);
     return response;
   }
   // 获取聊天回复
-  async getChatResponse(user, messages) {
+  async getChatResponse(user, messages, prompt) {
+    const hasTicket = user?.items?.["地灵殿通行证"]?.description && user.items["地灵殿通行证"].description === "on";
+    const maxLength = hasTicket ? user?.items?.["地灵殿通行证"]?.metadata?.use_not_reasoner_LLM_length : this.config.use_not_reasoner_LLM_length;
+    const useNoReasoner = prompt.length <= maxLength && this.config.enable_reasoner_like;
     let response = await this.apiClient.chat(user, messages);
     if (this.config.log_ask_response) {
       if (this.config.enable_favorability && this.config.enable_mood)
-        logger13.info(`Satori AI：（心情值：${this.moodManager.getMoodValue(user.userid)}）${response.content}`);
+        logger12.info(`Satori AI：（心情值：${this.moodManager.getMoodValue(user.userid)}）${response.content}`);
       else
-        logger13.info(`Satori AI：${response.content}`);
+        logger12.info(`Satori AI：${response.content}`);
+    }
+    if (!response.error) {
+      response = filterResponse(response.content, this.config.reasoner_filter_word.split("-"), {
+        applyBracketFilter: this.config.reasoner_filter,
+        applyTagFilter: useNoReasoner || this.config.enhanceReasoningProtection
+      });
     }
-    if (this.config.reasoner_filter && !response.error)
-      response = filterResponse(response.content, this.config.reasoner_filter_word.split("-"));
     return response;
   }
   // 构建消息
   async buildMessages(session, prompt) {
     const messages = [];
-    const example = `<think>
+    const user = await ensureUserExists(this.ctx, session.userId, session.username);
+    const hasTicket = user?.items?.["地灵殿通行证"]?.description && user.items["地灵殿通行证"].description === "on";
+    const maxLength = hasTicket ? user?.items?.["地灵殿通行证"]?.metadata?.use_not_reasoner_LLM_length : this.config.use_not_reasoner_LLM_length;
+    const useNoReasoner = prompt.length <= maxLength && this.config.enable_reasoner_like;
+    const exampleWithoutReasoner = `<think>
 好的，我会尽量做到的
 </think>
 <p>已明确对话要求</p>`;
+    const exampleWithTag = `<p>已明确对话要求</p>`;
+    const exampleWithoutTag = `已明确对话要求`;
+    const example = useNoReasoner ? exampleWithoutReasoner : this.config.enhanceReasoningProtection ? exampleWithTag : exampleWithoutTag;
     if (this.config.no_system_prompt) {
       messages.push({ role: "user", content: await this.buildSystemPrompt(session, prompt) });
       messages.push({ role: "assistant", content: example });
     } else {
       messages.push({ role: "system", content: await this.buildSystemPrompt(session, prompt) });
     }
-    const userMemory = this.memoryManager.getChannelContext(this.config.personal_memory ? session.userId : session.channelId);
-    messages.push(...userMemory);
+    if (prompt != randomPrompt) {
+      const userMemory = this.memoryManager.getChannelContext(this.config.personal_memory ? session.userId : session.channelId);
+      messages.push(...userMemory);
+    }
     messages.push({ role: "user", content: prompt });
     let payload = messages.map((msg) => msg.role + ":" + msg.content).join("\n");
     if (this.config.log_system_prompt)
-      logger13.info(`系统提示：
+      logger12.info(`系统提示：
 ${payload}`);
     return messages;
   }
   // 构建系统提示
   async buildSystemPrompt(session, prompt) {
     const commonSense = await this.memoryManager.searchMemories(session, prompt, "common");
+    const groupSense = await this.memoryManager.searchMemories(session, prompt, "group");
     const channelDialogue = await this.memoryManager.getChannelDialogue(session);
     const userMemory = await this.memoryManager.searchMemories(session, prompt);
     const user = await getUser(this.ctx, session.userId);
     const moodLevel = this.moodManager.getMoodLevel(user.userid);
     let systemPrompt = "";
+    if (prompt == randomPrompt) {
+      systemPrompt += "#首先明确一些参考信息\n";
+      systemPrompt += "\n##" + channelDialogue;
+      systemPrompt += this.getThinkingPrompt(user, prompt);
+      systemPrompt += this.config.prompt;
+      if (this.config.enhanceReasoningProtection) {
+        systemPrompt += `
+#注意：你最终的回复内容必须使用“<p>”开头，使用“</p>”结尾
+`;
+        if (this.config.no_system_prompt)
+          systemPrompt += "\n#如果你明白以上内容，请回复“<p>已明确对话要求</p>”";
+      }
+      return systemPrompt;
+    }
     systemPrompt += "#首先明确一些参考信息\n";
     systemPrompt += "\n##" + commonSense;
+    systemPrompt += "\n##" + groupSense;
     systemPrompt += "\n##" + channelDialogue;
     systemPrompt += "\n##" + userMemory;
     if (moodLevel == "normal" || moodLevel == "happy")
       systemPrompt += "\n##" + this.portraitManager.getUserPortrait(session);
-    systemPrompt += "\n#参考信息到此为止，接下来是思考要求\n";
     systemPrompt += this.getThinkingPrompt(user, prompt);
-    systemPrompt += "\n#接下来是对话要求，以下要求仅对最终的回复内容生效，不限制思考过程\n";
     systemPrompt += this.config.prompt;
     if (user?.items?.["觉的衣柜"]?.count && (moodLevel == "normal" || moodLevel == "happy")) {
       const clothes = user?.items?.["觉的衣柜"]?.metadata?.clothes;
@@ -3683,23 +3499,31 @@ ${payload}`);
     if (nickName)
       systemPrompt += `, 昵称是：${nickName},称呼用户时请优先使用昵称
 `;
-    systemPrompt += `
+    if (this.config.enhanceReasoningProtection) {
+      systemPrompt += `
 #注意：你最终的回复内容必须使用“<p>”开头，使用“</p>”结尾
 `;
-    if (this.config.no_system_prompt)
-      systemPrompt += "\n#如果你明白以上内容，请回复“<p>已明确对话要求</p>”";
+      if (this.config.no_system_prompt)
+        systemPrompt += "\n#如果你明白以上内容，请回复“<p>已明确对话要求</p>”";
+    }
     return systemPrompt;
   }
   // 思考提示
   getThinkingPrompt(user, prompt) {
     const reasonerPrompt = this.config.reasoner_prompt;
-    const promptForNoReasoner = `#请你在回复时先进行分析思考，并且模仿思维链的模式输出思考内容，${reasonerPrompt};
+    const promptForNoReasoner = `
+#参考信息到此为止，接下来是思考要求
+#请你在回复时先进行分析思考，并且模仿思维链的模式输出思考内容，${reasonerPrompt};
 #你在思考时必须以 "<think>" 开头, "</think>" 结尾。仔细揣摩用户意图，**完整输出思考内容后**再输出正式的回复内容;
-#注意：你的正式回复内容必须使用“<p>”开头，使用“</p>”结尾，并且无论如何都要把标签输出完整
-`;
-    const promptForReasoner = `#你在思考时必须以 "嗯" 开头。仔细揣摩用户意图，思考结束后返回符合要求的回复。
-#注意：你的回复内容必须使用“<p>”开头，使用“</p>”结尾
+#注意：你的正式回复内容必须使用“<p>”开头，在输出全部回复后使用“</p>”结尾（即输出且仅输出一对标签），并且无论如何都要把标签输出完整
+#接下来是对话要求，以下要求仅对最终的回复内容生效，不限制思考过程
 `;
+    const promptForReasoner = this.config.enhanceReasoningProtection ? `
+#参考信息到此为止，接下来是思考要求
+#你在思考时必须以 "嗯" 开头。仔细揣摩用户意图，思考结束后返回符合要求的回复。
+#注意：你的回复内容必须使用“<p>”开头，在输出全部回复后使用“</p>”结尾（即输出且仅输出一对标签）
+#接下来是对话要求，以下要求仅对最终的回复内容生效，不限制思考过程
+` : "";
     const hasTicket = user?.items?.["地灵殿通行证"]?.description && user.items["地灵殿通行证"].description === "on";
     const maxLength = hasTicket ? user?.items?.["地灵殿通行证"]?.metadata?.use_not_reasoner_LLM_length : this.config.use_not_reasoner_LLM_length;
     const useNoReasoner = prompt.length <= maxLength;
@@ -3740,10 +3564,10 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
       response = `@${session.username} ` + response;
     }
     if (this.config.sentences_divide && response.length > 10) {
-      const sentences = splitSentences(response, this.config.min_sentences_length, this.config.max_sentences_length).map((text) => import_koishi14.h.text(text));
+      const sentences = splitSentences(response, this.config.min_sentences_length, this.config.max_sentences_length).map((text) => import_koishi13.h.text(text));
       for (const sentence of sentences) {
         await session.send(sentence);
-        await new Promise((resolve3) => setTimeout(resolve3, this.config.time_interval));
+        await new Promise((resolve2) => setTimeout(resolve2, this.config.time_interval));
       }
       return null;
     }
@@ -3753,7 +3577,7 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
     if (!this.config.enable_warning)
       return;
     if (auxiliaryResult.includes("好感↓")) {
-      logger13.info(`在群${session.channelId}中，${session.username}骚扰我！`);
+      logger12.info(`在群${session.channelId}中，${session.username}骚扰我！`);
       this.usersToWarn.set(session.channelId, session.username);
     }
   }
@@ -3793,13 +3617,25 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
   async addCommonSense(session, content) {
     if (!content)
       return session.text("commands.sat.common_sense.messages.no-prompt");
-    const filePath = path7.join(this.config.dataDir, "common_sense.txt");
+    const filePath = path6.join(this.config.dataDir, "common_sense.txt");
     await this.memoryManager.saveLongTermMemory(session, [{
       role: "user",
       content: content.replace(/\"/g, "'").trim()
     }], filePath);
     return session.text("commands.sat.common_sense.messages.succeed", [content]);
   }
+  // 添加群常识
+  async addGroupCommonSense(session, content, groupId) {
+    if (!content)
+      return session.text("commands.sat.common_sense.messages.no-prompt");
+    const id = groupId || session.channelId;
+    const filePath = path6.join(this.config.dataDir, `group_sense`, `${id}.txt`);
+    await this.memoryManager.saveLongTermMemory(session, [{
+      role: "user",
+      content: content.replace(/\"/g, "'").trim()
+    }], filePath);
+    return session.text("commands.sat.common_sense.messages.succeed", [`群${id}中：` + content]);
+  }
   // 更新用户等级
   async handleUserLevel(session, options) {
     const userId = options.id || session.userId;
@@ -3828,21 +3664,10 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
     return result;
   }
   // 随机中间件转接
-  async handleRandomMiddleware(session, prompt) {
-    const user = await getUser(this.ctx, session.userId);
-    const processedPrompt = processPrompt(session.content);
-    if (this.performPreChecks(session, processedPrompt))
-      return null;
-    if (await this.checkUserDialogueCount(session, user, 0))
-      return null;
-    if (await this.checkFavorabilityBlock(session))
-      return null;
-    let censored = processedPrompt;
-    if (this.ctx.censor)
-      censored = await this.ctx.censor.transform(processedPrompt, session);
-    if (censored.includes("**"))
-      return null;
-    return this.handleSatCommand(session, prompt);
+  async handleRandomMiddleware(session) {
+    await this.updateChannelParallelCount(session, 1);
+    const response = await this.generateResponse(session, randomPrompt);
+    return await this.formatResponse(session, response.content, null);
   }
   // 昵称中间件转接
   async handleNickNameMiddleware(session, prompt) {

package/lib/memory.d.ts

@@ -23,7 +23,7 @@ export declare class MemoryManager {
     clearAllMemories(): void;
     getChannelMemory(channelId: string): MemoryEntry[];
     saveLongTermMemory(session: Session, dialogues: MemoryEntry[], filePath?: string): Promise<void>;
-    searchMemories(session: Session, prompt: string, type?: 'user' | 'common'): Promise<string>;
+    searchMemories(session: Session, prompt: string, type?: 'user' | 'common' | 'group'): Promise<string>;
     private findBestMatches;
     private calculateMatchScore;
     private formatMatches;

package/lib/types.d.ts

@@ -148,6 +148,7 @@ export declare namespace Sat {
         baseURL: string;
         key: string[];
         appointModel: string;
+        enhanceReasoningProtection: boolean;
         not_reasoner_LLM_URL: string;
         not_reasoner_LLM: string;
         not_reasoner_LLM_key: string[];
@@ -191,6 +192,7 @@ export declare namespace Sat {
         duplicateDialogueCheck: boolean;
         enable_online_user_check: boolean;
         random_min_tokens: number;
+        enable_random_without_favorability: boolean;
         randnum: number;
         sentences_divide: boolean;
         min_sentences_length: number;
@@ -244,9 +246,6 @@ export declare namespace Sat {
         waiting_time: number;
         enable_game: boolean;
         game_block_channel: string[];
-        enable_gobang: boolean;
-        channel_id_for_gobang: string[];
-        cd_for_gobang: number;
         enable_fencing: boolean;
         enable_OneTouch: boolean;
         cd_for_OneTouch: number;

package/lib/userportrait.d.ts

@@ -9,7 +9,8 @@ export declare class UserPortraitManager {
     hasPortrait(userId: string): boolean;
     readPortrait(userId: string): string;
     private getDialogues;
-    private buildMessage;
+    private buildFirstMessage;
+    private buildSecondMessage;
     generatePortrait(session: Session, user: User, apiClient: APIClient): Promise<void>;
     private savePortrait;
     private ensurePortraitFile;

package/lib/utils.d.ts

@@ -23,7 +23,10 @@ export declare function processPrompt(prompt: string): string;
  * @param words 需要过滤的关键词
  * @returns 处理后的字符串，删除含有关键词的部分
  */
-export declare function filterResponse(prompt: string, words: string[]): {
+export declare function filterResponse(prompt: string, words: string[], options?: {
+    applyBracketFilter?: boolean;
+    applyTagFilter?: boolean;
+}): {
     content: string;
     error: boolean;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-satori-ai",
   "description": "基于 Satori 适配器的智能对话插件，具备用户画像、长期记忆、常识管理和好感度系统",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "types": "lib/index.d.ts",