@walkhi/code-relax 0.1.0-beta.50 → 0.1.0-beta.59

package/dist/src/file-transfer-range.mjs

@@ -1,22 +1,22 @@
-export const FILE_READ_LIMIT = 20 * 1024 * 1024;
-export const FILE_PART_BYTES = 256 * 1024;
-export class FileRangeError extends Error {
-  constructor(statusCode, message) { super(message); this.statusCode = statusCode; }
-}
-
-export function fileRange(query, size, revision) {
-  const offset = Number(query.get('offset') || 0);
-  const length = Number(query.get('length') || FILE_PART_BYTES);
-  if (!Number.isSafeInteger(offset) || offset < 0 || offset >= size ||
-      !Number.isSafeInteger(length) || length < 1 || length > FILE_PART_BYTES) {
-    throw new FileRangeError(400, '无效的文件读取范围。');
-  }
-  if ((offset && !query.get('revision')) || (query.has('revision') && query.get('revision') !== revision)) {
-    throw new FileRangeError(409, '文件已变化，请重新打开。');
-  }
-  return { offset, length: Math.min(length, size - offset) };
-}
-
-export function fileRevision(stat) {
-  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
-}
+export const FILE_READ_LIMIT = 20 * 1024 * 1024;
+export const FILE_PART_BYTES = 256 * 1024;
+export class FileRangeError extends Error {
+  constructor(statusCode, message) { super(message); this.statusCode = statusCode; }
+}
+
+export function fileRange(query, size, revision) {
+  const offset = Number(query.get('offset') || 0);
+  const length = Number(query.get('length') || FILE_PART_BYTES);
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset >= size ||
+      !Number.isSafeInteger(length) || length < 1 || length > FILE_PART_BYTES) {
+    throw new FileRangeError(400, '无效的文件读取范围。');
+  }
+  if ((offset && !query.get('revision')) || (query.has('revision') && query.get('revision') !== revision)) {
+    throw new FileRangeError(409, '文件已变化，请重新打开。');
+  }
+  return { offset, length: Math.min(length, size - offset) };
+}
+
+export function fileRevision(stat) {
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+}

package/dist/src/file-upload-session.mjs

@@ -1,130 +1,146 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-export const MAX_FILE_BYTES = 20 * 1024 * 1024;
-export const MAX_FILE_COUNT = 4;
-export const MAX_TOTAL_BYTES = 40 * 1024 * 1024;
-export const FILE_CHUNK_BYTES = 256 * 1024;
-
-function validName(value) {
-  return typeof value === 'string' && value.length > 0 && value.length <= 180 &&
-    value !== '.' && value !== '..' && !/[\\/:*?"<>|\x00-\x1f]/.test(value) && !/[. ]$/.test(value) &&
-    !/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(value);
-}
-
-async function uniqueDestination(directory, name, partial) {
-  const dot = name.lastIndexOf('.');
-  const stem = dot > 0 ? name.slice(0, dot) : name;
-  const extension = dot > 0 ? name.slice(dot) : '';
-  for (let index = 0; ; index++) {
-    const suffix = index ? ` (${index})` : '';
-    const candidate = index ? `${stem.slice(0, 180 - extension.length - suffix.length)}${suffix}${extension}` : name;
-    if (!candidate || candidate.length > 180) throw new Error('同名文件过多，文件名无法继续编号');
-    const destination = path.join(directory, candidate);
-    try {
-      await fs.link(partial, destination);
-      await fs.unlink(partial);
-      return { name: candidate, path: destination };
-    } catch (error) {
-      if (error.code !== 'EEXIST') throw error;
-    }
-  }
-}
-
-export function createFileUploadSession(root) {
-  let upload;
-  const completed = new Map();
-  let completedBytes = 0;
-  const directory = path.join(root, 'incoming');
-  const clearActive = async () => {
-    const current = upload;
-    upload = undefined;
-    if (!current) return;
-    await current.handle.close().catch(() => {});
-    await fs.unlink(current.partial).catch(() => {});
-  };
-  const clear = async () => {
-    await clearActive();
-    for (const file of completed.values()) {
-      await fs.unlink(file.path).catch(() => {});
-      if (file.preview) await fs.unlink(file.preview.path).catch(() => {});
-    }
-    completed.clear(); completedBytes = 0;
-  };
-  return {
-    async receive(message) {
-      if (!message || typeof message !== 'object') throw new Error('无效的文件上传请求');
-      if (message.type === 'cancel') { await clear(); return { type: 'cancelled' }; }
-      if (message.type === 'commit') {
-        if (upload) throw new Error('文件尚未上传完成');
-        completed.clear(); completedBytes = 0;
-        return { type: 'committed' };
-      }
-      if (message.type === 'remove') {
-        if (upload) throw new Error('请等待当前文件上传完成');
-        const file = completed.get(message.id);
-        if (!file) throw new Error('文件上传会话已失效');
-        await fs.unlink(file.path);
-        if (file.preview) await fs.unlink(file.preview.path);
-        completed.delete(message.id); completedBytes -= file.size;
-        return { type: 'removed', id: message.id };
-      }
-      if (message.type === 'start') {
-        if (upload) throw new Error('已有文件正在上传');
-        if (!validName(message.name)) throw new Error('文件名无效');
-        if (!Number.isSafeInteger(message.size) || message.size < 1 || message.size > MAX_FILE_BYTES) {
-          throw new Error('单个文件不得超过 20 MiB');
-        }
-        const parent = message.previewOf ? completed.get(message.previewOf) : null;
-        if (message.previewOf && (!parent || parent.preview || message.size > FILE_CHUNK_BYTES)) throw new Error('预览图关联无效或超过 256 KiB');
-        if (!parent && (completed.size >= MAX_FILE_COUNT || completedBytes + message.size > MAX_TOTAL_BYTES)) {
-          throw new Error('每条消息最多 4 个文件，合计不超过 40 MiB');
-        }
-        if (!/^[a-f0-9]{64}$/i.test(message.sha256 || '')) throw new Error('文件校验值无效');
-        const id = crypto.randomUUID();
-        await fs.mkdir(directory, { recursive: true });
-        const partial = path.join(directory, `.upload-${id}`);
-        const handle = await fs.open(partial, 'wx');
-        upload = { id, partial, handle, name: parent ? `${id}.preview.jpg` : message.name, size: message.size, parent,
-          expected: message.sha256.toLowerCase(), hash: crypto.createHash('sha256'), offset: 0 };
-        return { type: 'started', id, offset: 0, chunkBytes: FILE_CHUNK_BYTES };
-      }
-      const current = upload;
-      if (!current || message.id !== current.id) throw new Error('文件上传会话已失效');
-      if (message.type === 'chunk') {
-        if (!Number.isSafeInteger(message.offset) || message.offset !== current.offset) {
-          return { type: 'offset', id: current.id, offset: current.offset };
-        }
-        if (!Buffer.isBuffer(message.data)) {
-          throw new Error('文件分片格式无效');
-        }
-        const bytes = message.data;
-        if (!bytes.length || bytes.length > FILE_CHUNK_BYTES || current.offset + bytes.length > current.size) {
-          throw new Error('文件分片大小无效');
-        }
-        await current.handle.writeFile(bytes);
-        current.hash.update(bytes);
-        current.offset += bytes.length;
-        return { type: 'offset', id: current.id, offset: current.offset };
-      }
-      if (message.type === 'finish') {
-        if (current.offset !== current.size || current.hash.digest('hex') !== current.expected) {
-          await clear(); throw new Error('文件大小或 SHA-256 校验失败');
-        }
-        await current.handle.sync();
-        await current.handle.close();
-        upload = undefined;
-        let saved;
-        try { saved = await uniqueDestination(directory, current.name, current.partial); }
-        catch (error) { await fs.unlink(current.partial).catch(() => {}); throw error; }
-        const result = { type: 'completed', id: current.id, ...saved, size: current.size, sha256: current.expected };
-        if (current.parent) current.parent.preview = result;
-        else { completed.set(current.id, result); completedBytes += current.size; }
-        return result;
-      }
-      throw new Error('不支持的文件上传操作');
-    },
-    close: clear,
-  };
-}
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const MAX_FILE_BYTES = 20 * 1024 * 1024;
+export const MAX_FILE_COUNT = 4;
+export const MAX_TOTAL_BYTES = 40 * 1024 * 1024;
+export const FILE_CHUNK_BYTES = 256 * 1024;
+
+function validName(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 180 &&
+    value !== '.' && value !== '..' && !/[\\/:*?"<>|\x00-\x1f]/.test(value) && !/[. ]$/.test(value) &&
+    !/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(value);
+}
+
+async function uniqueDestination(directory, name, partial) {
+  const dot = name.lastIndexOf('.');
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  const extension = dot > 0 ? name.slice(dot) : '';
+  for (let index = 0; ; index++) {
+    const suffix = index ? ` (${index})` : '';
+    const candidate = index ? `${stem.slice(0, 180 - extension.length - suffix.length)}${suffix}${extension}` : name;
+    if (!candidate || candidate.length > 180) throw new Error('同名文件过多，文件名无法继续编号');
+    const destination = path.join(directory, candidate);
+    try {
+      await fs.link(partial, destination);
+      await fs.unlink(partial);
+      return { name: candidate, path: destination };
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+  }
+}
+
+export function createFileUploadSession(root) {
+  let upload;
+  let committed = false;
+  const files = new Map();
+  const completed = new Map();
+  let completedBytes = 0;
+  const directory = path.join(root, 'incoming');
+  const clearActive = async () => {
+    const current = upload;
+    upload = undefined;
+    if (!current) return;
+    await current.handle.close().catch(() => {});
+    await fs.unlink(current.partial).catch(() => {});
+  };
+  const clear = async () => {
+    await clearActive();
+    if (committed) return;
+    for (const file of completed.values()) {
+      await fs.unlink(file.path).catch(() => {});
+      if (file.preview) await fs.unlink(file.preview.path).catch(() => {});
+    }
+    completed.clear(); files.clear(); completedBytes = 0;
+  };
+  return {
+    async receive(message) {
+      if (!message || typeof message !== 'object') throw new Error('无效的文件上传请求');
+      if (message.type === 'cancel') { await clear(); return { type: 'cancelled' }; }
+      if (message.type === 'commit') {
+        if (upload) throw new Error('文件尚未上传完成');
+        committed = true;
+        return { type: 'committed' };
+      }
+      if (message.type === 'remove') {
+        if (committed) throw new Error('文件批次已提交');
+        if (upload) throw new Error('请等待当前文件上传完成');
+        const file = completed.get(message.id);
+        if (!file) throw new Error('文件上传会话已失效');
+        await fs.unlink(file.path);
+        if (file.preview) await fs.unlink(file.preview.path);
+        completed.delete(message.id); completedBytes -= file.size;
+        for (const [key, value] of files) if (value.id === message.id || value.previewOf === message.id) files.delete(key);
+        return { type: 'removed', id: message.id };
+      }
+      if (message.type === 'start') {
+        if (typeof message.fileKey !== 'string' || !/^[0-9]+(?:-preview)?$/.test(message.fileKey)) throw new Error('文件批次编号无效');
+        const previous = files.get(message.fileKey);
+        if (previous) {
+          if (previous.originalName !== message.name || previous.size !== message.size ||
+              previous.expected !== message.sha256?.toLowerCase() || previous.previewOf !== message.previewOf) throw new Error('续传文件身份不一致');
+          return previous.result || { type: 'started', id: previous.id, offset: previous.offset, chunkBytes: FILE_CHUNK_BYTES };
+        }
+        if (committed) throw new Error('文件批次已提交');
+        if (upload) throw new Error('已有文件正在上传');
+        if (!validName(message.name)) throw new Error('文件名无效');
+        if (!Number.isSafeInteger(message.size) || message.size < 1 || message.size > MAX_FILE_BYTES) {
+          throw new Error('单个文件不得超过 20 MiB');
+        }
+        const parent = message.previewOf ? completed.get(message.previewOf) : null;
+        if (message.previewOf && (!parent || parent.preview || message.size > FILE_CHUNK_BYTES)) throw new Error('预览图关联无效或超过 256 KiB');
+        if (!parent && (completed.size >= MAX_FILE_COUNT || completedBytes + message.size > MAX_TOTAL_BYTES)) {
+          throw new Error('每条消息最多 4 个文件，合计不超过 40 MiB');
+        }
+        if (!/^[a-f0-9]{64}$/i.test(message.sha256 || '')) throw new Error('文件校验值无效');
+        const id = crypto.randomUUID();
+        await fs.mkdir(directory, { recursive: true });
+        const partial = path.join(directory, `.upload-${id}`);
+        const handle = await fs.open(partial, 'wx');
+        upload = { id, partial, handle, name: parent ? `${id}.preview.jpg` : message.name, size: message.size, parent,
+          originalName: message.name, previewOf: message.previewOf,
+          expected: message.sha256.toLowerCase(), hash: crypto.createHash('sha256'), offset: 0 };
+        files.set(message.fileKey, upload);
+        return { type: 'started', id, offset: 0, chunkBytes: FILE_CHUNK_BYTES };
+      }
+      const current = upload;
+      if (!current || message.id !== current.id) throw new Error('文件上传会话已失效');
+      if (message.type === 'chunk') {
+        if (!Number.isSafeInteger(message.offset) || message.offset !== current.offset) {
+          return { type: 'offset', id: current.id, offset: current.offset };
+        }
+        if (!Buffer.isBuffer(message.data)) {
+          throw new Error('文件分片格式无效');
+        }
+        const bytes = message.data;
+        if (!bytes.length || bytes.length > FILE_CHUNK_BYTES || current.offset + bytes.length > current.size) {
+          throw new Error('文件分片大小无效');
+        }
+        await current.handle.writeFile(bytes);
+        current.hash.update(bytes);
+        current.offset += bytes.length;
+        return { type: 'offset', id: current.id, offset: current.offset };
+      }
+      if (message.type === 'finish') {
+        if (current.offset !== current.size || current.hash.digest('hex') !== current.expected) {
+          await clear(); throw new Error('文件大小或 SHA-256 校验失败');
+        }
+        await current.handle.sync();
+        await current.handle.close();
+        upload = undefined;
+        let saved;
+        try { saved = await uniqueDestination(directory, current.name, current.partial); }
+        catch (error) { await fs.unlink(current.partial).catch(() => {}); throw error; }
+        const result = { type: 'completed', id: current.id, ...saved, size: current.size, sha256: current.expected };
+        current.result = result;
+        if (current.parent) current.parent.preview = result;
+        else { completed.set(current.id, result); completedBytes += current.size; }
+        return result;
+      }
+      throw new Error('不支持的文件上传操作');
+    },
+    close: clear,
+  };
+}

package/dist/src/hosted-history-app-server.mjs

@@ -1,103 +1,103 @@
-import { SharedAppServer } from './shared-app-server.mjs';
-import { historyCacheScope, completedHistory, turnMetadata } from './hosted-history-cache.mjs';
-
-// Hosted history uses a disk range cache; local kernel history retains its own storage.
-export class HostedHistoryAppServer extends SharedAppServer {
-  constructor(url, historyCache) {
-    super(url);
-    this.historyCache = historyCache;
-    this.historyHeadKey = 'latest';
-    this.diskHeads = new Map(); this.invalidatedTurns = new Set(); this.windowSaves = new Map();
-    this.historyVersions = new Map();
-    this.on('disconnected', () => { this.diskHeads.clear(); this.invalidatedTurns.clear(); this.historyVersions.clear(); });
-  }
-
-  historyScope(threadId) { return historyCacheScope(this.historyIdentity, this.historySource, threadId); }
-  historyVersion(threadId) { return `${this.epoch}:${this.historyVersions.get(threadId) || 0}`; }
-
-  async restoreHistoryHead(threadId) {
-    const scope = this.historyScope(threadId);
-    const result = await this.historyCache?.get(scope, this.historyHeadKey);
-    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-    return result;
-  }
-
-  saveHistoryWindow(threadId, immediate = false) {
-    const record = this.threads.get(threadId), scope = this.historyScope(threadId);
-    if (!this.historyCache || !scope || !record || record.hydrating || record.needsReload
-      || record.historyTrimmed || record.metadataOnly || record.readOnly || !completedHistory(record.thread.turns)) return;
-    const value = structuredClone({ updatedAt: record.thread.updatedAt, turns: record.thread.turns,
-      nextCursor: record.nextCursor, revision: record.thread.chatRevision,
-      ...(record.approvalBeforeMs !== undefined ? { approvalBeforeMs: record.approvalBeforeMs } : {}) });
-    const pending = this.windowSaves.get(scope);
-    if (pending) { clearTimeout(pending); this.windowSaves.delete(scope); }
-    const save = () => { this.windowSaves.delete(scope); return this.historyCache.put(scope, this.historyHeadKey, value); };
-    if (immediate) return save();
-    const timer = setTimeout(save, 200); timer.unref(); this.windowSaves.set(scope, timer);
-  }
-
-  invalidateHistory(method, params) {
-    const id = params.threadId || params.thread?.id, scope = this.historyScope(id);
-    if (!scope || !this.historyCache) return;
-    const turnId = params.turnId || params.turn?.id;
-    const whole = ['thread/deleted', 'thread/compacted'].includes(method);
-    if (!whole && (!turnId || !/^(?:item\/|turn\/)/.test(method))) return;
-    this.historyVersions.set(id, (this.historyVersions.get(id) || 0) + 1);
-    clearTimeout(this.windowSaves.get(scope)); this.windowSaves.delete(scope);
-    const key = `${scope}:${turnId}`;
-    if (whole || !this.invalidatedTurns.has(key)) {
-      this.invalidatedTurns.add(key); this.diskHeads.delete(id);
-      void this.historyCache.invalidate(scope, whole ? undefined : turnId);
-    }
-    if (whole) {
-      const record = this.threads.get(id);
-      if (record) record.needsReload = true;
-      this.emit('history-invalidated', id);
-    }
-    if (method === 'turn/completed') this.invalidatedTurns.delete(key);
-  }
-
-  async compactTurn(threadId, turn, cursor = null, apply, limit = 100) {
-    const scope = this.historyScope(threadId), candidate = this.diskHeads.get(threadId);
-    const version = this.historyVersion(threadId);
-    if (cursor && !turn.status && this.historyCache) {
-      const final = await this.historyCache.get(scope, `turn:${turn.id}`);
-      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-      if (final) turn = { ...final.turns[0], ...turn };
-    }
-    const saved = !cursor && candidate?.head?.turns.find(value => value.id === turn.id);
-    if (scope && this.historyCache && saved && candidate.scope === scope && candidate.updatedAt != null
-      && candidate.head.updatedAt === candidate.updatedAt && completedHistory([saved])
-      && turnMetadata(saved) === turnMetadata(turn)) {
-      const result = { ...saved, ...turn, items: saved.items, itemPage: saved.itemPage };
-      apply?.(result); return result;
-    }
-    const result = await super.compactTurn(threadId, turn, cursor, apply, limit);
-    if (this.historyCache && scope === this.historyScope(threadId) && version === this.historyVersion(threadId)
-      && completedHistory([{ ...turn, items: [] }])) {
-      const { items, itemPage, ...metadata } = turn;
-      await this.historyCache.put(scope, `turn:${turn.id}`, { turns: [metadata] });
-    }
-    return result;
-  }
-
-  async history(threadId, cursor, options = {}) {
-    await this.connect();
-    let position;
-    try { position = JSON.parse(cursor); } catch { position = null; }
-    if (position?.threadId !== threadId) return super.history(threadId, cursor, options);
-    const scope = this.historyScope(threadId);
-    const version = this.historyVersion(threadId);
-    const key = JSON.stringify(['history', position.turnId, position.itemCursor, position.turnCursor, options.itemLimit ?? 100]);
-    const cached = await this.historyCache?.get(scope, key);
-    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-    if (cached && version === this.historyVersion(threadId)) return { thread: { id: threadId, turns: cached.turns },
-      nextCursor: cached.position ? JSON.stringify(cached.position) : null };
-    const result = await super.history(threadId, cursor, options);
-    if (scope === this.historyScope(threadId) && version === this.historyVersion(threadId) && completedHistory(result.thread.turns)) {
-      const next = result.nextCursor ? JSON.parse(result.nextCursor) : null;
-      await this.historyCache?.put(scope, key, { turns: result.thread.turns, position: next });
-    }
-    return result;
-  }
-}
+import { SharedAppServer } from './shared-app-server.mjs';
+import { historyCacheScope, completedHistory, turnMetadata } from './hosted-history-cache.mjs';
+
+// Hosted history uses a disk range cache; local kernel history retains its own storage.
+export class HostedHistoryAppServer extends SharedAppServer {
+  constructor(url, historyCache) {
+    super(url);
+    this.historyCache = historyCache;
+    this.historyHeadKey = 'latest';
+    this.diskHeads = new Map(); this.invalidatedTurns = new Set(); this.windowSaves = new Map();
+    this.historyVersions = new Map();
+    this.on('disconnected', () => { this.diskHeads.clear(); this.invalidatedTurns.clear(); this.historyVersions.clear(); });
+  }
+
+  historyScope(threadId) { return historyCacheScope(this.historyIdentity, this.historySource, threadId); }
+  historyVersion(threadId) { return `${this.epoch}:${this.historyVersions.get(threadId) || 0}`; }
+
+  async restoreHistoryHead(threadId) {
+    const scope = this.historyScope(threadId);
+    const result = await this.historyCache?.get(scope, this.historyHeadKey);
+    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+    return result;
+  }
+
+  saveHistoryWindow(threadId, immediate = false) {
+    const record = this.threads.get(threadId), scope = this.historyScope(threadId);
+    if (!this.historyCache || !scope || !record || record.hydrating || record.needsReload
+      || record.historyTrimmed || record.metadataOnly || record.readOnly || !completedHistory(record.thread.turns)) return;
+    const value = structuredClone({ updatedAt: record.thread.updatedAt, turns: record.thread.turns,
+      nextCursor: record.nextCursor, revision: record.thread.chatRevision,
+      ...(record.approvalBeforeMs !== undefined ? { approvalBeforeMs: record.approvalBeforeMs } : {}) });
+    const pending = this.windowSaves.get(scope);
+    if (pending) { clearTimeout(pending); this.windowSaves.delete(scope); }
+    const save = () => { this.windowSaves.delete(scope); return this.historyCache.put(scope, this.historyHeadKey, value); };
+    if (immediate) return save();
+    const timer = setTimeout(save, 200); timer.unref(); this.windowSaves.set(scope, timer);
+  }
+
+  invalidateHistory(method, params) {
+    const id = params.threadId || params.thread?.id, scope = this.historyScope(id);
+    if (!scope || !this.historyCache) return;
+    const turnId = params.turnId || params.turn?.id;
+    const whole = ['thread/deleted', 'thread/compacted'].includes(method);
+    if (!whole && (!turnId || !/^(?:item\/|turn\/)/.test(method))) return;
+    this.historyVersions.set(id, (this.historyVersions.get(id) || 0) + 1);
+    clearTimeout(this.windowSaves.get(scope)); this.windowSaves.delete(scope);
+    const key = `${scope}:${turnId}`;
+    if (whole || !this.invalidatedTurns.has(key)) {
+      this.invalidatedTurns.add(key); this.diskHeads.delete(id);
+      void this.historyCache.invalidate(scope, whole ? undefined : turnId);
+    }
+    if (whole) {
+      const record = this.threads.get(id);
+      if (record) record.needsReload = true;
+      this.emit('history-invalidated', id);
+    }
+    if (method === 'turn/completed') this.invalidatedTurns.delete(key);
+  }
+
+  async compactTurn(threadId, turn, cursor = null, apply, limit = 100) {
+    const scope = this.historyScope(threadId), candidate = this.diskHeads.get(threadId);
+    const version = this.historyVersion(threadId);
+    if (cursor && !turn.status && this.historyCache) {
+      const final = await this.historyCache.get(scope, `turn:${turn.id}`);
+      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+      if (final) turn = { ...final.turns[0], ...turn };
+    }
+    const saved = !cursor && candidate?.head?.turns.find(value => value.id === turn.id);
+    if (scope && this.historyCache && saved && candidate.scope === scope && candidate.updatedAt != null
+      && candidate.head.updatedAt === candidate.updatedAt && completedHistory([saved])
+      && turnMetadata(saved) === turnMetadata(turn)) {
+      const result = { ...saved, ...turn, items: saved.items, itemPage: saved.itemPage };
+      apply?.(result); return result;
+    }
+    const result = await super.compactTurn(threadId, turn, cursor, apply, limit);
+    if (this.historyCache && scope === this.historyScope(threadId) && version === this.historyVersion(threadId)
+      && completedHistory([{ ...turn, items: [] }])) {
+      const { items, itemPage, ...metadata } = turn;
+      await this.historyCache.put(scope, `turn:${turn.id}`, { turns: [metadata] });
+    }
+    return result;
+  }
+
+  async history(threadId, cursor, options = {}) {
+    await this.connect();
+    let position;
+    try { position = JSON.parse(cursor); } catch { position = null; }
+    if (position?.threadId !== threadId) return super.history(threadId, cursor, options);
+    const scope = this.historyScope(threadId);
+    const version = this.historyVersion(threadId);
+    const key = JSON.stringify(['history', position.turnId, position.itemCursor, position.turnCursor, options.itemLimit ?? 100]);
+    const cached = await this.historyCache?.get(scope, key);
+    if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+    if (cached && version === this.historyVersion(threadId)) return { thread: { id: threadId, turns: cached.turns },
+      nextCursor: cached.position ? JSON.stringify(cached.position) : null };
+    const result = await super.history(threadId, cursor, options);
+    if (scope === this.historyScope(threadId) && version === this.historyVersion(threadId) && completedHistory(result.thread.turns)) {
+      const next = result.nextCursor ? JSON.parse(result.nextCursor) : null;
+      await this.historyCache?.put(scope, key, { turns: result.thread.turns, position: next });
+    }
+    return result;
+  }
+}