@yeaft/webchat-agent 0.1.1104 → 0.1.1107

package/yeaft/web-bridge.js

@@ -66,7 +66,7 @@ import { isHiddenConversationRow } from './conversation/internal-control.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { pairSanitize } from './pair-sanitize.js';
 import { filterSnapshotForVp } from './snapshot-filter.js';
-import { createVpStatusBroker } from './vp-status-broker.js';
+import { createVpStatusBroker, isVpStatusRunning } from './vp-status-broker.js';
 import { classifyThread as defaultClassifyThread, fallbackTitle } from './vp/thread-classifier.js';
 import { listMcpServers, upsertMcpServer, removeMcpServer } from './config-api.js';
 import { buildMcpFlattenedTools } from './tools/mcp-tools.js';
@@ -433,6 +433,32 @@ function buildVpPromptPayload(vpId, envelope) {
   return { text, prompt, promptParts };
 }
 
+function buildPendingRescueEnvelope({ sessionId, taskId = null, threadId = 'main', followUpId, leftover, replayText, replayParts = null }) {
+  const leftoverIsInternal = Boolean(leftover?.internal);
+  const leftoverInjectedBy = leftoverIsInternal && typeof leftover?.injectedBy === 'string'
+    ? leftover.injectedBy
+    : null;
+  return {
+    sessionId,
+    taskId,
+    trigger: 'pending_rescue',
+    msg: {
+      id: followUpId,
+      from: leftoverIsInternal && leftover.senderVpId ? leftover.senderVpId : 'user',
+      role: leftoverIsInternal ? 'assistant' : 'user',
+      text: replayText,
+      meta: {
+        rescuedFrom: 'pendingQueries',
+        threadId,
+        ...(leftoverInjectedBy ? { injectedBy: leftoverInjectedBy } : {}),
+        ...(leftoverIsInternal && leftover.senderVpId ? { senderVpId: leftover.senderVpId } : {}),
+        ...(leftoverIsInternal && leftover.sourceThreadId ? { sourceThreadId: leftover.sourceThreadId } : {}),
+      },
+    },
+    ...(Array.isArray(replayParts) && replayParts.length > 0 ? { _promptParts: replayParts } : {}),
+  };
+}
+
 export function visibleInboundThreadId(envelope, fallbackThreadId = 'main') {
   const meta = envelope?.msg?.meta || {};
   if (
@@ -1217,6 +1243,7 @@ function formatTaskResultForVp(task) {
     `<task-result id="${task.id}" kind="${task.kind}" status="${task.status}">`,
     `title: ${task.title || task.kind || task.id}`,
   ];
+  if (task?.runtime?.command) lines.push(`command: ${task.runtime.command}`);
   if (result.exitCode !== undefined && result.exitCode !== null) lines.push(`exitCode: ${result.exitCode}`);
   if (result.signal) lines.push(`signal: ${result.signal}`);
   if (result.error) lines.push(`error: ${result.error}`);
@@ -1349,6 +1376,9 @@ async function routeEnvelopeToVpThread(sessionId, vpId, envelope) {
       originalText: text,
       originalParts: Array.isArray(envelope?._promptParts) ? envelope._promptParts : null,
       internal: isInternalAppend,
+      injectedBy: isInternalAppend ? injectedBy : null,
+      senderVpId: isInternalAppend ? (envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null) : null,
+      sourceThreadId: isInternalAppend ? visibleInboundThreadId(envelope, thread.threadId) : null,
     });
     persistInboundMessageOnceByMsgId({
       msgId: envelope?.msg?.id,
@@ -1533,18 +1563,15 @@ function ensureDriverRunning(sessionId, vpId, threadId = 'main') {
             : null;
           if (!replayText && !replayParts) continue;
           const followUpId = `followup_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
-          const followUpEnvelope = {
+          const followUpEnvelope = buildPendingRescueEnvelope({
             sessionId,
             taskId: envelope?.taskId || null,
-            trigger: 'pending_rescue',
-            msg: {
-              id: followUpId,
-              from: 'user',
-              text: replayText,
-              meta: { rescuedFrom: 'pendingQueries', threadId: thread.threadId },
-            },
-            ...(replayParts ? { _promptParts: replayParts } : {}),
-          };
+            threadId: thread.threadId,
+            followUpId,
+            leftover,
+            replayText,
+            replayParts,
+          });
           const followUpTurnId = `${randomUUID().slice(0, 8)}:${vpId}`;
           inbox.push({ envelope: followUpEnvelope, turnId: followUpTurnId, thread });
           try {
@@ -1824,7 +1851,7 @@ function decorateSessionsWithRuntimeState(sessions) {
     const sessionId = status?.sessionId || status?.groupId || null;
     if (!sessionId) continue;
     const state = status.state || 'idle';
-    const running = !['idle', 'offline', 'completed', 'failed', 'aborted'].includes(state);
+    const running = isVpStatusRunning(state);
     const updatedAt = status.updatedAt || status.since || Date.now();
     const prev = bySession.get(sessionId) || { running: false, runningVpCount: 0, latestActivityAt: 0 };
     if (running) prev.runningVpCount += 1;
@@ -2354,6 +2381,89 @@ function maybeTransitionVpStatus(hctx, state) {
   }
 }
 
+const STREAM_TEXT_BATCH_MAX_CHARS = 200;
+const STREAM_TEXT_BATCH_MAX_MS = 200;
+
+function createStreamTextBatch() {
+  return {
+    parts: [],
+    charCount: 0,
+    timer: null,
+    envelope: null,
+    immediateNext: true,
+  };
+}
+
+function getStreamTextBatch(hctx) {
+  if (!hctx) return null;
+  if (!hctx.streamTextBatch) hctx.streamTextBatch = createStreamTextBatch();
+  return hctx.streamTextBatch;
+}
+
+function clearStreamTextBatchTimer(batch) {
+  if (!batch?.timer) return;
+  clearTimeout(batch.timer);
+  batch.timer = null;
+}
+
+function sendAssistantTextFrame(text, envelope) {
+  if (!text) return;
+  sendSessionOutputFrame({
+    type: 'assistant',
+    message: { content: [{ type: 'text', text }] },
+  }, envelope);
+}
+
+function flushStreamTextBatch(hctx, envelope, { resetImmediate = false } = {}) {
+  const batch = hctx?.streamTextBatch;
+  if (!batch) return false;
+  clearStreamTextBatchTimer(batch);
+  const text = batch.parts.join('');
+  batch.parts = [];
+  batch.charCount = 0;
+  const flushEnvelope = envelope || batch.envelope;
+  batch.envelope = flushEnvelope || null;
+  if (resetImmediate) batch.immediateNext = true;
+  if (!text) return false;
+  sendAssistantTextFrame(text, flushEnvelope);
+  return true;
+}
+
+function scheduleStreamTextBatchFlush(hctx, batch) {
+  if (!hctx || batch.timer) return;
+  batch.timer = setTimeout(() => {
+    batch.timer = null;
+    flushStreamTextBatch(hctx, batch.envelope);
+  }, STREAM_TEXT_BATCH_MAX_MS);
+  if (batch.timer && typeof batch.timer.unref === 'function') {
+    batch.timer.unref();
+  }
+}
+
+function queueStreamTextDelta(hctx, text, envelope) {
+  if (typeof text !== 'string' || text.length === 0) return;
+  const batch = getStreamTextBatch(hctx);
+  if (!batch) {
+    sendAssistantTextFrame(text, envelope);
+    return;
+  }
+
+  batch.envelope = envelope;
+  if (batch.immediateNext) {
+    batch.immediateNext = false;
+    sendAssistantTextFrame(text, envelope);
+    return;
+  }
+
+  batch.parts.push(text);
+  batch.charCount += text.length;
+  if (batch.charCount >= STREAM_TEXT_BATCH_MAX_CHARS) {
+    flushStreamTextBatch(hctx, envelope);
+    return;
+  }
+  scheduleStreamTextBatchFlush(hctx, batch);
+}
+
 /**
  * Handle a single engine event unwrapped from an `engine_event` envelope.
  * Stamps threadId on every outgoing frame so frontend grouping, tools,
@@ -2375,13 +2485,17 @@ function handleEngineEvent(event, hctx) {
     threadId: hctx.threadId || event.threadId,
   };
 
+  if (event.type !== 'text_delta') {
+    // Preserve wire order. Any boundary/metadata/tool event must see all text
+    // accepted before it flushed first; otherwise the browser can render a tool
+    // call or terminal result before the text that led to it.
+    flushStreamTextBatch(hctx, envelope, { resetImmediate: true });
+  }
+
   switch (event.type) {
     case 'text_delta':
       hctx.assistantTextParts.push(event.text);
-      sendSessionOutputFrame({
-        type: 'assistant',
-        message: { content: [{ type: 'text', text: event.text }] },
-      }, envelope);
+      queueStreamTextDelta(hctx, event.text, envelope);
       // vp-status: first text-delta of a (thinking|tool) phase flips
       // the row to 'streaming'. transition() is a no-op when already
       // streaming, so subsequent deltas are cheap.
@@ -3410,6 +3524,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
   let turnEndReason = 'end_turn';
   let turnEndEmitted = false;
   let turnEndDetail = null;
+  let handlerCtx = null;
   const markTurnEnd = (reason) => { turnEndEmitted = true; turnEndReason = reason; };
   const emitVpTurnEnd = (reason, detail = null) => {
     if (turnEndEmitted) return;
@@ -3483,7 +3598,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
       vpEngine = getOrCreateVpEngine(sessionId, vpId, threadId);
       if (thread) thread.engine = vpEngine;
 
-      const handlerCtx = {
+      handlerCtx = {
         assistantTextParts,
         toolCallsAccum,
         toolResultsAccum,
@@ -3529,6 +3644,8 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         handleEngineEvent(event, handlerCtx);
       }
 
+      flushStreamTextBatch(handlerCtx, envelope, { resetImmediate: true });
+
       // Turn completed — atomically append this VP's output to shared history.
       // route_forward handoff text is an internal trigger, already visible as
       // the source VP's tool action. Do not append it as a visible prompt for
@@ -3557,6 +3674,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
   } catch (err) {
     const isAbort = err && (err.name === 'AbortError' || err.name === 'LLMAbortError');
     if (isAbort) {
+      flushStreamTextBatch(handlerCtx, envelope, { resetImmediate: true });
       sendSessionOutputFrame({
         type: 'result',
         result_text: '',
@@ -3581,6 +3699,8 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
       console.warn('[Yeaft] vp-status error transition failed:', brokerErr?.message || brokerErr);
     }
 
+    flushStreamTextBatch(handlerCtx, envelope, { resetImmediate: true });
+
     if (isPermissionErrorMsg(err.message)) {
       if (!_permissionDiagnosticSent) {
         _permissionDiagnosticSent = true;
@@ -4358,7 +4478,7 @@ export async function handleYeaftFetchToolStats(_msg = {}) {
 }
 
 /**
- * Hydrate the YeaftDebugPanel from the persistent SQLite trace. The
+ * Hydrate the YeaftDebugPanel from the persistent file-backed trace. The
  * panel state (`yeaftDebugLoops` / `yeaftDebugTurnsById`) is otherwise
  * built ONLY from in-flight `loop` / `turn_open` events on the wire,
  * so a panel opened after a turn has finished sees nothing for that
@@ -4366,28 +4486,36 @@ export async function handleYeaftFetchToolStats(_msg = {}) {
  * splices into place.
  *
  * Inputs (all optional):
- *   - `limit`     — max number of loops to return (1..500, default 100)
- *   - `sessionId`   — narrow by group
- *   - `threadId`  — narrow by thread
+ *   - `limit`        — request cap; bounded by the file trace store
+ *   - `indexOnly`    — list request summaries without loop/detail payloads
+ *   - `detailTurnId` — fetch full loops/tools for one request
+ *   - `sessionId`    — narrow by Session
+ *   - `threadId`     — narrow by thread
+ *   - `search`       — regex matched against bounded request summaries
  *
  * Sends:
- *   { type: 'yeaft_debug_history', loops: [...], turns: [...] }
+ *   { type: 'yeaft_debug_history', loops: [...], turns: [...], indexOnly, detailTurnId }
  *
  * Best-effort: if the session / trace isn't ready, sends an empty
  * snapshot so the panel renders a placeholder instead of spinning.
  */
 export async function handleYeaftFetchDebugHistory(msg = {}) {
-  const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 100;
+  const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 10;
   const dreamLimit = Number.isFinite(msg?.dreamLimit) ? Number(msg.dreamLimit) : 5;
   const sessionId = typeof msg?.sessionId === 'string' && msg.sessionId ? msg.sessionId : null;
   const threadId = typeof msg?.threadId === 'string' && msg.threadId ? msg.threadId : null;
+  const search = typeof msg?.search === 'string' ? msg.search.trim() : '';
+  const requestId = typeof msg?.requestId === 'string' && msg.requestId ? msg.requestId : null;
+  const requestKind = typeof msg?.requestKind === 'string' && msg.requestKind ? msg.requestKind : null;
+  const indexOnly = !!msg?.indexOnly;
+  const detailTurnId = typeof msg?.detailTurnId === 'string' && msg.detailTurnId ? msg.detailTurnId : null;
   let loops = [];
   let turns = [];
   let dreamEvents = [];
   let hasMore = false;
   try {
     if (session?.trace && typeof session.trace.fetchRecentDebugHistory === 'function') {
-      const out = session.trace.fetchRecentDebugHistory({ limit, dreamLimit, sessionId, threadId });
+      const out = session.trace.fetchRecentDebugHistory({ limit, dreamLimit, sessionId, threadId, indexOnly, detailTurnId, search });
       loops = Array.isArray(out?.loops) ? out.loops : [];
       turns = Array.isArray(out?.turns) ? out.turns : [];
       dreamEvents = Array.isArray(out?.dreamEvents) ? out.dreamEvents : [];
@@ -4399,6 +4527,14 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
       loops: [],
       turns: [],
       dreamEvents: [],
+      requestId,
+      requestKind,
+      sessionId,
+      threadId,
+      search,
+      limit,
+      indexOnly,
+      detailTurnId,
       error: err && err.message ? err.message : String(err),
     });
     return;
@@ -4408,10 +4544,15 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
     loops,
     turns,
     dreamEvents,
+    requestId,
+    requestKind,
     sessionId,
     threadId,
+    search,
     hasMore,
     limit,
+    indexOnly,
+    detailTurnId,
   });
 }
 
@@ -4483,6 +4624,54 @@ export function handleYeaftSubAgentPrompt(msg) {
   }, { sessionId, vpId: task.ownerVpId || null, threadId: task.source?.threadId || null });
 }
 
+export function handleYeaftTaskCancel(msg) {
+  const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
+  const taskId = typeof msg?.taskId === 'string' ? msg.taskId.trim() : '';
+  const clientRequestId = typeof msg?.clientRequestId === 'string' ? msg.clientRequestId.trim() : '';
+  const fail = (error, task = null) => {
+    sendSessionEvent({
+      type: 'yeaft_task_cancel_result',
+      success: false,
+      taskId: taskId || null,
+      clientRequestId: clientRequestId || null,
+      error,
+      ...(task ? { task } : {}),
+    }, sessionId ? { sessionId, vpId: task?.ownerVpId || null, threadId: task?.source?.threadId || null } : undefined);
+  };
+
+  if (!sessionId || !taskId) {
+    fail('sessionId and taskId are required');
+    return;
+  }
+  if (!session?.taskManager || typeof session.taskManager.cancelTask !== 'function') {
+    fail('task manager unavailable');
+    return;
+  }
+
+  let result;
+  try {
+    result = session.taskManager.cancelTask(sessionId, taskId);
+  } catch (err) {
+    fail(err?.message || String(err));
+    return;
+  }
+
+  const task = result?.task || session.taskManager.getTask?.(sessionId, taskId) || null;
+  if (!result?.ok) {
+    fail(result?.error || 'Failed to cancel task', task);
+    return;
+  }
+
+  sendSessionEvent({
+    type: 'yeaft_task_cancel_result',
+    success: true,
+    taskId,
+    clientRequestId: clientRequestId || null,
+    pending: !!result?.pending,
+    task,
+  }, { sessionId, vpId: task?.ownerVpId || null, threadId: task?.source?.threadId || null });
+}
+
 /** Deprecated mode switch — Yeaft is single-mode. */
 export function handleYeaftModeSwitch(_msg) {
   console.warn('[Yeaft] yeaft_mode_switch is deprecated and ignored — Yeaft now runs in a single unified mode.');
@@ -5112,6 +5301,7 @@ export async function handleYeaftMcpReload(msg = {}) {
 export const __testHooks = {
   loadVisibleGroupHistoryPage,
   persistInboundMessageOnceByMsgId,
+  buildPendingRescueEnvelope,
   setSessionForTest(nextSession) {
     session = nextSession || null;
   },
@@ -5121,6 +5311,13 @@ export const __testHooks = {
     vpAborts.clear();
     vpInboxes.clear();
   },
+  resetVpStatusBroker() {
+    if (vpStatusBroker) vpStatusBroker.reset();
+  },
+  seedVpStatus(status) {
+    return getVpStatusBroker().transition(status);
+  },
+  decorateSessionsWithRuntimeState,
   seedQueuedVpTurn({ sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test' } = {}) {
     const key = threadKey(sessionId, vpId, threadId);
     const inbox = vpInboxes.get(key) || [];