@yeaft/webchat-agent 1.0.576 → 1.0.578

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.576"}
+{"version":"1.0.578"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.576",
+  "version": "1.0.578",
   "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/engine.js

@@ -3169,7 +3169,12 @@ export class Engine {
             });
           }
           switch (event.type) {
+            case 'provider_activity':
+              // Internal liveness only: no text, tools, usage or durable state.
+              if (!sawProviderStop) yield { type: 'provider_activity' };
+              break;
             case 'text_delta':
+              if (typeof event.text !== 'string' || event.text.length === 0) break;
               if (ttfbMs === null) {
                 ttfbMs = Date.now() - startTime;
                 traceRequest('llm.first_text', {
@@ -3184,6 +3189,7 @@ export class Engine {
               providerState = event.providerState;
               break;
             case 'thinking_delta':
+              if (typeof event.text !== 'string' || event.text.length === 0) break;
               yield event;
               break;
             case 'thinking_block_end':

package/yeaft/llm/adapter.js

@@ -44,12 +44,13 @@ import { utf8PrefixWithinBytes } from '../utf8.js';
  * @typedef {{ type: 'thinking_delta', text: string }} ThinkingDeltaEvent
  * @typedef {{ type: 'thinking_block_end', thinking: string, signature: string }} ThinkingBlockEndEvent
  * @typedef {{ type: 'tool_call', id: string, name: string, input: object }} ToolCallEvent
+ * @typedef {{ type: 'provider_activity' }} ProviderActivityEvent Content-free progress on a non-empty hidden delta; watchdog only, never UI/history.
  * @typedef {{ type: 'provider_state', providerState: object, providerStateBytes: number }} ProviderStateEvent Internal only; never forward to UI/search.
  * @typedef {{ type: 'usage', inputTokens: number, outputTokens: number, reasoningTokens?: number, cacheReadTokens?: number, cacheWriteTokens?: number, cacheTokensAreIncludedInInput?: boolean }} UsageEvent
  * @typedef {{ type: 'stop', stopReason: 'end_turn' | 'tool_use' | 'max_tokens' }} StopEvent
  * @typedef {{ type: 'error', error: Error, retryable: boolean }} ErrorEvent
  *
- * @typedef {TextDeltaEvent | ThinkingDeltaEvent | ThinkingBlockEndEvent | ProviderStateEvent | ToolCallEvent | UsageEvent | StopEvent | ErrorEvent} StreamEvent
+ * @typedef {TextDeltaEvent | ThinkingDeltaEvent | ThinkingBlockEndEvent | ProviderActivityEvent | ProviderStateEvent | ToolCallEvent | UsageEvent | StopEvent | ErrorEvent} StreamEvent
  */
 
 // ─── Unified Message Types ─────────────────────────────────────

package/yeaft/llm/anthropic.js

@@ -395,6 +395,8 @@ export class AnthropicAdapter extends LLMAdapter {
           }
 
           const type = event.type;
+          if (signal?.aborted) throw new LLMAbortError();
+          if (sawStop) continue;
 
           if (type === 'content_block_start') {
             const block = event.content_block;
@@ -435,11 +437,15 @@ export class AnthropicAdapter extends LLMAdapter {
             const st = blockByIndex.get(idx);
             if (delta?.type === 'text_delta') {
               if (st?.kind === 'text') st.text += delta.text || '';
-              yield { type: 'text_delta', text: delta.text };
+              if (typeof delta.text === 'string' && delta.text.length > 0) {
+                yield { type: 'text_delta', text: delta.text };
+              }
             } else if (delta?.type === 'thinking_delta') {
               // Forward delta for live UI; ALSO accumulate for round-trip.
               if (st && st.kind === 'thinking') st.thinking += delta.thinking || '';
-              yield { type: 'thinking_delta', text: delta.thinking };
+              if (typeof delta.thinking === 'string' && delta.thinking.length > 0) {
+                yield { type: 'thinking_delta', text: delta.thinking };
+              }
             } else if (delta?.type === 'signature_delta') {
               // Anthropic typically sends signature in one delta near the
               // end of the (redacted_)thinking block. Accumulate defensively.
@@ -447,7 +453,11 @@ export class AnthropicAdapter extends LLMAdapter {
                 st.signature += delta.signature || '';
               }
             } else if (delta?.type === 'input_json_delta') {
-              if (st && st.kind === 'tool_use') st.input += delta.partial_json;
+              if (st?.kind === 'tool_use' && typeof delta.partial_json === 'string' && delta.partial_json.length > 0) {
+                st.input += delta.partial_json;
+                // No content and no throttling: the last delta defines idle time.
+                yield { type: 'provider_activity' };
+              }
             }
           } else if (type === 'content_block_stop') {
             const idx = event.index;

package/yeaft/llm/openai-responses.js

@@ -429,6 +429,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
           const type = event.type;
 
+          if (signal?.aborted) throw new LLMAbortError();
           if (sawTerminalEvent) continue;
           if (type === 'response.output_item.done') {
             if (Number.isInteger(event.output_index) && event.item) completedItems.set(event.output_index, event.item);
@@ -450,8 +451,14 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
           } else if (type === 'response.function_call_arguments.delta') {
             const idx = event.output_index;
             const accum = toolCallAccum.get(idx);
-            if (accum) {
-              accum.arguments += event.delta || '';
+            if (accum && typeof event.delta === 'string' && event.delta.length > 0) {
+              accum.arguments += event.delta;
+              yield { type: 'provider_activity' };
+            }
+          } else if (type === 'response.reasoning_text.delta' || type === 'response.reasoning_summary_text.delta') {
+            // Reasoning remains hidden; only report actual incremental content.
+            if (typeof event.delta === 'string' && event.delta.length > 0) {
+              yield { type: 'provider_activity' };
             }
           } else if (type === 'response.function_call_arguments.done') {
             const idx = event.output_index;

package/yeaft/models.js

@@ -496,8 +496,9 @@ function inferThinkingCapability(model) {
     return { supportsThinking: true, thinkingProtocol: 'openai-reasoning', defaultEffort: null, maxBudgetTokens: null };
   }
 
-  // Claude Opus 4.7/4.8 expose the full adaptive effort set, including xhigh.
-  if (/^claude-opus-4[-.]?(7|8)($|-|\.)/.test(id)) {
+  // Claude Opus 4.7/4.8 and every Claude 5+ generation (e.g. claude-opus-5.5,
+  // claude-sonnet-5) use adaptive thinking with output_config.effort.
+  if (/^claude-opus-4[-.]?(7|8)($|-|\.)/.test(id) || /^claude-(opus|sonnet|haiku)-([5-9]|[1-9]\d)($|-|\.)/.test(id)) {
     return {
       supportsThinking: true,
       thinkingProtocol: 'anthropic-adaptive',

package/yeaft/sub-agent/runner.js

@@ -490,6 +490,8 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
           // Liveness — update first so even listener throws don't lose
           // the bump.
           bumpLivenessFromEvent(agent.liveness, evt);
+          // Hidden provider progress is liveness only, never a log/task/UI event.
+          if (evt?.type === 'provider_activity') continue;
 
           // Mirror every raw event to the durable log. We still keep
           // `sub_agent_event` text_delta suppressed so the inline transcript

package/yeaft/web-bridge.js

@@ -1157,7 +1157,7 @@ export function broadcastLanguageChange(language) {
   applyLiveLanguage(language);
 }
 
-/** Query timeout in ms — abort if LLM doesn't respond within this window */
+/** Provider inactivity windows (not a total-duration limit on an LLM call). */
 const QUERY_TIMEOUT_MS = 120_000;
 const HIGH_REASONING_QUERY_TIMEOUT_MS = 300_000;
 /** AskUser is human-paced but must never pin a VP turn forever. */
@@ -1168,6 +1168,41 @@ function isHighReasoningEffort(effort) {
   return value === 'high' || value === 'xhigh' || value === 'max' || value === 'ultra';
 }
 
+/**
+ * Per-query provider inactivity window, not a total LLM call deadline.
+ * Hidden deltas only refresh an armed timer; tool/retry waits stay paused.
+ * stop() is irreversible, including on abort, so late events cannot revive it.
+ * @param {{ signal: AbortSignal, timeoutMs: number, onTimeout: Function }} options
+ */
+function createQueryWatchdog({ signal, timeoutMs, onTimeout }) {
+  let timer = null;
+  let stopped = signal.aborted;
+  const pause = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+  const stop = () => {
+    stopped = true;
+    pause();
+    signal.removeEventListener('abort', stop);
+  };
+  const reset = () => {
+    if (stopped || signal.aborted) return;
+    if (timer) {
+      timer.refresh();
+      return;
+    }
+    timer = setTimeout(() => {
+      stop();
+      onTimeout();
+    }, timeoutMs);
+  };
+  // No throttling or trailing heartbeat: the actual last delta owns idle time.
+  const touch = () => { if (timer) reset(); };
+  if (!stopped) signal.addEventListener('abort', stop, { once: true });
+  return { reset, pause, touch, stop };
+}
+
 function queryTimeoutMsForSessionConfig(config = null) {
   return isHighReasoningEffort(config?.modelEffort) ? HIGH_REASONING_QUERY_TIMEOUT_MS : QUERY_TIMEOUT_MS;
 }
@@ -4087,15 +4122,25 @@ function queueStreamTextDelta(hctx, text, envelope) {
  * todos, debug cards, and persistence all share the same boundary.
  *
  * @param {object} event — engine event (text_delta / tool_call / …)
- * @param {{assistantTextParts:string[], toolCallsAccum:Array, toolResultsAccum:Array, thinkingBlocksAccum?:Array, resetQueryTimer:Function, pauseQueryTimer?:Function, markEngineTerminal?:Function, sessionId?:string, vpId?:string, turnId?:string}} hctx
+ * @param {{assistantTextParts:string[], toolCallsAccum:Array, toolResultsAccum:Array, thinkingBlocksAccum?:Array, resetQueryTimer:Function, pauseQueryTimer?:Function, touchQueryTimer?:Function, stopQueryTimer?:Function, markEngineTerminal?:Function, sessionId?:string, vpId?:string, turnId?:string}} hctx
  */
 export function __testHandleEngineEvent(event, hctx) {
   return handleEngineEvent(event, hctx);
 }
 
 function handleEngineEvent(event, hctx) {
+  // Hidden progress has no wire/history/status projection and must not flush
+  // pending visible text or resume a paused/terminal provider watchdog.
+  if (event.type === 'provider_activity') {
+    hctx.touchQueryTimer?.();
+    return;
+  }
+  if ((event.type === 'text_delta' || event.type === 'thinking_delta')
+      && (typeof event.text !== 'string' || event.text.length === 0)) return;
   const terminalTurnEnd = event.type === 'turn_end' && event.terminal === true;
   const managesQueryTimer = terminalTurnEnd
+    || event.type === 'aborted'
+    || event.type === 'usage'
     || event.type === 'tool_start'
     || event.type === 'tool_end'
     || event.type === 'async_task_wait_start'
@@ -4300,6 +4345,7 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'aborted':
+      (hctx.stopQueryTimer || hctx.pauseQueryTimer)?.();
       if (typeof hctx.markEngineTerminal === 'function') {
         hctx.markEngineTerminal('aborted', { reason: event.reason || 'external' });
       }
@@ -4309,8 +4355,8 @@ function handleEngineEvent(event, hctx) {
       // Most engine turn_end events are internal loop boundaries. Only the
       // explicit terminal event precedes post-turn persistence/maintenance;
       // stop the user-query silence watchdog before that best-effort work.
-      if (event.terminal && typeof hctx.pauseQueryTimer === 'function') {
-        hctx.pauseQueryTimer();
+      if (event.terminal) {
+        (hctx.stopQueryTimer || hctx.pauseQueryTimer)?.();
       }
       // A normal tool_use stop means "run tools, then call the adapter again",
       // so it must NOT end the VP's visible turn. An aborted turn is terminal
@@ -5282,7 +5328,7 @@ function startSessionLoadInBackground({ sessionId = null, sessionMeta = null, pe
 /**
  * Wrap {@link runVpTurn} with a second-stage abort escalation.
  *
- * The in-turn watchdog is activity based: every engine event resets its
+ * The in-turn watchdog is activity based: content progress resets its
  * silence timer, and only a genuinely silent turn calls `vpAbort.abort()`.
  * This wrapper must therefore start its grace period from that abort signal,
  * not from turn enqueue. A fixed enqueue deadline incorrectly terminates
@@ -5507,21 +5553,16 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
   };
 
   try {
-    let queryTimer = null;
     const queryTimeoutMs = queryTimeoutMsForSession(sessionId);
-    const pauseQueryTimer = () => {
-      if (queryTimer) clearTimeout(queryTimer);
-      queryTimer = null;
-    };
-    const resetQueryTimer = () => {
-      pauseQueryTimer();
-      queryTimer = setTimeout(() => {
-        if (!vpAbort.signal.aborted) {
-          console.error(`[Yeaft] query timeout after ${queryTimeoutMs / 1000}s of silence — aborting VP ${vpId}`);
-          try { vpAbort.abort(); } catch { /* best-effort */ }
-        }
-      }, queryTimeoutMs);
-    };
+    const watchdog = createQueryWatchdog({
+      signal: vpAbort.signal,
+      timeoutMs: queryTimeoutMs,
+      onTimeout: () => {
+        console.error(`[Yeaft] query timeout after ${queryTimeoutMs / 1000}s of silence — aborting VP ${vpId}`);
+        try { vpAbort.abort(); } catch { /* best-effort */ }
+      },
+    });
+    const { reset: resetQueryTimer, pause: pauseQueryTimer } = watchdog;
     resetQueryTimer();
 
     // Emit turn_start so frontend can create the message block.
@@ -5605,6 +5646,8 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         thinkingBlocksAccum,
         resetQueryTimer,
         pauseQueryTimer,
+        touchQueryTimer: watchdog.touch,
+        stopQueryTimer: watchdog.stop,
         sessionId,
         vpId,
         turnId,
@@ -5656,10 +5699,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
           // Human think time is not engine silence. Pause the query watchdog,
           // but keep a separate bounded AskUser lifetime so an abandoned card
           // cannot pin the VP forever.
-          if (queryTimer) {
-            clearTimeout(queryTimer);
-            queryTimer = null;
-          }
+          pauseQueryTimer();
           const pending = {
             resolve,
             reject,
@@ -5706,7 +5746,6 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
             messageType: event?.type || null,
           });
         }
-        resetQueryTimer();
         handleEngineEvent(event, handlerCtx);
       }
       if (perfTraceId) {
@@ -5781,7 +5820,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         emitVpTurnEnd('end_turn');
       }
     } finally {
-      if (queryTimer) clearTimeout(queryTimer);
+      watchdog.stop();
     }
   } catch (err) {
     if (escalationState?.escalated) return;
@@ -8068,6 +8107,7 @@ export const __testHooks = {
   projectRuntimeCount() {
     return projectRuntimes.size;
   },
+  createQueryWatchdog,
   queryTimeoutMsForSessionConfig,
   queryTimeoutMsForSession,
   seedQueuedVpTurn({ sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test' } = {}) {

package/yeaft/work-center/runner.js

@@ -1394,6 +1394,9 @@ export class WorkItemRunner {
           stoppedByEngineEvent = true;
           break;
         }
+        // Provider activity is liveness-only; keep control handling above, but
+        // never turn it into durable Run progress or a UI broadcast.
+        if (event?.type === 'provider_activity') continue;
         if (event?.type === 'loop') {
           loopCount += 1;
           this.store.appendRunLoop?.(run.id, ownerBootId, run.leaseEpoch, {