@yeaft/webchat-agent 1.0.637 → 1.0.638

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.637",
+  "version": "1.0.638",
   "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

@@ -3311,7 +3311,9 @@ export class Engine {
               totalUsage.cacheInputDeltaTokens += cacheInputDeltaTokens;
               cumulativeInputTokens += inputTokens + cacheInputDeltaTokens;
               cumulativeOutputTokens += outputTokens;
+              queryProgress.usageObserved(event);
               yield event;
+              yield queryProgress.snapshot(progressIdentity);
               break;
             }
             case 'stop':
@@ -4856,6 +4858,7 @@ export class Engine {
           reused: reusedReadOnlyResult || Boolean(readyParallelExecution?.shared),
           skipped: skipped || needsProjectDocReload,
           policy: duplicateCallPolicy,
+          pendingOutcome: pendingPresentations.has(tc.id),
         });
         const toolDurationMs = readyParallelExecution?.durationMs ?? (Date.now() - toolStartTime);
 
@@ -4994,9 +4997,11 @@ export class Engine {
           if (toolMessage) Object.assign(toolMessage, { content: output, isError: true });
           const toolRecord = this.#persistedToolMessages.get(callId);
           try { this.#conversationStore?.update?.(toolRecord, { content: output, isError: true }); } catch { /* original storage failure */ }
+          queryProgress.finalizeOutcome(callId, true);
           yield { type: 'tool_end', id: callId, name: 'PresentResponse', output, isError: true, threadId: runtimeThreadId };
           continue;
         }
+        queryProgress.finalizeOutcome(callId, false);
         publishedResponses.set(callId, record);
         lastPersistedAssistantTextMessage = record;
         // Metadata is transcript/UI-only. Providers receive the summary as a
@@ -5137,8 +5142,39 @@ export class Engine {
             loopRange: [batchStart, batchEnd],
             toolCount: pairs.length,
           };
+          // Observe only this synchronous query-owned call. Do not tap the
+          // shared accounting adapter (also used by children), or feed these
+          // costs into the main loop's token/dispatch budget. Capture raw usage
+          // before reflection diagnostics normalize away cache-inclusion flags.
+          const reflectionAdapter = typeof this.#adapter.call === 'function' ? {
+            call: async params => {
+              let dispatches = 0;
+              let result;
+              let failure;
+              try {
+                result = await this.#adapter.call({
+                  ...params,
+                  onRequestStart: (...args) => {
+                    dispatches++;
+                    queryProgress.requestStarted();
+                    params.onRequestStart?.(...args);
+                  },
+                });
+                return result;
+              } catch (error) {
+                failure = error;
+                throw error;
+              } finally {
+                // Native adapters report every dispatch, including a refreshed
+                // credential retry. Legacy adapters without the hook count once.
+                if (dispatches === 0) queryProgress.requestStarted();
+                const usage = result?.usage || failure?.usage;
+                if (usage) queryProgress.usageObserved(usage);
+              }
+            },
+          } : this.#adapter;
           const { content, durationMs } = await runT1Reflection({
-            adapter: this.#adapter,
+            adapter: reflectionAdapter,
             model: this.#config.model,
             originalUserMsg: prompt,
             toolPairs: pairs,
@@ -5228,6 +5264,7 @@ export class Engine {
           // when every T1 attempt has errored.
           lastT1AtLoopCount = completedToolLoops;
         }
+        yield queryProgress.snapshot(progressIdentity);
         }
       }
 

package/yeaft/query-progress.js

@@ -7,6 +7,7 @@ import { createHash } from 'node:crypto';
 import { argsHashOf } from './tool-folding/exec-log.js';
 
 const MAX_ENTRIES = 1024;
+const MAX_TOOL_STATS = 128;
 const WARNING_BATCHES = 4;
 const RECOVERY_BATCHES = 8;
 const REPORT_BATCHES = 12;
@@ -61,6 +62,10 @@ export class QueryProgress {
   #results = new Map();
   #mutations = new Map();
   #failures = new Map();
+  #toolStats = new Map();
+  #pendingOutcomes = new Map();
+  #usageTotals = { inputTokens: 0, outputTokens: 0 };
+  #toolStatsTruncated = false;
   #batch = { evidence: false, repeated: false, failed: false };
   #revision = 0;
   #state = {
@@ -70,6 +75,23 @@ export class QueryProgress {
 
   requestStarted() { this.#state.modelRequests += 1; }
 
+  /** Query-local telemetry only: include synchronous side calls, not billing or loop budgets. */
+  usageObserved(usage) {
+    const reported = key => (!Array.isArray(usage.reportedTokenFields) || usage.reportedTokenFields.includes(key))
+      && Number.isSafeInteger(usage[key]) && usage[key] >= 0;
+    const cacheInputDelta = usage.cacheTokensAreIncludedInInput ? 0
+      : (usage.cacheReadTokens || 0) + (usage.cacheWriteTokens || 0);
+    this.#usageTotals.inputTokens += (usage.inputTokens || 0) + cacheInputDelta;
+    this.#usageTotals.outputTokens += usage.outputTokens || 0;
+    const inputReported = reported('inputTokens') || (!usage.cacheTokensAreIncludedInInput
+      && ['cacheReadTokens', 'cacheWriteTokens'].some(key => reported(key) && usage[key] > 0));
+    for (const [key, known] of [['inputTokens', inputReported], ['outputTokens', reported('outputTokens')]]) {
+      if (!known) continue;
+      if (Number.isSafeInteger(this.#usageTotals[key]) && this.#usageTotals[key] >= 0) this.#state[key] = this.#usageTotals[key];
+      else delete this.#state[key];
+    }
+  }
+
   /** Caller feedback/new owned task results may invalidate prior observations. */
   resetEvidence() {
     this.#results.clear();
@@ -93,11 +115,33 @@ export class QueryProgress {
     return `Blocked unchanged failed call to ${call.name} after ${failure.count} equivalent failures. This call was NOT executed. Use the earlier error to correct the arguments or choose a different supported path. If an earlier operation timed out or disconnected, its side effects may already have happened: verify the target state before retrying. Otherwise report the concrete blocker. Previous failed call: ${failure.callId}.`;
   }
 
-  observe({ call, output, isError = false, readOnly = false, executed = true, reused = false, skipped = false, policy = 'warn' }) {
+  observe({ call, output, isError = false, readOnly = false, executed = true, reused = false, skipped = false, policy = 'warn', pendingOutcome = false }) {
     if (skipped) return;
     if (executed) this.#state.toolExecutions += 1;
     if (reused) this.#state.reusedCalls += 1;
     if (isError) this.#state.failedCalls += 1;
+    // Keep this bounded independently of the evidence caches. Existing rows
+    // remain cumulative even after the catalogue limit or an evidence reset.
+    const name = call.name;
+    const validName = typeof name === 'string' && /^[^\u0000-\u001f\u007f]{1,128}$/.test(name) && name.trim() === name;
+    // Never rewrite names: truncation/normalization can collide with another tool.
+    let stats = this.#toolStats.get(name);
+    if (!stats && validName && this.#toolStats.size < MAX_TOOL_STATS) {
+      stats = { name, executions: 0, failedCalls: 0, blockedCalls: 0 };
+      this.#toolStats.set(name, stats);
+    }
+    if (!stats) this.#toolStatsTruncated = true;
+    if (stats) {
+      if (executed) stats.executions += 1;
+      if (isError) {
+        stats.failedCalls += 1;
+        if (!executed) stats.blockedCalls += 1;
+      }
+    }
+    // Only publications with a delayed durable acknowledgement need correction.
+    // Keep it separate from evidence/failure caches so final telemetry cannot
+    // change duplicate detection, replay protection or loop-guard decisions.
+    if (pendingOutcome) this.#pendingOutcomes.set(call.id, { stats, isError, executed });
     const key = `${call.name}:${argsHashOf(call.input)}`;
     const hash = resultHash(output);
     if (isError) {
@@ -166,8 +210,22 @@ export class QueryProgress {
     }
   }
 
+  /** Final acknowledgement may change status, but must never count another execution. */
+  finalizeOutcome(callId, isError) {
+    const pending = this.#pendingOutcomes.get(callId);
+    if (!pending) return;
+    this.#pendingOutcomes.delete(callId);
+    const delta = Number(isError) - Number(pending.isError);
+    this.#state.failedCalls += delta;
+    if (pending.stats) {
+      pending.stats.failedCalls += delta;
+      if (!pending.executed) pending.stats.blockedCalls += delta;
+    }
+  }
+
   /** Called only AFTER every tool result is paired and persisted. */
   finishBatch() {
+    this.#pendingOutcomes.clear();
     const previousStage = this.#state.stage;
     if (this.#batch.evidence) {
       this.#state.stagnantBatches = 0;
@@ -188,7 +246,9 @@ export class QueryProgress {
   }
 
   snapshot(identity = {}) {
-    return { type: 'query_progress', ...identity, revision: ++this.#revision, ...this.#state };
+    return { type: 'query_progress', ...identity, revision: ++this.#revision, ...this.#state,
+      toolStats: [...this.#toolStats.values()].map(stats => ({ ...stats })),
+      ...(this.#toolStatsTruncated ? { toolStatsTruncated: true } : {}) };
   }
 }
 

package/yeaft/web-bridge.js

@@ -4168,9 +4168,26 @@ function handleEngineEvent(event, hctx) {
     hctx.queryProgressRevision = event.revision;
     const { turnId, threadId, sessionId, vpId, revision, modelRequests, toolExecutions, reusedCalls,
       repeatedCalls, failedCalls, stage, reason, lastEvidenceAt, stagnantBatches } = event;
+    // Optional enhancements must never invalidate a legacy progress frame or
+    // carry arbitrary provider/tool payloads across this projection boundary.
+    const enhanced = {};
+    for (const key of ['inputTokens', 'outputTokens']) {
+      if (Number.isSafeInteger(event[key]) && event[key] >= 0) enhanced[key] = event[key];
+    }
+    if (Array.isArray(event.toolStats) && event.toolStats.length <= 128) {
+      const names = new Set();
+      if (event.toolStats.every(row => row && typeof row.name === 'string'
+          && /^[^\u0000-\u001f\u007f]{1,128}$/.test(row.name) && row.name.trim() === row.name
+          && !names.has(row.name) && names.add(row.name)
+          && ['executions', 'failedCalls', 'blockedCalls'].every(key => Number.isSafeInteger(row[key]) && row[key] >= 0)
+          && row.blockedCalls <= row.failedCalls)) {
+        enhanced.toolStats = event.toolStats.map(({ name, executions, failedCalls, blockedCalls }) => ({ name, executions, failedCalls, blockedCalls }));
+        if (typeof event.toolStatsTruncated === 'boolean') enhanced.toolStatsTruncated = event.toolStatsTruncated;
+      }
+    }
     sendToServer({ type: 'yeaft_output', conversationId: yeaftConversationId, sessionId, vpId, turnId, threadId,
       event: { type: 'query_progress', turnId, threadId, sessionId, vpId, revision, modelRequests,
-        toolExecutions, reusedCalls, repeatedCalls, failedCalls, stage, reason, lastEvidenceAt, stagnantBatches } });
+        toolExecutions, reusedCalls, repeatedCalls, failedCalls, stage, reason, lastEvidenceAt, stagnantBatches, ...enhanced } });
     return;
   }
   if (event.type === 'aborted' || (event.type === 'turn_end' && event.terminal === true)) hctx.queryProgressTerminal = true;