koishi-plugin-aka-comfy-agent 0.2.0

package/dist/index.js

@@ -0,0 +1,1781 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(index_exports);
+var import_koishi3 = require("koishi");
+
+// src/config.ts
+var import_koishi = require("koishi");
+
+// src/llm/prompts.ts
+var MAIN_SYSTEM_PROMPT = `You are the edit-intent author for an image re-render pipeline. The pipeline prepends fixed identity, backdrop and lighting anchors before your output. Describe only the user's requested look (material or optical adjustments; a background change or light override when explicitly asked) as one short natural English clause. Placeholder default; the full prompt is restored via config override from the private design doc.`;
+var GLM_PROBE_PROMPT = `You are an asset extractor for a character image. From the screenshot, list every visual detail that a re-render could drift, and output a structured English JSON inventory (species, per-part colors, accessories, body surface, tail, pose, background). Do not invent details; use "none" when absent. Placeholder default; full prompt (with exact schema) is in the private design doc.`;
+var VISION_USER_TEXT = "分析这张游戏角色截图，输出资产清单 JSON。";
+var VISION_CROSSCHECK_TEXT = `这是对同一张源图的【资产清单对抗复核】。
+
+【上一轮 GLM 输出】
+{prev}
+
+请基于源图逐项对抗验证上一轮的每一项字段，明确指出错误/遗漏/脑补，修正会导致重绘跑偏的项，保持英文枚举与同一 schema 不变；不确定时写 "none"。只输出修正后的权威 JSON。`;
+var VISION_REPORT_LABEL = "资产清单(GLM 修正后)";
+var IDENTITY_ANCHOR = `Preserve the subject, its pose, outfit, accessories and colors of the source image exactly, keeping the same composition and framing, at high resolution, with no UI and no watermark. (Generic placeholder; the full locked wording is in the private design doc.)`;
+var LIGHTFIELD_ANCHOR = `Evenly light the character's front with gentle volume, keep the shadows soft and the face readable, and add a subtle rim so the silhouette lifts off the backdrop with a soft contact shadow. (Generic placeholder; the full locked wording is in the private design doc.)`;
+function buildBackdropClause(color) {
+  const c = (color || "yellow").trim().toLowerCase();
+  return `Place the character on a plain solid ${c} seamless studio backdrop that fully replaces the source background. (Generic placeholder; full wording in private doc.)`;
+}
+function buildBackdropFromOverride(desc) {
+  const d = (desc || "").trim().replace(/\s+/g, " ");
+  return `Place the character against ${d}, fully replacing the source background. (Generic placeholder; full wording in private doc.)`;
+}
+
+// src/config.ts
+var llmSchema = (modelsKey, systemPromptDefault, baseUrlDefault) => import_koishi.Schema.object({
+  enabled: import_koishi.Schema.boolean().default(true).description("启用"),
+  baseUrl: import_koishi.Schema.string().default(baseUrlDefault).description("接口地址"),
+  apiKey: import_koishi.Schema.string().description("ApiKey（可空）"),
+  model: import_koishi.Schema.dynamic(modelsKey).description("模型"),
+  systemPrompt: import_koishi.Schema.string().role("textarea").default(systemPromptDefault).description("模型专属系统提示（角色/规则）"),
+  userText: import_koishi.Schema.string().role("textarea").default(VISION_USER_TEXT).description("请求正文模板（vision 用）")
+});
+var Config = import_koishi.Schema.object({
+  mainLLM: llmSchema("aka-comfy-agent.models.main", MAIN_SYSTEM_PROMPT, "http://127.0.0.1:8000/v1").description("主模型（DS：判定+选择）"),
+  visionLLM: llmSchema("aka-comfy-agent.models.vision", GLM_PROBE_PROMPT, "http://127.0.0.1:8001/v1").description("视觉模型（GLM：资产清单 probe）"),
+  comfy: import_koishi.Schema.object({
+    baseUrl: import_koishi.Schema.string().default("http://127.0.0.1:8188").description("ComfyUI 地址"),
+    timeoutMs: import_koishi.Schema.number().min(3e4).max(6e5).default(18e4).description("超时(ms)")
+  }).description("ComfyUI"),
+  defaultBackgroundColor: import_koishi.Schema.string().default("yellow").description("背景色兜底（DS 未给或非法时使用；英文颜色词）"),
+  session: import_koishi.Schema.object({
+    maxTurns: import_koishi.Schema.number().min(1).max(50).default(10).description("最大轮次"),
+    idleTimeoutMs: import_koishi.Schema.number().min(6e4).max(24 * 60 * 60 * 1e3).default(10 * 60 * 1e3).description("空闲销毁(ms)"),
+    perUserInGroup: import_koishi.Schema.boolean().default(false).description("群内按人隔离"),
+    maxDiagnoseRetries: import_koishi.Schema.number().min(0).max(5).default(2).description("报错重试上限")
+  }).description("会话规则"),
+  confirmBeforeGenerate: import_koishi.Schema.object({
+    command: import_koishi.Schema.boolean().default(true).description("comfy 命令路径：生成前先发送 GLM 资产清单，待用户确认/修正后才提交生成"),
+    chatluna: import_koishi.Schema.boolean().default(false).description("ChatLuna 工具路径：开启确认闸（工具无交互确认能力，开启后工具生成前会卡住，一般保持关闭）")
+  }).description("生成前确认闸（仅对视觉分析轮生效）"),
+  visionCrosscheckRounds: import_koishi.Schema.number().min(1).max(5).default(2).description("视觉对抗自校验轮数：1=仅一次分析；2=分析后做1次对抗复核（推荐）；更多=多次复核更稳但更慢更贵"),
+  chatlunaEnabled: import_koishi.Schema.boolean().default(false).description("接入 ChatLuna 工具（未装则静默禁用）"),
+  chatlunaRoomLastGenerated: import_koishi.Schema.boolean().default(true).description("记录房间最近生成图，供 last_generated 引用")
+});
+
+// src/llm/client.ts
+var LlmClient = class {
+  constructor(ctx, config, model, timeoutMs) {
+    this.ctx = ctx;
+    this.config = config;
+    this.model = model;
+    this.timeoutMs = timeoutMs;
+  }
+  get enabled() {
+    return this.config.enabled && !!this.config.baseUrl && !!this.model;
+  }
+  async chat(messages, opts) {
+    if (!this.enabled) throw new Error(`LLM 未启用或未解析 model（baseUrl=${this.config.baseUrl}）`);
+    const url = joinUrl(this.config.baseUrl, "/chat/completions");
+    const body = {
+      model: this.model,
+      messages,
+      temperature: opts?.temperature ?? 0.4
+    };
+    if (opts?.jsonMode) body["response_format"] = { type: "json_object" };
+    const headers = { "Content-Type": "application/json" };
+    if (this.config.apiKey) headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    const res = await this.ctx.http(url, {
+      method: "POST",
+      data: body,
+      headers,
+      timeout: this.timeoutMs
+    });
+    const data = extractResponseData(res);
+    const content = data?.choices?.[0]?.message?.content;
+    if (typeof content !== "string" || !content) {
+      throw new Error(`LLM 响应无 content：${JSON.stringify(data).slice(0, 200)}`);
+    }
+    return content;
+  }
+};
+function extractResponseData(res) {
+  if (res && typeof res === "object" && "data" in res && res.headers) return res.data;
+  return res;
+}
+function joinUrl(base, path) {
+  const b = base.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${b}${p}`;
+}
+
+// src/llm/models.ts
+async function listModels(ctx, cfg, timeoutMs) {
+  const url = joinUrl(cfg.baseUrl, "/models");
+  const headers = {};
+  if (cfg.apiKey) headers["Authorization"] = `Bearer ${cfg.apiKey}`;
+  const res = await ctx.http.get(url, { timeout: timeoutMs, headers });
+  const payload = res && typeof res === "object" && "data" in res && Array.isArray(res.data) ? res : { data: [] };
+  const ids = [];
+  for (const item of payload.data) {
+    if (item && typeof item.id === "string") ids.push(item.id);
+  }
+  return ids;
+}
+
+// src/comfy/client.ts
+var ComfyClient = class {
+  constructor(ctx, baseUrl, timeoutMs) {
+    this.ctx = ctx;
+    this.baseUrl = baseUrl;
+    this.timeoutMs = timeoutMs;
+  }
+  /** POST /upload/image (multipart, field name = image)。返回 ComfyUI 用于 LoadImage.image 的 name。 */
+  async uploadImage(buffer, filename, mimeType = "image/png") {
+    const form = new FormData();
+    form.append("image", new Blob([new Uint8Array(buffer)], { type: mimeType }), filename);
+    form.append("overwrite", "true");
+    const res = await this.ctx.http(this.url("/upload/image"), {
+      method: "POST",
+      data: form,
+      timeout: this.timeoutMs
+    });
+    const data = unwrap(res);
+    if (!data || typeof data.name !== "string") {
+      throw new Error(`ComfyUI /upload/image 未返回 name：${JSON.stringify(data).slice(0, 200)}`);
+    }
+    return data.name;
+  }
+  /** POST /prompt。body { prompt, client_id }。返回 prompt_id。 */
+  async submitPrompt(workflow, clientId) {
+    const res = await this.ctx.http(this.url("/prompt"), {
+      method: "POST",
+      data: { prompt: workflow, client_id: clientId },
+      headers: { "Content-Type": "application/json" },
+      timeout: this.timeoutMs
+    });
+    const data = unwrap(res);
+    if (!data || typeof data.prompt_id !== "string") {
+      const err = data?.error ?? data?.node_errors ?? data;
+      throw new Error(`ComfyUI /prompt 拒绝：${safeStringify(err).slice(0, 500)}`);
+    }
+    return data.prompt_id;
+  }
+  async getHistory(promptId) {
+    const res = await this.ctx.http.get(this.url(`/history/${encodeURIComponent(promptId)}`), {
+      timeout: this.timeoutMs
+    });
+    const data = unwrap(res);
+    if (!data || typeof data !== "object") return null;
+    const entry = data[promptId];
+    return entry ?? null;
+  }
+  /** GET /view?filename&subfolder&type，返回 image buffer。 */
+  async view(filename, subfolder = "", type = "output") {
+    const url = this.url(`/view?filename=${encodeURIComponent(filename)}&subfolder=${encodeURIComponent(subfolder)}&type=${type}`);
+    const ab = await this.ctx.http.get(url, { responseType: "arraybuffer", timeout: this.timeoutMs });
+    return Buffer.from(ab);
+  }
+  async queue() {
+    const res = await this.ctx.http.get(this.url("/queue"), { timeout: this.timeoutMs });
+    const data = unwrap(res) ?? {};
+    const running = Array.isArray(data.queue_running) ? data.queue_running.length : 0;
+    const pending = Array.isArray(data.queue_pending) ? data.queue_pending.length : 0;
+    return { running, pending };
+  }
+  /** 轮询 history 到 success/error，或超时（timeoutMs 独立传入以覆盖首次模型加载） */
+  async pollUntilDone(promptId, opts) {
+    const interval = opts.intervalMs ?? 1500;
+    const start = Date.now();
+    let last = null;
+    while (Date.now() - start < opts.timeoutMs) {
+      const entry = await this.getHistory(promptId).catch(() => null);
+      if (entry) {
+        last = entry;
+        const st = entry.status;
+        if (st?.completed === true) return entry;
+        if (st?.status_str === "error") return entry;
+        if (Array.isArray(st?.messages)) {
+          for (const m of st.messages) {
+            if (Array.isArray(m) && m[0] === "execution_error") return entry;
+          }
+        }
+      }
+      if (opts.onTick) opts.onTick(Date.now() - start);
+      await sleep(interval);
+    }
+    if (last) return last;
+    throw new Error(`ComfyUI 轮询超时（${opts.timeoutMs}ms），prompt_id=${promptId}`);
+  }
+  url(p) {
+    const base = this.baseUrl.replace(/\/+$/, "");
+    return `${base}${p.startsWith("/") ? p : `/${p}`}`;
+  }
+};
+function unwrap(res) {
+  if (res && typeof res === "object" && "data" in res && "headers" in res) return res.data;
+  return res;
+}
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/comfy/workflow.ts
+function buildFlux2Workflow(input) {
+  const { imageName, text, seed } = input;
+  return {
+    unet: {
+      class_type: "UNETLoader",
+      inputs: { unet_name: "flux2_dev_fp8mixed.safetensors", weight_dtype: "default" }
+    },
+    clip: {
+      class_type: "CLIPLoader",
+      inputs: { clip_name: "mistral_3_small_flux2_bf16.safetensors", type: "flux2" }
+    },
+    vae: {
+      class_type: "VAELoader",
+      inputs: { vae_name: "flux2-vae.safetensors" }
+    },
+    loadimg: {
+      class_type: "LoadImage",
+      inputs: { image: imageName }
+    },
+    enc_img: {
+      class_type: "VAEEncode",
+      inputs: { pixels: ["loadimg", 0], vae: ["vae", 0] }
+    },
+    sched: {
+      class_type: "Flux2Scheduler",
+      inputs: { steps: 20, width: 1024, height: 1024 }
+    },
+    sel: {
+      class_type: "KSamplerSelect",
+      inputs: { sampler_name: "euler" }
+    },
+    noise: {
+      class_type: "RandomNoise",
+      inputs: { noise_seed: seed }
+    },
+    enc: {
+      class_type: "CLIPTextEncode",
+      inputs: { text, clip: ["clip", 0] }
+    },
+    guid: {
+      class_type: "FluxGuidance",
+      inputs: { conditioning: ["enc", 0], guidance: 4 }
+    },
+    reflat: {
+      class_type: "ReferenceLatent",
+      // 注意:本机 ReferenceLatent 节点仅收 conditioning+latent,无 strength 参数(node 定义经 /object_info 核实)
+      inputs: { conditioning: ["guid", 0], latent: ["enc_img", 0] }
+    },
+    guider: {
+      class_type: "BasicGuider",
+      inputs: { model: ["unet", 0], conditioning: ["reflat", 0] }
+    },
+    empty: {
+      class_type: "EmptyFlux2LatentImage",
+      inputs: { width: 1024, height: 1024, batch_size: 1 }
+    },
+    sample: {
+      class_type: "SamplerCustomAdvanced",
+      inputs: {
+        noise: ["noise", 0],
+        guider: ["guider", 0],
+        sampler: ["sel", 0],
+        sigmas: ["sched", 0],
+        latent_image: ["empty", 0]
+      }
+    },
+    dec: {
+      class_type: "VAEDecode",
+      inputs: { samples: ["sample", 0], vae: ["vae", 0] }
+    },
+    save: {
+      class_type: "SaveImage",
+      inputs: { images: ["dec", 0], filename_prefix: "flux2_render" }
+    }
+  };
+}
+function randomSeed() {
+  return Math.floor(Math.random() * 4294967295) >>> 0;
+}
+
+// src/agent/diagnose.ts
+function diagnose(rawError) {
+  const msg = rawError.toLowerCase();
+  if (msg.includes("vram") && msg.includes("grow")) {
+    return {
+      message: "ComfyUI 报 VRAM grow failed（GPU 可能被占或模型加载失败）。等一下再试，别切卡。",
+      retryable: false
+    };
+  }
+  if (msg.includes("out of memory") || msg.includes("cuda oom") || msg.includes("oom")) {
+    return {
+      message: "显存不足，稍后重试。",
+      retryable: true
+    };
+  }
+  if (msg.includes("no module named matplotlib")) {
+    return {
+      message: "comfyui_controlnet_aux 依赖警告（matplotlib 缺失），不影响本流程，忽略。",
+      retryable: true
+    };
+  }
+  if (msg.includes("timeout") || msg.includes("running") || msg.includes("queue")) {
+    return {
+      message: "任务仍在 running（可能首次加载模型慢），等一下即可。",
+      retryable: true
+    };
+  }
+  if (msg.includes("validation") || msg.includes("node_errors") || msg.includes("invalid")) {
+    return {
+      message: "workflow 校验失败：参数已固定，换 seed 重试一次。",
+      retryable: true
+    };
+  }
+  return {
+    message: `未知报错：${rawError.slice(0, 200)}`,
+    retryable: false
+  };
+}
+
+// src/agent/brain.ts
+async function runTurn(deps, session, userFeedback, opts) {
+  const { vision, logger } = deps;
+  if (opts.runVision && vision.enabled && opts.sourceDataUrl) {
+    try {
+      const analysis = await runAnalysisOnly(deps, opts.sourceDataUrl);
+      session.materialAnalysis = analysis;
+      logger.info("vision analysis ok len=%d preview=%s", analysis.length, analysis.slice(0, 60).replace(/\s+/g, " "));
+    } catch (err) {
+      logger.warn("vision analysis failed: %s", errMsg(err));
+      session.materialAnalysis = session.materialAnalysis || "（vision 分析失败）";
+    }
+  } else if (!vision.enabled && !session.materialAnalysis) {
+    session.materialAnalysis = "（vision 未启用）";
+  }
+  return runGenerateOnly(deps, session, userFeedback);
+}
+async function runAnalysisOnly(deps, dataUrl) {
+  const { vision } = deps;
+  if (!vision.enabled) return "（vision 未启用）";
+  let report = await runVisionAnalysis(vision, dataUrl, deps.visionSystemPrompt, deps.visionUserText);
+  const rounds = Math.max(1, Math.floor(deps.visionCrosscheckRounds) || 1);
+  for (let i = 1; i < rounds; i++) {
+    const crossText = (deps.visionCrosscheckText || "").replace("{prev}", report);
+    report = await runVisionAnalysis(vision, dataUrl, deps.visionSystemPrompt, crossText);
+    deps.logger.info(
+      "vision crosscheck round=%d/%d len=%d preview=%s",
+      i + 1,
+      rounds,
+      report.length,
+      report.slice(0, 60).replace(/\s+/g, " ")
+    );
+  }
+  return report;
+}
+async function runVisionAnalysis(vision, dataUrl, systemPrompt, userText) {
+  const messages = [
+    { role: "system", content: systemPrompt },
+    {
+      role: "user",
+      content: [
+        { type: "text", text: userText },
+        { type: "image_url", image_url: { url: dataUrl } }
+      ]
+    }
+  ];
+  return (await vision.chat(messages, { temperature: 0.1, jsonMode: true })).trim();
+}
+async function runGenerateOnly(deps, session, userFeedback) {
+  const { main, comfy, lock, logger } = deps;
+  const decision = await runMainLlm(main, session, userFeedback, deps.mainSystemPrompt);
+  const backdrop = decision.background ? buildBackdropFromOverride(decision.background) : buildBackdropClause(deps.defaultBackgroundColor);
+  const promptText = `${IDENTITY_ANCHOR} ${backdrop} ${LIGHTFIELD_ANCHOR} ${decision.prompt}`;
+  logger.info("brain prompt len=%d ds=%d backdrop=%s lightfield=%d preview=%s", promptText.length, decision.prompt.length, decision.background?.slice(0, 40) || deps.defaultBackgroundColor || "yellow", LIGHTFIELD_ANCHOR.length, promptText.slice(0, 160).replace(/\s+/g, " "));
+  logger.info("brain note=%s", decision.note ?? "");
+  let seed = session.params.seed;
+  if (!Number.isFinite(seed) || seed < 0) seed = randomSeed();
+  let attempt = 0;
+  const maxAttempts = 1 + Math.max(0, deps.maxDiagnoseRetries);
+  let lastError = "";
+  while (attempt < maxAttempts) {
+    attempt++;
+    try {
+      const result = await lock.run(async () => {
+        const workflow = buildFlux2Workflow({
+          imageName: session.source.name,
+          text: promptText,
+          seed
+        });
+        const promptId = await comfy.submitPrompt(workflow, deps.clientId);
+        logger.info("comfy submit ok prompt_id=%s attempt=%d seed=%d", promptId, attempt, seed);
+        const history = await comfy.pollUntilDone(promptId, {
+          timeoutMs: deps.comfyTimeoutMs,
+          onTick: (t) => {
+            deps.onGenerateProgress?.(t);
+            if (t % 15e3 < 1600) logger.info("poll elapsed=%dms prompt_id=%s", t, promptId);
+          }
+        });
+        return { promptId, history };
+      });
+      const outputImage = pickOutputImage(result.history);
+      if (!outputImage) {
+        const errMsgText = extractHistoryError(result.history) || "未生成输出图（未知）";
+        throw new Error(errMsgText);
+      }
+      const buf = await comfy.view(outputImage.filename, outputImage.subfolder ?? "", "output");
+      session.params = { seed };
+      return {
+        imageBuffer: buf,
+        filename: outputImage.filename,
+        params: session.params,
+        promptId: result.promptId,
+        note: decision.note,
+        material: decision.material,
+        lighting: decision.lighting,
+        background: decision.background
+      };
+    } catch (err) {
+      lastError = errMsg(err);
+      session.errorHistory.push({ at: Date.now(), message: lastError });
+      const hint = diagnose(lastError);
+      logger.warn(
+        "brain attempt=%d failed: %s → hint: %s retryable=%s",
+        attempt,
+        lastError.slice(0, 200),
+        hint.message,
+        hint.retryable
+      );
+      session.errorHistory[session.errorHistory.length - 1].hint = hint.message;
+      if (!hint.retryable || attempt >= maxAttempts) {
+        throw new Error(`${lastError}
+诊断：${hint.message}`);
+      }
+      seed = randomSeed();
+    }
+  }
+  throw new Error(`brain 重试耗尽（${maxAttempts} 次）：${lastError}`);
+}
+async function runMainLlm(main, session, feedback, systemPrompt) {
+  const contextMessages = [];
+  contextMessages.push({ role: "system", content: systemPrompt });
+  for (const m of session.llmContext) contextMessages.push(m);
+  const userText = [
+    `[本轮反馈]
+${feedback || "（无新反馈，请按当前状态生成或微调一次）"}`,
+    `[当前 params 快照]
+${JSON.stringify(session.params)}`,
+    `[${VISION_REPORT_LABEL}]
+${session.materialAnalysis}`,
+    session.errorHistory.length ? `[错误历史(最近3条)]
+${session.errorHistory.slice(-3).map((e) => `- ${e.message}${e.hint ? `｜诊断:${e.hint}` : ""}`).join("\n")}` : "",
+    "请直接输出最终的 FLUX.2 prompt（英文自然语言一段），如需可另起一行以 NOTE: 开头给一句中文备注。"
+  ].filter(Boolean).join("\n\n");
+  const userMsg = { role: "user", content: userText };
+  contextMessages.push(userMsg);
+  const raw = await main.chat(contextMessages, { temperature: 0.7 });
+  const parsed = parsePrompt(raw);
+  session.llmContext.push(userMsg);
+  session.llmContext.push({ role: "assistant", content: parsed.prompt });
+  trimContext(session);
+  return parsed;
+}
+function parsePrompt(raw) {
+  let text = raw.trim().replace(/^```(?:text|prompt|en)?\s*/i, "").replace(/```$/i, "").trim();
+  if (!text) throw new Error("主 LLM 输出为空");
+  let note;
+  const noteLine = text.match(/\n?:?\s*NOTE:\s*([\s\S]*)$/i);
+  if (noteLine && noteLine.index !== void 0 && noteLine[1]) {
+    note = noteLine[1].trim();
+    text = text.slice(0, noteLine.index).trim();
+  }
+  let background;
+  const bgLine = text.match(/^BACKGROUND:\s*(.+)$/im);
+  if (bgLine && bgLine[1]) {
+    background = bgLine[1].trim();
+    text = text.replace(/^BACKGROUND:[^\n]*\n?/im, "").trim();
+  }
+  const prompt = text || (background ? "" : raw.trim());
+  return { prompt, note, background };
+}
+function pickOutputImage(history) {
+  const outs = history?.outputs;
+  if (!outs) return null;
+  const preferred = outs["save"];
+  const fromPreferred = preferred?.images?.[0];
+  if (fromPreferred) return fromPreferred;
+  for (const key of Object.keys(outs)) {
+    const img = outs[key]?.images?.[0];
+    if (img) return img;
+  }
+  return null;
+}
+function extractHistoryError(history) {
+  const msgs = history?.status?.messages;
+  if (!Array.isArray(msgs)) return "";
+  const parts = [];
+  for (const m of msgs) {
+    if (!Array.isArray(m)) continue;
+    if (m[0] === "execution_error" || m[0] === "execution_interrupted" || m[0] === "execution_cached") {
+      parts.push(JSON.stringify(m).slice(0, 300));
+    }
+  }
+  return parts.join(" | ");
+}
+function trimContext(session, maxMessages = 20) {
+  if (session.llmContext.length > maxMessages) {
+    session.llmContext.splice(0, session.llmContext.length - maxMessages);
+  }
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/agent/session.ts
+var SessionStore = class {
+  constructor(idleTimeoutMs) {
+    this.idleTimeoutMs = idleTimeoutMs;
+  }
+  map = /* @__PURE__ */ new Map();
+  sweepTimer = null;
+  /** 记录最近被空闲清除的会话 key → 清除时刻 ms（供“会话已过期”提示，区分“从未有会话”） */
+  recentlyExpired = /* @__PURE__ */ new Map();
+  key(input) {
+    if (!input.guildId) return `dm:${input.userId}`;
+    if (input.perUserInGroup) return `g:${input.channelId}:${input.userId}`;
+    return `g:${input.channelId}`;
+  }
+  get(key) {
+    const s = this.map.get(key);
+    if (!s) return void 0;
+    if (Date.now() - s.lastUsedAt > this.idleTimeoutMs) {
+      this.map.delete(key);
+      this.recentlyExpired.set(key, Date.now());
+      return void 0;
+    }
+    return s;
+  }
+  /** 该 key 是否有“刚过期”的会话（用于会话已过期提示；expiryWindowMs 内有效） */
+  wasRecentlyExpired(key, expiryWindowMs) {
+    const t = this.recentlyExpired.get(key);
+    if (t === void 0) return false;
+    if (Date.now() - t > expiryWindowMs) {
+      this.recentlyExpired.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /** 销毁后显式记录过期（用户 + 空清空 / 换图重建时），保证后续提示一致 */
+  markExpired(key) {
+    this.recentlyExpired.set(key, Date.now());
+  }
+  set(key, session) {
+    this.map.set(key, session);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  size() {
+    return this.map.size;
+  }
+  touch(session) {
+    session.lastUsedAt = Date.now();
+  }
+  startSweep(intervalMs = 5 * 60 * 1e3) {
+    if (this.sweepTimer) return;
+    this.sweepTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [k, s] of this.map) {
+        if (now - s.lastUsedAt > this.idleTimeoutMs) {
+          this.map.delete(k);
+          this.recentlyExpired.set(k, now);
+        }
+      }
+    }, intervalMs);
+    if (typeof this.sweepTimer === "object" && this.sweepTimer && "unref" in this.sweepTimer) {
+      ;
+      this.sweepTimer.unref();
+    }
+  }
+  stopSweep() {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+  }
+};
+var SerialLock = class {
+  chain = Promise.resolve();
+  run(task) {
+    const next = this.chain.then(task, task);
+    this.chain = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+};
+function initialParams(seed) {
+  return { seed };
+}
+
+// src/agent/render-facade.ts
+function createRenderFacade(deps) {
+  return {
+    async renderOneShot(input) {
+      const main = deps.getMainClient();
+      if (!main.enabled) {
+        throw new Error("主 LLM 未启用或未解析到 model，请在配置里补 baseUrl/apiKey/model 再试。");
+      }
+      const downloaded = await fetchImage(deps.ctx, input.imageUrl, deps.comfyTimeoutMs);
+      const filename = `input_${Date.now()}.${extForMime(downloaded.mimeType)}`;
+      const name2 = await deps.comfy.uploadImage(downloaded.buffer, filename, downloaded.mimeType);
+      const uploaded = { name: name2, mimeType: downloaded.mimeType, bytes: downloaded.buffer.length };
+      deps.logger.info("facade upload ok name=%s bytes=%d", name2, downloaded.buffer.length);
+      const baseParams = initialParams(randomSeed());
+      const merged = { ...baseParams, ...input.paramsOverride ?? {} };
+      if (!Number.isFinite(merged.seed) || merged.seed < 0) merged.seed = randomSeed();
+      if (input.confirmBrake) {
+        let analysis = "";
+        try {
+          const vision = deps.getVisionClient();
+          if (vision.enabled) {
+            analysis = await runAnalysisOnly(
+              {
+                main,
+                vision,
+                comfy: deps.comfy,
+                lock: deps.lock,
+                logger: deps.logger,
+                clientId: deps.clientId,
+                comfyTimeoutMs: deps.comfyTimeoutMs,
+                maxDiagnoseRetries: deps.maxDiagnoseRetries,
+                mainSystemPrompt: deps.mainSystemPrompt,
+                visionSystemPrompt: deps.visionSystemPrompt,
+                visionUserText: deps.visionUserText,
+                visionCrosscheckRounds: deps.visionCrosscheckRounds,
+                visionCrosscheckText: deps.visionCrosscheckText,
+                defaultBackgroundColor: deps.defaultBackgroundColor
+              },
+              downloaded.dataUrl
+            );
+          } else {
+            analysis = "（vision 未启用）";
+          }
+          deps.logger.info("facade confirmBrake analysis len=%d preview=%s", analysis.length, analysis.slice(0, 60).replace(/\s+/g, " "));
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw new Error(`视觉分析失败：${msg}`);
+        }
+        return {
+          buffer: Buffer.alloc(0),
+          filename: "",
+          params: merged,
+          comfyViewUrl: "",
+          awaitingAnalysis: analysis
+        };
+      }
+      const session = {
+        key: `chatluna:${input.userId}:${Date.now()}`,
+        channelId: input.channelId ?? "",
+        userId: input.userId,
+        guildId: input.guildId,
+        source: uploaded,
+        materialAnalysis: "",
+        turns: 0,
+        params: merged,
+        llmContext: [],
+        errorHistory: [],
+        createdAt: Date.now(),
+        lastUsedAt: Date.now(),
+        busy: false
+      };
+      const result = await runTurn(
+        {
+          main,
+          vision: deps.getVisionClient(),
+          comfy: deps.comfy,
+          lock: deps.lock,
+          logger: deps.logger,
+          clientId: deps.clientId,
+          comfyTimeoutMs: deps.comfyTimeoutMs,
+          maxDiagnoseRetries: deps.maxDiagnoseRetries,
+          mainSystemPrompt: deps.mainSystemPrompt,
+          visionSystemPrompt: deps.visionSystemPrompt,
+          visionUserText: deps.visionUserText,
+          visionCrosscheckRounds: deps.visionCrosscheckRounds,
+          visionCrosscheckText: deps.visionCrosscheckText,
+          defaultBackgroundColor: deps.defaultBackgroundColor
+        },
+        session,
+        input.instruction,
+        { runVision: true, sourceDataUrl: downloaded.dataUrl }
+      );
+      const comfyViewUrl = buildComfyViewUrl(deps.comfy.baseUrl, result.filename);
+      return {
+        buffer: result.imageBuffer,
+        filename: result.filename,
+        note: result.note,
+        params: result.params,
+        comfyViewUrl,
+        material: result.material,
+        lighting: result.lighting,
+        background: result.background
+      };
+    }
+  };
+}
+async function fetchImage(ctx, url, timeoutMs) {
+  let buffer;
+  let mimeType = "image/png";
+  if (url.startsWith("internal:") || url.startsWith("file:") || url.startsWith("data:")) {
+    const file = await ctx.http.file(url, { timeout: timeoutMs });
+    buffer = Buffer.from(file.data);
+    if (typeof file.type === "string" && file.type) mimeType = file.type;
+  } else {
+    const ab = await ctx.http.get(url, { responseType: "arraybuffer", timeout: timeoutMs });
+    buffer = Buffer.from(ab);
+    mimeType = sniffMime(buffer) || mimeType;
+  }
+  const dataUrl = `data:${mimeType};base64,${buffer.toString("base64")}`;
+  return { buffer, mimeType, dataUrl };
+}
+function sniffMime(buffer) {
+  if (buffer.length < 4) return null;
+  if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) return "image/png";
+  if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "image/jpeg";
+  if (buffer[0] === 71 && buffer[1] === 73 && buffer[2] === 70) return "image/gif";
+  if (buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70) return "image/webp";
+  return null;
+}
+function extForMime(mime) {
+  if (mime === "image/png") return "png";
+  if (mime === "image/jpeg") return "jpg";
+  if (mime === "image/gif") return "gif";
+  if (mime === "image/webp") return "webp";
+  return "png";
+}
+function buildComfyViewUrl(baseUrl, filename, subfolder = "", type = "output") {
+  const base = baseUrl.replace(/\/+$/, "");
+  return `${base}/view?filename=${encodeURIComponent(filename)}&subfolder=${encodeURIComponent(subfolder)}&type=${type}`;
+}
+
+// src/bridge/chatluna/runtime.ts
+var import_node_module = require("module");
+var runtimeRequire = (0, import_node_module.createRequire)(`${process.cwd()}/package.json`);
+async function loadChatLunaRuntime() {
+  const [chatlunaModule, langchainToolsModule] = await Promise.all([
+    loadRuntimeModule("koishi-plugin-chatluna/services/chat"),
+    loadRuntimeModule("@langchain/core/tools")
+  ]);
+  const ChatLunaPlugin = chatlunaModule.ChatLunaPlugin;
+  const StructuredTool = langchainToolsModule.StructuredTool;
+  if (!ChatLunaPlugin) {
+    throw new Error("ChatLunaPlugin export not found from koishi-plugin-chatluna/services/chat.");
+  }
+  if (!StructuredTool) {
+    throw new Error("StructuredTool export not found from @langchain/core/tools.");
+  }
+  return { ChatLunaPlugin, StructuredTool };
+}
+async function loadRuntimeModule(specifier) {
+  try {
+    return runtimeRequire(specifier);
+  } catch (requireError) {
+    const dynamicImport = new Function("s", "return import(s)");
+    return dynamicImport(specifier).catch((importError) => {
+      const requireMessage = requireError instanceof Error ? requireError.message : String(requireError);
+      const importMessage = importError instanceof Error ? importError.message : String(importError);
+      throw new Error(`failed to load runtime module "${specifier}"; require: ${requireMessage}; import: ${importMessage}`);
+    });
+  }
+}
+
+// src/bridge/chatluna/tool-runtime.ts
+var import_koishi2 = require("koishi");
+var TOOL_NAME = "comfy_render";
+var TOOL_DESCRIPTION = "Run one ComfyUI FLUX.2 image-to-image render through the aka-comfy-agent internal agent (GLM asset probe + DS material/lighting/background judgment + fixed snippet assembly + workflow submit/poll/fetch). Prefer this tool when the user wants to modify or continue iterating an existing image with natural language.";
+var TOOL_USAGE = "Provide the user instruction plus a referenceMode telling the tool where to load the source image from. The tool sends the rendered image back into the current session and returns { ok, imageUrl, note?, params? } as JSON.";
+var COMFY_USAGE_GUIDE = '使用准则（务必遵守）：\n1. 源图获取(referenceMode)：优先让用户"引用(quote)"要修改的那张图片，然后用 quoted_message 模式自动取图；若引用本会话前一张图或"上次生成的图"，用 last_generated；若用户给了图片 URL，用 explicit。仅在"当前这条用户消息本身直接带有图片"时才用 current_message——在 ChatLuna 里 current_message 通常拿不到上一条消息中的图。\n2. 拿不到源图时：不要长篇技术解释，也不许自己编一张图。直接引导用户：引用那张图片再发一次，或提供图片链接，或用文字描述画面。\n3. instruction 必须忠实转述用户的原话意图，禁止自行扩充或改写生成目标。\n4. 若工具的返回带 awaitingConfirmation / awaitingAnalysis，表示已进入确认闸：把图像分析报告转述给用户并等待其确认/修正，确认后再调用本工具真正生成，不要跳过确认直接出图。';
+var TOOL_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    instruction: {
+      type: "string",
+      description: "Natural-language instruction describing the desired modification / generation intent."
+    },
+    referenceMode: {
+      type: "string",
+      enum: ["current_message", "quoted_message", "explicit", "last_generated"],
+      description: "Where to load the source image from. Defaults to current_message."
+    },
+    imageUrls: {
+      type: "array",
+      items: { type: "string" },
+      description: "Explicit image URLs when referenceMode is explicit."
+    },
+    params: {
+      type: "object",
+      description: "Optional overrides for FLUX.2 render parameters (only seed is configurable; all other workflow params are fixed).",
+      properties: {
+        seed: { type: "number" }
+      },
+      additionalProperties: false
+    }
+  },
+  required: ["instruction"],
+  additionalProperties: false
+};
+function createComfyRenderToolInstance(StructuredTool, deps) {
+  return new class extends StructuredTool {
+    name = TOOL_NAME;
+    description = [
+      TOOL_DESCRIPTION,
+      `Usage: ${TOOL_USAGE}`,
+      COMFY_USAGE_GUIDE,
+      `Input JSON schema: ${JSON.stringify(TOOL_INPUT_SCHEMA)}`
+    ].join("\n");
+    schema = TOOL_INPUT_SCHEMA;
+    constructor() {
+      super({ verboseParsingErrors: true });
+    }
+    async _call(input, _runManager, runtimeConfig) {
+      const session = runtimeConfig?.configurable?.session;
+      if (!session?.userId) {
+        return formatToolError("会话无效，无法识别用户。");
+      }
+      try {
+        const cfg = runtimeConfig?.configurable ?? {};
+        const ac = cfg.agentContext;
+        const safe = (v, n = 120) => {
+          const s = typeof v === "string" ? v : JSON.stringify(v);
+          return !s ? "" : s.length > n ? s.slice(0, n) + "…" : s;
+        };
+        deps.logger?.info("[comfy_render] diag-config keys=%j", Object.keys(cfg));
+        deps.logger?.info(
+          "[comfy_render] diag-agentContext keys=%j conversationId=%s messages=%s",
+          ac ? Object.keys(ac) : "(none)",
+          ac?.conversationId ?? ac?.conversation_id ?? ac?.roomId ?? ac?.room_id ?? "",
+          Array.isArray(ac?.messages) ? `array(${ac.messages.length})` : typeof ac?.messages
+        );
+        if (Array.isArray(ac?.messages)) {
+          const lastImg = [...ac.messages].reverse().find((m) => {
+            const c = m?.content;
+            const s = typeof c === "string" ? c : JSON.stringify(c ?? "");
+            return /<img|image_url|data:image|internal:|img src/i.test(s);
+          });
+          deps.logger?.info(
+            "[comfy_render] diag-agentContext lastImageMsg role=%s contentHead=%s",
+            lastImg?.role ?? "",
+            safe(typeof lastImg?.content === "string" ? lastImg.content : JSON.stringify(lastImg?.content ?? ""), 200)
+          );
+        }
+        deps.logger?.info(
+          "[comfy_render] diag-session2 elements=%s eventKeys=%j",
+          Array.isArray(session.elements) ? safe(session.elements.map((e) => {
+            try {
+              return e && typeof e.toString === "function" ? e.toString() : String(e);
+            } catch {
+              return String(e);
+            }
+          }).join(" | ").slice(0, 200)) : typeof session.elements,
+          session.event ? Object.keys(session.event) : "(none)"
+        );
+        return await runComfyRender(input, session, deps);
+      } catch (error) {
+        return formatToolError(error instanceof Error ? error.message : String(error));
+      }
+    }
+  }();
+}
+async function runComfyRender(input, session, deps) {
+  const userId = session.userId;
+  if (deps.userTaskLocks.has(userId)) {
+    return formatToolError("您有一个 comfy 渲染任务正在进行中，请等待完成。");
+  }
+  deps.userTaskLocks.add(userId);
+  try {
+    const instruction = typeof input.instruction === "string" ? input.instruction.trim() : "";
+    if (!instruction) return formatToolError("instruction 必填。");
+    const referenceMode = typeof input.referenceMode === "string" ? input.referenceMode : "current_message";
+    const imageUrls = resolveReferenceImages(referenceMode, input, session, deps.lastGenerated);
+    const sourceUrl = imageUrls[0];
+    if (!sourceUrl) {
+      return formatToolError(
+        `未能解析到源图（referenceMode=${referenceMode}）。请按下面任一方式引导用户把源图提供给我，不要长篇技术解释，也不许自创一张图：(a) 让用户【引用(quote)】那张要修改的图片后再发一次 → 用 referenceMode=quoted_message；(b) 若是引用本会话刚生成/前一张图 → 用 referenceMode=last_generated；(c) 若用户能提供图片 URL → 用 referenceMode=explicit 并填 imageUrls。`
+      );
+    }
+    const paramsOverride = normalizeParamsOverride(input.params);
+    const confirmBrake = deps.getConfig().confirmBeforeGenerate?.chatluna === true;
+    const result = await deps.render.renderOneShot({
+      imageUrl: sourceUrl,
+      instruction,
+      paramsOverride,
+      userId,
+      channelId: session.channelId,
+      guildId: session.guildId,
+      confirmBrake
+    });
+    if (result.awaitingAnalysis) {
+      return formatToolJson({
+        ok: true,
+        awaitingConfirmation: true,
+        analysis: result.awaitingAnalysis,
+        instruction,
+        hint: "已将图像分析报告返回给模型。模型应向用户展示报告并征询确认/修正；用户确认后再次调用本工具生成（可附上修正后的 instruction）。"
+      });
+    }
+    if (typeof session.send === "function") {
+      try {
+        await Promise.resolve(session.send(import_koishi2.h.image(result.comfyViewUrl)));
+      } catch {
+      }
+    }
+    const config = deps.getConfig();
+    if (config.chatlunaRoomLastGenerated) {
+      const conversationId = resolveConversationId(session);
+      if (conversationId) {
+        deps.lastGenerated.set(conversationId, { imageUrl: result.comfyViewUrl, at: Date.now() });
+      }
+    }
+    return formatToolJson({
+      ok: true,
+      imageUrl: result.comfyViewUrl,
+      note: result.note,
+      params: result.params
+    });
+  } finally {
+    deps.userTaskLocks.delete(userId);
+  }
+}
+function resolveReferenceImages(referenceMode, input, session, lastGenerated) {
+  if (referenceMode === "explicit") {
+    return normalizeImageUrls(Array.isArray(input.imageUrls) ? input.imageUrls : []);
+  }
+  if (referenceMode === "last_generated") {
+    const conversationId = resolveConversationId(session);
+    if (!conversationId) return [];
+    const rec = lastGenerated.get(conversationId);
+    return rec ? [rec.imageUrl] : [];
+  }
+  if (referenceMode === "current_message") {
+    return parseImagesFromMessageContent(session.content);
+  }
+  if (referenceMode === "quoted_message") {
+    return normalizeImageUrls([
+      ...parseImagesFromMessageContent(session.quote?.content),
+      ...Array.isArray(session.quote?.elements) ? import_koishi2.h.select(session.quote.elements, "img").map((img) => img.attrs?.src) : []
+    ]);
+  }
+  return [];
+}
+var IMAGE_PLACEHOLDER_RE = /\[image:([^\]]+)\]/gi;
+function extractImagePlaceholders(text) {
+  const urls = [];
+  const re = new RegExp(IMAGE_PLACEHOLDER_RE.source, IMAGE_PLACEHOLDER_RE.flags);
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const u = (m[1] ?? "").trim();
+    if (u) urls.push(u);
+  }
+  return urls;
+}
+function parseImagesFromMessageContent(content) {
+  if (typeof content === "string" && content.trim()) {
+    return normalizeImageUrls([
+      ...import_koishi2.h.select(import_koishi2.h.parse(content), "img").map((img) => img.attrs?.src),
+      ...extractImagePlaceholders(content)
+    ]);
+  }
+  if (Array.isArray(content)) {
+    const urls = [];
+    for (const el of content) {
+      if (!el || typeof el !== "object") continue;
+      const type = el.type;
+      if (type === "img" && el.attrs?.src) {
+        urls.push(el.attrs.src);
+      } else if (type === "text" && el.attrs?.content) {
+        urls.push(...extractImagePlaceholders(String(el.attrs.content)));
+      }
+    }
+    return normalizeImageUrls(urls);
+  }
+  return [];
+}
+function normalizeImageUrls(items) {
+  return items.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
+}
+function resolveConversationId(session) {
+  const cid = session.conversationId ?? session.conversation_id ?? session.roomId ?? session.room_id;
+  if (typeof cid === "string" && cid.trim()) return cid.trim();
+  return void 0;
+}
+function normalizeParamsOverride(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const obj = v;
+  const patch = {};
+  const raw = obj["seed"];
+  if (typeof raw === "number" && Number.isFinite(raw)) patch.seed = raw;
+  else if (typeof raw === "string" && raw.trim() && Number.isFinite(Number(raw))) patch.seed = Number(raw);
+  return Object.keys(patch).length ? patch : void 0;
+}
+function formatToolError(message) {
+  return formatToolJson({ ok: false, error: message });
+}
+function formatToolJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+var TOOL_TRIGGER_RE = /comfy|v2|改图|重绘|渲染|换成|生成图像|把.{0,10}?(背景|颜色|风格|材质)|背景|配色|材质|毛绒|编辑.{0,4}图/i;
+function extractMessageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((block) => {
+      if (typeof block === "string") return block;
+      if (block && typeof block === "object") {
+        const anyBlock = block;
+        return [anyBlock.text, anyBlock.content_url, anyBlock.image_url, anyBlock.url].filter((v) => typeof v === "string").join(" ");
+      }
+      return "";
+    }).filter(Boolean).join(" ");
+  }
+  return "";
+}
+function shouldActivateComfyTool(messages) {
+  const arr = Array.isArray(messages) ? messages : [];
+  const last = arr[arr.length - 1];
+  if (!last) return false;
+  const text = extractMessageText(last.content).trim();
+  if (!text) return Boolean(last.images || last.elements);
+  if (/\[image:/i.test(text)) return true;
+  return TOOL_TRIGGER_RE.test(text) || /<img|!\[[^\]]*\]\(https?/.test(text);
+}
+
+// src/bridge/chatluna/manager.ts
+var CHATLUNA_BRIDGE_PLATFORM_NAME = "aka-comfy-agent-chatluna-bridge";
+var COMFY_RENDER_TOOL_NAME = "comfy_render";
+var ChatLunaBridgeManager = class {
+  constructor(ctx, deps, config, logger) {
+    this.ctx = ctx;
+    this.deps = deps;
+    this.config = config;
+    this.logger = logger;
+  }
+  chatLunaPlugin;
+  warnedUnavailable = false;
+  syncQueue = Promise.resolve();
+  getConfig = () => this.config;
+  updateConfig(config) {
+    this.config = config;
+  }
+  sync(enabled) {
+    this.syncQueue = this.syncQueue.catch(() => {
+    }).then(async () => {
+      if (enabled) await this.enable();
+      else await this.disable();
+    });
+    return this.syncQueue;
+  }
+  async dispose() {
+    await this.disable();
+  }
+  async enable() {
+    const chatlunaService = this.getChatLunaService();
+    if (!chatlunaService) {
+      if (!this.warnedUnavailable) {
+        this.logger.warn("ChatLuna bridge enabled, but ChatLuna service is not available. Install and enable ChatLuna first.");
+        this.warnedUnavailable = true;
+      }
+      return;
+    }
+    if (this.chatLunaPlugin) {
+      this.warnedUnavailable = false;
+      return;
+    }
+    const runtime2 = await loadChatLunaRuntime().catch((error) => {
+      if (!this.warnedUnavailable) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.warn("ChatLuna bridge enabled but runtime modules are unavailable: %s", message);
+        this.warnedUnavailable = true;
+      }
+      return null;
+    });
+    if (!runtime2) return;
+    const existing = chatlunaService.getPlugin?.(CHATLUNA_BRIDGE_PLATFORM_NAME);
+    if (existing) {
+      this.logger.warn('ChatLuna plugin name "%s" is already in use, skip built-in bridge registration.', CHATLUNA_BRIDGE_PLATFORM_NAME);
+      this.warnedUnavailable = true;
+      return;
+    }
+    const plugin = new runtime2.ChatLunaPlugin(this.ctx, {}, CHATLUNA_BRIDGE_PLATFORM_NAME, false);
+    this.registerTools(plugin, runtime2.StructuredTool);
+    if (!chatlunaService.getPlugin?.(CHATLUNA_BRIDGE_PLATFORM_NAME)) {
+      await Promise.resolve(chatlunaService.installPlugin(plugin));
+    }
+    this.chatLunaPlugin = plugin;
+    this.warnedUnavailable = false;
+    this.logger.info("ChatLuna bridge enabled (tool: %s).", COMFY_RENDER_TOOL_NAME);
+  }
+  async disable() {
+    if (!this.chatLunaPlugin) return;
+    const plugin = this.chatLunaPlugin;
+    this.chatLunaPlugin = void 0;
+    const chatlunaService = this.getChatLunaService();
+    try {
+      chatlunaService?.uninstallPlugin(plugin);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn("failed to uninstall ChatLuna bridge plugin: %s", message);
+    }
+    try {
+      await Promise.resolve(plugin.dispose?.());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn("failed to dispose ChatLuna bridge plugin: %s", message);
+    }
+    this.logger.info("ChatLuna bridge disabled.");
+  }
+  registerTools(plugin, StructuredTool) {
+    const deps = this.deps;
+    const getConfig = this.getConfig;
+    const logger = this.logger;
+    plugin.registerTool(COMFY_RENDER_TOOL_NAME, {
+      selector: (messages) => {
+        const arr = Array.isArray(messages) ? messages : [];
+        const last = arr[arr.length - 1];
+        const name2 = last && last.name || last && last._name || "";
+        const active = shouldActivateComfyTool(messages);
+        logger.info(
+          "[comfy_render] selector active=%s nmsg=%d lastRole=%s lastName=%s content=%j (head300=%s)",
+          active,
+          arr.length,
+          last?.role ?? "",
+          name2,
+          arr.length ? JSON.stringify(last?.content).slice(0, 600) : "(no msg)",
+          typeof last?.content === "string" ? last.content.slice(0, 300) : "(non-string)"
+        );
+        return active;
+      },
+      authorization(session) {
+        if (session?.userId) {
+          try {
+            logger.info(
+              "[comfy_render] diag-session keys=%j contentType=%s contentHead=%s elements=%s quote=%s msg=%s",
+              Object.keys(session),
+              typeof session.content,
+              typeof session.content === "string" ? "<" + session.content.slice(0, 220).replace(/data:[^,]{0,40}/g, "data:[DATA]") + ">" : "(non-string)",
+              Array.isArray(session.elements) ? `array(${session.elements.length})` : typeof session.elements,
+              session.quote ? JSON.stringify(Object.keys(session.quote)) : "no",
+              typeof session.message === "object" ? JSON.stringify(Object.keys(session.message)) : typeof session.message
+            );
+          } catch (e) {
+          }
+        }
+        return Boolean(session?.userId);
+      },
+      createTool() {
+        return createComfyRenderToolInstance(StructuredTool, {
+          render: deps.render,
+          getConfig,
+          lastGenerated: deps.lastGenerated,
+          userTaskLocks: deps.userTaskLocks,
+          logger
+        });
+      }
+    });
+  }
+  getChatLunaService() {
+    const service = this.ctx.chatluna;
+    if (!service) return null;
+    if (typeof service.installPlugin !== "function" || typeof service.uninstallPlugin !== "function") return null;
+    return service;
+  }
+};
+
+// src/index.ts
+var name = "aka-comfy-agent";
+var inject = { optional: ["chatluna"] };
+var runtime = {
+  store: null,
+  lock: new SerialLock(),
+  lastGenByConv: /* @__PURE__ */ new Map(),
+  userTaskLocks: /* @__PURE__ */ new Set(),
+  awaitingImage: /* @__PURE__ */ new Map()
+};
+function apply(ctx, config) {
+  const logger = ctx.logger(name);
+  if (!runtime.store || runtime.store.__idle !== config.session.idleTimeoutMs) {
+    if (runtime.store) runtime.store.stopSweep();
+    runtime.store = new SessionStore(config.session.idleTimeoutMs);
+    runtime.store.__idle = config.session.idleTimeoutMs;
+    runtime.store.startSweep();
+  }
+  const store = runtime.store;
+  const lock = runtime.lock;
+  const clientId = `koishi-aka-comfy-${Math.floor(Math.random() * 1e9)}`;
+  const awaitingImage = runtime.awaitingImage;
+  const AWAIT_TIMEOUT_MS = config.session.idleTimeoutMs;
+  const awaitSweeper = setInterval(() => {
+    const now = Date.now();
+    for (const [k, p] of awaitingImage) {
+      if (now - p.createdAt > AWAIT_TIMEOUT_MS) awaitingImage.delete(k);
+    }
+  }, 6e4);
+  awaitSweeper.unref?.();
+  const comfy = new ComfyClient(ctx, config.comfy.baseUrl, config.comfy.timeoutMs);
+  const brainDeps = () => ({
+    main: mainClient,
+    vision: visionClient,
+    comfy,
+    lock,
+    logger,
+    clientId,
+    comfyTimeoutMs: config.comfy.timeoutMs,
+    maxDiagnoseRetries: config.session.maxDiagnoseRetries,
+    mainSystemPrompt: config.mainLLM.systemPrompt?.trim() || MAIN_SYSTEM_PROMPT,
+    visionSystemPrompt: config.visionLLM.systemPrompt?.trim() || GLM_PROBE_PROMPT,
+    visionUserText: config.visionLLM.userText?.trim() || VISION_USER_TEXT,
+    visionCrosscheckRounds: config.visionCrosscheckRounds,
+    visionCrosscheckText: VISION_CROSSCHECK_TEXT,
+    defaultBackgroundColor: config.defaultBackgroundColor,
+    // Comfy 生成轮询期间编辑「正在生成」进度消息（约每 15s 一次，由 brain onTick 触发）
+    onGenerateProgress: (elapsedMs) => {
+      const g = genProgress;
+      if (!g) return;
+      const sec = Math.floor(elapsedMs / 1e3);
+      void reportProgress(g.session, g.handle, `正在生成，已等待 ${sec}s…`).then((h3) => {
+        if (genProgress === g) genProgress.handle = h3;
+      });
+    }
+  });
+  let mainClient = new LlmClient(ctx, config.mainLLM, config.mainLLM.model, config.comfy.timeoutMs);
+  let visionClient = new LlmClient(ctx, config.visionLLM, config.visionLLM.model, config.comfy.timeoutMs);
+  const schemaScope = ctx.schema;
+  const seedDynamic = (label, cfg, key) => {
+    if (!schemaScope) return;
+    const cur = cfg.model?.trim();
+    if (cur) {
+      schemaScope.set(key, import_koishi3.Schema.union([import_koishi3.Schema.const(cur).description(cur)]));
+    } else {
+      schemaScope.set(key, import_koishi3.Schema.string().description("模型（探测中，完成后可选）"));
+    }
+    logger.info("%s: 下拉占位已注册 key=%s cur=%s", label, key, cur || "(空)");
+  };
+  seedDynamic("main", config.mainLLM, "aka-comfy-agent.models.main");
+  seedDynamic("vision", config.visionLLM, "aka-comfy-agent.models.vision");
+  async function probeOptions(label, cfg) {
+    const name2 = label === "vision" ? "aka-comfy-agent.models.vision" : "aka-comfy-agent.models.main";
+    try {
+      const ids = await listModels(ctx, cfg, 15e3);
+      if (schemaScope) {
+        schemaScope.set(
+          name2,
+          import_koishi3.Schema.union(ids.map((id) => import_koishi3.Schema.const(id).description(id)))
+        );
+      }
+      logger.info("%s: 模型下拉 %d 个选项", label, ids.length);
+      return ids;
+    } catch (err) {
+      if (schemaScope) schemaScope.set(name2, import_koishi3.Schema.string().description("模型（无法获取列表，手动填写）"));
+      logger.warn("%s: 模型列表探测失败：%s", label, err instanceof Error ? err.message : String(err));
+      return [];
+    }
+  }
+  void (async () => {
+    const [mainIds, visionIds] = await Promise.all([
+      probeOptions("main", config.mainLLM),
+      probeOptions("vision", config.visionLLM)
+    ]);
+    const mainModel = config.mainLLM.model?.trim() || (config.mainLLM.enabled ? mainIds[0] ?? "" : "");
+    const visionModel = config.visionLLM.model?.trim() || (config.visionLLM.enabled ? visionIds[0] ?? "" : "");
+    if (mainModel) mainClient = new LlmClient(ctx, config.mainLLM, mainModel, config.comfy.timeoutMs);
+    if (visionModel) visionClient = new LlmClient(ctx, config.visionLLM, visionModel, config.comfy.timeoutMs);
+    const snapMain = config.mainLLM.enabled && !config.mainLLM.model?.trim() && mainIds.length > 0;
+    const snapVision = config.visionLLM.enabled && !config.visionLLM.model?.trim() && visionIds.length > 0;
+    if ((snapMain || snapVision) && ctx.scope?.update) {
+      try {
+        await ctx.scope.update({
+          ...config,
+          mainLLM: { ...config.mainLLM, model: snapMain ? mainIds[0] : config.mainLLM.model },
+          visionLLM: { ...config.visionLLM, model: snapVision ? visionIds[0] : config.visionLLM.model }
+        });
+        logger.info("已自动切到第一个模型：main=%s vision=%s", snapMain ? mainIds[0] : "-", snapVision ? visionIds[0] : "-");
+      } catch (err) {
+        logger.warn("自动切换模型持久化失败：%s", err instanceof Error ? err.message : String(err));
+      }
+    }
+    logger.info("models resolved main=%s vision=%s", mainClient.model || "(disabled)", visionClient.model || "(disabled)");
+  })();
+  logger.info("aka-comfy-agent apply comfy=%s clientId=%s", config.comfy.baseUrl, clientId);
+  const renderFacade = createRenderFacade({
+    ctx,
+    logger,
+    comfy,
+    getMainClient: () => mainClient,
+    getVisionClient: () => visionClient,
+    lock,
+    clientId,
+    comfyTimeoutMs: config.comfy.timeoutMs,
+    maxDiagnoseRetries: config.session.maxDiagnoseRetries,
+    mainSystemPrompt: config.mainLLM.systemPrompt?.trim() || MAIN_SYSTEM_PROMPT,
+    visionSystemPrompt: config.visionLLM.systemPrompt?.trim() || GLM_PROBE_PROMPT,
+    visionUserText: config.visionLLM.userText?.trim() || VISION_USER_TEXT,
+    visionCrosscheckRounds: config.visionCrosscheckRounds,
+    visionCrosscheckText: VISION_CROSSCHECK_TEXT,
+    defaultBackgroundColor: config.defaultBackgroundColor
+  });
+  const lastGeneratedStore = {
+    get: (id) => runtime.lastGenByConv.get(id),
+    set: (id, rec) => {
+      runtime.lastGenByConv.set(id, rec);
+    }
+  };
+  const chatLunaBridge = new ChatLunaBridgeManager(
+    ctx,
+    { render: renderFacade, lastGenerated: lastGeneratedStore, userTaskLocks: runtime.userTaskLocks },
+    config,
+    logger
+  );
+  ctx.inject?.(["chatluna"], async () => {
+    await chatLunaBridge.sync(Boolean(config.chatlunaEnabled));
+  });
+  ctx.accept?.(
+    ["chatlunaEnabled", "chatlunaRoomLastGenerated"],
+    (nextConfig) => {
+      chatLunaBridge.updateConfig(nextConfig);
+      if (ctx.chatluna) {
+        void chatLunaBridge.sync(Boolean(nextConfig.chatlunaEnabled));
+      }
+    },
+    { immediate: true }
+  );
+  ctx.on("dispose", async () => {
+    clearInterval(awaitSweeper);
+    await chatLunaBridge.dispose();
+  });
+  function pickImageUrl(elements) {
+    if (!elements?.length) return null;
+    const imgs = import_koishi3.h.select(elements, "img");
+    for (const el of imgs) {
+      const src = el.attrs?.src;
+      if (typeof src === "string" && src) return src;
+    }
+    return null;
+  }
+  let genProgress;
+  async function reportProgress(session, handle, text) {
+    if (handle?.mid) {
+      try {
+        await session.bot.editMessage(session.channelId ?? "", handle.mid, text);
+        return handle;
+      } catch (err) {
+        logger.warn("progress edit failed (will fall back to new message): %s", errMsg2(err));
+      }
+    }
+    const mid = await session.send(text);
+    return { mid: Array.isArray(mid) ? mid[0] : String(mid ?? "") };
+  }
+  function pickText(elements) {
+    if (!elements?.length) return "";
+    let out = "";
+    const walk = (arr) => {
+      for (const el of arr) {
+        if (el.type === "text" && typeof el.attrs?.content === "string") out += el.attrs.content;
+        if (el.children?.length) walk(el.children);
+      }
+    };
+    walk(elements);
+    return out.trim();
+  }
+  async function fetchImage2(url) {
+    let buffer;
+    let mimeType = "image/png";
+    if (url.startsWith("internal:") || url.startsWith("file:") || url.startsWith("data:")) {
+      const file = await ctx.http.file(url, { timeout: config.comfy.timeoutMs });
+      buffer = Buffer.from(file.data);
+      if (typeof file.type === "string" && file.type) mimeType = file.type;
+    } else {
+      const ab = await ctx.http.get(url, { responseType: "arraybuffer", timeout: config.comfy.timeoutMs });
+      buffer = Buffer.from(ab);
+      mimeType = sniffMime2(buffer) || mimeType;
+    }
+    const dataUrl = `data:${mimeType};base64,${buffer.toString("base64")}`;
+    return { buffer, mimeType, dataUrl };
+  }
+  function keyFor(session) {
+    if (session.isDirect) return `dm:${session.userId ?? "unknown"}`;
+    const channelId = session.channelId ?? session.userId ?? "unknown";
+    if (config.session.perUserInGroup) return `g:${channelId}:${session.userId ?? "unknown"}`;
+    return `g:${channelId}`;
+  }
+  async function startOrRestartSession(session, imageUrl, intent) {
+    if (!mainClient.enabled) {
+      return "主 LLM 未启用或未解析到 model：先在配置里补 baseUrl/apiKey/model（或让 /v1/models 可用），再试。";
+    }
+    let downloaded;
+    try {
+      downloaded = await fetchImage2(imageUrl);
+    } catch (err) {
+      logger.warn("fetchImage failed: %s", errMsg2(err));
+      return `图片下载失败：${errMsg2(err)}`;
+    }
+    let uploaded;
+    try {
+      const filename = `input_${Date.now()}.${extForMime2(downloaded.mimeType)}`;
+      const name2 = await comfy.uploadImage(downloaded.buffer, filename, downloaded.mimeType);
+      uploaded = { name: name2, mimeType: downloaded.mimeType, bytes: downloaded.buffer.length };
+      logger.info("uploaded to comfy name=%s bytes=%d", name2, downloaded.buffer.length);
+    } catch (err) {
+      logger.warn("comfy upload failed: %s", errMsg2(err));
+      return `上传 ComfyUI 失败：${errMsg2(err)}`;
+    }
+    const params = initialParams(randomSeed());
+    const newSession = {
+      key: keyFor(session),
+      channelId: session.channelId ?? "",
+      userId: session.userId ?? "",
+      guildId: session.guildId,
+      source: uploaded,
+      materialAnalysis: "",
+      turns: 0,
+      params,
+      llmContext: [],
+      errorHistory: [],
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      busy: false
+    };
+    store.set(newSession.key, newSession);
+    if (config.confirmBeforeGenerate.command && downloaded.dataUrl) {
+      try {
+        await reportProgress(session, void 0, `已收到图片（${(downloaded.buffer.length / 1048576).toFixed(1)} MB）✓ 正在解析角色资产清单…`);
+        const analysis = await runAnalysisOnly(brainDeps(), downloaded.dataUrl);
+        newSession.materialAnalysis = analysis;
+        newSession.pendingConfirm = { analysis, intent };
+        store.set(newSession.key, newSession);
+        logger.info("confirm gate armed key=%s analysis_len=%d", newSession.key, analysis.length);
+        return formatConfirmPrompt(analysis, intent);
+      } catch (err) {
+        logger.warn("confirm gate vision analysis failed, fall back to direct generation: %s", errMsg2(err));
+        return await performTurn(session, newSession, intent, { runVision: true, sourceDataUrl: downloaded.dataUrl });
+      }
+    }
+    return await performTurn(session, newSession, intent, { runVision: true, sourceDataUrl: downloaded.dataUrl });
+  }
+  async function performTurn(session, convo, feedbackIn, opts) {
+    if (convo.busy) return "本会话上一轮还在跑，等它结束再发。";
+    if (convo.turns >= config.session.maxTurns) {
+      return `会话已达上限（${config.session.maxTurns} 轮）。发「退出」重开。`;
+    }
+    if (!mainClient.enabled) return "主 LLM 未启用/未解析到 model。";
+    convo.busy = true;
+    convo.turns += 1;
+    store.touch(convo);
+    let feedback = feedbackIn;
+    if (convo.pendingConfirm) {
+      convo.materialAnalysis = convo.pendingConfirm.analysis;
+      const intent = convo.pendingConfirm.intent;
+      const corrections = convo.pendingConfirm.corrections ?? [];
+      convo.pendingConfirm = void 0;
+      feedback = [intent, ...corrections, feedbackIn ? `[用户确认] ${feedbackIn}` : ""].filter(Boolean).join("\n");
+      store.touch(convo);
+    }
+    try {
+      const mid = await reportProgress(session, void 0, "正在生成…");
+      genProgress = { session, handle: mid };
+      const result = await runTurn(
+        brainDeps(),
+        convo,
+        feedback,
+        opts
+      );
+      genProgress = void 0;
+      await reportProgress(session, mid, "生成完毕 ✓");
+      const parts = [];
+      parts.push(import_koishi3.h.image(result.imageBuffer, mimeFromFilename(result.filename)));
+      const noteLine = result.note ? `做法：${result.note}
+` : "";
+      const meta = `seed=${result.params.seed}` + (result.material ? ` · 材质=${result.material}` : "") + (result.lighting ? ` · 灯光=${result.lighting}` : "") + (result.background ? ` · 背景=${result.background}` : "");
+      parts.push((0, import_koishi3.h)("text", { content: `
+${noteLine}${meta}
+${statusBar(convo, config.session.maxTurns, "可改图")}` }));
+      return parts;
+    } catch (err) {
+      logger.warn("performTurn failed key=%s turn=%d: %s", convo.key, convo.turns, errMsg2(err));
+      if (genProgress) {
+        const g = genProgress;
+        genProgress = void 0;
+        await reportProgress(g.session, g.handle, `生成失败：${errMsg2(err)}`);
+      }
+      return `本轮失败：${errMsg2(err)}`;
+    } finally {
+      convo.busy = false;
+      store.touch(convo);
+    }
+  }
+  ctx.command("comfy [...content:text]", "ComfyUI FLUX.2 图生图 + agent 迭代（支持分步接图：先 comfy 记意图/等图，再单独发图开始）").alias("v2").example("comfy 把背景换成黄色").example("comfy <图> 把背景换成草原，加强毛绒质感").action(async ({ session }, ...contentArgs) => {
+    if (!session) return;
+    const text = (contentArgs.join(" ") || "").trim();
+    const elements = session.elements;
+    const imageUrl = pickImageUrl(elements);
+    const key = keyFor(session);
+    const existing = store.get(key);
+    if (!imageUrl && isExitIntent(text)) {
+      return destroyComfy(key);
+    }
+    if (!existing) {
+      if (imageUrl) {
+        awaitingImage.delete(key);
+        return await startOrRestartSession(session, imageUrl, text || "（用户未给具体意图，请按材质分层做保守增强）");
+      }
+      awaitingImage.set(key, { text, createdAt: Date.now() });
+      return text ? `已记录意图「${text}」。请发送要处理的图片（一张），收到后立即开始生成。` : "请发送要处理的图片（一张），收到后立即开始生成。";
+    }
+    if (imageUrl) {
+      awaitingImage.delete(key);
+      store.delete(key);
+      return await startOrRestartSession(session, imageUrl, text || "（用户换了源图，请重新分析并给出保守首轮）");
+    }
+    if (!text) return "会话已在进行中：附上文字反馈来触发下一轮；或发「退出」重开。";
+    return await performTurn(session, existing, text, { runVision: false });
+  });
+  ctx.command("comfy.help", "查看 comfy 使用说明", { authority: 1 }).alias("帮助").action(async () => helpText());
+  ctx.command("comfy.status", "查看当前 comfy 会话参数与错误史", { authority: 1 }).alias("状态").action(async ({ session }) => {
+    if (!session) return;
+    return statusText(store.get(keyFor(session)));
+  });
+  ctx.command("comfy.clear", "销毁当前会话，离开循环回到聊天", { authority: 1 }).alias("退出").action(async ({ session }) => {
+    if (!session) return;
+    const key = keyFor(session);
+    awaitingImage.delete(key);
+    const removed = store.delete(key);
+    return removed ? "已销毁本会话，已离开循环。" : "当前没有会话。";
+  });
+  function destroyComfy(key) {
+    const hadAwait = awaitingImage.delete(key);
+    const removed = store.delete(key);
+    if (removed) return "已销毁本会话，已离开循环。";
+    if (hadAwait) return "已离开循环（清空了等待中的会话）。";
+    return "当前没有进行中的 comfy 会话。";
+  }
+  ctx.middleware(async (session, next) => {
+    if (!session.channelId && !session.userId) return next();
+    const key = keyFor(session);
+    const elements = session.elements;
+    const imageUrl = pickImageUrl(elements);
+    if (imageUrl) {
+      const pendingImg = awaitingImage.get(key);
+      if (!pendingImg) return next();
+      if (Date.now() - pendingImg.createdAt > AWAIT_TIMEOUT_MS) {
+        awaitingImage.delete(key);
+        return "等图状态已超时（超过空闲时限）。请重新发 comfy，再发图开始。";
+      }
+      awaitingImage.delete(key);
+      const text = (pickText(elements) || pendingImg.text || "").trim();
+      return await startOrRestartSession(
+        session,
+        imageUrl,
+        text || "（用户未给具体意图，请按材质分层做保守增强）"
+      );
+    }
+    const rawContent = pickText(elements) || (session.content ?? "").toString().trim();
+    if (!rawContent) return next();
+    if (/^\s*[./!\\]?\s*(comfy|v2)\b/i.test(rawContent)) return next();
+    if (isExitIntent(rawContent) && (awaitingImage.get(key) || store.get(key))) {
+      logger.info("cmt: bare exit key=%s text=%s", key, rawContent.slice(0, 30));
+      return destroyComfy(key);
+    }
+    const pendingAwait = awaitingImage.get(key);
+    if (pendingAwait) {
+      pendingAwait.text = rawContent;
+      pendingAwait.createdAt = Date.now();
+      return `已更新意图「${rawContent}」，请发送要处理的图片。`;
+    }
+    const convo = store.get(key);
+    if (!convo) {
+      if (store.wasRecentlyExpired(key, AWAIT_TIMEOUT_MS)) {
+        logger.info("cmt: expired session key=%s text=%s", key, rawContent.slice(0, 30));
+        return `你的图像会话已因空闲超时结束（超过 ${Math.round(config.session.idleTimeoutMs / 6e4)} 分钟无操作）。发「comfy <图> <意图>」重新开始。`;
+      }
+      logger.info(
+        "cmt: no session, pass down key=%s direct=%s channel=%s user=%s text=%s",
+        key,
+        !!session.isDirect,
+        session.channelId ?? "",
+        session.userId ?? "",
+        rawContent.slice(0, 30)
+      );
+      return next();
+    }
+    if (convo.pendingConfirm && !convo.busy) {
+      logger.info(
+        "cmt: pendingConfirm enter key=%s isConfirm=%s text=%s",
+        key,
+        isConfirmWord((rawContent || "").trim()),
+        (rawContent || "").slice(0, 30)
+      );
+      if (imageUrl) return next();
+      const text = rawContent.trim();
+      if (!text) return "正在等待你对视觉分析结果的确认：回复确认词开始生成，或直接描述需要修正的地方。";
+      if (isExitIntent(text)) {
+        return destroyComfy(key);
+      }
+      if (isConfirmWord(text)) {
+        logger.info("cmt: confirmed by word key=%s text=%s", key, text);
+        return await performTurn(session, convo, "", { runVision: false });
+      }
+      convo.pendingConfirm.analysis = `${convo.pendingConfirm.analysis}
+
+[用户修正]
+${text}`;
+      convo.pendingConfirm.corrections = [...convo.pendingConfirm.corrections ?? [], text];
+      convo.materialAnalysis = convo.pendingConfirm.analysis;
+      store.touch(convo);
+      return `已记录你的修正：「${text}」。
+
+${formatConfirmPrompt(convo.pendingConfirm.analysis, convo.pendingConfirm.intent)}`;
+    }
+    if (convo.busy) return "本会话上一轮还在跑，稍等它完成再发。";
+    if (isLikelyChatter(rawContent)) {
+      logger.info("cmt: chatter detected key=%s text=%s", key, rawContent.slice(0, 30));
+      return [
+        `「${rawContent.slice(0, 60)}」看起来不像改图指令。`,
+        `你当前在 COMFY 工作循环里（第 ${convo.turns}/${config.session.maxTurns} 轮）：`,
+        `- 想调整这张图：直接说改法，如「毛再蓬一点」「背景换红」`,
+        `- 想离开循环回到聊天：直接发「清空」或「退出」，无需 comfy 前缀`
+      ].join("\n");
+    }
+    return await performTurn(session, convo, rawContent, { runVision: false });
+  });
+  function statusText(convo) {
+    if (!convo) return '当前没有会话。发 "comfy <图> <意图>" 开新的。';
+    const errs = convo.errorHistory.slice(-3).map((e) => `- ${e.message}${e.hint ? `｜${e.hint}` : ""}`).join("\n") || "（无）";
+    return [
+      `会话：key=${convo.key}`,
+      `轮次：${convo.turns}/${config.session.maxTurns}`,
+      `源图：name=${convo.source.name} bytes=${convo.source.bytes}`,
+      `参数：${JSON.stringify(convo.params)}`,
+      `视觉报告：${convo.materialAnalysis.slice(0, 200)}`,
+      `最近错误：
+${errs}`
+    ].join("\n");
+  }
+  function helpText() {
+    return [
+      "ComfyUI FLUX.2 图生图 agent（本期仅 i2i）：",
+      "- comfy <图> <意图>：一条消息带图+意图，立即开始",
+      "- comfy <意图>：分步接图，先记意图再等图，收到图自动开始（或 comfy 后直接发图）",
+      "- 会话内直接发「退出」：销毁当前会话，离开循环回到聊天（无需 comfy 前缀）",
+      "- comfy 状态：查看会话参数与错误史",
+      "- comfy 帮助：本页",
+      `- 每会话 ${config.session.maxTurns} 轮上限；空闲 ${Math.round(config.session.idleTimeoutMs / 6e4)} 分钟自动销毁。`
+    ].join("\n");
+  }
+}
+function sniffMime2(buffer) {
+  if (buffer.length < 4) return null;
+  if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) return "image/png";
+  if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "image/jpeg";
+  if (buffer[0] === 71 && buffer[1] === 73 && buffer[2] === 70) return "image/gif";
+  if (buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70) return "image/webp";
+  return null;
+}
+function extForMime2(mime) {
+  if (mime === "image/png") return "png";
+  if (mime === "image/jpeg") return "jpg";
+  if (mime === "image/gif") return "gif";
+  if (mime === "image/webp") return "webp";
+  return "png";
+}
+function mimeFromFilename(filename) {
+  const lower = filename.toLowerCase();
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".webp")) return "image/webp";
+  return "image/png";
+}
+function errMsg2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function statusBar(convo, maxTurns, state) {
+  const label = `【COMFY · 第 ${convo.turns}/${maxTurns} 轮${state ? `｜${state}` : ""}】`;
+  return [
+    ``,
+    label,
+    `想继续调整就直接发文字（如「毛再蓬一点」「背景换红」），会在这张图上迭代。`,
+    `离开循环回到聊天：直接发「退出」。`
+  ].join("\n");
+}
+var CONFIRM_WORDS = /* @__PURE__ */ new Set(["确认", "开始", "生成", "可以", "好", "好的", "ok", "OK", "Ok", "oK", "yes", "Yes", "YES", "go", "start", "没问题", "就这个", "就这样", "同意", "干"]);
+function isConfirmWord(text) {
+  const t = text.trim().toLowerCase().replace(/[。．.!！?？,，~～\s]/g, "");
+  if (!t) return false;
+  if (CONFIRM_WORDS.has(t)) return true;
+  if (/^(确认|开始|生成|可以|好|ok|yes|go|没问题|就这样|同意|干)$/.test(t)) return true;
+  return false;
+}
+var EDIT_SIGNAL_RE = /(背景|材质|毛绒|毛|质感|灯光|光照|颜色|色调|配色|肤色|毛发|睫毛|亮|暗|深|浅|饱和度|对比度|锐化|模糊|清晰|重画|再画|放大|缩小|构图|比例|裁剪|seed|种子|风格|角度|透视|阴影|高光|线条|细节|氛围|改|换|加|去|变|红|橙|黄|绿|蓝|紫|粉|黑|白|灰|金|银|卡通|写实|厚涂|薄涂|塑料|金属|布料|皮毛|皮肤|眼睛|头发|脸部|衣|帽子|鞋子)/i;
+var CHATTER_SIGNAL_RE = /(你好|在吗|在不在|谢谢|多谢|辛苦|拜拜|再见|哈哈|嘿嘿|不错|太棒|好棒|厉害|牛逼|你是|你是谁|你会|你能|会画|聊天|别的|其他|还能|还会|什么|为什么|怎么用|多少钱|退出|不弄了|算了|到此为止|停)/i;
+function isLikelyChatter(text) {
+  const t = (text || "").trim();
+  if (!t) return false;
+  if (EDIT_SIGNAL_RE.test(t)) return false;
+  return CHATTER_SIGNAL_RE.test(t);
+}
+var EXIT_INTENT_RE = /^(退出|算了|不弄了|停止|离开|quit|exit|stop|bye)(了|吧|啦|哦)?$/i;
+function isExitIntent(text) {
+  const t = (text || "").trim();
+  return EXIT_INTENT_RE.test(t);
+}
+function formatConfirmPrompt(analysis, intent) {
+  const preview = analysis && analysis.length > 900 ? `${analysis.slice(0, 900)}…` : analysis || "（无）";
+  return [
+    `【图像分析 · 待确认】`,
+    `意图：${intent || "（未提供，将按材质分层做保守增强）"}`,
+    ``,
+    `视觉分析结果：`,
+    preview,
+    ``,
+    `回复「确认」开始生成;或直接描述要修正的地方（如：它是黑色的毛, 领子是红的, 不要偏色），会并入分析后再等你确认。`,
+    `【COMFY 循环 · 待确认】想离开循环回聊天：直接发「清空」或「退出」。`
+  ].join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});
+//# sourceMappingURL=index.js.map