@juspay/neurolink 12.49.16 → 12.49.18

package/dist/core/analytics.js

@@ -5,7 +5,6 @@
  * including tokens, costs, performance metrics, and custom context.
  */
 import { logger } from "../utils/logger.js";
-import { modelConfig } from "./modelConfiguration.js";
 import { extractTokenUsage as extractTokenUsageUtil } from "../utils/tokenUtils.js";
 import { calculateCost, hasPricing } from "../utils/pricing.js";
 /**
@@ -84,8 +83,8 @@ function extractTokenUsage(result) {
 }
 /**
  * Estimate cost based on provider, model, and token usage.
- * Uses the per-model pricing table first (which includes cache token rates),
- * then falls back to the provider-level configuration system.
+ * Uses known per-model rates, including cache tiers. An unpriced model has
+ * unknown cost; another model's provider default cannot estimate its bill.
  */
 function estimateCost(provider, model, tokens) {
     try {
@@ -93,21 +92,7 @@ function estimateCost(provider, model, tokens) {
         if (hasPricing(provider, model)) {
             return calculateCost(provider, model, tokens);
         }
-        // Fall back to the configuration system for providers/models not in the pricing table
-        const costInfo = modelConfig.getCostInfo(provider.toLowerCase(), model);
-        if (!costInfo) {
-            return undefined;
-        }
-        // Calculate cost using the configuration system (per-1K-token rates).
-        // costInfo has no cache tiers, so cache tokens are billed at the input
-        // rate — the pre-split total a cache-blind provider would report, never $0.
-        const inputCost = ((tokens.input +
-            (tokens.cacheReadTokens ?? 0) +
-            (tokens.cacheCreationTokens ?? 0)) /
-            1000) *
-            costInfo.input;
-        const outputCost = (tokens.output / 1000) * costInfo.output;
-        return Math.round((inputCost + outputCost) * 1_000_000) / 1_000_000; // Round to 6 decimal places
+        return undefined;
     }
     catch (error) {
         logger.debug("Cost estimation failed", { provider, model, error });

package/dist/core/evaluationProviders.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderModelConfig } from "../types/index.js";
+import type { ProviderModelConfig, ProviderPerformanceSample } from "../types/index.js";
 /**
  * Dynamic provider configurations for evaluation
  * Now uses configurable system instead of hardcoded values
@@ -35,12 +35,7 @@ export declare function getBestAvailableProvider(preferCheap?: boolean): Provide
 /**
  * Record actual provider performance for optimization
  */
-export declare function recordProviderPerformanceFromMetrics(providerName: string, metrics: {
-    responseTime: number;
-    tokensGenerated: number;
-    cost: number;
-    success: boolean;
-}): void;
+export declare function recordProviderPerformanceFromMetrics(providerName: string, metrics: ProviderPerformanceSample): void;
 /**
  * Get performance-optimized provider based on real metrics
  */

package/dist/core/evaluationProviders.js

@@ -142,7 +142,7 @@ export function recordProviderPerformanceFromMetrics(providerName, metrics) {
     // If responseTime is 0, skip updating tokenThroughput for this sample
     // but still update other metrics
     // Update cost efficiency (tokens per dollar)
-    if (metrics.cost > 0) {
+    if (metrics.cost !== undefined && metrics.cost > 0) {
         const tokensPerDollar = metrics.tokensGenerated / metrics.cost;
         existing.costEfficiency =
             (existing.costEfficiency * existing.sampleCount + tokensPerDollar) /

package/dist/core/modules/TelemetryHandler.d.ts

@@ -40,18 +40,10 @@ export declare class TelemetryHandler {
      */
     recordTTSFailure(ttsProvider: string, error: NonNullable<TTSMetadata["error"]>, latency: number): void;
     /**
-     * Calculate actual cost based on token usage and provider configuration.
-     *
-     * Uses the per-model pricing table first (which has accurate rates for
-     * specific models like Claude on Vertex AI), then falls back to the
-     * provider-level default cost from modelConfiguration.
-     *
-     * Previously this only used modelConfig.getCostInfo() which returns
-     * provider-level defaults (e.g. Gemini rates for the "vertex" provider),
-     * causing a ~1,780x under-estimate when the actual model was Claude Sonnet
-     * on Vertex AI ($0.000060 vs $0.106895 for the same request).
+     * Estimate cost only from known per-model rates. Unknown pricing remains
+     * absent from cost metrics instead of using another model's default rate.
      */
-    calculateActualCost(usage: TokenUsage): Promise<number>;
+    calculateActualCost(usage: TokenUsage): Promise<number | undefined>;
     /**
      * Create telemetry configuration for Vercel AI SDK experimental_telemetry
      * This enables automatic OpenTelemetry tracing when telemetry is enabled

package/dist/core/modules/TelemetryHandler.js

@@ -17,7 +17,6 @@ import { nanoid } from "nanoid";
 import { extractTokenUsage } from "../../utils/tokenUtils.js";
 import { logger } from "../../utils/logger.js";
 import { recordProviderPerformanceFromMetrics } from "../evaluationProviders.js";
-import { modelConfig } from "../modelConfiguration.js";
 import { TelemetryService } from "../../telemetry/telemetryService.js";
 import { calculateCost, hasPricing } from "../../utils/pricing.js";
 import { getLangfuseContext } from "../../services/server/ai/observability/instrumentation.js";
@@ -89,11 +88,11 @@ export class TelemetryHandler {
                 success: true,
             });
             // Wire TelemetryService metrics so OTEL counters/histograms are populated
-            TelemetryService.getInstance().recordAIRequest(this.providerName, this.modelName, totalTokens, responseTime, actualCost > 0 ? actualCost : undefined);
+            TelemetryService.getInstance().recordAIRequest(this.providerName, this.modelName, totalTokens, responseTime, actualCost !== undefined && actualCost > 0 ? actualCost : undefined);
             logger.debug(`Performance recorded for ${this.providerName}`, {
                 responseTime: `${responseTime}ms`,
                 tokens: totalTokens,
-                estimatedCost: `$${actualCost.toFixed(6)}`,
+                estimatedCost: actualCost === undefined ? "unknown" : `$${actualCost.toFixed(6)}`,
             });
         }
         catch (perfError) {
@@ -121,16 +120,8 @@ export class TelemetryHandler {
         }
     }
     /**
-     * Calculate actual cost based on token usage and provider configuration.
-     *
-     * Uses the per-model pricing table first (which has accurate rates for
-     * specific models like Claude on Vertex AI), then falls back to the
-     * provider-level default cost from modelConfiguration.
-     *
-     * Previously this only used modelConfig.getCostInfo() which returns
-     * provider-level defaults (e.g. Gemini rates for the "vertex" provider),
-     * causing a ~1,780x under-estimate when the actual model was Claude Sonnet
-     * on Vertex AI ($0.000060 vs $0.106895 for the same request).
+     * Estimate cost only from known per-model rates. Unknown pricing remains
+     * absent from cost metrics instead of using another model's default rate.
      */
     async calculateActualCost(usage) {
         try {
@@ -139,25 +130,11 @@ export class TelemetryHandler {
             if (hasPricing(this.providerName, this.modelName)) {
                 return calculateCost(this.providerName, this.modelName, usage);
             }
-            // Fall back to provider-level default cost from configuration system
-            const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
-            if (!costInfo) {
-                return 0; // No cost info available
-            }
-            // Calculate cost per 1K tokens. costInfo has no cache tiers, so cache
-            // tokens are billed at the input rate — the same total a provider
-            // without cache-aware splitting would have reported, never $0.
-            const inputCost = ((usage.input +
-                (usage.cacheReadTokens ?? 0) +
-                (usage.cacheCreationTokens ?? 0)) /
-                1000) *
-                costInfo.input;
-            const outputCost = (usage.output / 1000) * costInfo.output;
-            return inputCost + outputCost;
+            return undefined;
         }
         catch (error) {
             logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
-            return 0; // Fallback to 0 on any error
+            return undefined;
         }
     }
     /**

package/dist/mcp/externalServerManager.d.ts

@@ -19,6 +19,12 @@ export declare class ExternalServerManager extends EventEmitter {
     private inFlightToolCalls;
     /** Consecutive pings missed while idle, per server. */
     private unresponsiveChecks;
+    private consecutiveFailures;
+    private retryDeadlines;
+    private lastHealth;
+    private lifecycleStates;
+    /** Closed clients must never publish readiness after an awaited startup phase. */
+    private closedClients;
     private toolDiscovery;
     private enableMainRegistryIntegration;
     private hitlManager?;