@juspay/neurolink 12.47.4 → 12.47.6

package/dist/localUsage/copilotCliReader.js

@@ -125,7 +125,7 @@ export async function createCopilotCliReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: dbPath,
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/localUsage/cursorReader.js

@@ -375,7 +375,7 @@ export async function createCursorReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: chatsRoot(),
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/localUsage/hermesReader.js

@@ -318,7 +318,7 @@ export async function createHermesReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: hermesHome(),
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/localUsage/openCodeReader.js

@@ -80,10 +80,11 @@ export async function createOpenCodeReader() {
             const errors = [];
             const models = new Set();
             const dbPath = databasePath();
-            // `node:sqlite` is built in from Node 22 but still flagged experimental,
-            // so it can be absent or change shape. Imported lazily and behind a
-            // try/catch: a runtime without it must degrade to a reported failure for
-            // this one reader, not take down a scan of all the others.
+            // `node:sqlite` arrived in Node 22.5.0 behind `--experimental-sqlite`, was
+            // unflagged in 22.13.0 and is still marked experimental, so it can be
+            // absent or change shape. Imported lazily and behind a try/catch: a
+            // runtime without it must degrade to a reported failure for this one
+            // reader, not take down a scan of all the others.
             let DatabaseSync;
             try {
                 const sqlite = await import("node:sqlite");
@@ -102,7 +103,7 @@ export async function createOpenCodeReader() {
                 errors.push({
                     cliId: CLI_ID,
                     filePath: dbPath,
-                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)}`,
+                    message: `node:sqlite unavailable on this runtime: ${error instanceof Error ? error.message : String(error)} (needs Node >=22.13.0; on 22.5-22.12 pass --experimental-sqlite)`,
                 });
                 return { cliId: CLI_ID, totals, filesScanned: 0, errors };
             }

package/dist/neurolink.d.ts

@@ -129,7 +129,7 @@ export declare class NeuroLink {
      * request dedup — BZ-664's actual goal — is untouched: the first
      * occurrence in a request may still be served from cache. Request-scoped
      * like _disableToolCacheForCurrentRequest above (assigned a fresh Set at
-     * request start so the router's save/restore-by-reference pattern works).
+     * request start so `preservingTurnState`'s save/restore-by-reference works).
      */
     private _toolCacheKeysServedThisRequest;
     /** True only while a generate()/stream() turn is executing — the
@@ -1094,6 +1094,18 @@ export declare class NeuroLink {
      */
     private streamWithIterationFallback;
     private executeStreamRequest;
+    /**
+     * Runs an internal call that re-enters the public generate() (the tool-routing
+     * router, the classifier router) without ending the outer turn's tool-cache
+     * state. generate()'s own `finally` resets these fields, so the outer turn
+     * would otherwise lose its repeat-call cache bypass for every later tool
+     * call. Restored by reference: the nested call assigns a new Set rather than
+     * mutating the outer one.
+     *
+     * Covers one turn re-entering itself. Two concurrent turns on one instance
+     * still share these fields.
+     */
+    private preservingTurnState;
     /**
      * Pre-call tool routing for both stream() and generate() turns: runs the
      * router LLM once per turn and appends the unpicked servers' registered tool

package/dist/neurolink.js

@@ -433,7 +433,7 @@ export class NeuroLink {
      * request dedup — BZ-664's actual goal — is untouched: the first
      * occurrence in a request may still be served from cache. Request-scoped
      * like _disableToolCacheForCurrentRequest above (assigned a fresh Set at
-     * request start so the router's save/restore-by-reference pattern works).
+     * request start so `preservingTurnState`'s save/restore-by-reference works).
      */
     _toolCacheKeysServedThisRequest = new Set();
     /** True only while a generate()/stream() turn is executing — the
@@ -994,9 +994,9 @@ export class NeuroLink {
         // generate() (marked so it never recursively re-routes). Fails open.
         this.classifierRouter = config?.classifierRouter?.enabled
             ? new ClassifierRouter(config.classifierRouter, {
-                generate: (genOptions) => this.generate({
+                generate: (genOptions) => this.preservingTurnState(() => this.generate({
                     ...genOptions,
-                }),
+                })),
                 // Fail-open by construction: tryDecide returns null rather than
                 // throwing, so an absent or broken decision provider leaves routing
                 // exactly as it was.
@@ -7265,6 +7265,30 @@ Current user's request: ${currentInput}`;
             throw error;
         }
     }
+    /**
+     * Runs an internal call that re-enters the public generate() (the tool-routing
+     * router, the classifier router) without ending the outer turn's tool-cache
+     * state. generate()'s own `finally` resets these fields, so the outer turn
+     * would otherwise lose its repeat-call cache bypass for every later tool
+     * call. Restored by reference: the nested call assigns a new Set rather than
+     * mutating the outer one.
+     *
+     * Covers one turn re-entering itself. Two concurrent turns on one instance
+     * still share these fields.
+     */
+    async preservingTurnState(run) {
+        const disableToolCache = this._disableToolCacheForCurrentRequest;
+        const keysServed = this._toolCacheKeysServedThisRequest;
+        const turnActive = this._generationTurnActive;
+        try {
+            return await run();
+        }
+        finally {
+            this._disableToolCacheForCurrentRequest = disableToolCache;
+            this._toolCacheKeysServedThisRequest = keysServed;
+            this._generationTurnActive = turnActive;
+        }
+    }
     /**
      * Pre-call tool routing for both stream() and generate() turns: runs the
      * router LLM once per turn and appends the unpicked servers' registered tool
@@ -7420,104 +7444,92 @@ Current user's request: ${currentInput}`;
                     return;
                 }
             }
-            // The router call below re-enters the public generate(), whose finally
-            // block resets _disableToolCacheForCurrentRequest to false. That flag is
-            // turn-scoped (set at the top of this turn) and read by the main tool
-            // execution path that runs after routing, so save it before the router
-            // call and restore it afterward to keep the turn's cache setting intact.
-            const cacheDisabledForCurrentRequest = this._disableToolCacheForCurrentRequest;
             let routedExcludeTools;
             let resolvedDecision;
-            try {
-                // Intercept the decision so we can store it in the cache.
-                const captureDecision = (decision) => {
-                    resolvedDecision = decision;
-                    emitDecision(decision);
-                };
-                // --- ITEM B: build the embedFn for the L2 embedding fast-path ---
-                // The vector cache is persisted at the NeuroLink instance level so
-                // tool embedding vectors are computed once and reused across turns
-                // (Finding 1 fix). It is cleared by setToolRoutingServers() when the
-                // catalog changes so stale vectors are never used after an update.
-                let routingEmbedFn;
-                const embeddingCfg = routingConfig.embedding;
-                if (embeddingCfg?.enabled === true) {
-                    try {
-                        // Resolve the embedding provider: use the explicitly configured one
-                        // if present, otherwise fall back to the stream/generate call's
-                        // provider. The factory call is wrapped in try/catch so a provider
-                        // that doesn't support embedMany (it throws at call time, not
-                        // construction time) fails open when routingEmbedFn is invoked.
-                        const embProviderName = embeddingCfg.provider ??
-                            (options.provider && options.provider !== "auto"
-                                ? options.provider
-                                : undefined) ??
-                            routingConfig.routerModel?.provider;
-                        if (embProviderName) {
-                            const embProvider = await AIProviderFactory.createProvider(embProviderName, embeddingCfg.model, true, this, undefined, this.resolveCredentials(options.credentials));
-                            // Bind embedMany with the configured model (may be undefined —
-                            // the provider uses its default embedding model in that case).
-                            routingEmbedFn = (texts) => withTimeout(embProvider.embedMany(texts, embeddingCfg.model), embeddingCfg.timeoutMs ?? 10000);
-                            // Lazy-init the persistent vector cache for this instance.
-                            // Subsequent turns reuse the same Map so text→vector lookups
-                            // already populated from earlier turns are served from memory.
-                            if (!this.toolRoutingVectorCache) {
-                                this.toolRoutingVectorCache = new Map();
-                            }
+            // Intercept the decision so we can store it in the cache.
+            const captureDecision = (decision) => {
+                resolvedDecision = decision;
+                emitDecision(decision);
+            };
+            // --- ITEM B: build the embedFn for the L2 embedding fast-path ---
+            // The vector cache is persisted at the NeuroLink instance level so
+            // tool embedding vectors are computed once and reused across turns
+            // (Finding 1 fix). It is cleared by setToolRoutingServers() when the
+            // catalog changes so stale vectors are never used after an update.
+            let routingEmbedFn;
+            const embeddingCfg = routingConfig.embedding;
+            if (embeddingCfg?.enabled === true) {
+                try {
+                    // Resolve the embedding provider: use the explicitly configured one
+                    // if present, otherwise fall back to the stream/generate call's
+                    // provider. The factory call is wrapped in try/catch so a provider
+                    // that doesn't support embedMany (it throws at call time, not
+                    // construction time) fails open when routingEmbedFn is invoked.
+                    const embProviderName = embeddingCfg.provider ??
+                        (options.provider && options.provider !== "auto"
+                            ? options.provider
+                            : undefined) ??
+                        routingConfig.routerModel?.provider;
+                    if (embProviderName) {
+                        const embProvider = await AIProviderFactory.createProvider(embProviderName, embeddingCfg.model, true, this, undefined, this.resolveCredentials(options.credentials));
+                        // Bind embedMany with the configured model (may be undefined —
+                        // the provider uses its default embedding model in that case).
+                        routingEmbedFn = (texts) => withTimeout(embProvider.embedMany(texts, embeddingCfg.model), embeddingCfg.timeoutMs ?? 10000);
+                        // Lazy-init the persistent vector cache for this instance.
+                        // Subsequent turns reuse the same Map so text→vector lookups
+                        // already populated from earlier turns are served from memory.
+                        if (!this.toolRoutingVectorCache) {
+                            this.toolRoutingVectorCache = new Map();
                         }
                     }
-                    catch (embSetupError) {
-                        logger.debug("[ToolRouting] Embedding provider setup failed, L2 path disabled for this turn", {
-                            error: embSetupError instanceof Error
-                                ? embSetupError.message
-                                : String(embSetupError),
-                        });
-                        // routingEmbedFn remains undefined — fast-path is skipped.
-                    }
                 }
-                routedExcludeTools = await resolveToolRoutingExclusions({
-                    catalog,
-                    alwaysIncludeServerIds: routingConfig.alwaysIncludeServerIds ?? [],
-                    userQuery: routingQuery,
-                    routerPromptPrefix: routingConfig.routerPromptPrefix,
-                    routerModel: {
-                        provider: routingConfig.routerModel?.provider ??
-                            options.provider,
-                        model: routingConfig.routerModel?.model ?? options.model,
-                        region: routingConfig.routerModel?.region ?? options.region,
-                        temperature: routingConfig.routerModel?.temperature,
-                    },
-                    timeoutMs: routingConfig.timeoutMs ?? DEFAULT_TOOL_ROUTING_TIMEOUT_MS,
-                    // Forward the abort signal so a cancelled turn aborts the router
-                    // call promptly instead of waiting out the routing timeout.
-                    generateFn: (generateOptions) => this.generate({
-                        ...generateOptions,
-                        abortSignal: options.abortSignal,
-                    }),
-                    // Calibrated per-server routing when a decision provider is
-                    // configured. tryDecide returns null without one, so the resolver
-                    // falls straight through to the generative router as before.
-                    decideFn: (decisionOptions) => this.tryDecide({
-                        ...decisionOptions,
-                        signal: options.abortSignal,
-                    }),
-                    decisionMinDropConfidence: routingConfig.minDropConfidence,
-                    emitDecision: captureDecision,
-                    // L2 / ITEM D — only populated when embedding is configured.
-                    embedFn: routingEmbedFn,
-                    embeddingConfig: embeddingCfg,
-                    granularity: routingConfig.granularity ?? "server",
-                    // Pass the persistent vector cache so tool embeddings are reused
-                    // across turns (Finding 1).
-                    embeddingVectorCache: routingEmbedFn !== undefined
-                        ? this.toolRoutingVectorCache
-                        : undefined,
-                });
-            }
-            finally {
-                this._disableToolCacheForCurrentRequest =
-                    cacheDisabledForCurrentRequest;
-            }
+                catch (embSetupError) {
+                    logger.debug("[ToolRouting] Embedding provider setup failed, L2 path disabled for this turn", {
+                        error: embSetupError instanceof Error
+                            ? embSetupError.message
+                            : String(embSetupError),
+                    });
+                    // routingEmbedFn remains undefined — fast-path is skipped.
+                }
+            }
+            routedExcludeTools = await resolveToolRoutingExclusions({
+                catalog,
+                alwaysIncludeServerIds: routingConfig.alwaysIncludeServerIds ?? [],
+                userQuery: routingQuery,
+                routerPromptPrefix: routingConfig.routerPromptPrefix,
+                routerModel: {
+                    provider: routingConfig.routerModel?.provider ??
+                        options.provider,
+                    model: routingConfig.routerModel?.model ?? options.model,
+                    region: routingConfig.routerModel?.region ?? options.region,
+                    temperature: routingConfig.routerModel?.temperature,
+                },
+                timeoutMs: routingConfig.timeoutMs ?? DEFAULT_TOOL_ROUTING_TIMEOUT_MS,
+                // Forward the abort signal so a cancelled turn aborts the router
+                // call promptly instead of waiting out the routing timeout.
+                generateFn: (generateOptions) => this.preservingTurnState(() => this.generate({
+                    ...generateOptions,
+                    abortSignal: options.abortSignal,
+                })),
+                // Calibrated per-server routing when a decision provider is
+                // configured. tryDecide returns null without one, so the resolver
+                // falls straight through to the generative router as before.
+                decideFn: (decisionOptions) => this.tryDecide({
+                    ...decisionOptions,
+                    signal: options.abortSignal,
+                }),
+                decisionMinDropConfidence: routingConfig.minDropConfidence,
+                emitDecision: captureDecision,
+                // L2 / ITEM D — only populated when embedding is configured.
+                embedFn: routingEmbedFn,
+                embeddingConfig: embeddingCfg,
+                granularity: routingConfig.granularity ?? "server",
+                // Pass the persistent vector cache so tool embeddings are reused
+                // across turns (Finding 1).
+                embeddingVectorCache: routingEmbedFn !== undefined
+                    ? this.toolRoutingVectorCache
+                    : undefined,
+            });
             // Aborted during the router call — skip applying now-stale exclusions;
             // the main generation path enforces the abort itself.
             if (options.abortSignal?.aborted) {
@@ -7986,6 +7998,20 @@ Current user's request: ${currentInput}`;
                         yield* incrementalFallback;
                     }
                     ttsResolver?.(streamedTTSResult);
+                    // `streamState.finishReason` starts as a "stop" placeholder, before a
+                    // single chunk exists. A provider that records how the turn really
+                    // ended in metadata (a token-limit cut, a content filter, a step cap
+                    // that left tool calls pending) has that adopted here, once the drain
+                    // is done. Only the three unified values count: a raw vendor string
+                    // or "stop" leaves the graded reason alone, and a fallback's own
+                    // value is never overwritten.
+                    const drainedFinishReason = mcpStreamOutcome.metadata?.finishReason;
+                    if (!metadata.fallbackAttempted &&
+                        (drainedFinishReason === "length" ||
+                            drainedFinishReason === "tool-calls" ||
+                            drainedFinishReason === "content-filter")) {
+                        streamState.finishReason = drainedFinishReason;
+                    }
                     resolvedUsage = mcpStreamOutcome.usage;
                     if (!resolvedUsage && mcpStreamOutcome.analytics) {
                         try {
@@ -8176,8 +8202,19 @@ Current user's request: ${currentInput}`;
                 }
             })();
             const streamResult = await this.processStreamResult(processedStream, enhancedOptions, factoryResult);
-            streamResult.finishReason =
+            streamState.finishReason =
                 streamState.finishReason || streamResult.finishReason;
+            // Live, like toolCalls/toolResults below: the reason a stream ends with is
+            // only known after it drains, so a plain copy would stay the creation-time
+            // placeholder for every truncated or capped turn.
+            Object.defineProperty(streamResult, "finishReason", {
+                enumerable: true,
+                configurable: true,
+                get: () => streamState.finishReason,
+                set: (value) => {
+                    streamState.finishReason = value;
+                },
+            });
             // #1819 / E1b: a top-level cross-provider fallback (handleStreamFallback,
             // inside `processedStream` above) only reassigns
             // `streamState.toolCalls`/`toolResults` once the caller starts draining
@@ -9207,13 +9244,18 @@ Current user's request: ${currentInput}`;
         if (toolResultsDescriptor) {
             Object.defineProperty(response, "toolResults", toolResultsDescriptor);
         }
+        const finishReasonDescriptor = Object.getOwnPropertyDescriptor(streamResult, "finishReason");
+        if (finishReasonDescriptor) {
+            Object.defineProperty(response, "finishReason", finishReasonDescriptor);
+        }
         if (!source) {
             return response;
         }
         // NeuroLink grades the turn's terminal state itself (a normalized
         // finishReason, stopReason for aborts and time limits), so those fields
-        // stay plain values here. Copying the provider's getter for them would
-        // report the raw vendor reason, e.g. Anthropic's end_turn, instead.
+        // keep NeuroLink's own value here (finishReason through the descriptor
+        // copied above). Copying the provider's getter for them would report the
+        // raw vendor reason, e.g. Anthropic's end_turn, instead.
         //
         // toolCalls/toolResults are excluded for a different reason: `source`
         // (the PRIMARY provider's own result) may itself define them as live

package/dist/providers/openaiChatCompletionsBase.js

@@ -99,6 +99,28 @@ const resolveAgainstSchema = (text, schema) => {
     const scalar = recoverScalarRoot(text, schema);
     return scalar.kind === "accepted" ? scalar.value : undefined;
 };
+/**
+ * The one place a finish reason becomes the unified spelling. Accepts the wire's
+ * `finish_reason` (`tool_calls`, `content_filter`) and the unified spelling a
+ * middleware's own finish part already carries (`tool-calls`, `content-filter`),
+ * since both reach the stream path. Anything else, including `stop`, `error` and
+ * an absent value, reads as `stop`.
+ */
+const toUnifiedFinishReason = (reason) => {
+    switch (reason) {
+        case "length":
+            return "length";
+        case "tool_calls":
+        case "function_call":
+        case "tool-calls":
+            return "tool-calls";
+        case "content_filter":
+        case "content-filter":
+            return "content-filter";
+        default:
+            return "stop";
+    }
+};
 // Pull one native chunk at a time and forward cancellation to its iterator.
 const chunksToV3Stream = (source, completion, cancel) => {
     const iterator = source[Symbol.asyncIterator]();
@@ -774,13 +796,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     });
                 }
                 const rawFinish = choice?.finish_reason;
-                const unified = rawFinish === "length"
-                    ? "length"
-                    : rawFinish === "tool_calls" || rawFinish === "function_call"
-                        ? "tool-calls"
-                        : rawFinish === "content_filter"
-                            ? "content-filter"
-                            : "stop";
+                const unified = toUnifiedFinishReason(rawFinish);
                 return {
                     content,
                     finishReason: { unified, raw: rawFinish ?? "stop" },
@@ -1839,7 +1855,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 if (!loopPromise) {
                     resolveFinish("stop");
                 }
-                streamMetadata.rawFinishReason = await finishPromise;
+                const rawFinishReason = await finishPromise;
+                streamMetadata.rawFinishReason = rawFinishReason;
                 // Structured output for a `stream({ schema })` turn. Runs HERE —
                 // after the stream is fully drained — so a tool-free re-ask (when the
                 // streamed answer isn't already schema-valid) never reaches
@@ -1884,9 +1901,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // Only reached once the structured-output re-ask above (when there
                 // was one) has resolved without throwing. A caller abort during that
                 // re-ask rejects `resolveStreamStructuredData` and skips this line
-                // entirely, so `metadata.finishReason` never claims "stop" for a
+                // entirely, so `metadata.finishReason` never claims a finish for a
                 // turn that actually failed after the wire stream itself finished.
-                streamMetadata.finishReason = "stop";
+                // The reason is the turn's own (a token-limit cut reads "length"), not
+                // a blanket "stop" for every stream that drained without throwing.
+                streamMetadata.finishReason = toUnifiedFinishReason(rawFinishReason);
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
                 // Pipeline B (ContextEnricher) surfaces a WARNING-level Langfuse

package/dist/proxy/proxyConfig.js

@@ -241,6 +241,10 @@ function kebabToCamelRoutingKey(kebabKey) {
  * *because* one of the spellings was explicitly `null` — never merely
  * because both were absent — so callers can warn once per null key without
  * warning on ordinary omission.
+ *
+ * `account-allowlist` is the one key whose `null` `validateProxyConfig`
+ * rejects before this runs, so for it the `null` branch is only reachable
+ * through a direct `parseRoutingConfig` call.
  */
 function readLegacyRoutingKey(routing, kebabKey) {
     const camelKey = kebabToCamelRoutingKey(kebabKey);
@@ -313,6 +317,13 @@ export function validateProxyConfig(config) {
                 }
             });
         }
+        // A `null` allowlist must not read as "unset": a reload that loses a
+        // restriction this way would silently open the proxy to every account.
+        // Checked per spelling, before the legacy read coalesces them.
+        if (routing["account-allowlist"] === null ||
+            routing[kebabToCamelRoutingKey("account-allowlist")] === null) {
+            errors.push("routing.account-allowlist must be an array of non-empty strings (null is not allowed; omit the key to remove the restriction)");
+        }
         const rawAccountAllowlist = readLegacyRoutingKey(routing, "account-allowlist").value;
         if (rawAccountAllowlist !== undefined) {
             if (!Array.isArray(rawAccountAllowlist)) {

package/dist/utils/errorClassifier.d.ts

@@ -1,7 +1,10 @@
 /**
- * Shared provider-error classification. Every provider's
- * `formatProviderError(error)` delegates here instead of hand-rolling its
+ * Shared provider-error classification. Migrated providers'
+ * `formatProviderError(error)` delegate here instead of hand-rolling their
  * own TimeoutError-check → .includes()-chain → `new XError(...)` ladder.
+ * Not yet migrated (they do not call it): Google AI Studio, SageMaker, the
+ * media and embedding providers (Ideogram, Recraft, Stability, Replicate,
+ * Jina, Voyage) and the System One decision provider.
  *
  * `classifyProviderError` picks the Error subclass + message; it does NOT
  * stamp statusCode/isRetryable/retryAfterMs onto the result — that

package/dist/utils/errorClassifier.js

@@ -1,7 +1,10 @@
 /**
- * Shared provider-error classification. Every provider's
- * `formatProviderError(error)` delegates here instead of hand-rolling its
+ * Shared provider-error classification. Migrated providers'
+ * `formatProviderError(error)` delegate here instead of hand-rolling their
  * own TimeoutError-check → .includes()-chain → `new XError(...)` ladder.
+ * Not yet migrated (they do not call it): Google AI Studio, SageMaker, the
+ * media and embedding providers (Ideogram, Recraft, Stability, Replicate,
+ * Jina, Voyage) and the System One decision provider.
  *
  * `classifyProviderError` picks the Error subclass + message; it does NOT
  * stamp statusCode/isRetryable/retryAfterMs onto the result — that
@@ -116,7 +119,14 @@ export function classifyProviderError(error, rules, provider, modelName) {
 // A 404 alone is a route answer (a wrong base URL gives the same reply): it only
 // means "missing model" when the text names a model or deployment as absent.
 // The gap is bounded rather than "no dot" because real model ids contain dots.
-const MODEL_404_TEXT = /model[_ ]?not[_ ]?found|unknown model|no such model|invalid model|unsupported model|\b(?:model|deployment)\b.{0,120}\b(?:does not exist|not found|unavailable|not (?:available|supported))\b|\b(?:does not exist|not found)\b.{0,120}\b(?:model|deployment)\b|unable to access.{0,60}\bmodel\b/i;
+// "model" or "deployment" followed by a route noun ("model gateway route") is a
+// modifier of that route, not the subject of the 404, in either word order, and
+// that holds for the named phrases ("unknown model gateway route") as well.
+const NOT_A_ROUTE_MODIFIER = "(?![\\s-]+(?:route|gateway|endpoint|url|path|proxy|server|service|api|host)s?(?![\\w-]))";
+const MODEL_WORD = `\\bmodel\\b${NOT_A_ROUTE_MODIFIER}`;
+const MODEL_OR_DEPLOYMENT = `\\b(?:model|deployment)\\b${NOT_A_ROUTE_MODIFIER}`;
+const NAMED_MODEL_ERROR = `(?:unknown|no such|invalid|unsupported) model${NOT_A_ROUTE_MODIFIER}`;
+const MODEL_404_TEXT = new RegExp(`model[_ ]?not[_ ]?found|${NAMED_MODEL_ERROR}|${MODEL_OR_DEPLOYMENT}.{0,120}\\b(?:does not exist|not found|unavailable|not (?:available|supported))\\b|\\b(?:does not exist|not found)\\b.{0,120}${MODEL_OR_DEPLOYMENT}|unable to access.{0,60}${MODEL_WORD}`, "i");
 /**
  * Generic fallback rule table covering the five categories every
  * OpenAI-compatible provider already hand-rolled near-identically: