@juspay/neurolink 10.12.9 → 11.1.0

package/dist/providers/ollama/client.js

@@ -1,6 +1,7 @@
 import { modelConfig } from "../../core/modelConfiguration.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 import { InvalidModelError, NetworkError, ProviderError, } from "../../types/index.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { createTimeoutController, parseTimeout, TimeoutError, } from "../../utils/timeout.js";
@@ -81,47 +82,61 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
+            // Custom message (not classifyProviderError's built-in "Request timed
+            // out: ..." default). TimeoutError is handled unconditionally inside
+            // classifyProviderError ahead of any rule table, so this quirk can only
+            // be preserved via a pre-delegate intercept (same pattern used for
+            // groq's TimeoutError override).
             return new NetworkError(`Ollama request timed out. The model may be loading or the request is too large.`, "ollama");
         }
+        // `responseBody` isn't part of ProviderErrorContext, so it's read off the
+        // raw error here (mirrors openAI's `errorType` extraction) for the
+        // missing-model / 404 rules below, which match against message+body
+        // combined exactly as the pre-migration code did.
         const errorRecord = error;
-        const message = typeof errorRecord?.message === "string"
-            ? errorRecord.message
-            : "Unknown error";
-        const cause = errorRecord?.cause ?? {};
-        const code = (errorRecord?.code ?? cause?.code);
-        if (code === "ECONNREFUSED" ||
-            message.includes("ECONNREFUSED") ||
-            message.includes("Failed to fetch") ||
-            message.includes("fetch failed")) {
-            return new NetworkError(`Cannot connect to Ollama at ${redactUrlCredentials(this.config.baseURL)}. ` +
-                `Install Ollama (https://ollama.com), start it with 'ollama serve', then try again.`, "ollama");
-        }
-        // The base client (buildAPIError) attaches statusCode + responseBody to
-        // HTTP failures. Distinguish a genuine missing-model error (give 'ollama
-        // pull' guidance) from a bare endpoint-mismatch 404 (wrong base URL / not
-        // the OpenAI-compatible /v1 surface) so the advice is actionable. Match on
-        // wording, not a bare "404" substring, to avoid misclassifying unrelated
-        // messages that merely contain those digits.
-        const statusCode = typeof errorRecord?.statusCode === "number"
-            ? errorRecord.statusCode
-            : undefined;
         const responseBody = typeof errorRecord?.responseBody === "string"
             ? errorRecord.responseBody
             : "";
-        const haystack = `${message} ${responseBody}`.toLowerCase();
-        const looksLikeMissingModel = haystack.includes("model_not_found") ||
-            (haystack.includes("model") && haystack.includes("not found"));
-        if (looksLikeMissingModel) {
-            return new InvalidModelError(`Ollama model '${this.modelName}' is not available locally. ` +
-                `Pull it first with 'ollama pull ${this.modelName}' (or try '${FALLBACK_OLLAMA_MODEL}'); ` +
-                `list installed models with 'ollama list'.`, "ollama");
-        }
-        if (statusCode === 404 || haystack.includes("status 404")) {
-            return new ProviderError(`Ollama returned HTTP 404 from ${redactUrlCredentials(this.config.baseURL)}. ` +
-                `Verify the base URL serves the OpenAI-compatible /v1 API and that the ` +
-                `model is installed ('ollama list').`, "ollama");
-        }
-        return new ProviderError(`Ollama error: ${message}`, "ollama");
+        const cause = errorRecord?.cause ?? {};
+        const code = (errorRecord?.code ?? cause?.code);
+        const rules = [
+            {
+                match: (ctx) => code === "ECONNREFUSED" ||
+                    /ECONNREFUSED|Failed to fetch|fetch failed/.test(ctx.message),
+                errorClass: NetworkError,
+                message: () => `Cannot connect to Ollama at ${redactUrlCredentials(this.config.baseURL)}. ` +
+                    `Install Ollama (https://ollama.com), start it with 'ollama serve', then try again.`,
+            },
+            // The base client (buildAPIError) attaches statusCode + responseBody to
+            // HTTP failures. Distinguish a genuine missing-model error (give 'ollama
+            // pull' guidance) from a bare endpoint-mismatch 404 (wrong base URL / not
+            // the OpenAI-compatible /v1 surface) so the advice is actionable. Match
+            // on wording, not a bare "404" substring, to avoid misclassifying
+            // unrelated messages that merely contain those digits.
+            {
+                match: (ctx) => {
+                    const haystack = `${ctx.message} ${responseBody}`.toLowerCase();
+                    return (haystack.includes("model_not_found") ||
+                        (haystack.includes("model") && haystack.includes("not found")));
+                },
+                errorClass: InvalidModelError,
+                message: () => `Ollama model '${this.modelName}' is not available locally. ` +
+                    `Pull it first with 'ollama pull ${this.modelName}' (or try '${FALLBACK_OLLAMA_MODEL}'); ` +
+                    `list installed models with 'ollama list'.`,
+            },
+            {
+                match: (ctx) => {
+                    const haystack = `${ctx.message} ${responseBody}`.toLowerCase();
+                    return ctx.statusCode === 404 || haystack.includes("status 404");
+                },
+                errorClass: ProviderError,
+                message: () => `Ollama returned HTTP 404 from ${redactUrlCredentials(this.config.baseURL)}. ` +
+                    `Verify the base URL serves the OpenAI-compatible /v1 API and that the ` +
+                    `model is installed ('ollama list').`,
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "ollama", this.modelName);
     }
     // ===========================================================================
     // Optional hooks — Ollama-specific behaviour
@@ -181,29 +196,7 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
      * back to a model that the first real request can't serve, so report unusable.
      */
     async validateConfiguration() {
-        try {
-            const url = `${stripTrailingSlash(this.config.baseURL)}/models`;
-            const proxyFetch = createProxyFetch();
-            const r = await proxyFetch(url, {
-                headers: {
-                    ...this.getAuthHeaders(),
-                    "Content-Type": "application/json",
-                },
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!r.ok) {
-                return false;
-            }
-            const data = (await r.json().catch(() => null));
-            return Boolean(data?.data?.some((m) => typeof m?.id === "string" && m.id.trim().length > 0));
-        }
-        catch (error) {
-            logger.debug("Ollama validateConfiguration probe failed", {
-                baseURL: redactUrlCredentials(this.config.baseURL),
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
+        return this.probeModelsEndpoint(this.getAuthHeaders());
     }
     getConfiguration() {
         return {

package/dist/providers/ollama/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/ollama/index.js

@@ -1,3 +1,2 @@
 export * from "./client.js";
 export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/openAI/client.js

@@ -1,14 +1,15 @@
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { AIProviderName as AIProviderNameEnum } from "../../constants/enums.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
+import { AuthenticationError, InvalidModelError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { calculateCost } from "../../utils/pricing.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { MAX_IMAGE_BYTES, readBoundedBuffer } from "../../utils/sizeGuard.js";
 import { assertSafeUrl } from "../../utils/ssrfGuard.js";
-import { createTimeoutController, TimeoutError } from "../../utils/timeout.js";
+import { createTimeoutController } from "../../utils/timeout.js";
 import { stripTrailingSlash } from "../openaiChatCompletionsClient.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 const OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
@@ -89,48 +90,44 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
         return getOpenAIModel();
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(error.message, this.providerName);
-        }
+        // `type` isn't part of `ProviderErrorContext` (it's an OpenAI-specific
+        // error-body field), so it's read directly off the raw error here and
+        // captured by the rule closures below.
         const errorObj = error;
-        const message = errorObj?.message && typeof errorObj.message === "string"
-            ? errorObj.message
-            : "Unknown error";
         const errorType = errorObj?.type && typeof errorObj.type === "string"
             ? errorObj.type
             : undefined;
-        const statusCode = typeof errorObj?.status === "number"
-            ? errorObj.status
-            : typeof errorObj?.statusCode === "number"
-                ? errorObj.statusCode
-                : undefined;
-        // Curator P1-1 / Reviewer Finding #4: only the explicit auth markers
-        // map to AuthenticationError. Earlier we treated every
-        // `invalid_request_error` as an auth failure — that's OpenAI's catch-all
-        // for any bad request (unsupported parameter, malformed JSON, etc.) and
-        // mislabelled them as "invalid API key". Use credential-specific
-        // signals only.
-        if (message.includes("API_KEY_INVALID") ||
-            message.includes("Invalid API key") ||
-            message.includes("Incorrect API key") ||
-            message.includes("invalid_api_key") ||
-            errorType === "invalid_api_key" ||
-            statusCode === 401) {
-            return new AuthenticationError(message.includes("Incorrect API key") ||
-                message.includes("Invalid API key")
-                ? message
-                : "Invalid OpenAI API key. Please check your OPENAI_API_KEY environment variable.", this.providerName);
-        }
-        if (message.includes("rate limit") ||
-            errorType === "rate_limit_error" ||
-            statusCode === 429) {
-            return new RateLimitError("OpenAI rate limit exceeded. Please try again later.", this.providerName);
-        }
-        if (message.includes("model_not_found")) {
-            return new InvalidModelError(`Model not found: ${this.modelName}`, this.providerName);
-        }
-        // Generic provider error
-        return new ProviderError(`OpenAI error: ${message}`, this.providerName);
+        const rules = [
+            // Curator P1-1 / Reviewer Finding #4: only the explicit auth markers
+            // map to AuthenticationError. Earlier we treated every
+            // `invalid_request_error` as an auth failure — that's OpenAI's
+            // catch-all for any bad request (unsupported parameter, malformed
+            // JSON, etc.) and mislabelled them as "invalid API key". Use
+            // credential-specific signals only.
+            {
+                match: (ctx) => ctx.statusCode === 401 ||
+                    errorType === "invalid_api_key" ||
+                    /API_KEY_INVALID|Invalid API key|Incorrect API key|invalid_api_key/i.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: (ctx) => /Incorrect API key|Invalid API key/i.test(ctx.message)
+                    ? ctx.message
+                    : "Invalid OpenAI API key. Please check your OPENAI_API_KEY environment variable.",
+            },
+            {
+                match: (ctx) => ctx.statusCode === 429 ||
+                    errorType === "rate_limit_error" ||
+                    /rate limit/i.test(ctx.message),
+                errorClass: RateLimitError,
+                message: "OpenAI rate limit exceeded. Please try again later.",
+            },
+            {
+                match: (ctx) => /model_not_found/i.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: (ctx) => `Model not found: ${ctx.modelName}`,
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // Optional hook overrides

package/dist/providers/openAI/index.d.ts

@@ -1,3 +1 @@
 export * from "./client.js";
-export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/openAI/index.js

@@ -1,3 +1 @@
 export * from "./client.js";
-export * from "./constants.js";
-export * from "./utils.js";

package/dist/providers/openRouter/client.js

@@ -1,10 +1,10 @@
 import { AIProviderName } from "../../constants/enums.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
+import { classifyProviderError, DEFAULT_ERROR_RULES, } from "../../utils/errorClassifier.js";
 import { isAbortError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
-import { TimeoutError } from "../../utils/timeout.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 import { stripTrailingSlash } from "../openaiChatCompletionsClient.js";
 import { getDefaultOpenRouterModel } from "./utils.js";
@@ -87,63 +87,69 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
         return getDefaultOpenRouterModel();
     }
     formatProviderError(error) {
-        if (error instanceof TimeoutError) {
-            return new NetworkError(`Request timed out: ${error.message}`, "openrouter");
-        }
-        // Check for timeout by error name and message as fallback
-        const errorRecord = error;
-        if (errorRecord?.name === "TimeoutError" ||
-            (typeof errorRecord?.message === "string" &&
-                errorRecord.message.includes("Timeout"))) {
-            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, "openrouter");
-        }
-        if (typeof errorRecord?.message === "string") {
-            if (errorRecord.message.includes("ECONNREFUSED") ||
-                errorRecord.message.includes("Failed to fetch")) {
-                return new NetworkError("OpenRouter API not available. Please check your network connection and try again.", "openrouter");
-            }
-            if (errorRecord.message.includes("API_KEY_INVALID") ||
-                errorRecord.message.includes("Invalid API key") ||
-                errorRecord.message.includes("invalid_api_key") ||
-                errorRecord.message.includes("Unauthorized")) {
-                return new AuthenticationError("Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
-                    "Get your key at https://openrouter.ai/keys", "openrouter");
-            }
-            if (errorRecord.message.includes("rate limit")) {
-                return new RateLimitError("OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits", "openrouter");
-            }
-            if (errorRecord.message.includes("model") &&
-                errorRecord.message.includes("not found")) {
-                return new InvalidModelError(`Model '${this.modelName}' not available on OpenRouter. ` +
-                    "Browse available models at https://openrouter.ai/models", "openrouter");
-            }
-            if (errorRecord.message.includes("insufficient_credits")) {
-                return new ProviderError("Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits", "openrouter");
-            }
+        const rules = [
+            // Duck-typed timeout detection (name === "TimeoutError" OR message
+            // contains "Timeout", case-sensitive — matches the original's
+            // `.includes("Timeout")`) distinct from the `instanceof TimeoutError`
+            // check classifyProviderError already performs first.
+            {
+                match: (ctx) => ctx.errorName === "TimeoutError" || /Timeout/.test(ctx.message),
+                errorClass: NetworkError,
+                message: (ctx) => `Request timed out: ${ctx.message}`,
+            },
+            {
+                match: (ctx) => /ECONNREFUSED|Failed to fetch/.test(ctx.message),
+                errorClass: NetworkError,
+                message: "OpenRouter API not available. Please check your network connection and try again.",
+            },
+            {
+                match: (ctx) => /API_KEY_INVALID|Invalid API key|invalid_api_key|Unauthorized/.test(ctx.message),
+                errorClass: AuthenticationError,
+                message: "Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
+                    "Get your key at https://openrouter.ai/keys",
+            },
+            {
+                match: (ctx) => /rate limit/.test(ctx.message),
+                errorClass: RateLimitError,
+                message: "OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits",
+            },
+            {
+                match: (ctx) => /model/.test(ctx.message) && /not found/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `Model '${this.modelName}' not available on OpenRouter. ` +
+                    "Browse available models at https://openrouter.ai/models",
+            },
+            {
+                match: (ctx) => /insufficient_credits/.test(ctx.message),
+                errorClass: ProviderError,
+                message: "Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits",
+            },
             // "No endpoints found" — model temporarily unavailable or unsupported
             // parameters. Distinct from tool errors: it can happen on any request
             // when the model has no available providers on OpenRouter.
-            if (errorRecord.message.includes("No endpoints found")) {
-                return new InvalidModelError(`No endpoints found for model '${this.modelName}' on OpenRouter. ` +
+            {
+                match: (ctx) => /No endpoints found/.test(ctx.message),
+                errorClass: InvalidModelError,
+                message: () => `No endpoints found for model '${this.modelName}' on OpenRouter. ` +
                     "The model may be temporarily unavailable or does not support the requested parameters. " +
-                    "Try a different model or check availability at https://openrouter.ai/models", "openrouter");
-            }
+                    "Try a different model or check availability at https://openrouter.ai/models",
+            },
             // Tool/function calling errors
-            if (errorRecord.message.includes("tool use") ||
-                errorRecord.message.includes("tool_use") ||
-                errorRecord.message.includes("function_call") ||
-                errorRecord.message.includes("tools are not supported")) {
-                return new ProviderError(`Model '${this.modelName}' does not support tool calling. ` +
+            {
+                match: (ctx) => /tool use|tool_use|function_call|tools are not supported/.test(ctx.message),
+                errorClass: ProviderError,
+                message: () => `Model '${this.modelName}' does not support tool calling. ` +
                     "Use a tool-capable model like:\n" +
                     "  • google/gemini-2.0-flash-exp:free (free)\n" +
                     "  • meta-llama/llama-3.3-70b-instruct:free (free)\n" +
                     "  • anthropic/claude-3.7-sonnet (paid)\n" +
                     "  • openai/gpt-4o (paid)\n" +
                     "Or use --disableTools flag. " +
-                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools", "openrouter");
-            }
-        }
-        return new ProviderError(`OpenRouter error: ${errorRecord?.message || "Unknown error"}`, "openrouter");
+                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools",
+            },
+            ...DEFAULT_ERROR_RULES,
+        ];
+        return classifyProviderError(error, rules, "openrouter", this.modelName);
     }
     // ===========================================================================
     // Optional hooks — provider-specific quirks

package/dist/providers/openRouter/utils.d.ts

@@ -1,3 +1 @@
-import type { OpenRouterConfig } from "../../types/index.js";
-export declare const getOpenRouterConfig: () => OpenRouterConfig;
 export declare const getDefaultOpenRouterModel: () => string;

package/dist/providers/openRouter/utils.js

@@ -1,17 +1,5 @@
 import { OpenRouterModels } from "../../constants/enums.js";
 import { getProviderModel } from "../../utils/providerConfig.js";
-export const getOpenRouterConfig = () => {
-    const apiKey = process.env.OPENROUTER_API_KEY;
-    if (!apiKey) {
-        throw new Error("OPENROUTER_API_KEY environment variable is required. " +
-            "Get your API key at https://openrouter.ai/keys");
-    }
-    return {
-        apiKey,
-        referer: process.env.OPENROUTER_REFERER,
-        appName: process.env.OPENROUTER_APP_NAME,
-    };
-};
 export const getDefaultOpenRouterModel = () => {
     return getProviderModel("OPENROUTER_MODEL", OpenRouterModels.CLAUDE_SONNET_4_5);
 };

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -166,6 +166,15 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * override this to probe the server's `/models` endpoint.
      */
     validateConfiguration(): Promise<boolean>;
+    /**
+     * Shared local-runtime reachability probe: GET `${baseURL}/models` with a
+     * short timeout, requiring at least one model entry with a non-empty id.
+     * Local providers (Ollama, LM Studio, llama.cpp) call this from their own
+     * validateConfiguration() override instead of relying on the base class's
+     * "apiKey is a non-empty string" default, which can't detect an
+     * unreachable local server.
+     */
+    protected probeModelsEndpoint(headers?: Record<string, string>): Promise<boolean>;
     /**
      * Snapshot of the provider's resolved configuration — part of the documented
      * public provider contract (`docs/provider-integration/00-architecture.md`).

package/dist/providers/openaiChatCompletionsBase.js

@@ -17,6 +17,7 @@
  * Nothing here imports from "ai" or "@ai-sdk/*". The base class is a
  * direct HTTP client + multi-step tool-execution loop driven by SSE.
  */
+import { trace } from "@opentelemetry/api";
 import { getAvailableInputTokens, getRuntimeContextWindow, getRuntimeOutputCeiling, registerRuntimeContextWindow, } from "../constants/contextWindows.js";
 import { guardOpenAICompatConversation } from "../context/openaiCompatLoopGuard.js";
 import { isContextOverflowError, parseProviderOverflowDetails, } from "../context/errorDetection.js";
@@ -26,12 +27,14 @@ import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
+import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, } from "../utils/timeout.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { withProviderRetry } from "../utils/providerRetry.js";
 import { resolveDeferredTool } from "../tools/toolDiscovery.js";
 import { buildAPIError, buildBody, buildToolsForOpenAI, buildWireToolNameMaps, createChunkQueue, createDeferredAnalytics, ensureJsonWordInBody, estimateWireTokens, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
 /**
@@ -272,6 +275,38 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         return (typeof this.config.apiKey === "string" &&
             this.config.apiKey.trim().length > 0);
     }
+    /**
+     * Shared local-runtime reachability probe: GET `${baseURL}/models` with a
+     * short timeout, requiring at least one model entry with a non-empty id.
+     * Local providers (Ollama, LM Studio, llama.cpp) call this from their own
+     * validateConfiguration() override instead of relying on the base class's
+     * "apiKey is a non-empty string" default, which can't detect an
+     * unreachable local server.
+     */
+    async probeModelsEndpoint(headers = {}) {
+        try {
+            const url = `${stripTrailingSlash(this.config.baseURL)}/models`;
+            const proxyFetch = createProxyFetch();
+            const response = await proxyFetch(url, {
+                headers: { ...headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                return false;
+            }
+            const data = (await response
+                .json()
+                .catch(() => null));
+            return Boolean(data?.data?.some((m) => typeof m?.id === "string" && m.id.trim().length > 0));
+        }
+        catch (error) {
+            logger.debug(`[${this.constructor.name}] probeModelsEndpoint failed`, {
+                baseURL: redactUrlCredentials(this.config.baseURL),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
     /**
      * Snapshot of the provider's resolved configuration — part of the documented
      * public provider contract (`docs/provider-integration/00-architecture.md`).
@@ -899,22 +934,44 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 : {}),
             streaming: true,
         }), args.modelId));
-        let res = await args.fetchImpl(args.url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...this.getAuthHeaders(),
-            },
-            body: JSON.stringify(body),
-            ...(args.abortSignal ? { signal: args.abortSignal } : {}),
-        });
-        if (!res.ok) {
-            const apiErr = await buildAPIError(args.url, body, res);
-            // One-shot 400 retry — overflow corrector first (re-fits max_tokens
-            // from the provider's own numbers + self-heals the window registry),
-            // then the subclass hook (e.g. NIM strips chat_template /
-            // reasoning_budget when a model rejects them).
-            const retryBody = res.status === 400
+        // The initial fetch gets 429/5xx retry-with-backoff via the same
+        // primitive the non-streaming path already uses (withProviderRetry).
+        // `doFetch` throws the classified APIError (buildAPIError attaches
+        // .statusCode + .responseHeaders, which withProviderRetry's duck-typing
+        // reads directly) so a non-ok response is what drives the retry
+        // decision, not a return value.
+        const doFetch = async () => {
+            const attemptRes = await args.fetchImpl(args.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.getAuthHeaders(),
+                },
+                body: JSON.stringify(body),
+                ...(args.abortSignal ? { signal: args.abortSignal } : {}),
+            });
+            if (!attemptRes.ok) {
+                throw await buildAPIError(args.url, body, attemptRes);
+            }
+            return attemptRes;
+        };
+        let res;
+        try {
+            res = await withProviderRetry(doFetch, trace.getActiveSpan() ?? undefined, `${this.providerName} stream`);
+        }
+        catch (err) {
+            // The one-shot 400 context-overflow fallback lives outside
+            // withProviderRetry (400 isn't retryable there anyway — see
+            // isRetryableProviderError), so it fires on the classified error's
+            // .statusCode. The raw Response is no longer in scope here: it was
+            // consumed inside doFetch's closure, either returned on success or
+            // discarded after buildAPIError read its body on failure.
+            const apiErr = err;
+            // Overflow corrector first (re-fits max_tokens from the provider's
+            // own numbers + self-heals the window registry), then the subclass
+            // hook (e.g. NIM strips chat_template / reasoning_budget when a model
+            // rejects them).
+            const retryBody = apiErr.statusCode === 400
                 ? (this.correctBodyAfterContextOverflow(body, apiErr) ??
                     this.adjustBodyAfter400(body, apiErr))
                 : undefined;