@juspay/neurolink 12.34.2 → 12.34.3

package/dist/services/server/ai/observability/instrumentation.d.ts

@@ -51,6 +51,11 @@ export declare function initializeOpenTelemetry(config: LangfuseConfig): Promise
 export declare function flushOpenTelemetry(): Promise<void>;
 /**
  * Shutdown OpenTelemetry and Langfuse span processor
+ *
+ * Concurrent callers share one in-flight teardown, the same way concurrent
+ * initializers share one in-flight `initializeOpenTelemetry`: a second
+ * shutdown call joins the first instead of tearing down the same provider
+ * instances a second time.
  */
 export declare function shutdownOpenTelemetry(): Promise<void>;
 /**

package/dist/services/server/ai/observability/instrumentation.js

@@ -106,6 +106,7 @@ let loggerProvider = null;
 let langfuseProcessor = null;
 let isInitialized = false;
 let initializationPromise = null;
+let shutdownPromise = null;
 let isCredentialsValid = false;
 let currentConfig = null;
 let usingExternalProvider = false;
@@ -841,6 +842,15 @@ async function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpo
  * flush or shutdown wait for the same initialization before touching providers.
  */
 export async function initializeOpenTelemetry(config) {
+    if (shutdownPromise) {
+        // A shutdown already in flight is what made isInitialized/
+        // initializationPromise true or null in the first place; either reading
+        // is stale until it actually finishes. Waiting here means this call sees
+        // the settled post-teardown state — nothing initialized, nothing
+        // pending — and falls through to build fresh providers, rather than
+        // returning early on a flag that is about to flip out from under it.
+        await shutdownPromise;
+    }
     if (isInitialized) {
         currentConfig = config;
         logger.debug(`${LOG_PREFIX} Already initialized, config updated`, {
@@ -991,8 +1001,29 @@ export async function flushOpenTelemetry() {
 }
 /**
  * Shutdown OpenTelemetry and Langfuse span processor
+ *
+ * Concurrent callers share one in-flight teardown, the same way concurrent
+ * initializers share one in-flight `initializeOpenTelemetry`: a second
+ * shutdown call joins the first instead of tearing down the same provider
+ * instances a second time.
  */
 export async function shutdownOpenTelemetry() {
+    if (shutdownPromise) {
+        await shutdownPromise;
+        return;
+    }
+    const pending = shutdownOpenTelemetryOnce();
+    shutdownPromise = pending;
+    try {
+        await pending;
+    }
+    finally {
+        if (shutdownPromise === pending) {
+            shutdownPromise = null;
+        }
+    }
+}
+async function shutdownOpenTelemetryOnce() {
     if (initializationPromise) {
         try {
             await initializationPromise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.34.2",
+  "version": "12.34.3",
   "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": {