@yeaft/webchat-agent 1.0.371 → 1.0.372

package/connection/buffer.js

@@ -2,7 +2,6 @@ import WebSocket from 'ws';
 import ctx from '../context.js';
 import { encrypt, decrypt, isEncrypted } from '../encryption.js';
 
-// 需要在断连期间缓冲的消息类型（CLI / Session 输出相关的关键消息）
 export const BUFFERABLE_TYPES = new Set([
   'claude_output', 'yeaft_output', 'yeaft_session_output', 'session_output',
   'yeaft_history_chunk',
@@ -10,43 +9,56 @@ export const BUFFERABLE_TYPES = new Set([
   'session_id_update', 'compact_status', 'slash_commands_update',
   'background_task_started', 'background_task_output',
   'subagent_started', 'subagent_message', 'subagent_completed',
-  // Work Center broadcasts are projections over Agent-local SQLite. Buffering
-  // prevents a terminal transition from disappearing during a short reconnect;
-  // clients still refresh with `list` after reconnect for authoritative state.
   'work_center_event'
 ]);
 
+function messageBytes(msg) {
+  try { return Buffer.byteLength(JSON.stringify(msg), 'utf8'); }
+  catch { return 0; }
+}
+
+const TERMINAL_TYPES = new Set(['turn_completed', 'conversation_closed']);
+
+function removeBufferedAt(index) {
+  const [removed] = ctx.messageBuffer.splice(index, 1);
+  ctx.messageBufferBytes = Math.max(0, Number(ctx.messageBufferBytes || 0) - messageBytes(removed));
+}
+
+function removeOutboundAt(index, outcome = 'dropped') {
+  const [removed] = ctx.outboundSendQueue.splice(index, 1);
+  ctx.outboundSendQueueBytes = Math.max(0, Number(ctx.outboundSendQueueBytes || 0) - Number(removed?.bytes || 0));
+  removed?.resolve?.(outcome);
+}
+
 function bufferMessage(msg, reason) {
   if (!BUFFERABLE_TYPES.has(msg.type)) {
     console.warn(`[WS] Cannot send message, WebSocket not open: ${msg.type}`);
     return 'dropped';
   }
-  if (ctx.messageBuffer.length < ctx.messageBufferMaxSize) {
-    ctx.messageBuffer.push(msg);
-    console.log(`[WS] ${reason}, buffered: ${msg.type} (queue: ${ctx.messageBuffer.length})`);
-    return 'buffered';
+  const bytes = messageBytes(msg);
+  const maxBytes = Math.max(1, Number(ctx.messageBufferMaxBytes) || 8 * 1024 * 1024);
+  if (bytes > maxBytes) {
+    console.warn(`[WS] Message exceeds disconnected buffer byte budget, dropping: ${msg.type}`);
+    return 'dropped';
   }
-  // Buffer full: drop oldest non-status messages to make room
-  const dropIdx = ctx.messageBuffer.findIndex(m => m.type !== 'turn_completed');
-  if (dropIdx >= 0) {
-    ctx.messageBuffer.splice(dropIdx, 1);
-    ctx.messageBuffer.push(msg);
-    console.warn(`[WS] Buffer full, dropped oldest to make room for: ${msg.type}`);
-    return 'buffered';
+  while (ctx.messageBuffer.length > 0 && (
+    ctx.messageBuffer.length >= ctx.messageBufferMaxSize
+    || Number(ctx.messageBufferBytes || 0) + bytes > maxBytes
+  )) {
+    const nonTerminal = ctx.messageBuffer.findIndex(m => !TERMINAL_TYPES.has(m.type));
+    if (nonTerminal < 0) break;
+    removeBufferedAt(nonTerminal);
   }
-  console.warn(`[WS] Buffer full (${ctx.messageBufferMaxSize}), dropping: ${msg.type}`);
-  return 'dropped';
+  if (ctx.messageBuffer.length >= ctx.messageBufferMaxSize
+      || Number(ctx.messageBufferBytes || 0) + bytes > maxBytes) return 'dropped';
+  ctx.messageBuffer.push(msg);
+  ctx.messageBufferBytes = Number(ctx.messageBufferBytes || 0) + bytes;
+  console.log(`[WS] ${reason}, buffered: ${msg.type} (queue: ${ctx.messageBuffer.length})`);
+  return 'buffered';
 }
 
 async function sendNow(msg) {
-  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) {
-    return bufferMessage(msg, 'Disconnected');
-  }
-
-  // feat-ws-plaintext-negotiation: encrypt only when the server has
-  // NOT advertised plaintext acceptance. Defaults to encrypted for
-  // back-compat with old servers; flipped to plaintext when the
-  // `registered` frame includes `acceptPlaintext: true`.
+  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) return bufferMessage(msg, 'Disconnected');
   if (ctx.serverEncryptionRequired && ctx.sessionKey) {
     const encrypted = await encrypt(msg, ctx.sessionKey);
     ctx.ws.send(JSON.stringify(encrypted));
@@ -63,6 +75,7 @@ function scheduleOutboundDrain() {
     try {
       while (ctx.outboundSendQueue.length > 0) {
         const item = ctx.outboundSendQueue.shift();
+        ctx.outboundSendQueueBytes = Math.max(0, Number(ctx.outboundSendQueueBytes || 0) - Number(item?.bytes || 0));
         const msg = item?.msg ?? item;
         try {
           const outcome = await sendNow(msg);
@@ -72,8 +85,6 @@ function scheduleOutboundDrain() {
           const outcome = msg ? bufferMessage(msg, 'Send failed') : 'dropped';
           item?.resolve?.(outcome);
         }
-        // Yield between frames so ping/pong, inbound control messages and UI
-        // events cannot be starved by a reconnect flush or a burst of tool output.
         await new Promise(resolve => setImmediate(resolve));
       }
     } finally {
@@ -83,42 +94,45 @@ function scheduleOutboundDrain() {
   });
 }
 
-// Send message to server (with encryption if available)
-// 断连时对关键消息类型进行缓冲，重连后自动 flush
 export async function sendToServer(msg) {
-  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) {
-    return bufferMessage(msg, 'Disconnected');
+  if (!ctx.ws || ctx.ws.readyState !== WebSocket.OPEN) return bufferMessage(msg, 'Disconnected');
+  const bytes = messageBytes(msg);
+  const maxBytes = Math.max(1, Number(ctx.outboundSendQueueMaxBytes) || 8 * 1024 * 1024);
+  if (bytes > maxBytes) {
+    console.warn(`[WS] Outbound message exceeds byte budget, dropping: ${msg.type}`);
+    return 'dropped';
+  }
+  while (TERMINAL_TYPES.has(msg.type)
+      && Number(ctx.outboundSendQueueBytes || 0) + bytes > maxBytes) {
+    const nonTerminal = ctx.outboundSendQueue.findIndex(item => !TERMINAL_TYPES.has(item?.msg?.type));
+    if (nonTerminal < 0) break;
+    removeOutboundAt(nonTerminal);
+  }
+  if (Number(ctx.outboundSendQueueBytes || 0) + bytes > maxBytes) {
+    console.warn(`[WS] Outbound queue byte budget exceeded, dropping: ${msg.type}`);
+    return 'dropped';
   }
   const promise = new Promise((resolve, reject) => {
-    ctx.outboundSendQueue.push({ msg, resolve, reject });
+    ctx.outboundSendQueue.push({ msg, bytes, resolve, reject });
+    ctx.outboundSendQueueBytes = Number(ctx.outboundSendQueueBytes || 0) + bytes;
   });
   scheduleOutboundDrain();
   return promise;
 }
 
-// Flush 断连期间缓冲的消息
 export async function flushMessageBuffer() {
   if (ctx.messageBuffer.length === 0) return;
-
   const buffered = ctx.messageBuffer.splice(0);
+  ctx.messageBufferBytes = 0;
   console.log(`[WS] Flushing ${buffered.length} buffered messages...`);
-
-  for (const msg of buffered) {
-    await sendToServer(msg);
-  }
-
-  console.log(`[WS] Flush queued`);
+  for (const msg of buffered) await sendToServer(msg);
+  console.log('[WS] Flush queued');
 }
 
-// Parse incoming message (decrypt if encrypted)
 export async function parseMessage(data) {
   try {
     const parsed = JSON.parse(data.toString());
-
-    if (ctx.sessionKey && isEncrypted(parsed)) {
-      return await decrypt(parsed, ctx.sessionKey);
-    }
-
+    if (ctx.sessionKey && isEncrypted(parsed)) return await decrypt(parsed, ctx.sessionKey);
     return parsed;
   } catch (e) {
     console.error('Failed to parse message:', e);

package/context.js

@@ -47,11 +47,15 @@ export default {
   lastHeartbeatStallAt: 0,
   lastHeartbeatStallMs: 0,
   outboundSendQueue: [],
+  outboundSendQueueBytes: 0,
+  outboundSendQueueMaxBytes: 8 * 1024 * 1024,
   outboundSendQueueActive: false,
   assetOutbox: null,
   // 断连期间的消息缓冲队列（重连后 flush）
   messageBuffer: [],
-  messageBufferMaxSize: 5000, // 防止内存无限增长
+  messageBufferBytes: 0,
+  messageBufferMaxSize: 5000,
+  messageBufferMaxBytes: 8 * 1024 * 1024,
   // 由 connection.js 注册的通信函数
   sendToServer: null,
   // 由 index.js 注册的配置保存函数

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.371"}
+{"version":"1.0.372"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.371",
+  "version": "1.0.372",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/debug-trace.js

@@ -127,9 +127,19 @@ function regexHasUnsafeQuantifiedGroup(pattern) {
 function buildTraceSearchDocument(trace) {
   const loops = Array.isArray(trace?.loops) ? trace.loops : [];
   const tools = Array.isArray(trace?.tools) ? trace.tools : [];
-  const toolNames = tools.map(t => t?.toolName || t?.name || '').filter(Boolean).join(' ');
-  const loopModels = loops.map(l => l?.model || '').filter(Boolean).join(' ');
-  const stopReasons = loops.map(l => l?.stopReason || '').filter(Boolean).join(' ');
+  const toolNames = [
+    ...tools.map(t => t?.toolName || t?.name || '').filter(Boolean),
+    ...(Array.isArray(trace?.toolNames) ? trace.toolNames : []),
+  ].join(' ');
+  const loopModels = [
+    ...loops.map(l => l?.model || '').filter(Boolean),
+    ...(Array.isArray(trace?.loopModels) ? trace.loopModels : []),
+  ].join(' ');
+  const stopReasons = [
+    ...loops.map(l => l?.stopReason || '').filter(Boolean),
+    ...(Array.isArray(trace?.stopReasons) ? trace.stopReasons : []),
+    trace?.finalStopReason || '',
+  ].filter(Boolean).join(' ');
   return [
     trace?.requestId,
     trace?.traceId,
@@ -596,7 +606,24 @@ function turnLocatorPath(rootDir, sessionId, turnId) {
 }
 
 function serializableTraceMeta(trace) {
-  const meta = { ...trace };
+  const loops = Array.isArray(trace?.loops) ? trace.loops : [];
+  const tools = Array.isArray(trace?.tools) ? trace.tools : [];
+  const usage = loops.reduce((acc, loop) => {
+    const normalized = normalizeUsage(loop?.usage || {});
+    acc.totalMs += Number(loop?.latencyMs || 0);
+    acc.totalTokens += Number(normalized.totalTokens || 0);
+    acc.summaryInputTokens += Number(normalized.totalInputTokens || 0);
+    acc.summaryOutputTokens += Number(normalized.outputTokens || 0);
+    return acc;
+  }, { totalMs: 0, totalTokens: 0, summaryInputTokens: 0, summaryOutputTokens: 0 });
+  const meta = {
+    ...trace,
+    loopCount: loops.length,
+    ...usage,
+    loopModels: [...new Set(loops.map(loop => loop?.model).filter(Boolean))],
+    stopReasons: [...new Set(loops.map(loop => loop?.stopReason).filter(Boolean))],
+    toolNames: [...new Set(tools.map(tool => tool?.toolName || tool?.name).filter(Boolean))],
+  };
   delete meta._lastSnapshot;
   delete meta._persistedFormat;
   delete meta._persistedRequestDir;
@@ -689,11 +716,11 @@ function summarizeTrace(trace, detailsLoaded = false) {
     threadId: trace?.threadId || null,
     openedAt: trace?.openedAt || 0,
     closedAt: trace?.closedAt || null,
-    totalMs: usage.totalMs,
-    totalTokens: usage.totalTokens,
-    summaryInputTokens: usage.summaryInputTokens,
-    summaryOutputTokens: usage.summaryOutputTokens,
-    loopCount: loops.length,
+    totalMs: loops.length > 0 ? usage.totalMs : Number(trace?.totalMs || 0),
+    totalTokens: loops.length > 0 ? usage.totalTokens : Number(trace?.totalTokens || 0),
+    summaryInputTokens: loops.length > 0 ? usage.summaryInputTokens : Number(trace?.summaryInputTokens || 0),
+    summaryOutputTokens: loops.length > 0 ? usage.summaryOutputTokens : Number(trace?.summaryOutputTokens || 0),
+    loopCount: loops.length > 0 ? loops.length : Number(trace?.loopCount || 0),
     memoryLoaded: null,
     memoryAdjust: null,
     tools: Array.isArray(trace?.tools) ? trace.tools.map(t => ({
@@ -1123,33 +1150,39 @@ export class DebugTrace {
   }
 
   async queryByMessage(messageId) {
-    await this.#ensureHydrated();
     await this.#drainWrites();
-    const traces = this.#traceSummaries()
-      .filter(({ trace }) => trace.messageId === messageId)
-      .map(({ trace }) => trace);
+    const traces = (await readTraceSummaries(this.#rootDir)).map(item => item.trace)
+      .filter(trace => trace.messageId === messageId);
     return this.#expandLegacy(traces);
   }
 
   async queryByTrace(traceId) {
-    await this.#ensureHydrated();
     await this.#drainWrites();
-    const traces = this.#traceSummaries()
-      .filter(({ trace }) => trace.traceId === traceId || trace.requestId === traceId)
-      .map(({ trace }) => trace);
+    const traces = (await readTraceSummaries(this.#rootDir)).map(item => item.trace)
+      .filter(trace => trace.traceId === traceId || trace.requestId === traceId);
     return this.#expandLegacy(traces);
   }
 
   async queryRecent(limit = 20) {
-    await this.#ensureHydrated();
     await this.#drainWrites();
     const lim = Math.max(1, Math.min(MAX_HISTORY_LIMIT, Number(limit) || MAX_HISTORY_LIMIT));
-    return this.#traceSummaries()
+    return (await readTraceSummaries(this.#rootDir))
       .slice(-lim)
       .reverse()
       .flatMap(({ trace }) => traceToLegacyRows(trace));
   }
 
+  finalizeQuery(traceId, { sessionId = null, stopReason = 'end_turn' } = {}) {
+    for (const trace of this.#requestCache.values()) {
+      if (trace.traceId !== traceId || (sessionId != null && trace.sessionId !== sessionId)) continue;
+      trace.active = false;
+      trace.closedAt ||= Date.now();
+      trace.updatedAt = Date.now();
+      trace.finalStopReason = stopReason;
+      this.#appendTraceRecord(trace, 'finalize', { at: trace.updatedAt, stopReason }, { writeMeta: true, evictAfterWrite: true });
+    }
+  }
+
   async fetchTurnDebug({ sessionId, turnId, dreamLimit = 0 } = {}) {
     const requestedSessionId = typeof sessionId === 'string' && sessionId ? sessionId : null;
     const requestedTurnId = typeof turnId === 'string' && turnId ? turnId : null;
@@ -1166,10 +1199,7 @@ export class DebugTrace {
       const locator = await readJson(turnLocatorPath(this.#rootDir, requestedSessionId, requestedTurnId));
       if (locator?.requestKey && locator.sessionId === requestedSessionId && locator.requestId === requestedTurnId) {
         const located = await readRequestDir(requestDirFor(this.#rootDir, requestedSessionId, locator.requestKey));
-        if (traceMatchesIdentity(located, requestedSessionId, requestedTurnId)) {
-          trace = located;
-          this.#requestCache.set(trace.requestKey, trace);
-        }
+        if (traceMatchesIdentity(located, requestedSessionId, requestedTurnId)) trace = located;
       }
     }
     if (!trace) {
@@ -1178,7 +1208,6 @@ export class DebugTrace {
       for (const item of await readTraceSummaries(this.#rootDir, requestedSessionId)) {
         if (traceMatchesIdentity(item.trace, requestedSessionId, requestedTurnId)) {
           trace = item.trace;
-          this.#requestCache.set(trace.requestKey, trace);
           break;
         }
       }
@@ -1195,14 +1224,13 @@ export class DebugTrace {
       const detail = await this.fetchTurnDebug({ sessionId, turnId: requestedDetailTurnId, dreamLimit });
       return { ...detail, hasMore: false, limit: detail.loops.length, indexOnly: false };
     }
-    await this.#ensureHydrated();
     await this.#drainWrites();
     const lim = Math.max(1, Math.min(MAX_HISTORY_LIMIT, Number(limit) || MAX_HISTORY_LIMIT));
     const searchRegex = requestedDetailTurnId ? null : compileTraceSearchRegex(search);
-    const traces = this.#traceSummaries(sessionId)
-      .filter(({ trace }) => !threadId || trace.threadId === threadId)
-      .filter(({ trace }) => requestedDetailTurnId || traceMatchesRegex(trace, searchRegex))
-      .map(({ trace }) => trace);
+    const traces = (await readTraceHeaders(this.#rootDir, sessionId))
+      .map(({ trace }) => trace)
+      .filter(trace => !threadId || trace.threadId === threadId)
+      .filter(trace => requestedDetailTurnId || traceMatchesRegex(trace, searchRegex));
     const dreamEvents = this.#readDreamEvents({ sessionId, dreamLimit });
     if (requestedDetailTurnId) {
       const trace = traces.find(t => t.requestId === requestedDetailTurnId || t.traceId === requestedDetailTurnId);
@@ -1214,14 +1242,22 @@ export class DebugTrace {
     if (indexOnly) {
       return {
         loops: [],
-        turns: selected.map(trace => summarizeTrace(trace, false)),
+        turns: selected.map(trace => ({
+          ...summarizeTrace(trace, false),
+          loopCount: Number(trace.loopCount || 0),
+          tools: [],
+        })),
         dreamEvents,
         hasMore: traces.length > selected.length,
         limit: lim,
         indexOnly: true,
       };
     }
-    const expanded = selected.reduce((acc, trace) => {
+    const selectedKeys = new Set(selected.map(trace => trace.requestKey));
+    const detailed = (await readTraceSummaries(this.#rootDir, sessionId))
+      .map(({ trace }) => trace)
+      .filter(trace => selectedKeys.has(trace.requestKey));
+    const expanded = detailed.reduce((acc, trace) => {
       const item = expandTrace(trace);
       acc.loops.push(...item.loops);
       acc.turns.push(...item.turns);
@@ -1324,6 +1360,7 @@ export class DebugTrace {
     const isUsableExisting = (t) => (
       t?.sessionId === normalizedSessionId
       && t?.traceId === traceId
+      && t.active !== false
       && !(turnNumber === 1 && (t.loops || []).some(l => l.loopNumber === 1))
     );
     // Cache-only: the write path must NEVER touch disk (that was the O(N^2)
@@ -1374,6 +1411,23 @@ export class DebugTrace {
     return this.#requestCache.get(requestKey) || null;
   }
 
+  async resumeTrace({ sessionId, turnId } = {}) {
+    if (!sessionId || !turnId) return false;
+    const locator = await readJson(turnLocatorPath(this.#rootDir, sessionId, turnId));
+    let trace = null;
+    if (locator?.requestKey && locator.sessionId === sessionId) {
+      trace = await readRequestDir(requestDirFor(this.#rootDir, sessionId, locator.requestKey));
+    }
+    if (!traceMatchesIdentity(trace, sessionId, turnId)) {
+      trace = (await readTraceSummaries(this.#rootDir, sessionId))
+        .map(item => item.trace)
+        .find(item => traceMatchesIdentity(item, sessionId, turnId)) || null;
+    }
+    if (!trace) return false;
+    this.#requestCache.set(trace.requestKey, trace);
+    return true;
+  }
+
   #traceSummaries(sessionId = null) {
     // Cache-only: #ensureHydrated() has already merged every on-disk trace
     // into #requestCache exactly once, so we never touch disk here. This is
@@ -1448,7 +1502,7 @@ export class DebugTrace {
     return tracePathFor(this.#rootDir, trace.sessionId || null, trace.requestKey);
   }
 
-  #appendTraceRecord(trace, type, record, { writeMeta = false } = {}) {
+  #appendTraceRecord(trace, type, record, { writeMeta = false, evictAfterWrite = false } = {}) {
     if (!this.#acceptingWrites || !trace?.requestKey || !record) return;
     this.#requestCache.set(trace.requestKey, trace);
     const initialize = !this.#initializedRequestKeys.has(trace.requestKey);
@@ -1459,6 +1513,7 @@ export class DebugTrace {
       record: cloneJsonValue(record),
       initialize,
       writeMeta: !!writeMeta,
+      evictAfterWrite: !!evictAfterWrite,
     });
     if (writeMeta) {
       this.#flushPending();
@@ -1498,15 +1553,16 @@ export class DebugTrace {
       for (const entry of entries) {
         if (!this.#requestCache.has(entry.trace.requestKey)) continue;
         const requestDir = requestDirFor(this.#rootDir, entry.trace.sessionId || null, entry.trace.requestKey);
-        const batch = batches.get(requestDir) || { trace: entry.trace, initialize: false, writeMeta: false, lines: [] };
+        const batch = batches.get(requestDir) || { trace: entry.trace, initialize: false, writeMeta: false, evictAfterWrite: false, lines: [] };
         batch.trace = entry.trace;
         batch.initialize ||= entry.initialize;
         batch.writeMeta ||= entry.writeMeta;
+        batch.evictAfterWrite ||= entry.evictAfterWrite;
         batch.lines.push(`${JSON.stringify({ type: entry.type, record: entry.record })}\n`);
         batches.set(requestDir, batch);
       }
       for (const [requestDir, batch] of batches) {
-        const { trace, initialize, writeMeta } = batch;
+        const { trace, initialize, writeMeta, evictAfterWrite } = batch;
         const lines = [...batch.lines];
         const legacyRequestDir = trace._persistedFormat === 'legacy'
           ? trace._persistedRequestDir || null
@@ -1542,6 +1598,7 @@ export class DebugTrace {
           if (legacyRequestDir && legacyRequestDir !== requestDir) {
             await removeRequestDirIfIdentityMatches(legacyRequestDir, trace);
           }
+          if (evictAfterWrite) this.#requestCache.delete(trace.requestKey);
         } catch (err) {
           console.warn('[Yeaft] debug trace append failed:', err?.message || err);
         }
@@ -1721,6 +1778,8 @@ export class DebugTrace {
 export class NullTrace {
   startTurn() { return 'null'; }
   endTurn() {}
+  finalizeQuery() {}
+  async resumeTrace() { return false; }
   logTool() { return 'null'; }
   logEvent() { return 'null'; }
   event() { return 'null'; }

package/yeaft/engine.js

@@ -1972,12 +1972,18 @@ export class Engine {
    * @yields {EngineEvent}
    */
   async *query(params = {}) {
+    const queryTraceId = typeof params.vpTurnId === 'string' && params.vpTurnId
+      ? params.vpTurnId : null;
     let terminalEmitted = false;
+    let terminalStopReason = 'error';
     let lastTurnNumber = 0;
     try {
       for await (const event of this.#queryLifecycle(params)) {
         if (Number.isFinite(event?.turnNumber)) lastTurnNumber = event.turnNumber;
-        if (event?.type === 'turn_end' && event.terminal === true) terminalEmitted = true;
+        if (event?.type === 'turn_end' && event.terminal === true) {
+          terminalEmitted = true;
+          terminalStopReason = event.stopReason || terminalStopReason;
+        }
         yield event;
       }
     } catch (err) {
@@ -2001,6 +2007,13 @@ export class Engine {
         // hook must not retroactively turn the completed answer into an error.
         console.warn('[Engine] post-turn maintenance failed:', err?.message || err);
       }
+    } finally {
+      if (queryTraceId && typeof this.#trace?.finalizeQuery === 'function') {
+        this.#trace.finalizeQuery(queryTraceId, {
+          sessionId: params.sessionId || null,
+          stopReason: terminalEmitted ? terminalStopReason : 'interrupted',
+        });
+      }
     }
   }