@juspay/neurolink 12.49.17 → 12.49.19

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/neurolink.d.ts

@@ -66,6 +66,8 @@ export declare class NeuroLink {
     private mcpSkipped;
     private mcpInitPromise;
     private emitter;
+    /** Request ownership for conversation capture; unscoped emitter events are ignored. */
+    private readonly conversationEventContext;
     /**
      * Process-unique id used to attribute this instance's log events. The SDK
      * entry points run their bodies inside `logger.runInInstanceScope(this.logInstanceId, …)`,
@@ -1047,6 +1049,7 @@ export declare class NeuroLink {
      */
     private generateTextInternal;
     private executeGenerateTextInternalWithSpan;
+    private executeGenerateTextInternalInEventScope;
     private initializeGenerateTextInternalContext;
     private runGenerateTextInternalFlow;
     private captureOriginalConversationMessagesForRecovery;
@@ -1196,6 +1199,8 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions | DynamicOptions): Promise<StreamResult>;
+    /** Re-enter request ownership when the caller drives a deferred async iterator. */
+    private bindConversationEventStream;
     /**
      * Body of {@link stream}, always entered through the instance log scope.
      *

package/dist/neurolink.js

@@ -370,6 +370,8 @@ export class NeuroLink {
     mcpSkipped = false;
     mcpInitPromise = null;
     emitter = createTypedEmitter();
+    /** Request ownership for conversation capture; unscoped emitter events are ignored. */
+    conversationEventContext = new AsyncLocalStorage();
     /**
      * Process-unique id used to attribute this instance's log events. The SDK
      * entry points run their bodies inside `logger.runInInstanceScope(this.logInstanceId, …)`,
@@ -4724,6 +4726,7 @@ Current user's request: ${currentInput}`;
             stallTimeoutMs: options.stallTimeoutMs,
             wrapupTimeLeadMs: options.wrapupTimeLeadMs,
             toolTimeoutMs: options.toolTimeoutMs,
+            toolExecutionCapture: options.toolExecutionCapture,
             abortSignal: options.abortSignal,
             skipToolPromptInjection: options.skipToolPromptInjection,
             middleware: options.middleware,
@@ -4946,7 +4949,7 @@ Current user's request: ${currentInput}`;
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
             toolCalls: textResult.toolCalls ?? [],
-            toolExecutions: toToolExecutionRecords(textResult.toolExecutions),
+            toolExecutions: toToolExecutionRecords(textResult.toolExecutions, options.toolExecutionCapture),
             enhancedWithTools: textResult.enhancedWithTools,
             availableTools: transformAvailableTools(textResult.availableTools),
             analytics: textResult.analytics,
@@ -5483,8 +5486,15 @@ Current user's request: ${currentInput}`;
         return tracers.sdk.startActiveSpan("neurolink.generateTextInternal", { kind: SpanKind.INTERNAL }, (internalSpan) => this.executeGenerateTextInternalWithSpan(options, internalSpan));
     }
     async executeGenerateTextInternalWithSpan(options, internalSpan) {
+        return this.conversationEventContext.run(Symbol("generate-conversation"), () => this.executeGenerateTextInternalInEventScope(options, internalSpan));
+    }
+    async executeGenerateTextInternalInEventScope(options, internalSpan) {
+        const { eventSequence, cleanup } = this.setupStreamEventListeners();
         try {
-            const context = this.initializeGenerateTextInternalContext(options);
+            const context = {
+                ...this.initializeGenerateTextInternalContext(options),
+                eventSequence,
+            };
             internalSpan.setAttribute("neurolink.request_id", context.requestId);
             internalSpan.setAttribute("neurolink.has_conversation_memory", !!this.conversationMemory);
             internalSpan.setAttribute("neurolink.provider", options.provider || "auto");
@@ -5514,6 +5524,7 @@ Current user's request: ${currentInput}`;
             throw error;
         }
         finally {
+            cleanup();
             internalSpan.end();
         }
     }
@@ -5544,6 +5555,7 @@ Current user's request: ${currentInput}`;
                     internalSpan,
                     requestId: context.requestId,
                     startTime: context.generateInternalStartTime,
+                    events: context.eventSequence,
                 });
             }
             if (options.abortSignal?.aborted) {
@@ -5559,6 +5571,7 @@ Current user's request: ${currentInput}`;
                 internalSpan,
                 requestId: context.requestId,
                 startTime: context.generateInternalStartTime,
+                events: context.eventSequence,
             });
         }
         catch (error) {
@@ -5586,7 +5599,11 @@ Current user's request: ${currentInput}`;
             : undefined;
     }
     async finalizeGenerateTextInternalResult(params) {
-        const { path, result, options, internalSpan, requestId, startTime } = params;
+        const { path, result, options, internalSpan, requestId, startTime, events, } = params;
+        const historyEvents = events?.filter((event) => event.type !== "response:chunk");
+        if (historyEvents?.length) {
+            result.events = historyEvents;
+        }
         logger.info(`[NeuroLink.generateTextInternal] generate() - COMPLETE SUCCESS${path === "mcp" ? " (MCP path)" : ""}`, {
             provider: result.provider,
             model: result.model,
@@ -7347,7 +7364,36 @@ Current user's request: ${currentInput}`;
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     async stream(options) {
-        return logger.runInInstanceScope(this.logInstanceId, () => this.streamInInstanceScope(options));
+        const eventScope = Symbol("stream-conversation");
+        return this.conversationEventContext.run(eventScope, () => logger.runInInstanceScope(this.logInstanceId, async () => {
+            const result = await this.streamInInstanceScope(options);
+            return preserveLiveStreamAccessors(result, {
+                ...result,
+                stream: this.bindConversationEventStream(result.stream, eventScope),
+            });
+        }));
+    }
+    /** Re-enter request ownership when the caller drives a deferred async iterator. */
+    bindConversationEventStream(stream, eventScope) {
+        const scope = this.conversationEventContext;
+        return (async function* () {
+            const iterator = stream[Symbol.asyncIterator]();
+            try {
+                while (true) {
+                    const next = await scope.run(eventScope, () => iterator.next());
+                    if (next.done) {
+                        return;
+                    }
+                    yield next.value;
+                }
+            }
+            finally {
+                const close = iterator.return?.bind(iterator);
+                if (close) {
+                    await scope.run(eventScope, () => close());
+                }
+            }
+        })();
     }
     /**
      * Body of {@link stream}, always entered through the instance log scope.
@@ -7909,7 +7955,11 @@ Current user's request: ${currentInput}`;
             // (Finding 1 fix). It is cleared by setToolRoutingServers() when the
             // catalog changes so stale vectors are never used after an update.
             let routingEmbedFn;
-            const embeddingCfg = routingConfig.embedding;
+            // A host-owned routing callback owns every inference account. The
+            // instance's embedding fast-path would otherwise borrow turn credentials.
+            const embeddingCfg = routingConfig.generateFn
+                ? undefined
+                : routingConfig.embedding;
             if (embeddingCfg?.enabled === true) {
                 try {
                     // Resolve the embedding provider: use the explicitly configured one
@@ -7959,7 +8009,7 @@ Current user's request: ${currentInput}`;
                 timeoutMs: routingConfig.timeoutMs ?? DEFAULT_TOOL_ROUTING_TIMEOUT_MS,
                 // Forward the abort signal so a cancelled turn aborts the router
                 // call promptly instead of waiting out the routing timeout.
-                generateFn: (generateOptions) => this.preservingTurnState(() => this.generate({
+                generateFn: (generateOptions) => this.preservingTurnState(() => (routingConfig.generateFn ?? ((input) => this.generate(input)))({
                     ...generateOptions,
                     abortSignal: options.abortSignal,
                 })),
@@ -7967,7 +8017,11 @@ Current user's request: ${currentInput}`;
                 // configured. siteDecide returns null without one, so the resolver
                 // falls straight through to the generative router as before. The
                 // outer request's credentials, abort signal and ids ride along.
-                decideFn: (decisionOptions) => this.siteDecide(decisionOptions, this.decisionSiteContext(options, sessionId || undefined)),
+                // A host-owned routing callback owns the inference account too.
+                // Bypass the instance's decision fast-path in that explicit mode.
+                decideFn: routingConfig.generateFn
+                    ? undefined
+                    : (decisionOptions) => this.siteDecide(decisionOptions, this.decisionSiteContext(options, sessionId || undefined)),
                 decisionMinDropConfidence: routingConfig.minDropConfidence,
                 emitDecision: captureDecision,
                 // L2 / ITEM D — only populated when embedding is configured.
@@ -8948,7 +9002,30 @@ Current user's request: ${currentInput}`;
     setupStreamEventListeners() {
         const eventSequence = [];
         let eventSeqCounter = 0;
-        const captureEvent = (type, data) => {
+        const eventScope = this.conversationEventContext.getStore();
+        const ownedConfirmations = new Set();
+        const confirmationId = (event) => {
+            if (!event ||
+                typeof event !== "object" ||
+                !("payload" in event) ||
+                !event.payload ||
+                typeof event.payload !== "object" ||
+                !("confirmationId" in event.payload) ||
+                typeof event.payload.confirmationId !== "string") {
+                return undefined;
+            }
+            return event.payload.confirmationId;
+        };
+        const captureEvent = (type, data, ownedConfirmation) => {
+            // Never infer ownership from whichever listeners happen to be active.
+            // This also fails closed where async context propagation is unavailable.
+            const belongsToTurn = eventScope !== undefined &&
+                this.conversationEventContext.getStore() === eventScope;
+            const belongsToConfirmation = ownedConfirmation !== undefined &&
+                ownedConfirmations.has(ownedConfirmation);
+            if (!belongsToTurn && !belongsToConfirmation) {
+                return;
+            }
             eventSequence.push({
                 type,
                 seq: eventSeqCounter++,
@@ -8990,19 +9067,46 @@ Current user's request: ${currentInput}`;
                 });
             }
         };
+        const onHostConversationEvent = (...args) => {
+            const event = args[0];
+            if (event &&
+                typeof event === "object" &&
+                "type" in event &&
+                typeof event.type === "string" &&
+                "data" in event &&
+                event.data &&
+                typeof event.data === "object" &&
+                !Array.isArray(event.data)) {
+                captureEvent(event.type, { data: event.data });
+            }
+        };
         const onUIComponent = (...args) => {
             captureEvent("ui-component", args[0]);
         };
         const onHITLRequest = (...args) => {
-            captureEvent("hitl:confirmation-request", args[0]);
+            if (eventScope !== undefined &&
+                this.conversationEventContext.getStore() === eventScope) {
+                const id = confirmationId(args[0]);
+                if (id !== undefined) {
+                    ownedConfirmations.add(id);
+                }
+                captureEvent("hitl:confirmation-request", args[0]);
+            }
         };
         const onHITLResponse = (...args) => {
-            captureEvent("hitl:confirmation-response", args[0]);
+            const id = confirmationId(args[0]);
+            // A host answers from its own HTTP/async context. The issued confirmation
+            // id carries ownership without admitting arbitrary global emitter data.
+            if (id !== undefined && ownedConfirmations.has(id)) {
+                captureEvent("hitl:confirmation-response", args[0], id);
+                ownedConfirmations.delete(id);
+            }
         };
         this.emitter.on("response:chunk", onResponseChunk);
         this.emitter.on("tool:start", onToolStart);
         this.emitter.on("tool:end", onToolEnd);
         this.emitter.on("ui-component", onUIComponent);
+        this.emitter.on("host:conversation-event", onHostConversationEvent);
         this.emitter.on("hitl:confirmation-request", onHITLRequest);
         this.emitter.on("hitl:confirmation-response", onHITLResponse);
         const cleanup = () => {
@@ -9010,6 +9114,7 @@ Current user's request: ${currentInput}`;
             this.emitter.off("tool:start", onToolStart);
             this.emitter.off("tool:end", onToolEnd);
             this.emitter.off("ui-component", onUIComponent);
+            this.emitter.off("host:conversation-event", onHostConversationEvent);
             this.emitter.off("hitl:confirmation-request", onHITLRequest);
             this.emitter.off("hitl:confirmation-response", onHITLResponse);
         };

package/dist/types/agentNetwork.d.ts

@@ -7,7 +7,7 @@
 import type { z } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
 import type { TokenUsage } from "./analytics.js";
-import type { GenerateStopReason, ToolExecutionRecord } from "./generate.js";
+import type { GenerateStopReason, ToolExecutionRecord, ToolExecutionCaptureOptions } from "./generate.js";
 /**
  * Agent definition for creating agents in the network
  */
@@ -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,24 @@ 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;
+    /** Per-turn tool opt-out; cannot expand the agent tool scope. */
+    disableTools?: boolean;
+    /** Provider region override for this turn. */
+    region?: string;
+    /** Output bound for this turn. */
+    maxTokens?: number;
+    /** Opt out of session history and user-memory reads/writes for this turn, retaining stored state. */
+    useMemory?: boolean;
+    /** Conversation memory identity; never included in the model prompt. */
+    sessionId?: string;
+    /** Refuse SDK-internal provider/model fallback for this execution. */
+    disableInternalFallback?: boolean;
+    /** Bounds and callback for the underlying SDK's tool execution capture. */
+    toolExecutionCapture?: ToolExecutionCaptureOptions;
     /** Additional context for the agent */
     context?: Record<string, unknown>;
     /** Override max steps for this execution */
@@ -469,6 +489,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 */
@@ -485,6 +507,12 @@ export type AgentStreamChunk = {
     usage?: TokenUsage;
     /** Duration in ms (for complete chunks) */
     duration?: number;
+    /** Complete-turn status; errors remain failures even after partial text. */
+    status?: AgentResult["status"];
+    /** Final, bounded per-call records in the same shape as AgentResult. */
+    toolExecutions?: ToolExecutionRecord[];
+    /** Terminal reason from the underlying stream. */
+    stopReason?: GenerateStopReason;
     /** Error message (for error chunks) */
     error?: string;
     /** Tool name (for tool chunks) */

package/dist/types/common.d.ts

@@ -93,6 +93,11 @@ export type InternalStreamEvent = {
  * Flexible type to support both typed and legacy event patterns
  */
 export type NeuroLinkEvents = {
+    /** Application-owned events captured in ordered conversation history. */
+    "host:conversation-event": {
+        type: string;
+        data: Record<string, unknown>;
+    };
     "tool:start": unknown;
     "tool:end": unknown;
     "stream:start": unknown;

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/types/generate.d.ts

@@ -7,7 +7,7 @@ import type { ClaudeLimitSnapshot } from "./subscription.js";
 import type { JsonValue } from "./common.js";
 import type { TerminalAgentModeOption, TerminalAgentModeVersion } from "./agentMode.js";
 import type { Content, ImageWithAltText } from "./content.js";
-import type { ChatMessage, ConversationMemoryConfig, ToolReplayMode } from "./conversation.js";
+import type { ChatMessage, ConversationMemoryConfig, StreamEventSequence, ToolReplayMode } from "./conversation.js";
 import type { MemoryCallOptions } from "./memory.js";
 import type { EvaluationData } from "./evaluation.js";
 import type { MiddlewareFactoryOptions, OnFinishCallback, OnErrorCallback } from "./middleware.js";
@@ -1663,6 +1663,8 @@ export type TextGenerationOptions = {
  * Text generation result (consolidated from core types)
  */
 export type TextGenerationResult = {
+    /** Ordered tool and host events persisted with the conversation turn. */
+    events?: StreamEventSequence[];
     content: string;
     /** Parsed structured object when a `schema` was requested (see GenerateResult.structuredData). */
     structuredData?: unknown;

package/dist/types/toolRouting.d.ts

@@ -106,6 +106,12 @@ export type ToolRoutingEmbeddingConfig = {
 };
 /** Constructor-level configuration for pre-call tool routing. */
 export type ToolRoutingConfig = {
+    /**
+     * Host-owned generative routing, independent of main-turn credentials.
+     * When provided, instance decision and embedding fast-paths are bypassed;
+     * routing selection is performed by this callback.
+     */
+    generateFn?: (options: GenerateOptions) => Promise<GenerateResult>;
     /** Master switch. Routing runs only when true AND the server catalog is non-empty. */
     enabled: boolean;
     /**

package/dist/utils/conversationMemory.js

@@ -384,7 +384,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
                 providerDetails,
                 enableSummarization: originalOptions.enableSummarization,
                 requestId,
-                events: toolActivityEvents,
+                events: result.events?.length ? result.events : toolActivityEvents,
                 ...(skillMessages && skillMessages.length > 0
                     ? { skillMessages }
                     : {}),

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.19",
   "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": {
@@ -75,6 +75,8 @@
     "test": "pnpm exec tsx test/continuous-test-suite.ts",
     "test:agent-delegation": "pnpm exec tsx test/continuous-test-suite-agent-delegation.ts",
     "test:agent-tasks": "pnpm exec tsx test/continuous-test-suite-agent-tasks.ts",
+    "test:agent:session-stream": "pnpm exec tsx test/continuous-test-suite-agent-session-stream.ts",
+    "test:agent:platform-router": "pnpm exec tsx test/continuous-test-suite-agent-platform-router.ts",
     "test:artifact-banking": "pnpm exec tsx test/continuous-test-suite-artifact-banking.ts",
     "test:background-commands": "pnpm exec tsx test/continuous-test-suite-background-commands.ts",
     "test:client": "pnpm exec tsx test/continuous-test-suite-client.ts",
@@ -107,6 +109,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",