@juspay/neurolink 12.49.17 → 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/types/agentNetwork.d.ts

@@ -49,6 +49,8 @@ export type AgentInput = string | Record<string, unknown>;
  * Result of agent execution
  */
 export type AgentResult = {
+    /** SDK estimate in USD; undefined when the model has no known pricing. */
+    cost?: number;
     /** Generated content */
     content: string;
     /** Structured output if schema was provided */
@@ -80,6 +82,10 @@ export type AgentResult = {
  * Options for agent execution
  */
 export type AgentExecutionOptions = {
+    /** Enable SDK usage and cost analytics for this execution. */
+    enableAnalytics?: boolean;
+    /** Cumulative budget for the NeuroLink instance, not a per-run cap. */
+    maxBudgetUsd?: number;
     /** Additional context for the agent */
     context?: Record<string, unknown>;
     /** Override max steps for this execution */
@@ -469,6 +475,8 @@ export type AgentStreamChunkType = "agent-start" | "agent-thinking" | "agent-tex
  * Agent stream chunk
  */
 export type AgentStreamChunk = {
+    /** SDK cost estimate in USD (for complete chunks), when priced. */
+    cost?: number;
     /** Chunk type */
     type: AgentStreamChunkType;
     /** Agent ID */

package/dist/types/evaluationProviders.d.ts

@@ -28,6 +28,12 @@ export type ProviderModelConfig = {
 /**
  * Real-time provider performance tracking metrics
  */
+export type ProviderPerformanceSample = {
+    responseTime: number;
+    tokensGenerated: number;
+    cost?: number;
+    success: boolean;
+};
 export type ProviderPerformanceMetrics = {
     responseTime: number[];
     successRate: number;

package/dist/utils/pricing.js

@@ -283,6 +283,15 @@ const PRICING = {
     },
     // Google Vertex AI — Claude models on Vertex (same pricing, @ date suffix)
     vertex: {
+        // Standard Sonnet 4 rates; the lookup also recognizes its @ date suffix.
+        // https://platform.claude.com/docs/en/about-claude/pricing
+        "claude-sonnet-4": {
+            input: 3.0 / 1_000_000,
+            output: 15.0 / 1_000_000,
+            cacheRead: 0.3 / 1_000_000,
+            cacheCreation: 3.75 / 1_000_000,
+            cacheCreation1h: 6.0 / 1_000_000,
+        },
         // A 1-hour cache write is 2x base input, as on the direct API.
         // Claude 5 family. Absent here until now, so a Vertex leg serving any of
         // them resolved to no rate at all and booked the turn at $0 — on the one
@@ -527,7 +536,13 @@ const PRICING = {
     },
     // Google (Gemini) — updated March 2026
     google: {
-        // Gemini 3.1 family (all require -preview suffix)
+        // GA text/image/video rates: https://ai.google.dev/gemini-api/docs/pricing
+        "gemini-3.1-flash-lite": {
+            input: 0.25 / 1_000_000,
+            output: 1.5 / 1_000_000,
+            cacheRead: 0.025 / 1_000_000,
+        },
+        // Gemini 3.1 preview family
         // cacheRead = 0.25x input (cached content tokens; explicit-cache storage is
         // billed separately by TTL/time, so no per-token cacheCreation rate here).
         "gemini-3.1-pro-preview": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.49.17",
+  "version": "12.49.18",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -107,6 +107,7 @@
     "test:anthropic-silent-truncation": "pnpm exec tsx test/continuous-test-suite-anthropic-silent-truncation.ts",
     "test:anthropic-thinking-disabled": "pnpm exec tsx test/continuous-test-suite-anthropic-thinking-disabled.ts",
     "test:cache-cost-accounting": "pnpm exec tsx test/continuous-test-suite-cache-cost-accounting.ts",
+    "test:agent:cost": "pnpm exec tsx test/continuous-test-suite-agent-cost.ts",
     "test:adjust-body-after-400": "pnpm exec tsx test/continuous-test-suite-adjust-body-after-400.ts",
     "test:zod3-schema-native-path": "pnpm exec tsx test/continuous-test-suite-zod3-schema-native-path.ts",
     "test:error-classification-e2e": "pnpm exec tsx test/continuous-test-suite-error-classification-e2e.ts",