@yeaft/webchat-agent 1.0.17 → 1.0.19

package/yeaft/engine.js

@@ -2294,18 +2294,139 @@ export class Engine {
               stopReason = event.stopReason;
               yield event;
               break;
-            case 'error':
-              yield event;
-              break;
+            case 'error': {
+              const adapterError = event.error instanceof Error
+                ? event.error
+                : new Error(String(event.error?.message || event.error || 'LLM stream error'));
+              adapterError.retryable = Boolean(event.retryable);
+              if (event.retryable) {
+                if (adapterError instanceof LLMRateLimitError || adapterError instanceof LLMServerError) {
+                  throw adapterError;
+                }
+                throw new LLMServerError(adapterError.message, adapterError.statusCode ?? 0);
+              }
+              if (adapterError instanceof LLMRateLimitError || adapterError instanceof LLMServerError) {
+                const nonRetryableError = new Error(adapterError.message);
+                nonRetryableError.name = adapterError.name || 'LLMStreamError';
+                nonRetryableError.code = adapterError.code;
+                nonRetryableError.statusCode = adapterError.statusCode;
+                nonRetryableError.retryable = false;
+                throw nonRetryableError;
+              }
+              throw adapterError;
+            }
           }
         }
         // Stream completed without throwing — reset the retry counter so
-        // the next turn starts with a clean budget. Note: this includes
-        // stream() that emitted an in-band `error` event (server didn't
-        // throw), since those are policy-specific and not transport-level.
+        // the next turn starts with a clean budget. In-band adapter errors
+        // are converted to throws above so they share the real error path.
         consecutiveRetryableErrors = 0;
       } catch (err) {
         const latencyMs = Date.now() - startTime;
+
+        const endAttemptTrace = (attemptStopReason) => {
+          this.#trace.endTurn(turnId, {
+            model: currentModel,
+            inputTokens: totalUsage.inputTokens,
+            outputTokens: totalUsage.outputTokens,
+            cacheReadTokens: totalUsage.cacheReadTokens,
+            cacheWriteTokens: totalUsage.cacheWriteTokens,
+            stopReason: attemptStopReason,
+            latencyMs,
+            responseText,
+            systemPrompt,
+            messages: conversationMessages.map(mapDebugMessage),
+            toolCalls: toolCalls.map(tc => ({ id: tc.id, name: tc.name, input: tc.input })),
+            usage: {
+              inputTokens: totalUsage.inputTokens || 0,
+              outputTokens: totalUsage.outputTokens || 0,
+              cacheReadTokens: totalUsage.cacheReadTokens || 0,
+              cacheWriteTokens: totalUsage.cacheWriteTokens || 0,
+              totalInputTokens: (totalUsage.inputTokens || 0) + (totalUsage.cacheInputDeltaTokens || 0),
+              totalTokens: (totalUsage.inputTokens || 0) + (totalUsage.cacheInputDeltaTokens || 0) + (totalUsage.outputTokens || 0),
+            },
+            ttfbMs,
+            rawRequest,
+            rawResponse,
+          });
+        };
+
+        // Abort/retry/fallback are not final assistant responses. Handle them
+        // before writing debug loop rows; otherwise transient DeepSeek stream
+        // cuts or user stops show up as bogus `Error: Request aborted` replies.
+        const earlyIsAbort = err instanceof LLMAbortError
+          || err?.name === 'AbortError'
+          || err?.name === 'LLMAbortError'
+          || (signal?.aborted && /abort/i.test(err?.message || ''));
+        if (earlyIsAbort || signal?.aborted) {
+          endAttemptTrace('aborted');
+          yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
+          yield { type: 'turn_end', turnNumber, stopReason: 'aborted', threadId };
+          break;
+        }
+
+        if (err instanceof LLMContextError && this.#conversationStore) {
+          const retryConsolidated = await this.#maybeConsolidate();
+          if (retryConsolidated && retryConsolidated.archivedCount > 0) {
+            endAttemptTrace('context_overflow_retry');
+            yield { type: 'consolidate', archivedCount: retryConsolidated.archivedCount, extractedCount: retryConsolidated.extractedCount };
+            yield { type: 'turn_end', turnNumber, stopReason: 'context_overflow_retry', threadId };
+            continue;
+          }
+        }
+
+        const earlyIsRateLimit = err instanceof LLMRateLimitError;
+        const earlyIsTransient = err instanceof LLMServerError;
+        if (earlyIsRateLimit || earlyIsTransient) {
+          if (consecutiveRetryableErrors < retryPolicy.maxRetries) {
+            consecutiveRetryableErrors += 1;
+            let delayMs;
+            let reason;
+            if (earlyIsRateLimit && Number.isFinite(err.retryAfterMs) && err.retryAfterMs > 0) {
+              delayMs = Math.min(retryPolicy.maxDelayMs, err.retryAfterMs);
+              reason = 'rate_limit_retry_after';
+            } else if (earlyIsRateLimit) {
+              delayMs = computeBackoffDelay(retryPolicy, consecutiveRetryableErrors);
+              reason = 'rate_limit_backoff';
+            } else {
+              delayMs = computeBackoffDelay(retryPolicy, consecutiveRetryableErrors - 1);
+              reason = err instanceof LLMStreamIdleTimeoutError
+                ? 'stream_idle_timeout'
+                : 'transient_backoff';
+            }
+            endAttemptTrace('llm_retry');
+            yield {
+              type: 'llm_retry',
+              attempt: consecutiveRetryableErrors,
+              maxRetries: retryPolicy.maxRetries,
+              delayMs,
+              reason,
+              errorName: err.name,
+              statusCode: err.statusCode ?? null,
+              message: String(err.message || '').slice(0, 300),
+            };
+            const slept = await sleepWithAbort(delayMs, signal);
+            if (!slept || signal?.aborted) {
+              yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
+              yield { type: 'turn_end', turnNumber, stopReason: 'aborted', threadId };
+              break;
+            }
+            yield { type: 'turn_end', turnNumber, stopReason: 'llm_retry', threadId };
+            continue;
+          }
+        }
+
+        const earlyFallbackModel = this.#config.fallbackModel;
+        if (earlyFallbackModel && earlyFallbackModel !== currentModel
+          && (earlyIsRateLimit || earlyIsTransient)) {
+          endAttemptTrace('fallback_retry');
+          yield { type: 'fallback', from: currentModel, to: earlyFallbackModel, reason: err.message };
+          currentModel = earlyFallbackModel;
+          consecutiveRetryableErrors = 0;
+          yield { type: 'turn_end', turnNumber, stopReason: 'fallback_retry', threadId };
+          continue;
+        }
+
         this.#trace.endTurn(turnId, {
           model: currentModel,
           inputTokens: totalUsage.inputTokens,
@@ -2367,96 +2488,6 @@ export class Engine {
           rawResponse,
         };
 
-        // ─── task-325a: abort short-circuit ────────────────
-        // If the adapter threw LLMAbortError, or the signal fired during
-        // stream() (fetch throws AbortError / DOMException), we converge
-        // the state machine on the 'aborted' terminal state — no retry,
-        // no fallback, no persistence. One `aborted` event + one
-        // `turn_end` with stopReason='aborted' and we're done.
-        const isAbort = err instanceof LLMAbortError
-          || err?.name === 'AbortError'
-          || err?.name === 'LLMAbortError'
-          || (signal?.aborted && /abort/i.test(err?.message || ''));
-        if (isAbort || signal?.aborted) {
-          yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
-          yield { type: 'turn_end', turnNumber, stopReason: 'aborted', threadId };
-          break;
-        }
-
-        // ─── LLMContextError → force compact → retry ──────
-        if (err instanceof LLMContextError && this.#conversationStore) {
-          const consolidated = await this.#maybeConsolidate();
-          if (consolidated && consolidated.archivedCount > 0) {
-            yield { type: 'consolidate', archivedCount: consolidated.archivedCount, extractedCount: consolidated.extractedCount };
-            yield { type: 'turn_end', turnNumber, stopReason: 'context_overflow_retry', threadId };
-            continue; // retry with fewer messages
-          }
-        }
-
-        // ─── Rate-limit / transient / stream-idle retry ───
-        // Honour server-supplied Retry-After for 429/529; fall back to
-        // exponential backoff for 5xx, transport failures, and stream-idle
-        // timeouts wrapped as LLMServerError. Counts against
-        // retryPolicy.maxRetries; on exhaustion we fall through to the
-        // fallback-model path (and ultimately the error event) without
-        // further waiting.
-        const isRateLimit = err instanceof LLMRateLimitError;
-        const isTransient = err instanceof LLMServerError;
-        if (isRateLimit || isTransient) {
-          if (consecutiveRetryableErrors < retryPolicy.maxRetries) {
-            consecutiveRetryableErrors += 1;
-            let delayMs;
-            let reason;
-            if (isRateLimit && Number.isFinite(err.retryAfterMs) && err.retryAfterMs > 0) {
-              // Server told us exactly when to come back. Respect it,
-              // but still cap to maxDelayMs so a misconfigured upstream
-              // can't make us hang forever on one turn.
-              delayMs = Math.min(retryPolicy.maxDelayMs, err.retryAfterMs);
-              reason = 'rate_limit_retry_after';
-            } else if (isRateLimit) {
-              // No header — use backoff but start one step higher so the
-              // first retry isn't immediate (rate-limit windows are
-              // usually >= 1s wide).
-              delayMs = computeBackoffDelay(retryPolicy, consecutiveRetryableErrors);
-              reason = 'rate_limit_backoff';
-            } else {
-              delayMs = computeBackoffDelay(retryPolicy, consecutiveRetryableErrors - 1);
-              reason = err instanceof LLMStreamIdleTimeoutError
-                ? 'stream_idle_timeout'
-                : 'transient_backoff';
-            }
-            yield {
-              type: 'llm_retry',
-              attempt: consecutiveRetryableErrors,
-              maxRetries: retryPolicy.maxRetries,
-              delayMs,
-              reason,
-              errorName: err.name,
-              statusCode: err.statusCode ?? null,
-              message: String(err.message || '').slice(0, 300),
-            };
-            const slept = await sleepWithAbort(delayMs, signal);
-            if (!slept || signal?.aborted) {
-              yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
-              yield { type: 'turn_end', turnNumber, stopReason: 'aborted', threadId };
-              break;
-            }
-            yield { type: 'turn_end', turnNumber, stopReason: 'llm_retry', threadId };
-            continue; // retry the same turn with the same model
-          }
-          // Exhausted — fall through to fallback-model / error paths.
-        }
-
-        // ─── Fallback model ──────────────────────────────
-        const fallbackModel = this.#config.fallbackModel;
-        if (fallbackModel && fallbackModel !== currentModel &&
-            (err instanceof LLMRateLimitError || err instanceof LLMServerError)) {
-          yield { type: 'fallback', from: currentModel, to: fallbackModel, reason: err.message };
-          currentModel = fallbackModel;
-          consecutiveRetryableErrors = 0; // new model, fresh retry budget
-          yield { type: 'turn_end', turnNumber, stopReason: 'fallback_retry', threadId };
-          continue; // retry with fallback model
-        }
 
         const isRetryableError = err instanceof LLMRateLimitError || err instanceof LLMServerError;
         const errorEvent = {

package/yeaft/llm/adapter.js

@@ -240,12 +240,17 @@ export function retryAfterFromResponse(response) {
  *                          prove from the error shape.
  *
  * @param {unknown} err
- * @param {{ providerLabel?: string }} [opts]
+ * @param {{ providerLabel?: string, signal?: AbortSignal }} [opts]
  * @returns {Error}
  */
 export function classifyFetchError(err, opts = {}) {
   if (!(err instanceof Error)) return err instanceof Object ? err : new Error(String(err));
-  if (err.name === 'AbortError' || err.name === 'LLMAbortError') return new LLMAbortError();
+  if (err.name === 'LLMAbortError' || err instanceof LLMAbortError) return new LLMAbortError();
+  const label = opts.providerLabel ? `${opts.providerLabel}: ` : '';
+  if (err.name === 'AbortError') {
+    if (opts.signal?.aborted) return new LLMAbortError();
+    return new LLMServerError(`${label}stream aborted unexpectedly: ${err.message || 'AbortError'}`, 0);
+  }
   // Anything already classified: keep as-is.
   if (err instanceof LLMRateLimitError
     || err instanceof LLMAuthError
@@ -254,7 +259,6 @@ export function classifyFetchError(err, opts = {}) {
     || err instanceof LLMAbortError) {
     return err;
   }
-  const label = opts.providerLabel ? `${opts.providerLabel}: ` : '';
   const code = err.cause?.code || err.code || null;
   const transientCodes = new Set([
     'ECONNRESET', 'ECONNREFUSED', 'ECONNABORTED', 'ETIMEDOUT',

package/yeaft/llm/anthropic.js

@@ -278,7 +278,7 @@ export class AnthropicAdapter extends LLMAdapter {
         signal,
       });
     } catch (err) {
-      throw classifyFetchError(err, { providerLabel: 'Anthropic' });
+      throw classifyFetchError(err, { providerLabel: 'Anthropic', signal });
     }
 
     if (!response.ok) {
@@ -320,6 +320,8 @@ export class AnthropicAdapter extends LLMAdapter {
     const rawSseBodyChunks = [];
     const responseHeaders = safeHeaders(response);
     const responseStatus = response.status;
+    let sawStop = false;
+    let sawMessageStart = false;
 
     try {
       while (true) {
@@ -339,7 +341,10 @@ export class AnthropicAdapter extends LLMAdapter {
         for (const line of lines) {
           if (!line.startsWith('data: ')) continue;
           const data = line.slice(6).trim();
-          if (data === '[DONE]') continue;
+          if (data === '[DONE]') {
+            sawStop = true;
+            continue;
+          }
 
           let event;
           try {
@@ -439,6 +444,7 @@ export class AnthropicAdapter extends LLMAdapter {
           } else if (type === 'message_delta') {
             const stopReason = event.delta?.stop_reason;
             if (stopReason) {
+              sawStop = true;
               yield {
                 type: 'stop',
                 stopReason: this.#mapStopReason(stopReason),
@@ -452,7 +458,10 @@ export class AnthropicAdapter extends LLMAdapter {
                 outputTokens: event.usage.output_tokens || 0,
               };
             }
+          } else if (type === 'message_stop') {
+            sawStop = true;
           } else if (type === 'message_start') {
+            sawMessageStart = true;
             // Usage from message_start
             if (event.message?.usage) {
               yield {
@@ -472,8 +481,11 @@ export class AnthropicAdapter extends LLMAdapter {
           }
         }
       }
+      if (sawMessageStart && !sawStop) {
+        throw new LLMServerError('Anthropic stream ended before stop event', 0);
+      }
     } catch (err) {
-      throw classifyFetchError(err, { providerLabel: 'Anthropic' });
+      throw classifyFetchError(err, { providerLabel: 'Anthropic', signal });
     } finally {
       reader.releaseLock();
       // Emit raw exchange after stream completes (or errors). Body is the
@@ -527,7 +539,7 @@ export class AnthropicAdapter extends LLMAdapter {
         signal,
       });
     } catch (err) {
-      throw classifyFetchError(err, { providerLabel: 'Anthropic' });
+      throw classifyFetchError(err, { providerLabel: 'Anthropic', signal });
     }
 
     if (!response.ok) {

package/yeaft/llm/openai-responses.js

@@ -17,7 +17,7 @@
  *     - response.function_call_arguments.delta / .done
  *     - response.completed  (contains final response.usage)
  *     - response.incomplete (e.g. max_output_tokens)
- *     - response.error
+ *     - response.failed
  *   - Usage: only in terminal completed/incomplete events
  *
  * Id contract (agreed with PM):
@@ -292,8 +292,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
         signal,
       });
     } catch (err) {
-      if (err.name === 'AbortError') throw new LLMAbortError();
-      throw classifyFetchError(err, { providerLabel: 'OpenAI' });
+      throw classifyFetchError(err, { providerLabel: 'OpenAI', signal });
     }
 
     if (!response.ok) {
@@ -332,6 +331,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     const rawSseBodyChunks = [];
     const responseHeaders = safeHeaders(response);
     const responseStatus = response.status;
+    let sawTerminalEvent = false;
 
     try {
       while (true) {
@@ -353,7 +353,8 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
           const line = rawLine.trimEnd();
           if (!line.startsWith('data:')) continue;
           const data = line.slice(5).trim();
-          if (!data || data === '[DONE]') continue;
+          if (!data) continue;
+          if (data === '[DONE]') continue;
 
           let event;
           try {
@@ -409,6 +410,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
               toolCallAccum.delete(idx);
             }
           } else if (type === 'response.completed' || type === 'response.incomplete') {
+            sawTerminalEvent = true;
             const respObj = event.response || {};
 
             // Fallback: flush any function_call items in the final output that we
@@ -449,17 +451,26 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
               type: 'stop',
               stopReason: this.#mapStopReason(respObj, sawToolCall),
             };
-          } else if (type === 'response.error') {
-            // Let the engine decide; emit error event
-            const message = event.error?.message || event.message || 'response.error';
-            yield { type: 'error', error: new Error(message), retryable: false };
+          } else if (type === 'response.failed' || type === 'response.error') {
+            sawTerminalEvent = true;
+            // Let the engine decide; emit error event. `response.failed` is
+            // the official terminal event; keep `response.error` as a legacy
+            // compatibility alias for older mocks/proxies.
+            const errObj = event.response?.error || event.error || {};
+            const code = errObj.code || event.response?.status || type;
+            const message = errObj.message || event.message || `${type}: ${code}`;
+            const failure = new Error(message);
+            failure.code = code;
+            yield { type: 'error', error: failure, retryable: false };
           }
           // Other semantic events (output_item.done, content_part.added, etc.) are ignored.
         }
       }
+      if (!sawTerminalEvent) {
+        throw new LLMServerError('OpenAI stream ended before terminal event', 0);
+      }
     } catch (err) {
-      if (err?.name === 'AbortError') throw new LLMAbortError();
-      throw classifyFetchError(err, { providerLabel: 'OpenAI' });
+      throw classifyFetchError(err, { providerLabel: 'OpenAI', signal });
     } finally {
       try { reader.releaseLock(); } catch { /* noop */ }
       // Emit raw exchange after stream completes (or errors). Body is the
@@ -523,8 +534,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
         signal,
       });
     } catch (err) {
-      if (err.name === 'AbortError') throw new LLMAbortError();
-      throw classifyFetchError(err, { providerLabel: 'OpenAI' });
+      throw classifyFetchError(err, { providerLabel: 'OpenAI', signal });
     }
 
     if (!response.ok) {

package/yeaft/session.js

@@ -218,26 +218,18 @@ export async function loadSession(options = {}) {
   }
 
   // ─── 3. Create trajectory trace ─────────────────────────
-  // feat-always-on-trajectory-store: the trace is no longer gated on
-  // config.debug. It is a TRAJECTORY STORE: every turn's full
-  // (system_prompt, messages, tool_calls, tool_results, response, usage)
-  // is persisted to ~/.yeaft/debug.db so it can serve two purposes:
-  //   1. Debug panel hydration — user opens "请求日志" and sees prior turns.
-  //   2. SFT / RL training data — scripts can later dump JSONL trajectories.
-  // Cost is negligible (one insert per turn, WAL mode), and the data only
-  // accumulates while the user actually uses the agent. The previous gate
-  // silently discarded every turn unless the user had set debug:true in
-  // ~/.yeaft/config.json, which nobody ever did — wasting the asset.
+  // Always-on request trace for the Debug panel. It is file-backed, not
+  // SQLite-backed: each request writes one bounded JSON file under
+  // `<yeaftDir>/debug/` (session traces are nested under
+  // `<yeaftDir>/sessions/<sessionId>/debug/requests/`). A request file stores one
+  // base request snapshot plus per-loop deltas, so 100-200 loop requests do
+  // not become hundreds of tiny files or repeated cumulative payloads.
   const trace = createTrace({
     enabled: true,
-    dbPath: join(yeaftDir, 'debug.db'),
+    dirPath: yeaftDir,
   });
-  // Bound disk growth: prune trajectories older than 10 days on session load.
-  // Cheap (indexed DELETE + incremental_vacuum), runs once per process start,
-  // not per turn. The always-on store stamps every turn with the *cumulative*
-  // request/response (each long-session row is ~MB), so without a tight TTL the
-  // file balloons — a real deployment hit 5GB in 15 days. 10 days keeps enough
-  // history for debug-panel replay while capping the steady-state footprint.
+  // Hard cap debug history to the most recent 10 requests per Session. Trace
+  // failures are best-effort and must never stop the agent loop.
   try { trace.cleanup?.(10); } catch (err) {
     console.warn('[Yeaft] trace.cleanup failed:', err?.message || err);
   }

package/yeaft/web-bridge.js

@@ -4452,7 +4452,7 @@ export async function handleYeaftFetchToolStats(_msg = {}) {
 }
 
 /**
- * Hydrate the YeaftDebugPanel from the persistent SQLite trace. The
+ * Hydrate the YeaftDebugPanel from the persistent file-backed trace. The
  * panel state (`yeaftDebugLoops` / `yeaftDebugTurnsById`) is otherwise
  * built ONLY from in-flight `loop` / `turn_open` events on the wire,
  * so a panel opened after a turn has finished sees nothing for that
@@ -4460,7 +4460,7 @@ export async function handleYeaftFetchToolStats(_msg = {}) {
  * splices into place.
  *
  * Inputs (all optional):
- *   - `limit`        — legacy recent-detail loop cap; ignored by index-only
+ *   - `limit`        — request cap; bounded by the file trace store
  *   - `indexOnly`    — list request summaries without loop/detail payloads
  *   - `detailTurnId` — fetch full loops/tools for one request
  *   - `sessionId`    — narrow by Session
@@ -4473,7 +4473,7 @@ export async function handleYeaftFetchToolStats(_msg = {}) {
  * snapshot so the panel renders a placeholder instead of spinning.
  */
 export async function handleYeaftFetchDebugHistory(msg = {}) {
-  const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 100;
+  const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 10;
   const dreamLimit = Number.isFinite(msg?.dreamLimit) ? Number(msg.dreamLimit) : 5;
   const sessionId = typeof msg?.sessionId === 'string' && msg.sessionId ? msg.sessionId : null;
   const threadId = typeof msg?.threadId === 'string' && msg.threadId ? msg.threadId : null;