@yeaft/webchat-agent 0.1.823 → 0.1.825

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.823",
+  "version": "0.1.825",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/debug-trace.js

@@ -125,6 +125,38 @@ function truncate(str, max) {
   return str.slice(0, max) + '... [truncated]';
 }
 
+function truncatedJsonSentinel(originalBytes) {
+  return {
+    __truncated: true,
+    originalBytes,
+    maxBytes: MAX_LOOP_PAYLOAD,
+  };
+}
+
+function truncateJsonValue(value) {
+  if (value == null) return value;
+  if (typeof value === 'string') return truncate(value, MAX_LOOP_PAYLOAD);
+  try {
+    const s = JSON.stringify(value);
+    if (s.length <= MAX_LOOP_PAYLOAD) return value;
+    return truncatedJsonSentinel(s.length);
+  } catch {
+    return null;
+  }
+}
+
+function boundDreamEventData(eventType, eventData) {
+  if (eventType !== 'dream_loop' || !eventData || typeof eventData !== 'object') return eventData;
+  return {
+    ...eventData,
+    systemPrompt: truncateJsonValue(eventData.systemPrompt),
+    messages: truncateJsonValue(eventData.messages),
+    response: truncateJsonValue(eventData.response),
+    rawRequest: truncateJsonValue(eventData.rawRequest),
+    rawResponse: truncateJsonValue(eventData.rawResponse),
+  };
+}
+
 /**
  * DebugTrace — SQLite-backed debug trace.
  */
@@ -229,11 +261,7 @@ export class DebugTrace {
       try {
         const s = JSON.stringify(v);
         if (s.length <= MAX_LOOP_PAYLOAD) return s;
-        return JSON.stringify({
-          __truncated: true,
-          originalBytes: s.length,
-          maxBytes: MAX_LOOP_PAYLOAD,
-        });
+        return JSON.stringify(truncatedJsonSentinel(s.length));
       } catch { return null; }
     };
     // For raw request/response, accept either a pre-stringified blob
@@ -304,7 +332,8 @@ export class DebugTrace {
   logEvent({ traceId, eventType, eventData = null }) {
     const id = randomUUID();
     const now = Date.now();
-    const data = eventData != null ? JSON.stringify(eventData) : null;
+    const boundedData = boundDreamEventData(eventType, eventData);
+    const data = boundedData != null ? JSON.stringify(boundedData) : null;
     this.#prepare('insertEvent', `
       INSERT INTO trace_events (id, trace_id, event_type, event_data, created_at)
       VALUES (?, ?, ?, ?, ?)
@@ -312,6 +341,19 @@ export class DebugTrace {
     return id;
   }
 
+  /**
+   * Compatibility helper used by older engine/dream call sites.
+   * @param {string} eventType
+   * @param {unknown} eventData
+   * @returns {string}
+   */
+  event(eventType, eventData = null) {
+    const traceId = (eventData && typeof eventData === 'object' && (eventData.turnId || eventData.runId))
+      ? String(eventData.turnId || eventData.runId)
+      : String(eventType || 'event');
+    return this.logEvent({ traceId, eventType, eventData });
+  }
+
   // ─── Read API ────────────────────────────────────────────────
 
   /**
@@ -477,7 +519,9 @@ export class DebugTrace {
     const dreamEvents = [];
     if (dreamLim > 0) {
       const eventRows = this.#db.prepare(`
-        SELECT * FROM trace_events WHERE event_type = 'dream_progress' ORDER BY created_at DESC LIMIT ?
+        SELECT * FROM trace_events
+        WHERE event_type IN ('dream_progress', 'dream_loop', 'dream_turn_open', 'dream_turn_close', 'dream_run')
+        ORDER BY created_at DESC, rowid DESC LIMIT ?
       `).all(Math.max(dreamLim * 5, dreamLim));
       for (const er of eventRows) {
         const data = parseJsonSafe(er.event_data) || {};
@@ -488,7 +532,12 @@ export class DebugTrace {
           const isThisGroup = evtGroupId === groupId || target === `group/${groupId}`;
           if (!isBroadcast && !isThisGroup) continue;
         }
-        dreamEvents.push({ type: 'dream_progress', ...data, at: er.created_at, ts: data.ts || er.created_at });
+        dreamEvents.push({
+          type: data.type || (er.event_type === 'dream_progress' ? 'dream_progress' : er.event_type),
+          ...data,
+          at: er.created_at,
+          ts: data.ts || data.at || er.created_at,
+        });
         if (dreamEvents.length >= dreamLim) break;
       }
       dreamEvents.reverse();
@@ -638,6 +687,7 @@ export class NullTrace {
   endTurn() {}
   logTool() { return 'null'; }
   logEvent() { return 'null'; }
+  event() { return 'null'; }
   queryByMessage() { return { turns: [], tools: [], events: [] }; }
   queryByTrace() { return { turns: [], tools: [], events: [] }; }
   queryRecent() { return []; }

package/unify/dream-v2/session-wiring.js

@@ -128,29 +128,128 @@ function makeLlm(session) {
     });
 
     // Emit complete loop event (request + response) to the debug panel.
+    const latencyMs = Date.now() - startedMs;
+    const usage = normalizeDreamUsage(r?.usage || {});
+    if (!session._dreamMetrics) session._dreamMetrics = createDreamMetrics({ turnId });
+    session._dreamMetrics.llmCallCount += 1;
+    session._dreamMetrics.inputTokens += usage.inputTokens;
+    session._dreamMetrics.outputTokens += usage.outputTokens;
+    session._dreamMetrics.totalTokens += usage.totalTokens;
+    session._dreamMetrics.byPass[pass] = session._dreamMetrics.byPass[pass] || createDreamPassMetrics();
+    session._dreamMetrics.byPass[pass].llmCallCount += 1;
+    session._dreamMetrics.byPass[pass].inputTokens += usage.inputTokens;
+    session._dreamMetrics.byPass[pass].outputTokens += usage.outputTokens;
+    session._dreamMetrics.byPass[pass].totalTokens += usage.totalTokens;
+    session._dreamMetrics.byPass[pass].durationMs += latencyMs;
+    const loopEvent = stampDreamScope(session, {
+      type: 'loop',
+      turnId,
+      loopNumber,
+      pass,
+      model: model || 'unknown',
+      systemPrompt: effectiveSystem,
+      messages: [{ role: 'user', content: prompt }],
+      response: typeof r?.text === 'string' ? r.text : '',
+      toolCalls: [],
+      usage,
+      latencyMs,
+      ttfbMs: null,
+      stopReason: 'end_turn',
+      rawRequest: null,
+      rawResponse: null,
+    });
+    persistDreamTrace(session, 'dream_loop', loopEvent);
     if (typeof session._dreamProgressSink === 'function') {
-      session._dreamProgressSink({
-        type: 'loop',
-        turnId,
-        loopNumber,
-        model: model || 'unknown',
-        systemPrompt: effectiveSystem,
-        messages: [{ role: 'user', content: prompt }],
-        response: typeof r?.text === 'string' ? r.text : '',
-        toolCalls: [],
-        usage: r?.usage || { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        latencyMs: Date.now() - startedMs,
-        ttfbMs: null,
-        stopReason: 'end_turn',
-        rawRequest: null,
-        rawResponse: null,
-      });
+      session._dreamProgressSink(loopEvent);
     }
 
     return (r && r.text) ? r.text : '';
   };
 }
 
+
+function stampDreamScope(session, evt) {
+  if (!evt || typeof evt !== 'object') return evt;
+  if (evt.groupId || !session?._dreamActiveGroupId) return evt;
+  return { ...evt, groupId: session._dreamActiveGroupId };
+}
+
+function finiteNumber(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+function normalizeDreamUsage(usage = {}) {
+  const inputTokens = finiteNumber(
+    usage.inputTokens ?? usage.input_tokens ?? usage.promptTokens ?? usage.prompt_tokens,
+  );
+  const outputTokens = finiteNumber(
+    usage.outputTokens ?? usage.output_tokens ?? usage.completionTokens ?? usage.completion_tokens,
+  );
+  const explicitTotal = finiteNumber(usage.totalTokens ?? usage.total_tokens);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: explicitTotal || inputTokens + outputTokens,
+  };
+}
+
+function createDreamPassMetrics() {
+  return { llmCallCount: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, durationMs: 0 };
+}
+
+function createDreamMetrics({ turnId, startedAt = Date.now() } = {}) {
+  return {
+    turnId: turnId || 'dream',
+    startedAt,
+    durationMs: 0,
+    llmCallCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    byPass: {},
+  };
+}
+
+function finalizeDreamMetrics(metrics, durationMs) {
+  const m = metrics || createDreamMetrics();
+  return {
+    turnId: m.turnId || 'dream',
+    startedAt: m.startedAt || null,
+    durationMs: finiteNumber(durationMs),
+    llmCallCount: finiteNumber(m.llmCallCount),
+    inputTokens: finiteNumber(m.inputTokens),
+    outputTokens: finiteNumber(m.outputTokens),
+    totalTokens: finiteNumber(m.totalTokens),
+    passBreakdown: Object.fromEntries(Object.entries(m.byPass || {}).map(([pass, rec]) => [pass, {
+      llmCallCount: finiteNumber(rec.llmCallCount),
+      inputTokens: finiteNumber(rec.inputTokens),
+      outputTokens: finiteNumber(rec.outputTokens),
+      totalTokens: finiteNumber(rec.totalTokens),
+      durationMs: finiteNumber(rec.durationMs),
+    }])),
+  };
+}
+
+function summarizeDreamResult(result = {}) {
+  return {
+    groups: Array.isArray(result.groups) ? result.groups.length : 0,
+    targets: Array.isArray(result.targets) ? result.targets.length : 0,
+    error: result.error || null,
+    skipped: !!result.skipped,
+    skippedReason: result.skippedReason || null,
+  };
+}
+
+function persistDreamTrace(session, eventType, eventData) {
+  try {
+    if (typeof session?.trace?.event === 'function') session.trace.event(eventType, eventData);
+    else if (typeof session?.trace?.logEvent === 'function') {
+      session.trace.logEvent({ traceId: String(eventData?.turnId || eventData?.runId || eventType), eventType, eventData });
+    }
+  } catch { /* trace must never break dream */ }
+}
+
 /**
  * Create a v2 dream scheduler bound to a session and wire its progress
  * events into the engine's sub-agent event sink (web-bridge translates
@@ -162,20 +261,21 @@ function makeLlm(session) {
 export function createV2DreamScheduler(session) {
   const onProgress = (evt) => {
     try {
+      const stampedEvt = stampDreamScope(session, evt);
       const sink = session.engine?.subAgentEventSink || null;
       // We don't have a sub-agent id; emit on the engine's standard
       // event channel instead. session.engine exposes setSubAgentEventSink
       // for nested events; for top-level dream, we route through trace.
       if (typeof session.trace?.event === 'function') {
-        session.trace.event('dream_progress', evt);
+        session.trace.event('dream_progress', stampedEvt);
       }
       if (typeof session._dreamProgressSink === 'function') {
-        session._dreamProgressSink(evt);
+        session._dreamProgressSink(stampedEvt);
       }
       // Best-effort console for debug builds.
       if (session.config?.debug) {
         // eslint-disable-next-line no-console
-        console.log('[dream-v2]', evt);
+        console.log('[dream-v2]', stampedEvt);
       }
     } catch { /* never let progress reporting kill the run */ }
   };
@@ -190,16 +290,19 @@ export function createV2DreamScheduler(session) {
     const startedAt = Date.now();
     session._dreamTurnId = turnId;
     session._dreamLoopCounter = 0;
+    session._dreamMetrics = createDreamMetrics({ turnId, startedAt });
 
+    const turnOpen = stampDreamScope(session, {
+      type: 'turn_open',
+      turnId,
+      userPrompt: '[dream] automatic memory consolidation',
+      vpId: null,
+      groupId: null,
+      at: startedAt,
+    });
+    persistDreamTrace(session, 'dream_turn_open', turnOpen);
     if (typeof session._dreamProgressSink === 'function') {
-      session._dreamProgressSink({
-        type: 'turn_open',
-        turnId,
-        userPrompt: '[dream] automatic memory consolidation',
-        vpId: null,
-        groupId: null,
-        at: startedAt,
-      });
+      session._dreamProgressSink(turnOpen);
     }
 
     return runDream({
@@ -208,14 +311,35 @@ export function createV2DreamScheduler(session) {
       scopeFilter: Array.isArray(opts.scopeFilter) ? opts.scopeFilter : undefined,
     }).then((result) => {
       // Bug 2: emit turn_close when the dream pass completes.
+      result.trigger = opts.manual ? 'manual' : 'auto';
+      if (session._dreamActiveGroupId && !result.groupId) result.groupId = session._dreamActiveGroupId;
+      const metrics = finalizeDreamMetrics(session._dreamMetrics, Date.now() - startedAt);
+      result.metrics = metrics;
+      result.durationMs = metrics.durationMs;
+      result.llmCallCount = metrics.llmCallCount;
+      result.inputTokens = metrics.inputTokens;
+      result.outputTokens = metrics.outputTokens;
+      result.totalTokens = metrics.totalTokens;
+      result.passBreakdown = metrics.passBreakdown;
+      const turnClose = stampDreamScope(session, {
+        type: 'turn_close',
+        turnId,
+        totalMs: metrics.durationMs,
+        totalTokens: metrics.totalTokens,
+        loopCount: metrics.llmCallCount,
+        metrics,
+      });
+      persistDreamTrace(session, 'dream_turn_close', turnClose);
+      persistDreamTrace(session, 'dream_run', stampDreamScope(session, {
+        type: 'dream_run',
+        turnId,
+        phase: 'result',
+        status: result?.error ? 'error' : 'done',
+        metrics,
+        resultSummary: summarizeDreamResult(result),
+      }));
       if (typeof session._dreamProgressSink === 'function') {
-        session._dreamProgressSink({
-          type: 'turn_close',
-          turnId,
-          totalMs: Date.now() - startedAt,
-          totalTokens: 0,
-          loopCount: session._dreamLoopCounter || 0,
-        });
+        session._dreamProgressSink(turnClose);
       }
       return result;
     });

package/unify/web-bridge.js

@@ -3222,6 +3222,13 @@ export function normalizeDreamResult(result) {
 
   return {
     success,
+    durationMs: Number.isFinite(Number(result?.durationMs)) ? Number(result.durationMs) : 0,
+    llmCallCount: Number.isFinite(Number(result?.llmCallCount)) ? Number(result.llmCallCount) : 0,
+    inputTokens: Number.isFinite(Number(result?.inputTokens)) ? Number(result.inputTokens) : 0,
+    outputTokens: Number.isFinite(Number(result?.outputTokens)) ? Number(result.outputTokens) : 0,
+    totalTokens: Number.isFinite(Number(result?.totalTokens)) ? Number(result.totalTokens) : 0,
+    metrics: result?.metrics || null,
+    passBreakdown: result?.passBreakdown || result?.metrics?.passBreakdown || null,
     skipped,
     skippedReason,
     groupsProcessed,
@@ -3260,13 +3267,15 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   // group or different) overlapping the same inflight pass used to set
   // the module-level groupId slot, race the sink wrapping, and let the
   // second `finally` restore the original sink while the first run was
-  // still emitting events. We now refuse any second scoped trigger
-  // while ANY scoped pass is inflight — the scheduler already
-  // short-circuits the underlying run for same-group, and a different
-  // group's filter would have been silently dropped anyway (see
-  // dream-v2/schedule.js inflight reuse), so the user-facing semantics
-  // are unchanged ("you already asked").
-  if (groupId && inflightScopedDreamGroups.size > 0) {
+  // still emitting events. We now refuse scoped triggers while ANY dream
+  // pass is already running: a scoped manual click during an unscoped
+  // auto run must not install `_dreamActiveGroupId` or wrap the sink,
+  // otherwise auto-run events can be persisted under the clicked group.
+  // The scheduler also short-circuits the underlying run for same-group,
+  // and a different group's filter would have been silently dropped
+  // anyway (see dream-v2/schedule.js inflight reuse), so the user-facing
+  // semantics are unchanged ("you already asked").
+  if (groupId && (inflightScopedDreamGroups.size > 0 || session.dreamScheduler.isRunning)) {
     const skippedResult = {
       skipped: true,
       skippedReason: 'already-running',
@@ -3289,6 +3298,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   // OTHER groupIds chain (last-installed wins) but each restoration
   // unwinds back to its predecessor.
   const originalSink = session?._dreamProgressSink;
+  if (groupId) session._dreamActiveGroupId = groupId;
   if (groupId && typeof originalSink === 'function') {
     inflightScopedDreamGroups.add(groupId);
     session._dreamProgressSink = (evt) => {
@@ -3345,6 +3355,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     });
   } finally {
     // Restore the original sink and release the per-group inflight lock.
+    if (groupId && session?._dreamActiveGroupId === groupId) session._dreamActiveGroupId = null;
     if (groupId && typeof originalSink === 'function') {
       session._dreamProgressSink = originalSink;
       inflightScopedDreamGroups.delete(groupId);