koishi-plugin-dify-ai 0.1.5 → 0.1.7

package/lib/api/client.d.ts

@@ -18,7 +18,6 @@ export declare class DifyClient {
     /** blocking JSON 请求（本插件只用 blocking 模式） */
     private request;
     getAppInfo(): Promise<DifyAppInfo>;
-    getParameters(): Promise<any>;
     /** chat / agent-chat / advanced-chat（conversation_id 传空串表示新建会话） */
     runChat(body: {
         inputs: Record<string, any>;

package/lib/config.d.ts

@@ -120,8 +120,9 @@ export declare function resolveUploadConfig(config: Config): {
     maxMb: number;
 };
 /**
- * 引用触发消息配置（含 0.1.x 布尔开关迁移）：schema 形态缺失时
- * 旧 quoteTrigger 若被配置层透传保留则迁移，否则按总是引用处理。
+ * 引用触发消息配置（含 0.1.x 布尔开关迁移）：schema 会给旧配置填默认 quote 对象，
+ * 因此迁移判据是「旧布尔被配置层透传保留 且 quote 仍是默认形态（用户未在新表单改过）」——
+ * 此时以旧布尔为准；用户改过新表单（quote 非默认）则新值优先。
  */
 export declare function resolveQuoteConfig(config: Config): {
     enabled: boolean;

package/lib/history.d.ts

@@ -11,8 +11,12 @@ export interface HistoryEntry {
     userId: string;
     username: string;
     messageId?: string;
-    /** 纯文本 + 图片占位符 */
+    /** 原貌（含 @bot 渲染与图片占位）：统一格式行（query/历史变量）用 */
     content: string;
+    /** 剔除 @bot 的原貌：content 变量与精简行用 */
+    contentText: string;
+    /** 图片元素 URL（按元素序，与 content 中 [image:摘要] 序一致）：窗口类触发的上传依据 */
+    imageUrls?: string[];
     timestamp: number;
     quote?: QuotedMessage;
 }
@@ -24,6 +28,8 @@ export interface HistoryEntry {
 export declare function formatHistoryEntry(entry: HistoryEntry): string;
 /** 多条消息逐行拼接 */
 export declare function formatHistoryEntries(entries: HistoryEntry[]): string;
+/** 精简行：只记消息 ID 与剔除 @bot 的原貌内容，不带时间与作者前缀——窗口触发的 content 变量用 */
+export declare function formatHistoryBrief(entries: HistoryEntry[]): string;
 /** 从会话消息构造记录条目（历史缓冲 / 消息池共用）；assistant 行标注为机器人自己的发言 */
 export declare function buildHistoryEntry(session: Session, role?: 'user' | 'assistant'): HistoryEntry | null;
 /**

package/lib/index.js

@@ -165,7 +165,8 @@ var uploadSchema = import_koishi.Schema.union([
     mode: import_koishi.Schema.const("on").required(),
     maxCount: import_koishi.Schema.natural().default(0).description("数量上限，0 不限"),
     maxSizeMb: import_koishi.Schema.natural().default(0).description("单文件大小上限 MB，0 不限")
-  }).default({ mode: "on", maxCount: 0, maxSizeMb: 0 }).description("开启")
+  }).default({ mode: "on", maxCount: 0, maxSizeMb: 0 }).description("开启"),
+  import_koishi.Schema.boolean().description("旧版开关")
 ]);
 var Config = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
@@ -316,14 +317,14 @@ function toVariable(entry) {
   }
   if (entry.source === "meta") {
     if (entry.key === "none") return null;
-    return { field, source: { type: "meta", key: entry.key || "triggerType" } };
+    return { field, source: { type: "meta", key: entry.key } };
   }
   if (entry.source === "history") {
     const limit = Number(entry.limit);
     return { field, source: { type: "history", ...limit > 0 ? { limit } : {} } };
   }
   if (entry.key === "none" || entry.key === "history") return null;
-  return { field, source: { type: "session", key: entry.key || "content" } };
+  return { field, source: { type: "session", key: entry.key } };
 }
 __name(toVariable, "toVariable");
 function resolveUploadConfig(config) {
@@ -333,34 +334,29 @@ function resolveUploadConfig(config) {
   if (config.uploadFiles?.mode === "off") return { enabled: false, maxCount: 0, maxMb: 0 };
   return {
     enabled: true,
-    maxCount: Math.max(0, Number(config.uploadFiles?.maxCount) || 0),
-    maxMb: Math.max(0, Number(config.uploadFiles?.maxSizeMb) || 0)
+    maxCount: Number(config.uploadFiles?.maxCount) || 0,
+    maxMb: Number(config.uploadFiles?.maxSizeMb) || 0
   };
 }
 __name(resolveUploadConfig, "resolveUploadConfig");
 function resolveQuoteConfig(config) {
-  if (config.quote?.mode === "off") return { enabled: false, minElapsedSeconds: 0 };
-  if (config.quote?.mode === "on") {
-    return { enabled: true, minElapsedSeconds: Math.max(0, Number(config.quote.minElapsedSeconds) || 0) };
+  const quote = config.quote;
+  const isDefaultQuote = !quote || quote.mode === "on" && !(Number(quote.minElapsedSeconds) > 0);
+  if (typeof config.quoteTrigger === "boolean" && isDefaultQuote) {
+    return { enabled: config.quoteTrigger, minElapsedSeconds: 0 };
   }
-  if (config.quoteTrigger === false) return { enabled: false, minElapsedSeconds: 0 };
-  return { enabled: true, minElapsedSeconds: 0 };
+  if (quote?.mode === "off") return { enabled: false, minElapsedSeconds: 0 };
+  return { enabled: true, minElapsedSeconds: Number(quote?.minElapsedSeconds) || 0 };
 }
 __name(resolveQuoteConfig, "resolveQuoteConfig");
 function toCooldown(entry) {
   if (entry?.mode === "fixed") {
-    const seconds = Number(entry.seconds);
-    return seconds > 0 ? { mode: "fixed", ms: seconds * 1e3 } : null;
+    return { mode: "fixed", ms: Number(entry.seconds) * 1e3 };
   }
   if (entry?.mode === "sliding") {
     const minSeconds = Number(entry.minSeconds);
     const maxSeconds = Number(entry.maxSeconds);
-    if (!(minSeconds > 0) || !(maxSeconds > 0)) return null;
-    return {
-      mode: "sliding",
-      minMs: minSeconds * 1e3,
-      maxMs: Math.max(minSeconds, maxSeconds) * 1e3
-    };
+    return { mode: "sliding", minMs: minSeconds * 1e3, maxMs: Math.max(minSeconds, maxSeconds) * 1e3 };
   }
   return null;
 }
@@ -371,12 +367,16 @@ function normalizeConfig(config) {
     if (app.name?.trim() && !apps.has(app.name)) apps.set(app.name, app);
   }
   const rules = [];
+  const seenNames = /* @__PURE__ */ new Set();
   for (const entry of config.rules ?? []) {
     if (!entry.name?.trim() || entry.enabled === false) continue;
+    const name2 = entry.name.trim();
+    if (seenNames.has(name2)) continue;
+    seenNames.add(name2);
     const conditions = (entry.conditions ?? []).filter((condition) => condition != null).map(toCondition).filter((condition) => condition != null);
     const variables = (entry.variables ?? []).filter((variable) => variable != null).map(toVariable).filter((variable) => variable != null);
     rules.push({
-      name: entry.name.trim(),
+      name: name2,
       enabled: true,
       priority: Number(entry.priority) || 0,
       app: entry.app?.trim() ?? "",
@@ -449,9 +449,6 @@ var DifyClient = class {
   getAppInfo() {
     return this.request("GET", "/info");
   }
-  getParameters() {
-    return this.request("GET", "/parameters");
-  }
   /** chat / agent-chat / advanced-chat（conversation_id 传空串表示新建会话） */
   runChat(body) {
     return this.request("POST", "/chat-messages", body);
@@ -500,6 +497,7 @@ __name(createDifyClient, "createDifyClient");
 // src/utils/session-text.ts
 var import_crypto = require("crypto");
 var import_koishi2 = require("koishi");
+var IMAGE_HASH_LENGTH = 8;
 function parseTextSafe(content) {
   if (!content) return "";
   try {
@@ -509,10 +507,9 @@ function parseTextSafe(content) {
   }
 }
 __name(parseTextSafe, "parseTextSafe");
-function extractText(session, options = {}) {
+function extractText(session) {
   if (session.elements?.length) {
-    const elements = options.excludeAt ? session.elements.filter((element) => element.type !== "at") : session.elements;
-    return import_koishi2.h.select(elements, "text").join("").trim();
+    return import_koishi2.h.select(session.elements, "text").join("").trim();
   }
   return parseTextSafe(session.content);
 }
@@ -520,7 +517,7 @@ __name(extractText, "extractText");
 var IMAGE_PLACEHOLDER = "[图片]";
 function imagePlaceholder(url) {
   if (!url) return IMAGE_PLACEHOLDER;
-  return `[image:${(0, import_crypto.createHash)("sha1").update(url).digest("hex").slice(0, 8)}]`;
+  return `[image:${(0, import_crypto.createHash)("sha1").update(url).digest("hex").slice(0, IMAGE_HASH_LENGTH)}]`;
 }
 __name(imagePlaceholder, "imagePlaceholder");
 function annotateDroppedPlaceholders(text, droppedUrls) {
@@ -532,19 +529,25 @@ function annotateDroppedPlaceholders(text, droppedUrls) {
   return result;
 }
 __name(annotateDroppedPlaceholders, "annotateDroppedPlaceholders");
-function extractTextWithPlaceholders(session) {
-  const elements = session.elements?.length ? session.elements : (() => {
-    try {
-      return import_koishi2.h.parse(session.content ?? "");
-    } catch {
-      return [];
-    }
-  })();
+function elementsOf(session) {
+  if (session.elements?.length) return session.elements;
+  try {
+    return import_koishi2.h.parse(session.content ?? "");
+  } catch {
+    return [];
+  }
+}
+__name(elementsOf, "elementsOf");
+function extractTextWithPlaceholders(session, options = {}) {
   const parts = [];
-  for (const element of elements) {
+  for (const element of elementsOf(session)) {
     if (element.type === "text") {
       const text = element.attrs?.["content"] ?? "";
       if (text) parts.push(text);
+    } else if (element.type === "at") {
+      if (options.excludeBotAt && element.attrs?.["id"] === session.selfId) continue;
+      const name2 = element.attrs?.["name"] ?? element.attrs?.["id"];
+      if (name2) parts.push(`@${name2}`);
     } else if (element.type === "img" || element.type === "image") {
       parts.push(imagePlaceholder(element.attrs?.["url"] ?? element.attrs?.["src"]));
     }
@@ -552,6 +555,16 @@ function extractTextWithPlaceholders(session) {
   return parts.join(" ").replace(/\s+/g, " ").trim();
 }
 __name(extractTextWithPlaceholders, "extractTextWithPlaceholders");
+function extractImageUrls(session) {
+  const urls = [];
+  for (const element of elementsOf(session)) {
+    if (element.type !== "img" && element.type !== "image") continue;
+    const source = element.attrs?.["url"] ?? element.attrs?.["src"];
+    if (typeof source === "string" && source) urls.push(source);
+  }
+  return urls;
+}
+__name(extractImageUrls, "extractImageUrls");
 
 // src/history.ts
 var HISTORY_CAPACITY_MULTIPLIER = 2;
@@ -572,6 +585,10 @@ function formatHistoryEntries(entries) {
   return entries.map(formatHistoryEntry).join("\n");
 }
 __name(formatHistoryEntries, "formatHistoryEntries");
+function formatHistoryBrief(entries) {
+  return entries.map((entry) => entry.messageId ? `[msg:${entry.messageId}] ${entry.contentText}` : entry.contentText).join("\n");
+}
+__name(formatHistoryBrief, "formatHistoryBrief");
 function buildQuote(session) {
   const quote = session.quote;
   if (!quote?.user?.id) return void 0;
@@ -586,12 +603,15 @@ __name(buildQuote, "buildQuote");
 function buildHistoryEntry(session, role = "user") {
   const content = extractTextWithPlaceholders(session);
   if (!content) return null;
+  const imageUrls = extractImageUrls(session);
   return {
     role,
     userId: role === "assistant" ? session.selfId : session.userId ?? "未知用户",
-    username: role === "assistant" ? "你自己的发言" : session.username || session.userId || "用户",
+    username: role === "assistant" ? "你自己的发言" : session.username || session.userId,
     messageId: session.messageId,
     content,
+    contentText: extractTextWithPlaceholders(session, { excludeBotAt: true }),
+    ...imageUrls.length ? { imageUrls } : {},
     timestamp: session.timestamp ?? Date.now(),
     quote: role === "user" ? buildQuote(session) : void 0
   };
@@ -629,40 +649,49 @@ function hasAt(session, id) {
   return session.elements?.some((element) => element.type === "at" && element.attrs?.["id"] === id) ?? false;
 }
 __name(hasAt, "hasAt");
+var NON_TEXT_PREFIX = new RegExp(`^(?:@\\S+|\\[image:[0-9a-f]{${IMAGE_HASH_LENGTH}}\\]|\\[图片\\]|\\s)*`);
+function stripPrefixKeyword(verbatim, keyword) {
+  const prefix = NON_TEXT_PREFIX.exec(verbatim)?.[0] ?? "";
+  const rest = verbatim.slice(prefix.length);
+  if (!rest.startsWith(keyword)) return null;
+  return (prefix + rest.slice(keyword.length)).trim();
+}
+__name(stripPrefixKeyword, "stripPrefixKeyword");
 function evaluateCondition(condition, session) {
   const text = extractText(session);
+  const verbatim = extractTextWithPlaceholders(session, { excludeBotAt: true });
   switch (condition.type) {
     case "keyword-prefix": {
       const keyword = condition.keywords.find((k) => k && text.startsWith(k));
       if (!keyword) return null;
-      const rest = text.slice(keyword.length).trim();
-      return { type: "keyword-prefix", queryText: rest || text };
+      const rest = verbatim.startsWith(keyword) ? verbatim.slice(keyword.length).trim() : stripPrefixKeyword(verbatim, keyword) ?? text.slice(keyword.length).trim();
+      return { type: "keyword-prefix", contentText: rest || verbatim };
     }
     case "keyword-contains": {
       const keyword = condition.keywords.find((k) => k && text.includes(k));
       if (!keyword) return null;
-      return { type: "keyword-contains", queryText: text };
+      return { type: "keyword-contains", contentText: verbatim };
     }
     case "at-bot": {
       const botId = session.bot?.userId;
       if (!botId) return null;
       if (!session.stripped?.atSelf && !hasAt(session, botId)) return null;
-      return { type: "at-bot", queryText: extractText(session, { excludeAt: true }) };
+      return { type: "at-bot", contentText: verbatim };
     }
     case "at-user": {
       const isAtAnyUser = condition.userIds.some((id) => hasAt(session, id));
       if (!isAtAnyUser) return null;
-      return { type: "at-user", queryText: text };
+      return { type: "at-user", contentText: verbatim };
     }
     case "quote-bot": {
       const botId = session.bot?.userId;
       if (!botId || session.quote?.user?.id !== botId) return null;
-      return { type: "quote-bot", queryText: extractText(session, { excludeAt: true }) };
+      return { type: "quote-bot", contentText: verbatim };
     }
     case "quote-user": {
       const author = session.quote?.user?.id;
       if (!author || !condition.userIds.includes(author)) return null;
-      return { type: "quote-user", queryText: extractText(session, { excludeAt: true }) };
+      return { type: "quote-user", contentText: verbatim };
     }
     default:
       return null;
@@ -801,13 +830,7 @@ var RuleScheduler = class {
   }
   entries = [];
   sync(rules) {
-    const previous = new Map(this.entries.map((entry) => [entry.rule.name, entry.nextRunAt]));
-    const nextEntries = [];
-    for (const rule of rules) {
-      const nextRunAt = previous.get(rule.name) ?? this.computeNextRun(rule);
-      if (nextRunAt != null) nextEntries.push({ rule, nextRunAt });
-    }
-    this.entries = nextEntries;
+    this.entries = rules.map((rule) => ({ rule, nextRunAt: this.computeNextRun(rule) })).filter((entry) => entry.nextRunAt != null);
   }
   tick() {
     const now = Date.now();
@@ -857,8 +880,9 @@ var RuleScheduler = class {
 
 // src/trigger/cooldown.ts
 var BUFFER_CAPACITY = 1024;
+var DENSITY_LANE_PREFIX = "density:";
 function densityLane(index) {
-  return `density:${index}`;
+  return `${DENSITY_LANE_PREFIX}${index}`;
 }
 __name(densityLane, "densityLane");
 function laneKeyOf(ruleName, lane) {
@@ -889,30 +913,33 @@ var TriggerCooldown = class {
     });
   }
   isCooling(channelKey, ruleName, lane, now) {
-    const state = this.lanesOf(channelKey).get(laneKeyOf(ruleName, lane));
+    const state = this.channels.get(channelKey)?.get(laneKeyOf(ruleName, lane));
     return state != null && now < state.deadline;
   }
-  /** 滑动窗口顺延：截止时间顺延到「now + 最小窗口」，不超过「触发时刻 + 最大窗口」 */
-  extend(channelKey, ruleName, lane, now) {
-    if (this.setting?.mode !== "sliding") return;
-    const state = this.lanesOf(channelKey).get(laneKeyOf(ruleName, lane));
-    if (!state) return;
+  /** 滑动窗口顺延：截止推到「now + 最小窗口」，不超过「触发时刻 + 最大窗口」 */
+  slide(state, setting, now) {
     state.deadline = Math.min(
-      Math.max(state.deadline, now + this.setting.minMs),
-      state.fireAt + this.setting.maxMs
+      Math.max(state.deadline, now + setting.minMs),
+      state.fireAt + setting.maxMs
     );
   }
-  /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动） */
+  /** 滑动窗口顺延：已到期的通道不复活 */
+  extend(channelKey, ruleName, lane, now) {
+    const setting = this.setting;
+    if (setting?.mode !== "sliding") return;
+    const state = this.channels.get(channelKey)?.get(laneKeyOf(ruleName, lane));
+    if (!state || now >= state.deadline) return;
+    this.slide(state, setting, now);
+  }
+  /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动）；已到期的不复活 */
   extendDensityLanes(channelKey, now) {
-    if (this.setting?.mode !== "sliding") return;
+    const setting = this.setting;
+    if (setting?.mode !== "sliding") return;
     const lanes = this.channels.get(channelKey);
     if (!lanes) return;
     for (const [key, state] of lanes) {
-      if (!key.includes("\ndensity:")) continue;
-      state.deadline = Math.min(
-        Math.max(state.deadline, now + this.setting.minMs),
-        state.fireAt + this.setting.maxMs
-      );
+      if (!key.includes("\ndensity:") || now >= state.deadline) continue;
+      this.slide(state, setting, now);
     }
   }
   /** 冷却期内缓存一条命中消息（仅消息通道） */
@@ -924,22 +951,24 @@ var TriggerCooldown = class {
       state.buffer.splice(0, state.buffer.length - BUFFER_CAPACITY);
     }
   }
-  /** 到期扫描：取走全部到期通道（连缓冲一并交出），由调用方决定是否重新登记 */
-  collectExpired(now) {
+  /** 到期扫描：取走到期通道（连缓冲一并交出），由调用方决定是否重新登记；限定频道时只扫该频道 */
+  collectExpired(now, channelKey) {
     const expired = [];
-    for (const [channelKey, lanes] of this.channels) {
-      for (const [key, state] of lanes) {
+    const targets = channelKey ? [[channelKey, this.channels.get(channelKey)]] : this.channels;
+    for (const [key, lanes] of targets) {
+      if (!lanes) continue;
+      for (const [laneKey, state] of lanes) {
         if (now < state.deadline) continue;
-        const separator = key.indexOf("\n");
-        lanes.delete(key);
+        const separator = laneKey.indexOf("\n");
+        lanes.delete(laneKey);
         expired.push({
-          channelKey,
-          ruleName: key.slice(0, separator),
-          lane: key.slice(separator + 1),
+          channelKey: key,
+          ruleName: laneKey.slice(0, separator),
+          lane: laneKey.slice(separator + 1),
           buffer: state.buffer
         });
       }
-      if (!lanes.size) this.channels.delete(channelKey);
+      if (!lanes.size) this.channels.delete(key);
     }
     return expired;
   }
@@ -955,6 +984,29 @@ var TriggerCooldown = class {
 
 // src/trigger/engine.ts
 var SCHEDULER_TICK_MS = 1e3;
+function collectImageUrls(entries) {
+  return entries.flatMap((entry) => entry?.role === "user" ? entry.imageUrls ?? [] : []);
+}
+__name(collectImageUrls, "collectImageUrls");
+function sessionIdentityOf(session) {
+  return {
+    platform: session.platform,
+    selfId: session.selfId,
+    channelId: session.channelId,
+    guildId: session.guildId ?? session.channelId,
+    userId: session.userId
+  };
+}
+__name(sessionIdentityOf, "sessionIdentityOf");
+function poolIdentityOf(channel) {
+  return {
+    platform: channel.platform,
+    selfId: channel.selfId,
+    channelId: channel.channelId,
+    guildId: channel.guildId
+  };
+}
+__name(poolIdentityOf, "poolIdentityOf");
 var TriggerEngine = class {
   constructor(ctx, runner, history, rules, cooldown) {
     this.ctx = ctx;
@@ -991,6 +1043,7 @@ var TriggerEngine = class {
     if (this.ctx.bots[session.uid]) return next();
     if (!session.channelId) return next();
     const channelKey = channelKeyOf(session.platform, session.channelId);
+    this.tickCooldown(channelKey);
     const entry = buildHistoryEntry(session);
     if (entry) {
       this.history.recordEntry(channelKey, entry);
@@ -1006,13 +1059,14 @@ var TriggerEngine = class {
       }
     }
     return next(async (nextMiddleware) => {
+      this.tickCooldown(channelKey);
       const matched = this.matchRule(session);
       if (!matched) return nextMiddleware();
       if (this.cooldown.isCooling(channelKey, matched.rule.name, "message", Date.now())) {
         this.cooldown.bufferMessage(channelKey, matched.rule.name, {
           session,
           entry,
-          contentText: matched.condition.queryText
+          contentText: matched.condition.contentText
         });
         this.cooldown.extend(channelKey, matched.rule.name, "message", Date.now());
         return;
@@ -1043,32 +1097,24 @@ var TriggerEngine = class {
     this.beginCooldown(channelKeyOf(session.platform, session.channelId), rule.name, "message");
     this.run({
       session,
-      platform: session.platform,
-      selfId: session.selfId,
-      channelId: session.channelId,
-      guildId: session.guildId ?? session.channelId,
-      userId: session.userId,
+      ...sessionIdentityOf(session),
       triggerType: condition.type,
       rule,
       // query 为该条消息的统一格式单行；纯 @ / 纯引用等无文本消息 entry 为空，由请求器占位兜底
       queryText: entry ? formatHistoryEntry(entry) : "",
-      contentText: condition.queryText
+      contentText: condition.contentText
     });
   }
   fireDensity(fire, session) {
     this.beginCooldown(channelKeyOf(session.platform, session.channelId), fire.rule.name, densityLane(fire.conditionIndex));
-    const windowText = formatHistoryEntries(fire.entries);
     this.run({
       session,
-      platform: session.platform,
-      selfId: session.selfId,
-      channelId: session.channelId,
-      guildId: session.guildId ?? session.channelId,
-      userId: session.userId,
+      ...sessionIdentityOf(session),
       triggerType: "density",
       rule: fire.rule,
-      queryText: windowText,
-      contentText: windowText
+      queryText: formatHistoryEntries(fire.entries),
+      contentText: formatHistoryBrief(fire.entries),
+      imageUrls: collectImageUrls(fire.entries)
     });
   }
   /** 冷却到期：把缓冲内的触发消息合并为一次触发，session 取首条（供投递与文件上传） */
@@ -1079,30 +1125,37 @@ var TriggerEngine = class {
     this.beginCooldown(channelKeyOf(first.session.platform, first.session.channelId), rule.name, "message");
     this.run({
       session: first.session,
-      platform: first.session.platform,
-      selfId: first.session.selfId,
-      channelId: first.session.channelId,
-      guildId: first.session.guildId ?? first.session.channelId,
-      userId: first.session.userId,
+      ...sessionIdentityOf(first.session),
       triggerType: "merged",
       rule,
       queryText,
-      contentText
+      contentText,
+      // 补齐缓冲内非首条消息的图片（首条由 session 元素提取，重复由上传入口去重）
+      imageUrls: collectImageUrls(buffer.map((item) => item.entry))
     });
   }
   /** 密度冷却到期复查达标：无当前消息，用池身份构造上下文（投递同定时路径） */
-  fireDensityExpiry(rule, conditionIndex, channel) {
+  fireDensityExpiry(rule, conditionIndex, channel, now) {
     this.beginCooldown(channelKeyOf(channel.platform, channel.channelId), rule.name, densityLane(conditionIndex));
-    const windowText = formatHistoryEntries(channel.entries);
+    const condition = rule.conditions[conditionIndex];
+    const windowMs = condition.type === "density" ? condition.densityWindowSeconds * 1e3 : 0;
+    let userId;
+    for (let i = channel.entries.length - 1; i >= 0; i--) {
+      const item = channel.entries[i];
+      if (item.role === "user" && now - item.timestamp <= windowMs) {
+        userId = item.userId;
+        break;
+      }
+    }
     this.run({
-      platform: channel.platform,
-      selfId: channel.selfId,
-      channelId: channel.channelId,
-      guildId: channel.guildId,
+      ...poolIdentityOf(channel),
+      userId,
       triggerType: "density",
       rule,
-      queryText: windowText,
-      contentText: windowText
+      queryText: formatHistoryEntries(channel.entries),
+      contentText: formatHistoryBrief(channel.entries),
+      imageUrls: collectImageUrls(channel.entries),
+      isDirect: channel.isDirect
     });
   }
   /**
@@ -1111,24 +1164,22 @@ var TriggerEngine = class {
    */
   fireSchedule(rule) {
     for (const channel of this.pool.takeSchedule(rule)) {
-      const windowText = formatHistoryEntries(channel.entries);
       this.run({
-        platform: channel.platform,
-        selfId: channel.selfId,
-        channelId: channel.channelId,
-        guildId: channel.guildId,
+        ...poolIdentityOf(channel),
         triggerType: "schedule",
         rule,
-        queryText: windowText,
-        contentText: windowText
+        queryText: formatHistoryEntries(channel.entries),
+        contentText: formatHistoryBrief(channel.entries),
+        imageUrls: collectImageUrls(channel.entries),
+        isDirect: channel.isDirect
       });
     }
   }
-  /** 每秒扫描冷却到期：消息通道合并触发，密度通道复查池 */
-  tickCooldown() {
+  /** 扫描冷却到期（带频道只扫该频道，消息路径用；每秒 interval 全量扫描）：消息通道合并触发，密度通道复查池 */
+  tickCooldown(channelKey) {
     if (!this.cooldown.enabled) return;
     const now = Date.now();
-    for (const expired of this.cooldown.collectExpired(now)) {
+    for (const expired of this.cooldown.collectExpired(now, channelKey)) {
       this.onCooldownExpired(expired, now);
     }
   }
@@ -1139,11 +1190,11 @@ var TriggerEngine = class {
       if (expired.buffer.length) this.fireMerged(rule, expired.buffer);
       return;
     }
-    const index = Number(expired.lane.slice("density:".length));
+    const index = Number(expired.lane.slice(DENSITY_LANE_PREFIX.length));
     const condition = rule.conditions[index];
     if (condition?.type !== "density") return;
     const channel = this.pool.takeDensityChannel(rule, condition, expired.channelKey, now);
-    if (channel) this.fireDensityExpiry(rule, index, channel);
+    if (channel) this.fireDensityExpiry(rule, index, channel, now);
   }
 };
 
@@ -1235,11 +1286,26 @@ function extractFileCandidates(session) {
   return candidates;
 }
 __name(extractFileCandidates, "extractFileCandidates");
+function percentDecodeBytes(input) {
+  const bytes = [];
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === "%" && /^[0-9a-fA-F]{2}$/.test(input.slice(i + 1, i + 3))) {
+      bytes.push(parseInt(input.slice(i + 1, i + 3), 16));
+      i += 2;
+    } else {
+      bytes.push(char.charCodeAt(0) & 255);
+    }
+  }
+  return Buffer.from(bytes);
+}
+__name(percentDecodeBytes, "percentDecodeBytes");
 function parseDataUrl(source) {
-  const match = source.match(/^data:([^;]+);base64,(.+)$/);
+  const match = source.match(/^data:([^;,]*)((?:;[^;,]*)*)?,(.+)$/);
   if (!match) return null;
-  const mimeType = match[1];
-  const buffer = Buffer.from(match[2], "base64");
+  const mimeType = match[1] || "application/octet-stream";
+  const isBase64 = /(?:^|;)base64/.test(match[2] ?? "");
+  const buffer = isBase64 ? Buffer.from(match[3], "base64") : percentDecodeBytes(match[3]);
   return { buffer, fileName: `file.${guessExtension(mimeType)}`, mimeType };
 }
 __name(parseDataUrl, "parseDataUrl");
@@ -1313,19 +1379,28 @@ async function uploadOne(ctx, client, candidate, difyUser, limit) {
   }
 }
 __name(uploadOne, "uploadOne");
-async function uploadMessageFiles(ctx, client, session, difyUser, limit) {
-  const candidates = extractFileCandidates(session);
-  const limited = limit.maxCount > 0 ? candidates.slice(0, limit.maxCount) : candidates;
-  const dropped = candidates.slice(limited.length).map((candidate) => candidate.source);
+async function uploadCandidates(ctx, client, candidates, difyUser, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = candidates.filter((candidate) => {
+    if (seen.has(candidate.source)) return false;
+    seen.add(candidate.source);
+    return true;
+  });
+  const limited = limit.maxCount > 0 ? unique.slice(0, limit.maxCount) : unique;
+  const dropped = [];
+  const markDropped = /* @__PURE__ */ __name((source) => {
+    if (!dropped.includes(source)) dropped.push(source);
+  }, "markDropped");
+  unique.slice(limited.length).forEach((candidate) => markDropped(candidate.source));
   const files = [];
   for (const candidate of limited) {
     const uploaded = await uploadOne(ctx, client, candidate, difyUser, limit);
     if (uploaded) files.push(uploaded);
-    else dropped.push(candidate.source);
+    else markDropped(candidate.source);
   }
   return { files, dropped };
 }
-__name(uploadMessageFiles, "uploadMessageFiles");
+__name(uploadCandidates, "uploadCandidates");
 
 // src/requester/variables.ts
 function resolveSessionField(key, fireCtx, now) {
@@ -1354,7 +1429,7 @@ function resolveSessionField(key, fireCtx, now) {
     case "timestamp":
       return now;
     case "isDirect":
-      return session?.isDirect ?? false;
+      return session?.isDirect ?? fireCtx.isDirect ?? false;
     default:
       return "";
   }
@@ -1436,7 +1511,7 @@ ${line}` : line;
 __name(splitText, "splitText");
 function renderReply(input) {
   const messages = [];
-  const segments = splitText(input.text, input.config.maxSegmentLength ?? 0);
+  const segments = splitText(input.text, input.config.maxSegmentLength);
   segments.forEach((segment, index) => {
     const elements = [];
     if (index === 0 && input.quoteMessageId) {
@@ -1492,6 +1567,7 @@ function extractTextOutputs(outputs) {
 __name(extractTextOutputs, "extractTextOutputs");
 function parseWorkflowResponse(response) {
   const data = response.data;
+  if (!data) throw new DifyApiError("workflow 响应缺少 data", 200);
   if (data.error) throw new DifyApiError(data.error, 200);
   if (data.status && !SUCCESS_STATUSES.includes(data.status)) {
     throw new DifyApiError(`workflow ${data.status}`, 200);
@@ -1534,11 +1610,13 @@ var RequestRunner = class {
       uploadedFiles: []
     };
     const upload = resolveUploadConfig(this.config);
-    if (upload.enabled && fireCtx.session) {
-      const { files, dropped } = await uploadMessageFiles(
+    if (upload.enabled) {
+      const sessionCandidates = fireCtx.session ? extractFileCandidates(fireCtx.session) : [];
+      const urlCandidates = (fireCtx.imageUrls ?? []).filter((url) => !sessionCandidates.some((candidate) => candidate.source === url)).map((url) => ({ source: url, type: "image" }));
+      const { files, dropped } = await uploadCandidates(
         this.ctx,
         client,
-        fireCtx.session,
+        [...sessionCandidates, ...urlCandidates],
         requestCtx.difyUser,
         { maxCount: upload.maxCount, maxSizeMb: upload.maxMb }
       );
@@ -1562,17 +1640,20 @@ var RequestRunner = class {
       this.ctx.logger.warn("规则 %s 的请求未返回任何内容", rule.name);
       return;
     }
-    const quote = resolveQuoteConfig(this.config);
-    const elapsedSeconds = (Date.now() - startedAt) / 1e3;
-    const shouldQuote = quote.enabled && elapsedSeconds >= quote.minElapsedSeconds && isMessageTrigger(fireCtx.triggerType);
     const messages = renderReply({
       text: reply.text,
       files: reply.files,
-      quoteMessageId: shouldQuote ? fireCtx.session?.messageId : void 0,
+      quoteMessageId: this.shouldQuoteReply(fireCtx, startedAt) ? fireCtx.session?.messageId : void 0,
       config: this.config
     });
     await this.deliver(fireCtx, messages);
   }
+  /** 引用判定：开关开启、回复耗时达到阈值、且由消息触发（定时与密度没有单一触发消息） */
+  shouldQuoteReply(fireCtx, startedAt) {
+    const quote = resolveQuoteConfig(this.config);
+    if (!quote.enabled) return false;
+    return (Date.now() - startedAt) / 1e3 >= quote.minElapsedSeconds && isMessageTrigger(fireCtx.triggerType);
+  }
   /** 按应用类型分流：workflow/completion 无会话，chat 系续接 conversation_id */
   async dispatch(app, client, fireCtx, requestCtx) {
     const base = {
@@ -1610,7 +1691,8 @@ var RequestRunner = class {
       }
       return;
     }
-    const bot = Object.values(this.ctx.bots).find((b) => b.platform === fireCtx.platform);
+    const bots = Object.values(this.ctx.bots);
+    const bot = bots.find((b) => b.platform === fireCtx.platform && b.selfId === fireCtx.selfId) ?? bots.find((b) => b.platform === fireCtx.platform);
     if (!bot) {
       this.ctx.logger.warn("平台 %s 上没有可用 bot，无法发送主动消息", fireCtx.platform);
       return;
@@ -1632,7 +1714,7 @@ var ConversationStore = class {
   }
   /** 粒度归一：bindingKey 与 difyUser 共用，保证两者始终对齐 */
   resolveScopeDimension(rule, fireCtx) {
-    if (fireCtx.session?.isDirect || rule.conversationScope === "per-user") return "user";
+    if (this.isDirectOf(fireCtx) || rule.conversationScope === "per-user") return "user";
     switch (rule.conversationScope) {
       case "global":
         return "global";
@@ -1642,13 +1724,17 @@ var ConversationStore = class {
         return "guild";
     }
   }
+  /** 私聊判定：有 session 读 session，无 session 的主动触发读池透传的标记 */
+  isDirectOf(fireCtx) {
+    return fireCtx.session?.isDirect ?? fireCtx.isDirect ?? false;
+  }
   /** bindingKey = 应用 ID + 粒度 + 平台身份 */
   computeBindingKey(appId, rule, fireCtx) {
     const base = `${appId}:${fireCtx.platform}:${fireCtx.selfId}`;
     switch (this.resolveScopeDimension(rule, fireCtx)) {
       // 群内按「群+用户」区分；私聊用 private 段占位
       case "user":
-        return fireCtx.session?.isDirect ? `${base}:private:${fireCtx.userId ?? fireCtx.channelId}` : `${base}:user:${fireCtx.guildId ?? fireCtx.channelId}:${fireCtx.userId ?? fireCtx.channelId}`;
+        return this.isDirectOf(fireCtx) ? `${base}:private:${fireCtx.userId ?? fireCtx.channelId}` : `${base}:user:${fireCtx.guildId ?? fireCtx.channelId}:${fireCtx.userId ?? fireCtx.channelId}`;
       case "guild":
         return `${base}:guild:${fireCtx.guildId ?? fireCtx.channelId}`;
       case "channel":
@@ -1665,7 +1751,7 @@ var ConversationStore = class {
   computeDifyUser(rule, fireCtx) {
     switch (this.resolveScopeDimension(rule, fireCtx)) {
       case "user":
-        return fireCtx.session?.isDirect ? `koishi:${fireCtx.platform}:private:${fireCtx.userId ?? fireCtx.channelId}` : `koishi:${fireCtx.platform}:${fireCtx.guildId ?? fireCtx.channelId}:${fireCtx.userId ?? fireCtx.channelId}`;
+        return this.isDirectOf(fireCtx) ? `koishi:${fireCtx.platform}:private:${fireCtx.userId ?? fireCtx.channelId}` : `koishi:${fireCtx.platform}:${fireCtx.guildId ?? fireCtx.channelId}:${fireCtx.userId ?? fireCtx.channelId}`;
       case "guild":
         return `koishi:${fireCtx.platform}:${fireCtx.guildId ?? fireCtx.channelId}`;
       case "channel":
@@ -1705,16 +1791,25 @@ var ConversationStore = class {
   /**
    * 重置匹配的绑定：本地删行 + 尽力删除 Dify 侧会话（失败仅记录）。
    * 表已无 guildKey 列，按频道匹配时全表读回后解析 bindingKey 过滤（行数量级很小）。
+   * 覆盖 guild / user（群内）/ channel 段与私聊执行时的 private 段；
+   * global 段跨频道，不随单频道重置。
    */
   async resetWhere(filter) {
     const rows = await this.ctx.database.get("dify_conversation", {});
+    const splitKey = /* @__PURE__ */ __name((key) => {
+      const separator = key.indexOf(":");
+      return separator < 0 ? [key, ""] : [key.slice(0, separator), key.slice(separator + 1)];
+    }, "splitKey");
+    const [guildPlatform, guildId] = splitKey(filter.guildKey ?? "");
+    const [channelPlatform, channelId] = splitKey(filter.channelKey ?? "");
     const matched = rows.filter((row) => {
       if (filter.bindingKey) return row.bindingKey === filter.bindingKey;
       const { platform, scope, ids } = this.parseBindingKey(row.bindingKey);
-      const [guildPlatform, guildId] = (filter.guildKey ?? "").split(":");
       if (platform !== guildPlatform) return false;
       if (scope === "guild") return ids[0] === guildId;
       if (scope === "user") return ids.length === 2 ? ids[0] === guildId : false;
+      if (scope === "channel") return platform === channelPlatform && ids[0] === channelId;
+      if (scope === "private") return filter.isDirect === true && ids[0] === filter.userId;
       return false;
     });
     let reset = 0;
@@ -1757,8 +1852,12 @@ __name(defineTables, "defineTables");
 // src/commands/misc.ts
 function registerMiscCommands(parent, conversationStore) {
   parent.subcommand(".conv.reset", { authority: 3 }).action(async ({ session }) => {
-    const guildKey = guildKeyOf(session.platform, session.guildId, session.channelId);
-    const reset = await conversationStore.resetWhere({ guildKey });
+    const reset = await conversationStore.resetWhere({
+      guildKey: guildKeyOf(session.platform, session.guildId, session.channelId),
+      channelKey: channelKeyOf(session.platform, session.channelId),
+      isDirect: session.isDirect,
+      userId: session.userId
+    });
     if (!reset) return session.text("dify-ai.commands.conv-empty");
     return session.text("dify-ai.commands.conv-reset", [reset]);
   });
@@ -1768,6 +1867,7 @@ __name(registerMiscCommands, "registerMiscCommands");
 // src/index.ts
 var name = "dify-ai";
 var inject = { required: ["database"] };
+var PROBE_TIMEOUT_MS = 1e4;
 function apply(ctx, config) {
   ctx.i18n.define("zh-CN", zh_CN_default);
   ctx.i18n.define("en-US", en_US_default);
@@ -1778,18 +1878,20 @@ function apply(ctx, config) {
   const conversationStore = new ConversationStore(ctx, apps);
   const runner = new RequestRunner(ctx, config, conversationStore, history, apps, appTypes);
   const engine = new TriggerEngine(ctx, runner, history, rules, cooldown);
-  ctx.on("ready", async () => {
-    await probeAppTypes(ctx, config, apps, appTypes);
+  ctx.on("ready", () => {
     engine.start();
+    void probeAppTypes(ctx, apps, appTypes);
   });
   const admin = ctx.command("dify", { authority: 3 });
   registerMiscCommands(admin, conversationStore);
 }
 __name(apply, "apply");
-async function probeAppTypes(ctx, config, apps, appTypes) {
+async function probeAppTypes(ctx, apps, appTypes) {
+  const autoApps = [...apps.values()].filter((app) => app.appType === "auto");
+  if (!autoApps.length) return;
   await Promise.all(
-    [...apps.values()].filter((app) => app.appType === "auto").map(async (app) => {
-      const client = createDifyClient(ctx, app, config.requestTimeout);
+    autoApps.map(async (app) => {
+      const client = createDifyClient(ctx, app, PROBE_TIMEOUT_MS);
       if (!client) return;
       try {
         const info = await client.getAppInfo();

package/lib/requester/files.d.ts

@@ -27,6 +27,6 @@ export interface UploadResult {
     files: DifyInputFileObject[];
     dropped: string[];
 }
-/** 提取并上传消息中的文件（先按数量上限截断候选，再逐个上传） */
-export declare function uploadMessageFiles(ctx: Context, client: DifyClient, session: Session, difyUser: string, limit: UploadLimit): Promise<UploadResult>;
+/** 上传一批候选（入口按 type:source 去重，再按数量上限截断、逐个上传） */
+export declare function uploadCandidates(ctx: Context, client: DifyClient, candidates: FileCandidate[], difyUser: string, limit: UploadLimit): Promise<UploadResult>;
 export {};

package/lib/requester/runner.d.ts

@@ -28,6 +28,8 @@ export declare class RequestRunner {
     /** 应用类型：schema 显式指定优先，auto 时用探测结果（未探测到回退 chat） */
     private appTypeOf;
     run(fireCtx: FireContext): Promise<void>;
+    /** 引用判定：开关开启、回复耗时达到阈值、且由消息触发（定时与密度没有单一触发消息） */
+    private shouldQuoteReply;
     /** 按应用类型分流：workflow/completion 无会话，chat 系续接 conversation_id */
     private dispatch;
     private deliver;

package/lib/state/conversation.d.ts

@@ -15,6 +15,8 @@ export declare class ConversationStore {
     apps: Map<string, AppConfigEntry>);
     /** 粒度归一：bindingKey 与 difyUser 共用，保证两者始终对齐 */
     private resolveScopeDimension;
+    /** 私聊判定：有 session 读 session，无 session 的主动触发读池透传的标记 */
+    private isDirectOf;
     /** bindingKey = 应用 ID + 粒度 + 平台身份 */
     computeBindingKey(appId: string, rule: DifyRule, fireCtx: FireContext): string;
     /**
@@ -32,10 +34,15 @@ export declare class ConversationStore {
     /**
      * 重置匹配的绑定：本地删行 + 尽力删除 Dify 侧会话（失败仅记录）。
      * 表已无 guildKey 列，按频道匹配时全表读回后解析 bindingKey 过滤（行数量级很小）。
+     * 覆盖 guild / user（群内）/ channel 段与私聊执行时的 private 段；
+     * global 段跨频道，不随单频道重置。
      */
     resetWhere(filter: {
         bindingKey?: string;
         guildKey?: string;
+        channelKey?: string;
+        isDirect?: boolean;
+        userId?: string;
     }): Promise<number>;
     /** 按应用 ID（apps 配置的 appId 字段）反查应用 */
     private findByAppId;

package/lib/trigger/conditions.d.ts

@@ -2,10 +2,10 @@ import { Session } from 'koishi';
 import { MessageTriggerType, TriggerCondition, TriggerScope } from '../types';
 export interface ConditionMatched {
     type: MessageTriggerType;
-    /** 触发后用作 content 变量的剥离文本（query 由引擎按统一消息格式另行构造） */
-    queryText: string;
+    /** content 变量的剥离文本，保留 @ 与图片占位（query 由引擎按统一消息格式另行构造） */
+    contentText: string;
 }
-/** 评估单个消息条件；返回 null 表示未命中 */
+/** 评估单个消息条件；返回 null 表示未命中（匹配基于纯文本，@ 元素不参与判定） */
 export declare function evaluateCondition(condition: TriggerCondition, session: Session): ConditionMatched | null;
 /** 作用域过滤：留空的维度不做限制 */
 export declare function matchScope(scope: TriggerScope, session: Session): boolean;

package/lib/trigger/cooldown.d.ts

@@ -10,6 +10,8 @@ export interface PendingMessage {
 }
 /** 冷却通道：message = 规则内全部消息类条件共享；density:N = 第 N 个密度条件独立 */
 export type CooldownLane = 'message' | `density:${number}`;
+/** 密度通道名的下标前缀 */
+export declare const DENSITY_LANE_PREFIX = "density:";
 /** 密度条件的通道名 */
 export declare function densityLane(index: number): CooldownLane;
 /** 到期扫描交出的通道产物 */
@@ -34,13 +36,15 @@ export declare class TriggerCooldown {
     /** 触发发起时登记冷却 */
     begin(channelKey: string, ruleName: string, lane: CooldownLane, now: number): void;
     isCooling(channelKey: string, ruleName: string, lane: CooldownLane, now: number): boolean;
-    /** 滑动窗口顺延：截止时间顺延到「now + 最小窗口」，不超过「触发时刻 + 最大窗口」 */
+    /** 滑动窗口顺延：截止推到「now + 最小窗口」，不超过「触发时刻 + 最大窗口」 */
+    private slide;
+    /** 滑动窗口顺延：已到期的通道不复活 */
     extend(channelKey: string, ruleName: string, lane: CooldownLane, now: number): void;
-    /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动） */
+    /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动）；已到期的不复活 */
     extendDensityLanes(channelKey: string, now: number): void;
     /** 冷却期内缓存一条命中消息（仅消息通道） */
     bufferMessage(channelKey: string, ruleName: string, message: PendingMessage): void;
-    /** 到期扫描：取走全部到期通道（连缓冲一并交出），由调用方决定是否重新登记 */
-    collectExpired(now: number): ExpiredCooldown[];
+    /** 到期扫描：取走到期通道（连缓冲一并交出），由调用方决定是否重新登记；限定频道时只扫该频道 */
+    collectExpired(now: number, channelKey?: string): ExpiredCooldown[];
     private lanesOf;
 }

package/lib/trigger/engine.d.ts

@@ -33,7 +33,7 @@ export declare class TriggerEngine {
      * 频道身份取自池内最近一条消息；无消息的频道自然跳过。定时不受冷却影响。
      */
     private fireSchedule;
-    /** 每秒扫描冷却到期：消息通道合并触发，密度通道复查池 */
+    /** 扫描冷却到期（带频道只扫该频道，消息路径用；每秒 interval 全量扫描）：消息通道合并触发，密度通道复查池 */
     private tickCooldown;
     private onCooldownExpired;
 }

package/lib/types.d.ts

@@ -110,6 +110,10 @@ export interface FireContext {
     rule: DifyRule;
     /** 发给 Dify 的 query：统一消息格式（消息触发为单行，窗口触发为逐行拼接） */
     queryText: string;
-    /** content 变量的值：消息触发为剥离文本，窗口触发为统一格式拼接 */
+    /** content 变量的值：消息触发为剥离文本（剔除 @bot），窗口触发为精简行拼接 */
     contentText: string;
+    /** 本次触发相关消息的图片 URL（合并/密度/定时的池或缓冲条目合集）：供上传管线补齐非首条消息的图片 */
+    imageUrls?: string[];
+    /** 无 session 的主动触发（定时/密度到期）从消息池透传的私聊标记：会话绑定与 isDirect 变量用 */
+    isDirect?: boolean;
 }

package/lib/utils/session-text.d.ts

@@ -1,4 +1,6 @@
 import { Session } from 'koishi';
+/** 图片占位符携带的 URL 摘要长度（hex 位） */
+export declare const IMAGE_HASH_LENGTH = 8;
 /**
  * 会话文本提取的统一入口。此前有四个变体（条件匹配、历史记录、变量、@ 剥离）
  * 各自实现「elements 有则取 text 元素，否则解析 content」，trim 与解析行为已经漂移，
@@ -6,21 +8,24 @@ import { Session } from 'koishi';
  */
 /** 把可解析的消息文本（含元素标记）转纯文本；解析失败回退原文 */
 export declare function parseTextSafe(content: string | undefined): string;
-interface ExtractTextOptions {
-    /** 去掉 @ 元素（at-bot 触发的 query 语义） */
-    excludeAt?: boolean;
-}
-/** 会话消息纯文本：优先 elements，退回 content 解析；统一 trim */
-export declare function extractText(session: Session, options?: ExtractTextOptions): string;
+/** 会话消息纯文本：优先 elements，退回 content 解析；统一 trim（@ 元素不产生文本，仅供条件匹配） */
+export declare function extractText(session: Session): string;
 /** 消息中的图片元素在文本形态里的占位符（图片无 URL 时的兜底形态） */
 export declare const IMAGE_PLACEHOLDER = "[\u56FE\u7247]";
-/** 图片占位符带 URL 摘要前 8 位：同 URL 同标识，query 里的占位符与上传文件可全局对应 */
+/** 图片占位符带 URL 摘要：同 URL 同标识，query 里的占位符与上传文件可全局对应 */
 export declare function imagePlaceholder(url?: string): string;
 /** 给被丢弃图片的占位符追加已丢弃注记：按 URL 摘要全局定位，无需与元素顺序对齐 */
 export declare function annotateDroppedPlaceholders(text: string, droppedUrls: string[]): string;
+interface ExtractVerbatimOptions {
+    /** 跳过 @ 机器人自身的渲染（content 变量语义：@bot 是触发结构而非消息内容） */
+    excludeBotAt?: boolean;
+}
 /**
- * 带媒体占位符的消息文本：text 元素按序拼接，img/image 元素渲染为 [image:URL摘要]，
- * 供聊天记录呈现（历史消息变量 / 定时摘要 / 密度触发共用）。
+ * 消息原貌文本：text 元素按序拼接，@ 元素渲染为 @名字（缺名字用 ID），
+ * img/image 元素渲染为 [image:URL摘要]——统一格式行（query/池/历史）用默认形态，
+ * content 变量通道用 excludeBotAt 形态剔除 @bot。
  */
-export declare function extractTextWithPlaceholders(session: Session): string;
+export declare function extractTextWithPlaceholders(session: Session, options?: ExtractVerbatimOptions): string;
+/** 消息中图片元素的 URL 列表（按元素序，与原貌文本中 [image:摘要] 的出现序一致） */
+export declare function extractImageUrls(session: Session): string[];
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-dify-ai",
   "description": "Invoke Dify apps (chatflow / workflow / completion) in Koishi with triggers and conversation bindings",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "author": "PinkElysia",
   "license": "MIT",
   "homepage": "https://github.com/PinkElysiaDev/dify-ai-plugin-for-Koishi#readme",