@yeaft/webchat-agent 0.1.1104 → 0.1.1107

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

@@ -34,10 +34,10 @@ function thinkingV1Enabled() {
   return process.env.YEAFT_THINKING_V1 === '1';
 }
 
-function applyAnthropicThinking(body, model, effort) {
-  const cap = getThinkingCapability(model);
+function applyAnthropicThinking(body, model, effort, effortContext = {}) {
+  const cap = getThinkingCapability(model, effortContext);
   if (!cap.supportsThinking) return;
-  if (!getModelEffortOptions(model).includes(effort)) return;
+  if (!getModelEffortOptions(model, effortContext).includes(effort)) return;
 
   if (cap.thinkingProtocol === 'anthropic-adaptive') {
     body.thinking = { type: 'adaptive' };
@@ -59,6 +59,34 @@ function applyAnthropicThinking(body, model, effort) {
 const DEFAULT_BASE_URL = 'https://api.anthropic.com';
 const API_VERSION = '2023-06-01';
 
+function hasNonEmptyText(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function translateUserContent(content) {
+  if (hasNonEmptyText(content)) return content;
+
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (!part || typeof part !== 'object') {
+        if (hasNonEmptyText(part)) parts.push({ type: 'text', text: String(part) });
+        continue;
+      }
+      if (part.type === 'text') {
+        if (hasNonEmptyText(part.text)) parts.push(part);
+        continue;
+      }
+      // Non-text blocks (image/document/tool_result-like compatible payloads)
+      // are meaningful even without a text field. Preserve them verbatim.
+      parts.push(part);
+    }
+    return parts.length > 0 ? parts : null;
+  }
+
+  return null;
+}
+
 /**
  * AnthropicAdapter — Talks to Anthropic Messages API.
  */
@@ -116,7 +144,8 @@ export class AnthropicAdapter extends LLMAdapter {
     for (const msg of messages) {
       if (msg.role === 'system') continue; // system goes separately
       if (msg.role === 'user') {
-        result.push({ role: 'user', content: msg.content });
+        const content = translateUserContent(msg.content);
+        if (content) result.push({ role: 'user', content });
       } else if (msg.role === 'assistant') {
         const content = [];
         // task-327d: Anthropic requires thinking blocks to appear BEFORE
@@ -137,7 +166,7 @@ export class AnthropicAdapter extends LLMAdapter {
             }
           }
         }
-        if (msg.content) {
+        if (hasNonEmptyText(msg.content)) {
           content.push({ type: 'text', text: msg.content });
         }
         if (msg.toolCalls) {
@@ -150,7 +179,7 @@ export class AnthropicAdapter extends LLMAdapter {
             });
           }
         }
-        result.push({ role: 'assistant', content });
+        if (content.length > 0) result.push({ role: 'assistant', content });
       } else if (msg.role === 'tool') {
         // Anthropic requires all tool_results from the same turn in a single
         // user message. Merge consecutive tool messages into one.
@@ -207,10 +236,10 @@ export class AnthropicAdapter extends LLMAdapter {
   }
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'xhigh'|'max', effortSource?: 'user'|'auto', signal?: AbortSignal }} params
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'xhigh'|'max', effortSource?: 'user'|'auto', effortContext?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, signal, onRawExchange }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, effortContext, signal, onRawExchange }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -226,7 +255,7 @@ export class AnthropicAdapter extends LLMAdapter {
     // models use budget_tokens. Unsupported combinations silently drop effort.
     const normEffort = normalizeEffort(effort);
     if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
-      applyAnthropicThinking(body, model, normEffort);
+      applyAnthropicThinking(body, model, normEffort, effortContext);
     }
 
     const translatedTools = this.#translateTools(tools);
@@ -249,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) {
@@ -291,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) {
@@ -310,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 {
@@ -410,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),
@@ -423,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 {
@@ -443,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
@@ -473,7 +514,7 @@ export class AnthropicAdapter extends LLMAdapter {
    * models silently drop the param. max_tokens auto-widens to budget+1024
    * when needed.
    */
-  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, signal }) {
+  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, effortContext, signal }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -486,7 +527,7 @@ export class AnthropicAdapter extends LLMAdapter {
     // task-327c: mirror stream()'s thinking injection for side queries.
     const normEffort = normalizeEffort(effort);
     if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
-      applyAnthropicThinking(body, model, normEffort);
+      applyAnthropicThinking(body, model, normEffort, effortContext);
     }
 
     let response;
@@ -498,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/llm/router.js

@@ -552,9 +552,16 @@ export class AdapterRouter extends LLMAdapter {
    */
   async *stream(params) {
     const resolved = await this.#resolveAdapter(params.model);
+    const effortContext = {
+      protocol: resolved.protocol,
+      supportsEffort: resolved.entry?.supportsEffort,
+      effortOptions: resolved.entry?.effortOptions,
+      thinkingProtocol: resolved.entry?.thinkingProtocol,
+      maxBudgetTokens: resolved.entry?.maxBudgetTokens,
+    };
     const filtered = filterEffortForModel({ ...params, model: resolved.modelId }, resolved);
     const sanitized = sanitizeMessagesForWire(filtered);
-    yield* resolved.adapter.stream({ ...sanitized, model: resolved.modelId });
+    yield* resolved.adapter.stream({ ...sanitized, model: resolved.modelId, effortContext });
   }
 
   /**
@@ -565,9 +572,16 @@ export class AdapterRouter extends LLMAdapter {
    */
   async call(params) {
     const resolved = await this.#resolveAdapter(params.model);
+    const effortContext = {
+      protocol: resolved.protocol,
+      supportsEffort: resolved.entry?.supportsEffort,
+      effortOptions: resolved.entry?.effortOptions,
+      thinkingProtocol: resolved.entry?.thinkingProtocol,
+      maxBudgetTokens: resolved.entry?.maxBudgetTokens,
+    };
     const filtered = filterEffortForModel({ ...params, model: resolved.modelId }, resolved);
     const sanitized = sanitizeMessagesForWire(filtered);
-    return resolved.adapter.call({ ...sanitized, model: resolved.modelId });
+    return resolved.adapter.call({ ...sanitized, model: resolved.modelId, effortContext });
   }
 
   /**

package/yeaft/models.js

@@ -537,8 +537,13 @@ export function thinkingBudgetForEffort(model, effort) {
  */
 export function getThinkingCapability(model, context = {}) {
   const info = MODEL_REGISTRY.get(model);
+  const modelId = parseModelRef(model).modelId;
   const overrideOptions = normalizeEffortOptions(context.effortOptions);
-  const overrideProtocol = context.thinkingProtocol || (context.protocol === 'anthropic' ? 'anthropic' : context.protocol === 'openai-responses' ? 'openai-reasoning' : null);
+  const overrideProtocol = context.thinkingProtocol || (
+    context.protocol === 'anthropic'
+      ? (/^deepseek/i.test(modelId) ? 'anthropic-adaptive' : 'anthropic')
+      : context.protocol === 'openai-responses' ? 'openai-reasoning' : null
+  );
   if (context.supportsEffort === true || overrideOptions) {
     return {
       supportsThinking: true,
@@ -560,7 +565,15 @@ export function getThinkingCapability(model, context = {}) {
     };
   }
   if (context.protocol === 'anthropic' && inferred?.thinkingProtocol === 'openai-reasoning') {
-    inferred = null;
+    if (/^deepseek/i.test(modelId)) {
+      inferred = {
+        ...inferred,
+        thinkingProtocol: 'anthropic-adaptive',
+        effortOptions: ANTHROPIC_ADAPTIVE_EFFORT_OPTIONS,
+      };
+    } else {
+      inferred = null;
+    }
   }
   if ((!info || !info.supportsThinking) && !inferred) {
     return {

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);
   }