@juspay/neurolink 9.54.1 → 9.54.2

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

@@ -5,6 +5,20 @@ import { BaseProvider } from "../core/baseProvider.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
 import type { NeurolinkCredentials } from "../types/providers.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+/**
+ * Resolve the correct Vertex AI location for a given model.
+ *
+ * Google-published models (gemini-*) require the global endpoint
+ * (`aiplatform.googleapis.com`), not regional endpoints like
+ * `us-east5-aiplatform.googleapis.com`. Regional endpoints return
+ * "model not found" for these models.
+ *
+ * Anthropic-on-Vertex models (claude-*) require regional endpoints
+ * and are handled separately by `createVertexAnthropicSettings`.
+ *
+ * Embedding models and custom models use the configured location as-is.
+ */
+export declare const resolveVertexLocation: (modelName: string | undefined, configuredLocation: string) => string;
 /**
  * Vertex Model Aliases
  *

package/dist/lib/providers/googleVertex.js

@@ -79,7 +79,36 @@ const getVertexLocation = () => {
     return (process.env.GOOGLE_CLOUD_LOCATION ||
         process.env.VERTEX_LOCATION ||
         process.env.GOOGLE_VERTEX_LOCATION ||
-        "us-central1");
+        "global");
+};
+/**
+ * Resolve the correct Vertex AI location for a given model.
+ *
+ * Google-published models (gemini-*) require the global endpoint
+ * (`aiplatform.googleapis.com`), not regional endpoints like
+ * `us-east5-aiplatform.googleapis.com`. Regional endpoints return
+ * "model not found" for these models.
+ *
+ * Anthropic-on-Vertex models (claude-*) require regional endpoints
+ * and are handled separately by `createVertexAnthropicSettings`.
+ *
+ * Embedding models and custom models use the configured location as-is.
+ */
+export const resolveVertexLocation = (modelName, configuredLocation) => {
+    if (!modelName) {
+        return configuredLocation;
+    }
+    const normalized = modelName.toLowerCase();
+    // Google-published models always use the global endpoint.
+    // Hardcoded because Google's Vertex AI serves Gemini models exclusively
+    // from the global endpoint — regional endpoints like us-east5 return
+    // "Publisher Model was not found" errors. The env var GOOGLE_VERTEX_LOCATION
+    // is typically set for Anthropic-on-Vertex (which needs regional), so we
+    // cannot rely on it for Gemini routing.
+    if (normalized.startsWith("gemini-")) {
+        return "global";
+    }
+    return configuredLocation;
 };
 const getDefaultVertexModel = () => {
     // Use gemini-2.5-flash as default - latest and best price-performance model
@@ -96,8 +125,9 @@ const hasGoogleCredentials = () => {
 // Module-level cache for runtime-created credentials file to avoid per-request writes
 let cachedCredentialsPath = null;
 // Enhanced Vertex settings creation with authentication fallback and proxy support
-const createVertexSettings = async (region, credentials) => {
-    const location = credentials?.location || region || getVertexLocation();
+const createVertexSettings = async (region, credentials, modelName) => {
+    const configuredLocation = credentials?.location || region || getVertexLocation();
+    const location = resolveVertexLocation(modelName, configuredLocation);
     const project = credentials?.projectId || getVertexProjectId();
     const baseSettings = {
         project,
@@ -326,7 +356,12 @@ const createVertexAnthropicSettings = async (region, credentials) => {
     // which is invalid. The correct global endpoint omits the region prefix entirely.
     // Since the SDK doesn't handle this, redirect "global" to "us-east5" for Anthropic.
     const anthropicRegion = !region || region === "global" ? "us-east5" : region;
-    const baseVertexSettings = await createVertexSettings(anthropicRegion, credentials);
+    // Override credentials.location so it cannot conflict with the redirected
+    // region — createVertexSettings checks credentials.location first.
+    const anthropicCredentials = credentials?.location
+        ? { ...credentials, location: anthropicRegion }
+        : credentials;
+    const baseVertexSettings = await createVertexSettings(anthropicRegion, anthropicCredentials);
     // GoogleVertexAnthropicProviderSettings extends GoogleVertexProviderSettings
     // so we can use the same settings with proper typing
     return {
@@ -570,7 +605,9 @@ export class GoogleVertexProvider extends BaseProvider {
             networkConfig: {
                 projectId: this.projectId,
                 location: this.location,
-                expectedEndpoint: `https://${this.location}-aiplatform.googleapis.com`,
+                expectedEndpoint: this.location === "global"
+                    ? "https://aiplatform.googleapis.com"
+                    : `https://${this.location}-aiplatform.googleapis.com`,
                 httpProxy: process.env.HTTP_PROXY || process.env.http_proxy,
                 httpsProxy: process.env.HTTPS_PROXY || process.env.https_proxy,
                 noProxy: process.env.NO_PROXY || process.env.no_proxy,
@@ -582,7 +619,7 @@ export class GoogleVertexProvider extends BaseProvider {
             message: "Starting Vertex settings creation with network configuration analysis",
         });
         try {
-            const vertexSettings = await createVertexSettings(this.location, this.credentials);
+            const vertexSettings = await createVertexSettings(this.location, this.credentials, modelName);
             const vertexSettingsEndTime = process.hrtime.bigint();
             const vertexSettingsDurationNs = vertexSettingsEndTime - vertexSettingsStartTime;
             logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V009_VERTEX_SETTINGS_SUCCESS`, {
@@ -1116,12 +1153,13 @@ export class GoogleVertexProvider extends BaseProvider {
     /**
      * Create @google/genai client configured for Vertex AI
      */
-    async createVertexGenAIClient(regionOverride) {
+    async createVertexGenAIClient(regionOverride, modelName) {
         const project = this.credentials?.projectId || getVertexProjectId();
-        const location = this.credentials?.location ||
+        const configuredLocation = this.credentials?.location ||
             regionOverride ||
             this.location ||
             getVertexLocation();
+        const location = resolveVertexLocation(modelName, configuredLocation);
         const mod = await import("@google/genai");
         const ctor = mod.GoogleGenAI;
         if (!ctor) {
@@ -1308,8 +1346,8 @@ export class GoogleVertexProvider extends BaseProvider {
         }, (span) => this.executeNativeGemini3StreamWithSpan(options, modelName, span));
     }
     async executeNativeGemini3StreamWithSpan(options, modelName, span) {
-        const client = await this.createVertexGenAIClient(options.region);
-        const effectiveLocation = options.region || this.location || getVertexLocation();
+        const client = await this.createVertexGenAIClient(options.region, modelName);
+        const effectiveLocation = resolveVertexLocation(modelName, options.region || this.location || getVertexLocation());
         logger.debug("[GoogleVertex] Using native @google/genai for Gemini 3", {
             model: modelName,
             hasTools: !!options.tools && Object.keys(options.tools).length > 0,
@@ -1503,8 +1541,8 @@ export class GoogleVertexProvider extends BaseProvider {
                 [ATTR.NL_PROVIDER]: this.providerName,
             },
         }, async (span) => {
-            const client = await this.createVertexGenAIClient(options.region);
-            const effectiveLocation = options.region || this.location || getVertexLocation();
+            const client = await this.createVertexGenAIClient(options.region, modelName);
+            const effectiveLocation = resolveVertexLocation(modelName, options.region || this.location || getVertexLocation());
             logger.debug("[GoogleVertex] Using native @google/genai for Gemini 3 generate", {
                 model: modelName,
                 project: this.projectId,

package/dist/lib/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/lib/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,142 +26,79 @@ 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;
 }
 //# sourceMappingURL=routingPolicy.js.map