koishi-plugin-dify-ai 0.1.7 → 0.1.10

package/lib/api/client.d.ts

@@ -11,6 +11,7 @@ export declare class DifyClient {
     private timeout;
     constructor(http: Context['http'], app: DifyClientApp, timeout?: number);
     private buildUrl;
+    private authHeaders;
     private buildJsonHeaders;
     private errorFrom;
     /** 非 2xx 时抛出带状态码与 Dify 错误码的 DifyApiError */

package/lib/config.d.ts

@@ -52,6 +52,9 @@ export type VariableEntry = {
     source: 'constant';
     field: string;
     value: string;
+} | {
+    source: 'json';
+    template: string;
 };
 /** 作用域的一行：维度 + 值 */
 export interface ScopeRow {
@@ -68,13 +71,6 @@ export interface RuleEntry {
     scope: ScopeRow[];
     variables: VariableEntry[];
 }
-/** 引用触发消息的条件分支形态：关闭时空分支，开启时按耗时阈值决定是否引用 */
-export type QuoteEntry = {
-    mode: 'off';
-} | {
-    mode: 'on';
-    minElapsedSeconds: number;
-};
 /** 触发后冷却的条件分支形态 */
 export type CooldownEntry = {
     mode: 'off';
@@ -86,33 +82,29 @@ export type CooldownEntry = {
     minSeconds?: number;
     maxSeconds?: number;
 };
-/** 上传消息文件的条件分支形态：关闭时空分支，开启时限制数量与单文件大小 */
-export type UploadEntry = {
-    mode: 'off';
-} | {
-    mode: 'on';
-    maxCount?: number;
-    maxSizeMb?: number;
-};
 export interface Config {
     apps: AppConfigEntry[];
     rules: RuleEntry[];
     parseElements: boolean;
-    quote: QuoteEntry;
+    quote: boolean;
+    minElapsedSeconds: number;
     maxSegmentLength: number;
-    /** boolean 是 0.1.x 的遗留形态，仅迁移读取（true → 开启不限，false → 关闭） */
-    uploadFiles: UploadEntry | boolean;
-    /** 0.1.x 的布尔开关，仅用于迁移读取（true → 总是引用，false → 关闭） */
-    quoteTrigger?: boolean;
+    uploadFiles: boolean;
+    maxCount: number;
+    maxSizeMb: number;
     requestTimeout: number;
     historyLimit: number;
     sendErrors: boolean;
     cooldown: CooldownEntry;
 }
+/**
+ * 上传消息文件：布尔开关驱动分支（开=可配数量与单文件大小上限，关=空分支），官方 union-tagged 写法。
+ * 上限默认 -1 规避 0 被表单默认值机制吞掉（-1 与 0 同为不限，仍受 Dify 各类型上限约束）。
+ */
 export declare const Config: Schema<Config>;
 /**
- * 上传消息文件配置（含 0.1.x 布尔遗留形态迁移）：
- * 数量与单文件大小 0 均为不限，大小仍与 Dify 各类型上限取较小值。
+ * 上传消息文件配置（平铺开关，默认关闭：显式开启才上传）。数量与单文件大小
+ * 0 与 -1 均为不限，大小仍与 Dify 各类型上限取较小值。
  */
 export declare function resolveUploadConfig(config: Config): {
     enabled: boolean;
@@ -120,9 +112,8 @@ export declare function resolveUploadConfig(config: Config): {
     maxMb: number;
 };
 /**
- * 引用触发消息配置（含 0.1.x 布尔开关迁移）：schema 会给旧配置填默认 quote 对象，
- * 因此迁移判据是「旧布尔被配置层透传保留 且 quote 仍是默认形态（用户未在新表单改过）」——
- * 此时以旧布尔为准；用户改过新表单（quote 非默认）则新值优先。
+ * 引用触发消息配置（平铺开关，含 0.1.x quoteTrigger 透传迁移：
+ * 旧布尔被保留且开关与阈值均未被改动时以旧布尔为准）。阈值 -1 与 0 同为总是引用。
  */
 export declare function resolveQuoteConfig(config: Config): {
     enabled: boolean;

package/lib/index.js

@@ -49,6 +49,15 @@ var en_US_default = {
 
 // src/config.ts
 var import_koishi = require("koishi");
+
+// src/types.ts
+function isMessageTrigger(type) {
+  return type !== "schedule" && type !== "density";
+}
+__name(isMessageTrigger, "isMessageTrigger");
+var JSON_PLACEHOLDER = /\{\{\s*(\w+)(?::(\d+))?\s*\}\}/g;
+
+// src/config.ts
 var appTypeSchema = import_koishi.Schema.union([
   import_koishi.Schema.const("auto").description("自动探测"),
   import_koishi.Schema.const("chat").description("Chatbot"),
@@ -83,7 +92,7 @@ var conditionSchema = import_koishi.Schema.union([
   import_koishi.Schema.object({
     type: import_koishi.Schema.const("schedule").required(),
     cron: import_koishi.Schema.string().default("").description("Cron 表达式"),
-    intervalMinutes: import_koishi.Schema.number().default(0).min(0).description("间隔分钟")
+    intervalMinutes: import_koishi.Schema.number().default(-1).min(-1).description("间隔分钟")
   }).default({ type: "schedule", cron: "", intervalMinutes: 0 }).description("定时"),
   import_koishi.Schema.object({
     type: import_koishi.Schema.const("density").required(),
@@ -121,7 +130,7 @@ var variableSchema = import_koishi.Schema.union([
   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 用全局")
+    limit: import_koishi.Schema.number().default(-1).min(-1).max(100).description("条数，0 用全局")
   }).default({ source: "history", field: "", limit: 0 }).description("历史消息"),
   import_koishi.Schema.object({
     source: import_koishi.Schema.const("meta").required(),
@@ -132,16 +141,44 @@ var variableSchema = import_koishi.Schema.union([
     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("常量文本")
+  }).default({ source: "constant", field: "", value: "" }).description("常量文本"),
+  import_koishi.Schema.object({
+    source: import_koishi.Schema.const("json").required(),
+    template: import_koishi.Schema.string().role("textarea").required().description("JSON 对象")
+  }).default({ source: "json", template: "" }).description("JSON 对象")
 ]);
-var quoteSchema = import_koishi.Schema.union([
+var legacySwitch = import_koishi.Schema.transform(
+  import_koishi.Schema.any(),
+  (value) => typeof value === "boolean" ? value : value?.mode !== "off"
+);
+function switchSchema(defaultValue) {
+  return import_koishi.Schema.union([import_koishi.Schema.boolean().default(defaultValue), legacySwitch]).default(defaultValue);
+}
+__name(switchSchema, "switchSchema");
+var quoteSwitchSchema = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
-    mode: import_koishi.Schema.const("off").required()
-  }).default({ mode: "off" }).description("关闭"),
+    quote: switchSchema(true).description("引用触发消息")
+  }),
+  import_koishi.Schema.union([
+    import_koishi.Schema.object({
+      quote: import_koishi.Schema.const(true),
+      minElapsedSeconds: import_koishi.Schema.number().min(-1).default(-1).description("回复耗时多少秒才引用，0 总是引用")
+    }),
+    import_koishi.Schema.object({})
+  ])
+]);
+var uploadSwitchSchema = import_koishi.Schema.intersect([
   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("开启")
+    uploadFiles: switchSchema(false).description("上传消息中的文件")
+  }),
+  import_koishi.Schema.union([
+    import_koishi.Schema.object({
+      uploadFiles: import_koishi.Schema.const(true).required(),
+      maxCount: import_koishi.Schema.number().min(-1).default(-1).description("数量上限，0 不限"),
+      maxSizeMb: import_koishi.Schema.number().min(-1).default(-1).description("单文件大小上限 MB，0 不限")
+    }),
+    import_koishi.Schema.object({})
+  ])
 ]);
 var cooldownSchema = import_koishi.Schema.union([
   import_koishi.Schema.object({
@@ -157,17 +194,6 @@ var cooldownSchema = import_koishi.Schema.union([
     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("开启"),
-  import_koishi.Schema.boolean().description("旧版开关")
-]);
 var Config = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
     apps: import_koishi.Schema.array(
@@ -185,7 +211,7 @@ var Config = import_koishi.Schema.intersect([
       import_koishi.Schema.object({
         name: import_koishi.Schema.string().required().description("规则名"),
         enabled: import_koishi.Schema.boolean().default(true).description("启用"),
-        priority: import_koishi.Schema.number().default(0).description("优先级，大者先匹配"),
+        priority: import_koishi.Schema.number().default(-1).description("优先级，大者先匹配"),
         app: import_koishi.Schema.string().required().description("应用名"),
         conversationScope: import_koishi.Schema.union([
           import_koishi.Schema.const("per-guild").description("按群聊"),
@@ -214,10 +240,10 @@ var Config = import_koishi.Schema.intersect([
   }).description("触发规则"),
   import_koishi.Schema.object({
     parseElements: import_koishi.Schema.boolean().default(false).description("解析回复中的消息元素"),
-    quote: quoteSchema.default({ mode: "on", minElapsedSeconds: 0 }).description("引用触发消息"),
-    maxSegmentLength: import_koishi.Schema.natural().default(0).description("分段长度，0 不分段"),
-    uploadFiles: uploadSchema.default({ mode: "on", maxCount: 0, maxSizeMb: 0 }).description("上传消息中的文件")
+    maxSegmentLength: import_koishi.Schema.number().min(-1).default(-1).description("分段长度，0 不分段")
   }).description("回复行为"),
+  quoteSwitchSchema,
+  uploadSwitchSchema,
   import_koishi.Schema.object({
     requestTimeout: import_koishi.Schema.natural().role("ms").default(3e5).description("请求超时"),
     historyLimit: import_koishi.Schema.natural().default(20).min(1).description("历史消息条数"),
@@ -309,6 +335,17 @@ function toScope(rows) {
 }
 __name(toScope, "toScope");
 function toVariable(entry) {
+  if (entry.source === "json") {
+    const template = entry.template ?? "";
+    if (!template.trim()) return null;
+    try {
+      const probe = JSON.parse(template.replace(JSON_PLACEHOLDER, "0"));
+      if (typeof probe !== "object" || probe === null || Array.isArray(probe)) return null;
+    } catch {
+      return null;
+    }
+    return { field: "", source: { type: "json", template } };
+  }
   const field = entry.field?.trim();
   if (!field) return null;
   if (entry.source === "constant") {
@@ -328,25 +365,22 @@ function toVariable(entry) {
 }
 __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 };
+  if (config.uploadFiles !== true) return { enabled: false, maxCount: 0, maxMb: 0 };
   return {
     enabled: true,
-    maxCount: Number(config.uploadFiles?.maxCount) || 0,
-    maxMb: Number(config.uploadFiles?.maxSizeMb) || 0
+    maxCount: Number(config.maxCount) || 0,
+    maxMb: Number(config.maxSizeMb) || 0
   };
 }
 __name(resolveUploadConfig, "resolveUploadConfig");
 function resolveQuoteConfig(config) {
-  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 };
+  const threshold = Number(config.minElapsedSeconds) || 0;
+  const untouched = config.quote !== false && !(threshold > 0);
+  const legacy = config.quoteTrigger;
+  if (typeof legacy === "boolean" && untouched) {
+    return { enabled: legacy, minElapsedSeconds: 0 };
   }
-  if (quote?.mode === "off") return { enabled: false, minElapsedSeconds: 0 };
-  return { enabled: true, minElapsedSeconds: Number(quote?.minElapsedSeconds) || 0 };
+  return { enabled: config.quote !== false, minElapsedSeconds: threshold };
 }
 __name(resolveQuoteConfig, "resolveQuoteConfig");
 function toCooldown(entry) {
@@ -362,6 +396,7 @@ function toCooldown(entry) {
 }
 __name(toCooldown, "toCooldown");
 function normalizeConfig(config) {
+  config ??= {};
   const apps = /* @__PURE__ */ new Map();
   for (const app of config.apps ?? []) {
     if (app.name?.trim() && !apps.has(app.name)) apps.set(app.name, app);
@@ -419,11 +454,11 @@ var DifyClient = class {
   buildUrl(path) {
     return this.app.apiURL.replace(/\/+$/, "") + path;
   }
+  authHeaders() {
+    return { Authorization: `Bearer ${this.app.apiKey}` };
+  }
   buildJsonHeaders() {
-    return {
-      Authorization: `Bearer ${this.app.apiKey}`,
-      "Content-Type": "application/json"
-    };
+    return { ...this.authHeaders(), "Content-Type": "application/json" };
   }
   errorFrom(status, data, statusText = "") {
     const isObject = typeof data === "object" && data !== null;
@@ -473,7 +508,7 @@ var DifyClient = class {
     );
     form.set("user", user);
     const res = await this.http("POST", this.buildUrl("/files/upload"), {
-      headers: { Authorization: `Bearer ${this.app.apiKey}` },
+      headers: this.authHeaders(),
       data: form,
       timeout: this.timeout,
       validateStatus: /* @__PURE__ */ __name(() => true, "validateStatus")
@@ -529,6 +564,14 @@ function annotateDroppedPlaceholders(text, droppedUrls) {
   return result;
 }
 __name(annotateDroppedPlaceholders, "annotateDroppedPlaceholders");
+function isImageElement(element) {
+  return element.type === "img" || element.type === "image";
+}
+__name(isImageElement, "isImageElement");
+function imageSourceOf(element) {
+  return element.attrs?.["url"] ?? element.attrs?.["src"];
+}
+__name(imageSourceOf, "imageSourceOf");
 function elementsOf(session) {
   if (session.elements?.length) return session.elements;
   try {
@@ -548,8 +591,8 @@ function extractTextWithPlaceholders(session, options = {}) {
       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"]));
+    } else if (isImageElement(element)) {
+      parts.push(imagePlaceholder(imageSourceOf(element)));
     }
   }
   return parts.join(" ").replace(/\s+/g, " ").trim();
@@ -558,8 +601,8 @@ __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 (!isImageElement(element)) continue;
+    const source = imageSourceOf(element);
     if (typeof source === "string" && source) urls.push(source);
   }
   return urls;
@@ -578,7 +621,8 @@ __name(formatTimestamp, "formatTimestamp");
 function formatHistoryEntry(entry) {
   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}`;
+  const separator = quote ? "" : " ";
+  return `[${formatTimestamp(entry.timestamp)}] ${entry.username} (${entry.userId})${messageId}${quote}${separator}说：${entry.content}`;
 }
 __name(formatHistoryEntry, "formatHistoryEntry");
 function formatHistoryEntries(entries) {
@@ -649,7 +693,10 @@ 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)*`);
+var escapeRegExp = /* @__PURE__ */ __name((text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "escapeRegExp");
+var NON_TEXT_PREFIX = new RegExp(
+  `^(?:@\\S+|\\[image:[0-9a-f]{${IMAGE_HASH_LENGTH}}\\]|${escapeRegExp(IMAGE_PLACEHOLDER)}|\\s)*`
+);
 function stripPrefixKeyword(verbatim, keyword) {
   const prefix = NON_TEXT_PREFIX.exec(verbatim)?.[0] ?? "";
   const rest = verbatim.slice(prefix.length);
@@ -709,8 +756,7 @@ function matchScope(scope, session) {
   ];
   if (dimensions.some(([allowed, value]) => allowed?.length && !allowed.includes(value))) return false;
   if (scope.excludeUsers?.length && scope.excludeUsers.includes(session.userId)) return false;
-  if (scope.isDirect === true && !session.isDirect) return false;
-  if (scope.isDirect === false && session.isDirect) return false;
+  if (scope.isDirect != null && scope.isDirect !== !!session.isDirect) return false;
   return true;
 }
 __name(matchScope, "matchScope");
@@ -790,7 +836,7 @@ var MessagePool = class {
         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 }];
+          return [{ rule, conditionIndex: index, entries: pool.entries }];
         }
       }
     }
@@ -881,13 +927,13 @@ var RuleScheduler = class {
 // src/trigger/cooldown.ts
 var BUFFER_CAPACITY = 1024;
 var DENSITY_LANE_PREFIX = "density:";
+var LANE_KEY_SEPARATOR = "\n";
 function densityLane(index) {
   return `${DENSITY_LANE_PREFIX}${index}`;
 }
 __name(densityLane, "densityLane");
 function laneKeyOf(ruleName, lane) {
-  return `${ruleName}
-${lane}`;
+  return `${ruleName}${LANE_KEY_SEPARATOR}${lane}`;
 }
 __name(laneKeyOf, "laneKeyOf");
 var TriggerCooldown = class {
@@ -923,23 +969,23 @@ var TriggerCooldown = class {
       state.fireAt + setting.maxMs
     );
   }
-  /** 滑动窗口顺延：已到期的通道不复活 */
+  /** 滑动窗口顺延：sliding 模式且通道未到期才执行（已到期的不复活） */
+  slideIfActive(state, setting, now) {
+    if (setting?.mode !== "sliding" || !state || now >= state.deadline) return;
+    this.slide(state, setting, now);
+  }
+  /** 滑动窗口顺延 */
   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);
+    this.slideIfActive(state, this.setting, now);
   }
-  /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动）；已到期的不复活 */
+  /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动） */
   extendDensityLanes(channelKey, now) {
-    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:") || now >= state.deadline) continue;
-      this.slide(state, setting, now);
+      if (!key.includes(LANE_KEY_SEPARATOR + DENSITY_LANE_PREFIX)) continue;
+      this.slideIfActive(state, this.setting, now);
     }
   }
   /** 冷却期内缓存一条命中消息（仅消息通道） */
@@ -959,7 +1005,7 @@ var TriggerCooldown = class {
       if (!lanes) continue;
       for (const [laneKey, state] of lanes) {
         if (now < state.deadline) continue;
-        const separator = laneKey.indexOf("\n");
+        const separator = laneKey.indexOf(LANE_KEY_SEPARATOR);
         lanes.delete(laneKey);
         expired.push({
           channelKey: key,
@@ -984,10 +1030,19 @@ var TriggerCooldown = class {
 
 // src/trigger/engine.ts
 var SCHEDULER_TICK_MS = 1e3;
+var joinNonEmpty = /* @__PURE__ */ __name((parts) => parts.filter(Boolean).join("\n"), "joinNonEmpty");
 function collectImageUrls(entries) {
   return entries.flatMap((entry) => entry?.role === "user" ? entry.imageUrls ?? [] : []);
 }
 __name(collectImageUrls, "collectImageUrls");
+function windowFieldsOf(entries) {
+  return {
+    queryText: formatHistoryEntries(entries),
+    contentText: formatHistoryBrief(entries),
+    imageUrls: collectImageUrls(entries)
+  };
+}
+__name(windowFieldsOf, "windowFieldsOf");
 function sessionIdentityOf(session) {
   return {
     platform: session.platform,
@@ -1040,8 +1095,7 @@ var TriggerEngine = class {
     this.ctx.logger.info("已加载 %d 条启用规则", this.rules.length);
   }
   handleMessage(session, next) {
-    if (this.ctx.bots[session.uid]) return next();
-    if (!session.channelId) return next();
+    if (this.ctx.bots[session.uid] || !session.channelId) return next();
     const channelKey = channelKeyOf(session.platform, session.channelId);
     this.tickCooldown(channelKey);
     const entry = buildHistoryEntry(session);
@@ -1112,16 +1166,14 @@ var TriggerEngine = class {
       ...sessionIdentityOf(session),
       triggerType: "density",
       rule: fire.rule,
-      queryText: formatHistoryEntries(fire.entries),
-      contentText: formatHistoryBrief(fire.entries),
-      imageUrls: collectImageUrls(fire.entries)
+      ...windowFieldsOf(fire.entries)
     });
   }
   /** 冷却到期：把缓冲内的触发消息合并为一次触发，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");
+    const queryText = joinNonEmpty(buffer.map((item) => item.entry ? formatHistoryEntry(item.entry) : ""));
+    const contentText = joinNonEmpty(buffer.map((item) => item.contentText));
     this.beginCooldown(channelKeyOf(first.session.platform, first.session.channelId), rule.name, "message");
     this.run({
       session: first.session,
@@ -1135,10 +1187,9 @@ var TriggerEngine = class {
     });
   }
   /** 密度冷却到期复查达标：无当前消息，用池身份构造上下文（投递同定时路径） */
-  fireDensityExpiry(rule, conditionIndex, channel, now) {
+  fireDensityExpiry(rule, condition, conditionIndex, channel, now) {
     this.beginCooldown(channelKeyOf(channel.platform, channel.channelId), rule.name, densityLane(conditionIndex));
-    const condition = rule.conditions[conditionIndex];
-    const windowMs = condition.type === "density" ? condition.densityWindowSeconds * 1e3 : 0;
+    const windowMs = condition.densityWindowSeconds * 1e3;
     let userId;
     for (let i = channel.entries.length - 1; i >= 0; i--) {
       const item = channel.entries[i];
@@ -1152,9 +1203,7 @@ var TriggerEngine = class {
       userId,
       triggerType: "density",
       rule,
-      queryText: formatHistoryEntries(channel.entries),
-      contentText: formatHistoryBrief(channel.entries),
-      imageUrls: collectImageUrls(channel.entries),
+      ...windowFieldsOf(channel.entries),
       isDirect: channel.isDirect
     });
   }
@@ -1168,9 +1217,7 @@ var TriggerEngine = class {
         ...poolIdentityOf(channel),
         triggerType: "schedule",
         rule,
-        queryText: formatHistoryEntries(channel.entries),
-        contentText: formatHistoryBrief(channel.entries),
-        imageUrls: collectImageUrls(channel.entries),
+        ...windowFieldsOf(channel.entries),
         isDirect: channel.isDirect
       });
     }
@@ -1194,16 +1241,10 @@ var TriggerEngine = class {
     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, now);
+    if (channel) this.fireDensityExpiry(rule, condition, index, channel, now);
   }
 };
 
-// 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");
@@ -1259,6 +1300,10 @@ function guessExtension(mimeType) {
   return found ? found[0] : "bin";
 }
 __name(guessExtension, "guessExtension");
+function fallbackFileName(mimeType) {
+  return `file.${guessExtension(mimeType)}`;
+}
+__name(fallbackFileName, "fallbackFileName");
 function mimeToFileType(mimeType) {
   if (!mimeType) return "custom";
   if (mimeType.startsWith("image/")) return "image";
@@ -1272,15 +1317,11 @@ function mimeToFileType(mimeType) {
 __name(mimeToFileType, "mimeToFileType");
 function extractFileCandidates(session) {
   const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
   for (const element of session.elements ?? []) {
     const difyType = ELEMENT_TYPE[element.type];
     if (!difyType) continue;
-    const source = element.attrs?.["url"] ?? element.attrs?.["src"];
+    const source = imageSourceOf(element);
     if (typeof source !== "string" || !source) continue;
-    const key = `${difyType}:${source}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
     candidates.push({ source, type: difyType });
   }
   return candidates;
@@ -1306,7 +1347,7 @@ function parseDataUrl(source) {
   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 };
+  return { buffer, fileName: fallbackFileName(mimeType), mimeType };
 }
 __name(parseDataUrl, "parseDataUrl");
 async function readLocalFile(ctx, source) {
@@ -1317,7 +1358,7 @@ async function readLocalFile(ctx, source) {
   }
   const buffer = await (0, import_promises.readFile)(filePath);
   const mimeType = guessMime((0, import_path.extname)(filePath));
-  return { buffer, fileName: (0, import_path.basename)(filePath) || `file.${guessExtension(mimeType)}`, mimeType };
+  return { buffer, fileName: (0, import_path.basename)(filePath) || fallbackFileName(mimeType), mimeType };
 }
 __name(readLocalFile, "readLocalFile");
 async function fetchRemoteFile(ctx, source) {
@@ -1333,7 +1374,7 @@ async function fetchRemoteFile(ctx, source) {
     } catch {
     }
     const mimeType = guessMime((0, import_path.extname)(fileName));
-    return { buffer, fileName: fileName || `file.${guessExtension(mimeType)}`, mimeType };
+    return { buffer, fileName: fileName || fallbackFileName(mimeType), mimeType };
   } catch (error) {
     ctx.logger.warn("下载远程文件失败：%s (%s)", source, error);
     return null;
@@ -1448,29 +1489,73 @@ function resolveMetaField(key, fireCtx, now) {
   }
 }
 __name(resolveMetaField, "resolveMetaField");
+function historyVariableOf(fireCtx, history, limit) {
+  const channelKey = channelKeyOf(fireCtx.platform, fireCtx.channelId);
+  return history.toVariable(history.get(channelKey, limit ?? history.limit));
+}
+__name(historyVariableOf, "historyVariableOf");
 function resolveSource(source, fireCtx, history, now) {
-  switch (source?.type) {
+  switch (source.type) {
     case "session":
       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;
-      return history.toVariable(history.get(channelKey, limit));
-    }
+    case "history":
+      return historyVariableOf(fireCtx, history, source.limit);
     default:
       return void 0;
   }
 }
 __name(resolveSource, "resolveSource");
+var META_PLACEHOLDERS = /* @__PURE__ */ new Set(["triggerType", "ruleName", "triggerTime"]);
+function resolvePlaceholderValue(name2, limit, fireCtx, history, now) {
+  if (name2 === "history") {
+    return historyVariableOf(fireCtx, history, limit);
+  }
+  if (name2 === "isDirect") {
+    return resolveSessionField("isDirect", fireCtx, now);
+  }
+  if (META_PLACEHOLDERS.has(name2)) {
+    return resolveMetaField(name2, fireCtx, now);
+  }
+  return String(resolveSessionField(name2, fireCtx, now));
+}
+__name(resolvePlaceholderValue, "resolvePlaceholderValue");
+var BARE_PLACEHOLDER = new RegExp(`"${JSON_PLACEHOLDER.source}"`, "g");
+var escapeJsonText = /* @__PURE__ */ __name((value) => JSON.stringify(value).slice(1, -1), "escapeJsonText");
+function interpolateTemplate(template, fireCtx, history, now) {
+  const resolve = /* @__PURE__ */ __name((name2, limit) => resolvePlaceholderValue(name2, limit ? Number(limit) : void 0, fireCtx, history, now), "resolve");
+  const bareReplaced = template.replace(
+    BARE_PLACEHOLDER,
+    (_match, name2, limit) => JSON.stringify(resolve(name2, limit))
+  );
+  return bareReplaced.replace(
+    JSON_PLACEHOLDER,
+    (_match, name2, limit) => escapeJsonText(String(resolve(name2, limit)))
+  );
+}
+__name(interpolateTemplate, "interpolateTemplate");
+function resolveJsonObject(template, fireCtx, history, now) {
+  try {
+    const parsed = JSON.parse(interpolateTemplate(template, fireCtx, history, now));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+__name(resolveJsonObject, "resolveJsonObject");
 function resolveVariables(rule, fireCtx, history) {
   const inputs = {};
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const binding of rule.variables) {
-    if (!binding?.field) continue;
+    if (binding.source.type !== "json") continue;
+    const object = resolveJsonObject(binding.source.template, fireCtx, history, now);
+    if (object) Object.assign(inputs, object);
+  }
+  for (const binding of rule.variables) {
+    if (binding.source.type === "json") continue;
     const value = resolveSource(binding.source, fireCtx, history, now);
     if (value !== void 0) inputs[binding.field] = value;
   }
@@ -1486,12 +1571,13 @@ function splitText(text, maxLength) {
   const lines = text.split("\n");
   const segments = [];
   let current = "";
+  const flush = /* @__PURE__ */ __name(() => {
+    if (current) segments.push(current);
+  }, "flush");
   for (const line of lines) {
     if (line.length > maxLength) {
-      if (current) {
-        segments.push(current);
-        current = "";
-      }
+      flush();
+      current = "";
       for (let i = 0; i < line.length; i += maxLength) {
         segments.push(line.slice(i, i + maxLength));
       }
@@ -1505,7 +1591,7 @@ function splitText(text, maxLength) {
 ${line}` : line;
     }
   }
-  if (current) segments.push(current);
+  flush();
   return segments;
 }
 __name(splitText, "splitText");
@@ -1609,22 +1695,7 @@ var RequestRunner = class {
       inputs: resolveVariables(rule, fireCtx, this.history),
       uploadedFiles: []
     };
-    const upload = resolveUploadConfig(this.config);
-    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,
-        [...sessionCandidates, ...urlCandidates],
-        requestCtx.difyUser,
-        { maxCount: upload.maxCount, maxSizeMb: upload.maxMb }
-      );
-      requestCtx.uploadedFiles = files;
-      if (dropped.length) {
-        fireCtx.queryText = annotateDroppedPlaceholders(fireCtx.queryText, dropped);
-      }
-    }
+    await this.uploadTriggerFiles(fireCtx, client, requestCtx);
     let reply;
     try {
       reply = await this.dispatch(app, client, fireCtx, requestCtx);
@@ -1648,6 +1719,30 @@ var RequestRunner = class {
     });
     await this.deliver(fireCtx, messages);
   }
+  /**
+   * 文件上传管线：消息触发取会话元素候选（含音视频文件），窗口类触发（合并/密度/定时）
+   * 经 fireCtx.imageUrls 补齐相关消息的图片；同 URL 重复由上传入口去重；
+   * 被丢弃图片在 query 的占位符上注明已丢弃，模型可感知缺图原因。
+   * 注意：workflow 的「文件型输入变量」（inputs 内嵌文件对象）不在本管线范围内，
+   * 顶层 files 已覆盖视觉模型组合输入的主场景。
+   */
+  async uploadTriggerFiles(fireCtx, client, requestCtx) {
+    const upload = resolveUploadConfig(this.config);
+    if (!upload.enabled) return;
+    const sessionCandidates = fireCtx.session ? extractFileCandidates(fireCtx.session) : [];
+    const urlCandidates = (fireCtx.imageUrls ?? []).map((url) => ({ source: url, type: "image" }));
+    const { files, dropped } = await uploadCandidates(
+      this.ctx,
+      client,
+      [...sessionCandidates, ...urlCandidates],
+      requestCtx.difyUser,
+      { maxCount: upload.maxCount, maxSizeMb: upload.maxMb }
+    );
+    requestCtx.uploadedFiles = files;
+    if (dropped.length) {
+      fireCtx.queryText = annotateDroppedPlaceholders(fireCtx.queryText, dropped);
+    }
+  }
   /** 引用判定：开关开启、回复耗时达到阈值、且由消息触发（定时与密度没有单一触发消息） */
   shouldQuoteReply(fireCtx, startedAt) {
     const quote = resolveQuoteConfig(this.config);
@@ -1683,12 +1778,16 @@ var RequestRunner = class {
     }
     return { text: response.answer, files: [] };
   }
+  /** 逐条发送，单条失败仅告警不中断 */
+  async sendAll(messages, send) {
+    for (const message of messages) {
+      await send(message).catch((error) => this.ctx.logger.warn(error));
+    }
+  }
   async deliver(fireCtx, messages) {
     if (!messages.length) return;
     if (fireCtx.session) {
-      for (const message of messages) {
-        await fireCtx.session.send(message).catch((error) => this.ctx.logger.warn(error));
-      }
+      await this.sendAll(messages, (message) => fireCtx.session.send(message));
       return;
     }
     const bots = Object.values(this.ctx.bots);
@@ -1697,9 +1796,7 @@ var RequestRunner = class {
       this.ctx.logger.warn("平台 %s 上没有可用 bot，无法发送主动消息", fireCtx.platform);
       return;
     }
-    for (const message of messages) {
-      await bot.sendMessage(fireCtx.channelId, message).catch((error) => this.ctx.logger.warn(error));
-    }
+    await this.sendAll(messages, (message) => bot.sendMessage(fireCtx.channelId, message));
   }
 };
 
@@ -1767,23 +1864,34 @@ var ConversationStore = class {
   async saveConversationId(bindingKey, difyConversationId) {
     await this.ctx.database.upsert("dify_conversation", [{ bindingKey, difyConversationId }]);
   }
-  /** 解析 bindingKey 的构成（重置时反查应用凭据与 difyUser 用） */
+  /** 解析 bindingKey 的构成（重置时反查应用凭据与 difyUser 用）。
+   *  段位定位假设 appId / platform / selfId 不含冒号（平台名与应用标识按约定不含；
+   *  Matrix 的 bot id 含冒号属键格式改造范畴，当前不区分） */
   parseBindingKey(bindingKey) {
-    const [appId, platform, , scope, ...ids] = bindingKey.split(":");
+    const segments = bindingKey.split(":");
+    if (segments.length === 2 && segments[1] === "global") {
+      return { appId: segments[0], platform: "", scope: "global", ids: [] };
+    }
+    const [appId, platform, , scope, ...ids] = segments;
     return { appId, platform, scope, ids };
   }
+  /** scope 之后的 id 片段拼回整体（键内 id 可能内嵌冒号，消费方按语义整体比较） */
+  joinedIdsOf(bindingKey) {
+    return this.parseBindingKey(bindingKey).ids.join(":");
+  }
   /** 由 bindingKey 还原删除 Dify 会话所需的 difyUser（与 computeDifyUser 对齐） */
   difyUserOfBindingKey(bindingKey) {
-    const { platform, scope, ids } = this.parseBindingKey(bindingKey);
+    const { platform, scope } = this.parseBindingKey(bindingKey);
+    const ids = this.joinedIdsOf(bindingKey);
     switch (scope) {
       case "global":
         return "koishi";
       case "private":
-        return `koishi:${platform}:private:${ids.join(":")}`;
+        return `koishi:${platform}:private:${ids}`;
       case "guild":
       case "channel":
       case "user":
-        return `koishi:${platform}:${ids.join(":")}`;
+        return `koishi:${platform}:${ids}`;
       default:
         return `koishi:${platform}`;
     }
@@ -1804,12 +1912,13 @@ var ConversationStore = class {
     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 { platform, scope } = this.parseBindingKey(row.bindingKey);
       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;
+      const joinedIds = this.joinedIdsOf(row.bindingKey);
+      if (scope === "guild") return joinedIds === guildId;
+      if (scope === "user") return joinedIds.startsWith(`${guildId}:`);
+      if (scope === "channel") return platform === channelPlatform && joinedIds === channelId;
+      if (scope === "private") return filter.isDirect === true && joinedIds === filter.userId;
       return false;
     });
     let reset = 0;
@@ -1852,14 +1961,14 @@ __name(defineTables, "defineTables");
 // src/commands/misc.ts
 function registerMiscCommands(parent, conversationStore) {
   parent.subcommand(".conv.reset", { authority: 3 }).action(async ({ session }) => {
-    const reset = await conversationStore.resetWhere({
+    const resetCount = 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]);
+    if (!resetCount) return session.text("dify-ai.commands.conv-empty");
+    return session.text("dify-ai.commands.conv-reset", [resetCount]);
   });
 }
 __name(registerMiscCommands, "registerMiscCommands");
@@ -1869,6 +1978,7 @@ var name = "dify-ai";
 var inject = { required: ["database"] };
 var PROBE_TIMEOUT_MS = 1e4;
 function apply(ctx, config) {
+  const startedAt = Date.now();
   ctx.i18n.define("zh-CN", zh_CN_default);
   ctx.i18n.define("en-US", en_US_default);
   defineTables(ctx);
@@ -1880,7 +1990,11 @@ function apply(ctx, config) {
   const engine = new TriggerEngine(ctx, runner, history, rules, cooldown);
   ctx.on("ready", () => {
     engine.start();
-    void probeAppTypes(ctx, apps, appTypes);
+    ctx.logger.info("插件装配完成，耗时 %dms", Date.now() - startedAt);
+    const probeStart = Date.now();
+    void probeAppTypes(ctx, apps, appTypes).then(() => {
+      ctx.logger.info("应用类型探测完成，耗时 %dms", Date.now() - probeStart);
+    });
   });
   const admin = ctx.command("dify", { authority: 3 });
   registerMiscCommands(admin, conversationStore);

package/lib/requester/files.d.ts

@@ -13,7 +13,7 @@ interface FilePayload {
 }
 /** mime → Dify 文件类型 */
 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>;
@@ -27,6 +27,6 @@ export interface UploadResult {
     files: DifyInputFileObject[];
     dropped: string[];
 }
-/** 上传一批候选（入口按 type:source 去重，再按数量上限截断、逐个上传） */
+/** 上传一批候选（入口按来源 URL 去重，再按数量上限截断、逐个上传） */
 export declare function uploadCandidates(ctx: Context, client: DifyClient, candidates: FileCandidate[], difyUser: string, limit: UploadLimit): Promise<UploadResult>;
 export {};

package/lib/requester/runner.d.ts

@@ -28,10 +28,20 @@ export declare class RequestRunner {
     /** 应用类型：schema 显式指定优先，auto 时用探测结果（未探测到回退 chat） */
     private appTypeOf;
     run(fireCtx: FireContext): Promise<void>;
+    /**
+     * 文件上传管线：消息触发取会话元素候选（含音视频文件），窗口类触发（合并/密度/定时）
+     * 经 fireCtx.imageUrls 补齐相关消息的图片；同 URL 重复由上传入口去重；
+     * 被丢弃图片在 query 的占位符上注明已丢弃，模型可感知缺图原因。
+     * 注意：workflow 的「文件型输入变量」（inputs 内嵌文件对象）不在本管线范围内，
+     * 顶层 files 已覆盖视觉模型组合输入的主场景。
+     */
+    private uploadTriggerFiles;
     /** 引用判定：开关开启、回复耗时达到阈值、且由消息触发（定时与密度没有单一触发消息） */
     private shouldQuoteReply;
     /** 按应用类型分流：workflow/completion 无会话，chat 系续接 conversation_id */
     private dispatch;
+    /** 逐条发送，单条失败仅告警不中断 */
+    private sendAll;
     private deliver;
 }
 export {};

package/lib/requester/variables.d.ts

@@ -1,5 +1,9 @@
 import { FireContext } from '../types';
 import { MessageHistory } from '../history';
 import { DifyRule } from '../types';
-/** 按规则的变量映射表构造 Dify inputs */
+/**
+ * 按规则的变量映射表构造 Dify inputs。
+ * JSON 对象条目先注入（顶层键展开合并进 inputs），单条映射后注入覆盖同名键——
+ * 现有单条配置行为不变，JSON 作为批量默认值。
+ */
 export declare function resolveVariables(rule: DifyRule, fireCtx: FireContext, history: MessageHistory): Record<string, any>;

package/lib/state/conversation.d.ts

@@ -27,8 +27,12 @@ export declare class ConversationStore {
     computeDifyUser(rule: DifyRule, fireCtx: FireContext): string;
     getConversationId(bindingKey: string): Promise<string | undefined>;
     saveConversationId(bindingKey: string, difyConversationId: string): Promise<void>;
-    /** 解析 bindingKey 的构成（重置时反查应用凭据与 difyUser 用） */
+    /** 解析 bindingKey 的构成（重置时反查应用凭据与 difyUser 用）。
+     *  段位定位假设 appId / platform / selfId 不含冒号（平台名与应用标识按约定不含；
+     *  Matrix 的 bot id 含冒号属键格式改造范畴，当前不区分） */
     private parseBindingKey;
+    /** scope 之后的 id 片段拼回整体（键内 id 可能内嵌冒号，消费方按语义整体比较） */
+    private joinedIdsOf;
     /** 由 bindingKey 还原删除 Dify 会话所需的 difyUser（与 computeDifyUser 对齐） */
     private difyUserOfBindingKey;
     /**

package/lib/trigger/cooldown.d.ts

@@ -38,9 +38,11 @@ export declare class TriggerCooldown {
     isCooling(channelKey: string, ruleName: string, lane: CooldownLane, now: number): boolean;
     /** 滑动窗口顺延：截止推到「now + 最小窗口」，不超过「触发时刻 + 最大窗口」 */
     private slide;
-    /** 滑动窗口顺延：已到期的通道不复活 */
+    /** 滑动窗口顺延：sliding 模式且通道未到期才执行（已到期的不复活） */
+    private slideIfActive;
+    /** 滑动窗口顺延 */
     extend(channelKey: string, ruleName: string, lane: CooldownLane, now: number): void;
-    /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动）；已到期的不复活 */
+    /** 该频道所有密度通道由一条过路消息顺延（密度冷却期内的消息积攒驱动窗口滑动） */
     extendDensityLanes(channelKey: string, now: number): void;
     /** 冷却期内缓存一条命中消息（仅消息通道） */
     bufferMessage(channelKey: string, ruleName: string, message: PendingMessage): void;

package/lib/trigger/pool.d.ts

@@ -13,8 +13,7 @@ export interface ChannelPool {
 }
 export interface DensityFire {
     rule: DifyRule;
-    /** 命中的密度条件与其在规则内的下标（密度冷却通道键） */
-    condition: DensityCondition;
+    /** 命中条件在规则内的下标（密度冷却通道键） */
     conditionIndex: number;
     /** 触发时取走的该频道全池消息（含 bot 行与时效外条目） */
     entries: HistoryEntry[];

package/lib/types.d.ts

@@ -68,7 +68,12 @@ export type VariableSource = {
 } | {
     type: 'constant';
     value: string;
+} | {
+    type: 'json';
+    template: string;
 };
+/** JSON 对象模板里的占位符：{{变量名}} 或 {{history:条数}}（加载校验与运行时插值共用） */
+export declare const JSON_PLACEHOLDER: RegExp;
 /** 一条变量映射：Dify inputs 字段名 ← 来源 */
 export interface VariableBinding {
     field: string;

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

@@ -1,4 +1,4 @@
-import { Session } from 'koishi';
+import { h, Session } from 'koishi';
 /** 图片占位符携带的 URL 摘要长度（hex 位） */
 export declare const IMAGE_HASH_LENGTH = 8;
 /**
@@ -20,6 +20,8 @@ interface ExtractVerbatimOptions {
     /** 跳过 @ 机器人自身的渲染（content 变量语义：@bot 是触发结构而非消息内容） */
     excludeBotAt?: boolean;
 }
+/** 媒体元素的源地址（url 或 src 属性，未定形态原样返回由调用方守卫） */
+export declare function imageSourceOf(element: h): unknown;
 /**
  * 消息原貌文本：text 元素按序拼接，@ 元素渲染为 @名字（缺名字用 ID），
  * img/image 元素渲染为 [image:URL摘要]——统一格式行（query/池/历史）用默认形态，

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