@yeaft/webchat-agent 1.0.668 → 1.0.670

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.668",
+  "version": "1.0.670",
   "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/llm/openai-responses.js

@@ -667,7 +667,11 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
       }
       if (!sawTerminalEvent) {
         if (hasToolItems()) {
-          throw new LLMToolInputError('OpenAI tool stream ended before terminal event');
+          // Calls remain buffered until terminal validation, so clean EOF here
+          // is a transport failure, not proof of invalid tool input. Let the
+          // engine apply its bounded retry/continuation policy; known malformed
+          // batches above (and in catch) still fail closed without replay.
+          throw new LLMServerError('OpenAI tool stream ended before terminal event', 0);
         }
         throw new LLMServerError('OpenAI stream ended before terminal event', 0);
       }

package/yeaft/sessions/scheduled-task-scheduler.js

@@ -181,6 +181,13 @@ export class ScheduledTaskScheduler {
   }
 
   observe(sessionId, event) {
+    // Stop can arrive before boot/classification creates any VP turn controller
+    // or terminal event. Retire those claims once their ingress has drained.
+    if (event.type === 'yeaft_aborted' && event.all) {
+      for (const [id, active] of this.runs) {
+        if (!sessionId || id === sessionId) active.interrupted = true;
+      }
+    }
     const active = this.runs.get(sessionId);
     if (!active) return;
     if (event.type === 'error') active.error = event.message || event.error?.message || String(event.error || 'Execution failed');

package/yeaft/web-bridge.js

@@ -510,6 +510,36 @@ const vpAborts = new Map();
  */
 const sessionCopyEpochs = new Map();
 const modelReentryActivity = new Map();
+// Pending ingress has no VP AbortController yet. Keep per-request tokens so
+// Stop fences existing boot/classification awaits, not later inputs in the
+// same activity epoch (or inputs belonging to another Session).
+const pendingSessionIngress = new Map();
+
+function beginSessionIngress(sessionId) {
+  let pending = pendingSessionIngress.get(sessionId);
+  if (!pending) {
+    pending = new Set();
+    pendingSessionIngress.set(sessionId, pending);
+  }
+  const ingress = {
+    cancelled: false,
+    release() {
+      pending.delete(ingress);
+      if (pending.size === 0 && pendingSessionIngress.get(sessionId) === pending) {
+        pendingSessionIngress.delete(sessionId);
+      }
+    },
+  };
+  pending.add(ingress);
+  return ingress;
+}
+
+function cancelSessionIngress(sessionId = null) {
+  for (const [id, pending] of pendingSessionIngress) {
+    if (sessionId && id !== sessionId) continue;
+    for (const ingress of pending) ingress.cancelled = true;
+  }
+}
 
 function hasSessionRuntimeWork(sessionId) {
   const prefix = `${sessionId}::`;
@@ -2273,14 +2303,16 @@ function scheduleTaskResultReentry(event) {
 
 async function routeEnvelopeToVpThread(sessionId, vpId, envelope) {
   const releaseActivity = beginSessionActivity(sessionId);
+  const ingress = beginSessionIngress(sessionId);
   try {
-    return await routeActiveEnvelopeToVpThread(sessionId, vpId, envelope);
+    return await routeActiveEnvelopeToVpThread(sessionId, vpId, envelope, ingress);
   } finally {
+    ingress.release();
     releaseActivity();
   }
 }
 
-async function routeActiveEnvelopeToVpThread(sessionId, vpId, envelope) {
+async function routeActiveEnvelopeToVpThread(sessionId, vpId, envelope, ingress) {
   const routeStart = perfNowMs();
   const { text, prompt, promptParts } = buildVpPromptPayload(vpId, envelope);
   const runningThreads = getRunningThreads(sessionId, vpId);
@@ -2313,6 +2345,7 @@ async function routeActiveEnvelopeToVpThread(sessionId, vpId, envelope) {
       // promise would leave it visible in history without ever starting a turn.
       console.warn('[Yeaft] VP thread classification failed; starting a new thread:', err?.message || err);
     }
+    if (ingress.cancelled) return null;
     const targetIsRunning = decision
       ? runningThreads.some((t) => t.threadId === decision.targetThreadId)
       : false;
@@ -5214,22 +5247,25 @@ async function runYeaftSessionSend(msg) {
   traceDuration('session_send.open_session', openSessionStart, { ok: !!sessionHandle });
 
   const releaseActivity = beginSessionActivity(sessionId);
+  const ingress = beginSessionIngress(sessionId);
   try {
     return await dispatchAcceptedSessionSend({
-      msg, text, mentions, quote, sessionId, yeaftDir, perfTraceId, perfStart,
+      msg, text, mentions, quote, sessionId, yeaftDir, perfTraceId, perfStart, ingress,
       tracePerf, traceDuration, turnConfig, sessionHandle, sessionRoot, sessionMetaForRuntime,
     });
   } finally {
+    ingress.release();
     releaseActivity();
   }
 }
 
 async function dispatchAcceptedSessionSend({
-  msg, text, mentions, quote, sessionId, yeaftDir, perfTraceId, perfStart,
+  msg, text, mentions, quote, sessionId, yeaftDir, perfTraceId, perfStart, ingress,
   tracePerf, traceDuration, turnConfig, sessionHandle, sessionRoot, sessionMetaForRuntime,
 }) {
   const ensureSessionStart = perfNowMs();
   await ensureSessionLoaded({ sessionMeta: sessionMetaForRuntime, perfTraceId });
+  if (ingress.cancelled) return;
   // Runtime boot may await I/O. Re-read the claim immediately before ingress
   // so edits, disable, archive or deletion during boot cannot execute stale work.
   msg[SCHEDULED_TASK_DISPATCH_GUARD]?.();
@@ -6742,6 +6778,7 @@ export function handleYeaftAbortThread(_msg = {}) {
 export function handleYeaftAbortAll(msg = {}) {
   const sessionId = typeof msg.sessionId === 'string' && msg.sessionId ? msg.sessionId : null;
   const aborted = [];
+  cancelSessionIngress(sessionId);
   if (!sessionId && currentAbortCtrl && !currentAbortCtrl.signal.aborted) {
     try { currentAbortCtrl.abort(); aborted.push('main'); } catch { /* best-effort */ }
   }