koishi-plugin-dify-ai 0.1.2 → 0.1.4

package/lib/config.d.ts

@@ -35,11 +35,14 @@ export type ConditionEntry = {
     densityCount?: number;
     densityWindowSeconds?: number;
 };
-/** 变量映射的条件分支形态：先选来源分支，再填该分支的字段（历史消息是会话字段下的一项） */
+/** 变量映射的条件分支形态：先选来源分支，再填该分支的字段（历史消息是独立分支） */
 export type VariableEntry = {
     source: 'session';
     field: string;
     key: string;
+} | {
+    source: 'history';
+    field: string;
     limit?: number;
 } | {
     source: 'meta';

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

@@ -103,8 +103,7 @@ 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("triggerType").description("触发类型"),
@@ -112,20 +111,16 @@ var metaKeySchema = import_koishi.Schema.union([
   import_koishi.Schema.const("triggerTime").description("触发时间")
 ]);
 var variableSchema = import_koishi.Schema.union([
-  import_koishi.Schema.intersect([
-    import_koishi.Schema.object({
-      source: import_koishi.Schema.const("session").required(),
-      field: import_koishi.Schema.string().required().description("字段名"),
-      key: sessionKeySchema.default("content").description("变量")
-    }),
-    import_koishi.Schema.union([
-      import_koishi.Schema.object({
-        key: import_koishi.Schema.const("history").required(),
-        limit: import_koishi.Schema.natural().default(0).min(0).max(100).description("条数，0 用全局")
-      }).default({ key: "history", limit: 0 }),
-      import_koishi.Schema.object({})
-    ])
-  ]).default({ source: "session", field: "", key: "content" }).description("会话字段"),
+  import_koishi.Schema.object({
+    source: import_koishi.Schema.const("session").required(),
+    field: import_koishi.Schema.string().required().description("字段名"),
+    key: sessionKeySchema.default("content").description("变量")
+  }).default({ source: "session", field: "", key: "content" }).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("字段名"),
@@ -277,10 +272,11 @@ function toVariable(entry) {
   if (entry.source === "meta") {
     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 === "history") return null;
   return { field, source: { type: "session", key: entry.key || "content" } };
 }
 __name(toVariable, "toVariable");
@@ -467,9 +463,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) {
@@ -493,7 +489,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(),
@@ -600,73 +596,81 @@ 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 = 256;
+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);
+    }
   }
-  windows = /* @__PURE__ */ new Map();
-  /** 把一条消息计入所有 density 规则的窗口；达到阈值的窗口立即触发 */
-  record(rules, session, entry) {
+  /**
+   * 新消息入池后的密度评估：时效内（相对触发消息）且通过规则作用域的真人条数达到阈值。
+   * 触发即取走并清空该频道全池（bot 行不推高密度，防自激励）；池清空后其余规则无从触发。
+   */
+  checkDensity(rules, session) {
+    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) {
         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);
+        const count = pool.entries.filter(
+          (item) => item.role === "user" && now - item.timestamp <= windowMs && matchScope(rule.scope, scopeSessionOf(pool, item))
+        ).length;
+        if (count >= condition.densityCount) {
+          this.channels.delete(key);
+          return [{ rule, 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 [];
+  }
+  /** 定时到点：取走该规则作用域内有消息的所有频道（整池清空，含未过作用域的条目） */
+  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;
   }
 };
 
@@ -746,21 +750,22 @@ var TriggerEngine = class {
     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();
   }
   static {
     __name(this, "TriggerEngine");
   }
   scheduler;
-  density;
-  digest;
+  pool;
   start() {
     this.ctx.middleware((session, next) => this.handleMessage(session, next));
     this.ctx.setInterval(() => this.scheduler.tick(), 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);
@@ -771,13 +776,15 @@ var TriggerEngine = class {
     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.pool.record(session, entry);
+      for (const fire of this.pool.checkDensity(this.rules, session)) {
+        this.fireDensity(fire.rule, session, fire.entries);
+      }
     }
     return next(async (nextMiddleware) => {
       const matched = this.matchRule(session);
       if (!matched) return nextMiddleware();
-      this.fireMessage(matched.rule, session, matched.condition);
+      this.fireMessage(matched.rule, session, matched.condition, entry);
     });
   }
   matchRule(session) {
@@ -795,7 +802,7 @@ var TriggerEngine = class {
   run(fireCtx) {
     void this.runner.run(fireCtx).catch((error) => this.ctx.logger.warn(error));
   }
-  fireMessage(rule, session, condition) {
+  fireMessage(rule, session, condition, entry) {
     this.run({
       session,
       platform: session.platform,
@@ -805,10 +812,13 @@ 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) {
+    const windowText = formatHistoryEntries(entries);
     this.run({
       session,
       platform: session.platform,
@@ -818,15 +828,17 @@ var TriggerEngine = class {
       userId: session.userId,
       triggerType: "density",
       rule,
-      queryText: formatHistoryEntries(entries)
+      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,
@@ -834,7 +846,8 @@ var TriggerEngine = class {
         guildId: channel.guildId,
         triggerType: "schedule",
         rule,
-        queryText: channel.entries.map((entry) => `${entry.username}: ${entry.content}`).join("\n")
+        queryText: windowText,
+        contentText: windowText
       });
     }
   }
@@ -1028,7 +1041,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":
@@ -1146,7 +1159,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) {

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/engine.d.ts

@@ -12,8 +12,7 @@ export declare class TriggerEngine {
     private history;
     private rules;
     private scheduler;
-    private density;
-    private digest;
+    private pool;
     constructor(ctx: Context, runner: RequestRunner, history: MessageHistory, rules: DifyRule[]);
     start(): void;
     private handleMessage;
@@ -23,8 +22,8 @@ export declare class TriggerEngine {
     private fireMessage;
     private fireDensity;
     /**
-     * 定时触发（消息摘要）：把窗口内有消息的每个频道各发一次请求。
-     * 频道身份取自窗口缓冲里记录的真实消息；窗口空（无消息）自然跳过。
+     * 定时触发（消息摘要）：把消息池内该规则作用域有消息的每个频道各发一次请求（取走即清空全池）。
+     * 频道身份取自池内最近一条消息；无消息的频道自然跳过。
      */
     private fireSchedule;
 }

package/lib/trigger/pool.d.ts

@@ -0,0 +1,35 @@
+import { Session } from 'koishi';
+import { 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;
+    /** 触发时取走的该频道全池消息（含 bot 行与时效外条目） */
+    entries: HistoryEntry[];
+}
+/**
+ * 频道消息池：密度与定时触发共用的缓冲层。
+ * 密度只作触发依据（时效内真人条数达阈值），触发即取走全池；
+ * 定时到点取走作用域内有消息的频道全池——两者天然互相清空、重新积累。
+ */
+export declare class MessagePool {
+    private channels;
+    /** 一条消息（含 bot 自己的发言）入池，全量记录不做规则过滤 */
+    record(session: Session, entry: HistoryEntry): void;
+    /**
+     * 新消息入池后的密度评估：时效内（相对触发消息）且通过规则作用域的真人条数达到阈值。
+     * 触发即取走并清空该频道全池（bot 行不推高密度，防自激励）；池清空后其余规则无从触发。
+     */
+    checkDensity(rules: DifyRule[], session: Session): DensityFire[];
+    /** 定时到点：取走该规则作用域内有消息的所有频道（整池清空，含未过作用域的条目） */
+    takeSchedule(rule: DifyRule): ChannelPool[];
+}

package/lib/types.d.ts

@@ -94,6 +94,8 @@ export interface FireContext {
     userId?: string;
     triggerType: TriggerType;
     rule: DifyRule;
-    /** 作为 Dify query / content 变量的文本（已去掉触发词与 @ 前缀） */
+    /** 发给 Dify 的 query：统一消息格式（消息触发为单行，窗口触发为逐行拼接） */
     queryText: string;
+    /** content 变量的值：消息触发为剥离文本，窗口触发为统一格式拼接 */
+    contentText: 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.2",
+  "version": "0.1.4",
   "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/commands/app.d.ts

@@ -1,4 +0,0 @@
-import { Command, Context } from 'koishi';
-import { RequestRunner } from '../requester/runner';
-/** dify.app.* 管理命令（authority 3；koishi 子命令不继承父命令权限，需各自声明） */
-export declare function registerAppCommands(parent: Command, ctx: Context, runner: RequestRunner): void;

package/lib/commands/rule.d.ts

@@ -1,4 +0,0 @@
-import { Command, Context } from 'koishi';
-import { TriggerEngine } from '../trigger/engine';
-/** dify.rule.* 管理命令（authority 3）：规则以 JSON 导入维护 */
-export declare function registerRuleCommands(parent: Command, ctx: Context, engine: TriggerEngine): void;

package/lib/services/app-service.d.ts

@@ -1,17 +0,0 @@
-import { Context } from 'koishi';
-import { RequestRunner } from '../requester/runner';
-import { DifyApp } from '../state/tables';
-/** 应用接入的共享业务层：命令（dify.app.*）调用。 */
-/** 新建应用接入（重名拒绝）；返回新行 id */
-export declare function createApp(ctx: Context, runner: RequestRunner, input: {
-    name: string;
-    apiURL: string;
-    apiKey: string;
-}): Promise<string>;
-/** 探测应用类型（GET /info + /parameters），成败都回写 status/lastCheckAt */
-export declare function testApp(ctx: Context, runner: RequestRunner, app: DifyApp): Promise<{
-    mode: string;
-    name: string;
-}>;
-/** 删除应用；被规则引用时拒绝 */
-export declare function deleteApp(ctx: Context, runner: RequestRunner, app: DifyApp): Promise<void>;

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[];
-}