koishi-plugin-dify-ai 0.1.3 → 0.1.5

package/lib/config.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from 'koishi';
-import { DifyRule } from './types';
+import { CooldownSetting, DifyRule } from './types';
 export type AppTypeSetting = 'auto' | 'chat' | 'agent-chat' | 'advanced-chat' | 'workflow' | 'completion';
 export interface AppConfigEntry {
     name: string;
@@ -35,16 +35,23 @@ export type ConditionEntry = {
     densityCount?: number;
     densityWindowSeconds?: number;
 };
-/** 变量映射的条件分支形态：先选来源分支，再填该分支的字段（历史消息是会话字段下的一项） */
+/** 变量映射的条件分支形态：先选来源分支，再填该分支的字段（历史消息是独立分支） */
 export type VariableEntry = {
     source: 'session';
     field: string;
     key: string;
+} | {
+    source: 'history';
+    field: string;
     limit?: number;
 } | {
     source: 'meta';
     field: string;
     key: string;
+} | {
+    source: 'constant';
+    field: string;
+    value: string;
 };
 /** 作用域的一行：维度 + 值 */
 export interface ScopeRow {
@@ -61,23 +68,71 @@ export interface RuleEntry {
     scope: ScopeRow[];
     variables: VariableEntry[];
 }
+/** 引用触发消息的条件分支形态：关闭时空分支，开启时按耗时阈值决定是否引用 */
+export type QuoteEntry = {
+    mode: 'off';
+} | {
+    mode: 'on';
+    minElapsedSeconds: number;
+};
+/** 触发后冷却的条件分支形态 */
+export type CooldownEntry = {
+    mode: 'off';
+} | {
+    mode: 'fixed';
+    seconds?: number;
+} | {
+    mode: 'sliding';
+    minSeconds?: number;
+    maxSeconds?: number;
+};
+/** 上传消息文件的条件分支形态：关闭时空分支，开启时限制数量与单文件大小 */
+export type UploadEntry = {
+    mode: 'off';
+} | {
+    mode: 'on';
+    maxCount?: number;
+    maxSizeMb?: number;
+};
 export interface Config {
     apps: AppConfigEntry[];
     rules: RuleEntry[];
     parseElements: boolean;
-    quoteTrigger: boolean;
+    quote: QuoteEntry;
     maxSegmentLength: number;
-    uploadFiles: boolean;
+    /** boolean 是 0.1.x 的遗留形态，仅迁移读取（true → 开启不限，false → 关闭） */
+    uploadFiles: UploadEntry | boolean;
+    /** 0.1.x 的布尔开关，仅用于迁移读取（true → 总是引用，false → 关闭） */
+    quoteTrigger?: boolean;
     requestTimeout: number;
     historyLimit: number;
     sendErrors: boolean;
+    cooldown: CooldownEntry;
 }
 export declare const Config: Schema<Config>;
 /**
- * 配置规范化：应用表 + 按优先级降序的规则列表。
+ * 上传消息文件配置（含 0.1.x 布尔遗留形态迁移）：
+ * 数量与单文件大小 0 均为不限，大小仍与 Dify 各类型上限取较小值。
+ */
+export declare function resolveUploadConfig(config: Config): {
+    enabled: boolean;
+    maxCount: number;
+    maxMb: number;
+};
+/**
+ * 引用触发消息配置（含 0.1.x 布尔开关迁移）：schema 形态缺失时
+ * 旧 quoteTrigger 若被配置层透传保留则迁移，否则按总是引用处理。
+ */
+export declare function resolveQuoteConfig(config: Config): {
+    enabled: boolean;
+    minElapsedSeconds: number;
+};
+/**
+ * 配置规范化：应用表 + 按优先级降序的规则列表 + 冷却设置。
  * 坏条件/无名变量直接丢弃；引用不存在应用的规则保留但运行时会 warn 跳过。
  */
 export declare function normalizeConfig(config: Config): {
     apps: Map<string, AppConfigEntry>;
     rules: DifyRule[];
+    cooldown: CooldownSetting | null;
 };

package/lib/history.d.ts

@@ -24,7 +24,7 @@ export interface HistoryEntry {
 export declare function formatHistoryEntry(entry: HistoryEntry): string;
 /** 多条消息逐行拼接 */
 export declare function formatHistoryEntries(entries: HistoryEntry[]): string;
-/** 从会话消息构造记录条目（历史缓冲 / 密度窗口 / 定时窗口共用） */
+/** 从会话消息构造记录条目（历史缓冲 / 消息池共用）；assistant 行标注为机器人自己的发言 */
 export declare function buildHistoryEntry(session: Session, role?: 'user' | 'assistant'): HistoryEntry | null;
 /**
  * 每个频道在内存中保留最近消息（含 bot 自己的回复），

package/lib/index.js

@@ -92,6 +92,7 @@ var conditionSchema = import_koishi.Schema.union([
   }).default({ type: "density", densityCount: 5, densityWindowSeconds: 60 }).description("消息密度")
 ]);
 var sessionKeySchema = import_koishi.Schema.union([
+  import_koishi.Schema.const("none").description("无"),
   import_koishi.Schema.const("userId").description("用户 ID"),
   import_koishi.Schema.const("botId").description("Bot ID"),
   import_koishi.Schema.const("guildId").description("群聊 ID"),
@@ -103,10 +104,10 @@ var sessionKeySchema = import_koishi.Schema.union([
   import_koishi.Schema.const("quoteAuthorId").description("被引用作者"),
   import_koishi.Schema.const("username").description("用户名"),
   import_koishi.Schema.const("timestamp").description("触发时间"),
-  import_koishi.Schema.const("isDirect").description("是否私聊"),
-  import_koishi.Schema.const("history").description("历史消息")
+  import_koishi.Schema.const("isDirect").description("是否私聊")
 ]);
 var metaKeySchema = import_koishi.Schema.union([
+  import_koishi.Schema.const("none").description("无"),
   import_koishi.Schema.const("triggerType").description("触发类型"),
   import_koishi.Schema.const("ruleName").description("规则名"),
   import_koishi.Schema.const("triggerTime").description("触发时间")
@@ -115,14 +116,56 @@ var variableSchema = import_koishi.Schema.union([
   import_koishi.Schema.object({
     source: import_koishi.Schema.const("session").required(),
     field: import_koishi.Schema.string().required().description("字段名"),
-    key: sessionKeySchema.default("content").description("变量"),
-    limit: import_koishi.Schema.natural().default(0).min(0).max(100).description("条数，选历史消息时生效")
-  }).default({ source: "session", field: "", key: "content", limit: 0 }).description("会话字段"),
+    key: sessionKeySchema.default("none").description("变量")
+  }).default({ source: "session", field: "", key: "none" }).description("会话字段"),
+  import_koishi.Schema.object({
+    source: import_koishi.Schema.const("history").required(),
+    field: import_koishi.Schema.string().required().description("字段名"),
+    limit: import_koishi.Schema.natural().default(0).min(0).max(100).description("条数，0 用全局")
+  }).default({ source: "history", field: "", limit: 0 }).description("历史消息"),
   import_koishi.Schema.object({
     source: import_koishi.Schema.const("meta").required(),
     field: import_koishi.Schema.string().required().description("字段名"),
-    key: metaKeySchema.default("triggerType").description("变量")
-  }).default({ source: "meta", field: "", key: "triggerType" }).description("触发元信息")
+    key: metaKeySchema.default("none").description("变量")
+  }).default({ source: "meta", field: "", key: "none" }).description("触发元信息"),
+  import_koishi.Schema.object({
+    source: import_koishi.Schema.const("constant").required(),
+    field: import_koishi.Schema.string().required().description("字段名"),
+    value: import_koishi.Schema.string().role("textarea").required().description("固定文本")
+  }).default({ source: "constant", field: "", value: "" }).description("常量文本")
+]);
+var quoteSchema = import_koishi.Schema.union([
+  import_koishi.Schema.object({
+    mode: import_koishi.Schema.const("off").required()
+  }).default({ mode: "off" }).description("关闭"),
+  import_koishi.Schema.object({
+    mode: import_koishi.Schema.const("on").required(),
+    minElapsedSeconds: import_koishi.Schema.natural().default(0).description("回复耗时多少秒才引用，0 总是引用")
+  }).default({ mode: "on", minElapsedSeconds: 0 }).description("开启")
+]);
+var cooldownSchema = import_koishi.Schema.union([
+  import_koishi.Schema.object({
+    mode: import_koishi.Schema.const("off").required()
+  }).default({ mode: "off" }).description("关闭"),
+  import_koishi.Schema.object({
+    mode: import_koishi.Schema.const("fixed").required(),
+    seconds: import_koishi.Schema.natural().default(30).min(1).description("冷却秒数")
+  }).default({ mode: "fixed", seconds: 30 }).description("固定窗口"),
+  import_koishi.Schema.object({
+    mode: import_koishi.Schema.const("sliding").required(),
+    minSeconds: import_koishi.Schema.natural().default(30).min(1).description("最小冷却秒数"),
+    maxSeconds: import_koishi.Schema.natural().default(120).min(1).description("最大冷却秒数")
+  }).default({ mode: "sliding", minSeconds: 30, maxSeconds: 120 }).description("滑动窗口")
+]);
+var uploadSchema = import_koishi.Schema.union([
+  import_koishi.Schema.object({
+    mode: import_koishi.Schema.const("off").required()
+  }).default({ mode: "off" }).description("关闭"),
+  import_koishi.Schema.object({
+    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("开启")
 ]);
 var Config = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
@@ -170,14 +213,15 @@ var Config = import_koishi.Schema.intersect([
   }).description("触发规则"),
   import_koishi.Schema.object({
     parseElements: import_koishi.Schema.boolean().default(false).description("解析回复中的消息元素"),
-    quoteTrigger: import_koishi.Schema.boolean().default(true).description("引用触发消息"),
+    quote: quoteSchema.default({ mode: "on", minElapsedSeconds: 0 }).description("引用触发消息"),
     maxSegmentLength: import_koishi.Schema.natural().default(0).description("分段长度，0 不分段"),
-    uploadFiles: import_koishi.Schema.boolean().default(true).description("上传消息中的文件")
+    uploadFiles: uploadSchema.default({ mode: "on", maxCount: 0, maxSizeMb: 0 }).description("上传消息中的文件")
   }).description("回复行为"),
   import_koishi.Schema.object({
     requestTimeout: import_koishi.Schema.natural().role("ms").default(3e5).description("请求超时"),
     historyLimit: import_koishi.Schema.natural().default(20).min(1).description("历史消息条数"),
-    sendErrors: import_koishi.Schema.boolean().default(false).description("失败时提示错误")
+    sendErrors: import_koishi.Schema.boolean().default(false).description("失败时提示错误"),
+    cooldown: cooldownSchema.default({ mode: "off" }).description("触发后冷却")
   }).description("运行参数")
 ]);
 var CONVERSATION_SCOPES = ["per-user", "per-guild", "per-channel", "global"];
@@ -266,16 +310,61 @@ __name(toScope, "toScope");
 function toVariable(entry) {
   const field = entry.field?.trim();
   if (!field) return null;
+  if (entry.source === "constant") {
+    if (!entry.value) return null;
+    return { field, source: { type: "constant", value: entry.value } };
+  }
   if (entry.source === "meta") {
+    if (entry.key === "none") return null;
     return { field, source: { type: "meta", key: entry.key || "triggerType" } };
   }
-  if (entry.key === "history") {
+  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" } };
 }
 __name(toVariable, "toVariable");
+function resolveUploadConfig(config) {
+  if (typeof config.uploadFiles === "boolean") {
+    return config.uploadFiles ? { enabled: true, maxCount: 0, maxMb: 0 } : { enabled: false, maxCount: 0, maxMb: 0 };
+  }
+  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)
+  };
+}
+__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) };
+  }
+  if (config.quoteTrigger === false) return { enabled: false, minElapsedSeconds: 0 };
+  return { enabled: true, 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;
+  }
+  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 null;
+}
+__name(toCooldown, "toCooldown");
 function normalizeConfig(config) {
   const apps = /* @__PURE__ */ new Map();
   for (const app of config.apps ?? []) {
@@ -298,7 +387,7 @@ function normalizeConfig(config) {
     });
   }
   rules.sort((a, b) => b.priority - a.priority);
-  return { apps, rules };
+  return { apps, rules, cooldown: toCooldown(config.cooldown) };
 }
 __name(normalizeConfig, "normalizeConfig");
 
@@ -409,6 +498,7 @@ function createDifyClient(ctx, app, timeout) {
 __name(createDifyClient, "createDifyClient");
 
 // src/utils/session-text.ts
+var import_crypto = require("crypto");
 var import_koishi2 = require("koishi");
 function parseTextSafe(content) {
   if (!content) return "";
@@ -428,6 +518,20 @@ function extractText(session, options = {}) {
 }
 __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)}]`;
+}
+__name(imagePlaceholder, "imagePlaceholder");
+function annotateDroppedPlaceholders(text, droppedUrls) {
+  let result = text;
+  for (const url of droppedUrls) {
+    const placeholder = imagePlaceholder(url);
+    result = result.split(placeholder).join(`${placeholder}（已丢弃）`);
+  }
+  return result;
+}
+__name(annotateDroppedPlaceholders, "annotateDroppedPlaceholders");
 function extractTextWithPlaceholders(session) {
   const elements = session.elements?.length ? session.elements : (() => {
     try {
@@ -442,7 +546,7 @@ function extractTextWithPlaceholders(session) {
       const text = element.attrs?.["content"] ?? "";
       if (text) parts.push(text);
     } else if (element.type === "img" || element.type === "image") {
-      parts.push(IMAGE_PLACEHOLDER);
+      parts.push(imagePlaceholder(element.attrs?.["url"] ?? element.attrs?.["src"]));
     }
   }
   return parts.join(" ").replace(/\s+/g, " ").trim();
@@ -459,9 +563,9 @@ function formatTimestamp(timestamp) {
 }
 __name(formatTimestamp, "formatTimestamp");
 function formatHistoryEntry(entry) {
-  const quote = entry.quote ? `（引用了 ${formatTimestamp(entry.quote.timestamp)} ${entry.quote.username} (${entry.quote.userId}) 说：${entry.quote.content}）` : "";
+  const quote = entry.quote ? `（引用了 [${formatTimestamp(entry.quote.timestamp)}] ${entry.quote.username} (${entry.quote.userId}) 说：${entry.quote.content}）` : "";
   const messageId = entry.messageId ? ` [msg:${entry.messageId}]` : "";
-  return `${formatTimestamp(entry.timestamp)} ${entry.username} (${entry.userId})${messageId}${quote}${quote ? "" : " "}说：${entry.content}`;
+  return `[${formatTimestamp(entry.timestamp)}] ${entry.username} (${entry.userId})${messageId}${quote}${quote ? "" : " "}说：${entry.content}`;
 }
 __name(formatHistoryEntry, "formatHistoryEntry");
 function formatHistoryEntries(entries) {
@@ -485,7 +589,7 @@ function buildHistoryEntry(session, role = "user") {
   return {
     role,
     userId: role === "assistant" ? session.selfId : session.userId ?? "未知用户",
-    username: role === "assistant" ? "bot" : session.username || session.userId || "用户",
+    username: role === "assistant" ? "你自己的发言" : session.username || session.userId || "用户",
     messageId: session.messageId,
     content,
     timestamp: session.timestamp ?? Date.now(),
@@ -592,73 +696,95 @@ function guildKeyOf(platform, guildId, channelId) {
 }
 __name(guildKeyOf, "guildKeyOf");
 
-// src/trigger/density.ts
-var DensityTracker = class {
-  constructor(onTrigger) {
-    this.onTrigger = onTrigger;
-  }
+// src/trigger/pool.ts
+var POOL_CAPACITY = 1024;
+function scopeSessionOf(pool, entry) {
+  return {
+    platform: pool.platform,
+    selfId: pool.selfId,
+    channelId: pool.channelId,
+    guildId: pool.guildId,
+    userId: entry.userId,
+    isDirect: pool.isDirect
+  };
+}
+__name(scopeSessionOf, "scopeSessionOf");
+var MessagePool = class {
   static {
-    __name(this, "DensityTracker");
+    __name(this, "MessagePool");
+  }
+  channels = /* @__PURE__ */ new Map();
+  /** 一条消息（含 bot 自己的发言）入池，全量记录不做规则过滤 */
+  record(session, entry) {
+    const key = channelKeyOf(session.platform, session.channelId);
+    let pool = this.channels.get(key);
+    if (!pool) {
+      pool = {
+        platform: session.platform,
+        channelId: session.channelId,
+        guildId: session.guildId,
+        selfId: session.selfId,
+        isDirect: session.isDirect,
+        entries: []
+      };
+      this.channels.set(key, pool);
+    }
+    pool.selfId = session.selfId;
+    pool.guildId = session.guildId;
+    pool.isDirect = session.isDirect;
+    pool.entries.push(entry);
+    if (pool.entries.length > POOL_CAPACITY) {
+      pool.entries.splice(0, pool.entries.length - POOL_CAPACITY);
+    }
+  }
+  /** 时效内且通过规则作用域的真人条数（bot 行不推高密度，防自激励） */
+  countQualified(pool, rule, condition, now) {
+    const windowMs = condition.densityWindowSeconds * 1e3;
+    return pool.entries.filter(
+      (item) => item.role === "user" && now - item.timestamp <= windowMs && matchScope(rule.scope, scopeSessionOf(pool, item))
+    ).length;
   }
-  windows = /* @__PURE__ */ new Map();
-  /** 把一条消息计入所有 density 规则的窗口；达到阈值的窗口立即触发 */
-  record(rules, session, entry) {
+  /**
+   * 新消息入池后的密度评估：时效内（相对触发消息）且通过规则作用域的真人条数达到阈值。
+   * 触发即取走并清空该频道全池（bot 行不推高密度，防自激励）；池清空后其余规则无从触发。
+   * skip 返回 true 的条件（冷却中的密度条件）不参与判定。
+   */
+  checkDensity(rules, session, skip) {
+    const key = channelKeyOf(session.platform, session.channelId);
+    const pool = this.channels.get(key);
+    if (!pool) return [];
+    const now = session.timestamp ?? Date.now();
     for (const rule of rules) {
-      for (const condition of rule.conditions) {
+      for (let index = 0; index < rule.conditions.length; index++) {
+        const condition = rule.conditions[index];
         if (condition.type !== "density") continue;
-        const windowMs = condition.densityWindowSeconds * 1e3;
-        const key = `${rule.name}|${channelKeyOf(session.platform, session.channelId)}`;
-        const entries = (this.windows.get(key) ?? []).filter((item) => entry.timestamp - item.timestamp <= windowMs);
-        entries.push(entry);
-        if (entries.length >= condition.densityCount) {
-          this.windows.delete(key);
-          this.onTrigger(rule, session, entries);
-        } else {
-          this.windows.set(key, entries);
+        if (skip?.(rule, condition, index)) continue;
+        if (this.countQualified(pool, rule, condition, now) >= condition.densityCount) {
+          this.channels.delete(key);
+          return [{ rule, condition, conditionIndex: index, entries: pool.entries }];
         }
       }
     }
-  }
-};
-
-// src/trigger/digest.ts
-var MessageDigest = class {
-  static {
-    __name(this, "MessageDigest");
-  }
-  /** ruleName → channelKey → 窗口缓冲 */
-  windows = /* @__PURE__ */ new Map();
-  /** 把一条消息记入所有 schedule 规则（作用域匹配）的窗口 */
-  record(rules, session, entry) {
-    for (const rule of rules) {
-      if (!rule.conditions.some((condition) => condition.type === "schedule")) continue;
-      if (!matchScope(rule.scope, session)) continue;
-      const key = channelKeyOf(session.platform, session.channelId);
-      let channels = this.windows.get(rule.name);
-      if (!channels) {
-        channels = /* @__PURE__ */ new Map();
-        this.windows.set(rule.name, channels);
-      }
-      let digest = channels.get(key);
-      if (!digest) {
-        digest = {
-          platform: session.platform,
-          channelId: session.channelId,
-          guildId: session.guildId,
-          selfId: session.selfId,
-          entries: []
-        };
-        channels.set(key, digest);
-      }
-      digest.entries.push(entry);
+    return [];
+  }
+  /** 冷却到期复查：按条件参数统计该频道池（now 为复查时刻），达标即取走整池，未达标返回 null */
+  takeDensityChannel(rule, condition, channelKey, now) {
+    const pool = this.channels.get(channelKey);
+    if (!pool) return null;
+    if (this.countQualified(pool, rule, condition, now) < condition.densityCount) return null;
+    this.channels.delete(channelKey);
+    return pool;
+  }
+  /** 定时到点：取走该规则作用域内有消息的所有频道（整池清空，含未过作用域的条目） */
+  takeSchedule(rule) {
+    const taken = [];
+    for (const [key, pool] of this.channels) {
+      const matched = pool.entries.some((entry) => matchScope(rule.scope, scopeSessionOf(pool, entry)));
+      if (!matched) continue;
+      taken.push(pool);
+      this.channels.delete(key);
     }
-  }
-  /** 取走规则窗口内的全部非空频道缓冲（并清空该规则的窗口） */
-  take(rule) {
-    const channels = this.windows.get(rule.name);
-    this.windows.delete(rule.name);
-    if (!channels) return [];
-    return [...channels.values()].filter((digest) => digest.entries.length > 0);
+    return taken;
   }
 };
 
@@ -729,30 +855,134 @@ var RuleScheduler = class {
   }
 };
 
+// src/trigger/cooldown.ts
+var BUFFER_CAPACITY = 1024;
+function densityLane(index) {
+  return `density:${index}`;
+}
+__name(densityLane, "densityLane");
+function laneKeyOf(ruleName, lane) {
+  return `${ruleName}
+${lane}`;
+}
+__name(laneKeyOf, "laneKeyOf");
+var TriggerCooldown = class {
+  constructor(setting) {
+    this.setting = setting;
+  }
+  static {
+    __name(this, "TriggerCooldown");
+  }
+  /** channelKey → (规则名+通道 → 冷却态) */
+  channels = /* @__PURE__ */ new Map();
+  get enabled() {
+    return this.setting != null;
+  }
+  /** 触发发起时登记冷却 */
+  begin(channelKey, ruleName, lane, now) {
+    if (!this.setting) return;
+    const ms = this.setting.mode === "fixed" ? this.setting.ms : this.setting.minMs;
+    this.lanesOf(channelKey).set(laneKeyOf(ruleName, lane), {
+      fireAt: now,
+      deadline: now + ms,
+      buffer: []
+    });
+  }
+  isCooling(channelKey, ruleName, lane, now) {
+    const state = this.lanesOf(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;
+    state.deadline = Math.min(
+      Math.max(state.deadline, now + this.setting.minMs),
+      state.fireAt + this.setting.maxMs
+    );
+  }
+  /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动） */
+  extendDensityLanes(channelKey, now) {
+    if (this.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
+      );
+    }
+  }
+  /** 冷却期内缓存一条命中消息（仅消息通道） */
+  bufferMessage(channelKey, ruleName, message) {
+    const state = this.lanesOf(channelKey).get(laneKeyOf(ruleName, "message"));
+    if (!state) return;
+    state.buffer.push(message);
+    if (state.buffer.length > BUFFER_CAPACITY) {
+      state.buffer.splice(0, state.buffer.length - BUFFER_CAPACITY);
+    }
+  }
+  /** 到期扫描：取走全部到期通道（连缓冲一并交出），由调用方决定是否重新登记 */
+  collectExpired(now) {
+    const expired = [];
+    for (const [channelKey, lanes] of this.channels) {
+      for (const [key, state] of lanes) {
+        if (now < state.deadline) continue;
+        const separator = key.indexOf("\n");
+        lanes.delete(key);
+        expired.push({
+          channelKey,
+          ruleName: key.slice(0, separator),
+          lane: key.slice(separator + 1),
+          buffer: state.buffer
+        });
+      }
+      if (!lanes.size) this.channels.delete(channelKey);
+    }
+    return expired;
+  }
+  lanesOf(channelKey) {
+    let lanes = this.channels.get(channelKey);
+    if (!lanes) {
+      lanes = /* @__PURE__ */ new Map();
+      this.channels.set(channelKey, lanes);
+    }
+    return lanes;
+  }
+};
+
 // src/trigger/engine.ts
 var SCHEDULER_TICK_MS = 1e3;
 var TriggerEngine = class {
-  constructor(ctx, runner, history, rules) {
+  constructor(ctx, runner, history, rules, cooldown) {
     this.ctx = ctx;
     this.runner = runner;
     this.history = history;
     this.rules = rules;
     this.scheduler = new RuleScheduler(ctx, (rule) => this.fireSchedule(rule));
-    this.density = new DensityTracker((rule, session, entries) => this.fireDensity(rule, session, entries));
-    this.digest = new MessageDigest();
+    this.pool = new MessagePool();
+    this.cooldown = new TriggerCooldown(cooldown);
   }
   static {
     __name(this, "TriggerEngine");
   }
   scheduler;
-  density;
-  digest;
+  pool;
+  cooldown;
   start() {
     this.ctx.middleware((session, next) => this.handleMessage(session, next));
-    this.ctx.setInterval(() => this.scheduler.tick(), SCHEDULER_TICK_MS);
+    this.ctx.setInterval(() => {
+      this.scheduler.tick();
+      this.tickCooldown();
+    }, SCHEDULER_TICK_MS);
     this.ctx.on("send", (session) => {
       const entry = session.channelId ? buildHistoryEntry(session, "assistant") : null;
-      if (entry) this.history.recordEntry(channelKeyOf(session.platform, session.channelId), entry);
+      if (!entry) return;
+      const key = channelKeyOf(session.platform, session.channelId);
+      this.history.recordEntry(key, entry);
+      this.pool.record(session, entry);
     });
     this.scheduler.sync(this.rules);
     this.ctx.logger.info("已加载 %d 条启用规则", this.rules.length);
@@ -760,16 +990,34 @@ var TriggerEngine = class {
   handleMessage(session, next) {
     if (this.ctx.bots[session.uid]) return next();
     if (!session.channelId) return next();
+    const channelKey = channelKeyOf(session.platform, session.channelId);
     const entry = buildHistoryEntry(session);
     if (entry) {
-      this.history.recordEntry(channelKeyOf(session.platform, session.channelId), entry);
-      this.density.record(this.rules, session, entry);
-      this.digest.record(this.rules, session, entry);
+      this.history.recordEntry(channelKey, entry);
+      this.pool.record(session, entry);
+      const now = session.timestamp ?? Date.now();
+      this.cooldown.extendDensityLanes(channelKey, now);
+      for (const fire of this.pool.checkDensity(
+        this.rules,
+        session,
+        (rule, _condition, index) => this.cooldown.isCooling(channelKey, rule.name, densityLane(index), now)
+      )) {
+        this.fireDensity(fire, session);
+      }
     }
     return next(async (nextMiddleware) => {
       const matched = this.matchRule(session);
       if (!matched) return nextMiddleware();
-      this.fireMessage(matched.rule, session, matched.condition);
+      if (this.cooldown.isCooling(channelKey, matched.rule.name, "message", Date.now())) {
+        this.cooldown.bufferMessage(channelKey, matched.rule.name, {
+          session,
+          entry,
+          contentText: matched.condition.queryText
+        });
+        this.cooldown.extend(channelKey, matched.rule.name, "message", Date.now());
+        return;
+      }
+      this.fireMessage(matched.rule, session, matched.condition, entry);
     });
   }
   matchRule(session) {
@@ -787,7 +1035,12 @@ var TriggerEngine = class {
   run(fireCtx) {
     void this.runner.run(fireCtx).catch((error) => this.ctx.logger.warn(error));
   }
-  fireMessage(rule, session, condition) {
+  /** 登记冷却（定时触发不调用；冷却关闭时零开销直退） */
+  beginCooldown(channelKey, ruleName, lane) {
+    this.cooldown.begin(channelKey, ruleName, lane, Date.now());
+  }
+  fireMessage(rule, session, condition, entry) {
+    this.beginCooldown(channelKeyOf(session.platform, session.channelId), rule.name, "message");
     this.run({
       session,
       platform: session.platform,
@@ -797,10 +1050,14 @@ var TriggerEngine = class {
       userId: session.userId,
       triggerType: condition.type,
       rule,
-      queryText: condition.queryText
+      // query 为该条消息的统一格式单行；纯 @ / 纯引用等无文本消息 entry 为空，由请求器占位兜底
+      queryText: entry ? formatHistoryEntry(entry) : "",
+      contentText: condition.queryText
     });
   }
-  fireDensity(rule, session, entries) {
+  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,
@@ -809,16 +1066,52 @@ var TriggerEngine = class {
       guildId: session.guildId ?? session.channelId,
       userId: session.userId,
       triggerType: "density",
+      rule: fire.rule,
+      queryText: windowText,
+      contentText: windowText
+    });
+  }
+  /** 冷却到期：把缓冲内的触发消息合并为一次触发，session 取首条（供投递与文件上传） */
+  fireMerged(rule, buffer) {
+    const first = buffer[0];
+    const queryText = buffer.map((item) => item.entry ? formatHistoryEntry(item.entry) : "").filter(Boolean).join("\n");
+    const contentText = buffer.map((item) => item.contentText).filter(Boolean).join("\n");
+    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,
+      triggerType: "merged",
       rule,
-      queryText: formatHistoryEntries(entries)
+      queryText,
+      contentText
+    });
+  }
+  /** 密度冷却到期复查达标：无当前消息，用池身份构造上下文（投递同定时路径） */
+  fireDensityExpiry(rule, conditionIndex, channel) {
+    this.beginCooldown(channelKeyOf(channel.platform, channel.channelId), rule.name, densityLane(conditionIndex));
+    const windowText = formatHistoryEntries(channel.entries);
+    this.run({
+      platform: channel.platform,
+      selfId: channel.selfId,
+      channelId: channel.channelId,
+      guildId: channel.guildId,
+      triggerType: "density",
+      rule,
+      queryText: windowText,
+      contentText: windowText
     });
   }
   /**
-   * 定时触发（消息摘要）：把窗口内有消息的每个频道各发一次请求。
-   * 频道身份取自窗口缓冲里记录的真实消息；窗口空（无消息）自然跳过。
+   * 定时触发（消息摘要）：把消息池内该规则作用域有消息的每个频道各发一次请求（取走即清空全池）。
+   * 频道身份取自池内最近一条消息；无消息的频道自然跳过。定时不受冷却影响。
    */
   fireSchedule(rule) {
-    for (const channel of this.digest.take(rule)) {
+    for (const channel of this.pool.takeSchedule(rule)) {
+      const windowText = formatHistoryEntries(channel.entries);
       this.run({
         platform: channel.platform,
         selfId: channel.selfId,
@@ -826,12 +1119,40 @@ var TriggerEngine = class {
         guildId: channel.guildId,
         triggerType: "schedule",
         rule,
-        queryText: channel.entries.map((entry) => `${entry.username}: ${entry.content}`).join("\n")
+        queryText: windowText,
+        contentText: windowText
       });
     }
   }
+  /** 每秒扫描冷却到期：消息通道合并触发，密度通道复查池 */
+  tickCooldown() {
+    if (!this.cooldown.enabled) return;
+    const now = Date.now();
+    for (const expired of this.cooldown.collectExpired(now)) {
+      this.onCooldownExpired(expired, now);
+    }
+  }
+  onCooldownExpired(expired, now) {
+    const rule = this.rules.find((item) => item.name === expired.ruleName);
+    if (!rule) return;
+    if (expired.lane === "message") {
+      if (expired.buffer.length) this.fireMerged(rule, expired.buffer);
+      return;
+    }
+    const index = Number(expired.lane.slice("density:".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);
+  }
 };
 
+// src/types.ts
+function isMessageTrigger(type) {
+  return type !== "schedule" && type !== "density";
+}
+__name(isMessageTrigger, "isMessageTrigger");
+
 // src/requester/files.ts
 var import_promises = require("fs/promises");
 var import_fs = require("fs");
@@ -965,19 +1286,19 @@ function resolveFileType(mimeType, elementType) {
   return mime === "custom" && elementType !== "custom" ? elementType : mime;
 }
 __name(resolveFileType, "resolveFileType");
-async function uploadOne(ctx, client, candidate, difyUser) {
+async function uploadOne(ctx, client, candidate, difyUser, limit) {
   try {
     const payload = await resolveFilePayload(ctx, candidate);
     if (!payload) return null;
     const type = resolveFileType(payload.mimeType, candidate.type);
-    const limit = SIZE_LIMITS[type];
-    if (payload.buffer.length > limit) {
+    const maxBytes = limit.maxSizeMb > 0 ? limit.maxSizeMb * MB : Infinity;
+    const sizeLimit = Math.min(SIZE_LIMITS[type], maxBytes);
+    if (payload.buffer.length > sizeLimit) {
       ctx.logger.warn(
-        "文件 %s (%dMB) 超过 %s 类型上限 %dMB，跳过",
+        "文件 %s (%dMB) 超过上限 %dMB，跳过",
         payload.fileName,
         Math.round(payload.buffer.length / MB),
-        type,
-        Math.round(limit / MB)
+        Math.round(sizeLimit / MB)
       );
       return null;
     }
@@ -992,14 +1313,17 @@ async function uploadOne(ctx, client, candidate, difyUser) {
   }
 }
 __name(uploadOne, "uploadOne");
-async function uploadMessageFiles(ctx, client, session, difyUser) {
+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);
   const files = [];
-  for (const candidate of candidates) {
-    const uploaded = await uploadOne(ctx, client, candidate, difyUser);
+  for (const candidate of limited) {
+    const uploaded = await uploadOne(ctx, client, candidate, difyUser, limit);
     if (uploaded) files.push(uploaded);
+    else dropped.push(candidate.source);
   }
-  return files;
+  return { files, dropped };
 }
 __name(uploadMessageFiles, "uploadMessageFiles");
 
@@ -1020,7 +1344,7 @@ function resolveSessionField(key, fireCtx, now) {
     case "messageId":
       return session?.messageId ?? "";
     case "content":
-      return fireCtx.queryText;
+      return fireCtx.contentText;
     case "quoteContent":
       return parseTextSafe(session?.quote?.content);
     case "quoteAuthorId":
@@ -1055,6 +1379,8 @@ function resolveSource(source, fireCtx, history, now) {
       return resolveSessionField(source.key, fireCtx, now);
     case "meta":
       return resolveMetaField(source.key, fireCtx, now);
+    case "constant":
+      return source.value;
     case "history": {
       const channelKey = channelKeyOf(fireCtx.platform, fireCtx.channelId);
       const limit = source.limit ?? history.limit;
@@ -1113,7 +1439,7 @@ function renderReply(input) {
   const segments = splitText(input.text, input.config.maxSegmentLength ?? 0);
   segments.forEach((segment, index) => {
     const elements = [];
-    if (index === 0 && input.config.quoteTrigger && input.quoteMessageId) {
+    if (index === 0 && input.quoteMessageId) {
       elements.push(import_koishi3.h.quote(input.quoteMessageId));
     }
     if (input.config.parseElements) {
@@ -1138,7 +1464,7 @@ function errorMessage(error) {
 __name(errorMessage, "errorMessage");
 
 // src/requester/runner.ts
-var FALLBACK_QUERY = "（本次由系统触发，请参考变量中的上下文）";
+var FALLBACK_QUERY = "（本次触发无文本内容，请参考变量中的上下文）";
 var SUCCESS_STATUSES = ["succeeded", "partial-succeeded"];
 var FALLBACK_APP_TYPE = "chat";
 function isFileObject(value) {
@@ -1192,6 +1518,7 @@ var RequestRunner = class {
     return app.appType !== "auto" ? app.appType : this.appTypes.get(app.name) ?? FALLBACK_APP_TYPE;
   }
   async run(fireCtx) {
+    const startedAt = Date.now();
     const { rule } = fireCtx;
     const app = this.apps.get(rule.app);
     if (!app) {
@@ -1206,8 +1533,19 @@ var RequestRunner = class {
       inputs: resolveVariables(rule, fireCtx, this.history),
       uploadedFiles: []
     };
-    if (this.config.uploadFiles !== false && fireCtx.session) {
-      requestCtx.uploadedFiles = await uploadMessageFiles(this.ctx, client, fireCtx.session, requestCtx.difyUser);
+    const upload = resolveUploadConfig(this.config);
+    if (upload.enabled && fireCtx.session) {
+      const { files, dropped } = await uploadMessageFiles(
+        this.ctx,
+        client,
+        fireCtx.session,
+        requestCtx.difyUser,
+        { maxCount: upload.maxCount, maxSizeMb: upload.maxMb }
+      );
+      requestCtx.uploadedFiles = files;
+      if (dropped.length) {
+        fireCtx.queryText = annotateDroppedPlaceholders(fireCtx.queryText, dropped);
+      }
     }
     let reply;
     try {
@@ -1224,10 +1562,13 @@ 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: fireCtx.session?.messageId,
+      quoteMessageId: shouldQuote ? fireCtx.session?.messageId : void 0,
       config: this.config
     });
     await this.deliver(fireCtx, messages);
@@ -1431,12 +1772,12 @@ function apply(ctx, config) {
   ctx.i18n.define("zh-CN", zh_CN_default);
   ctx.i18n.define("en-US", en_US_default);
   defineTables(ctx);
-  const { apps, rules } = normalizeConfig(config);
+  const { apps, rules, cooldown } = normalizeConfig(config);
   const appTypes = /* @__PURE__ */ new Map();
   const history = new MessageHistory(config.historyLimit);
   const conversationStore = new ConversationStore(ctx, apps);
   const runner = new RequestRunner(ctx, config, conversationStore, history, apps, appTypes);
-  const engine = new TriggerEngine(ctx, runner, history, rules);
+  const engine = new TriggerEngine(ctx, runner, history, rules, cooldown);
   ctx.on("ready", async () => {
     await probeAppTypes(ctx, config, apps, appTypes);
     engine.start();

package/lib/requester/files.d.ts

@@ -17,6 +17,16 @@ export declare function mimeToFileType(mimeType?: string): DifyFileType;
 export declare function extractFileCandidates(session: Session): FileCandidate[];
 /** 三源归一：data URL / 远程 URL / 本地路径 → {buffer, fileName, mimeType}（冒烟测试直测） */
 export declare function resolveFilePayload(ctx: Context, candidate: FileCandidate): Promise<FilePayload | null>;
-/** 提取并上传消息中的文件，返回可附加到请求体的 files 数组 */
-export declare function uploadMessageFiles(ctx: Context, client: DifyClient, session: Session, difyUser: string): Promise<DifyInputFileObject[]>;
+/** 上传数量与单文件大小限制（0 不限；大小与 Dify 各类型上限取较小值） */
+export interface UploadLimit {
+    maxCount: number;
+    maxSizeMb: number;
+}
+/** 一次上传的产物：成功的 files 载荷 + 被丢弃候选的来源 URL（截断/超限/失败统一记录，供占位符注记） */
+export interface UploadResult {
+    files: DifyInputFileObject[];
+    dropped: string[];
+}
+/** 提取并上传消息中的文件（先按数量上限截断候选，再逐个上传） */
+export declare function uploadMessageFiles(ctx: Context, client: DifyClient, session: Session, difyUser: string, limit: UploadLimit): Promise<UploadResult>;
 export {};

package/lib/requester/render.d.ts

@@ -4,6 +4,7 @@ import { DifyFilePayload } from '../api/types';
 export interface RenderInput {
     text: string;
     files: DifyFilePayload[];
+    /** 引用哪条消息；调用方完成开关与耗时判定，未达标传空即不引用 */
     quoteMessageId?: string;
     /** 回复行为配置（koishi schema「回复行为」组） */
     config: Config;

package/lib/trigger/conditions.d.ts

@@ -2,7 +2,7 @@ import { Session } from 'koishi';
 import { MessageTriggerType, TriggerCondition, TriggerScope } from '../types';
 export interface ConditionMatched {
     type: MessageTriggerType;
-    /** 触发后用作 Dify query / content 变量的文本（已去掉触发词与 @ 前缀） */
+    /** 触发后用作 content 变量的剥离文本（query 由引擎按统一消息格式另行构造） */
     queryText: string;
 }
 /** 评估单个消息条件；返回 null 表示未命中 */

package/lib/trigger/cooldown.d.ts

@@ -0,0 +1,46 @@
+import { Session } from 'koishi';
+import { CooldownSetting } from '../types';
+import { HistoryEntry } from '../history';
+/** 冷却期内缓存的一条触发消息（entry 供统一格式渲染，纯 @ 等无文本消息为空） */
+export interface PendingMessage {
+    session: Session;
+    entry: HistoryEntry | null;
+    /** 该条消息命中条件时剥离出的文本（contentText 用） */
+    contentText: string;
+}
+/** 冷却通道：message = 规则内全部消息类条件共享；density:N = 第 N 个密度条件独立 */
+export type CooldownLane = 'message' | `density:${number}`;
+/** 密度条件的通道名 */
+export declare function densityLane(index: number): CooldownLane;
+/** 到期扫描交出的通道产物 */
+export interface ExpiredCooldown {
+    channelKey: string;
+    ruleName: string;
+    lane: CooldownLane;
+    buffer: PendingMessage[];
+}
+/**
+ * 触发后冷却：从触发发起时刻计时（请求耗时计入冷却）。
+ * 消息通道冷却期内命中消息进缓冲并顺延滑动窗口，到期合并为一次触发；
+ * 密度通道冷却期即积攒期（池照常记录），全部过路消息顺延，到期复查达标才触发。
+ * 定时触发不参与冷却。配置关闭时所有方法零开销直退。
+ */
+export declare class TriggerCooldown {
+    private setting;
+    /** channelKey → (规则名+通道 → 冷却态) */
+    private channels;
+    constructor(setting: CooldownSetting | null);
+    get enabled(): boolean;
+    /** 触发发起时登记冷却 */
+    begin(channelKey: string, ruleName: string, lane: CooldownLane, now: number): void;
+    isCooling(channelKey: string, ruleName: string, lane: CooldownLane, now: number): boolean;
+    /** 滑动窗口顺延：截止时间顺延到「now + 最小窗口」，不超过「触发时刻 + 最大窗口」 */
+    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[];
+    private lanesOf;
+}

package/lib/trigger/engine.d.ts

@@ -1,5 +1,5 @@
 import { Context } from 'koishi';
-import { DifyRule } from '../types';
+import { CooldownSetting, DifyRule } from '../types';
 import { MessageHistory } from '../history';
 import { RequestRunner } from '../requester/runner';
 /**
@@ -12,19 +12,28 @@ export declare class TriggerEngine {
     private history;
     private rules;
     private scheduler;
-    private density;
-    private digest;
-    constructor(ctx: Context, runner: RequestRunner, history: MessageHistory, rules: DifyRule[]);
+    private pool;
+    private cooldown;
+    constructor(ctx: Context, runner: RequestRunner, history: MessageHistory, rules: DifyRule[], cooldown: CooldownSetting | null);
     start(): void;
     private handleMessage;
     private matchRule;
     /** 异步执行一次请求；错误由请求器与这里的兜底记录 */
     private run;
+    /** 登记冷却（定时触发不调用；冷却关闭时零开销直退） */
+    private beginCooldown;
     private fireMessage;
     private fireDensity;
+    /** 冷却到期：把缓冲内的触发消息合并为一次触发，session 取首条（供投递与文件上传） */
+    private fireMerged;
+    /** 密度冷却到期复查达标：无当前消息，用池身份构造上下文（投递同定时路径） */
+    private fireDensityExpiry;
     /**
-     * 定时触发（消息摘要）：把窗口内有消息的每个频道各发一次请求。
-     * 频道身份取自窗口缓冲里记录的真实消息；窗口空（无消息）自然跳过。
+     * 定时触发（消息摘要）：把消息池内该规则作用域有消息的每个频道各发一次请求（取走即清空全池）。
+     * 频道身份取自池内最近一条消息；无消息的频道自然跳过。定时不受冷却影响。
      */
     private fireSchedule;
+    /** 每秒扫描冷却到期：消息通道合并触发，密度通道复查池 */
+    private tickCooldown;
+    private onCooldownExpired;
 }

package/lib/trigger/pool.d.ts

@@ -0,0 +1,43 @@
+import { Session } from 'koishi';
+import { DensityCondition, DifyRule } from '../types';
+import { HistoryEntry } from '../history';
+/** 一个频道的缓冲池：密度与定时共用，谁先触发谁取走清空 */
+export interface ChannelPool {
+    platform: string;
+    channelId: string;
+    guildId?: string;
+    /** 定时投递凭据，跟随最近一条消息的 bot */
+    selfId: string;
+    isDirect?: boolean;
+    entries: HistoryEntry[];
+}
+export interface DensityFire {
+    rule: DifyRule;
+    /** 命中的密度条件与其在规则内的下标（密度冷却通道键） */
+    condition: DensityCondition;
+    conditionIndex: number;
+    /** 触发时取走的该频道全池消息（含 bot 行与时效外条目） */
+    entries: HistoryEntry[];
+}
+/**
+ * 频道消息池：密度与定时触发共用的缓冲层。
+ * 密度只作触发依据（时效内真人条数达阈值），触发即取走全池；
+ * 定时到点取走作用域内有消息的频道全池——两者天然互相清空、重新积累。
+ */
+export declare class MessagePool {
+    private channels;
+    /** 一条消息（含 bot 自己的发言）入池，全量记录不做规则过滤 */
+    record(session: Session, entry: HistoryEntry): void;
+    /** 时效内且通过规则作用域的真人条数（bot 行不推高密度，防自激励） */
+    private countQualified;
+    /**
+     * 新消息入池后的密度评估：时效内（相对触发消息）且通过规则作用域的真人条数达到阈值。
+     * 触发即取走并清空该频道全池（bot 行不推高密度，防自激励）；池清空后其余规则无从触发。
+     * skip 返回 true 的条件（冷却中的密度条件）不参与判定。
+     */
+    checkDensity(rules: DifyRule[], session: Session, skip?: (rule: DifyRule, condition: DensityCondition, index: number) => boolean): DensityFire[];
+    /** 冷却到期复查：按条件参数统计该频道池（now 为复查时刻），达标即取走整池，未达标返回 null */
+    takeDensityChannel(rule: DifyRule, condition: DensityCondition, channelKey: string, now: number): ChannelPool | null;
+    /** 定时到点：取走该规则作用域内有消息的所有频道（整池清空，含未过作用域的条目） */
+    takeSchedule(rule: DifyRule): ChannelPool[];
+}

package/lib/types.d.ts

@@ -1,9 +1,11 @@
 import type { Session } from 'koishi';
-/** 消息驱动的触发原因 */
-export type MessageTriggerType = 'keyword-prefix' | 'keyword-contains' | 'at-bot' | 'at-user' | 'quote-bot' | 'quote-user';
+/** 消息驱动的触发原因（merged = 冷却期内多条触发消息合并为一次触发） */
+export type MessageTriggerType = 'keyword-prefix' | 'keyword-contains' | 'at-bot' | 'at-user' | 'quote-bot' | 'quote-user' | 'merged';
 /** 非消息驱动的触发原因 */
 export type ProactiveTriggerType = 'schedule' | 'density';
 export type TriggerType = MessageTriggerType | ProactiveTriggerType;
+/** 是否由消息触发（合并触发也算）：定时与密度触发没有单一触发消息 */
+export declare function isMessageTrigger(type: TriggerType): boolean;
 /** 关键词条件（prefix 触发时剥离关键词作为 query，contains 保留全文） */
 export interface KeywordCondition {
     type: 'keyword-prefix' | 'keyword-contains';
@@ -63,6 +65,9 @@ export type VariableSource = {
 } | {
     type: 'meta';
     key: MetaField;
+} | {
+    type: 'constant';
+    value: string;
 };
 /** 一条变量映射：Dify inputs 字段名 ← 来源 */
 export interface VariableBinding {
@@ -71,6 +76,15 @@ export interface VariableBinding {
 }
 /** Dify 会话绑定粒度 */
 export type ConversationScope = 'per-user' | 'per-guild' | 'per-channel' | 'global';
+/** 触发后冷却设置（schema 规范化后的内部形态；null 表示关闭） */
+export type CooldownSetting = {
+    mode: 'fixed';
+    ms: number;
+} | {
+    mode: 'sliding';
+    minMs: number;
+    maxMs: number;
+};
 /** 触发规则（配置页 schema 规范化后的内部形态；身份即 name，按优先级降序排列） */
 export interface DifyRule {
     name: string;
@@ -94,6 +108,8 @@ export interface FireContext {
     userId?: string;
     triggerType: TriggerType;
     rule: DifyRule;
-    /** 作为 Dify query / content 变量的文本（已去掉触发词与 @ 前缀） */
+    /** 发给 Dify 的 query：统一消息格式（消息触发为单行，窗口触发为逐行拼接） */
     queryText: string;
+    /** content 变量的值：消息触发为剥离文本，窗口触发为统一格式拼接 */
+    contentText: string;
 }

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

@@ -12,10 +12,14 @@ interface ExtractTextOptions {
 }
 /** 会话消息纯文本：优先 elements，退回 content 解析；统一 trim */
 export declare function extractText(session: Session, options?: ExtractTextOptions): string;
-/** 消息中的图片元素在文本形态里的占位符 */
+/** 消息中的图片元素在文本形态里的占位符（图片无 URL 时的兜底形态） */
 export declare const IMAGE_PLACEHOLDER = "[\u56FE\u7247]";
+/** 图片占位符带 URL 摘要前 8 位：同 URL 同标识，query 里的占位符与上传文件可全局对应 */
+export declare function imagePlaceholder(url?: string): string;
+/** 给被丢弃图片的占位符追加已丢弃注记：按 URL 摘要全局定位，无需与元素顺序对齐 */
+export declare function annotateDroppedPlaceholders(text: string, droppedUrls: string[]): string;
 /**
- * 带媒体占位符的消息文本：text 元素按序拼接，img/image 元素渲染为 [图片]，
+ * 带媒体占位符的消息文本：text 元素按序拼接，img/image 元素渲染为 [image:URL摘要]，
  * 供聊天记录呈现（历史消息变量 / 定时摘要 / 密度触发共用）。
  */
 export declare function extractTextWithPlaceholders(session: Session): string;

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.3",
+  "version": "0.1.5",
   "author": "PinkElysia",
   "license": "MIT",
   "homepage": "https://github.com/PinkElysiaDev/dify-ai-plugin-for-Koishi#readme",

package/readme.md

@@ -4,7 +4,7 @@
 
 ## 特性
 
-- **8 种触发条件**：关键词开头 / 包含关键词 / @ 机器人 / @ 指定用户 / 引用机器人 / 引用指定用户 / 定时摘要（Cron 或固定间隔，把窗口内的群消息合并请求一次，无消息则跳过）/ 消息密度，同一规则多条件任一命中即触发
+- **8 种触发条件**：关键词开头 / 包含关键词 / @ 机器人 / @ 指定用户 / 引用机器人 / 引用指定用户 / 定时摘要（Cron 或固定间隔，把消息池内积攒的群消息合并请求一次，无消息则跳过）/ 消息密度（池内消息达到阈值即触发；两种触发共用消息池，谁先触发谁清空），同一规则多条件任一命中即触发
 - **多应用多规则**：规则按优先级匹配，按平台 / Bot / 群聊 / 频道 / 用户限定作用域
 - **会话绑定**：按群聊 / 用户 / 频道 / 全局粒度续接 Dify 会话，`dify.conv.reset` 可重置
 - **变量系统**：把会话字段、历史消息、触发元信息映射为 Dify inputs

package/lib/trigger/density.d.ts

@@ -1,15 +0,0 @@
-import { Session } from 'koishi';
-import { DifyRule } from '../types';
-import { HistoryEntry } from '../history';
-/**
- * 消息密度触发：按 (规则, 频道) 维护滑动窗口内的消息，
- * 窗口内条数达到阈值即回调触发，并把窗口内这些消息交给触发方作 query 上下文。
- * 触发后清空窗口，需重新积累即天然防连发。
- */
-export declare class DensityTracker {
-    private onTrigger;
-    private windows;
-    constructor(onTrigger: (rule: DifyRule, session: Session, entries: HistoryEntry[]) => void);
-    /** 把一条消息计入所有 density 规则的窗口；达到阈值的窗口立即触发 */
-    record(rules: DifyRule[], session: Session, entry: HistoryEntry): void;
-}

package/lib/trigger/digest.d.ts

@@ -1,26 +0,0 @@
-import { Session } from 'koishi';
-import { DifyRule } from '../types';
-import { HistoryEntry } from '../history';
-/** 一个频道的定时窗口缓冲：身份字段取自该频道最近一条被记录的消息 */
-export interface ChannelDigest {
-    platform: string;
-    channelId: string;
-    guildId?: string;
-    selfId: string;
-    entries: HistoryEntry[];
-}
-/**
- * 定时触发的消息窗口收集器。
- *
- * 定时规则是「消息摘要」模型：持续收集作用域内各频道的消息，
- * 到点（cron/间隔）把每个频道窗口内的消息合并为一次 Dify 请求，窗口空则跳过。
- * take() 取走即清空——窗口即「上次触发至今」；规则各自独立缓冲，互不干扰。
- */
-export declare class MessageDigest {
-    /** ruleName → channelKey → 窗口缓冲 */
-    private windows;
-    /** 把一条消息记入所有 schedule 规则（作用域匹配）的窗口 */
-    record(rules: DifyRule[], session: Session, entry: HistoryEntry): void;
-    /** 取走规则窗口内的全部非空频道缓冲（并清空该规则的窗口） */
-    take(rule: DifyRule): ChannelDigest[];
-}