@yeaft/webchat-agent 0.1.1069 → 0.1.1070

package/package.json

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

package/yeaft/config.js

@@ -65,11 +65,14 @@ const DEFAULTS = {
   //   • baseDelayMs / maxDelayMs: exponential backoff bounds used when
   //     the server didn't send a Retry-After header.
   //   • jitterRatio: ± random fraction applied to backoff; 0 disables.
+  //   • streamIdleTimeoutMs: per-SSE-chunk silence budget. 0 disables the
+  //     stalled-stream guard; every received chunk refreshes the budget.
   llmRetry: {
     maxRetries: 3,
     baseDelayMs: 1_000,
     maxDelayMs: 30_000,
     jitterRatio: 0.25,
+    streamIdleTimeoutMs: 110_000,
   },
 };
 
@@ -85,7 +88,7 @@ const DEFAULTS = {
  *
  * @param {object | null | undefined} fileConfig
  * @param {object | null | undefined} overrides
- * @returns {{ maxRetries: number, baseDelayMs: number, maxDelayMs: number, jitterRatio: number }}
+ * @returns {{ maxRetries: number, baseDelayMs: number, maxDelayMs: number, jitterRatio: number, streamIdleTimeoutMs: number }}
  */
 export function normalizeLlmRetry(fileConfig, overrides) {
   const base = DEFAULTS.llmRetry;
@@ -104,6 +107,9 @@ export function normalizeLlmRetry(fileConfig, overrides) {
     if (Number.isFinite(src.jitterRatio) && src.jitterRatio >= 0) {
       out.jitterRatio = Math.min(1, src.jitterRatio);
     }
+    if (Number.isFinite(src.streamIdleTimeoutMs) && src.streamIdleTimeoutMs >= 0) {
+      out.streamIdleTimeoutMs = Math.min(600_000, Math.floor(src.streamIdleTimeoutMs));
+    }
   };
   apply(fileConfig);
   apply(overrides);

package/yeaft/llm/adapter.js

@@ -100,6 +100,15 @@ export class LLMServerError extends Error {
   }
 }
 
+/** Streaming response went idle after the server accepted the request. Retryable. */
+export class LLMStreamIdleTimeoutError extends LLMServerError {
+  constructor(message, idleMs) {
+    super(message, 0);
+    this.name = 'LLMStreamIdleTimeoutError';
+    this.idleMs = idleMs;
+  }
+}
+
 /** Abort error — signal was aborted. */
 export class LLMAbortError extends Error {
   constructor() {
@@ -108,6 +117,57 @@ export class LLMAbortError extends Error {
   }
 }
 
+/**
+ * Read one chunk from a Fetch stream with a silence timeout. This is not a
+ * total request deadline: every received chunk gets a fresh budget. A caller
+ * abort still wins and is classified as LLMAbortError; only an idle stream is
+ * converted into a retryable server error.
+ *
+ * @param {ReadableStreamDefaultReader<Uint8Array>} reader
+ * @param {{ signal?: AbortSignal, idleMs?: number, providerLabel?: string }} [opts]
+ * @returns {Promise<ReadableStreamReadResult<Uint8Array>>}
+ */
+export async function readStreamChunkWithIdleTimeout(reader, opts = {}) {
+  const idleMs = Number.isFinite(opts.idleMs) ? Math.max(0, Math.floor(opts.idleMs)) : 0;
+  if (idleMs <= 0) return reader.read();
+  if (opts.signal?.aborted) throw new LLMAbortError();
+
+  let timer = null;
+  let abortListener = null;
+  let settled = false;
+  const clear = () => {
+    settled = true;
+    if (timer) clearTimeout(timer);
+    if (opts.signal && abortListener) opts.signal.removeEventListener('abort', abortListener);
+  };
+  try {
+    return await Promise.race([
+      reader.read().finally(clear),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          if (settled) return;
+          const err = new LLMStreamIdleTimeoutError(
+            `${opts.providerLabel || 'LLM'} stream idle timeout after ${idleMs}ms`,
+            idleMs,
+          );
+          try { Promise.resolve(reader.cancel(err)).catch(() => {}); } catch { /* best-effort: reject below */ }
+          reject(err);
+        }, idleMs);
+        if (timer && typeof timer.unref === 'function') timer.unref();
+        if (opts.signal) {
+          abortListener = () => {
+            if (settled) return;
+            reject(new LLMAbortError());
+          };
+          opts.signal.addEventListener('abort', abortListener, { once: true });
+        }
+      }),
+    ]);
+  } finally {
+    clear();
+  }
+}
+
 // ─── Retry helpers ─────────────────────────────────────────────
 
 /**
@@ -319,7 +379,7 @@ export async function createLLMAdapter(config) {
   // ─── New path: config.json with providers ─────────────
   if (config.providers && config.providers.length > 0) {
     const { AdapterRouter } = await import('./router.js');
-    return new AdapterRouter({ providers: config.providers });
+    return new AdapterRouter({ providers: config.providers, llmRetry: config.llmRetry });
   }
 
   // ─── Legacy path: single adapter from env vars ────────
@@ -333,6 +393,7 @@ export async function createLLMAdapter(config) {
     return new AnthropicAdapter({
       apiKey: config.apiKey,
       baseUrl: config.baseUrl || undefined, // AnthropicAdapter has its own default
+      streamIdleTimeoutMs: config.llmRetry?.streamIdleTimeoutMs,
     });
   }
 

package/yeaft/llm/anthropic.js

@@ -15,6 +15,7 @@ import {
   LLMContextError,
   LLMServerError,
   LLMAbortError,
+  readStreamChunkWithIdleTimeout,
   redactRawRequest,
   safeHeaders,
 } from './adapter.js';
@@ -65,15 +66,17 @@ export class AnthropicAdapter extends LLMAdapter {
   #apiKey;
   #baseUrl;
   #authHeaderMode;
+  #streamIdleTimeoutMs;
 
   /**
-   * @param {{ apiKey: string, baseUrl?: string, authHeaderMode?: 'x-api-key'|'bearer' }} config
+   * @param {{ apiKey: string, baseUrl?: string, authHeaderMode?: 'x-api-key'|'bearer', streamIdleTimeoutMs?: number }} config
    */
-  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL, authHeaderMode = 'x-api-key' }) {
-    super({ apiKey, baseUrl });
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL, authHeaderMode = 'x-api-key', streamIdleTimeoutMs = 0 }) {
+    super({ apiKey, baseUrl, streamIdleTimeoutMs });
     this.#apiKey = apiKey;
     this.#baseUrl = baseUrl;
     this.#authHeaderMode = authHeaderMode === 'bearer' ? 'bearer' : 'x-api-key';
+    this.#streamIdleTimeoutMs = Number.isFinite(streamIdleTimeoutMs) ? Math.max(0, Math.floor(streamIdleTimeoutMs)) : 0;
   }
 
   #headers() {
@@ -291,7 +294,11 @@ export class AnthropicAdapter extends LLMAdapter {
 
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await readStreamChunkWithIdleTimeout(reader, {
+          signal,
+          idleMs: this.#streamIdleTimeoutMs,
+          providerLabel: 'Anthropic',
+        });
         if (done) break;
 
         const chunkText = decoder.decode(value, { stream: true });
@@ -436,6 +443,8 @@ export class AnthropicAdapter extends LLMAdapter {
           }
         }
       }
+    } catch (err) {
+      throw classifyFetchError(err, { providerLabel: 'Anthropic' });
     } finally {
       reader.releaseLock();
       // Emit raw exchange after stream completes (or errors). Body is the

package/yeaft/llm/openai-responses.js

@@ -34,6 +34,7 @@ import {
   LLMAbortError,
   classifyFetchError,
   retryAfterFromResponse,
+  readStreamChunkWithIdleTimeout,
   redactRawRequest,
   safeHeaders,
 } from './adapter.js';
@@ -67,14 +68,16 @@ function effortForResponses(effort) {
 export class OpenAIResponsesAdapter extends LLMAdapter {
   #apiKey;
   #baseUrl;
+  #streamIdleTimeoutMs;
 
   /**
-   * @param {{ apiKey: string, baseUrl?: string }} config
+   * @param {{ apiKey: string, baseUrl?: string, streamIdleTimeoutMs?: number }} config
    */
-  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL }) {
-    super({ apiKey, baseUrl });
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL, streamIdleTimeoutMs = 0 }) {
+    super({ apiKey, baseUrl, streamIdleTimeoutMs });
     this.#apiKey = apiKey;
     this.#baseUrl = (baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    this.#streamIdleTimeoutMs = Number.isFinite(streamIdleTimeoutMs) ? Math.max(0, Math.floor(streamIdleTimeoutMs)) : 0;
   }
 
   /** Expose baseUrl for testing. */
@@ -332,7 +335,11 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await readStreamChunkWithIdleTimeout(reader, {
+          signal,
+          idleMs: this.#streamIdleTimeoutMs,
+          providerLabel: 'OpenAI',
+        });
         if (done) break;
         const chunkText = decoder.decode(value, { stream: true });
         buffer += chunkText;
@@ -452,7 +459,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
       }
     } catch (err) {
       if (err?.name === 'AbortError') throw new LLMAbortError();
-      throw err;
+      throw classifyFetchError(err, { providerLabel: 'OpenAI' });
     } finally {
       try { reader.releaseLock(); } catch { /* noop */ }
       // Emit raw exchange after stream completes (or errors). Body is the

package/yeaft/llm/router.js

@@ -241,12 +241,18 @@ export class AdapterRouter extends LLMAdapter {
   /** @type {object[]} raw providers array */
   #providers;
 
+  /** @type {number} per-SSE-chunk silence budget; <= 0 disables the guard */
+  #streamIdleTimeoutMs;
+
   /**
-   * @param {{ providers: object[], config?: object }} params
+   * @param {{ providers: object[], llmRetry?: { streamIdleTimeoutMs?: number } }} params
    * @param {object[]} params.providers — Array of { name, baseUrl, apiKey, protocol?, models[] }
    */
-  constructor({ providers }) {
+  constructor({ providers, llmRetry = {} }) {
     super();
+    this.#streamIdleTimeoutMs = Number.isFinite(llmRetry.streamIdleTimeoutMs)
+      ? Math.max(0, Math.floor(llmRetry.streamIdleTimeoutMs))
+      : 0;
     this.#providers = [];
     this.#modelToProvider = new Map();
     this.#adapterCache = new Map();
@@ -466,6 +472,7 @@ export class AdapterRouter extends LLMAdapter {
         apiKey,
         baseUrl: provider.baseUrl,
         authHeaderMode: anthropicAuthHeaderMode,
+        streamIdleTimeoutMs: this.#streamIdleTimeoutMs,
       });
     } else if (protocol === 'openai-responses') {
       // OpenAI Responses API (/v1/responses) — canonical OpenAI-compatible path.
@@ -473,6 +480,7 @@ export class AdapterRouter extends LLMAdapter {
       adapter = new OpenAIResponsesAdapter({
         apiKey,
         baseUrl: provider.baseUrl,
+        streamIdleTimeoutMs: this.#streamIdleTimeoutMs,
       });
     } else {
       throw new Error(