@juspay/neurolink 9.54.1 → 9.54.3

package/dist/providers/openRouter.js

@@ -252,6 +252,7 @@ export class OpenRouterProvider extends BaseProvider {
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/providers/openaiCompatible.js

@@ -195,6 +195,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {

package/dist/proxy/routingPolicy.d.ts

@@ -1,33 +1,43 @@
-import type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
-export type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, ProxyTranslationAttempt, ProxyTranslationPlan, };
+import type { ClaudeProxyModelTier, CooldownSkippedAccount, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
+export type { ClaudeProxyModelTier, ProxyTranslationAttempt, ProxyTranslationPlan, };
 export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
-export declare function classifyClaudeProxyRequest(requestedModel: string, parsed: ParsedClaudeRequest): ClaudeProxyRequestProfile;
-export declare function getRequestClassCooldownKey(profile: ClaudeProxyRequestProfile): string;
-export declare function getModelTierCooldownKey(profile: ClaudeProxyRequestProfile): string;
-export declare function evaluateFallbackEligibility(profile: ClaudeProxyRequestProfile, candidate: {
-    provider?: string;
-    model?: string;
-}): FallbackEligibilityDecision;
+/**
+ * Build a translation plan for a Claude-compatible proxy request.
+ * The plan lists the primary provider followed by eligible fallback targets.
+ * All configured fallback entries are always eligible — no contract-based gating.
+ * When no fallback chain is configured, an "auto-provider" entry is appended.
+ */
 export declare function buildProxyTranslationPlan(primary: {
     provider: string;
     model?: string;
-}, fallbackChain: FallbackEntry[], requestedModel: string, parsed: ParsedClaudeRequest): ProxyTranslationPlan;
-export declare function summarizeSkippedFallbacks(plan: Pick<ProxyTranslationPlan, "profile" | "skipped">): string | null;
-export declare function getActiveCooldownScope(state: RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): CooldownScope | null;
+}, fallbackChain: FallbackEntry[], requestedModel: string, _parsed: ParsedClaudeRequest): ProxyTranslationPlan;
+/**
+ * Check whether an account is currently cooling down.
+ * Returns the cooldown timestamp if active, null otherwise.
+ */
+export declare function getAccountCooldownUntil(state: RuntimeAccountState, now?: number): number | null;
+/**
+ * Partition accounts into eligible (no cooldown) and skipped (cooling down).
+ */
 export declare function partitionAccountsByCooldown<T extends {
     key: string;
-}>(accounts: T[], getState: (account: T) => RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): {
+}>(accounts: T[], getState: (account: T) => RuntimeAccountState, now?: number): {
     eligible: T[];
     skipped: CooldownSkippedAccount<T>[];
 };
-export declare function applyRateLimitCooldownScope(args: {
+/**
+ * Apply a rate-limit cooldown to an account.
+ * Uses simple exponential backoff with a floor and cap.
+ */
+export declare function applyRateLimitCooldown(args: {
     state: RuntimeAccountState;
-    profile: ClaudeProxyRequestProfile;
     retryAfterMs?: number;
     now?: number;
     capMs: number;
 }): {
     backoffMs: number;
-    requestClassKey: string;
-    modelTierKey: string;
 };
+/**
+ * Clear cooldown state for an account after a successful request.
+ */
+export declare function clearAccountCooldown(state: RuntimeAccountState): void;

package/dist/proxy/routingPolicy.js

@@ -1,9 +1,4 @@
-const STREAMING_CONVERSATIONAL_TOOL_THRESHOLD = 4;
-const STRONG_TOOL_FIDELITY_THRESHOLD = 8;
-const HIGH_TOOL_COUNT_THRESHOLD = 24;
 const DEFAULT_COOLDOWN_FLOOR_MS = 1_000;
-const HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS = 10_000;
-const HIGH_FIDELITY_COOLDOWN_FLOOR_MS = 300_000;
 export function inferClaudeProxyModelTier(modelName) {
     const normalized = modelName.toLowerCase();
     if (normalized.includes("opus")) {
@@ -17,101 +12,13 @@ export function inferClaudeProxyModelTier(modelName) {
     }
     return "other";
 }
-function detectToolHistory(parsed) {
-    return parsed.conversationMessages.some((message) => {
-        return (message.content.includes("[tool_use:") ||
-            message.content.includes("[tool_result:"));
-    });
-}
-export function classifyClaudeProxyRequest(requestedModel, parsed) {
-    const toolCount = Object.keys(parsed.tools).length;
-    const hasImages = parsed.images.length > 0;
-    const hasThinking = !!parsed.thinkingConfig?.enabled;
-    const hasToolHistory = detectToolHistory(parsed);
-    const requiresSpecificTool = !!parsed.toolChoiceName;
-    const requiresToolUse = parsed.toolChoice === "required" || requiresSpecificTool || hasToolHistory;
-    const requiresStrongToolFidelity = toolCount >= STRONG_TOOL_FIDELITY_THRESHOLD ||
-        requiresSpecificTool ||
-        hasToolHistory;
-    const isHighToolCountNonStream = !parsed.stream && toolCount >= HIGH_TOOL_COUNT_THRESHOLD;
-    const isStreamingConversational = parsed.stream &&
-        !hasImages &&
-        toolCount <= STREAMING_CONVERSATIONAL_TOOL_THRESHOLD &&
-        !requiresStrongToolFidelity;
-    const classes = [];
-    if (hasImages) {
-        classes.push("multimodal");
-    }
-    if (isHighToolCountNonStream) {
-        classes.push("high-tool-count-non-stream-structured");
-    }
-    if (requiresStrongToolFidelity) {
-        classes.push("strong-tool-fidelity");
-    }
-    if (isStreamingConversational) {
-        classes.push("streaming-conversational");
-    }
-    if (classes.length === 0) {
-        classes.push("standard");
-    }
-    return {
-        requestedModel,
-        modelTier: inferClaudeProxyModelTier(requestedModel),
-        primaryClass: classes[0],
-        classes,
-        stream: parsed.stream,
-        toolCount,
-        hasImages,
-        hasThinking,
-        hasToolHistory,
-        requiresToolUse,
-        requiresSpecificTool,
-        requiresStrongToolFidelity,
-        isHighToolCountNonStream,
-        isStreamingConversational,
-        isMultimodal: hasImages,
-    };
-}
-export function getRequestClassCooldownKey(profile) {
-    return `${profile.primaryClass}:${profile.requestedModel.toLowerCase()}`;
-}
-export function getModelTierCooldownKey(profile) {
-    return profile.modelTier;
-}
-function getQualityGuardReason(profile, provider, _model) {
-    // Only gate auto-provider fallback (no explicit provider).
-    // Configured fallback-chain entries are always allowed through —
-    // let them attempt the request and fail naturally if the provider
-    // cannot handle it.
-    if (!provider) {
-        if (profile.modelTier === "opus" ||
-            profile.requiresStrongToolFidelity ||
-            profile.isHighToolCountNonStream) {
-            return "auto-provider fallback is disabled for requests that require contract preservation";
-        }
-        return null;
-    }
-    return null;
-}
-export function evaluateFallbackEligibility(profile, candidate) {
-    const policyBlockReason = getQualityGuardReason(profile, candidate.provider, candidate.model);
-    if (policyBlockReason) {
-        return {
-            provider: candidate.provider,
-            model: candidate.model,
-            eligible: false,
-            reason: policyBlockReason,
-        };
-    }
-    return {
-        provider: candidate.provider,
-        model: candidate.model,
-        eligible: true,
-        reason: "eligible",
-    };
-}
-export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel, parsed) {
-    const profile = classifyClaudeProxyRequest(requestedModel, parsed);
+/**
+ * Build a translation plan for a Claude-compatible proxy request.
+ * The plan lists the primary provider followed by eligible fallback targets.
+ * All configured fallback entries are always eligible — no contract-based gating.
+ * When no fallback chain is configured, an "auto-provider" entry is appended.
+ */
+export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel, _parsed) {
     const attempts = [
         {
             provider: primary.provider,
@@ -119,141 +26,78 @@ export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel
             label: `${primary.provider}/${primary.model ?? "unknown"}`,
         },
     ];
-    const skipped = [];
     for (const fallback of fallbackChain) {
         if (fallback.provider === primary.provider &&
             fallback.model === primary.model) {
             continue;
         }
-        const decision = evaluateFallbackEligibility(profile, fallback);
-        if (!decision.eligible) {
-            skipped.push(decision);
-            continue;
-        }
         attempts.push({
             provider: fallback.provider,
             model: fallback.model,
             label: `${fallback.provider}/${fallback.model}`,
         });
     }
-    if (fallbackChain.length === 0) {
-        const autoDecision = evaluateFallbackEligibility(profile, {});
-        if (autoDecision.eligible) {
-            attempts.push({ label: "auto-provider" });
-        }
-        else {
-            skipped.push(autoDecision);
-        }
+    // Append auto-provider when no configured fallback chain exists,
+    // or when all configured entries were deduped (same as primary).
+    if (fallbackChain.length === 0 || attempts.length === 1) {
+        attempts.push({ label: "auto-provider" });
     }
     return {
-        profile,
+        requestedModel,
+        modelTier: inferClaudeProxyModelTier(requestedModel),
         attempts,
-        skipped,
+        skipped: [],
     };
 }
-export function summarizeSkippedFallbacks(plan) {
-    if (plan.skipped.length === 0) {
-        return null;
-    }
-    const summary = plan.skipped
-        .map((decision) => {
-        const label = decision.provider
-            ? `${decision.provider}/${decision.model ?? "unknown"}`
-            : "auto-provider";
-        return `${label}: ${decision.reason}`;
-    })
-        .join("; ");
-    return `Fallback policy preserved the requested ${plan.profile.primaryClass} contract by skipping ineligible targets. ${summary}`;
-}
-export function getActiveCooldownScope(state, profile, now = Date.now()) {
-    let longest = null;
-    const requestClassKey = getRequestClassCooldownKey(profile);
-    const requestClassUntil = state.requestClassCooldowns?.[requestClassKey] ?? undefined;
-    if (requestClassUntil && requestClassUntil > now) {
-        longest = {
-            scope: "request_class",
-            key: requestClassKey,
-            until: requestClassUntil,
-        };
-    }
-    const modelTierKey = getModelTierCooldownKey(profile);
-    const modelTierUntil = state.modelTierCooldowns?.[modelTierKey] ?? undefined;
-    if (modelTierUntil &&
-        modelTierUntil > now &&
-        modelTierUntil > (longest?.until ?? 0)) {
-        longest = {
-            scope: "model_tier",
-            key: modelTierKey,
-            until: modelTierUntil,
-        };
-    }
-    if (state.coolingUntil &&
-        state.coolingUntil > now &&
-        state.coolingUntil > (longest?.until ?? 0)) {
-        longest = {
-            scope: "generic",
-            key: "generic",
-            until: state.coolingUntil,
-        };
+// ---------------------------------------------------------------------------
+// Simple per-account cooldown
+// ---------------------------------------------------------------------------
+/**
+ * Check whether an account is currently cooling down.
+ * Returns the cooldown timestamp if active, null otherwise.
+ */
+export function getAccountCooldownUntil(state, now = Date.now()) {
+    if (state.coolingUntil && state.coolingUntil > now) {
+        return state.coolingUntil;
     }
-    return longest;
+    return null;
 }
-export function partitionAccountsByCooldown(accounts, getState, profile, now = Date.now()) {
+/**
+ * Partition accounts into eligible (no cooldown) and skipped (cooling down).
+ */
+export function partitionAccountsByCooldown(accounts, getState, now = Date.now()) {
     const eligible = [];
     const skipped = [];
     for (const account of accounts) {
-        const cooldown = getActiveCooldownScope(getState(account), profile, now);
-        if (cooldown) {
-            skipped.push({ account, cooldown });
+        const state = getState(account);
+        const until = getAccountCooldownUntil(state, now);
+        if (until !== null) {
+            skipped.push({
+                account,
+                cooldown: { until, backoffLevel: state.backoffLevel },
+            });
             continue;
         }
         eligible.push(account);
     }
-    return {
-        eligible,
-        skipped,
-    };
+    return { eligible, skipped };
 }
-export function applyRateLimitCooldownScope(args) {
+/**
+ * Apply a rate-limit cooldown to an account.
+ * Uses simple exponential backoff with a floor and cap.
+ */
+export function applyRateLimitCooldown(args) {
     const now = args.now ?? Date.now();
-    const requestClassKey = getRequestClassCooldownKey(args.profile);
-    const modelTierKey = getModelTierCooldownKey(args.profile);
-    const rcBackoffLevels = args.state.requestClassBackoffLevels ?? {};
-    const mtBackoffLevels = args.state.modelTierBackoffLevels ?? {};
-    const scopedBackoffLevel = Math.max(rcBackoffLevels[requestClassKey] ?? 0, mtBackoffLevels[modelTierKey] ?? 0);
-    // High-tool-count-non-stream gets its own (lower) floor so that requests
-    // recover faster once proper OAuth betas are forwarded. Check it first
-    // because every >=24-tool request also satisfies requiresStrongToolFidelity
-    // (threshold 8), which would otherwise shadow this branch.
-    const floorMs = args.profile.isHighToolCountNonStream
-        ? HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS
-        : args.profile.modelTier === "opus" ||
-            args.profile.requiresStrongToolFidelity
-            ? HIGH_FIDELITY_COOLDOWN_FLOOR_MS
-            : DEFAULT_COOLDOWN_FLOOR_MS;
-    const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, floorMs);
-    const backoffMs = Math.min(baseCooldownMs * 2 ** scopedBackoffLevel, args.capMs);
-    const until = now + backoffMs;
-    args.state.requestClassCooldowns = {
-        ...(args.state.requestClassCooldowns ?? {}),
-        [requestClassKey]: Math.max(args.state.requestClassCooldowns?.[requestClassKey] ?? 0, until),
-    };
-    args.state.modelTierCooldowns = {
-        ...(args.state.modelTierCooldowns ?? {}),
-        [modelTierKey]: Math.max(args.state.modelTierCooldowns?.[modelTierKey] ?? 0, until),
-    };
-    args.state.requestClassBackoffLevels = {
-        ...rcBackoffLevels,
-        [requestClassKey]: (rcBackoffLevels[requestClassKey] ?? 0) + 1,
-    };
-    args.state.modelTierBackoffLevels = {
-        ...mtBackoffLevels,
-        [modelTierKey]: (mtBackoffLevels[modelTierKey] ?? 0) + 1,
-    };
+    const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, DEFAULT_COOLDOWN_FLOOR_MS);
+    const backoffMs = Math.min(baseCooldownMs * 2 ** args.state.backoffLevel, args.capMs);
+    args.state.coolingUntil = now + backoffMs;
     args.state.backoffLevel += 1;
-    return {
-        backoffMs,
-        requestClassKey,
-        modelTierKey,
-    };
+    return { backoffMs };
+}
+/**
+ * Clear cooldown state for an account after a successful request.
+ */
+export function clearAccountCooldown(state) {
+    state.coolingUntil = undefined;
+    state.backoffLevel = 0;
 }