@juspay/neurolink 9.59.0 → 9.59.1

package/dist/lib/neurolink.d.ts

@@ -5,13 +5,41 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { DynamicOptions } from "./types/index.js";
 import { TaskManager } from "./tasks/taskManager.js";
+/**
+ * Curator P2-4 dedup (concurrency-safe): native providers emit
+ * `generation:end` on the shared SDK emitter. We attach a fresh
+ * mutable `dedupContext` object directly to the per-call
+ * `StreamOptions` (under `_streamDedupContext`) so each stream gets
+ * its own instance — concurrent streams have different option objects
+ * and therefore different contexts, so they cannot interfere.
+ *
+ * Native provider emit sites read `options._streamDedupContext` and
+ * flip `.providerEmitted = true` before emitting; the orchestration's
+ * finally block reads the same closed-over reference and skips its
+ * own emit when the flag is set.
+ *
+ * This avoids the AsyncLocalStorage approach which doesn't reliably
+ * propagate through async-generator yield boundaries when iteration
+ * happens from outside the original `run()` scope (e.g. when the
+ * consumer drives `for await of result.stream` after `sdk.stream(...)`
+ * returns).
+ */
+export declare const STREAM_DEDUP_CONTEXT_KEY: "_streamDedupContext";
+/**
+ * Native providers call this from their `generation:end` emit sites,
+ * passing the same `options` object they received. Safe no-op when
+ * the field isn't set.
+ */
+export declare function markStreamProviderEmittedGenerationEnd(options: {
+    _streamDedupContext?: StreamGenerationEndContext;
+} | undefined): void;
 export declare class NeuroLink {
     private mcpInitialized;
     private mcpSkipped;

package/dist/lib/neurolink.js

@@ -297,6 +297,37 @@ function isNonRetryableProviderError(error) {
  * same NeuroLink instance would clobber each other's trace context.
  */
 const metricsTraceContextStorage = new AsyncLocalStorage();
+/**
+ * Curator P2-4 dedup (concurrency-safe): native providers emit
+ * `generation:end` on the shared SDK emitter. We attach a fresh
+ * mutable `dedupContext` object directly to the per-call
+ * `StreamOptions` (under `_streamDedupContext`) so each stream gets
+ * its own instance — concurrent streams have different option objects
+ * and therefore different contexts, so they cannot interfere.
+ *
+ * Native provider emit sites read `options._streamDedupContext` and
+ * flip `.providerEmitted = true` before emitting; the orchestration's
+ * finally block reads the same closed-over reference and skips its
+ * own emit when the flag is set.
+ *
+ * This avoids the AsyncLocalStorage approach which doesn't reliably
+ * propagate through async-generator yield boundaries when iteration
+ * happens from outside the original `run()` scope (e.g. when the
+ * consumer drives `for await of result.stream` after `sdk.stream(...)`
+ * returns).
+ */
+export const STREAM_DEDUP_CONTEXT_KEY = "_streamDedupContext";
+/**
+ * Native providers call this from their `generation:end` emit sites,
+ * passing the same `options` object they received. Safe no-op when
+ * the field isn't set.
+ */
+export function markStreamProviderEmittedGenerationEnd(options) {
+    const ctx = options?._streamDedupContext;
+    if (ctx) {
+        ctx.providerEmitted = true;
+    }
+}
 export class NeuroLink {
     mcpInitialized = false;
     mcpSkipped = false;
@@ -4984,8 +5015,23 @@ Current user's request: ${currentInput}`;
             const streamStartTime = Date.now();
             const sessionId = enhancedOptions.context
                 ?.sessionId;
+            // Curator P2-4 dedup (concurrency-safe): native provider stream paths
+            // (Gemini 3 on Vertex / Google AI Studio) emit `generation:end`
+            // themselves. We attach a per-stream mutable flag directly to
+            // `enhancedOptions._streamDedupContext` — native providers receive
+            // these options and flip the flag before their emit; this finally
+            // block reads the same closed-over reference. Concurrent streams
+            // have different option objects so the contexts don't interfere.
+            const dedupContext = {
+                providerEmitted: false,
+            };
+            enhancedOptions._streamDedupContext = dedupContext;
             const processedStream = (async function* () {
                 let streamError;
+                // Curator P2-4: hoist `resolvedUsage` so the finally block can emit a
+                // single `generation:end` event with cost data. Cost listeners
+                // subscribe here; previously the stream path never fired it.
+                let resolvedUsage;
                 try {
                     for await (const chunk of mcpStream) {
                         chunkCount++;
@@ -5015,7 +5061,7 @@ Current user's request: ${currentInput}`;
                             accumulatedContent += content;
                         });
                     }
-                    let resolvedUsage = streamUsage;
+                    resolvedUsage = streamUsage;
                     if (!resolvedUsage && streamAnalytics) {
                         try {
                             const resolved = await Promise.resolve(streamAnalytics);
@@ -5090,6 +5136,61 @@ Current user's request: ${currentInput}`;
                         guardrailsBlocked: metadata.guardrailsBlocked,
                         error: metadata.error,
                     });
+                    // Curator P2-4: emit `generation:end` exactly once per stream so
+                    // cost listeners receive the same contract as for `generate()`.
+                    // The previous implementation only fired `stream:complete`, leaving
+                    // any subscriber to `generation:end` with zero events.
+                    //
+                    // Dedup: native provider stream paths (Gemini 3 on Vertex / Google
+                    // AI Studio) already emit `generation:end` themselves so Pipeline B
+                    // (Langfuse) records a GENERATION observation. Skip our emit when
+                    // they already fired — preserves their Pipeline B observation
+                    // source and keeps the "exactly once" contract. Per-stream flag
+                    // is concurrency-safe because it's scoped via AsyncLocalStorage.
+                    if (!dedupContext.providerEmitted) {
+                        try {
+                            const finalProvider = metadata.fallbackProvider ?? providerName ?? "unknown";
+                            const finalModel = metadata.fallbackModel ??
+                                streamModel ??
+                                enhancedOptions.model ??
+                                "unknown";
+                            const finalFinishReason = streamError
+                                ? "error"
+                                : (streamState.finishReason ?? "stop");
+                            self.emitter.emit("generation:end", {
+                                provider: finalProvider,
+                                model: finalModel,
+                                responseTime: Date.now() - streamStartTime,
+                                toolsUsed: streamState.toolCalls?.map((t) => t.toolName),
+                                timestamp: Date.now(),
+                                result: {
+                                    content: accumulatedContent,
+                                    usage: resolvedUsage,
+                                    model: finalModel,
+                                    provider: finalProvider,
+                                    finishReason: finalFinishReason,
+                                },
+                                prompt: enhancedOptions.input?.text ||
+                                    enhancedOptions.prompt,
+                                temperature: enhancedOptions.temperature,
+                                maxTokens: enhancedOptions.maxTokens,
+                                success: !streamError,
+                                error: streamError
+                                    ? streamError instanceof Error
+                                        ? streamError.message
+                                        : String(streamError)
+                                    : undefined,
+                                pipelineAHandled: true,
+                            });
+                        }
+                        catch (emitError) {
+                            logger.debug("[NeuroLink.stream] generation:end listener threw — ignored", {
+                                error: emitError instanceof Error
+                                    ? emitError.message
+                                    : String(emitError),
+                            });
+                        }
+                    }
                     self._disableToolCacheForCurrentRequest = false;
                     cleanupListeners();
                     streamSpan.setAttribute("neurolink.response_time_ms", Date.now() - spanStartTime);

package/dist/lib/providers/googleAiStudio.js

@@ -4,6 +4,7 @@ import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enum
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { markStreamProviderEmittedGenerationEnd, } from "../neurolink.js";
 import { SpanStatusCode } from "@opentelemetry/api";
 import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
@@ -735,6 +736,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // AI SDK so experimental_telemetry is never injected; we emit manually.
                         const nativeStreamEmitter = this.neurolink?.getEventEmitter();
                         if (nativeStreamEmitter) {
+                            // Curator P2-4 dedup: flag the per-stream context attached
+                            // to options so the orchestration skips its own emit.
+                            markStreamProviderEmittedGenerationEnd(options);
                             nativeStreamEmitter.emit("generation:end", {
                                 provider: this.providerName,
                                 responseTime,
@@ -767,6 +771,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // Emit failure generation:end so Pipeline B records the failed stream
                         const errorEmitter = this.neurolink?.getEventEmitter();
                         if (errorEmitter) {
+                            // Curator P2-4 dedup: flag the per-stream context attached
+                            // to options so the orchestration skips its own emit.
+                            markStreamProviderEmittedGenerationEnd(options);
                             errorEmitter.emit("generation:end", {
                                 provider: this.providerName,
                                 responseTime: Date.now() - startTime,

package/dist/lib/providers/googleVertex.js

@@ -10,6 +10,7 @@ import { ErrorCategory, ErrorSeverity, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
+import { markStreamProviderEmittedGenerationEnd, } from "../neurolink.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
@@ -1630,8 +1631,12 @@ export class GoogleVertexProvider extends BaseProvider {
             // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
             // observation. The native @google/genai stream path on Vertex bypasses the
             // Vercel AI SDK so experimental_telemetry is never injected; we emit manually.
+            // Curator P2-4 dedup: flag the per-stream context attached to options
+            // so the orchestration in `runStandardStreamRequest` knows we already
+            // emitted and skips its own emit (preserving exactly-once).
             const vertexStreamEmitter = this.neurolink?.getEventEmitter();
             if (vertexStreamEmitter) {
+                markStreamProviderEmittedGenerationEnd(params.options);
                 vertexStreamEmitter.emit("generation:end", {
                     provider: this.providerName,
                     responseTime,

package/dist/lib/types/index.d.ts

@@ -57,3 +57,4 @@ export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
 export * from "./dynamic.js";
+export * from "./streamDedup.js";

package/dist/lib/types/index.js

@@ -60,4 +60,6 @@ export * from "./imageGen.js";
 export * from "./elicitation.js";
 // Dynamic Arguments types
 export * from "./dynamic.js";
+// Curator P2-4 dedup: per-stream AsyncLocalStorage context
+export * from "./streamDedup.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/types/streamDedup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Curator P2-4 dedup (concurrency-safe): per-stream context that lets
+ * the orchestration's `runStandardStreamRequest` finally block know
+ * whether a *native provider* path within THIS stream's async chain
+ * already emitted `generation:end`. Native providers (Vertex / Google
+ * AI Studio for Gemini 3, etc.) emit on the shared SDK emitter; without
+ * scoping, a concurrent unrelated stream's emit on the same NeuroLink
+ * instance would suppress the wrong stream's orchestration emit.
+ *
+ * AsyncLocalStorage scopes each stream's flag to its own async chain.
+ */
+export type StreamGenerationEndContext = {
+    providerEmitted: boolean;
+};

package/dist/lib/types/streamDedup.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=streamDedup.js.map

package/dist/neurolink.d.ts

@@ -5,13 +5,41 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { DynamicOptions } from "./types/index.js";
 import { TaskManager } from "./tasks/taskManager.js";
+/**
+ * Curator P2-4 dedup (concurrency-safe): native providers emit
+ * `generation:end` on the shared SDK emitter. We attach a fresh
+ * mutable `dedupContext` object directly to the per-call
+ * `StreamOptions` (under `_streamDedupContext`) so each stream gets
+ * its own instance — concurrent streams have different option objects
+ * and therefore different contexts, so they cannot interfere.
+ *
+ * Native provider emit sites read `options._streamDedupContext` and
+ * flip `.providerEmitted = true` before emitting; the orchestration's
+ * finally block reads the same closed-over reference and skips its
+ * own emit when the flag is set.
+ *
+ * This avoids the AsyncLocalStorage approach which doesn't reliably
+ * propagate through async-generator yield boundaries when iteration
+ * happens from outside the original `run()` scope (e.g. when the
+ * consumer drives `for await of result.stream` after `sdk.stream(...)`
+ * returns).
+ */
+export declare const STREAM_DEDUP_CONTEXT_KEY: "_streamDedupContext";
+/**
+ * Native providers call this from their `generation:end` emit sites,
+ * passing the same `options` object they received. Safe no-op when
+ * the field isn't set.
+ */
+export declare function markStreamProviderEmittedGenerationEnd(options: {
+    _streamDedupContext?: StreamGenerationEndContext;
+} | undefined): void;
 export declare class NeuroLink {
     private mcpInitialized;
     private mcpSkipped;

package/dist/neurolink.js

@@ -297,6 +297,37 @@ function isNonRetryableProviderError(error) {
  * same NeuroLink instance would clobber each other's trace context.
  */
 const metricsTraceContextStorage = new AsyncLocalStorage();
+/**
+ * Curator P2-4 dedup (concurrency-safe): native providers emit
+ * `generation:end` on the shared SDK emitter. We attach a fresh
+ * mutable `dedupContext` object directly to the per-call
+ * `StreamOptions` (under `_streamDedupContext`) so each stream gets
+ * its own instance — concurrent streams have different option objects
+ * and therefore different contexts, so they cannot interfere.
+ *
+ * Native provider emit sites read `options._streamDedupContext` and
+ * flip `.providerEmitted = true` before emitting; the orchestration's
+ * finally block reads the same closed-over reference and skips its
+ * own emit when the flag is set.
+ *
+ * This avoids the AsyncLocalStorage approach which doesn't reliably
+ * propagate through async-generator yield boundaries when iteration
+ * happens from outside the original `run()` scope (e.g. when the
+ * consumer drives `for await of result.stream` after `sdk.stream(...)`
+ * returns).
+ */
+export const STREAM_DEDUP_CONTEXT_KEY = "_streamDedupContext";
+/**
+ * Native providers call this from their `generation:end` emit sites,
+ * passing the same `options` object they received. Safe no-op when
+ * the field isn't set.
+ */
+export function markStreamProviderEmittedGenerationEnd(options) {
+    const ctx = options?._streamDedupContext;
+    if (ctx) {
+        ctx.providerEmitted = true;
+    }
+}
 export class NeuroLink {
     mcpInitialized = false;
     mcpSkipped = false;
@@ -4984,8 +5015,23 @@ Current user's request: ${currentInput}`;
             const streamStartTime = Date.now();
             const sessionId = enhancedOptions.context
                 ?.sessionId;
+            // Curator P2-4 dedup (concurrency-safe): native provider stream paths
+            // (Gemini 3 on Vertex / Google AI Studio) emit `generation:end`
+            // themselves. We attach a per-stream mutable flag directly to
+            // `enhancedOptions._streamDedupContext` — native providers receive
+            // these options and flip the flag before their emit; this finally
+            // block reads the same closed-over reference. Concurrent streams
+            // have different option objects so the contexts don't interfere.
+            const dedupContext = {
+                providerEmitted: false,
+            };
+            enhancedOptions._streamDedupContext = dedupContext;
             const processedStream = (async function* () {
                 let streamError;
+                // Curator P2-4: hoist `resolvedUsage` so the finally block can emit a
+                // single `generation:end` event with cost data. Cost listeners
+                // subscribe here; previously the stream path never fired it.
+                let resolvedUsage;
                 try {
                     for await (const chunk of mcpStream) {
                         chunkCount++;
@@ -5015,7 +5061,7 @@ Current user's request: ${currentInput}`;
                             accumulatedContent += content;
                         });
                     }
-                    let resolvedUsage = streamUsage;
+                    resolvedUsage = streamUsage;
                     if (!resolvedUsage && streamAnalytics) {
                         try {
                             const resolved = await Promise.resolve(streamAnalytics);
@@ -5090,6 +5136,61 @@ Current user's request: ${currentInput}`;
                         guardrailsBlocked: metadata.guardrailsBlocked,
                         error: metadata.error,
                     });
+                    // Curator P2-4: emit `generation:end` exactly once per stream so
+                    // cost listeners receive the same contract as for `generate()`.
+                    // The previous implementation only fired `stream:complete`, leaving
+                    // any subscriber to `generation:end` with zero events.
+                    //
+                    // Dedup: native provider stream paths (Gemini 3 on Vertex / Google
+                    // AI Studio) already emit `generation:end` themselves so Pipeline B
+                    // (Langfuse) records a GENERATION observation. Skip our emit when
+                    // they already fired — preserves their Pipeline B observation
+                    // source and keeps the "exactly once" contract. Per-stream flag
+                    // is concurrency-safe because it's scoped via AsyncLocalStorage.
+                    if (!dedupContext.providerEmitted) {
+                        try {
+                            const finalProvider = metadata.fallbackProvider ?? providerName ?? "unknown";
+                            const finalModel = metadata.fallbackModel ??
+                                streamModel ??
+                                enhancedOptions.model ??
+                                "unknown";
+                            const finalFinishReason = streamError
+                                ? "error"
+                                : (streamState.finishReason ?? "stop");
+                            self.emitter.emit("generation:end", {
+                                provider: finalProvider,
+                                model: finalModel,
+                                responseTime: Date.now() - streamStartTime,
+                                toolsUsed: streamState.toolCalls?.map((t) => t.toolName),
+                                timestamp: Date.now(),
+                                result: {
+                                    content: accumulatedContent,
+                                    usage: resolvedUsage,
+                                    model: finalModel,
+                                    provider: finalProvider,
+                                    finishReason: finalFinishReason,
+                                },
+                                prompt: enhancedOptions.input?.text ||
+                                    enhancedOptions.prompt,
+                                temperature: enhancedOptions.temperature,
+                                maxTokens: enhancedOptions.maxTokens,
+                                success: !streamError,
+                                error: streamError
+                                    ? streamError instanceof Error
+                                        ? streamError.message
+                                        : String(streamError)
+                                    : undefined,
+                                pipelineAHandled: true,
+                            });
+                        }
+                        catch (emitError) {
+                            logger.debug("[NeuroLink.stream] generation:end listener threw — ignored", {
+                                error: emitError instanceof Error
+                                    ? emitError.message
+                                    : String(emitError),
+                            });
+                        }
+                    }
                     self._disableToolCacheForCurrentRequest = false;
                     cleanupListeners();
                     streamSpan.setAttribute("neurolink.response_time_ms", Date.now() - spanStartTime);

package/dist/providers/googleAiStudio.js

@@ -4,6 +4,7 @@ import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enum
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { markStreamProviderEmittedGenerationEnd, } from "../neurolink.js";
 import { SpanStatusCode } from "@opentelemetry/api";
 import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
@@ -735,6 +736,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // AI SDK so experimental_telemetry is never injected; we emit manually.
                         const nativeStreamEmitter = this.neurolink?.getEventEmitter();
                         if (nativeStreamEmitter) {
+                            // Curator P2-4 dedup: flag the per-stream context attached
+                            // to options so the orchestration skips its own emit.
+                            markStreamProviderEmittedGenerationEnd(options);
                             nativeStreamEmitter.emit("generation:end", {
                                 provider: this.providerName,
                                 responseTime,
@@ -767,6 +771,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // Emit failure generation:end so Pipeline B records the failed stream
                         const errorEmitter = this.neurolink?.getEventEmitter();
                         if (errorEmitter) {
+                            // Curator P2-4 dedup: flag the per-stream context attached
+                            // to options so the orchestration skips its own emit.
+                            markStreamProviderEmittedGenerationEnd(options);
                             errorEmitter.emit("generation:end", {
                                 provider: this.providerName,
                                 responseTime: Date.now() - startTime,

package/dist/providers/googleVertex.js

@@ -10,6 +10,7 @@ import { ErrorCategory, ErrorSeverity, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
+import { markStreamProviderEmittedGenerationEnd, } from "../neurolink.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
@@ -1630,8 +1631,12 @@ export class GoogleVertexProvider extends BaseProvider {
             // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION
             // observation. The native @google/genai stream path on Vertex bypasses the
             // Vercel AI SDK so experimental_telemetry is never injected; we emit manually.
+            // Curator P2-4 dedup: flag the per-stream context attached to options
+            // so the orchestration in `runStandardStreamRequest` knows we already
+            // emitted and skips its own emit (preserving exactly-once).
             const vertexStreamEmitter = this.neurolink?.getEventEmitter();
             if (vertexStreamEmitter) {
+                markStreamProviderEmittedGenerationEnd(params.options);
                 vertexStreamEmitter.emit("generation:end", {
                     provider: this.providerName,
                     responseTime,

package/dist/types/index.d.ts

@@ -57,3 +57,4 @@ export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
 export * from "./dynamic.js";
+export * from "./streamDedup.js";

package/dist/types/index.js

@@ -60,3 +60,5 @@ export * from "./imageGen.js";
 export * from "./elicitation.js";
 // Dynamic Arguments types
 export * from "./dynamic.js";
+// Curator P2-4 dedup: per-stream AsyncLocalStorage context
+export * from "./streamDedup.js";

package/dist/types/streamDedup.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Curator P2-4 dedup (concurrency-safe): per-stream context that lets
+ * the orchestration's `runStandardStreamRequest` finally block know
+ * whether a *native provider* path within THIS stream's async chain
+ * already emitted `generation:end`. Native providers (Vertex / Google
+ * AI Studio for Gemini 3, etc.) emit on the shared SDK emitter; without
+ * scoping, a concurrent unrelated stream's emit on the same NeuroLink
+ * instance would suppress the wrong stream's orchestration emit.
+ *
+ * AsyncLocalStorage scopes each stream's flag to its own async chain.
+ */
+export type StreamGenerationEndContext = {
+    providerEmitted: boolean;
+};

package/dist/types/streamDedup.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.59.0",
+  "version": "9.59.1",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {