@juspay/neurolink 12.12.2 → 12.12.4

package/dist/cli/loop/optionsSchema.js

@@ -118,6 +118,10 @@ export const textGenerationOptionsSchema = {
         type: "boolean",
         description: "Disable tool result caching for this request (overrides global mcp.cache.enabled).",
     },
+    disableInternalFallback: {
+        type: "boolean",
+        description: "Own fallback order yourself: skip NeuroLink's provider-priority walk and the catalog model fallback, so an invalid model or unavailable provider surfaces as its own error.",
+    },
     disableToolCallRepair: {
         type: "boolean",
         description: "Disable the schema-driven tool call repair mechanism (near-miss tool names, mis-typed arguments). Repair is enabled by default.",

package/dist/core/baseProvider.js

@@ -1299,11 +1299,10 @@ export class BaseProvider {
             const otelSpanState = { ended: false };
             return await context.with(activeCtx, async () => this.runGenerateInActiveContext(options, startTime, otelSpan, otelSpanState));
         };
-        // TextGenerationOptions does not declare the flag (it lives on
-        // StreamOptions), but callers that own fallback order pass it on both
-        // paths, so honour it here as well.
-        const callerOwnsFallback = "disableInternalFallback" in options &&
-            options.disableInternalFallback === true;
+        // Callers that own fallback order (providerFallback / modelChain callers,
+        // or a router that retries on its own) pass the flag on both paths;
+        // TextGenerationOptions declares it, so a plain read is enough here.
+        const callerOwnsFallback = options.disableInternalFallback === true;
         return await this.runGenerateWithModelFallback(attempt, callerOwnsFallback);
     }
     /**

package/dist/neurolink.js

@@ -4121,6 +4121,11 @@ Current user's request: ${currentInput}`;
             disableTools: options.disableTools,
             toolFilter: options.toolFilter,
             excludeTools: options.excludeTools,
+            // This explicit field list is the only road into the provider, so a
+            // flag left out here never reaches BaseProvider — which is exactly how
+            // disableInternalFallback was dropped on generate() while stream()
+            // (which spreads its options) honoured it.
+            disableInternalFallback: options.disableInternalFallback,
             maxSteps: options.maxSteps,
             toolChoice: options.toolChoice,
             prepareStep: options.prepareStep,
@@ -5930,11 +5935,23 @@ Current user's request: ${currentInput}`;
             : requestedProvider
                 ? [requestedProvider]
                 : providerPriority;
+        // The caller owns fallback order (a providerFallback / modelChain caller,
+        // or a router that retries on its own): bound the walk to its first
+        // candidate so an unavailable provider surfaces as its own error instead
+        // of a silent switch. An explicit provider is already a one-element
+        // list; this only changes the "auto" and orchestrated-preference walks.
+        const providersToTry = options.disableInternalFallback === true
+            ? tryProviders.slice(0, 1)
+            : tryProviders;
+        // Caller-owned fallback never enters tryProviders: providerFallback and
+        // modelChain are walked by runWithFallbackOrchestration around the public
+        // generate() call, and a configured ModelPool is consumed by the block
+        // above. Slicing here therefore never clips a caller's own list.
         logger.debug(`[${functionTag}] Starting direct generation`, {
             requestedProvider: requestedProvider || "auto",
             preferredOrchestrated: preferredOrchestrated || "none",
-            tryProviders,
-            allowFallback: !requestedProvider || !!preferredOrchestrated,
+            tryProviders: providersToTry,
+            allowFallback: providersToTry.length > 1,
         });
         // ─── ModelPool path ──────────────────────────────────────────────────────
         // When a ModelPool is configured, source the candidate sequence from the
@@ -6080,7 +6097,7 @@ Current user's request: ${currentInput}`;
         // ─── End ModelPool path ───────────────────────────────────────────────────
         let lastError = null;
         // Try each provider in order
-        for (const providerName of tryProviders) {
+        for (const providerName of providersToTry) {
             if (options.abortSignal?.aborted) {
                 throw new DOMException("The operation was aborted", "AbortError");
             }
@@ -6437,7 +6454,7 @@ Current user's request: ${currentInput}`;
         // All providers failed
         const responseTime = Date.now() - startTime;
         logger.error(`[${functionTag}] All providers failed`, {
-            triedProviders: tryProviders,
+            triedProviders: providersToTry,
             lastError: lastError?.message,
             responseTime,
         });

package/dist/proxy/codexFallback.d.ts

@@ -6,14 +6,14 @@
  * in the native Codex proxy handler so fallback traffic follows the same pool
  * rules as a native Codex request.
  */
-import type { ClaudeRequest, CodexFallbackResult, CodexResponsesRequest } from "../types/index.js";
+import type { ClaudeRequest, CodexFallbackResult, CodexReasoningEffort, CodexResponsesRequest } from "../types/index.js";
 export declare class CodexFallbackResponseError extends Error {
     readonly status: number;
     readonly responseBody: string;
     constructor(status: number, responseBody: string);
 }
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
-export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string): CodexResponsesRequest;
+export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string, reasoningEffort?: CodexReasoningEffort): CodexResponsesRequest;
 /**
  * Parse a complete Codex Responses SSE stream before emitting Claude output.
  *

package/dist/proxy/codexFallback.js

@@ -131,7 +131,7 @@ function convertClaudeMessage(role, content) {
     return input;
 }
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
-export function convertClaudeRequestToCodex(body, model) {
+export function convertClaudeRequestToCodex(body, model, reasoningEffort) {
     const input = body.messages.flatMap((message) => convertClaudeMessage(message.role, message.content));
     const request = {
         model,
@@ -139,6 +139,9 @@ export function convertClaudeRequestToCodex(body, model) {
         stream: true,
         // ChatGPT's backend rejects requests unless this is explicitly false.
         store: false,
+        ...(reasoningEffort !== undefined
+            ? { reasoning: { effort: reasoningEffort } }
+            : {}),
     };
     const instructions = buildSystemInstructions(body);
     if (instructions) {

package/dist/proxy/proxyConfig.js

@@ -189,6 +189,18 @@ function applyAccountDefaults(account) {
         metadata: account.metadata,
     };
 }
+const CODEX_REASONING_EFFORTS = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+function isCodexReasoningEffort(value) {
+    return CODEX_REASONING_EFFORTS.some((effort) => effort === value);
+}
 /**
  * Validate the shape of a parsed proxy config.
  * Returns an array of human-readable error strings (empty = valid).
@@ -215,6 +227,28 @@ export function validateProxyConfig(config) {
     }
     if (hasRouting) {
         const routing = cfg.routing;
+        const rawFallback = routing["fallback-chain"] ?? routing.fallbackChain;
+        if (Array.isArray(rawFallback)) {
+            rawFallback.forEach((entry, index) => {
+                if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                    return;
+                }
+                const fallback = entry;
+                const effort = fallback["reasoning-effort"] !== undefined
+                    ? fallback["reasoning-effort"]
+                    : fallback.reasoningEffort;
+                if (effort === undefined) {
+                    return;
+                }
+                const field = `routing.fallback-chain[${index}].reasoning-effort`;
+                if (!isCodexReasoningEffort(effort)) {
+                    errors.push(`${field} must be one of: ${CODEX_REASONING_EFFORTS.join(", ")}`);
+                }
+                if (String(fallback.provider ?? "").trim() !== "codex") {
+                    errors.push(`${field} is only supported for provider codex`);
+                }
+            });
+        }
         const rawAccountAllowlist = routing["account-allowlist"] ?? routing.accountAllowlist;
         if (rawAccountAllowlist !== undefined) {
             if (!Array.isArray(rawAccountAllowlist)) {
@@ -350,7 +384,7 @@ function warnPlaintextApiKeys(accounts) {
  * Extracts:
  * - `strategy` ("round-robin" | "fill-first")
  * - `model-mappings` / `modelMappings` — array of {from, to, provider}
- * - `fallback-chain` / `fallbackChain` — array of {provider, model}
+ * - `fallback-chain` / `fallbackChain` — array of {provider, model, reasoningEffort?}
  * - `auto-fallback` / `autoFallback` — opt in to an unspecified provider
  * - `max-inflight-per-account` / `maxInflightPerAccount` — concurrency cap
  * - `passthroughModels` / `passthrough-models` — array of model IDs
@@ -404,7 +438,16 @@ function parseRoutingConfig(raw) {
                 logger.warn(`[proxy-config] Skipping fallback entry with empty "provider" or "model": ${JSON.stringify(e)}`);
                 return null;
             }
-            return { provider, model };
+            const effort = e["reasoning-effort"] !== undefined
+                ? e["reasoning-effort"]
+                : e.reasoningEffort;
+            return {
+                provider,
+                model,
+                ...(isCodexReasoningEffort(effort)
+                    ? { reasoningEffort: effort }
+                    : {}),
+            };
         })
             .filter((e) => e !== null);
     }

package/dist/proxy/routingPolicy.js

@@ -35,6 +35,9 @@ export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel
         attempts.push({
             provider: fallback.provider,
             model: fallback.model,
+            ...(fallback.reasoningEffort !== undefined
+                ? { reasoningEffort: fallback.reasoningEffort }
+                : {}),
             label: `${fallback.provider}/${fallback.model}`,
         });
     }

package/dist/server/routes/claudeProxyRoutes.js

@@ -3628,7 +3628,7 @@ async function executeClaudeFallbackWithRetry(args) {
  * output guarantee when Codex returns an incomplete stream.
  */
 async function executeClaudeCodexFallback(args) {
-    const { ctx, body, model, tracer, requestStartTime, logProxyBody, logFinalRequest, } = args;
+    const { ctx, body, model, reasoningEffort, tracer, requestStartTime, logProxyBody, logFinalRequest, } = args;
     const codexCtx = {
         ...ctx,
         requestId: `${ctx.requestId}:codex-fallback`,
@@ -3640,7 +3640,7 @@ async function executeClaudeCodexFallback(args) {
         },
         query: {},
         params: {},
-        body: convertClaudeRequestToCodex(body, model),
+        body: convertClaudeRequestToCodex(body, model, reasoningEffort),
         metadata: { ...ctx.metadata, "neurolink.codexFallback": true },
         // Keep the child attribution isolated until its stream has passed
         // validation. A failed Codex attempt must not look like a served request.
@@ -3827,7 +3827,7 @@ async function tryConfiguredClaudeFallbackChain(args) {
         }
         const fallbackStart = Date.now();
         try {
-            logger.always(`[proxy] fallback → ${fallback.provider}/${fallback.model}`);
+            logger.always(`[proxy] fallback → ${fallback.provider}/${fallback.model}${fallback.reasoningEffort ? ` reasoning=${fallback.reasoningEffort}` : ""}`);
             let response;
             if (fallback.provider === "codex") {
                 // Codex is a local OAuth account pool, not a generic SDK provider.
@@ -3836,6 +3836,7 @@ async function tryConfiguredClaudeFallbackChain(args) {
                     ctx,
                     body,
                     model: fallback.model,
+                    reasoningEffort: fallback.reasoningEffort,
                     tracer,
                     requestStartTime,
                     logProxyBody,

package/dist/types/codex.d.ts

@@ -138,12 +138,17 @@ export type CodexResponsesInputItem = {
     call_id: string;
     output: string;
 };
+/** Codex reasoning settings; supported levels depend on the selected model. */
+export type CodexReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 /** Request shape used to bridge Anthropic Messages traffic to Codex Responses. */
 export type CodexResponsesRequest = {
     model: string;
     input: CodexResponsesInputItem[];
     stream: true;
     store: false;
+    reasoning?: {
+        effort: CodexReasoningEffort;
+    };
     instructions?: string;
     tools?: Array<{
         type: "function";

package/dist/types/generate.d.ts

@@ -459,6 +459,19 @@ export type GenerateOptions = {
     skipToolPromptInjection?: boolean;
     /** Disable tool result caching for this request (overrides global mcp.cache.enabled) */
     disableToolCache?: boolean;
+    /**
+     * Disable NeuroLink's internal fallback for this request: the static
+     * provider-priority walk that runs when no provider was requested, and the
+     * catalog model-fallback walk a provider performs when its model is
+     * rejected as invalid. Callers that own fallback order (a caller-supplied
+     * `providerFallback` / `modelChain`, or a router that retries on its own,
+     * as the Claude proxy does for its streams) set this so an invalid model
+     * or an unavailable provider surfaces as exactly that.
+     * A configured `ModelPool`, `providerFallback` and `modelChain` are the
+     * caller's own fallback and are unaffected. Mirrors the same flag on
+     * `StreamOptions`.
+     */
+    disableInternalFallback?: boolean;
     /** Maximum number of tool execution steps (default: 200) */
     maxSteps?: number;
     /**
@@ -1204,6 +1217,14 @@ export type TextGenerationOptions = {
     excludeTools?: string[];
     /** Disable tool result caching for this request (overrides global mcp.cache.enabled) */
     disableToolCache?: boolean;
+    /**
+     * Caller owns fallback order. Read in two places: `directProviderGeneration`
+     * bounds its static provider-priority walk to one candidate, and
+     * `BaseProvider.generate()` skips the catalog model-fallback walk so an
+     * invalid-model error surfaces as itself. Mapped from
+     * `GenerateOptions.disableInternalFallback`.
+     */
+    disableInternalFallback?: boolean;
     /**
      * Tool choice configuration for the generation.
      * Controls whether and which tools the model must call.

package/dist/types/proxy.d.ts

@@ -1392,6 +1392,7 @@ export type ClaudeProxyModelTier = "opus" | "sonnet" | "haiku" | "other";
 export type ProxyTranslationAttempt = {
     provider?: string;
     model?: string;
+    reasoningEffort?: FallbackEntry["reasoningEffort"];
     label: string;
 };
 /** Ordered plan of provider attempts for a proxy request. */

package/dist/types/subscription.d.ts

@@ -5,6 +5,7 @@
  * and usage tracking for Anthropic API access.
  */
 import type { StoredOAuthTokens } from "./auth.js";
+import type { CodexReasoningEffort } from "./codex.js";
 export type { StoredOAuthTokens, TokenRefresher, TokenStorageData, StoredProviderTokens, } from "./auth.js";
 /**
  * Claude subscription tier levels
@@ -979,6 +980,8 @@ export type ModelMapping = {
 export type FallbackEntry = {
     provider: string;
     model: string;
+    /** Explicit Codex fallback effort. Omit to use the upstream default. */
+    reasoningEffort?: CodexReasoningEffort;
 };
 /** Full proxy routing config */
 export type ProxyRoutingConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.2",
+  "version": "12.12.4",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {