@juspay/neurolink 12.12.0 → 12.12.2

package/dist/core/nativeGenerateLoop.js

@@ -13,6 +13,7 @@
  * share this: the v3 result shape (`content` parts, `finishReason`, `usage`) is
  * the same across Anthropic, the OpenAI-compatible family and SageMaker.
  */
+import { logger } from "../utils/logger.js";
 import { guardToolExecutor } from "./toolExecutionGuards.js";
 /**
  * Narrow a model handle to the delegating shape this loop drives.
@@ -104,10 +105,19 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
     let steps = 0;
     // One bounded recovery re-ask per turn; see the empty-tool-calls branch.
     let reasked = false;
+    // True only while the NEXT step is the recovery re-ask. `reasked` stays set
+    // for the rest of the turn, so it cannot distinguish "this step is the
+    // re-ask" from "the re-ask already happened" — and degrading a later,
+    // unrelated failure would swallow a real error.
+    let reaskPending = false;
+    // The turn as it stood before the re-ask. The re-ask is a bonus request on
+    // top of a call that already produced a result, so if it fails the honest
+    // answer is that result — not a thrown turn.
+    let preReask;
     const hasTools = Boolean(args.tools && args.tools.length > 0);
     for (let step = 0; step < args.maxSteps; step++) {
         steps = step + 1;
-        const res = await args.runStep(() => args.doGenerate({
+        const runThisStep = () => args.runStep(() => args.doGenerate({
             prompt: args.conversation,
             ...(args.tools && args.tools.length > 0 ? { tools: args.tools } : {}),
             // The v3 call option is an OBJECT — `{ type: "none" }`. Passing the
@@ -120,7 +130,9 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 : args.toolChoice !== undefined
                     ? { toolChoice: args.toolChoice }
                     : {}),
-            ...(args.responseFormat ? { responseFormat: args.responseFormat } : {}),
+            ...(args.responseFormat
+                ? { responseFormat: args.responseFormat }
+                : {}),
             ...(args.providerOptions
                 ? { providerOptions: args.providerOptions }
                 : {}),
@@ -132,6 +144,30 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 : {}),
             ...(args.abortSignal ? { abortSignal: args.abortSignal } : {}),
         }));
+        let res;
+        try {
+            res = await runThisStep();
+        }
+        catch (stepError) {
+            // Ported from GenerationHandler.recoverEmptyToolCallsFinish's catch: a
+            // failed re-ask hands back the turn that already succeeded rather than
+            // turning a degraded turn into a thrown one. The native port made the
+            // re-ask a `continue`, so the failure surfaced from the NEXT step's
+            // doGenerate and propagated instead.
+            if (reaskPending && preReask) {
+                logger.warn("toolChoice: none re-ask failed; returning the original result", {
+                    error: stepError instanceof Error
+                        ? stepError.message
+                        : String(stepError),
+                });
+                text = preReask.text;
+                finishReason = preReask.finishReason;
+                rawFinishReason = preReask.rawFinishReason;
+                break;
+            }
+            throw stepError;
+        }
+        reaskPending = false;
         const parts = asParts(res.content);
         // Each step REPLACES the text rather than appending: the final step's
         // answer is the turn's answer, matching what generateText reported.
@@ -177,6 +213,8 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 step + 1 < args.maxSteps;
             if (emptyToolCallsFinish) {
                 reasked = true;
+                reaskPending = true;
+                preReask = { text, finishReason, rawFinishReason };
                 args.conversation.push({ role: "assistant", content: parts });
                 continue;
             }

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -20,9 +20,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { LanguageModel, OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatResponseFormat, OpenAICompatStreamLifecycleListeners, Schema, EnhancedGenerateResult, TextGenerationOptions, ValidationSchema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
-/**
- * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
- */
 export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider {
     protected config: {
         baseURL: string;

package/dist/providers/openaiChatCompletionsBase.js

@@ -36,6 +36,7 @@ import { resolveRequestKind } from "../core/resolveRequestKind.js";
 import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
 import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
+import { coerceJsonToSchema, schemaAccepts } from "../utils/json/coerce.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
@@ -52,6 +53,19 @@ const WINDOW_FIT_MARGIN_TOKENS = 512;
 /**
  * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
  */
+/**
+ * Did the model's text yield an object the caller's schema accepts?
+ *
+ * This is the trigger for the prompt-side structured-output fallback. It asks
+ * the question the ai-package's structured-output parser used to ask by
+ * throwing: did the native `response_format` attempt actually produce the
+ * object. A schema we cannot validate with accepts everything, so an unknown
+ * schema never forces a pointless second request.
+ */
+const yieldsSchemaValidObject = (text, schema) => {
+    const coerced = coerceJsonToSchema(text, schema);
+    return coerced !== null && schemaAccepts(schema, coerced.structuredData);
+};
 export class OpenAIChatCompletionsProvider extends BaseProvider {
     config;
     resolvedModel;
@@ -855,14 +869,42 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             logger.warn(`[${this.providerName}] provider rejected response_format — retrying with the schema in the system prompt`, { provider: this.providerName, model: modelId });
             loop = await runLoop(appendJsonSchemaInstruction(conversation, responseFormat.schema), undefined);
         }
+        // The vendor can also IGNORE `response_format` and answer in prose without
+        // erroring at all — GMI Cloud's MiniMax endpoint does exactly that, and it
+        // is the case the fallback was written for. On the ai-package path the
+        // structured-output parser threw on the unparseable answer, so the catch
+        // above was reached; the native loop has no such parser, so the silent
+        // case sailed through and handed the caller prose. Same recovery, keyed on
+        // the result rather than on an exception.
+        if (responseFormat !== undefined &&
+            options.schema !== undefined &&
+            !yieldsSchemaValidObject(loop.text, options.schema)) {
+            logger.warn(`[${this.providerName}] response_format did not yield a schema-valid object — retrying with the schema in the system prompt`, { provider: this.providerName, model: modelId });
+            loop = await runLoop(appendJsonSchemaInstruction(conversation, responseFormat.schema), undefined);
+        }
         const { text, finishReason, toolsUsed } = loop;
         const inputTokens = loop.inputTokens;
         const outputTokens = loop.outputTokens;
+        // stopReason / stepsUsed parity with the other native loops (Vertex
+        // Gemini / Claude / Bedrock) and with the ai-package path this replaced.
+        // Without them a consumer cannot tell a completed turn from one the step
+        // cap truncated: the turn that ends on a `tool-calls` finish with the
+        // budget spent is exactly the case the caller configured `maxSteps` to
+        // bound, and reporting it as a plain completion hides that.
+        const stepsUsed = loop.steps;
+        const stopReason = stepsUsed >= (options.maxSteps || DEFAULT_MAX_STEPS) &&
+            finishReason === "tool-calls"
+            ? "step-cap"
+            : finishReason === "error"
+                ? "provider-error"
+                : "completed";
         const enhanced = {
             content: text,
             provider: this.providerName,
             model: modelId,
             finishReason,
+            stopReason,
+            stepsUsed,
             usage: {
                 input: inputTokens,
                 output: outputTokens,

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -55,7 +55,7 @@ declare function resetEpochToMs(resetEpoch: number | undefined, now: number): nu
  * burst / acceleration limit) is transient: honor retry-after as a floor,
  * allow a couple of jittered same-account retries, then a short cooldown.
  */
-declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: number, now: number, unifiedStatus?: string | undefined, policy?: ProxyOveragePolicy): AccountCooldownPlan;
+declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: number, now: number, unifiedStatus?: string | undefined, policy?: ProxyOveragePolicy, requestedModel?: string): AccountCooldownPlan;
 /**
  * Reconcile quota-backed cooldowns against a fresh provider observation. A
  * rejected window parks the account until its reset; an allowed observation for

package/dist/server/routes/claudeProxyRoutes.js

@@ -553,6 +553,45 @@ function clampCooldownUntil(untilMs, now, reason) {
     const ceiling = Math.min(MAX_COOLDOWN_MS, (reason && MAX_COOLDOWN_MS_BY_REASON[reason]) ?? MAX_COOLDOWN_MS);
     return Math.min(Math.max(untilMs, now + MIN_COOLDOWN_MS), now + ceiling);
 }
+function isAllowedQuotaStatus(status) {
+    return status?.trim().toLowerCase() === "allowed";
+}
+function isScopedWindowExhausted(window, now) {
+    if (!window || resetEpochToMs(window.resetsAt, now) === undefined) {
+        return false;
+    }
+    return (window.status?.trim().toLowerCase() === "rejected" ||
+        (window.used ?? 0) >= 1);
+}
+/**
+ * Anthropic represents some model-specific limits through a rejected top-level
+ * unified status. The scope window is the authoritative discriminator: only
+ * treat that response as model-scoped when both account-wide windows remain
+ * explicitly allowed and the requested model's window is exhausted.
+ */
+function getScopedOnlyExhaustion(quota, requestedModel, now, policy = overagePolicy) {
+    if (!quota ||
+        !requestedModel ||
+        !isAllowedQuotaStatus(quota.sessionStatus) ||
+        !isAllowedQuotaStatus(quota.weeklyStatus) ||
+        isOverageUsable(quota, policy)) {
+        return null;
+    }
+    const scopedWindow = matchScopedQuotaWindow(quota, requestedModel, now);
+    return isScopedWindowExhausted(scopedWindow, now) ? scopedWindow : null;
+}
+function hasScopedOnlyExhaustion(quota, now, policy = overagePolicy) {
+    if (!isAllowedQuotaStatus(quota.sessionStatus) ||
+        !isAllowedQuotaStatus(quota.weeklyStatus) ||
+        isOverageUsable(quota, policy)) {
+        return false;
+    }
+    return (quota.windows ?? []).some((window) => window.kind === "weekly_scoped" &&
+        typeof window.scopeModel === "string" &&
+        now - scopedWindowObservedAt(quota, window) <=
+            QUOTA_SNAPSHOT_FRESHNESS_MS &&
+        isScopedWindowExhausted(window, now));
+}
 /**
  * Decide how to cool an account after a genuine (non-anti-abuse) 429.
  *
@@ -567,13 +606,14 @@ function clampCooldownUntil(untilMs, now, reason) {
  * burst / acceleration limit) is transient: honor retry-after as a floor,
  * allow a couple of jittered same-account retries, then a short cooldown.
  */
-function planCooldownFor429(quota, retryAfterMs, now, unifiedStatus = quota?.unifiedStatus, policy = overagePolicy) {
+function planCooldownFor429(quota, retryAfterMs, now, unifiedStatus = quota?.unifiedStatus, policy = overagePolicy, requestedModel) {
     // Weekly exhaustion takes precedence — it's the longest, hardest ceiling.
     if (quota && quota.weeklyStatus === "rejected") {
         const reset = resetEpochToMs(quota.weeklyResetAt, now) ??
             (retryAfterMs > 0 ? now + retryAfterMs : now + DEFAULT_COOLING_PERIOD_MS);
         return {
             reason: "weekly",
+            scope: "account",
             coolingUntil: clampCooldownUntil(reset, now, "weekly"),
             rotateImmediately: true,
         };
@@ -584,10 +624,25 @@ function planCooldownFor429(quota, retryAfterMs, now, unifiedStatus = quota?.uni
             (retryAfterMs > 0 ? now + retryAfterMs : now + DEFAULT_COOLING_PERIOD_MS);
         return {
             reason: "session",
+            scope: "account",
             coolingUntil: clampCooldownUntil(reset, now, "session"),
             rotateImmediately: true,
         };
     }
+    const scopedOnlyExhaustion = getScopedOnlyExhaustion(quota, requestedModel, now, policy);
+    if (scopedOnlyExhaustion) {
+        const reset = resetEpochToMs(scopedOnlyExhaustion.resetsAt, now) ??
+            (retryAfterMs > 0 ? now + retryAfterMs : now + DEFAULT_HARD_COOLDOWN_MS);
+        return {
+            // Keep the provider's top-level classification for logs, but do not
+            // persist it as an account cooldown. The scoped quota window gates only
+            // this model on subsequent requests.
+            reason: "unified",
+            scope: "model",
+            coolingUntil: reset,
+            rotateImmediately: true,
+        };
+    }
     // Anthropic may reject the authoritative top-level unified limit while both
     // 5h and 7d sub-window statuses still say "allowed". Treating this as a
     // transient burst retries a known-exhausted account and delays failover.
@@ -595,6 +650,7 @@ function planCooldownFor429(quota, retryAfterMs, now, unifiedStatus = quota?.uni
         const reset = retryAfterMs > 0 ? now + retryAfterMs : now + DEFAULT_HARD_COOLDOWN_MS;
         return {
             reason: "unified",
+            scope: "account",
             coolingUntil: clampCooldownUntil(reset, now, "unified"),
             rotateImmediately: true,
         };
@@ -605,6 +661,7 @@ function planCooldownFor429(quota, retryAfterMs, now, unifiedStatus = quota?.uni
     const base = retryAfterMs > 0 ? retryAfterMs : DEFAULT_COOLING_PERIOD_MS;
     return {
         reason: "transient",
+        scope: "account",
         coolingUntil: now +
             Math.max(MIN_COOLDOWN_MS, Math.min(base, TRANSIENT_MAX_COOLDOWN_MS)),
         rotateImmediately: false,
@@ -622,6 +679,7 @@ function minutesUntil(untilMs, now) {
  */
 function reconcileCooldownFromQuota(state, quota, now, policy = overagePolicy) {
     const overageAvailable = isOverageUsable(quota, policy);
+    const scopedOnlyExhaustion = hasScopedOnlyExhaustion(quota, now, policy);
     let until;
     let reason;
     if (quota.weeklyStatus === "rejected") {
@@ -646,7 +704,8 @@ function reconcileCooldownFromQuota(state, quota, now, policy = overagePolicy) {
     }
     else if (until === undefined &&
         quota.unifiedStatus === "rejected" &&
-        !overageAvailable) {
+        !overageAvailable &&
+        !scopedOnlyExhaustion) {
         until = now + DEFAULT_HARD_COOLDOWN_MS;
         reason = "unified";
     }
@@ -656,7 +715,7 @@ function reconcileCooldownFromQuota(state, quota, now, policy = overagePolicy) {
                 (state.coolingReason === "session" &&
                     quota.sessionStatus === "allowed") ||
                 (state.coolingReason === "unified" &&
-                    quota.unifiedStatus === "allowed"));
+                    (quota.unifiedStatus === "allowed" || scopedOnlyExhaustion)));
         if (recoveredQuotaCooldown && state.coolingUntil) {
             const previousCoolingUntil = state.coolingUntil;
             const previousCoolingReason = state.coolingReason;
@@ -4348,13 +4407,14 @@ async function handleAnthropicStreamingSuccessResponse(args) {
         const quota = parseQuotaHeaders(responseHeaders, { model: body.model });
         const now = Date.now();
         if (isRateLimit) {
-            const cooldownPlan = planCooldownFor429(quota, parseRetryAfterMs(responseHeaders["retry-after"] ?? null), now, getUnifiedRateLimitStatus(responseHeaders));
+            const cooldownPlan = planCooldownFor429(quota, parseRetryAfterMs(responseHeaders["retry-after"] ?? null), now, getUnifiedRateLimitStatus(responseHeaders), overagePolicy, typeof body.model === "string" ? body.model : undefined);
             accountState.quota = quota
                 ? mergeQuotaSnapshot(accountState.quota, quota)
                 : accountState.quota;
             const rateLimitKind = cooldownPlan.reason === "transient" ? "transient" : "quota";
-            if (!accountState.coolingUntil ||
-                cooldownPlan.coolingUntil > accountState.coolingUntil) {
+            if (cooldownPlan.scope === "account" &&
+                (!accountState.coolingUntil ||
+                    cooldownPlan.coolingUntil > accountState.coolingUntil)) {
                 accountState.coolingUntil = cooldownPlan.coolingUntil;
                 accountState.coolingReason = cooldownPlan.reason;
                 await saveAccountCooldown(account.key, cooldownPlan.coolingUntil, cooldownPlan.reason).catch(() => {
@@ -5132,7 +5192,7 @@ async function handleAnthropicAuthRetry(args) {
                 if (retryQuota429) {
                     accountState.quota = mergeQuotaSnapshot(accountState.quota, retryQuota429);
                 }
-                const retryPlan = planCooldownFor429(retryQuota429, parseRetryAfterMs(retryRespHeaders["retry-after"] ?? null), nowRetry, getUnifiedRateLimitStatus(retryRespHeaders));
+                const retryPlan = planCooldownFor429(retryQuota429, parseRetryAfterMs(retryRespHeaders["retry-after"] ?? null), nowRetry, getUnifiedRateLimitStatus(retryRespHeaders), overagePolicy, typeof body.model === "string" ? body.model : undefined);
                 const rateLimitKind = retryPlan.reason === "transient" ? "transient" : "quota";
                 recordAttemptError(account.label, account.type, retryStatus, rateLimitKind);
                 retryLogAttempt(429, "rate_limit_error", retryBody, {
@@ -5140,8 +5200,9 @@ async function handleAnthropicAuthRetry(args) {
                     rateLimitKind,
                     cooldownReason: retryPlan.reason,
                 });
-                if (!accountState.coolingUntil ||
-                    retryPlan.coolingUntil > accountState.coolingUntil) {
+                if (retryPlan.scope === "account" &&
+                    (!accountState.coolingUntil ||
+                        retryPlan.coolingUntil > accountState.coolingUntil)) {
                     accountState.coolingUntil = retryPlan.coolingUntil;
                     accountState.coolingReason = retryPlan.reason;
                 }
@@ -5150,9 +5211,11 @@ async function handleAnthropicAuthRetry(args) {
                         // Non-fatal: routing already has the in-memory snapshot.
                     });
                 }
-                await saveAccountCooldown(account.key, accountState.coolingUntil ?? retryPlan.coolingUntil, accountState.coolingReason ?? retryPlan.reason).catch(() => {
-                    // Non-fatal: routing already has the in-memory cooldown.
-                });
+                if (retryPlan.scope === "account") {
+                    await saveAccountCooldown(account.key, accountState.coolingUntil ?? retryPlan.coolingUntil, accountState.coolingReason ?? retryPlan.reason).catch(() => {
+                        // Non-fatal: routing already has the in-memory cooldown.
+                    });
+                }
                 advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
                 break;
             }
@@ -6149,10 +6212,10 @@ async function fetchAnthropicAccountResponse(args) {
         const now = Date.now();
         const quota = parseQuotaHeaders(errRespHeaders, { model: requestedModel });
         const unifiedStatus = getUnifiedRateLimitStatus(errRespHeaders);
-        const cooldownPlan = planCooldownFor429(quota, retryAfterMs, now, unifiedStatus);
+        const cooldownPlan = planCooldownFor429(quota, retryAfterMs, now, unifiedStatus, overagePolicy, requestedModel);
         const rateLimitKind = cooldownPlan.reason === "transient" ? "transient" : "quota";
         recordAttemptError(account.label, account.type, 429, rateLimitKind);
-        logger.always(`[proxy] ← 429 account=${account.label} reason=${cooldownPlan.reason} ` +
+        logger.always(`[proxy] ← 429 account=${account.label} reason=${cooldownPlan.reason} scope=${cooldownPlan.scope} ` +
             `retry-after=${retryAfterMs}ms 5h-status=${errRespHeaders["anthropic-ratelimit-unified-5h-status"] ?? "unknown"} ` +
             `7d-status=${errRespHeaders["anthropic-ratelimit-unified-7d-status"] ?? "unknown"} ` +
             `unified-status=${unifiedStatus ?? "unknown"} ` +
@@ -6507,14 +6570,15 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                         // Publish the cooldown before retrying so requests arriving behind
                         // this one skip the throttled account instead of joining the burst.
                         let cooldownExtended = false;
-                        if (!accountState.coolingUntil ||
-                            plan.coolingUntil > accountState.coolingUntil) {
+                        if (plan.scope === "account" &&
+                            (!accountState.coolingUntil ||
+                                plan.coolingUntil > accountState.coolingUntil)) {
                             accountState.coolingUntil = plan.coolingUntil;
                             accountState.coolingReason = plan.reason;
                             cooldownExtended = true;
                         }
-                        if (cooldownExtended) {
-                            await saveAccountCooldown(account.key, accountState.coolingUntil, accountState.coolingReason ?? plan.reason).catch(() => {
+                        if (cooldownExtended && plan.scope === "account") {
+                            await saveAccountCooldown(account.key, accountState.coolingUntil ?? plan.coolingUntil, accountState.coolingReason ?? plan.reason).catch(() => {
                                 // Non-fatal: routing already has the in-memory cooldown.
                             });
                         }

package/dist/types/proxy.d.ts

@@ -856,7 +856,13 @@ export type PreparedAnthropicAccountAttempt = {
 export type RateLimitCoolingReason = Exclude<AccountCoolingReason, "auth">;
 export type AccountCooldownPlan = {
     reason: RateLimitCoolingReason;
-    /** Epoch-ms until which the account should not be used. */
+    /**
+     * Whether this limit applies to every request on the account or only to the
+     * requested model. Model scope must never be persisted as an account
+     * cooldown; the quota window itself remains the routing evidence.
+     */
+    scope: "account" | "model";
+    /** Epoch-ms until which the limiting window is expected to recover. */
     coolingUntil: number;
     /** When true (unified/5h/7d rejected), rotate immediately — retrying the
      *  same account is futile until its window resets. When false (transient

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.0",
+  "version": "12.12.2",
   "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": {