koishi-plugin-chatluna 1.3.6 → 1.3.8

package/lib/index.cjs

@@ -3249,7 +3249,7 @@ __name(apply24, "apply");
 var import_logger3 = require("koishi-plugin-chatluna/utils/logger");
 var import_crypto4 = require("crypto");
 var logger6;
-var batches = /* @__PURE__ */ new Map();
+var queues = /* @__PURE__ */ new Map();
 function apply25(ctx, config, chain) {
   logger6 = (0, import_logger3.createLogger)(ctx);
   chain.middleware("message_delay", async (session, context) => {
@@ -3261,171 +3261,162 @@ function apply25(ctx, config, chain) {
     const conversationId = room.conversationId;
     const userName = inputMessage.name || "unknown";
     const messageId = context.options.messageId;
-    const batch = batches.get(conversationId);
-    if (!batch) {
+    const conversation = queues.get(conversationId) ?? {
+      turns: [],
+      inFlight: false
+    };
+    queues.set(conversationId, conversation);
+    const tailTurn = conversation.turns[conversation.turns.length - 1];
+    let turn;
+    if (tailTurn && tailTurn.state !== "processing" && tailTurn.userName === userName) {
+      turn = tailTurn;
       logger6.debug(
-        `Creating new batch for ${conversationId}, messageId: ${messageId}`
+        `Joining turn for ${conversationId}, messageId: ${messageId}, user: ${userName}, total: ${turn.messages.length + 1}`
       );
-      const newBatch = {
-        messages: [inputMessage],
+    } else {
+      const state = conversation.turns.length === 0 && config.messageQueueDelay > 0 ? "collecting" : "waiting";
+      turn = {
+        messages: [],
         userName,
-        resolveWaiters: []
+        state
       };
-      batches.set(conversationId, newBatch);
-      if (config.messageQueueDelay > 0) {
-        return await new Promise(
-          (resolve) => {
-            newBatch.processorResolve = resolve;
-            newBatch.timeout = ctx.setTimeout(() => {
-              if (batches.get(conversationId) === newBatch) {
-                logger6.debug(
-                  // eslint-disable-next-line max-len
-                  `Delay timeout (${config.messageQueueDelay}s) for ${conversationId}, processing batch with ${newBatch.messages.length} messages`
-                );
-                context.options.inputMessage = mergeMessages(newBatch.messages);
-                batches.delete(conversationId);
-                resolve(2 /* CONTINUE */);
-              }
-            }, config.messageQueueDelay * 1e3);
-          }
-        );
-      }
-      return 2 /* CONTINUE */;
-    }
-    if (batch.userName !== userName) {
+      conversation.turns.push(turn);
       logger6.debug(
-        `User mismatch for ${conversationId}, messageId: ${messageId}, waiting for batch completion`
-      );
-      return await waitForBatchCompletion(
-        batch,
-        conversationId,
-        inputMessage,
-        userName,
-        context
+        `Creating new turn for ${conversationId}, messageId: ${messageId}, user: ${userName}, queue: ${conversation.turns.length}`
       );
     }
-    if (batch.resolveWaiters.length === 0) {
-      logger6.debug(
-        `Adding message to batch for ${conversationId}, messageId: ${messageId}, total: ${batch.messages.length + 1}`
-      );
-      batch.messages.push(inputMessage);
-      if (config.messageQueueDelay > 0 && batch.timeout && batch.processorResolve) {
-        batch.timeout();
-        batch.timeout = ctx.setTimeout(() => {
-          if (batches.get(conversationId) === batch && batch.processorResolve) {
-            logger6.debug(
-              `Delay timeout (${config.messageQueueDelay}s) for ${conversationId}, processing batch with ${batch.messages.length} messages`
-            );
-            context.options.inputMessage = mergeMessages(
-              batch.messages
-            );
-            batches.delete(conversationId);
-            batch.processorResolve(
-              2 /* CONTINUE */
-            );
-          }
-        }, config.messageQueueDelay * 1e3);
-      }
-      return 1 /* STOP */;
+    turn.messages.push(inputMessage);
+    const statusPromise = awaitTurnStart(turn, context);
+    if (turn.state === "collecting") {
+      resetTurnTimeout(ctx, config, conversationId, turn);
     }
-    logger6.debug(
-      `Interrupting and merging for ${conversationId}, messageId: ${messageId}`
-    );
-    return await interruptAndMerge(batch, inputMessage, context);
+    tryStartHeadTurn(conversationId, conversation);
+    return await statusPromise;
   }).after("check_room").after("read_chat_message").before("lifecycle-handle_command");
-  const completeBatch = /* @__PURE__ */ __name(async (conversationId) => {
-    const batch = batches.get(conversationId);
-    if (batch?.resolveWaiters.length > 0) {
+  const completeTurn = /* @__PURE__ */ __name(async (conversationId) => {
+    const conversation = queues.get(conversationId);
+    if (!conversation) {
+      return;
+    }
+    const current = conversation.turns.shift();
+    conversation.inFlight = false;
+    if (current?.timeout) {
+      current.timeout();
+    }
+    if (current?.starter) {
+      current.starter.resolve(1 /* STOP */);
+      current.starter = void 0;
+    }
+    if (conversation.turns.length === 0) {
+      queues.delete(conversationId);
+      return;
+    }
+    tryStartHeadTurn(conversationId, conversation);
+    if (current) {
       logger6.debug(
-        `Completing batch for ${conversationId}, messages: ${batch.messages.length}`
+        `Completing turn for ${conversationId}, remaining: ${conversation.turns.length}`
       );
-      if (batch.timeout) {
-        batch.timeout();
-      }
-      batch.resolveWaiters.forEach((resolve) => resolve());
-      batches.delete(conversationId);
-    } else if (batch) {
-      logger6.debug(`Cleaning up batch for ${conversationId}`);
-      if (batch.timeout) {
-        batch.timeout();
-      }
-      if (batch.processorResolve) {
-        batch.processorResolve(1 /* STOP */);
-      }
-      batches.delete(conversationId);
     }
-  }, "completeBatch");
-  ctx.on(
-    "chatluna/after-chat",
-    async (conversationId) => await completeBatch(conversationId)
-  );
+  }, "completeTurn");
+  ctx.on("chatluna/after-chat", completeTurn);
   ctx.on(
     "chatluna/after-chat-error",
-    async (_, conversationId) => await completeBatch(conversationId)
+    (_, conversationId) => completeTurn(conversationId)
   );
   ctx.on("chatluna/clear-chat-history", async (conversationId) => {
-    const batch = batches.get(conversationId);
-    if (batch) {
+    const conversation = queues.get(conversationId);
+    if (conversation) {
+      const stoppedWaiters = conversation.turns.filter(
+        (turn) => !!turn.starter
+      ).length;
       logger6.debug(
-        `Clearing chat history for ${conversationId}, stopping ${batch.resolveWaiters.length} waiters`
-      );
-      if (batch.timeout) {
-        batch.timeout();
-      }
-      batch.resolveWaiters.forEach(
-        (resolve) => resolve(1 /* STOP */)
+        `Clearing chat history for ${conversationId}, stopping ${stoppedWaiters} waiters`
       );
-      if (batch.processorResolve) {
-        batch.processorResolve(1 /* STOP */);
+      for (const turn of conversation.turns) {
+        if (turn.timeout) {
+          turn.timeout();
+          turn.timeout = void 0;
+        }
+        if (turn.starter) {
+          turn.starter.resolve(1 /* STOP */);
+          turn.starter = void 0;
+        }
       }
-      batches.delete(conversationId);
+      queues.delete(conversationId);
     }
   });
 }
 __name(apply25, "apply");
-async function interruptAndMerge(batch, message, context) {
-  const oldWaiters = batch.resolveWaiters;
-  const oldProcessor = batch.processorResolve;
-  batch.resolveWaiters = [];
-  batch.processorResolve = void 0;
-  batch.messages.push(message);
-  if (batch.timeout) {
-    batch.timeout();
-    batch.timeout = void 0;
-  }
-  oldWaiters.forEach((resolve) => resolve(1 /* STOP */));
-  if (oldProcessor) {
-    oldProcessor(1 /* STOP */);
+function awaitTurnStart(turn, context) {
+  if (turn.starter) {
+    turn.starter.resolve(1 /* STOP */);
+    turn.starter = void 0;
   }
   return new Promise((resolve) => {
-    batch.resolveWaiters.push(() => {
-      context.options.inputMessage = mergeMessages(batch.messages);
-      resolve(2 /* CONTINUE */);
-    });
+    turn.starter = { resolve, context };
   });
 }
-__name(interruptAndMerge, "interruptAndMerge");
-async function waitForBatchCompletion(batch, conversationId, message, userName, context) {
-  return new Promise((resolve) => {
-    batch.resolveWaiters.push(() => {
-      batches.set(conversationId, {
-        messages: [message],
-        userName,
-        resolveWaiters: [
-          () => {
-            const newBatch = batches.get(conversationId);
-            context.options.inputMessage = mergeMessages(
-              newBatch.messages
-            );
-            batches.delete(conversationId);
-            resolve(2 /* CONTINUE */);
-          }
-        ]
-      });
-    });
-  });
+__name(awaitTurnStart, "awaitTurnStart");
+function resetTurnTimeout(ctx, config, conversationId, turn) {
+  if (turn.timeout) {
+    turn.timeout();
+  }
+  turn.timeout = ctx.setTimeout(() => {
+    const conversation = queues.get(conversationId);
+    if (!conversation || conversation.turns[0] !== turn) {
+      return;
+    }
+    turn.state = "waiting";
+    turn.timeout = void 0;
+    if (conversation.inFlight) {
+      return;
+    }
+    logger6.debug(
+      // eslint-disable-next-line max-len
+      `Delay timeout (${config.messageQueueDelay}s) for ${conversationId}, starting turn with ${turn.messages.length} messages`
+    );
+    startHeadTurn(conversationId, conversation, turn);
+  }, config.messageQueueDelay * 1e3);
 }
-__name(waitForBatchCompletion, "waitForBatchCompletion");
+__name(resetTurnTimeout, "resetTurnTimeout");
+function tryStartHeadTurn(conversationId, conversation) {
+  if (conversation.inFlight) {
+    return;
+  }
+  const head = conversation.turns[0];
+  if (!head) {
+    queues.delete(conversationId);
+    return;
+  }
+  if (head.state === "collecting") {
+    return;
+  }
+  startHeadTurn(conversationId, conversation, head);
+}
+__name(tryStartHeadTurn, "tryStartHeadTurn");
+function startHeadTurn(conversationId, conversation, head) {
+  if (conversation.inFlight) {
+    return;
+  }
+  if (conversation.turns[0] !== head) {
+    return;
+  }
+  if (!head.starter) {
+    return;
+  }
+  if (head.timeout) {
+    head.timeout();
+    head.timeout = void 0;
+  }
+  const starter = head.starter;
+  head.starter = void 0;
+  conversation.inFlight = true;
+  head.state = "processing";
+  starter.context.options.inputMessage = mergeMessages(head.messages);
+  head.messages = [];
+  starter.resolve(2 /* CONTINUE */);
+}
+__name(startHeadTurn, "startHeadTurn");
 function mergeMessages(messages) {
   if (messages.length === 1) return messages[0];
   const base = messages[0];
@@ -3595,8 +3586,86 @@ function apply26(ctx, config, chain) {
       )
     );
   });
+  ctx.inject(["chatluna_storage"], (ctx2) => {
+    logger7.debug("chatluna_storage service loaded.");
+    ctx2.effect(
+      () => ctx2.chatluna.messageTransformer.intercept(
+        "file",
+        async (session, element, message) => {
+          const fileName = element.attrs["file"] ?? element.attrs["name"];
+          const src = element.attrs["src"];
+          let buffer;
+          if (src.startsWith("http")) {
+            buffer = await readFile(ctx2, src);
+          } else {
+            buffer = await readPlatformFile(ctx2, session, element);
+          }
+          if (!buffer?.buffer) {
+            logger7.warn(
+              `Failed to read file for element: ${element.toString()}`
+            );
+            return;
+          }
+          const file = await ctx2.chatluna_storage.createTempFile(
+            buffer.buffer,
+            fileName
+          );
+          addMessageContent(message, `File: ${file.name} ${file.url}`);
+        }
+      )
+    );
+  });
 }
 __name(apply26, "apply");
+async function readPlatformFile(ctx, session, element) {
+  const fileId = element.attrs["fileId"];
+  let fileUrl;
+  if (session.platform === "onebot") {
+    const bot = session.bot;
+    if (session.isDirect) {
+      fileUrl = await bot.internal.getPrivateFileUrl(
+        session.userId,
+        fileId
+      );
+    } else {
+      fileUrl = await bot.internal.getGroupFileUrl(
+        session.guildId,
+        fileId,
+        element["busId"]
+      );
+    }
+  }
+  if (!fileUrl) {
+    logger7.warn(`Failed to get file URL for element: ${element.toString()}`);
+    return;
+  }
+  return await readFile(ctx, fileUrl);
+}
+__name(readPlatformFile, "readPlatformFile");
+async function readFile(ctx, url) {
+  try {
+    const response = await ctx.http(url, {
+      responseType: "arraybuffer",
+      method: "get",
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
+      }
+    });
+    const buffer = Buffer.from(response.data);
+    const base64 = buffer.toString("base64");
+    return {
+      base64Source: base64,
+      buffer
+    };
+  } catch (error) {
+    logger7.error(`Failed to read file from ${url}:`, error);
+    return {
+      base64Source: null,
+      buffer: null
+    };
+  }
+}
+__name(readFile, "readFile");
 async function readImage(ctx, url) {
   if (url.startsWith("data:image") && url.includes("base64")) {
     const buffer = Buffer.from(url.split(",")[1], "base64");

package/lib/index.mjs

@@ -3244,7 +3244,7 @@ __name(apply24, "apply");
 import { createLogger as createLogger3 } from "koishi-plugin-chatluna/utils/logger";
 import { randomUUID } from "crypto";
 var logger6;
-var batches = /* @__PURE__ */ new Map();
+var queues = /* @__PURE__ */ new Map();
 function apply25(ctx, config, chain) {
   logger6 = createLogger3(ctx);
   chain.middleware("message_delay", async (session, context) => {
@@ -3256,171 +3256,162 @@ function apply25(ctx, config, chain) {
     const conversationId = room.conversationId;
     const userName = inputMessage.name || "unknown";
     const messageId = context.options.messageId;
-    const batch = batches.get(conversationId);
-    if (!batch) {
+    const conversation = queues.get(conversationId) ?? {
+      turns: [],
+      inFlight: false
+    };
+    queues.set(conversationId, conversation);
+    const tailTurn = conversation.turns[conversation.turns.length - 1];
+    let turn;
+    if (tailTurn && tailTurn.state !== "processing" && tailTurn.userName === userName) {
+      turn = tailTurn;
       logger6.debug(
-        `Creating new batch for ${conversationId}, messageId: ${messageId}`
+        `Joining turn for ${conversationId}, messageId: ${messageId}, user: ${userName}, total: ${turn.messages.length + 1}`
       );
-      const newBatch = {
-        messages: [inputMessage],
+    } else {
+      const state = conversation.turns.length === 0 && config.messageQueueDelay > 0 ? "collecting" : "waiting";
+      turn = {
+        messages: [],
         userName,
-        resolveWaiters: []
+        state
       };
-      batches.set(conversationId, newBatch);
-      if (config.messageQueueDelay > 0) {
-        return await new Promise(
-          (resolve) => {
-            newBatch.processorResolve = resolve;
-            newBatch.timeout = ctx.setTimeout(() => {
-              if (batches.get(conversationId) === newBatch) {
-                logger6.debug(
-                  // eslint-disable-next-line max-len
-                  `Delay timeout (${config.messageQueueDelay}s) for ${conversationId}, processing batch with ${newBatch.messages.length} messages`
-                );
-                context.options.inputMessage = mergeMessages(newBatch.messages);
-                batches.delete(conversationId);
-                resolve(2 /* CONTINUE */);
-              }
-            }, config.messageQueueDelay * 1e3);
-          }
-        );
-      }
-      return 2 /* CONTINUE */;
-    }
-    if (batch.userName !== userName) {
+      conversation.turns.push(turn);
       logger6.debug(
-        `User mismatch for ${conversationId}, messageId: ${messageId}, waiting for batch completion`
-      );
-      return await waitForBatchCompletion(
-        batch,
-        conversationId,
-        inputMessage,
-        userName,
-        context
+        `Creating new turn for ${conversationId}, messageId: ${messageId}, user: ${userName}, queue: ${conversation.turns.length}`
       );
     }
-    if (batch.resolveWaiters.length === 0) {
-      logger6.debug(
-        `Adding message to batch for ${conversationId}, messageId: ${messageId}, total: ${batch.messages.length + 1}`
-      );
-      batch.messages.push(inputMessage);
-      if (config.messageQueueDelay > 0 && batch.timeout && batch.processorResolve) {
-        batch.timeout();
-        batch.timeout = ctx.setTimeout(() => {
-          if (batches.get(conversationId) === batch && batch.processorResolve) {
-            logger6.debug(
-              `Delay timeout (${config.messageQueueDelay}s) for ${conversationId}, processing batch with ${batch.messages.length} messages`
-            );
-            context.options.inputMessage = mergeMessages(
-              batch.messages
-            );
-            batches.delete(conversationId);
-            batch.processorResolve(
-              2 /* CONTINUE */
-            );
-          }
-        }, config.messageQueueDelay * 1e3);
-      }
-      return 1 /* STOP */;
+    turn.messages.push(inputMessage);
+    const statusPromise = awaitTurnStart(turn, context);
+    if (turn.state === "collecting") {
+      resetTurnTimeout(ctx, config, conversationId, turn);
     }
-    logger6.debug(
-      `Interrupting and merging for ${conversationId}, messageId: ${messageId}`
-    );
-    return await interruptAndMerge(batch, inputMessage, context);
+    tryStartHeadTurn(conversationId, conversation);
+    return await statusPromise;
   }).after("check_room").after("read_chat_message").before("lifecycle-handle_command");
-  const completeBatch = /* @__PURE__ */ __name(async (conversationId) => {
-    const batch = batches.get(conversationId);
-    if (batch?.resolveWaiters.length > 0) {
+  const completeTurn = /* @__PURE__ */ __name(async (conversationId) => {
+    const conversation = queues.get(conversationId);
+    if (!conversation) {
+      return;
+    }
+    const current = conversation.turns.shift();
+    conversation.inFlight = false;
+    if (current?.timeout) {
+      current.timeout();
+    }
+    if (current?.starter) {
+      current.starter.resolve(1 /* STOP */);
+      current.starter = void 0;
+    }
+    if (conversation.turns.length === 0) {
+      queues.delete(conversationId);
+      return;
+    }
+    tryStartHeadTurn(conversationId, conversation);
+    if (current) {
       logger6.debug(
-        `Completing batch for ${conversationId}, messages: ${batch.messages.length}`
+        `Completing turn for ${conversationId}, remaining: ${conversation.turns.length}`
       );
-      if (batch.timeout) {
-        batch.timeout();
-      }
-      batch.resolveWaiters.forEach((resolve) => resolve());
-      batches.delete(conversationId);
-    } else if (batch) {
-      logger6.debug(`Cleaning up batch for ${conversationId}`);
-      if (batch.timeout) {
-        batch.timeout();
-      }
-      if (batch.processorResolve) {
-        batch.processorResolve(1 /* STOP */);
-      }
-      batches.delete(conversationId);
     }
-  }, "completeBatch");
-  ctx.on(
-    "chatluna/after-chat",
-    async (conversationId) => await completeBatch(conversationId)
-  );
+  }, "completeTurn");
+  ctx.on("chatluna/after-chat", completeTurn);
   ctx.on(
     "chatluna/after-chat-error",
-    async (_, conversationId) => await completeBatch(conversationId)
+    (_, conversationId) => completeTurn(conversationId)
   );
   ctx.on("chatluna/clear-chat-history", async (conversationId) => {
-    const batch = batches.get(conversationId);
-    if (batch) {
+    const conversation = queues.get(conversationId);
+    if (conversation) {
+      const stoppedWaiters = conversation.turns.filter(
+        (turn) => !!turn.starter
+      ).length;
       logger6.debug(
-        `Clearing chat history for ${conversationId}, stopping ${batch.resolveWaiters.length} waiters`
-      );
-      if (batch.timeout) {
-        batch.timeout();
-      }
-      batch.resolveWaiters.forEach(
-        (resolve) => resolve(1 /* STOP */)
+        `Clearing chat history for ${conversationId}, stopping ${stoppedWaiters} waiters`
       );
-      if (batch.processorResolve) {
-        batch.processorResolve(1 /* STOP */);
+      for (const turn of conversation.turns) {
+        if (turn.timeout) {
+          turn.timeout();
+          turn.timeout = void 0;
+        }
+        if (turn.starter) {
+          turn.starter.resolve(1 /* STOP */);
+          turn.starter = void 0;
+        }
       }
-      batches.delete(conversationId);
+      queues.delete(conversationId);
     }
   });
 }
 __name(apply25, "apply");
-async function interruptAndMerge(batch, message, context) {
-  const oldWaiters = batch.resolveWaiters;
-  const oldProcessor = batch.processorResolve;
-  batch.resolveWaiters = [];
-  batch.processorResolve = void 0;
-  batch.messages.push(message);
-  if (batch.timeout) {
-    batch.timeout();
-    batch.timeout = void 0;
-  }
-  oldWaiters.forEach((resolve) => resolve(1 /* STOP */));
-  if (oldProcessor) {
-    oldProcessor(1 /* STOP */);
+function awaitTurnStart(turn, context) {
+  if (turn.starter) {
+    turn.starter.resolve(1 /* STOP */);
+    turn.starter = void 0;
   }
   return new Promise((resolve) => {
-    batch.resolveWaiters.push(() => {
-      context.options.inputMessage = mergeMessages(batch.messages);
-      resolve(2 /* CONTINUE */);
-    });
+    turn.starter = { resolve, context };
   });
 }
-__name(interruptAndMerge, "interruptAndMerge");
-async function waitForBatchCompletion(batch, conversationId, message, userName, context) {
-  return new Promise((resolve) => {
-    batch.resolveWaiters.push(() => {
-      batches.set(conversationId, {
-        messages: [message],
-        userName,
-        resolveWaiters: [
-          () => {
-            const newBatch = batches.get(conversationId);
-            context.options.inputMessage = mergeMessages(
-              newBatch.messages
-            );
-            batches.delete(conversationId);
-            resolve(2 /* CONTINUE */);
-          }
-        ]
-      });
-    });
-  });
+__name(awaitTurnStart, "awaitTurnStart");
+function resetTurnTimeout(ctx, config, conversationId, turn) {
+  if (turn.timeout) {
+    turn.timeout();
+  }
+  turn.timeout = ctx.setTimeout(() => {
+    const conversation = queues.get(conversationId);
+    if (!conversation || conversation.turns[0] !== turn) {
+      return;
+    }
+    turn.state = "waiting";
+    turn.timeout = void 0;
+    if (conversation.inFlight) {
+      return;
+    }
+    logger6.debug(
+      // eslint-disable-next-line max-len
+      `Delay timeout (${config.messageQueueDelay}s) for ${conversationId}, starting turn with ${turn.messages.length} messages`
+    );
+    startHeadTurn(conversationId, conversation, turn);
+  }, config.messageQueueDelay * 1e3);
 }
-__name(waitForBatchCompletion, "waitForBatchCompletion");
+__name(resetTurnTimeout, "resetTurnTimeout");
+function tryStartHeadTurn(conversationId, conversation) {
+  if (conversation.inFlight) {
+    return;
+  }
+  const head = conversation.turns[0];
+  if (!head) {
+    queues.delete(conversationId);
+    return;
+  }
+  if (head.state === "collecting") {
+    return;
+  }
+  startHeadTurn(conversationId, conversation, head);
+}
+__name(tryStartHeadTurn, "tryStartHeadTurn");
+function startHeadTurn(conversationId, conversation, head) {
+  if (conversation.inFlight) {
+    return;
+  }
+  if (conversation.turns[0] !== head) {
+    return;
+  }
+  if (!head.starter) {
+    return;
+  }
+  if (head.timeout) {
+    head.timeout();
+    head.timeout = void 0;
+  }
+  const starter = head.starter;
+  head.starter = void 0;
+  conversation.inFlight = true;
+  head.state = "processing";
+  starter.context.options.inputMessage = mergeMessages(head.messages);
+  head.messages = [];
+  starter.resolve(2 /* CONTINUE */);
+}
+__name(startHeadTurn, "startHeadTurn");
 function mergeMessages(messages) {
   if (messages.length === 1) return messages[0];
   const base = messages[0];
@@ -3594,8 +3585,86 @@ function apply26(ctx, config, chain) {
       )
     );
   });
+  ctx.inject(["chatluna_storage"], (ctx2) => {
+    logger7.debug("chatluna_storage service loaded.");
+    ctx2.effect(
+      () => ctx2.chatluna.messageTransformer.intercept(
+        "file",
+        async (session, element, message) => {
+          const fileName = element.attrs["file"] ?? element.attrs["name"];
+          const src = element.attrs["src"];
+          let buffer;
+          if (src.startsWith("http")) {
+            buffer = await readFile(ctx2, src);
+          } else {
+            buffer = await readPlatformFile(ctx2, session, element);
+          }
+          if (!buffer?.buffer) {
+            logger7.warn(
+              `Failed to read file for element: ${element.toString()}`
+            );
+            return;
+          }
+          const file = await ctx2.chatluna_storage.createTempFile(
+            buffer.buffer,
+            fileName
+          );
+          addMessageContent(message, `File: ${file.name} ${file.url}`);
+        }
+      )
+    );
+  });
 }
 __name(apply26, "apply");
+async function readPlatformFile(ctx, session, element) {
+  const fileId = element.attrs["fileId"];
+  let fileUrl;
+  if (session.platform === "onebot") {
+    const bot = session.bot;
+    if (session.isDirect) {
+      fileUrl = await bot.internal.getPrivateFileUrl(
+        session.userId,
+        fileId
+      );
+    } else {
+      fileUrl = await bot.internal.getGroupFileUrl(
+        session.guildId,
+        fileId,
+        element["busId"]
+      );
+    }
+  }
+  if (!fileUrl) {
+    logger7.warn(`Failed to get file URL for element: ${element.toString()}`);
+    return;
+  }
+  return await readFile(ctx, fileUrl);
+}
+__name(readPlatformFile, "readPlatformFile");
+async function readFile(ctx, url) {
+  try {
+    const response = await ctx.http(url, {
+      responseType: "arraybuffer",
+      method: "get",
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
+      }
+    });
+    const buffer = Buffer.from(response.data);
+    const base64 = buffer.toString("base64");
+    return {
+      base64Source: base64,
+      buffer
+    };
+  } catch (error) {
+    logger7.error(`Failed to read file from ${url}:`, error);
+    return {
+      base64Source: null,
+      buffer: null
+    };
+  }
+}
+__name(readFile, "readFile");
 async function readImage(ctx, url) {
   if (url.startsWith("data:image") && url.includes("base64")) {
     const buffer = Buffer.from(url.split(",")[1], "base64");

package/lib/llm-core/agent/openai/index.d.ts

@@ -22,4 +22,4 @@ export type CreateOpenAIAgentParams = {
 };
 export declare function createOpenAIAgent({ llm, tools, prompt }: CreateOpenAIAgentParams): RunnableSequence<{
     steps: AgentStep[];
-}, AgentAction | AgentFinish | AgentAction[]>;
+}, AgentAction | AgentAction[] | AgentFinish>;

package/lib/llm-core/agent/openai/output_parser.d.ts

@@ -12,7 +12,7 @@ export declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputP
     lc_namespace: string[];
     static lc_name(): string;
     parse(text: string): Promise<AgentAction | AgentFinish>;
-    parseResult(generations: ChatGeneration[]): Promise<FunctionsAgentAction | AgentFinish>;
+    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;
     /**
      * Parses the output message into a FunctionsAgentAction or AgentFinish
      * object.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna",
   "description": "chatluna for koishi",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "main": "lib/index.cjs",
   "module": "lib/index.mjs",
   "typings": "lib/index.d.ts",
@@ -226,8 +226,8 @@
     "langchain"
   ],
   "dependencies": {
-    "@chatluna/shared-prompt-renderer": "^1.0.3",
-    "@langchain/core": "0.3.62",
+    "@chatluna/shared-prompt-renderer": "^1.0.4",
+    "@langchain/core": "^0.3.80",
     "@vue/reactivity": "^3.6.0-alpha.2",
     "decimal.js": "^10.6.0",
     "he": "^1.2.0",
@@ -254,11 +254,12 @@
     "@types/js-yaml": "^4.0.9",
     "@types/qrcode": "^1.5.5",
     "@types/useragent": "^2",
-    "atsc": "^2.1.0"
+    "atsc": "^2.1.0",
+    "koishi-plugin-adapter-onebot": "^6.8.0"
   },
   "peerDependencies": {
     "koishi": "^4.18.9",
-    "koishi-plugin-chatluna-storage-service": "^0.0.11"
+    "koishi-plugin-chatluna-storage-service": "^1.0.1"
   },
   "peerDependenciesMeta": {
     "koishi-plugin-chatluna-storage-service": {
@@ -266,16 +267,16 @@
     }
   },
   "resolutions": {
-    "@langchain/core": "0.3.62",
+    "@langchain/core": "^0.3.80",
     "js-tiktoken": "npm:@dingyi222666/js-tiktoken@^1.0.21"
   },
   "overrides": {
-    "@langchain/core": "0.3.62",
+    "@langchain/core": "^0.3.80",
     "js-tiktoken": "npm:@dingyi222666/js-tiktoken@^1.0.21"
   },
   "pnpm": {
     "overrides": {
-      "@langchain/core": "0.3.62",
+      "@langchain/core": "^0.3.80",
       "js-tiktoken": "npm:@dingyi222666/js-tiktoken@^1.0.21"
     }
   },