koishi-plugin-chatluna-studio 1.1.8 → 1.1.9

package/lib/chatluna/character-turn-completion.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from 'koishi';
+/**
+ * 观察 chatluna-character 一轮响应真正退出的边界。
+ *
+ * Character 的 `after-chat` 只覆盖成功路径；它自己的 collect 回调则无论成功、提前返回还是抛错，都会在
+ * 最外层 finally 调用公开的 `releaseResponseLock(session)`。这里在每次 before-chat 时懒解析当前服务并
+ * 透明包装该方法，因此不需要声明注入，也能跟随 Character 后装或重载。
+ */
+export declare function observeCharacterTurnCompletion(ctx: Context, notify: (session: unknown) => void): () => void;

package/lib/chatluna/session-tracker.d.ts

@@ -72,6 +72,8 @@ export declare class ChatLunaSessionTracker {
      * 都没有，只有这张映射能把它还原成具体的（机器人，会话）。
      */
     private readonly coreKeys;
+    /** Character 的 session 对应到精确开始代次；失败终态只能收掉自己，不能按目标误删后继轮。 */
+    private readonly characterTurns;
     private readonly disposers;
     constructor(ctx: Context, options?: ChatLunaSessionTrackerOptions);
     /** 内部会话标识唯一对应一轮时才认；映射到多轮时这次错误归属不明。 */
@@ -91,7 +93,14 @@ export declare class ChatLunaSessionTracker {
     resolveActiveTurn(): ChatLunaTurnResolution;
     /** 当前正在进行的对话轮数；诊断与测试用。 */
     get activeTurnCount(): number;
+    /**
+     * 从 Character 的真实 finally 边界精确收掉对应开始代次。
+     *
+     * 同一目标的新一轮可能已覆盖活动表；此时过期 release 只消费自己的 token，不删除后继轮。
+     */
+    finishCharacterTurn(session: unknown): boolean;
     dispose(): void;
+    private beginCharacter;
     private begin;
     private finish;
     private finishCore;

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import { Context, Schema } from 'koishi';
 import type { StudioAppearance, StudioPersistenceMode } from './types';
 export * from './console';
 export * from './console-contract';
+export * from './chatluna/character-turn-completion';
 export * from './chatluna/error';
 export * from './chatluna/session-tracker';
 export * from './chatluna/usage';

package/lib/index.js

@@ -77,6 +77,7 @@ __export(index_exports, {
   matchesModelRequestQuery: () => matchesModelRequestQuery,
   modelRequestVariableStatusLabel: () => modelRequestVariableStatusLabel,
   name: () => name,
+  observeCharacterTurnCompletion: () => observeCharacterTurnCompletion,
   parsePresetSourceDocument: () => parsePresetSourceDocument,
   presentModelRequestDetail: () => presentModelRequestDetail,
   presentModelRequestListItem: () => presentModelRequestListItem,
@@ -100,6 +101,137 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_koishi3 = require("koishi");
 
+// src/chatluna/runtime.ts
+function readRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function readServiceFrom(host, serviceName, accept) {
+  const get = readRecord(host)?.get;
+  if (typeof get !== "function") return void 0;
+  const service = readRecord(get.call(host, serviceName));
+  return service ? accept(service) : void 0;
+}
+function listRegistryContexts(value) {
+  const registry = readRecord(readRecord(value)?.registry);
+  const values = registry?.values;
+  if (typeof values !== "function") return [];
+  return [...values.call(registry)].flatMap((runtime) => {
+    const ctx = readRecord(runtime)?.ctx;
+    return ctx ? [ctx] : [];
+  });
+}
+function findChatLunaRuntime(host, serviceName, accept) {
+  const direct = readServiceFrom(host, serviceName, accept);
+  if (direct) return direct;
+  for (const ctx of listRegistryContexts(host)) {
+    const resolved = readServiceFrom(ctx, serviceName, accept);
+    if (resolved) return resolved;
+  }
+}
+
+// src/chatluna/character-turn-completion.ts
+var runtimeStates = /* @__PURE__ */ new WeakMap();
+function observeCharacterTurnCompletion(ctx, notify) {
+  const observer = {
+    notify,
+    bindings: /* @__PURE__ */ new Set(),
+    disposed: false
+  };
+  const on = ctx.on.bind(ctx);
+  const disposeListener = on("chatluna_character/before-chat", (payload) => {
+    if (observer.disposed) return;
+    const session = readRecord(payload)?.session;
+    if (!session || typeof session !== "object") return;
+    const service = findChatLunaRuntime(ctx, "chatluna_character", acceptCharacterRuntime);
+    if (!service) return;
+    const binding = selectBinding(observer, ensureRuntimeState(service));
+    trackSession(binding, session);
+  });
+  return () => {
+    if (observer.disposed) return;
+    observer.disposed = true;
+    disposeListener();
+    for (const binding of [...observer.bindings]) detachBinding(binding);
+    observer.current = void 0;
+  };
+}
+function acceptCharacterRuntime(service) {
+  return typeof service.releaseResponseLock === "function" ? service : void 0;
+}
+function ensureRuntimeState(service) {
+  const existing = runtimeStates.get(service);
+  if (existing && service.releaseResponseLock === existing.wrapper) return existing;
+  const original = service.releaseResponseLock;
+  const state = {
+    service,
+    original,
+    bindings: /* @__PURE__ */ new Set()
+  };
+  state.wrapper = function(session, ...args) {
+    for (const binding of [...state.bindings]) {
+      if (!consumeSession(binding, session)) continue;
+      try {
+        binding.observer.notify(session);
+      } catch {
+      }
+      pruneInactiveBinding(binding);
+    }
+    return original.apply(this, [session, ...args]);
+  };
+  service.releaseResponseLock = state.wrapper;
+  runtimeStates.set(service, state);
+  return state;
+}
+function selectBinding(observer, state) {
+  if (observer.current?.state === state) return observer.current;
+  if (observer.current) {
+    observer.current.current = false;
+    pruneInactiveBinding(observer.current);
+  }
+  let binding = [...observer.bindings].find((candidate) => candidate.state === state);
+  if (!binding) {
+    binding = {
+      observer,
+      state,
+      pending: /* @__PURE__ */ new WeakMap(),
+      pendingCount: 0,
+      current: true
+    };
+    observer.bindings.add(binding);
+    state.bindings.add(binding);
+  } else {
+    binding.current = true;
+  }
+  observer.current = binding;
+  return binding;
+}
+function trackSession(binding, session) {
+  binding.pending.set(session, (binding.pending.get(session) ?? 0) + 1);
+  binding.pendingCount += 1;
+}
+function consumeSession(binding, session) {
+  if (!session || typeof session !== "object") return false;
+  const count = binding.pending.get(session);
+  if (!count) return false;
+  if (count === 1) binding.pending.delete(session);
+  else binding.pending.set(session, count - 1);
+  binding.pendingCount -= 1;
+  return true;
+}
+function pruneInactiveBinding(binding) {
+  if (binding.current || binding.pendingCount > 0) return;
+  detachBinding(binding);
+}
+function detachBinding(binding) {
+  binding.state.bindings.delete(binding);
+  binding.observer.bindings.delete(binding);
+  if (binding.observer.current === binding) binding.observer.current = void 0;
+  if (binding.state.bindings.size > 0) return;
+  const { service, wrapper, original } = binding.state;
+  if (service.releaseResponseLock === wrapper) service.releaseResponseLock = original;
+  if (runtimeStates.get(service) === binding.state) runtimeStates.delete(service);
+}
+
 // src/chatluna/error.ts
 var CHATLUNA_ERROR_CODE_DOCUMENTATION_URL = "https://chatluna.chat/guide/faq/error_code.html";
 var CHATLUNA_ERROR_CAUSES = {
@@ -116,7 +248,7 @@ var CHATLUNA_ERROR_CAUSES = {
   309: ["\u6A21\u578B\u8FD4\u56DE\u7A7A\u54CD\u5E94\uFF1B\u8BF7\u68C0\u67E5 API\u3001\u7F51\u7EDC\u548C\u5BC6\u94A5\uFF0C\u5E76\u786E\u8BA4\u5BF9\u8BDD\u6216\u9884\u8BBE\u5185\u5BB9\u672A\u88AB\u6A21\u578B\u62D2\u7EDD\u3002"]
 };
 function readChatLunaRequestError(error) {
-  const value = readRecord(error);
+  const value = readRecord2(error);
   if (!value) return;
   const code = readFiniteNumber(value.errorCode);
   const message = readNonEmptyString(value.message);
@@ -152,7 +284,7 @@ function archiveChatLunaModelRequestError(store, error, target) {
   }).catch(() => void 0);
   store.trackUpdate(task);
 }
-function readRecord(value) {
+function readRecord2(value) {
   return value !== null && typeof value === "object" ? value : void 0;
 }
 function readNonEmptyString(value) {
@@ -162,13 +294,13 @@ function readFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function readOriginMessage(origin) {
-  const record = readRecord(origin);
+  const record = readRecord2(origin);
   return readNonEmptyString(record?.message) ?? readNonEmptyString(origin);
 }
 
 // src/chatluna/session-tracker.ts
 var import_koishi = require("koishi");
-function readRecord2(value) {
+function readRecord3(value) {
   return value !== null && typeof value === "object" ? value : void 0;
 }
 function readString(value) {
@@ -176,7 +308,7 @@ function readString(value) {
 }
 function readNested(value, path) {
   let current = value;
-  for (const key of path) current = readRecord2(current)?.[key];
+  for (const key of path) current = readRecord3(current)?.[key];
   return current;
 }
 function readFirstString(value, paths) {
@@ -233,10 +365,10 @@ var ChatLunaSessionTracker = class {
     this.options = options;
     const on = ctx.on.bind(ctx);
     this.disposers.push(on("chatluna/before-chat", (conversationId, _message, _variables, _chatInterface, session) => {
-      const key = this.begin(session);
-      if (!key) return;
+      const started = this.begin(session);
+      if (!started) return;
       const keys = this.coreKeys.get(conversationId) ?? /* @__PURE__ */ new Set();
-      keys.add(key);
+      keys.add(started.key);
       this.coreKeys.set(conversationId, keys);
     }));
     this.disposers.push(on("chatluna/after-chat", (conversationId, _source, _response, _variables, _chatInterface, session) => {
@@ -248,10 +380,11 @@ var ChatLunaSessionTracker = class {
       this.finishCore(conversationId);
     }));
     this.disposers.push(on("chatluna_character/before-chat", (payload) => {
-      this.begin(readRecord2(payload)?.session);
+      this.beginCharacter(readRecord3(payload)?.session);
     }));
     this.disposers.push(on("chatluna_character/after-chat", (payload) => {
-      this.finish(readRecord2(payload)?.session);
+      const session = readRecord3(payload)?.session;
+      if (!this.finishCharacterTurn(session)) this.finish(session);
     }));
   }
   options;
@@ -264,6 +397,8 @@ var ChatLunaSessionTracker = class {
    * 都没有，只有这张映射能把它还原成具体的（机器人，会话）。
    */
   coreKeys = /* @__PURE__ */ new Map();
+  /** Character 的 session 对应到精确开始代次；失败终态只能收掉自己，不能按目标误删后继轮。 */
+  characterTurns = /* @__PURE__ */ new WeakMap();
   disposers = [];
   /** 内部会话标识唯一对应一轮时才认；映射到多轮时这次错误归属不明。 */
   resolveCoreTurn(conversationId) {
@@ -296,22 +431,44 @@ var ChatLunaSessionTracker = class {
   get activeTurnCount() {
     return this.turns.size;
   }
+  /**
+   * 从 Character 的真实 finally 边界精确收掉对应开始代次。
+   *
+   * 同一目标的新一轮可能已覆盖活动表；此时过期 release 只消费自己的 token，不删除后继轮。
+   */
+  finishCharacterTurn(session) {
+    if (!session || typeof session !== "object") return false;
+    const tokens = this.characterTurns.get(session);
+    const token = tokens?.shift();
+    if (!token) return false;
+    if (!tokens?.length) this.characterTurns.delete(session);
+    if (this.turns.get(token.key) === token.turn) this.turns.delete(token.key);
+    return true;
+  }
   dispose() {
     for (const dispose of this.disposers.splice(0)) dispose();
     this.turns.clear();
     this.coreKeys.clear();
   }
+  beginCharacter(session) {
+    const started = this.begin(session);
+    if (!started || !session || typeof session !== "object") return;
+    const tokens = this.characterTurns.get(session) ?? [];
+    tokens.push(started);
+    this.characterTurns.set(session, tokens);
+  }
   begin(session) {
     const entities = readStudioSessionEntities(session);
     if (!entities) return;
     const key = turnKey(entities);
     const existing = this.turns.get(key);
-    this.turns.set(key, {
+    const turn = {
       entities,
       interactionId: existing?.interactionId ?? import_koishi.Random.id(),
       virtual: isVirtualOneBotSession(session)
-    });
-    return key;
+    };
+    this.turns.set(key, turn);
+    return { key, turn };
   }
   finish(session) {
     const entities = readStudioSessionEntities(session);
@@ -4166,34 +4323,6 @@ function normalizeFileSystemError(error, fileName) {
   return new PresetRepositoryError("unsafe-file", `\u65E0\u6CD5\u5B89\u5168\u8BBF\u95EE\u9884\u8BBE\uFF1A${fileName}`, error);
 }
 
-// src/chatluna/runtime.ts
-function readRecord3(value) {
-  return value !== null && typeof value === "object" ? value : void 0;
-}
-function readServiceFrom(host, serviceName, accept) {
-  const get = readRecord3(host)?.get;
-  if (typeof get !== "function") return void 0;
-  const service = readRecord3(get.call(host, serviceName));
-  return service ? accept(service) : void 0;
-}
-function listRegistryContexts(value) {
-  const registry = readRecord3(readRecord3(value)?.registry);
-  const values = registry?.values;
-  if (typeof values !== "function") return [];
-  return [...values.call(registry)].flatMap((runtime) => {
-    const ctx = readRecord3(runtime)?.ctx;
-    return ctx ? [ctx] : [];
-  });
-}
-function findChatLunaRuntime(host, serviceName, accept) {
-  const direct = readServiceFrom(host, serviceName, accept);
-  if (direct) return direct;
-  for (const ctx of listRegistryContexts(host)) {
-    const resolved = readServiceFrom(ctx, serviceName, accept);
-    if (resolved) return resolved;
-  }
-}
-
 // src/presets/runtime-correlation.ts
 var PresetRuntimeSnapshotTracker = class {
   constructor(ctx) {
@@ -4231,23 +4360,17 @@ var PresetRuntimeSnapshotTracker = class {
       this.active.set(key, { target, turnId, snapshot });
       const session = record?.session;
       if (session && typeof session === "object") {
-        const keys = this.characterSessionTurnKeys.get(session) ?? /* @__PURE__ */ new Set();
-        keys.add(key);
+        const keys = this.characterSessionTurnKeys.get(session) ?? [];
+        keys.push(key);
         this.characterSessionTurnKeys.set(session, keys);
       }
     }));
     this.disposers.push(on("chatluna_character/after-chat", (payload) => {
       const record = readRecord4(payload);
-      const target = this.resolveSession(record?.session);
-      if (!target) return;
       const session = record?.session;
-      const sessionKeys = session && typeof session === "object" ? this.characterSessionTurnKeys.get(session) : void 0;
-      if (session && typeof session === "object" && sessionKeys?.size === 1) {
-        const [directKey] = sessionKeys;
-        if (directKey) this.active.delete(directKey);
-        this.characterSessionTurnKeys.delete(session);
-        return;
-      }
+      if (this.finishCharacterTurn(session)) return;
+      const target = this.resolveSession(session);
+      if (!target) return;
       const matches = [...this.active].filter(([, turn]) => turn.snapshot.kind === "character" && sameTarget(turn.target, target));
       if (matches.length === 1) this.active.delete(matches[0][0]);
     }));
@@ -4255,10 +4378,21 @@ var PresetRuntimeSnapshotTracker = class {
   ctx;
   active = /* @__PURE__ */ new Map();
   coreTurnKeys = /* @__PURE__ */ new Map();
+  /** Character 同一 session 上的开始代次按顺序保存，终态只能删除与自己对应的快照。 */
   characterSessionTurnKeys = /* @__PURE__ */ new WeakMap();
   disposers = [];
   nextCoreTurn = 1;
   nextCharacterTurn = 1;
+  /** Character 的 release 终态只删除该 session 最早尚未完成的快照代次。 */
+  finishCharacterTurn(session) {
+    if (!session || typeof session !== "object") return false;
+    const keys = this.characterSessionTurnKeys.get(session);
+    const key = keys?.shift();
+    if (!key) return false;
+    if (!keys?.length) this.characterSessionTurnKeys.delete(session);
+    this.active.delete(key);
+    return true;
+  }
   getActiveSnapshots(target) {
     const turns = [...this.active.values()].filter((turn) => sameTarget(turn.target, target));
     const snapshots = ["core", "character"].flatMap((kind) => {
@@ -4609,6 +4743,10 @@ function apply(ctx, config) {
         if (conversationId) archiveChatLunaModelRequestError(modelRequests, error, { conversationId });
       }
     });
+    const disposeCharacterTurnCompletion = observeCharacterTurnCompletion(inner, (session) => {
+      sessions.finishCharacterTurn(session);
+      presetSnapshots.finishCharacterTurn(session);
+    });
     const presets = new StudioPresetService({ baseDir: inner.baseDir, modelRequests });
     const getPersistenceStatus = () => {
       if (config.persistenceMode !== "database") {
@@ -4653,6 +4791,7 @@ function apply(ctx, config) {
     });
     inner.on("dispose", () => {
       disposeCollector();
+      disposeCharacterTurnCompletion();
       presetSnapshots.dispose();
       sessions.dispose();
       void modelRequests.waitForPersistence().catch((error) => {
@@ -4710,6 +4849,7 @@ function apply(ctx, config) {
   matchesModelRequestQuery,
   modelRequestVariableStatusLabel,
   name,
+  observeCharacterTurnCompletion,
   parsePresetSourceDocument,
   presentModelRequestDetail,
   presentModelRequestListItem,

package/lib/presets/runtime-correlation.d.ts

@@ -4,11 +4,14 @@ export declare class PresetRuntimeSnapshotTracker {
     private ctx;
     private readonly active;
     private readonly coreTurnKeys;
+    /** Character 同一 session 上的开始代次按顺序保存，终态只能删除与自己对应的快照。 */
     private readonly characterSessionTurnKeys;
     private readonly disposers;
     private nextCoreTurn;
     private nextCharacterTurn;
     constructor(ctx: Context);
+    /** Character 的 release 终态只删除该 session 最早尚未完成的快照代次。 */
+    finishCharacterTurn(session: unknown): boolean;
     getActiveSnapshots(target: PresetRuntimeSessionTarget): PresetRuntimeSnapshot[];
     dispose(): void;
     private resolveSession;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna-studio",
   "description": "在 Koishi 控制台中查看 ChatLuna 真实模型请求并编辑预设",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "type": "commonjs",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",