@yeaft/webchat-agent 1.0.12 → 1.0.14

package/connection/message-router.js

@@ -38,7 +38,7 @@ import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
 import { discoverLlmModels } from '../llm-model-discovery.js';
 import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
-import { handleYeaftSessionSend, handleYeaftSubAgentPrompt, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager } from '../yeaft/web-bridge.js';
+import { handleYeaftSessionSend, handleYeaftSubAgentPrompt, handleYeaftTaskCancel, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager } from '../yeaft/web-bridge.js';
 import { startYeaftStatusRefresh, refreshYeaftStatus } from '../yeaft/status-cache.js';
 
 export async function handleMessage(msg) {
@@ -658,6 +658,9 @@ export async function handleMessage(msg) {
     case 'yeaft_sub_agent_prompt':
       handleYeaftSubAgentPrompt(msg);
       break;
+    case 'yeaft_task_cancel':
+      handleYeaftTaskCancel(msg);
+      break;
 
     // wave-6b: manual dream trigger from VP detail page
     case 'yeaft_dream_trigger':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "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/tasks/manager.js

@@ -12,6 +12,7 @@ import { getRuntimePlatformInfo } from '../runtime-platform.js';
 
 const LOG_PREVIEW_BYTES = 4096;
 const SUB_AGENT_LOG_PREVIEW_BYTES = 1024 * 1024;
+const DEFAULT_CANCEL_ESCALATION_MS = 2000;
 
 function logPreviewBytesFor(task) {
   return task?.kind === 'sub_agent' ? SUB_AGENT_LOG_PREVIEW_BYTES : LOG_PREVIEW_BYTES;
@@ -45,14 +46,23 @@ function publicSnapshot(task) {
   };
 }
 
+function taskCommand(task) {
+  const command = task?.runtime?.command;
+  return typeof command === 'string' && command.trim() ? command.trim() : '';
+}
+
 export class TaskManager {
-  constructor({ yeaftDir, onEvent = null, runtimePlatform = null } = {}) {
+  constructor({ yeaftDir, onEvent = null, runtimePlatform = null, cancelEscalationMs = DEFAULT_CANCEL_ESCALATION_MS } = {}) {
     if (!yeaftDir) throw new Error('TaskManager requires yeaftDir');
     this.store = new TaskStore({ yeaftDir });
     this.onEvent = typeof onEvent === 'function' ? onEvent : null;
     this.runtimePlatform = runtimePlatform || getRuntimePlatformInfo();
+    this.cancelEscalationMs = Number.isFinite(cancelEscalationMs)
+      ? Math.max(0, Math.floor(cancelEscalationMs))
+      : DEFAULT_CANCEL_ESCALATION_MS;
     this.active = new Map();
     this.processes = new Map();
+    this.cancelEscalationTimers = new Map();
     this.#loadPersistedRunningTasks();
   }
 
@@ -191,9 +201,15 @@ export class TaskManager {
     const key = this.#key(sessionId, taskId);
     const task = this.active.get(key) || this.store.readTask(sessionId, taskId);
     if (!task || isTerminalTaskStatus(task.status)) return publicSnapshot(task);
+    const escalationTimer = this.cancelEscalationTimers.get(key);
+    if (escalationTimer) {
+      clearTimeout(escalationTimer);
+      this.cancelEscalationTimers.delete(key);
+    }
     const logPath = task.log?.path || this.store.logPath(sessionId, taskId);
     const tail = this.store.readLogFile(logPath, { tail: true, maxBytes: logPreviewBytesFor(task) });
-    task.status = status || TASK_STATUS.FAILED;
+    const cancelRequested = !!task.runtime?.cancelRequestedAt;
+    task.status = cancelRequested ? TASK_STATUS.CANCELLED : (status || TASK_STATUS.FAILED);
     task.updatedAt = nowIso();
     task.endedAt = nowIso();
     task.log = { ...(task.log || {}), path: tail.path, bytes: tail.bytes, preview: tail.text };
@@ -212,19 +228,61 @@ export class TaskManager {
     if (!task) return { ok: false, error: `Unknown task: ${taskId}` };
     if (isTerminalTaskStatus(task.status)) return { ok: true, task: publicSnapshot(task) };
     const runner = this.processes.get(key);
-    const killed = runner ? runner.kill('SIGTERM') : false;
-    if (!killed) {
+    if (!runner) {
       return {
         ok: false,
-        error: 'Unable to cancel task: no live process handle or process-tree kill failed.',
+        error: 'Unable to cancel task: no live process handle.',
         task: publicSnapshot(task),
       };
     }
-    const completed = this.#completeTask(sessionId, taskId, {
-      status: TASK_STATUS.CANCELLED,
-      signal: 'SIGTERM',
-    });
-    return { ok: true, task: completed };
+
+    if (!task.runtime?.cancelRequestedAt) {
+      const signalled = runner.kill('SIGTERM');
+      if (!signalled) {
+        return {
+          ok: false,
+          error: 'Unable to cancel task: process-tree signal failed.',
+          task: publicSnapshot(task),
+        };
+      }
+      const cancelRequestedAt = nowIso();
+      task.runtime = {
+        ...(task.runtime || {}),
+        cancelRequestedAt,
+        cancelSignal: 'SIGTERM',
+        cancelEscalationMs: this.cancelEscalationMs,
+      };
+      task.updatedAt = cancelRequestedAt;
+      this.store.writeTask(task);
+      this.active.set(key, task);
+      this.store.appendEvent(sessionId, { event: 'cancel_requested', taskId, signal: 'SIGTERM' });
+      this.#emit('updated', task, { cancelRequested: true });
+
+      if (this.cancelEscalationMs >= 0 && !this.cancelEscalationTimers.has(key)) {
+        const timer = setTimeout(() => {
+          this.cancelEscalationTimers.delete(key);
+          const current = this.active.get(key) || this.store.readTask(sessionId, taskId);
+          if (!current || isTerminalTaskStatus(current.status)) return;
+          const liveRunner = this.processes.get(key);
+          const escalated = liveRunner ? liveRunner.kill('SIGKILL') : false;
+          current.runtime = {
+            ...(current.runtime || {}),
+            cancelEscalatedAt: nowIso(),
+            cancelEscalatedSignal: 'SIGKILL',
+            cancelEscalationFailed: !escalated,
+          };
+          current.updatedAt = current.runtime.cancelEscalatedAt;
+          this.store.writeTask(current);
+          this.active.set(key, current);
+          this.store.appendEvent(sessionId, { event: 'cancel_escalated', taskId, signal: 'SIGKILL', ok: escalated });
+          this.#emit('updated', current, { cancelEscalated: true, cancelEscalationOk: escalated });
+        }, this.cancelEscalationMs);
+        if (typeof timer.unref === 'function') timer.unref();
+        this.cancelEscalationTimers.set(key, timer);
+      }
+    }
+
+    return { ok: true, task: publicSnapshot(task), pending: true };
   }
 
   listActiveTasks(sessionId = null) {
@@ -274,7 +332,9 @@ export class TaskManager {
     const lines = ['<active_tasks>'];
     for (const task of tasks) {
       const preview = (task.log?.preview || '').trim().split('\n').slice(-3).join(' | ');
-      lines.push(`- ${task.id} | ${task.kind} | ${task.status} | owner=${task.ownerVpId || 'unknown'} | title=${JSON.stringify(task.title)} | log=${task.log?.path || ''}${preview ? ` | tail=${JSON.stringify(preview)}` : ''}`);
+      const command = taskCommand(task);
+      const cancelRequestedAt = typeof task.runtime?.cancelRequestedAt === 'string' ? task.runtime.cancelRequestedAt : '';
+      lines.push(`- ${task.id} | ${task.kind} | ${task.status} | owner=${task.ownerVpId || 'unknown'} | title=${JSON.stringify(task.title)}${command ? ` | command=${JSON.stringify(command)}` : ''}${cancelRequestedAt ? ` | cancelRequestedAt=${JSON.stringify(cancelRequestedAt)}` : ''} | log=${task.log?.path || ''}${preview ? ` | tail=${JSON.stringify(preview)}` : ''}`);
     }
     lines.push('</active_tasks>');
     return lines.join('\n');

package/yeaft/web-bridge.js

@@ -1217,6 +1217,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}`);
@@ -2354,6 +2355,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 +2459,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 +3498,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 +3572,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 +3618,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 +3648,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 +3673,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;
@@ -4489,6 +4583,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.');