koishi-plugin-satori-ai 1.3.8 → 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

@@ -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;
@@ -718,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)) {
@@ -759,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}`;
@@ -772,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;
       }
@@ -925,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)
@@ -1074,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();
   };
@@ -1145,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([
@@ -1188,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("记忆设置"),
@@ -1203,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("每个分句的最小长度"),
@@ -3058,6 +3083,7 @@ __name(wrapInHTML2, "wrapInHTML");
 
 // src/index.tsx
 var logger12 = new import_koishi13.Logger("satori-ai");
+var randomPrompt = "根据群聊内最近的包括所有人的聊天记录，锐评一下群聊中的话题";
 var puppeteer = null;
 function refreshPuppeteer(ctx) {
   if (ctx.puppeteer) {
@@ -3192,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));
@@ -3356,15 +3383,18 @@ var SAT = class extends Sat {
     const messages = await this.buildMessages(session, prompt);
     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)
@@ -3372,25 +3402,38 @@ var SAT = class extends Sat {
       else
         logger12.info(`Satori AI：${response.content}`);
     }
-    if (this.config.reasoner_filter && !response.error)
-      response = filterResponse(response.content, this.config.reasoner_filter_word.split("-"));
+    if (!response.error) {
+      response = filterResponse(response.content, this.config.reasoner_filter_word.split("-"), {
+        applyBracketFilter: this.config.reasoner_filter,
+        applyTagFilter: useNoReasoner || this.config.enhanceReasoningProtection
+      });
+    }
     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)
@@ -3401,20 +3444,34 @@ ${payload}`);
   // 构建系统提示
   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;
@@ -3442,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;
@@ -3559,6 +3624,18 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
     }], 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;
@@ -3587,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;

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.8",
+  "version": "1.3.9",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "types": "lib/index.d.ts",