@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/src/dots-chat-server.mjs

@@ -0,0 +1,482 @@
+import { randomUUID } from 'node:crypto';
+import { readMessageUploads } from './message-upload-files.mjs';
+import { HostedHistoryAppServer } from './hosted-history-app-server.mjs';
+import { historyCacheScope } from './hosted-history-cache.mjs';
+import { DotsRoomClient } from './dots-room-client.mjs';
+import { DotsRoomActivity } from './dots-room-activity.mjs';
+import { DotsApprovalTimeline } from './dots-approval-timeline.mjs';
+import { dotsRoomTurns } from './dots-room-projection.mjs';
+import { dotsChatRevision, dotsChatMessageRevision, projectDotsChatItem } from './dots-chat-projection.mjs';
+import timelineSync from '../shared/timeline-sync.cjs';
+import serverRequests from '../shared/server-requests.cjs';
+import messageDelivery from '../shared/message-delivery.cjs';
+
+const pageSize = 20;
+const mergeTurns = (older, newer) => timelineSync.mergeOrderedEntries(older, newer, (old, fresh) => ({ ...fresh,
+  items: [...fresh.items, ...old.items.filter(item => !fresh.deleted && item.type === 'approval' && !fresh.items.some(next => next.id === item.id))] }));
+function connectedPrefix(previous, incoming) {
+  const old = previous.filter(turn => turn.roomMessage), ids = new Set(incoming.map(turn => turn.id));
+  const boundary = old.findIndex(turn => ids.has(turn.id));
+  return boundary >= 0 && old.slice(boundary).every(turn => ids.has(turn.id));
+}
+
+// Desktop 26.1002.7124.0: room messages are authoritative chat history.
+// The execution root remains the UI identity and owns tasks/approvals only.
+export class DotsChatServer extends HostedHistoryAppServer {
+  constructor(transport, roomClient = new DotsRoomClient(transport), { uploadsRoot } = {}) {
+    super(transport.localServer.url, transport.historyCache);
+    this.transport = transport; this.rooms = roomClient; this.uploadsRoot = uploadsRoot;
+    this.serverRequests = transport.serverRequests;
+    this.historyHeadKey = 'messaging-room-v1';
+    this.windowLoads = new Map(); this.historyLoads = new Map(); this.bindings = new Map();
+    this.roomApprovalResponses = new Map();
+    this.observedThreads = new Set(); this.reconnectAttempts = 0;
+    this.approvalTimeline = new DotsApprovalTimeline(this);
+    this.chatActivity = new DotsRoomActivity(this);
+    this.chatActivity.on('unavailable', error => this.emit('activity-error', error));
+    this.rooms.on('message', (topic, value) => this.roomNotification(topic, value));
+    this.rooms.on('disconnected', reason => { this.invalidate(reason); this.scheduleReconnect(); });
+    this.hostDisconnected = () => { this.rooms.close(); this.invalidate({ source: 'hosted-app-server' }); };
+    this.hostConnected = () => { void this.restoreObservers().catch(error => this.emit('subscription-error', error)); };
+    this.hostNotification = ({ method, params }) => this.executionNotification(method, params);
+    this.hostRequestsChanged = id => {
+      this.emit('requests-changed', id);
+      const observed = structuredClone(this.serverRequests.history(id));
+      const targets = new Set(this.approvalTimeline.targets(id));
+      if (transport.threadSources.get(id) === 'aeon') targets.add(id);
+      for (const threadId of targets) if (observed.length) {
+        void this.approvalTimeline.observe(threadId, observed, this.threads.get(threadId)?.thread.turns)
+          .then(() => this.applyApprovalWindow(threadId)).catch(error => this.emit('subscription-error', error));
+      }
+    };
+    transport.on('disconnected', this.hostDisconnected); transport.on('connected', this.hostConnected);
+    transport.on('host-notification', this.hostNotification); transport.on('requests-changed', this.hostRequestsChanged);
+  }
+
+  get ready() { return this.transport?.ready === true && this.rooms?.ready === true; }
+  get historyIdentity() { return this.transport.profileIdentity; }
+  historyScope(threadId) {
+    const roomId = this.bindings.get(threadId)?.id;
+    return roomId ? historyCacheScope(this.historyIdentity, 'aeon', `${threadId}:room:${roomId}`) : null;
+  }
+  async restoreHistoryHead(threadId) {
+    const scope = this.historyScope(threadId);
+    // Cache files are atomically replaced; this read need not wait behind
+    // another thread's queued writes. It never establishes live readiness.
+    const saved = scope && await this.historyCache?.record(scope);
+    if (scope !== this.historyScope(threadId)) throw new Error('点点账号已变化。');
+    return saved?.entries?.[this.historyHeadKey]?.value || null;
+  }
+  async connect() {
+    await this.transport.connect();
+    const identity = JSON.stringify(this.historyIdentity);
+    if (this.identity && this.identity !== identity) {
+      this.rooms.close(); this.invalidate(); this.threads.clear(); this.bindings.clear(); this.observedThreads.clear();
+    }
+    this.identity = identity;
+    await this.rooms.connect();
+  }
+  invalidate(reason = { source: 'identity' }) {
+    this.traceSync('invalidated', null, reason);
+    clearTimeout(this.reconnectTimer);
+    this.epoch = randomUUID(); this.chatActivity.close(); this.approvalTimeline.clear();
+    this.roomApprovalResponses.clear();
+    for (const record of this.threads.values()) { record.needsReload = true; record.tokens.clear(); record.refresh = null; }
+    for (const timer of this.windowSaves.values()) clearTimeout(timer); this.windowSaves.clear();
+    for (const slot of this.subscriptions.values()) clearTimeout(slot.expiry);
+    this.windowLoads.clear(); this.historyLoads.clear(); this.emit('disconnected');
+  }
+  scheduleReconnect() {
+    if (this.closed || !this.transport.ready || !this.observedThreads.size || this.reconnectAttempts >= 5) return;
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.restoreObservers().catch(error => { this.emit('subscription-error', error); this.scheduleReconnect(); });
+    }, Math.min(30000, 1000 * 2 ** this.reconnectAttempts++));
+    this.reconnectTimer.unref();
+  }
+  async restoreObservers() {
+    if (!this.observedThreads.size || this.closed) return;
+    await this.connect();
+    for (const id of this.observedThreads) await this.timeline(id);
+    this.reconnectAttempts = 0;
+  }
+  traceSync(stage, threadId, detail = {}) {
+    console.log(JSON.stringify({ time: new Date().toISOString(), event: 'dots-sync', pid: process.pid,
+      epoch: this.epoch, stage, threadId, ...detail }));
+  }
+  async room(threadId) {
+    const epoch = this.epoch;
+    const id = await this.rooms.roomId(threadId), room = await this.rooms.room(id);
+    if (epoch !== this.epoch) throw new Error('点点连接已变化，请重新同步。');
+    this.bindings.set(threadId, room); return room;
+  }
+  thread(threadId, turns, previous = {}) {
+    const messages = turns.filter(turn => turn.roomMessage), last = messages.at(-1);
+    const updatedAt = Math.max(Number(previous.updatedAt) || 0, ...messages.map(turn =>
+      Math.floor(Date.parse(turn.updatedAt || turn.createdAt) / 1000) || 0));
+    return { ...previous, id: threadId, hostId: 'durable', threadSource: 'aeon',
+      name: this.transport.profileName(threadId), avatar: this.transport.profileAvatar(threadId),
+      color: this.transport.profileColor(threadId), status: turns.some(turn => turn.status === 'inProgress') ? 'active' : 'idle',
+      messagingRoomId: this.bindings.get(threadId)?.id, lastMessageAt: last?.createdAt,
+      updatedAt,
+      chatRevision: dotsChatRevision(turns), chatMessageRevision: dotsChatMessageRevision(messages), turns };
+  }
+  async latestChatState(threadId) {
+    await this.timeline(threadId);
+    const { chatRevision, chatMessageRevision, updatedAt } = this.threads.get(threadId).thread;
+    return { chatRevision, chatMessageRevision, updatedAt };
+  }
+  prepare(threadId) { return this.timeline(threadId); }
+  historyCursor(threadId, _turn, cursor) {
+    return cursor ? JSON.stringify({ kind: 'dots-room-messages', threadId, roomId: this.bindings.get(threadId)?.id, before: cursor }) : null;
+  }
+  snapshot(threadId, record, notModified = false) {
+    // Catalog and chat must use the same current profile; a reused history
+    // window must not restore its earlier fallback name or empty avatar.
+    record.thread = { ...record.thread, name: this.transport.profileName(threadId),
+      avatar: this.transport.profileAvatar(threadId), color: this.transport.profileColor(threadId) };
+    const id = randomUUID();
+    record.tokens.set(id, { sequence: record.sequence, expires: Date.now() + 30000 });
+    this.scheduleCleanup(threadId, this.slot(threadId));
+    return { thread: notModified ? { ...record.thread, turns: [] } : record.thread,
+      ...(notModified ? { notModified: true } : {}),
+      nextCursor: this.historyCursor(threadId, null, record.nextCursor), sync: { id, epoch: this.epoch, seq: record.sequence } };
+  }
+  async timeline(threadId, options = {}, knownSync) {
+    const started = Date.now();
+    await this.connect();
+    const connectedAt = Date.now();
+    const epoch = this.epoch, force = options.reconcileObserved === true;
+    const observed = this.threads.get(threadId);
+    const retained = !force && observed && !observed.needsReload && !observed.hydrating;
+    let load = this.windowLoads.get(threadId);
+    if (!load || force && !load.force) {
+      const previous = load;
+      load = { force, work: previous ? previous.work.then(() => this.loadWindow(threadId, force)) : this.loadWindow(threadId, force) };
+      this.windowLoads.set(threadId, load);
+    }
+    try {
+      await load.work;
+      if (epoch !== this.epoch) throw new Error('点点连接已变化，请重新同步。');
+      const record = this.threads.get(threadId);
+      if (record.refresh) await record.refresh;
+      if (epoch !== this.epoch || this.threads.get(threadId) !== record) throw new Error('点点连接已变化，请重新同步。');
+      // The room remains observed while the phone is away. Its epoch/sequence
+      // identifies the body; the expiring token only owns snapshot-to-stream handoff.
+      const same = !force && (this.matchesUpdatedAt(record.thread, knownSync?.updatedAt)
+        || Boolean(retained && record === observed && knownSync?.epoch === this.epoch && Number.isSafeInteger(knownSync.seq)
+          && record.sequence === knownSync.seq));
+      this.traceSync('window-ready', threadId, { connectMs: connectedAt - started,
+        readMs: Date.now() - connectedAt, retained: Boolean(retained), notModified: same,
+        sequence: record.sequence, knownSequence: knownSync?.seq ?? null, turns: record.thread.turns.length });
+      if (!same && retained && record === observed && knownSync?.epoch === this.epoch && Number.isSafeInteger(knownSync.seq)
+        && knownSync.seq >= record.recoverAfter && knownSync.seq < record.sequence) {
+        const turns = [...record.changes.values()].filter(change => change.sequence > knownSync.seq).map(change => change.turn);
+        return { thread: { ...record.thread, turns }, incremental: true,
+          sync: { id: knownSync.id, epoch: this.epoch, fromSeq: knownSync.seq + 1, toSeq: record.sequence } };
+      }
+      return this.snapshot(threadId, record, same);
+    } finally { if (this.windowLoads.get(threadId) === load) this.windowLoads.delete(threadId); }
+  }
+  async loadWindow(threadId, force) {
+    const epoch = this.epoch, slot = this.slot(threadId); slot.readers++;
+    const work = slot.tail.then(async () => {
+      const current = () => { if (epoch !== this.epoch) throw new Error('点点连接已变化，请重新同步。'); };
+      current();
+      let record = this.threads.get(threadId);
+      if (!force && record && !record.needsReload && !record.hydrating) return;
+      if (record?.refresh) { await record.refresh.catch(() => {}); current(); }
+      const room = await this.room(threadId); current();
+      if (record && record.thread.messagingRoomId !== room.id) record = null;
+      record ||= { thread: this.thread(threadId, []), sequence: 0, recoverAfter: 0,
+        changes: new Map(), changeBytes: 0, tokens: new Map(), dirty: 0, updates: new Set() };
+      record.hydrating = true; record.needsReload = true;
+      this.threads.set(threadId, record); this.observedThreads.add(threadId);
+      try {
+        const [saved, page] = await Promise.all([this.restoreHistoryHead(threadId), this.rooms.messages(room.id)]); current();
+        if (!page.items.length && (room.room_messaging_state === 'has_messages_sent'
+          || record.thread.turns.some(turn => turn.items.length) || saved?.turns?.some(turn => turn.items.length))) {
+          throw new Error('点点最新消息尚未确认，请稍后重新同步。');
+        }
+        const incoming = dotsRoomTurns(room, page.items), observed = record.thread.turns.length ? record.thread.turns : saved?.turns || [];
+        const overlap = connectedPrefix(observed, incoming);
+        const turns = overlap ? mergeTurns(observed, incoming) : incoming;
+        const previousCursor = record.thread.turns.length ? record.nextCursor : saved?.nextCursor;
+        record.thread = this.thread(threadId, turns, record.thread);
+        record.nextCursor = overlap && previousCursor !== undefined ? previousCursor : page.before;
+        record.hydrating = false; record.needsReload = false;
+        record.recoverAfter = ++record.sequence; record.tokens.clear(); record.changes.clear(); record.changeBytes = 0;
+        if (record.dirty || record.updates.size) await this.refreshMessages(threadId, record);
+        current(); this.trimWindow(record);
+        this.emit('timeline-reset', this.snapshot(threadId, record));
+        void this.saveHistoryWindow(threadId, true)?.catch(error => this.emit('subscription-error', error));
+        void this.transport.watchExecution(threadId, 'aeon')
+          .catch(error => this.emit('subscription-error', error));
+      } catch (error) { record.hydrating = false; record.needsReload = true; throw error; }
+    }).finally(() => { slot.readers--; });
+    slot.tail = work.catch(() => {}); return work;
+  }
+  firstTime(turns) {
+    const times = turns.flatMap(turn => turn.items.map(item => item.startedAtMs)).filter(Number.isFinite);
+    return times.length ? Math.min(...times) : Infinity;
+  }
+  applyApprovalWindow(threadId) {
+    const record = this.threads.get(threadId);
+    if (!record || record.hydrating || record.needsReload) return;
+    this.publish(threadId, record, this.approvalTimeline.overlay(threadId, record.thread.turns, { fromMs: this.firstTime(record.thread.turns) }));
+  }
+  publish(threadId, record, turns) {
+    const changed = turns.filter(turn => JSON.stringify(turn) !== JSON.stringify(record.thread.turns.find(old => old.id === turn.id)));
+    if (!changed.length) return;
+    record.thread = this.thread(threadId, turns, record.thread);
+    this.publishChanges(threadId, record, changed);
+  }
+  publishChanges(threadId, record, changed) {
+    record.thread.updatedAt = Math.max(Number(record.thread.updatedAt) || 0, ...changed.map(turn =>
+      Math.floor(Date.parse(turn.updatedAt || turn.createdAt) / 1000) || 0));
+    for (const turn of changed) {
+      const sequence = ++record.sequence;
+      record.changes.set(turn.id, { turn, sequence });
+      record.changeBytes += Buffer.byteLength(JSON.stringify(turn));
+      if (record.changeBytes > 8 * 1024 * 1024) { record.recoverAfter = sequence; record.changes.clear(); record.changeBytes = 0; }
+      this.emit('turn', { thread: record.thread, turn, sequence, immediate: true });
+    }
+    this.emit('notification', { method: 'thread/status/changed', params: { threadId, status: record.thread.status,
+      updatedAt: record.thread.updatedAt, chatRevision: record.thread.chatRevision, chatMessageRevision: record.thread.chatMessageRevision } });
+    this.saveHistoryWindow(threadId);
+  }
+  trimWindow(record) {
+    if (record.thread.turns.length <= 40) return;
+    const turns = record.thread.turns.slice(-40), first = turns.find(turn => turn.roomMessage);
+    if (!first) return;
+    record.thread = this.thread(record.thread.id, turns, record.thread);
+    record.nextCursor = first.id; record.recoverAfter = record.sequence;
+    record.changes.clear(); record.changeBytes = 0;
+  }
+  roomNotification(topic, event) {
+    if (topic !== 'calpico-chatgpt-messaging') return;
+    const payload = event?.payload, roomId = payload?.room_id || payload?.room?.id;
+    for (const [threadId, room] of this.bindings) {
+      if (room.id !== roomId) continue;
+      const record = this.threads.get(threadId);
+      if (!record) continue;
+      if (event.type === 'calpico-message-add') {
+        record.dirty++;
+        if (typeof payload.message?.id === 'string') record.updates.add(payload.message.id);
+      }
+      else if (event.type === 'calpico-message-update' && typeof payload.message_id === 'string') record.updates.add(payload.message_id);
+      else if (event.type === 'calpico-room-leave') {
+        record.needsReload = true; this.emit('history-invalidated', threadId); return;
+      } else if (event.type === 'calpico-room-update' || event.type === 'calpico-room-metadata-update') {
+        if (!record.roomRefresh) {
+          const epoch = this.epoch;
+          record.roomRefresh = this.rooms.room(roomId).then(next => {
+            if (epoch === this.epoch && this.threads.get(threadId) === record) this.bindings.set(threadId, next);
+          }).catch(error => this.emit('subscription-error', error)).finally(() => { record.roomRefresh = null; });
+        }
+        return;
+      } else continue;
+      if (!record.hydrating && !record.needsReload) void this.refreshMessages(threadId, record)
+        .catch(error => { if (this.threads.get(threadId) !== record) return;
+          record.needsReload = true; this.emit('subscription-error', error); this.emit('history-invalidated', threadId); });
+    }
+  }
+  async refreshMessages(threadId, record) {
+    if (record.refresh) return record.refresh;
+    const epoch = this.epoch, room = this.bindings.get(threadId);
+    const check = () => { if (epoch !== this.epoch || this.threads.get(threadId) !== record) throw new Error('点点连接已变化。'); };
+    const work = (async () => {
+      do {
+        const dirty = record.dirty; record.dirty = 0;
+        const updates = new Set(record.updates); record.updates.clear();
+        if (dirty) {
+          let after = record.thread.turns.filter(turn => turn.roomMessage).at(-1)?.id;
+          do {
+            const page = await this.rooms.messages(room.id, { after }); check();
+            this.publish(threadId, record, mergeTurns(record.thread.turns, dotsRoomTurns(room, page.items)));
+            for (const message of page.items) updates.delete(message.id);
+            if (after && page.after === after) throw new Error('点点增量游标未推进。');
+            after = page.after;
+          } while (after);
+        }
+        for (const id of updates) {
+          const page = await this.rooms.messages(room.id, { around: id, limit: 1 }); check();
+          const message = page.items.find(message => message.id === id);
+          if (!message) throw new Error('点点消息更新尚未确认。');
+          const turns = dotsRoomTurns(room, [message]);
+          if (record.thread.turns.some(turn => turn.id === id)) this.publish(threadId, record, mergeTurns(record.thread.turns, turns));
+          else this.publishChanges(threadId, record, turns.map(turn => ({ ...turn, historyOnly: true })));
+        }
+      } while (record.dirty || record.updates.size);
+      this.trimWindow(record);
+    })();
+    record.refresh = work;
+    try { await work; } finally { if (record.refresh === work) record.refresh = null; }
+  }
+  async history(threadId, cursor, options = {}) {
+    await this.connect();
+    const room = this.bindings.get(threadId) || await this.room(threadId), epoch = this.epoch;
+    let position; try { position = JSON.parse(cursor); } catch {}
+    if (position?.kind !== 'dots-room-messages' || position.threadId !== threadId || position.roomId !== room.id || !position.before) {
+      throw Object.assign(new Error('点点历史游标已失效，请重新读取。'), { code: 'history_cursor_expired' });
+    }
+    const before = position.before, limit = options.itemLimit ?? pageSize;
+    const key = JSON.stringify([epoch, room.id, before, limit]);
+    let load = this.historyLoads.get(key);
+    if (!load) {
+      const record = this.threads.get(threadId);
+      load = { record, sequence: record?.sequence ?? 0, work: this.rooms.messages(room.id, { before, limit }) };
+      this.historyLoads.set(key, load);
+    }
+    let page; try { page = await load.work; } finally { if (this.historyLoads.get(key) === load) this.historyLoads.delete(key); }
+    if (epoch !== this.epoch) throw new Error('点点连接已变化，请重新同步。');
+    if (page.before === before) throw new Error('点点历史分页未推进。');
+    const record = this.threads.get(threadId);
+    // All consumers share the page's read boundary. If changes were discarded,
+    // keep the current cursor and let the existing local history retry reread it.
+    if (record !== load.record || record?.needsReload || record?.recoverAfter > load.sequence) {
+      throw new Error('点点历史读取期间消息已变化，请重试加载。');
+    }
+    const turns = dotsRoomTurns(room, page.items).map(turn => {
+      const changed = record?.changes.get(turn.id);
+      return changed?.sequence > load.sequence ? { ...changed.turn, historyOnly: false } : turn;
+    });
+    return { thread: this.thread(threadId, turns), nextCursor: this.historyCursor(threadId, null, page.before) };
+  }
+  async send(args) {
+    try { return await this.sendMessage(args); }
+    catch (error) { if (error.deliveryUnknown === undefined) error.deliveryUnknown = false; throw error; }
+  }
+  async findSentMessage(threadId, clientId, anchorItemId) {
+    await this.connect();
+    const room = this.bindings.get(threadId) || await this.room(threadId);
+    let before;
+    const seen = new Set();
+    do {
+      const page = await this.rooms.messages(room.id, { before, limit: pageSize });
+      if (!Array.isArray(page?.items)) throw new Error('发送核对失败：未取得房间历史');
+      for (const message of page.items) {
+        if (messageDelivery.normalizeId(message.request_id) === messageDelivery.normalizeId(clientId)) {
+          return { data: { messageId: message.id } };
+        }
+      }
+      if (anchorItemId && page.items.some(message => message.id === anchorItemId)) return null;
+      before = page.before;
+      if (before && seen.has(before)) throw new Error('发送核对失败：房间历史游标未推进');
+      if (before) seen.add(before);
+    } while (before);
+    return null;
+  }
+  async sendMessage(args) {
+    await this.connect(); this.requireWritable(args.threadId);
+    const record = this.threads.get(args.threadId), room = this.bindings.get(args.threadId), epoch = this.epoch;
+    if (!record || record.needsReload || record.hydrating || !room) throw new Error('请先完成点点消息同步。');
+    if (typeof args.prompt !== 'string' || args.prompt.length > 32000) throw new Error('点点消息文字无效或超过 32000 字符。');
+    const files = await readMessageUploads(args, this.uploadsRoot);
+    const compactId = (args.clientUserMessageId || randomUUID()).replace(/-/g, '');
+    if (!/^[a-f0-9]{32}$/i.test(compactId)) throw new Error('消息确认标识无效。');
+    const requestId = compactId.replace(/^(........)(....)(....)(....)(............)$/, '$1-$2-$3-$4-$5');
+    if (!args.prompt.trim() && !files.length) throw new Error('请输入文字或添加附件。');
+    const attachments = [];
+    for (const file of files) {
+      if (epoch !== this.epoch) throw new Error('点点连接已变化，请核对后发送。');
+      const boundary = `relax-${randomUUID()}`;
+      const name = file.name.replaceAll('"', '%22').replaceAll('\\', '%5C');
+      const body = Buffer.concat([Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${name}"\r\nContent-Type: ${file.mimeType}\r\n\r\n`), file.bytes, Buffer.from(`\r\n--${boundary}--\r\n`)]);
+      const result = await this.rooms.request(`/messaging/rooms/${encodeURIComponent(room.id)}/files`, {
+        method: 'POST', body, contentType: `multipart/form-data; boundary=${boundary}` })
+        .catch(error => { error.deliveryUnknown = false; throw error; });
+      if (!result?.id) throw new Error('点点附件上传未确认。');
+      attachments.push({ type: 'file', file_id: result.id });
+    }
+    if (epoch !== this.epoch) throw new Error('点点连接已变化，请核对后发送。');
+    const result = await this.rooms.request(`/messaging/rooms/${encodeURIComponent(room.id)}/messages`, {
+      method: 'POST', body: { content: { text: args.prompt, ...(attachments.length ? { attachments } : {}) },
+        request_id: requestId, idempotency_token: requestId } });
+    if (epoch !== this.epoch || !result?.id) throw Object.assign(new Error('发送结果未确认，请核对消息。'), { deliveryUnknown: true });
+    record.dirty++;
+    void this.refreshMessages(args.threadId, record).catch(error => {
+      if (epoch !== this.epoch) return;
+      record.needsReload = true; this.emit('subscription-error', error); this.emit('history-invalidated', args.threadId);
+    });
+    return { result: { messageId: result.id, requestId }, usage: { kind: 'dots-message', turnId: null } };
+  }
+  async markRead(threadId, body) {
+    const record = this.threads.get(threadId), room = this.bindings.get(threadId);
+    if (!this.ready || !record || record.needsReload || !room || body.roomId !== room.id
+      || body.revision !== record.thread.chatMessageRevision || body.lastMessageAt !== record.thread.lastMessageAt) return;
+    if (!body.lastMessageAt || room.last_read_at && Date.parse(room.last_read_at) >= Date.parse(body.lastMessageAt)) return;
+    const epoch = this.epoch;
+    await this.rooms.request(`/messaging/rooms/${encodeURIComponent(room.id)}/read`, { method: 'POST', body: { last_read_at: body.lastMessageAt } });
+    if (epoch === this.epoch && (!room.last_read_at || Date.parse(room.last_read_at) < Date.parse(body.lastMessageAt))) room.last_read_at = body.lastMessageAt;
+  }
+  executionNotification(method, params) {
+    if (params.item?.type !== 'subAgentActivity' || !['item/started', 'item/completed'].includes(method)) return;
+    const record = this.threads.get(params.threadId), item = projectDotsChatItem(params.item);
+    if (!item || !record || record.hydrating || record.needsReload) return;
+    const turn = { id: `activity:${params.turnId}:${item.id}`, status: 'completed', items: [item] };
+    this.publish(params.threadId, record, mergeTurns(record.thread.turns, [turn]));
+  }
+  async inspectApproval(threadId, body) {
+    if (typeof body.roomMessageId !== 'string' || !body.roomMessageId || typeof body.id !== 'string' || !body.id) throw new Error('确认请求标识无效');
+    const epoch = this.epoch, room = this.bindings.get(threadId) || await this.room(threadId);
+    const route = `/messaging/rooms/${encodeURIComponent(room.id)}/messages/${encodeURIComponent(body.roomMessageId)}/elicitation`;
+    const current = await this.rooms.request(`${route}?inspect=true`), request = current.elicitation;
+    if (epoch !== this.epoch || this.bindings.get(threadId) !== room || request?.request_id !== body.id
+      || request.params?.threadId !== request.thread_id || typeof current.request_fingerprint !== 'string') throw new Error('确认请求已变化，请重新核对。');
+    if (!serverRequests.confirmation({ method: serverRequests.elicitation, params: request.params })) throw new Error('此房间请求尚未支持');
+    const key = JSON.stringify([room.id, body.roomMessageId, body.id]);
+    return { requestId: request.request_id, params: request.params, fingerprint: current.request_fingerprint,
+      status: current.runtime_status, canRespond: current.can_respond === true && current.runtime_status === 'pending',
+      submissionStatus: this.roomApprovalResponses.get(key) || null };
+  }
+  async respondApproval(threadId, body) {
+    this.requireWritable(threadId);
+    if (!body.roomMessageId) return this.transport.respondApproval(threadId, body);
+    const epoch = this.epoch, room = this.bindings.get(threadId);
+    if (!room || typeof body.fingerprint !== 'string' || !body.fingerprint) throw new Error('请先核对确认请求。');
+    const key = JSON.stringify([room.id, body.roomMessageId, body.id]);
+    if (this.roomApprovalResponses.has(key)) throw new Error('此确认请求已提交，请核对结果。');
+    this.roomApprovalResponses.set(key, 'submitting');
+    let sent = false;
+    try {
+      const current = await this.inspectApproval(threadId, body);
+      if (epoch !== this.epoch || !current.canRespond || current.fingerprint !== body.fingerprint) throw new Error('确认请求已变化或结束，请重新核对。');
+      const request = { method: serverRequests.elicitation, params: current.params };
+      serverRequests.validate(request, body.result);
+      sent = true;
+      const route = `/messaging/rooms/${encodeURIComponent(room.id)}/messages/${encodeURIComponent(body.roomMessageId)}/elicitation/response`;
+      const result = await this.rooms.request(route, { method: 'POST', body: { request_fingerprint: current.fingerprint, result: body.result } });
+      if (epoch === this.epoch) this.roomApprovalResponses.set(key, result?.status === 'applied' ? 'applied' : 'unknown');
+      if (epoch === this.epoch && result?.status === 'applied') {
+        const record = this.threads.get(threadId);
+        const turns = record && structuredClone(record.thread.turns);
+        const applied = turns?.flatMap(turn => turn.items).find(item => item.roomMessageId === body.roomMessageId);
+        if (applied) { applied.status = 'resolved'; applied.result = body.result; this.publish(threadId, record, turns); }
+      }
+      return result;
+    } catch (error) {
+      if (!sent) error.deliveryUnknown = false;
+      if (epoch === this.epoch) {
+        if (error.deliveryUnknown === false) this.roomApprovalResponses.delete(key);
+        else this.roomApprovalResponses.set(key, 'unknown');
+      }
+      throw error;
+    }
+  }
+  acquireActivity(threadId, listener) { return this.chatActivity.acquire(threadId, listener); }
+  acquirePanelActivity(threadId, listener) { return this.chatActivity.acquire(threadId, listener); }
+  isHistorySyncing() { return false; }
+  async readContext() { return { available: false }; }
+  request() { return Promise.reject(new Error('点点主聊天不提供此执行线程操作。')); }
+  async unsubscribeThread() {}
+  keepThreadLoaded(_id, record) { return Boolean(record && this.ready); }
+  isThreadObserved(id, record) { return this.keepThreadLoaded(id, record); }
+  close() {
+    this.closed = true; clearTimeout(this.reconnectTimer); this.rooms.close(); this.invalidate(); this.chatActivity.dispose();
+    this.transport.off('disconnected', this.hostDisconnected); this.transport.off('connected', this.hostConnected);
+    this.transport.off('host-notification', this.hostNotification); this.transport.off('requests-changed', this.hostRequestsChanged);
+    for (const timer of this.windowSaves.values()) clearTimeout(timer); this.windowSaves.clear();
+  }
+}