micro-models-agent 0.63.3 → 1.1.0

package/dist/llm/openai-compat.js

@@ -1,7 +1,26 @@
 import { TokenCounter } from "./token-counter";
 import { t } from "../i18n/index";
+import { readMmaVersion } from "../core/version";
 import { createRateLimiter } from "../modules/security/rate-limiter";
+import { LlmError } from "./llm-errors";
+import { backoffDelay } from "../utils/retry";
+import { StreamState } from "./stream-state";
+import { parseCacheUsage } from "./cache-usage";
 const REQUEST_TIMEOUT_MS = 120000;
+/** Max wait (ms) for a self-inflicted rate-limit slot before giving up. */
+const MAX_RATE_WAIT_MS = 30_000;
+/**
+ * Client identity header. OpenCode Go asks clients to identify themselves with
+ * their own user agent (not a generic SDK/HTTP-library name) so requests route
+ * to coding-agent traffic. `readMmaVersion()` is memoized — every provider
+ * construction would otherwise re-read package.json.
+ */
+let cachedUserAgent = null;
+function defaultUserAgent() {
+    if (cachedUserAgent === null)
+        cachedUserAgent = `micro-models-agent/${readMmaVersion()}`;
+    return cachedUserAgent;
+}
 function buildRequestBody(opts) {
     const body = {
         model: opts.model,
@@ -10,9 +29,29 @@ function buildRequestBody(opts) {
     };
     if (opts.maxTokens !== undefined)
         body.max_tokens = opts.maxTokens;
-    if (opts.reasoningEffort) {
-        body.reasoning_effort = opts.reasoningEffort;
+    if (opts.cachePrompt)
+        body.cache_prompt = true;
+    if (opts.promptCacheKey)
+        body.prompt_cache_key = opts.promptCacheKey;
+    if (opts.sessionId)
+        body.session_id = opts.sessionId;
+    if (opts.stream && opts.streamUsage)
+        body.stream_options = { include_usage: true };
+    // Apply reasoning effort via the provider's strategy
+    const strategy = opts.reasoningStrategy ?? "openai-effort";
+    const level = opts.reasoningEffort;
+    if (strategy === "openai-effort" && level && level !== "default") {
+        body.reasoning_effort = level;
+    }
+    else if (strategy === "template-kwarg") {
+        body.chat_template_kwargs = { enable_thinking: level !== "none" };
+    }
+    else if (strategy === "prompt-tag" && level && level !== "default") {
+        // Send reasoning_effort in body (models that respect it via API) AND
+        // add /no_think tag to message (models that only respect prompt signals).
+        body.reasoning_effort = level;
     }
+    // "none" = unsupported, skip
     if (opts.tools && opts.tools.length > 0) {
         body.tools = opts.tools.map((t) => ({
             type: "function",
@@ -33,10 +72,19 @@ export class OpenAICompatProvider {
     tokenCounter;
     retryConfig;
     rateLimiter;
+    debug;
+    getSessionId;
+    userAgent;
+    cache;
+    cacheReport;
     constructor(config) {
         this.config = config;
         this.model = config.model;
         this.contextWindow = config.contextWindow ?? 32768;
+        this.cache = config.cache;
+        // Без capability всё равно читаем OpenAI-совместимые поля: это не меняет
+        // запрос и работает для локальных/кастомных серверов.
+        this.cacheReport = config.cache?.report ?? "openai";
         this.tokenCounter = new TokenCounter();
         this.retryConfig = config.retry ?? {
             maxRetries: 3,
@@ -46,31 +94,80 @@ export class OpenAICompatProvider {
             noDataTimeoutMs: 180000,
         };
         this.rateLimiter = createRateLimiter(config.rateLimits);
+        this.getSessionId = config.getSessionId;
+        this.userAgent = config.userAgent ?? defaultUserAgent();
+        this.debug = config.logger ? config.logger.debug.bind(config.logger) : null;
     }
     async *chat(messages, tools, signal, options) {
-        // Check rate limit before making request
+        // Check rate limit before making request. A self-inflicted limit should
+        // wait for a slot (bounded) instead of aborting a healthy turn; only if
+        // no slot frees within the window do we surface a recoverable error the
+        // agent loop can feed back (rather than dying).
         if (!this.rateLimiter.canMakeRequest()) {
-            throw new Error(`Rate limit exceeded: ${this.rateLimiter.getConfig().maxRequestsPerMinute} requests per minute`);
+            const waitMs = Math.min(this.rateLimiter.msUntilRequest(), MAX_RATE_WAIT_MS);
+            if (waitMs > 0) {
+                await this.sleep(waitMs, signal);
+            }
+            if (!this.rateLimiter.canMakeRequest()) {
+                throw new LlmError(`Rate limit exceeded: ${this.rateLimiter.getConfig().maxRequestsPerMinute} requests per minute`, { recoverable: true });
+            }
         }
         // Record this request
         this.rateLimiter.recordRequest();
-        const streamResult = this.doStream(messages, tools, signal, options);
+        // Apply prompt-tag strategy: append /no_think to last user message (outgoing copy only)
+        let effectiveMessages = messages;
+        if (options?.reasoningStrategy === "prompt-tag" && options?.reasoningEffort === "none") {
+            effectiveMessages = this.applyPromptTag(messages, "/no_think");
+        }
+        const streamResult = this.doStream(effectiveMessages, tools, signal, options);
         let hasToolCall = false;
         let hasText = false;
+        let hasReasoning = false;
         for await (const chunk of streamResult) {
             if (chunk.type === "tool_call")
                 hasToolCall = true;
             if (chunk.type === "text")
                 hasText = true;
+            if (chunk.type === "reasoning")
+                hasReasoning = true;
             yield chunk;
         }
+        // A stream that ended with reasoning but no text/tool_call means the model
+        // THOUGHT but never produced an answer (observed: qwen3.5-9b in LM Studio
+        // emits reasoning_content then stops). The streamed reasoning was already
+        // delivered; fetch the missing answer via non-streaming. The fallback's
+        // own reasoning chunk is dropped so thinking is not shown twice — no text
+        // was emitted, so there is no duplicate-answer risk.
         if (!hasToolCall && !hasText) {
-            const fallback = await this.doNonStreaming(messages, tools, signal, options);
+            this.debug?.("LLM streaming produced no text/tool_call — falling back to non-streaming");
+            const fallback = await this.doNonStreaming(effectiveMessages, tools, signal, options);
+            this.debug?.("LLM non-streaming fallback result", { chunks: fallback.length });
             for (const chunk of fallback) {
+                if (hasReasoning && chunk.type === "reasoning")
+                    continue;
                 yield chunk;
             }
         }
     }
+    /** Append a tag to the last user message (outgoing copy, never stored in context). */
+    applyPromptTag(messages, tag) {
+        const copy = [...messages];
+        for (let i = copy.length - 1; i >= 0; i--) {
+            if (copy[i].role === "user") {
+                const msg = { ...copy[i] };
+                if (typeof msg.content === "string") {
+                    msg.content = msg.content + "\n" + tag;
+                }
+                else {
+                    // Array of parts — append a text part
+                    msg.content = [...msg.content, { type: "text", text: tag }];
+                }
+                copy[i] = msg;
+                break;
+            }
+        }
+        return copy;
+    }
     async *doStream(messages, tools, signal, options) {
         const { baseDelay, maxDelay, maxStreamRetries, noDataTimeoutMs } = this.retryConfig;
         const streamRetries = maxStreamRetries ?? 2;
@@ -90,16 +187,15 @@ export class OpenAICompatProvider {
                     return;
             }
             catch (err) {
-                if (err?.name === "AbortError" || err?.llmTerminal || signal?.aborted)
+                if (err?.name === "AbortError" || (err instanceof LlmError && err.terminal) || signal?.aborted)
                     throw err;
                 // Content was already delivered — a re-stream would duplicate chunks.
                 if (emitted || attempt >= streamRetries)
                     throw err;
                 // Connection dropped before any content → retry the whole request.
             }
-            const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
-            const jitter = Math.random() * baseDelay * 0.1;
-            await this.sleep(delay + jitter, signal);
+            // Экспоненциальный backoff с джиттером (общий хелпер из src/utils).
+            await this.sleep(backoffDelay(attempt, baseDelay, maxDelay, 0.1), signal);
         }
     }
     async *streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs) {
@@ -111,6 +207,18 @@ export class OpenAICompatProvider {
             stream: true,
             maxTokens,
             reasoningEffort: options?.reasoningEffort,
+            reasoningStrategy: options?.reasoningStrategy,
+            ...this.cacheHints(),
+        });
+        this.debug?.("LLM stream request", {
+            baseUrl: this.config.baseUrl,
+            model: this.model,
+            stream: true,
+            maxTokens,
+            toolsCount: tools?.length ?? 0,
+            reasoningEffort: options?.reasoningEffort,
+            reasoningStrategy: options?.reasoningStrategy,
+            messagesCount: messages.length,
         });
         const { headers, abortSignal, cleanup, isTimeout, flagTimeout, controller } = this.buildRequestSetup(signal);
         let response;
@@ -128,20 +236,26 @@ export class OpenAICompatProvider {
             if (err?.name === "AbortError")
                 throw err;
             const wrapped = err instanceof Error ? err : new Error(String(err));
-            wrapped.llmTerminal = true;
-            throw wrapped;
+            if (wrapped instanceof LlmError) {
+                wrapped.markTerminal();
+                throw wrapped;
+            }
+            throw new LlmError(wrapped.message).markTerminal();
         }
         if (!response.ok) {
             cleanup();
             const errorText = await response.text();
-            const err = new Error(t("error.llm_api", {
+            throw new LlmError(t("error.llm_api", {
                 status: response.status,
                 statusText: response.statusText,
                 errorText,
-            }));
-            err.llmTerminal = true;
-            throw err;
+            }), { terminal: true });
         }
+        const contentType = response.headers?.get?.("content-type") ?? "";
+        this.debug?.("LLM stream response headers", {
+            status: response.status,
+            contentType,
+        });
         const reader = response.body?.getReader();
         if (!reader) {
             cleanup();
@@ -150,14 +264,8 @@ export class OpenAICompatProvider {
         const decoder = new TextDecoder();
         let buffer = "";
         const toolCallAccs = new Map();
-        // A tool_call started accumulating — the server committed to a response.
-        // If the stream stalls after this, the provider most likely buffers SSE
-        // instead of streaming argument deltas (seen with LM Studio).
-        let sawToolCallStart = false;
-        let usage;
-        let sawDone = false;
-        let lastFinishReason;
-        let sawText = false;
+        // Единый контейнер состояния стрима (вместо 9 разрозненных флагов).
+        const st = new StreamState();
         const readIdle = () => new Promise((resolve, reject) => {
             const idleTimer = setTimeout(() => {
                 flagTimeout();
@@ -166,13 +274,13 @@ export class OpenAICompatProvider {
             reader.read().then((result) => {
                 clearTimeout(idleTimer);
                 if (isTimeout())
-                    reject(new Error(t(sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                    reject(new Error(t(st.sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
                 else
                     resolve(result);
             }, (err) => {
                 clearTimeout(idleTimer);
                 if (isTimeout())
-                    reject(new Error(t(sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                    reject(new Error(t(st.sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
                 else
                     reject(err);
             });
@@ -187,116 +295,180 @@ export class OpenAICompatProvider {
                 buffer = lines.pop() || "";
                 for (const line of lines) {
                     const trimmed = line.trim();
-                    if (!trimmed || !trimmed.startsWith("data: "))
-                        continue;
-                    const data = trimmed.slice(6);
-                    if (data === "[DONE]") {
-                        sawDone = true;
+                    if (!trimmed)
                         continue;
+                    let data;
+                    if (trimmed.startsWith("data: ")) {
+                        data = trimmed.slice(6);
+                        if (data === "[DONE]") {
+                            st.sawDone = true;
+                            continue;
+                        }
+                    }
+                    else {
+                        // Not SSE-framed — Ollama (and some other backends) may stream
+                        // NDJSON or send mid-stream errors as bare JSON. Try to parse the
+                        // raw line; unparseable noise (SSE comments, keep-alives) is
+                        // counted and skipped.
+                        st.nonDataLines++;
+                        if (st.nonDataSamples.length < 5)
+                            st.nonDataSamples.push(trimmed.slice(0, 200));
+                        data = trimmed;
                     }
                     try {
                         const parsed = JSON.parse(data);
+                        st.parsedChunks++;
                         const choice = parsed.choices?.[0];
                         if (!choice) {
                             // Usage comes in the last chunk with empty choices
                             if (parsed.usage) {
-                                usage = {
+                                st.usage = {
                                     promptTokens: parsed.usage.prompt_tokens ?? 0,
                                     completionTokens: parsed.usage.completion_tokens ?? 0,
                                     totalTokens: parsed.usage.total_tokens ?? 0,
+                                    cache: parseCacheUsage(parsed.usage, this.cacheReport),
                                 };
+                                this.debug?.("LLM stream usage", { ...st.usage });
                             }
-                            continue;
-                        }
-                        const delta = choice.delta || {};
-                        const finishReason = choice.finish_reason;
-                        if (finishReason)
-                            lastFinishReason = finishReason;
-                        if (delta.reasoning_content) {
-                            onEmit();
-                            yield { type: "reasoning", content: delta.reasoning_content };
+                            else if (parsed.error) {
+                                // Mid-stream provider error (Ollama sends {"error": "..."} as
+                                // bare JSON once generation already started). Surface it —
+                                // swallowing it makes the response look silently empty.
+                                // Thrown OUTSIDE the JSON-parse try/catch below.
+                                st.midStreamError = String(parsed.error);
+                            }
+                            // NOTE: no `continue` here — it would skip the midStreamError
+                            // throw below (which lives outside this try/catch).
                         }
-                        if (delta.tool_calls) {
-                            sawToolCallStart = true;
-                            for (const tc of delta.tool_calls) {
-                                const idx = tc.index ?? 0;
-                                if (!toolCallAccs.has(idx)) {
-                                    toolCallAccs.set(idx, { id: "", name: "", arguments: "" });
-                                }
-                                const acc = toolCallAccs.get(idx);
-                                if (tc.id)
-                                    acc.id = tc.id;
-                                if (tc.function?.name)
-                                    acc.name = tc.function.name;
-                                if (tc.function?.arguments) {
-                                    acc.arguments += tc.function.arguments;
+                        else {
+                            if (st.parsedChunks <= 3 || st.parsedChunks % 50 === 0) {
+                                const d = choice.delta ?? {};
+                                this.debug?.("LLM stream chunk", {
+                                    n: st.parsedChunks,
+                                    finishReason: choice.finish_reason ?? null,
+                                    deltaKeys: Object.keys(d),
+                                });
+                            }
+                            const delta = choice.delta || {};
+                            const finishReason = choice.finish_reason;
+                            if (finishReason)
+                                st.lastFinishReason = finishReason;
+                            // `reasoning` is the Ollama alias for OpenAI's `reasoning_content`.
+                            const reasoningDelta = delta.reasoning_content ?? delta.reasoning;
+                            if (reasoningDelta) {
+                                onEmit();
+                                yield { type: "reasoning", content: reasoningDelta };
+                            }
+                            if (delta.tool_calls) {
+                                st.sawToolCallStart = true;
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? 0;
+                                    if (!toolCallAccs.has(idx)) {
+                                        toolCallAccs.set(idx, { id: "", name: "", arguments: "" });
+                                    }
+                                    const acc = toolCallAccs.get(idx);
+                                    if (tc.id)
+                                        acc.id = tc.id;
+                                    if (tc.function?.name)
+                                        acc.name = tc.function.name;
+                                    if (tc.function?.arguments) {
+                                        acc.arguments += tc.function.arguments;
+                                    }
                                 }
                             }
-                        }
-                        if (delta.content) {
-                            onEmit();
-                            sawText = true;
-                            yield { type: "text", content: delta.content };
-                        }
-                        if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
-                            for (const [, acc] of toolCallAccs) {
-                                if (acc.name) {
-                                    onEmit();
-                                    yield {
-                                        type: "tool_call",
-                                        toolCall: {
-                                            id: acc.id,
-                                            name: acc.name,
-                                            arguments: acc.arguments || "{}",
-                                        },
-                                    };
+                            if (delta.content) {
+                                onEmit();
+                                st.sawText = true;
+                                yield { type: "text", content: delta.content };
+                            }
+                            if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
+                                for (const [, acc] of toolCallAccs) {
+                                    if (acc.name) {
+                                        onEmit();
+                                        yield {
+                                            type: "tool_call",
+                                            toolCall: {
+                                                id: acc.id,
+                                                name: acc.name,
+                                                arguments: acc.arguments || "{}",
+                                            },
+                                        };
+                                    }
                                 }
+                                toolCallAccs.clear();
                             }
-                            toolCallAccs.clear();
                         }
                     }
                     catch {
                         // Skip malformed JSON lines
                     }
+                    if (st.midStreamError) {
+                        throw new Error(t("error.llm_provider_stream_error", { error: st.midStreamError.slice(0, 300) }));
+                    }
                 }
             }
-            if (usage) {
+            if (st.usage) {
                 onEmit();
-                yield { type: "done", usage };
+                yield { type: "done", usage: st.usage };
             }
             // finish_reason "length": the completion hit the token limit. An
             // unfinished tool_call would otherwise be silently swallowed (tool_calls
             // are only yielded on finish_reason "tool_calls") and surface as an
             // empty response → blind hallucination retries. Surface the real cause.
-            if (lastFinishReason === "length") {
-                const truncatedToolCall = sawToolCallStart && toolCallAccs.size > 0;
-                if (truncatedToolCall || !sawText) {
-                    const err = new Error(t(truncatedToolCall ? "error.llm_truncated_toolcall" : "error.llm_truncated", {
+            if (st.lastFinishReason === "length") {
+                const truncatedToolCall = st.sawToolCallStart && toolCallAccs.size > 0;
+                if (truncatedToolCall || !st.sawText) {
+                    // Провайдер в порядке — модель просто превысила completion-лимит.
+                    // terminal: стрим не ретраим (он завершился корректно); recoverable:
+                    // агентный цикл вернёт причину модели, чтобы она адаптировалась
+                    // (разбила вывод) вместо смерти сессии.
+                    throw new LlmError(t(truncatedToolCall ? "error.llm_truncated_toolcall" : "error.llm_truncated", {
                         tokens: maxTokens,
-                    }));
-                    err.llmTerminal = true;
-                    // The provider is fine — the model just overran the completion
-                    // limit. The agent loop feeds this back so the model can adapt
-                    // (split the output) instead of the session dying.
-                    err.recoverableLlm = true;
-                    throw err;
+                    }), { terminal: true, recoverable: true });
                 }
+                // Текст уже устримлен и не завершён — не глушим ответ, но и не
+                // принимаем обрезок молча: отдаём видимое предупреждение.
+                yield {
+                    type: "warning",
+                    content: t("error.llm_output_truncated", { tokens: maxTokens }),
+                };
             }
         }
         finally {
             cleanup();
             reader.releaseLock();
+            this.debug?.("LLM stream finished", st.snapshot());
         }
-        return sawDone;
+        return st.sawDone;
+    }
+    /**
+     * Вычисляет запросные подсказки кеша из возможностей провайдера и текущего
+     * session id. Без capability возвращает «ничего», сохраняя прежнее тело.
+     */
+    cacheHints() {
+        const sessionId = this.getSessionId?.();
+        return {
+            cachePrompt: this.cache?.requestCachePrompt === true,
+            promptCacheKey: this.cache?.requestPromptCacheKey ? sessionId : undefined,
+            sessionId: this.cache?.requestSessionId ? sessionId : undefined,
+            streamUsage: this.cache?.requestStreamUsage === true,
+        };
     }
     /** Shared request setup: auth headers + timeout/abort controller wiring. */
     buildRequestSetup(signal) {
         const headers = {
             "Content-Type": "application/json",
+            "User-Agent": this.userAgent,
         };
         if (this.config.apiKey && this.config.apiKey !== "not-needed") {
             headers["Authorization"] = `Bearer ${this.config.apiKey}`;
         }
+        const sessionId = this.getSessionId?.();
+        // Когда capability задана — шлём заголовок только тем, кому он нужен
+        // (Zen/Go). Без capability сохраняем легаси-поведение.
+        const sendSessionHeader = this.cache ? this.cache.sessionHeader : true;
+        if (sessionId && sendSessionHeader)
+            headers["x-opencode-session"] = sessionId;
         const controller = new AbortController();
         let timedOut = false;
         const timeoutId = setTimeout(() => {
@@ -328,13 +500,16 @@ export class OpenAICompatProvider {
         };
     }
     async doNonStreaming(messages, tools, signal, options) {
+        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
         const body = buildRequestBody({
             model: this.model,
             messages,
             tools,
             stream: false,
-            maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
+            maxTokens,
             reasoningEffort: options?.reasoningEffort,
+            reasoningStrategy: options?.reasoningStrategy,
+            ...this.cacheHints(),
         });
         const { headers, abortSignal, cleanup, isTimeout } = this.buildRequestSetup(signal);
         try {
@@ -353,14 +528,19 @@ export class OpenAICompatProvider {
                 }));
             }
             const data = await response.json();
+            // Some backends (e.g. Ollama) return HTTP 200 with {"error": "..."}.
+            if (data.error && !data.choices) {
+                throw new Error(t("error.llm_provider_stream_error", { error: String(data.error).slice(0, 300) }));
+            }
             const choice = data.choices?.[0];
             if (!choice) {
                 return [];
             }
             const msg = choice.message || {};
             const chunks = [];
-            if (msg.reasoning_content) {
-                chunks.push({ type: "reasoning", content: msg.reasoning_content });
+            const reasoning = msg.reasoning_content ?? msg.reasoning;
+            if (reasoning) {
+                chunks.push({ type: "reasoning", content: reasoning });
             }
             if (msg.content) {
                 chunks.push({ type: "text", content: msg.content });
@@ -377,6 +557,14 @@ export class OpenAICompatProvider {
                     });
                 }
             }
+            // Completed text but hit the cap: surface a visible warning instead of
+            // silently accepting a cut-off answer (see the streaming path).
+            if (choice.finish_reason === "length" && msg.content && !msg.tool_calls) {
+                chunks.push({
+                    type: "warning",
+                    content: t("error.llm_output_truncated", { tokens: maxTokens }),
+                });
+            }
             // Append usage from API response
             if (data.usage) {
                 chunks.push({
@@ -385,6 +573,7 @@ export class OpenAICompatProvider {
                         promptTokens: data.usage.prompt_tokens ?? 0,
                         completionTokens: data.usage.completion_tokens ?? 0,
                         totalTokens: data.usage.total_tokens ?? 0,
+                        cache: parseCacheUsage(data.usage, this.cacheReport),
                     },
                 });
             }
@@ -408,6 +597,7 @@ export class OpenAICompatProvider {
             const url = `${this.config.baseUrl.replace(/\/+$/, "")}/models`;
             const headers = {
                 "Content-Type": "application/json",
+                "User-Agent": this.userAgent,
             };
             if (this.config.apiKey && this.config.apiKey !== "not-needed") {
                 headers["Authorization"] = `Bearer ${this.config.apiKey}`;
@@ -436,6 +626,7 @@ export class OpenAICompatProvider {
         let lastStatus = 0;
         let lastRetryAfter = 0;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            lastRetryAfter = 0;
             try {
                 const response = await fetch(url, init);
                 if (!this.isRetryable(response.status))
@@ -456,22 +647,17 @@ export class OpenAICompatProvider {
                 // otherwise exponential backoff. 429s from free tiers need a real wait.
                 const delay = lastRetryAfter > 0
                     ? Math.min(lastRetryAfter, maxDelay)
-                    : Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
-                const jitter = Math.random() * baseDelay * 0.1;
-                await this.sleep(delay + jitter, init.signal ?? undefined);
+                    : backoffDelay(attempt, baseDelay, maxDelay, 0.1);
+                await this.sleep(delay, init.signal ?? undefined);
             }
         }
         if (lastStatus === 429) {
-            const e429 = new Error(t("error.llm_429", {
+            throw new LlmError(t("error.llm_429", {
                 model: this.model,
                 baseUrl: this.config.baseUrl,
-            }));
-            e429.llmStatus = lastStatus;
-            throw e429;
+            }), { llmStatus: lastStatus });
         }
-        const eRetry = new Error(t("error.llm_retries"));
-        eRetry.llmStatus = lastStatus;
-        throw eRetry;
+        throw new LlmError(t("error.llm_retries"), { llmStatus: lastStatus });
     }
     isRetryable(status) {
         return status === 429 || status >= 500;