koishi-plugin-chatluna-long-memory 1.3.4 → 1.3.6

package/lib/index.cjs

@@ -68,20 +68,41 @@ var import_logger = require("koishi-plugin-chatluna/utils/logger");
 var import_koishi_plugin_chatluna = require("koishi-plugin-chatluna");
 var import_chains = require("koishi-plugin-chatluna/chains");
 var import_crypto = require("crypto");
+
+// src/utils/conversation.ts
+async function getMemoryScope(ctx, session, options) {
+  const resolved = await ctx.chatluna.conversation.resolveContext(session, {
+    conversationId: options.conversationId,
+    presetLane: options.presetLane
+  });
+  const conversation = resolved.conversation;
+  if (conversation == null) {
+    return null;
+  }
+  return {
+    conversation,
+    preset: options.type ?? resolved.effectivePreset ?? conversation.preset,
+    info: {
+      presetId: options.type ?? resolved.effectivePreset ?? conversation.preset,
+      guildId: session.guildId || session.channelId,
+      userId: session.userId
+    }
+  };
+}
+__name(getMemoryScope, "getMemoryScope");
+
+// src/plugins/add_memory.ts
 function apply(ctx, config) {
   const chain = ctx.chatluna.chatChain;
   chain.middleware(
     "add_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, content, room, view }
+        options: { type, content, view, conversationId, presetLane }
       } = context;
       if (command !== "add_memory")
         return import_chains.ChainMiddlewareRunStatus.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -95,13 +116,18 @@ function apply(ctx, config) {
         }
       }
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".add_failed");
+          return import_chains.ChainMiddlewareRunStatus.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
@@ -120,7 +146,7 @@ function apply(ctx, config) {
             ])
           )
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".add_success");
       } catch (error) {
         import_koishi_plugin_chatluna.logger?.error(error);
@@ -1045,15 +1071,12 @@ function apply3(ctx, config) {
   chain.middleware(
     "clear_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, room, view }
+        options: { type, view, conversationId, presetLane }
       } = context;
       if (command !== "clear_memory")
         return import_chains2.ChainMiddlewareRunStatus.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -1067,19 +1090,24 @@ function apply3(ctx, config) {
         }
       }
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".clear_failed");
+          return import_chains2.ChainMiddlewareRunStatus.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
           layers.map((layer) => layer.clearMemories())
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".clear_success");
       } catch (error) {
         import_koishi_plugin_chatluna3.logger?.error(error);
@@ -1107,15 +1135,12 @@ function apply5(ctx, config) {
   chain.middleware(
     "delete_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, room, ids, view }
+        options: { type, ids, view, conversationId, presetLane }
       } = context;
       if (command !== "delete_memory")
         return import_chains3.ChainMiddlewareRunStatus.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -1129,19 +1154,24 @@ function apply5(ctx, config) {
         }
       }
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".delete_failed");
+          return import_chains3.ChainMiddlewareRunStatus.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
           layers.map((layer) => layer.deleteMemories(ids))
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".delete_success");
       } catch (error) {
         import_koishi_plugin_chatluna4.logger?.error(error);
@@ -1162,15 +1192,18 @@ function apply6(ctx, config) {
   chain.middleware(
     "edit_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, room, memoryId, view }
+        options: {
+          type,
+          memoryId,
+          view,
+          conversationId,
+          presetLane
+        }
       } = context;
       if (command !== "edit_memory")
         return import_chains4.ChainMiddlewareRunStatus.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -1185,16 +1218,25 @@ function apply6(ctx, config) {
       }
       try {
         await session.send(session.text(".edit_memory_start"));
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".edit_failed");
+          return import_chains4.ChainMiddlewareRunStatus.STOP;
+        }
         const content = await session.prompt();
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
           {
-            presetId: type,
+            ...scope.info,
             userId: session.userId,
             guildId: session.guildId || session.channelId,
             type: parsedLayerType,
             memoryId
           },
-          room.conversationId,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
@@ -1208,7 +1250,7 @@ function apply6(ctx, config) {
         await Promise.all(
           layers.map((layer) => layer.addMemories([memory]))
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".edit_success");
       } catch (error) {
         import_koishi_plugin_chatluna5.logger?.error(error);
@@ -2854,16 +2896,21 @@ function apply9(ctx, config) {
   chain.middleware(
     "search_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { page, limit, query, type, room, view }
+        options: {
+          page,
+          limit,
+          query,
+          type,
+          view,
+          conversationId,
+          presetLane
+        }
       } = context;
       if (command !== "search_memory") {
         return import_chains5.ChainMiddlewareRunStatus.SKIPPED;
       }
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -2887,19 +2934,24 @@ function apply9(ctx, config) {
       pagination.updateFormatItem(
         (value) => formatDocumentInfo(session, value)
       );
-      query = query ?? " ";
+      const content = query ?? " ";
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".search_failed");
+          return import_chains5.ChainMiddlewareRunStatus.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         const documents = await Promise.all(
-          layers.map((layer) => layer.retrieveMemory(query))
+          layers.map((layer) => layer.retrieveMemory(content))
         ).then((documents2) => documents2.flat());
         await pagination.push(documents);
         context.message = await pagination.getFormattedPage(
@@ -2951,6 +3003,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "search"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "none"
+      }
+    },
     createTool(params2) {
       return new MemorySearchTool(ctx, params2);
     }
@@ -2960,6 +3023,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "add"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "all"
+      }
+    },
     createTool(params2) {
       return new MemoryAddTool(ctx, params2);
     }
@@ -2969,6 +3043,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "delete"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "all"
+      }
+    },
     createTool(params2) {
       return new MemoryDeleteTool(ctx, params2);
     }
@@ -2978,6 +3063,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "update"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "all"
+      }
+    },
     createTool(params2) {
       return new MemoryUpdateTool(ctx, params2);
     }
@@ -3310,12 +3406,24 @@ var ChatLunaLongMemoryService = class extends import_koishi.Service {
       (layer) => MemoryRetrievalLayerType[layer.toUpperCase()]
     ).filter((v) => v != null);
     this.defaultLayerTypes.push(...mapped);
-    ctx.on(
-      "chatluna/clear-chat-history",
-      async (conversationId, _chatInterface) => {
-        delete this._memoryLayerNamespaces[conversationId];
-      }
-    );
+    const clear = /* @__PURE__ */ __name((conversationId) => {
+      delete this._memoryLayerNamespaces[conversationId];
+    }, "clear");
+    ctx.on("chatluna/conversation-after-clear-history", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-cache-clear", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-archive", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-restore", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-delete", async (payload) => {
+      clear(payload.conversation.id);
+    });
     ctx.setInterval(
       async () => {
         for (const [, layers] of Object.entries(

package/lib/index.mjs

@@ -28,20 +28,41 @@ import { createLogger } from "koishi-plugin-chatluna/utils/logger";
 import { logger } from "koishi-plugin-chatluna";
 import { ChainMiddlewareRunStatus } from "koishi-plugin-chatluna/chains";
 import { randomUUID } from "crypto";
+
+// src/utils/conversation.ts
+async function getMemoryScope(ctx, session, options) {
+  const resolved = await ctx.chatluna.conversation.resolveContext(session, {
+    conversationId: options.conversationId,
+    presetLane: options.presetLane
+  });
+  const conversation = resolved.conversation;
+  if (conversation == null) {
+    return null;
+  }
+  return {
+    conversation,
+    preset: options.type ?? resolved.effectivePreset ?? conversation.preset,
+    info: {
+      presetId: options.type ?? resolved.effectivePreset ?? conversation.preset,
+      guildId: session.guildId || session.channelId,
+      userId: session.userId
+    }
+  };
+}
+__name(getMemoryScope, "getMemoryScope");
+
+// src/plugins/add_memory.ts
 function apply(ctx, config) {
   const chain = ctx.chatluna.chatChain;
   chain.middleware(
     "add_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, content, room, view }
+        options: { type, content, view, conversationId, presetLane }
       } = context;
       if (command !== "add_memory")
         return ChainMiddlewareRunStatus.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -55,13 +76,18 @@ function apply(ctx, config) {
         }
       }
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".add_failed");
+          return ChainMiddlewareRunStatus.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
@@ -80,7 +106,7 @@ function apply(ctx, config) {
             ])
           )
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".add_success");
       } catch (error) {
         logger?.error(error);
@@ -1008,15 +1034,12 @@ function apply3(ctx, config) {
   chain.middleware(
     "clear_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, room, view }
+        options: { type, view, conversationId, presetLane }
       } = context;
       if (command !== "clear_memory")
         return ChainMiddlewareRunStatus2.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -1030,19 +1053,24 @@ function apply3(ctx, config) {
         }
       }
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".clear_failed");
+          return ChainMiddlewareRunStatus2.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
           layers.map((layer) => layer.clearMemories())
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".clear_success");
       } catch (error) {
         logger5?.error(error);
@@ -1070,15 +1098,12 @@ function apply5(ctx, config) {
   chain.middleware(
     "delete_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, room, ids, view }
+        options: { type, ids, view, conversationId, presetLane }
       } = context;
       if (command !== "delete_memory")
         return ChainMiddlewareRunStatus3.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -1092,19 +1117,24 @@ function apply5(ctx, config) {
         }
       }
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".delete_failed");
+          return ChainMiddlewareRunStatus3.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
           layers.map((layer) => layer.deleteMemories(ids))
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".delete_success");
       } catch (error) {
         logger6?.error(error);
@@ -1125,15 +1155,18 @@ function apply6(ctx, config) {
   chain.middleware(
     "edit_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { type, room, memoryId, view }
+        options: {
+          type,
+          memoryId,
+          view,
+          conversationId,
+          presetLane
+        }
       } = context;
       if (command !== "edit_memory")
         return ChainMiddlewareRunStatus4.SKIPPED;
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -1148,16 +1181,25 @@ function apply6(ctx, config) {
       }
       try {
         await session.send(session.text(".edit_memory_start"));
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".edit_failed");
+          return ChainMiddlewareRunStatus4.STOP;
+        }
         const content = await session.prompt();
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
           {
-            presetId: type,
+            ...scope.info,
             userId: session.userId,
             guildId: session.guildId || session.channelId,
             type: parsedLayerType,
             memoryId
           },
-          room.conversationId,
+          scope.conversation.id,
           parsedLayerType
         );
         await Promise.all(
@@ -1171,7 +1213,7 @@ function apply6(ctx, config) {
         await Promise.all(
           layers.map((layer) => layer.addMemories([memory]))
         );
-        await ctx.chatluna.clearCache(room);
+        await ctx.chatluna.clearCache(scope.conversation);
         context.message = session.text(".edit_success");
       } catch (error) {
         logger7?.error(error);
@@ -2817,16 +2859,21 @@ function apply9(ctx, config) {
   chain.middleware(
     "search_memory",
     async (session, context) => {
-      let {
+      const {
         command,
-        options: { page, limit, query, type, room, view }
+        options: {
+          page,
+          limit,
+          query,
+          type,
+          view,
+          conversationId,
+          presetLane
+        }
       } = context;
       if (command !== "search_memory") {
         return ChainMiddlewareRunStatus5.SKIPPED;
       }
-      if (!type) {
-        type = room.preset;
-      }
       let parsedLayerType = "user" /* USER */;
       if (view != null) {
         parsedLayerType = MemoryRetrievalLayerType[view.toUpperCase()];
@@ -2850,19 +2897,24 @@ function apply9(ctx, config) {
       pagination.updateFormatItem(
         (value) => formatDocumentInfo(session, value)
       );
-      query = query ?? " ";
+      const content = query ?? " ";
       try {
+        const scope = await getMemoryScope(ctx, session, {
+          conversationId,
+          presetLane,
+          type
+        });
+        if (scope == null) {
+          context.message = session.text(".search_failed");
+          return ChainMiddlewareRunStatus5.STOP;
+        }
         const layers = await ctx.chatluna_long_memory.initMemoryLayers(
-          {
-            presetId: type,
-            guildId: session.guildId || session.channelId,
-            userId: session.userId
-          },
-          room.conversationId,
+          scope.info,
+          scope.conversation.id,
           parsedLayerType
         );
         const documents = await Promise.all(
-          layers.map((layer) => layer.retrieveMemory(query))
+          layers.map((layer) => layer.retrieveMemory(content))
         ).then((documents2) => documents2.flat());
         await pagination.push(documents);
         context.message = await pagination.getFormattedPage(
@@ -2914,6 +2966,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "search"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "none"
+      }
+    },
     createTool(params2) {
       return new MemorySearchTool(ctx, params2);
     }
@@ -2923,6 +2986,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "add"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "all"
+      }
+    },
     createTool(params2) {
       return new MemoryAddTool(ctx, params2);
     }
@@ -2932,6 +3006,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "delete"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "all"
+      }
+    },
     createTool(params2) {
       return new MemoryDeleteTool(ctx, params2);
     }
@@ -2941,6 +3026,17 @@ async function apply10(ctx, config, plugin) {
     selector(history) {
       return true;
     },
+    meta: {
+      source: "extension",
+      group: "long-memory",
+      tags: ["long-memory", "update"],
+      defaultAvailability: {
+        enabled: true,
+        main: true,
+        chatluna: true,
+        characterScope: "all"
+      }
+    },
     createTool(params2) {
       return new MemoryUpdateTool(ctx, params2);
     }
@@ -3273,12 +3369,24 @@ var ChatLunaLongMemoryService = class extends Service {
       (layer) => MemoryRetrievalLayerType[layer.toUpperCase()]
     ).filter((v) => v != null);
     this.defaultLayerTypes.push(...mapped);
-    ctx.on(
-      "chatluna/clear-chat-history",
-      async (conversationId, _chatInterface) => {
-        delete this._memoryLayerNamespaces[conversationId];
-      }
-    );
+    const clear = /* @__PURE__ */ __name((conversationId) => {
+      delete this._memoryLayerNamespaces[conversationId];
+    }, "clear");
+    ctx.on("chatluna/conversation-after-clear-history", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-cache-clear", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-archive", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-restore", async (payload) => {
+      clear(payload.conversation.id);
+    });
+    ctx.on("chatluna/conversation-after-delete", async (payload) => {
+      clear(payload.conversation.id);
+    });
     ctx.setInterval(
       async () => {
         for (const [, layers] of Object.entries(

package/lib/plugins/add_memory.d.ts

@@ -1,5 +1,4 @@
 import { Context } from 'koishi';
-import { ConversationRoom } from 'koishi-plugin-chatluna';
 import { Config } from '../index';
 export declare function apply(ctx: Context, config: Config): void;
 declare module 'koishi-plugin-chatluna/chains' {
@@ -8,6 +7,5 @@ declare module 'koishi-plugin-chatluna/chains' {
     }
     interface ChainMiddlewareContextOptions {
         content?: string;
-        room?: ConversationRoom;
     }
 }

package/lib/plugins/tool.d.ts

@@ -15,10 +15,10 @@ export declare class MemorySearchTool extends StructuredTool {
         layer: z.ZodArray<z.ZodUnion<[z.ZodLiteral<"user">, z.ZodLiteral<"preset">, z.ZodLiteral<"guild">, z.ZodLiteral<"global">]>, "many">;
     }, "strip", z.ZodTypeAny, {
         content?: string;
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
     }, {
         content?: string;
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
     }>;
     constructor(ctx: Context, params: CreateToolParams);
     /** @ignore */
@@ -35,27 +35,27 @@ export declare class MemoryAddTool extends StructuredTool {
             type: z.ZodNativeEnum<typeof MemoryType>;
             importance: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }, {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }>, "many">;
         layer: z.ZodArray<z.ZodUnion<[z.ZodLiteral<"user">, z.ZodLiteral<"preset">, z.ZodLiteral<"guild">, z.ZodLiteral<"global">]>, "many">;
     }, "strip", z.ZodTypeAny, {
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
         memories?: {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }[];
     }, {
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
         memories?: {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }[];
     }>;
@@ -72,10 +72,10 @@ export declare class MemoryDeleteTool extends StructuredTool {
         memoryIds: z.ZodArray<z.ZodString, "many">;
         layer: z.ZodArray<z.ZodUnion<[z.ZodLiteral<"user">, z.ZodLiteral<"preset">, z.ZodLiteral<"guild">, z.ZodLiteral<"global">]>, "many">;
     }, "strip", z.ZodTypeAny, {
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
         memoryIds?: string[];
     }, {
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
         memoryIds?: string[];
     }>;
     constructor(ctx: Context, params: CreateToolParams);
@@ -94,29 +94,29 @@ export declare class MemoryUpdateTool extends StructuredTool {
             type: z.ZodNativeEnum<typeof MemoryType>;
             importance: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }, {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }>, "many">;
         layer: z.ZodArray<z.ZodUnion<[z.ZodLiteral<"user">, z.ZodLiteral<"preset">, z.ZodLiteral<"guild">, z.ZodLiteral<"global">]>, "many">;
     }, "strip", z.ZodTypeAny, {
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
         memoryIds?: string[];
         newMemories?: {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }[];
     }, {
-        layer?: ("global" | "preset" | "user" | "guild")[];
+        layer?: ("user" | "preset" | "guild" | "global")[];
         memoryIds?: string[];
         newMemories?: {
-            type?: MemoryType;
             content?: string;
+            type?: MemoryType;
             importance?: number;
         }[];
     }>;

package/lib/utils/conversation.d.ts

@@ -0,0 +1,14 @@
+import { Context, Session } from 'koishi';
+export declare function getMemoryScope(ctx: Context, session: Session, options: {
+    conversationId?: string;
+    presetLane?: string;
+    type?: string;
+}): Promise<{
+    conversation: Parameters<Context['chatluna']['clearCache']>[0];
+    preset: string;
+    info: {
+        presetId: string;
+        guildId: string;
+        userId: string;
+    };
+} | null>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna-long-memory",
   "description": "long memory for chatluna",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "main": "lib/index.cjs",
   "module": "lib/index.mjs",
   "typings": "lib/index.d.ts",
@@ -62,7 +62,7 @@
   },
   "peerDependencies": {
     "koishi": "^4.18.9",
-    "koishi-plugin-chatluna": "^1.3.34"
+    "koishi-plugin-chatluna": "^1.4.0-alpha.0"
   },
   "resolutions": {
     "@langchain/core": "^0.3.80",