@juspay/neurolink 12.33.0 → 12.34.1

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

@@ -7,23 +7,17 @@
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
 import { metrics, SpanStatusCode, trace, } from "@opentelemetry/api";
-import { W3CTraceContextPropagator } from "@opentelemetry/core";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
-import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
-import { BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "async_hooks";
 import { extractMcpErrorText } from "../../../../utils/mcpErrorText.js";
 import { logger } from "../../../../utils/logger.js";
 import { tryImport } from "../../../../utils/tryImport.js";
 import { LANGFUSE_ATTR } from "../../../../telemetry/attributes.js";
 const LOG_PREFIX = "[OpenTelemetry]";
-function createOtelResource(config, serviceName) {
+async function createOtelResource(config, serviceName) {
+    const [{ resourceFromAttributes }, { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION },] = await Promise.all([
+        import("@opentelemetry/resources"),
+        import("@opentelemetry/semantic-conventions"),
+    ]);
     return resourceFromAttributes({
         [ATTR_SERVICE_NAME]: serviceName,
         [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
@@ -32,13 +26,19 @@ function createOtelResource(config, serviceName) {
 }
 /**
  * Configure OTLP metrics and logs with bounded serialization batches for
- * request-serving processes.
+ * request-serving processes. Initialization awaits this so a caller may flush
+ * or shut down immediately after it returns without racing providers that have
+ * not been constructed yet. Signal-specific failures stay non-fatal here.
  */
-function initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName) {
+async function initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName) {
     if (!otlpEndpoint) {
         return;
     }
     try {
+        const [{ OTLPMetricExporter }, { MeterProvider, PeriodicExportingMetricReader },] = await Promise.all([
+            import("@opentelemetry/exporter-metrics-otlp-http"),
+            import("@opentelemetry/sdk-metrics"),
+        ]);
         const metricExporter = new OTLPMetricExporter({
             url: `${otlpEndpoint}/v1/metrics`,
         });
@@ -68,6 +68,10 @@ function initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName) {
         });
     }
     try {
+        const [{ OTLPLogExporter }, { BatchLogRecordProcessor, LoggerProvider }] = await Promise.all([
+            import("@opentelemetry/exporter-logs-otlp-http"),
+            import("@opentelemetry/sdk-logs"),
+        ]);
         const logExporter = new OTLPLogExporter({
             url: `${otlpEndpoint}/v1/logs`,
         });
@@ -101,6 +105,7 @@ let meterProvider = null;
 let loggerProvider = null;
 let langfuseProcessor = null;
 let isInitialized = false;
+let initializationPromise = null;
 let isCredentialsValid = false;
 let currentConfig = null;
 let usingExternalProvider = false;
@@ -637,8 +642,8 @@ async function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoin
                 ? await createLangfuseProcessor(config)
                 : null;
         usingExternalProvider = true;
+        await initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
         isInitialized = true;
-        initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
         try {
             const globalProvider = trace.getTracerProvider();
             const provider = globalProvider;
@@ -759,6 +764,10 @@ async function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpo
         }
         if (otlpEndpoint) {
             try {
+                const [{ OTLPTraceExporter }, { BatchSpanProcessor }] = await Promise.all([
+                    import("@opentelemetry/exporter-trace-otlp-http"),
+                    import("@opentelemetry/sdk-trace-base"),
+                ]);
                 const otlpExporter = new OTLPTraceExporter({
                     url: `${otlpEndpoint}/v1/traces`,
                 });
@@ -782,13 +791,17 @@ async function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpo
                 });
             }
         }
+        const [{ NodeTracerProvider }, { W3CTraceContextPropagator }] = await Promise.all([
+            import("@opentelemetry/sdk-trace-node"),
+            import("@opentelemetry/core"),
+        ]);
         tracerProvider = new NodeTracerProvider({ resource, spanProcessors });
         tracerProvider.register({
             propagator: new W3CTraceContextPropagator(),
         });
         usingExternalProvider = false;
+        await initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
         isInitialized = true;
-        initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
         logger.info(`${LOG_PREFIX} Observability initialized`, {
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
@@ -820,6 +833,39 @@ async function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpo
         throw error;
     }
 }
+/**
+ * Initialize OpenTelemetry once and let concurrent callers share the work.
+ *
+ * NeuroLink constructors intentionally start this asynchronously. Keeping the
+ * in-flight promise here lets another constructor join it and lets an immediate
+ * flush or shutdown wait for the same initialization before touching providers.
+ */
+export async function initializeOpenTelemetry(config) {
+    if (isInitialized) {
+        currentConfig = config;
+        logger.debug(`${LOG_PREFIX} Already initialized, config updated`, {
+            usingExternalProvider,
+            hasLangfuseProcessor: !!langfuseProcessor,
+            hasTraceNameFormat: typeof config.traceNameFormat === "function",
+        });
+        return;
+    }
+    if (initializationPromise) {
+        await initializationPromise;
+        currentConfig = config;
+        return;
+    }
+    const pending = initializeOpenTelemetryOnce(config);
+    initializationPromise = pending;
+    try {
+        await pending;
+    }
+    finally {
+        if (initializationPromise === pending) {
+            initializationPromise = null;
+        }
+    }
+}
 /**
  * Initialize OpenTelemetry with Langfuse span processor
  *
@@ -834,20 +880,7 @@ async function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpo
  *
  * @param config - Langfuse configuration passed from parent application
  */
-export async function initializeOpenTelemetry(config) {
-    // Guard against multiple initializations — but always update config
-    // so that later NeuroLink instances can change traceNameFormat,
-    // autoDetectOperationName, and other configuration preferences
-    // without re-initializing the OTEL infrastructure.
-    if (isInitialized) {
-        currentConfig = config;
-        logger.debug(`${LOG_PREFIX} Already initialized, config updated`, {
-            usingExternalProvider,
-            hasLangfuseProcessor: !!langfuseProcessor,
-            hasTraceNameFormat: typeof config.traceNameFormat === "function",
-        });
-        return;
-    }
+async function initializeOpenTelemetryOnce(config) {
     // FIRST: Check for external provider mode - bypasses enabled check
     // NOTE: When autoDetectExternalProvider is true, we trust the flag directly rather than
     // calling hasExternalTracerProvider(). This is because Neurolink may bundle its own copy
@@ -862,7 +895,7 @@ export async function initializeOpenTelemetry(config) {
     const langfuseRequested = config?.enabled === true;
     const hasLangfuseCreds = !!config.publicKey && !!config.secretKey;
     const serviceName = process.env.OTEL_SERVICE_NAME || "neurolink";
-    const resource = createOtelResource(config, serviceName);
+    const resource = await createOtelResource(config, serviceName);
     if (shouldUseExternal) {
         await initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
         return;
@@ -873,6 +906,15 @@ export async function initializeOpenTelemetry(config) {
  * Flush all pending spans to Langfuse
  */
 export async function flushOpenTelemetry() {
+    if (initializationPromise) {
+        try {
+            await initializationPromise;
+        }
+        catch {
+            // Initialization owns its error logging; a failed init leaves nothing
+            // initialized, so the check below skips the flush as it always has.
+        }
+    }
     if (!isInitialized) {
         logger.debug(`${LOG_PREFIX} Not initialized, skipping flush`);
         return;
@@ -951,8 +993,14 @@ export async function flushOpenTelemetry() {
  * Shutdown OpenTelemetry and Langfuse span processor
  */
 export async function shutdownOpenTelemetry() {
-    if (!isInitialized) {
-        return;
+    if (initializationPromise) {
+        try {
+            await initializationPromise;
+        }
+        catch {
+            // Initialization owns its error logging. Continue so any provider it
+            // created before failing is still shut down below.
+        }
     }
     try {
         // Only shutdown tracerProvider if we created it

package/dist/utils/modelChoices.js

@@ -103,14 +103,6 @@ const TOP_MODELS_CONFIG = {
             model: GoogleAIModels.GEMINI_3_PRO_PREVIEW,
             description: "Latest preview",
         },
-        {
-            model: GoogleAIModels.GEMINI_1_5_PRO,
-            description: "Previous generation",
-        },
-        {
-            model: GoogleAIModels.GEMINI_1_5_FLASH,
-            description: "Legacy fast model",
-        },
     ],
     [AIProviderName.VERTEX]: [
         {
@@ -126,7 +118,6 @@ const TOP_MODELS_CONFIG = {
             model: VertexModels.GEMINI_2_0_FLASH,
             description: "Stable production model",
         },
-        { model: VertexModels.GEMINI_1_5_PRO, description: "Previous generation" },
         {
             model: VertexModels.CLAUDE_3_5_SONNET,
             description: "Claude 3.5 on Vertex",

package/dist/utils/pricing.js

@@ -685,6 +685,11 @@ const PRICING = {
         // Voyage bills per million input tokens — output dimension is the
         // embedding vector, not generated tokens. We charge to input only.
         _default: { input: 0.18 / 1_000_000, output: 0 },
+        // Voyage 4 family — docs.voyageai.com/docs/embeddings pricing table
+        "voyage-4": { input: 0.06 / 1_000_000, output: 0 },
+        "voyage-4-large": { input: 0.12 / 1_000_000, output: 0 },
+        "voyage-4-lite": { input: 0.02 / 1_000_000, output: 0 },
+        "voyage-code-4": { input: 0.12 / 1_000_000, output: 0 },
         "voyage-3.5": { input: 0.06 / 1_000_000, output: 0 },
         "voyage-3.5-lite": { input: 0.02 / 1_000_000, output: 0 },
         "voyage-3-large": { input: 0.18 / 1_000_000, output: 0 },

package/dist/utils/providerHealth.js

@@ -423,7 +423,7 @@ export class ProviderHealthChecker {
                 healthStatus.recommendations.push(`Available models for ${providerName} (using dual provider architecture):\n` +
                     `  Google Models (via vertex provider):\n` +
                     `    • gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite\n` +
-                    `    • gemini-2.0-flash-001, gemini-1.5-pro, gemini-1.5-flash\n` +
+                    `    • gemini-2.0-flash-001, gemini-2.0-flash-lite\n` +
                     `  Anthropic Models (via vertexAnthropic provider):\n` +
                     `    • claude-sonnet-4@20250514, claude-opus-4@20250514\n` +
                     `    • claude-3-5-sonnet-20241022, claude-3-5-haiku-20241022\n` +
@@ -771,7 +771,7 @@ export class ProviderHealthChecker {
         return new URL("/v1/models", this.getLiteLLMBaseUrl()).toString();
     }
     static getConfiguredLiteLLMModel() {
-        return process.env.LITELLM_MODEL || "openai/gpt-4o-mini";
+        return process.env.LITELLM_MODEL || "openai/gpt-5.4-mini";
     }
     static getOllamaBaseUrl() {
         return (process.env.OLLAMA_BASE_URL ||
@@ -914,7 +914,7 @@ export class ProviderHealthChecker {
             return { ran: false, failed: false };
         }
         // Only pin the availability check to a specific model when the user
-        // explicitly configured one. The fallback default ("openai/gpt-4o-mini")
+        // explicitly configured one. The fallback default ("openai/gpt-5.4-mini")
         // is a guess, not configuration — proxies that serve a different model
         // set (every self-hosted gateway) were reported "Not configured" here
         // while generate/stream against them worked fine with explicit models.
@@ -1002,9 +1002,9 @@ export class ProviderHealthChecker {
                 ];
             case AIProviderName.GOOGLE_AI:
                 return [
-                    GoogleAIModels.GEMINI_1_5_PRO,
-                    GoogleAIModels.GEMINI_1_5_FLASH,
                     GoogleAIModels.GEMINI_2_5_PRO,
+                    GoogleAIModels.GEMINI_2_5_FLASH,
+                    GoogleAIModels.GEMINI_2_0_FLASH_001,
                 ];
             case AIProviderName.VERTEX:
                 return [
@@ -1013,8 +1013,6 @@ export class ProviderHealthChecker {
                     GoogleAIModels.GEMINI_2_5_FLASH,
                     GoogleAIModels.GEMINI_2_5_FLASH_LITE,
                     GoogleAIModels.GEMINI_2_0_FLASH_001,
-                    GoogleAIModels.GEMINI_1_5_PRO,
-                    GoogleAIModels.GEMINI_1_5_FLASH,
                     // Anthropic models (via vertexAnthropic provider)
                     "claude-sonnet-4@20250514",
                     "claude-opus-4@20250514",
@@ -1030,8 +1028,8 @@ export class ProviderHealthChecker {
                 return [OpenAIModels.GPT_4O, OpenAIModels.GPT_4O_MINI, "gpt-35-turbo"];
             case AIProviderName.LITELLM:
                 return [
-                    "openai/gpt-4o-mini",
-                    "anthropic/claude-3-haiku",
+                    "openai/gpt-5.4-mini",
+                    "anthropic/claude-haiku-4-5-20251001",
                     "google/gemini-2.5-flash",
                 ];
             case AIProviderName.OLLAMA: {

package/dist/utils/redis.js

@@ -3,7 +3,6 @@
  * Helper functions for Redis storage operations
  */
 import { randomUUID } from "crypto";
-import { createClient } from "redis";
 import { logger } from "./logger.js";
 const SESSION_ONLY_PREFIX = "session-only:";
 /** Characters that end the authority (`user:pass@host:port`) of a URL in text. */
@@ -195,6 +194,9 @@ export async function createRedisClient(config) {
     if (config.password && !config.url) {
         clientOptions.password = config.password;
     }
+    // Imported here, not at the top: the redis client is ~590 modules, a quarter
+    // of everything importing the SDK loaded, and most callers never connect.
+    const { createClient } = await import("redis");
     // Create client with secured options
     const client = createClient(clientOptions);
     client.on("error", (err) => {

package/dist/utils/tokenLimits.js

@@ -119,6 +119,15 @@ export function getClaudeMaxOutputTokens(model) {
     if (/sonnet[-_.]?4/.test(m) || /haiku[-_.]?4/.test(m)) {
         return 64000;
     }
+    // Claude 5.x family (Opus 5 / Opus 5.5 / Sonnet 5 / Fable 5.1 / Mythos):
+    // all confirmed at 128K standard max output on
+    // platform.claude.com/docs/en/about-claude/models/overview. The
+    // (?![0-9]) guard keeps this off dated 4.x ids like "opus-4-5-20251101"
+    // (Opus 4.5, not Opus 5), where the family word sits before the "4", not
+    // directly before this "5".
+    if (/(?:opus|sonnet|fable|mythos)[-_.]?5(?![0-9])/.test(m)) {
+        return 128000;
+    }
     // Claude 3.7 Sonnet supports 64K output.
     if (/3[-_.]?7[-_.]?sonnet/.test(m)) {
         return 64000;

package/dist/workflow/workflows/multiJudgeWorkflow.js

@@ -277,8 +277,8 @@ export function createMultiJudgeWorkflow(modelCount, judgeCount) {
         },
         {
             provider: AIProviderName.GOOGLE_AI,
-            model: "gemini-1.5-flash",
-            label: "Gemini 1.5 Flash",
+            model: "gemini-2.5-flash",
+            label: "Gemini 2.5 Flash",
             weight: 0.8,
             temperature: 0.7,
         },