@juspay/neurolink 11.1.1 → 11.2.1

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

@@ -8,6 +8,7 @@ import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
 import type { MultimodalAudioEntry } from "./file.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
+import type { ProviderErrorRule } from "./errors.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
 import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, OAuthToken } from "./subscription.js";
 import type { Tool } from "./tools.js";
@@ -577,6 +578,104 @@ export type ProviderConfigOptions = {
     fallbackEnvVars?: string[];
     optional?: boolean;
 };
+/**
+ * Minimal credential shape accepted by resolveOpenAICompatConfig() and
+ * ConfiguredOpenAICompatProvider. A structural superset of every real
+ * per-provider NeurolinkCredentials["<key>"] slice in this family (groq,
+ * xai, together, fireworks, perplexity, mistral, cloudflare) — all fields
+ * optional, so passing e.g. NeurolinkCredentials["groq"] (which has no
+ * accountId) here is always structurally valid.
+ */
+export type OpenAICompatCredentials = {
+    apiKey?: string;
+    baseURL?: string;
+    accountId?: string;
+};
+/**
+ * One row of the config-driven OpenAI-compatible provider catalog
+ * (OPENAI_COMPAT_CATALOG, src/lib/providers/openaiCompatCatalog.ts).
+ * Replaces a hand-written OpenAIChatCompletionsProvider subclass for
+ * providers whose only differences from every sibling are credentials,
+ * base URL, model defaults, and error-message classification.
+ */
+export type OpenAICompatCatalogEntry = {
+    /** Registry key / nl.generate({provider}) value, e.g. "groq". */
+    providerName: AIProviderName;
+    /** Registry aliases, e.g. ["together-ai", "together"]. */
+    aliases: string[];
+    /**
+     * Env var holding the API key, e.g. "GROQ_API_KEY".
+     *
+     * Declarative: the key is actually read through `configOptions.envVarName`,
+     * which `validateApiKey` consults. This field exists so an entry states its
+     * credential source without a caller having to reach into configOptions,
+     * and the catalog suite asserts the two always name the same variable — two
+     * fields describing one fact are worth nothing if they can disagree.
+     */
+    apiKeyEnvVar: string;
+    /**
+     * Env var that can override the base URL, e.g. "GROQ_BASE_URL". Omit
+     * for entries that use computedBaseURL instead (e.g. Cloudflare).
+     */
+    baseURLEnvVar?: string;
+    /** Static default base URL. Omit for computedBaseURL entries. */
+    defaultBaseURL?: string;
+    /**
+     * Present only for providers whose base URL is computed from an extra
+     * required credential value instead of a static default (Cloudflare's
+     * accountId). Deliberately narrow (accountId-shaped) rather than a
+     * generic extra-field mechanism — Cloudflare is the only current user.
+     */
+    computedBaseURL?: {
+        /** Env var fallback for the extra value, e.g. "CLOUDFLARE_ACCOUNT_ID". */
+        envVar: string;
+        /** Thrown when neither credentials.accountId nor envVar supply a value. */
+        missingValueMessage: string;
+        /** Builds the base URL from the resolved accountId. */
+        build: (accountId: string) => string;
+    };
+    /** Setup/help metadata, passed to validateApiKey(). Not consumed by
+     *  classifyProviderError() — that function's ProviderErrorContext has no
+     *  docsUrl field; any URL a rule's message needs is inlined in the rule
+     *  itself (see Task 4). */
+    configOptions: ProviderConfigOptions;
+    /** Env var for the default model, e.g. "GROQ_MODEL". */
+    modelEnvVar: string;
+    /** Default model when modelEnvVar is unset. */
+    defaultModel: string;
+    /**
+     * The literal passed as ProviderFactory.registerProvider()'s defaultModel
+     * argument (resolved before the provider is constructed). Preserves each
+     * provider's exact pre-migration registry behavior.
+     */
+    registryDefaultModel: string;
+    /**
+     * True for every provider except Mistral: whether the registry-level
+     * default also consults modelEnvVar before falling back to
+     * registryDefaultModel. False is a pre-existing, intentionally-preserved
+     * quirk unique to Mistral's registration (see plan's Design reference).
+     */
+    registryDefaultModelChecksEnvVar: boolean;
+    /** Fallback model name (getFallbackModelName()). */
+    fallbackModelName: string;
+    /** Fallback model list (getFallbackModels()). */
+    fallbackModels: string[];
+    /**
+     * Error-classification rules, consumed by classifyProviderError. Typed
+     * as a mutable array — not readonly — because plan 07's
+     * `classifyProviderError(error, rules: ProviderErrorRule[], provider, modelName?)`
+     * declares `rules` as `ProviderErrorRule[]`; a `readonly` array here
+     * would not be assignable to that parameter without a cast, which rule
+     * 14 (no double assertions) and general hygiene both rule out. Each
+     * entry's array is still constructed as a fresh literal per provider in
+     * Task 4, so nothing actually mutates it at runtime.
+     */
+    errorRules: ProviderErrorRule[];
+};
+/** The subset of OpenAICompatCatalogEntry that resolveOpenAICompatConfig()
+ *  needs — lets call sites pass a minimal object without the full catalog
+ *  entry (e.g. in tests, or a future non-catalog caller). */
+export type OpenAICompatConfigInput = Pick<OpenAICompatCatalogEntry, "providerName" | "apiKeyEnvVar" | "baseURLEnvVar" | "defaultBaseURL" | "computedBaseURL" | "configOptions">;
 /**
  * AI Provider type with flexible parameter support
  */

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

@@ -481,6 +481,13 @@ export type ProxyAccountRoutingCandidate = {
     weeklyStatus: string | null;
     weeklyUsed: number | null;
     weeklyResetAt: number | null;
+    /** Display name of the model-scoped window that matched the requested model
+     *  (e.g. "Fable"), or null when the account reports no scoped cap for it.
+     *  Optional so schema-v1 readers of older records stay valid. */
+    scopedModel?: string | null;
+    scopedStatus?: string | null;
+    scopedUsed?: number | null;
+    scopedResetAt?: number | null;
 };
 export type ProxyAccountRoutingDecision = {
     schemaVersion: 1;
@@ -531,6 +538,15 @@ export type ProxyAccountSortMetrics = {
     weeklyReset: number;
     weeklyUsed: number | null;
     weeklyUsedForSort: number;
+    /** Model-scoped weekly window matching the requested model. All null/false
+     *  when the account reports no scoped cap for it (the common case), which
+     *  makes every scoped comparator rung a no-op for unscoped traffic. */
+    scopedModel: string | null;
+    scopedStatus: string | null;
+    scopedUsed: number | null;
+    scopedReset: number;
+    scopedUsedForSort: number;
+    scopedSaturated: boolean;
 };
 export type RequestLogEntry = {
     timestamp: string;
@@ -665,6 +681,8 @@ export type AnthropicLoopState = {
     } | null;
     authFailureMessage: string | null;
     authCooldownMessage: string | null;
+    entitlementFailure: AnthropicEntitlementFailure | null;
+    scopedExhaustion: AnthropicScopedExhaustion | null;
     fallbackFailureMessage?: string;
     attemptNumber: number;
     lastTransportErrorCode?: string;
@@ -752,6 +770,7 @@ export type AnthropicAuthRetryResult = {
     retryDelayMs?: number;
     lastError: unknown;
     authFailureMessage: string | null;
+    entitlementFailure: AnthropicEntitlementFailure | null;
     sawRateLimit: boolean;
     sawTransientFailure: boolean;
     sawNetworkError: boolean;
@@ -771,6 +790,7 @@ export type AnthropicNonOkResult = {
         body: string;
         contentType?: string;
     } | null;
+    entitlementFailure: AnthropicEntitlementFailure | null;
     upstreamSpan?: Span;
 };
 export type PreparedAnthropicAccountAttempt = {
@@ -997,6 +1017,17 @@ export type AccountQuota = {
     overageStatus: string;
     /** Whether Anthropic reports that paid overage is actively serving traffic. */
     overageInUse?: boolean;
+    /** Why overage is unavailable, verbatim from
+     *  anthropic-ratelimit-unified-overage-disabled-reason (e.g.
+     *  "org_level_disabled"). Present only when the provider states one. */
+    overageDisabledReason?: string;
+    /** Authoritative extra-usage switch from the usage API's
+     *  `extra_usage.is_enabled`. Unlike the header trio this is reported even for
+     *  an account that has never served a request. */
+    overageEnabled?: boolean;
+    /** Which window Anthropic considers binding right now, verbatim from
+     *  anthropic-ratelimit-unified-representative-claim (e.g. "five_hour"). */
+    representativeClaim?: string;
     /** Epoch ms when we last captured this data */
     lastUpdated: number;
     /** Dynamic per-plan limit buckets from the usage API `limits[]` array
@@ -1033,8 +1064,21 @@ export type AccountQuotaWindow = {
     isActive?: boolean;
     /** Model display name for model-scoped windows (e.g. "Fable"). */
     scopeModel?: string;
+    /** Wire model id for the scope when the provider reports one
+     *  (`scope.model.id`), which matches a request's `model` exactly and so beats
+     *  display-name matching. Often null in practice. */
+    scopeModelId?: string;
     /** Surface scope when the provider reports one. */
     scopeSurface?: string;
+    /** Epoch ms this individual window was observed. Lets a header-derived window
+     *  and a usage-API window on the same account age independently — the flat
+     *  `lastUpdated` refreshes on every response and would otherwise make a
+     *  days-old scoped window look current. */
+    updatedAt?: number;
+    /** Provenance of this window, mirroring AccountQuotaSource. */
+    source?: AccountQuotaSource;
+    /** Raw unified header token for header-derived windows, e.g. "7d_oi". */
+    headerWindow?: string;
 };
 /** One utilization window from the OAuth usage endpoint (wire shape, loose). */
 export type AnthropicUsageWindow = {
@@ -2316,6 +2360,40 @@ export type ClaudeSnapshot = {
 export type ParsedClaudeError = {
     errorType?: string;
     message?: string;
+    /** `error.details.error_code`, e.g. "oauth_not_allowed_for_organization".
+     *  Absent on payloads that carry no details object. */
+    errorCode?: string;
+};
+/**
+ * Accounts rejected by an organization/plan entitlement policy during a single
+ * request. Anthropic answers such an account with a `permission_error` that no
+ * amount of retrying or token refreshing can fix, but which a *different*
+ * account may not hit at all — so it drives rotation, and is reported to the
+ * client only once every account has been tried.
+ */
+export type AnthropicEntitlementFailure = {
+    status: number;
+    /** Labels of every account that rejected this request on entitlement. */
+    accounts: string[];
+    /** Upstream message from the first such rejection. */
+    message: string;
+    errorCode?: string;
+};
+/**
+ * Every account's model-scoped window for the requested model is spent. Unlike
+ * a cooldown this is per-model: the same accounts stay healthy for every other
+ * model, so the client is told to switch model rather than to back off.
+ */
+export type AnthropicScopedExhaustion = {
+    /** Wire model id from the request. */
+    model: string;
+    /** Display name of the exhausted window, e.g. "Fable". */
+    scopeModel: string;
+    /** Epoch ms of the soonest reset across the exhausted accounts. */
+    earliestResetMs: number;
+    accounts: string[];
+    /** Provider reason overage is unavailable, e.g. "org_level_disabled". */
+    overageDisabledReason?: string;
 };
 /** ora spinner instance held by proxy CLI commands, nullable when --quiet. */
 export type ProxySpinner = Ora | null;
@@ -2340,7 +2418,12 @@ export type ProxyRequestRoutingSnapshot = {
     quotaRoutingEnabled: boolean;
     sessionSoftLimit: number;
     sessionResetToleranceMs: number;
+    /** Operator policy on spending paid extra usage once a subscription window is
+     *  spent. Only "never" can override the provider's own signal. */
+    useOverage: ProxyOveragePolicy;
 };
+/** Operator policy for paid extra usage. */
+export type ProxyOveragePolicy = "auto" | "always" | "never";
 /** Immutable last-known-good proxy configuration published at runtime. */
 export type ProxyRuntimeConfigSnapshot = ProxyRequestRoutingSnapshot & {
     loadedAt: string;

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

@@ -998,6 +998,19 @@ export type ProxyRoutingConfig = {
     passthroughModels?: string[];
     /** Enable quota-aware fill-first account ordering. Defaults to true. */
     quotaRouting?: boolean;
+    /**
+     * Whether an account may keep serving on paid extra usage once its
+     * subscription window is spent.
+     *
+     * - `auto` (default): follow whatever Anthropic reports for the account.
+     * - `never`: park the account at the subscription limit even when extra usage
+     *   is enabled, so the pool can never spend credits.
+     * - `always`: keep serving whenever the provider permits extra usage.
+     *
+     * Only `never` can override the provider — nothing here can enable extra usage
+     * that Anthropic has disabled (e.g. `org_level_disabled`).
+     */
+    useOverage?: "auto" | "always" | "never";
     /** Session utilization threshold used to proactively demote an account. */
     sessionSoftLimit?: number;
     /** Reset-time bucket width used when ordering quota windows. */

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

@@ -5,7 +5,7 @@
  * Enhanced with format validation and advanced error classification
  * Extended with Claude subscription OAuth support
  */
-import type { APIValidationResult, ProviderConfigOptions, AnthropicAuthMethod, ClaudeSubscriptionTier, AnthropicAuthConfig, AnthropicAuthConfigResult } from "../types/index.js";
+import type { APIValidationResult, ProviderConfigOptions, AnthropicAuthMethod, ClaudeSubscriptionTier, AnthropicAuthConfig, AnthropicAuthConfigResult, OpenAICompatConfigInput, OpenAICompatCredentials } from "../types/index.js";
 /**
  * API key format validation patterns (extracted from advanced validation system)
  * Exported for use across the codebase to replace scattered regex patterns
@@ -369,3 +369,25 @@ export declare function hasSubscriptionFeature(feature: "extended_thinking" | "p
  * @returns Human-readable configuration description
  */
 export declare function describeAnthropicConfig(): string;
+/**
+ * Resolves the {apiKey, baseURL} pair for a config-driven OpenAI-compatible
+ * catalog entry (see OpenAICompatCatalogEntry in types/providers.ts).
+ *
+ * Extracted from the identical 6-line precedence block that was copy-pasted
+ * across groq.ts, xai.ts, togetherAi.ts, fireworks.ts, perplexity.ts, and
+ * mistral.ts, plus Cloudflare's accountId-computed-baseURL variant.
+ *
+ * Precedence (matches every ported subclass's original behavior exactly):
+ *   apiKey:  credentials.apiKey (trimmed, non-blank) > env var > throw
+ *   baseURL: credentials.baseURL (trimmed, non-blank)
+ *            > env var (if entry.baseURLEnvVar is set, trimmed, non-blank)
+ *            > entry.defaultBaseURL
+ *   baseURL (computedBaseURL entries, e.g. Cloudflare):
+ *            credentials.baseURL > computedBaseURL.build(accountId), where
+ *            accountId = credentials.accountId (trimmed) > env var (trimmed)
+ *            > throw computedBaseURL.missingValueMessage
+ */
+export declare function resolveOpenAICompatConfig(entry: OpenAICompatConfigInput, credentials?: OpenAICompatCredentials): {
+    apiKey: string;
+    baseURL: string;
+};

package/dist/lib/utils/providerConfig.js

@@ -1300,4 +1300,64 @@ export function describeAnthropicConfig() {
     lines.push(`Priority Access: ${config.limits.priorityAccess ? "Yes" : "No"}`);
     return lines.join("\n");
 }
+/**
+ * Resolves the {apiKey, baseURL} pair for a config-driven OpenAI-compatible
+ * catalog entry (see OpenAICompatCatalogEntry in types/providers.ts).
+ *
+ * Extracted from the identical 6-line precedence block that was copy-pasted
+ * across groq.ts, xai.ts, togetherAi.ts, fireworks.ts, perplexity.ts, and
+ * mistral.ts, plus Cloudflare's accountId-computed-baseURL variant.
+ *
+ * Precedence (matches every ported subclass's original behavior exactly):
+ *   apiKey:  credentials.apiKey (trimmed, non-blank) > env var > throw
+ *   baseURL: credentials.baseURL (trimmed, non-blank)
+ *            > env var (if entry.baseURLEnvVar is set, trimmed, non-blank)
+ *            > entry.defaultBaseURL
+ *   baseURL (computedBaseURL entries, e.g. Cloudflare):
+ *            credentials.baseURL > computedBaseURL.build(accountId), where
+ *            accountId = credentials.accountId (trimmed) > env var (trimmed)
+ *            > throw computedBaseURL.missingValueMessage
+ */
+export function resolveOpenAICompatConfig(entry, credentials) {
+    const overrideApiKey = credentials?.apiKey?.trim();
+    const apiKey = overrideApiKey && overrideApiKey.length > 0
+        ? overrideApiKey
+        : validateApiKey(entry.configOptions);
+    if (entry.computedBaseURL) {
+        const { envVar, missingValueMessage, build } = entry.computedBaseURL;
+        // An explicit base URL is checked first and trimmed the same way the
+        // static branch trims it. It makes the account id irrelevant — there is
+        // nothing left to build — so demanding one anyway would reject a fully
+        // specified override.
+        const overrideComputedBaseURL = credentials?.baseURL?.trim();
+        if (overrideComputedBaseURL && overrideComputedBaseURL.length > 0) {
+            return { apiKey, baseURL: overrideComputedBaseURL };
+        }
+        const extraValue = (credentials?.accountId ??
+            process.env[envVar] ??
+            "").trim();
+        if (!extraValue) {
+            throw new Error(missingValueMessage);
+        }
+        return { apiKey, baseURL: build(extraValue) };
+    }
+    const overrideBaseURL = credentials?.baseURL?.trim();
+    const envBaseURL = entry.baseURLEnvVar
+        ? process.env[entry.baseURLEnvVar]?.trim()
+        : undefined;
+    const baseURL = (overrideBaseURL && overrideBaseURL.length > 0
+        ? overrideBaseURL
+        : undefined) ??
+        (envBaseURL && envBaseURL.length > 0 ? envBaseURL : undefined) ??
+        entry.defaultBaseURL;
+    if (!baseURL) {
+        // Reachable only for an entry that sets neither defaultBaseURL nor
+        // computedBaseURL. Returning "" instead would hand the SDK an empty base
+        // URL and surface as a confusing request failure far from the cause.
+        throw new Error(`${entry.providerName}: no base URL. Set one in credentials` +
+            (entry.baseURLEnvVar ? `, set ${entry.baseURLEnvVar}` : "") +
+            `, or give the catalog entry a defaultBaseURL.`);
+    }
+    return { apiKey, baseURL };
+}
 //# sourceMappingURL=providerConfig.js.map

package/dist/providers/configuredOpenAICompat.d.ts

@@ -0,0 +1,24 @@
+import type { AIProviderName } from "../constants/enums.js";
+import type { OpenAICompatCatalogEntry, OpenAICompatCredentials } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
+/**
+ * Generic OpenAI-compatible provider driven entirely by an
+ * OpenAICompatCatalogEntry. Replaces a hand-written subclass for any
+ * provider whose only differences from its siblings are credentials, base
+ * URL, model defaults, and error-classification rules — see
+ * OPENAI_COMPAT_CATALOG in openaiCompatCatalog.ts for the entries.
+ *
+ * If a provider needs a real hook override (adjustRequestBody,
+ * adjustBodyAfter400, getChatCompletionsURL, getAuthHeaders,
+ * suppressResponseFormatWithTools, ...) it does NOT belong in the catalog —
+ * write a dedicated subclass instead (see deepseek.ts, azureOpenai.ts).
+ */
+export declare class ConfiguredOpenAICompatProvider extends OpenAIChatCompletionsProvider {
+    private readonly entry;
+    constructor(entry: OpenAICompatCatalogEntry, modelName?: string, sdk?: unknown, credentials?: OpenAICompatCredentials);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected getFallbackModelName(): string;
+    protected getFallbackModels(): string[];
+    protected formatProviderError(error: unknown): Error;
+}

package/dist/providers/configuredOpenAICompat.js

@@ -0,0 +1,59 @@
+import { logger } from "../utils/logger.js";
+import { redactUrlCredentials } from "../utils/logSanitize.js";
+import { getProviderModel, resolveOpenAICompatConfig, } from "../utils/providerConfig.js";
+import { classifyProviderError } from "../utils/errorClassifier.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
+/**
+ * Generic OpenAI-compatible provider driven entirely by an
+ * OpenAICompatCatalogEntry. Replaces a hand-written subclass for any
+ * provider whose only differences from its siblings are credentials, base
+ * URL, model defaults, and error-classification rules — see
+ * OPENAI_COMPAT_CATALOG in openaiCompatCatalog.ts for the entries.
+ *
+ * If a provider needs a real hook override (adjustRequestBody,
+ * adjustBodyAfter400, getChatCompletionsURL, getAuthHeaders,
+ * suppressResponseFormatWithTools, ...) it does NOT belong in the catalog —
+ * write a dedicated subclass instead (see deepseek.ts, azureOpenai.ts).
+ */
+export class ConfiguredOpenAICompatProvider extends OpenAIChatCompletionsProvider {
+    entry;
+    constructor(entry, modelName, sdk, credentials) {
+        const { apiKey, baseURL } = resolveOpenAICompatConfig(entry, credentials);
+        // BaseProvider's constructor calls `this.getDefaultModel()` /
+        // `this.getProviderName()` synchronously inside `super()`, before this
+        // class's own constructor body (or field initializers) ever run — so
+        // `this.entry` is not yet assigned at that point and those overrides
+        // would read `undefined.modelEnvVar`. `entry.providerName` is always
+        // defined, so passing it straight through makes the base constructor's
+        // `providerName || this.getProviderName()` short-circuit; resolving the
+        // model up front and always passing a truthy `modelName` does the same
+        // for `getDefaultModel()`. Both overrides remain correct for any call
+        // made after construction, once `this.entry` is set below.
+        const resolvedModelName = modelName || getProviderModel(entry.modelEnvVar, entry.defaultModel);
+        super(entry.providerName, resolvedModelName, sdk, { baseURL, apiKey });
+        this.entry = entry;
+        logger.debug(`${entry.configOptions.providerName} Provider initialized`, {
+            modelName: this.modelName,
+            providerName: this.providerName,
+            baseURL: redactUrlCredentials(this.config.baseURL),
+        });
+    }
+    getProviderName() {
+        return this.entry.providerName;
+    }
+    getDefaultModel() {
+        return getProviderModel(this.entry.modelEnvVar, this.entry.defaultModel);
+    }
+    getFallbackModelName() {
+        return this.entry.fallbackModelName;
+    }
+    getFallbackModels() {
+        return this.entry.fallbackModels;
+    }
+    formatProviderError(error) {
+        // classifyProviderError handles TimeoutError internally (always maps
+        // to NetworkError, ahead of any rule table) — no local pre-check
+        // needed or wanted here; see this task's design note.
+        return classifyProviderError(error, this.entry.errorRules, this.entry.providerName, this.modelName);
+    }
+}

package/dist/providers/openaiCompatCatalog.d.ts

@@ -0,0 +1,24 @@
+import type { OpenAICompatCatalogEntry } from "../types/index.js";
+/**
+ * Config-driven catalog of the 7 zero-quirk OpenAI-compatible providers.
+ * Each entry fully replaces what used to be a hand-written
+ * OpenAIChatCompletionsProvider subclass — see ConfiguredOpenAICompatProvider
+ * for the class that reads these entries, and providerRegistry.ts for the
+ * registration loop that consumes this array.
+ *
+ * `errorRules` mirrors each provider's LIVE `formatProviderError` rule array
+ * (post plan-07/wave-2 migration), not the original hand-rolled ladder these
+ * providers had when plan 05 was first drafted: every provider below now
+ * keeps only its bespoke rule(s) — auth, plus Groq's model_decommissioned and
+ * xAI's insufficient_quota — before spreading the SAME exported
+ * `DEFAULT_ERROR_RULES` constant that the live subclasses spread (never an
+ * inlined copy, so this catalog cannot drift from that table independently).
+ * See plan-05/progress.md Ruling R4 for the full rationale.
+ *
+ * To add a new zero-quirk OpenAI-compatible provider: add one entry here.
+ * Do NOT add a provider here if it needs any hook override beyond the 3
+ * mandatory ones (getProviderName/getDefaultModel/formatProviderError) —
+ * write a dedicated subclass instead (see deepseek.ts, azureOpenai.ts, and
+ * Task 14's docs task for the deciding criteria).
+ */
+export declare const OPENAI_COMPAT_CATALOG: readonly OpenAICompatCatalogEntry[];