@juspay/neurolink 12.34.1 → 12.34.3

package/dist/providers/openaiChatCompletionsBase.js

@@ -1812,6 +1812,20 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // `loopPromise` is undefined when a middleware blocked the request
                 // before `doStream` ran, in which case there is no loop to surface.
                 await loopPromise;
+                // Record the terminal finish reason on the metadata object this
+                // provider returns by reference (`result.metadata`). A rejected
+                // `loopPromise` throws out of this `await` straight into the `catch`
+                // below, so reaching this line means `runStreamLoop` returned
+                // normally and already called `resolveFinish` with the wire value —
+                // `finishPromise` is settled, not pending.
+                //
+                // `rawFinishReason` is the verbatim vendor value (e.g. "stop",
+                // "length", "tool_calls", "content_filter") and is accurate the
+                // moment the wire stream itself finished, independent of whatever
+                // post-stream work follows. The graded `finishReason` is set later,
+                // once that post-stream work (the structured-output re-ask below)
+                // has actually succeeded — see the assignment after that block.
+                streamMetadata.rawFinishReason = await finishPromise;
                 // Structured output for a `stream({ schema })` turn. Runs HERE —
                 // after the stream is fully drained — so a tool-free re-ask (when the
                 // streamed answer isn't already schema-valid) never reaches
@@ -1853,6 +1867,12 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         });
                     }
                 }
+                // Only reached once the structured-output re-ask above (when there
+                // was one) has resolved without throwing. A caller abort during that
+                // re-ask rejects `resolveStreamStructuredData` and skips this line
+                // entirely, so `metadata.finishReason` never claims "stop" for a
+                // turn that actually failed after the wire stream itself finished.
+                streamMetadata.finishReason = "stop";
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
                 // Pipeline B (ContextEnricher) surfaces a WARNING-level Langfuse

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.1",
+  "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": {