@juspay/neurolink 9.76.0 → 9.77.0

package/dist/lib/routing/modelPool.js

@@ -0,0 +1,243 @@
+/**
+ * ModelPool runtime — multi-provider failover with per-member cooldown.
+ *
+ * This module is PURE (no provider imports, no circular dependencies).
+ * It works exclusively with provider NAMES + (provider, model, region) tuples;
+ * the existing AIProviderFactory creates actual provider instances.
+ *
+ * Usage:
+ *   const pool = new ModelPool({ members: [...], strategy: "round-robin" });
+ *   const member = pool.selectNext();
+ *   try {
+ *     await callProvider(member);
+ *     pool.recordSuccess(member);
+ *   } catch (err) {
+ *     pool.recordFailure(member, classifyProviderError(err));
+ *     // try next member ...
+ *   }
+ */
+import { AuthenticationError, AuthorizationError, ModelAccessDeniedError, } from "../types/index.js";
+import { looksLikeModelAccessDenied } from "../utils/providerErrorClassification.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Error classification
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Returns the HTTP status code embedded in an error object, or undefined.
+ */
+function extractHttpStatus(error) {
+    if (!error || typeof error !== "object") {
+        return undefined;
+    }
+    const e = error;
+    if (typeof e.status === "number") {
+        return e.status;
+    }
+    if (typeof e.statusCode === "number") {
+        return e.statusCode;
+    }
+    return undefined;
+}
+/**
+ * Classify a provider error into a coarse `ProviderErrorClass`.
+ *
+ * Rules (checked in order):
+ * 1. HTTP 429 or message pattern → "rate_limit"
+ * 2. HTTP 401/403, access-denied pattern, or auth keywords → "auth"
+ * 3. Context-window / token-limit message → "context_window"
+ * 4. HTTP 5xx or server-error message → "server"
+ * 5. Network connectivity error → "network"
+ * 6. Everything else → "unknown"
+ */
+export function classifyProviderError(error) {
+    const status = extractHttpStatus(error);
+    const msg = error instanceof Error
+        ? error.message
+        : typeof error === "object" && error !== null
+            ? String(error.message ?? error)
+            : String(error ?? "");
+    const lower = msg.toLowerCase();
+    // 1. Rate limit
+    if (status === 429 ||
+        /rate.?limit|quota exceeded|too many requests|requests per minute/.test(lower)) {
+        return "rate_limit";
+    }
+    // 2. Auth / access denied — also check typed error classes so that a
+    //    typed AuthenticationError or ModelAccessDeniedError is classified as
+    //    "auth" even when its message doesn't match the regex patterns.
+    if (status === 401 ||
+        status === 403 ||
+        error instanceof AuthenticationError ||
+        error instanceof AuthorizationError ||
+        error instanceof ModelAccessDeniedError ||
+        looksLikeModelAccessDenied(error) ||
+        /unauthori[sz]ed|forbidden|invalid api.?key|api key|access denied|authentication failed|permission denied|unauthenticated/.test(lower)) {
+        return "auth";
+    }
+    // 3. Context window
+    if (/context.?length|maximum context|token.*exceed|exceeds.*context|too.?long|input.*too.?large/.test(lower)) {
+        return "context_window";
+    }
+    // 4. Server error
+    if ((status !== undefined && status >= 500 && status < 600) ||
+        /server error|internal server|overloaded|service unavailable|bad gateway|gateway timeout/.test(lower)) {
+        return "server";
+    }
+    // 5. Network
+    if (/econnreset|etimedout|enotfound|network error|socket hang up|connection refused|connection reset/.test(lower)) {
+        return "network";
+    }
+    return "unknown";
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Cooldown constants
+// ─────────────────────────────────────────────────────────────────────────────
+const DEFAULT_COOLDOWN_MS = 60_000; // 1 minute for retryable errors
+// Non-retryable errors use a permanent-for-the-instance cooldown: 10 years.
+// NOTE: Because ModelPool is stored as a long-lived field on the NeuroLink
+// instance (neurolink.ts constructor), a "permanent" cooldown blocks the
+// member for the entire lifetime of the NeuroLink instance, not just the
+// current call.  Only use PERMANENT_COOLDOWN_MS for error classes where the
+// root cause is structural and will not resolve between calls (e.g. wrong API
+// key, model not whitelisted for the team).  Transient or unclassified errors
+// must use the timed cooldown so a momentary failure doesn't permanently
+// retire a healthy member.
+const PERMANENT_COOLDOWN_MS = 10 * 365 * 24 * 60 * 60 * 1000;
+/**
+ * Error classes that should receive a timed cooldown rather than a permanent
+ * ban.  "unknown" is deliberately included: because the classification is
+ * uncertain, treating an unrecognised error as permanent could retire a
+ * healthy member due to a one-off network blip or a non-standard error
+ * message.  A timed cooldown lets the member recover automatically.
+ */
+const RETRYABLE_ERROR_CLASSES = new Set([
+    "rate_limit",
+    "server",
+    "network",
+    "unknown",
+]);
+// ─────────────────────────────────────────────────────────────────────────────
+// ModelPool
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Multi-provider pool with per-member cooldown and strategy-based selection.
+ *
+ * All state (cooldowns, cursor) is instance-local and resets on construction.
+ * Thread safety is not required — Node.js is single-threaded for async work.
+ */
+export class ModelPool {
+    config;
+    strategy;
+    cooldownMs;
+    state;
+    cursor;
+    now;
+    constructor(config, injectors) {
+        this.config = config;
+        this.strategy = config.strategy ?? "priority";
+        this.cooldownMs = config.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+        this.now = injectors?.now ?? Date.now;
+        this.cursor = 0;
+        this.state = new Map();
+    }
+    /**
+     * The maximum number of attempts per call (pool config value or member count).
+     * Used by callers that drive the retry loop externally.
+     */
+    get maxAttempts() {
+        return this.config.maxAttempts ?? this.config.members.length;
+    }
+    /**
+     * Returns a stable string key for a pool member.
+     * Format: `${provider}:${model ?? "*"}:${region ?? "*"}`
+     */
+    memberKey(member) {
+        return `${member.provider}:${member.model ?? "*"}:${member.region ?? "*"}`;
+    }
+    /** Returns members whose cooldown has expired (or were never cooled). */
+    availableMembers() {
+        const now = this.now();
+        return this.config.members.filter((m) => {
+            const s = this.state.get(this.memberKey(m));
+            return !s || s.cooldownUntil <= now;
+        });
+    }
+    /**
+     * Selects the next member to try according to the configured strategy.
+     *
+     * @param excludedKeys — keys of members already attempted this call.
+     * @returns the chosen member, or undefined when all members are exhausted.
+     */
+    selectNext(excludedKeys) {
+        const candidates = this.availableMembers().filter((m) => !excludedKeys?.has(this.memberKey(m)));
+        if (candidates.length === 0) {
+            return undefined;
+        }
+        switch (this.strategy) {
+            case "priority":
+                return candidates[0];
+            case "round-robin": {
+                // Advance cursor to the next candidate index in the ORIGINAL list order.
+                const allMembers = this.config.members;
+                const candidateSet = new Set(candidates.map((m) => this.memberKey(m)));
+                // Find the next member starting from cursor that is in candidateSet.
+                for (let i = 0; i < allMembers.length; i++) {
+                    const idx = (this.cursor + i) % allMembers.length;
+                    const member = allMembers[idx];
+                    if (candidateSet.has(this.memberKey(member))) {
+                        // Advance cursor past this pick for the next call.
+                        this.cursor = (idx + 1) % allMembers.length;
+                        return member;
+                    }
+                }
+                return candidates[0];
+            }
+            case "weighted": {
+                // Deterministic weighted selection: compute cumulative weights, pick
+                // by cursor position (mod total weight) so repeated calls rotate.
+                const totalWeight = candidates.reduce((sum, m) => sum + (m.weight ?? 1), 0);
+                if (totalWeight <= 0) {
+                    return candidates[0];
+                }
+                const pick = this.cursor % totalWeight;
+                let accumulated = 0;
+                for (const member of candidates) {
+                    accumulated += member.weight ?? 1;
+                    if (pick < accumulated) {
+                        this.cursor = (this.cursor + 1) % Math.max(totalWeight, 1);
+                        return member;
+                    }
+                }
+                // Fallback (floating-point edge case)
+                this.cursor = (this.cursor + 1) % Math.max(totalWeight, 1);
+                return candidates[candidates.length - 1];
+            }
+            default:
+                return candidates[0];
+        }
+    }
+    /**
+     * Records a provider failure, setting a cooldown appropriate for the error class.
+     *
+     * - Retryable classes (rate_limit, server, network, unknown): timed cooldown
+     *   for `cooldownMs` so the member can recover and be retried later.
+     * - Non-retryable classes (auth, context_window): permanent cooldown for the
+     *   lifetime of this ModelPool instance, because these errors are structural
+     *   and will not resolve between calls (wrong credentials, model not available
+     *   in team whitelist, payload exceeds the model's context window).
+     */
+    recordFailure(member, errorClass) {
+        const key = this.memberKey(member);
+        const cooldown = RETRYABLE_ERROR_CLASSES.has(errorClass)
+            ? this.now() + this.cooldownMs
+            : this.now() + PERMANENT_COOLDOWN_MS;
+        this.state.set(key, { cooldownUntil: cooldown });
+    }
+    /**
+     * Records a successful response, clearing any existing cooldown for this member
+     * so it remains fully available.
+     */
+    recordSuccess(member) {
+        this.state.delete(this.memberKey(member));
+    }
+}
+//# sourceMappingURL=modelPool.js.map

package/dist/lib/routing/requestRouter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default heuristic request router.
+ *
+ * `createDefaultRequestRouter` produces a `RequestRouter` function that maps
+ * lightweight request characteristics to a provider/model/region override.
+ * It is entirely optional — hosts may supply their own `RequestRouter` function
+ * instead, or disable routing entirely by not passing either.
+ *
+ * This PR adds `requestRouter` (and `modelPool`) as NeuroLink constructor
+ * options. The router is skipped only when BOTH options.provider AND
+ * options.model are explicitly set by the caller — a partial pin (e.g. only
+ * provider) still allows the router to run.
+ *
+ * Decision logic (checked in order):
+ * 1. Vision request        → visionTier
+ * 2. Large input or tools  → largeTier
+ * 3. Default               → smallTier (only when config.smallTier is provided)
+ *
+ * When none of the configured tiers matches (or when the tier is not
+ * configured), the router returns `{}` which is a no-op — the caller keeps
+ * whatever provider/model was set by the user.
+ */
+import type { DefaultRequestRouterConfig, RequestRouter } from "../types/index.js";
+/**
+ * Creates a heuristic `RequestRouter` from a `DefaultRequestRouterConfig`.
+ *
+ * @param config — optional tier overrides; built-in defaults apply when omitted.
+ * @returns a synchronous `RequestRouter` function (satisfies the async signature).
+ */
+export declare function createDefaultRequestRouter(config?: DefaultRequestRouterConfig): RequestRouter;

package/dist/lib/routing/requestRouter.js

@@ -0,0 +1,81 @@
+/**
+ * Default heuristic request router.
+ *
+ * `createDefaultRequestRouter` produces a `RequestRouter` function that maps
+ * lightweight request characteristics to a provider/model/region override.
+ * It is entirely optional — hosts may supply their own `RequestRouter` function
+ * instead, or disable routing entirely by not passing either.
+ *
+ * This PR adds `requestRouter` (and `modelPool`) as NeuroLink constructor
+ * options. The router is skipped only when BOTH options.provider AND
+ * options.model are explicitly set by the caller — a partial pin (e.g. only
+ * provider) still allows the router to run.
+ *
+ * Decision logic (checked in order):
+ * 1. Vision request        → visionTier
+ * 2. Large input or tools  → largeTier
+ * 3. Default               → smallTier (only when config.smallTier is provided)
+ *
+ * When none of the configured tiers matches (or when the tier is not
+ * configured), the router returns `{}` which is a no-op — the caller keeps
+ * whatever provider/model was set by the user.
+ */
+/** Token threshold above which we treat a request as "large". */
+const DEFAULT_LARGE_TOKEN_THRESHOLD = 32_000;
+/**
+ * Built-in defaults for each tier.
+ * These are intentionally conservative — hosts should override them to match
+ * their provider credentials and preferred models.
+ */
+const DEFAULT_VISION_TIER = {
+    provider: "vertex",
+    model: "gemini-2.5-flash",
+};
+const DEFAULT_LARGE_TIER = {
+    provider: "anthropic",
+    model: "claude-sonnet-4-5",
+};
+const DEFAULT_SMALL_TIER = {
+    provider: "anthropic",
+    model: "claude-haiku-3-5",
+};
+function tierToDecision(tier, reason) {
+    return {
+        provider: tier.provider,
+        model: tier.model,
+        region: tier.region,
+        reason,
+    };
+}
+/**
+ * Creates a heuristic `RequestRouter` from a `DefaultRequestRouterConfig`.
+ *
+ * @param config — optional tier overrides; built-in defaults apply when omitted.
+ * @returns a synchronous `RequestRouter` function (satisfies the async signature).
+ */
+export function createDefaultRequestRouter(config) {
+    const largeTokenThreshold = config?.largeInputTokenThreshold ?? DEFAULT_LARGE_TOKEN_THRESHOLD;
+    const visionTier = config?.visionTier ?? DEFAULT_VISION_TIER;
+    const largeTier = config?.largeTier ?? DEFAULT_LARGE_TIER;
+    const smallTier = config?.smallTier ?? DEFAULT_SMALL_TIER;
+    return function defaultRequestRouter(ctx) {
+        // 1. Vision
+        if (ctx.requiresVision) {
+            return tierToDecision(visionTier, "vision request detected");
+        }
+        // 2. Large input or tool-heavy
+        const tokenCount = ctx.estimatedInputTokens ?? 0;
+        if (tokenCount >= largeTokenThreshold || ctx.hasTools) {
+            return tierToDecision(largeTier, ctx.hasTools ? "tool-enabled request" : "large input detected");
+        }
+        // 3. Default small/fast tier — only when config.smallTier is explicitly
+        //    provided. When not configured, return {} (no-op) so callers that did
+        //    not opt into a small tier see no surprise provider override.
+        if (config?.smallTier !== undefined) {
+            return tierToDecision(smallTier, "default small tier");
+        }
+        // No override — let the caller keep its own provider/model.
+        return {};
+    };
+}
+//# sourceMappingURL=requestRouter.js.map

package/dist/lib/types/config.d.ts

@@ -9,6 +9,8 @@ import type { ConversationMemoryConfig } from "./conversation.js";
 import type { ObservabilityConfig } from "./observability.js";
 import type { AuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
 import type { NeurolinkCredentials } from "./providers.js";
+import type { ModelPoolConfig } from "./modelPool.js";
+import type { RequestRouter } from "./requestRouter.js";
 /**
  * Main NeuroLink configuration type
  */
@@ -86,6 +88,22 @@ export type NeurolinkConstructorConfig = {
      * See {@link ToolDedupConfig}.
      */
     toolDedup?: ToolDedupConfig;
+    /**
+     * Multi-provider pool for error-class-aware failover with per-member
+     * cooldown. When set, generate() and stream() source their candidate
+     * provider sequence from the pool instead of (or in addition to) the
+     * static providerPriority fallback. Fails open: a pool error leaves
+     * existing behavior unchanged.
+     */
+    modelPool?: ModelPoolConfig;
+    /**
+     * Pluggable pre-call router: inspects lightweight request characteristics
+     * (token estimate, tools, vision, thinkingLevel) and returns an optional
+     * provider/model/region override. Only runs when the caller did NOT
+     * explicitly set options.provider/options.model. Fails open: a router
+     * error proceeds unrouted.
+     */
+    requestRouter?: RequestRouter;
 };
 /**
  * Configuration for MCP enhancement modules wired into generate()/stream() paths.

package/dist/lib/types/index.d.ts

@@ -69,3 +69,5 @@ export * from "./avatar.js";
 export * from "./music.js";
 export * from "./replicate.js";
 export * from "./safeFetch.js";
+export * from "./modelPool.js";
+export * from "./requestRouter.js";

package/dist/lib/types/index.js

@@ -76,4 +76,8 @@ export * from "./music.js";
 export * from "./replicate.js";
 // Safe-fetch helper types (SSRF-hardened download)
 export * from "./safeFetch.js";
+// ModelPool — multi-provider failover with per-member cooldown (M9.x+)
+export * from "./modelPool.js";
+// RequestRouter — pluggable pre-call provider/model selection (M9.x+)
+export * from "./requestRouter.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/types/modelPool.d.ts

@@ -0,0 +1,47 @@
+/**
+ * ModelPool types — multi-provider failover with per-member cooldown.
+ *
+ * A ModelPool holds an ordered list of (provider, model, region) members and
+ * selects among them per-turn using a configurable strategy. On provider
+ * failure, the pool cools down the failed member and retries with the next
+ * available one, using error-class-aware logic to distinguish retryable from
+ * permanent failures.
+ */
+/** One candidate provider/model/region tuple in a pool. */
+export type ModelPoolMember = {
+    provider: string;
+    model?: string;
+    region?: string;
+    /** Relative weight used by the "weighted" strategy. Default: 1. */
+    weight?: number;
+};
+/** Member-selection strategy when picking the next candidate. */
+export type ModelPoolStrategy = "priority" | "round-robin" | "weighted";
+/**
+ * Coarse error class returned by `classifyProviderError`.
+ * Drives the cooldown decision inside ModelPool.
+ */
+export type ProviderErrorClass = "rate_limit" | "auth" | "context_window" | "server" | "network" | "unknown";
+/** Constructor-level configuration for a ModelPool instance. */
+export type ModelPoolConfig = {
+    /** Ordered list of provider/model/region candidates. */
+    members: ModelPoolMember[];
+    /**
+     * How to pick among available members.
+     * - "priority"     — always try the first available member (default).
+     * - "round-robin"  — rotate through members in order.
+     * - "weighted"     — prefer members with higher weight, varies by cursor.
+     */
+    strategy?: ModelPoolStrategy;
+    /**
+     * How long (ms) a failed member stays in cooldown before it is eligible
+     * again. Applies to retryable error classes (rate_limit, server, network).
+     * Default: 60_000 (1 minute).
+     */
+    cooldownMs?: number;
+    /**
+     * Maximum total attempts across all pool members per call.
+     * Default: members.length (try every member once).
+     */
+    maxAttempts?: number;
+};

package/dist/lib/types/modelPool.js

@@ -0,0 +1,11 @@
+/**
+ * ModelPool types — multi-provider failover with per-member cooldown.
+ *
+ * A ModelPool holds an ordered list of (provider, model, region) members and
+ * selects among them per-turn using a configurable strategy. On provider
+ * failure, the pool cools down the failed member and retries with the next
+ * available one, using error-class-aware logic to distinguish retryable from
+ * permanent failures.
+ */
+export {};
+//# sourceMappingURL=modelPool.js.map

package/dist/lib/types/requestRouter.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Pluggable pre-call request router types.
+ *
+ * A RequestRouter is a host-supplied async function that inspects lightweight
+ * request characteristics (token estimate, tools, vision, thinking) and
+ * returns an optional provider/model/region override.  The router runs only
+ * when the host opts in (by passing `requestRouter` or `modelPool` to
+ * the NeuroLink constructor) and only when the user did NOT explicitly set
+ * BOTH `options.provider` AND `options.model` on the call (a partial pin —
+ * e.g. only `options.provider` — still allows the router to run).
+ *
+ * Everything fails open: if the router throws or returns an empty decision the
+ * call proceeds with whatever provider/model was configured by the caller.
+ */
+/**
+ * Lightweight characteristics of the incoming request available to the router
+ * without executing the full call.
+ */
+export type RouterInputContext = {
+    /** The text prompt (or first text segment of a multi-modal input). */
+    prompt: string;
+    /** Rough token estimate for the input, if known by the caller. */
+    estimatedInputTokens?: number;
+    /** True when the call includes at least one tool definition. */
+    hasTools?: boolean;
+    /** True when the call includes at least one image/vision attachment. */
+    requiresVision?: boolean;
+    /** Thinking level passed to the call ("minimal" | "low" | "medium" | "high"). */
+    thinkingLevel?: string;
+};
+/**
+ * The router's decision.  Any field that is undefined means "keep whatever the
+ * caller already configured" — returning `{}` is a valid no-op.
+ */
+export type RequestRouterDecision = {
+    provider?: string;
+    model?: string;
+    region?: string;
+    /** Optional human-readable reason, emitted at debug log level. */
+    reason?: string;
+};
+/**
+ * A pluggable pre-call router function.
+ *
+ * Receives a lightweight context snapshot and returns provider/model/region
+ * overrides.  May be async (e.g. to consult a remote config service).
+ */
+export type RequestRouter = (context: RouterInputContext) => RequestRouterDecision | Promise<RequestRouterDecision>;
+/**
+ * Tier-to-(provider,model) mapping used by `createDefaultRequestRouter`.
+ * Each tier is optional; an unmatched tier produces an empty decision.
+ */
+export type ModelTierEntry = {
+    provider: string;
+    model: string;
+    region?: string;
+};
+/**
+ * Configuration for the built-in heuristic request router produced by
+ * `createDefaultRequestRouter`.  All fields are optional; sensible defaults
+ * apply when omitted.
+ */
+export type DefaultRequestRouterConfig = {
+    /**
+     * Token threshold above which the "large" tier is selected.
+     * Default: 32_000.
+     */
+    largeInputTokenThreshold?: number;
+    /** Provider/model to use for vision requests. */
+    visionTier?: ModelTierEntry;
+    /** Provider/model to use for large inputs or tool-heavy requests. */
+    largeTier?: ModelTierEntry;
+    /** Provider/model to use for fast/small requests. */
+    smallTier?: ModelTierEntry;
+};

package/dist/lib/types/requestRouter.js

@@ -0,0 +1,16 @@
+/**
+ * Pluggable pre-call request router types.
+ *
+ * A RequestRouter is a host-supplied async function that inspects lightweight
+ * request characteristics (token estimate, tools, vision, thinking) and
+ * returns an optional provider/model/region override.  The router runs only
+ * when the host opts in (by passing `requestRouter` or `modelPool` to
+ * the NeuroLink constructor) and only when the user did NOT explicitly set
+ * BOTH `options.provider` AND `options.model` on the call (a partial pin —
+ * e.g. only `options.provider` — still allows the router to run).
+ *
+ * Everything fails open: if the router throws or returns an empty decision the
+ * call proceeds with whatever provider/model was configured by the caller.
+ */
+export {};
+//# sourceMappingURL=requestRouter.js.map

package/dist/lib/utils/providerErrorClassification.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared provider-error classification utilities used by both neurolink.ts and
+ * the ModelPool routing subsystem.
+ *
+ * Extracted here to avoid duplication and to ensure that typed error classes
+ * (AuthenticationError, AuthorizationError, ModelAccessDeniedError) are
+ * checked consistently in both code paths.
+ */
+/**
+ * Detects whether an error object looks like a model-access-denied condition.
+ * Matches LiteLLM "team not allowed" / "team can only access models=[...]"
+ * plus typed-error name/code markers when the full typed class is not present.
+ */
+export declare function looksLikeModelAccessDenied(error: unknown): boolean;
+/**
+ * Returns true when the error is definitively non-retryable: typed error
+ * classes (auth, access-denied, invalid-model), non-retryable HTTP status
+ * codes, or deterministic 400-class message patterns.
+ *
+ * NOTE: ContextBudgetExceededError is intentionally NOT non-retryable —
+ * each provider has its own context window, so a budget rejection on one
+ * provider does not preclude another provider accepting the same payload.
+ */
+export declare function isNonRetryableProviderError(error: unknown): boolean;

package/dist/lib/utils/providerErrorClassification.js

@@ -0,0 +1,89 @@
+/**
+ * Shared provider-error classification utilities used by both neurolink.ts and
+ * the ModelPool routing subsystem.
+ *
+ * Extracted here to avoid duplication and to ensure that typed error classes
+ * (AuthenticationError, AuthorizationError, ModelAccessDeniedError) are
+ * checked consistently in both code paths.
+ */
+import { AuthenticationError, AuthorizationError, InvalidModelError, ModelAccessDeniedError, } from "../types/index.js";
+import { NON_RETRYABLE_HTTP_STATUS_CODES, isDeterministicClientErrorMessage, } from "./retryability.js";
+/**
+ * Detects whether an error object looks like a model-access-denied condition.
+ * Matches LiteLLM "team not allowed" / "team can only access models=[...]"
+ * plus typed-error name/code markers when the full typed class is not present.
+ */
+export function looksLikeModelAccessDenied(error) {
+    if (!error) {
+        return false;
+    }
+    const e = error;
+    if (e.name === "ModelAccessDeniedError") {
+        return true;
+    }
+    if (e.code === "MODEL_ACCESS_DENIED") {
+        return true;
+    }
+    const msg = typeof e.message === "string"
+        ? e.message
+        : error instanceof Error
+            ? error.message
+            : String(error);
+    if (!msg) {
+        return false;
+    }
+    const lower = msg.toLowerCase();
+    return ((lower.includes("team") && lower.includes("not allowed")) ||
+        lower.includes("team can only access") ||
+        /not\s+allowed\s+to\s+access\s+(this\s+)?model/i.test(msg));
+}
+/**
+ * Returns true when the error is definitively non-retryable: typed error
+ * classes (auth, access-denied, invalid-model), non-retryable HTTP status
+ * codes, or deterministic 400-class message patterns.
+ *
+ * NOTE: ContextBudgetExceededError is intentionally NOT non-retryable —
+ * each provider has its own context window, so a budget rejection on one
+ * provider does not preclude another provider accepting the same payload.
+ */
+export function isNonRetryableProviderError(error) {
+    if (error instanceof InvalidModelError) {
+        return true;
+    }
+    if (error instanceof AuthenticationError) {
+        return true;
+    }
+    if (error instanceof AuthorizationError) {
+        return true;
+    }
+    if (error instanceof ModelAccessDeniedError) {
+        return true;
+    }
+    if (error && typeof error === "object") {
+        const err = error;
+        const status = typeof err.status === "number"
+            ? err.status
+            : typeof err.statusCode === "number"
+                ? err.statusCode
+                : undefined;
+        if (status !== undefined &&
+            NON_RETRYABLE_HTTP_STATUS_CODES.includes(status)) {
+            return true;
+        }
+    }
+    if (error instanceof Error) {
+        const msg = error.message;
+        if (msg.includes("NOT_FOUND") ||
+            msg.includes("Model Not Found") ||
+            msg.includes("model not found") ||
+            msg.includes("PERMISSION_DENIED") ||
+            msg.includes("UNAUTHENTICATED")) {
+            return true;
+        }
+        if (isDeterministicClientErrorMessage(msg)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=providerErrorClassification.js.map