@juspay/neurolink 7.48.1 → 7.50.0

package/dist/neurolink.js

@@ -39,6 +39,7 @@ import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 // Import orchestration components
 import { ModelRouter } from "./utils/modelRouter.js";
 import { BinaryTaskClassifier } from "./utils/taskClassifier.js";
+import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, } from "./services/server/ai/observability/instrumentation.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
 import { isZodSchema } from "./utils/schemaConversion.js";
 // Core types imported from "./types/index.js"
@@ -178,8 +179,10 @@ export class NeuroLink {
      * @throws {Error} When external server manager initialization fails
      * @throws {Error} When HITL configuration is invalid (if enabled)
      */
+    observabilityConfig;
     constructor(config) {
         this.toolRegistry = config?.toolRegistry || new MCPToolRegistry();
+        this.observabilityConfig = config?.observability;
         // Initialize orchestration setting
         this.enableOrchestration = config?.enableOrchestration ?? false;
         // Read tool cache duration from environment variables, with a default
@@ -194,6 +197,7 @@ export class NeuroLink {
         this.initializeConversationMemory(config, constructorId, constructorStartTime, constructorHrTimeStart);
         this.initializeExternalServerManager(constructorId, constructorStartTime, constructorHrTimeStart);
         this.initializeHITL(config, constructorId, constructorStartTime, constructorHrTimeStart);
+        this.initializeLangfuse(constructorId, constructorStartTime, constructorHrTimeStart);
         this.logConstructorComplete(constructorId, constructorStartTime, constructorHrTimeStart);
     }
     /**
@@ -494,6 +498,81 @@ export class NeuroLink {
             this.unregisterExternalMCPToolFromRegistry(event.toolName);
         });
     }
+    /**
+     * Initialize Langfuse observability for AI operations tracking
+     */
+    initializeLangfuse(constructorId, constructorStartTime, constructorHrTimeStart) {
+        const langfuseInitStartTime = process.hrtime.bigint();
+        try {
+            const langfuseConfig = this.observabilityConfig?.langfuse;
+            if (langfuseConfig?.enabled) {
+                logger.debug(`[NeuroLink] 📊 LOG_POINT_C019_LANGFUSE_INIT_START`, {
+                    logPoint: "C019_LANGFUSE_INIT_START",
+                    constructorId,
+                    timestamp: new Date().toISOString(),
+                    elapsedMs: Date.now() - constructorStartTime,
+                    elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                    langfuseInitStartTimeNs: langfuseInitStartTime.toString(),
+                    message: "Starting Langfuse observability initialization",
+                });
+                // Initialize OpenTelemetry FIRST (required for Langfuse v4)
+                initializeOpenTelemetry(langfuseConfig);
+                const healthStatus = getLangfuseHealthStatus();
+                const langfuseInitDurationNs = process.hrtime.bigint() - langfuseInitStartTime;
+                if (healthStatus.initialized &&
+                    healthStatus.hasProcessor &&
+                    healthStatus.isHealthy) {
+                    logger.debug(`[NeuroLink] ✅ LOG_POINT_C020_LANGFUSE_INIT_SUCCESS`, {
+                        logPoint: "C020_LANGFUSE_INIT_SUCCESS",
+                        constructorId,
+                        timestamp: new Date().toISOString(),
+                        elapsedMs: Date.now() - constructorStartTime,
+                        elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                        langfuseInitDurationNs: langfuseInitDurationNs.toString(),
+                        langfuseInitDurationMs: Number(langfuseInitDurationNs) / 1_000_000,
+                        healthStatus,
+                        message: "Langfuse observability initialized successfully",
+                    });
+                }
+                else {
+                    logger.warn(`[NeuroLink] ⚠️ LOG_POINT_C021_LANGFUSE_INIT_WARNING`, {
+                        logPoint: "C021_LANGFUSE_INIT_WARNING",
+                        constructorId,
+                        timestamp: new Date().toISOString(),
+                        elapsedMs: Date.now() - constructorStartTime,
+                        elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                        langfuseInitDurationNs: langfuseInitDurationNs.toString(),
+                        healthStatus,
+                        message: "Langfuse initialized but not healthy",
+                    });
+                }
+            }
+            else {
+                logger.debug(`[NeuroLink] 🚫 LOG_POINT_C022_LANGFUSE_DISABLED`, {
+                    logPoint: "C022_LANGFUSE_DISABLED",
+                    constructorId,
+                    timestamp: new Date().toISOString(),
+                    elapsedMs: Date.now() - constructorStartTime,
+                    elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                    message: "Langfuse observability not enabled - skipping initialization",
+                });
+            }
+        }
+        catch (error) {
+            const langfuseInitErrorDurationNs = process.hrtime.bigint() - langfuseInitStartTime;
+            logger.error(`[NeuroLink] ❌ LOG_POINT_C023_LANGFUSE_INIT_ERROR`, {
+                logPoint: "C023_LANGFUSE_INIT_ERROR",
+                constructorId,
+                timestamp: new Date().toISOString(),
+                elapsedMs: Date.now() - constructorStartTime,
+                elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                langfuseInitDurationNs: langfuseInitErrorDurationNs.toString(),
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorStack: error instanceof Error ? error.stack : undefined,
+                message: "Langfuse observability initialization failed",
+            });
+        }
+    }
     /**
      * Log constructor completion with final state summary
      */
@@ -992,6 +1071,68 @@ export class NeuroLink {
      * @throws {Error} When all providers fail to generate content
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
+    /**
+     * Get observability configuration
+     */
+    getObservabilityConfig() {
+        return this.observabilityConfig;
+    }
+    /**
+     * Check if Langfuse telemetry is enabled
+     * Centralized utility to avoid duplication across providers
+     */
+    isTelemetryEnabled() {
+        return this.observabilityConfig?.langfuse?.enabled || false;
+    }
+    /**
+     * Public method to initialize Langfuse observability
+     * This method can be called externally to ensure Langfuse is properly initialized
+     */
+    async initializeLangfuseObservability() {
+        try {
+            const langfuseConfig = this.observabilityConfig?.langfuse;
+            if (langfuseConfig?.enabled) {
+                initializeOpenTelemetry(langfuseConfig);
+                logger.debug("[NeuroLink] Langfuse observability initialized via public method");
+            }
+            else {
+                logger.debug("[NeuroLink] Langfuse not enabled, skipping initialization");
+            }
+        }
+        catch (error) {
+            logger.warn("[NeuroLink] Failed to initialize Langfuse observability:", error);
+        }
+    }
+    /**
+     * Gracefully shutdown NeuroLink and all MCP connections
+     */
+    async shutdown() {
+        try {
+            logger.debug("[NeuroLink] Starting graceful shutdown");
+            try {
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+                logger.debug("[NeuroLink] OpenTelemetry shutdown completed");
+            }
+            catch (error) {
+                logger.warn("[NeuroLink] OpenTelemetry shutdown failed:", error);
+            }
+            if (this.externalServerManager) {
+                try {
+                    await this.externalServerManager.shutdown();
+                    logger.debug("[NeuroLink] MCP servers shutdown completed");
+                }
+                catch (error) {
+                    logger.warn("[NeuroLink] MCP servers shutdown failed:", error);
+                }
+            }
+            logger.debug("[NeuroLink] Graceful shutdown completed");
+        }
+        catch (error) {
+            logger.error("[NeuroLink] Shutdown failed:", error);
+            throw error;
+        }
+    }
     async generate(optionsOrPrompt) {
         const originalPrompt = this._extractOriginalPrompt(optionsOrPrompt);
         // Convert string prompt to full options

package/dist/providers/anthropic.js

@@ -7,7 +7,7 @@ import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
-import { buildMessagesArray } from "../utils/messageBuilder.js";
+import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
@@ -92,8 +92,51 @@ export class AnthropicProvider extends BaseProvider {
             // ✅ Get tools for streaming (same as generate method)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
-            // Build message array from options
-            const messages = buildMessagesArray(options);
+            // Build message array from options with multimodal support
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
+            let messages;
+            if (hasMultimodalInput) {
+                logger.debug(`Anthropic: Detected multimodal input, using multimodal message builder`, {
+                    hasImages: !!options.input?.images?.length,
+                    imageCount: options.input?.images?.length || 0,
+                    hasContent: !!options.input?.content?.length,
+                    contentCount: options.input?.content?.length || 0,
+                    hasFiles: !!options.input?.files?.length,
+                    fileCount: options.input?.files?.length || 0,
+                    hasCSVFiles: !!options.input?.csvFiles?.length,
+                    csvFileCount: options.input?.csvFiles?.length || 0,
+                });
+                // Create multimodal options for buildMultimodalMessagesArray
+                const multimodalOptions = {
+                    input: {
+                        text: options.input?.text || "",
+                        images: options.input?.images,
+                        content: options.input?.content,
+                        files: options.input?.files,
+                        csvFiles: options.input?.csvFiles,
+                    },
+                    csvOptions: options.csvOptions,
+                    systemPrompt: options.systemPrompt,
+                    conversationHistory: options.conversationMessages,
+                    provider: this.providerName,
+                    model: this.modelName,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    enableAnalytics: options.enableAnalytics,
+                    enableEvaluation: options.enableEvaluation,
+                    context: options.context,
+                };
+                const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
+                messages = convertToCoreMessages(mm);
+            }
+            else {
+                logger.debug(`Anthropic: Text-only input, using standard message builder`);
+                messages = await buildMessagesArray(options);
+            }
             const model = await this.getAISDKModelWithMiddleware(options);
             const result = await streamText({
                 model: model,
@@ -104,6 +147,7 @@ export class AnthropicProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                experimental_telemetry: this.getStreamTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[AnthropicProvider] Failed to store tool executions", {

package/dist/providers/azureOpenai.js

@@ -110,7 +110,10 @@ export class AzureOpenAIProvider extends BaseProvider {
                 });
             }
             // Build message array from options with multimodal support
-            const hasMultimodalInput = !!(options.input?.images?.length || options.input?.content?.length);
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`Azure OpenAI: Detected multimodal input, using multimodal message builder`, {
@@ -125,7 +128,10 @@ export class AzureOpenAIProvider extends BaseProvider {
                         text: options.input?.text || "",
                         images: options.input?.images,
                         content: options.input?.content,
+                        files: options.input?.files,
+                        csvFiles: options.input?.csvFiles,
                     },
+                    csvOptions: options.csvOptions,
                     systemPrompt: options.systemPrompt,
                     conversationHistory: options.conversationMessages,
                     provider: this.providerName,
@@ -142,7 +148,7 @@ export class AzureOpenAIProvider extends BaseProvider {
             }
             else {
                 logger.debug(`Azure OpenAI: Text-only input, using standard message builder`);
-                messages = buildMessagesArray(options);
+                messages = await buildMessagesArray(options);
             }
             const model = await this.getAISDKModelWithMiddleware(options);
             const stream = await streamText({
@@ -156,6 +162,7 @@ export class AzureOpenAIProvider extends BaseProvider {
                     : {}),
                 tools,
                 toolChoice: shouldUseTools ? "auto" : "none",
+                experimental_telemetry: this.getStreamTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {

package/dist/providers/googleAiStudio.js

@@ -92,7 +92,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
             // Build message array from options with multimodal support
-            const hasMultimodalInput = !!(options.input?.images?.length || options.input?.content?.length);
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`Google AI Studio: Detected multimodal input, using multimodal message builder`, {
@@ -107,7 +110,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         text: options.input?.text || "",
                         images: options.input?.images,
                         content: options.input?.content,
+                        files: options.input?.files,
+                        csvFiles: options.input?.csvFiles,
                     },
+                    csvOptions: options.csvOptions,
                     systemPrompt: options.systemPrompt,
                     conversationHistory: options.conversationMessages,
                     provider: this.providerName,
@@ -124,7 +130,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             }
             else {
                 logger.debug(`Google AI Studio: Text-only input, using standard message builder`);
-                messages = buildMessagesArray(options);
+                messages = await buildMessagesArray(options);
             }
             const result = await streamText({
                 model,
@@ -135,6 +141,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                experimental_telemetry: this.getStreamTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[GoogleAiStudioProvider] Failed to store tool executions", {

package/dist/providers/googleVertex.js

@@ -596,7 +596,10 @@ export class GoogleVertexProvider extends BaseProvider {
             // Validate stream options
             this.validateStreamOptionsOnly(options);
             // Build message array from options with multimodal support
-            const hasMultimodalInput = !!(options.input?.images?.length || options.input?.content?.length);
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`${functionTag}: Detected multimodal input, using multimodal message builder`, {
@@ -611,7 +614,10 @@ export class GoogleVertexProvider extends BaseProvider {
                         text: options.input?.text || "",
                         images: options.input?.images,
                         content: options.input?.content,
+                        files: options.input?.files,
+                        csvFiles: options.input?.csvFiles,
                     },
+                    csvOptions: options.csvOptions,
                     systemPrompt: options.systemPrompt,
                     conversationHistory: options.conversationMessages,
                     provider: this.providerName,
@@ -628,7 +634,7 @@ export class GoogleVertexProvider extends BaseProvider {
             }
             else {
                 logger.debug(`${functionTag}: Text-only input, using standard message builder`);
-                messages = buildMessagesArray(options);
+                messages = await buildMessagesArray(options);
             }
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             // Get all available tools (direct + MCP + external) for streaming
@@ -660,6 +666,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
                 abortSignal: timeoutController?.controller.signal,
+                experimental_telemetry: this.getStreamTelemetryConfig(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -937,6 +944,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 modelName,
                 issue: modelValidation.issue,
                 recommendedModels: [
+                    "claude-sonnet-4-5@20250929",
                     "claude-sonnet-4@20250514",
                     "claude-opus-4@20250514",
                     "claude-3-5-sonnet-20241022",
@@ -1169,6 +1177,7 @@ export class GoogleVertexProvider extends BaseProvider {
         // Validate against known Claude model patterns
         const validPatterns = [
             /^claude-sonnet-4@\d{8}$/,
+            /^claude-sonnet-4-5@\d{8}$/,
             /^claude-opus-4@\d{8}$/,
             /^claude-3-5-sonnet-\d{8}$/,
             /^claude-3-5-haiku-\d{8}$/,
@@ -1390,6 +1399,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 "gemini-1.5-flash",
             ],
             claude: [
+                "claude-sonnet-4-5@20250929",
                 "claude-sonnet-4@20250514",
                 "claude-opus-4@20250514",
                 "claude-3-5-sonnet-20241022",

package/dist/providers/huggingFace.js

@@ -114,7 +114,7 @@ export class HuggingFaceProvider extends BaseProvider {
             // Enhanced tool handling for HuggingFace models
             const streamOptions = this.prepareStreamOptions(options, analysisSchema);
             // Build message array from options
-            const messages = buildMessagesArray(options);
+            const messages = await buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
                 messages: messages,

package/dist/providers/litellm.js

@@ -121,7 +121,7 @@ export class LiteLLMProvider extends BaseProvider {
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
             // Build message array from options
-            const messages = buildMessagesArray(options);
+            const messages = await buildMessagesArray(options);
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             const result = streamText({
                 model: model,

package/dist/providers/mistral.js

@@ -49,7 +49,7 @@ export class MistralProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
-            const messages = buildMessagesArray(options);
+            const messages = await buildMessagesArray(options);
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             const result = await streamText({
                 model,

package/dist/providers/openAI.js

@@ -8,7 +8,7 @@ import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, Ra
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
-import { buildMessagesArray } from "../utils/messageBuilder.js";
+import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
 // Configuration helpers - now using consolidated utility
@@ -244,8 +244,51 @@ export class OpenAIProvider extends BaseProvider {
                 toolNames: Object.keys(tools),
                 filteredOutTools: Object.keys(allTools).filter((name) => !tools[name]),
             });
-            // Build message array from options
-            const messages = buildMessagesArray(options);
+            // Build message array from options with multimodal support
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length);
+            let messages;
+            if (hasMultimodalInput) {
+                logger.debug(`OpenAI: Detected multimodal input, using multimodal message builder`, {
+                    hasImages: !!options.input?.images?.length,
+                    imageCount: options.input?.images?.length || 0,
+                    hasContent: !!options.input?.content?.length,
+                    contentCount: options.input?.content?.length || 0,
+                    hasFiles: !!options.input?.files?.length,
+                    fileCount: options.input?.files?.length || 0,
+                    hasCSVFiles: !!options.input?.csvFiles?.length,
+                    csvFileCount: options.input?.csvFiles?.length || 0,
+                });
+                // Create multimodal options for buildMultimodalMessagesArray
+                const multimodalOptions = {
+                    input: {
+                        text: options.input?.text || "",
+                        images: options.input?.images,
+                        content: options.input?.content,
+                        files: options.input?.files,
+                        csvFiles: options.input?.csvFiles,
+                    },
+                    csvOptions: options.csvOptions,
+                    systemPrompt: options.systemPrompt,
+                    conversationHistory: options.conversationMessages,
+                    provider: this.providerName,
+                    model: this.modelName,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    enableAnalytics: options.enableAnalytics,
+                    enableEvaluation: options.enableEvaluation,
+                    context: options.context,
+                };
+                const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
+                messages = convertToCoreMessages(mm);
+            }
+            else {
+                logger.debug(`OpenAI: Text-only input, using standard message builder`);
+                messages = await buildMessagesArray(options);
+            }
             // Debug the actual request being sent to OpenAI
             logger.debug(`OpenAI: streamText request parameters:`, {
                 modelName: this.modelName,
@@ -273,6 +316,7 @@ export class OpenAIProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                experimental_telemetry: this.getStreamTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });
                     // Handle tool execution storage

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

@@ -0,0 +1,57 @@
+/**
+ * OpenTelemetry Instrumentation for Langfuse v4
+ *
+ * Configures OpenTelemetry TracerProvider with LangfuseSpanProcessor to capture
+ * traces from Vercel AI SDK's experimental_telemetry feature.
+ *
+ * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
+ */
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import type { LangfuseConfig } from "../../../../types/observability.js";
+/**
+ * Initialize OpenTelemetry with Langfuse span processor
+ *
+ * This connects Vercel AI SDK's experimental_telemetry to Langfuse by:
+ * 1. Creating LangfuseSpanProcessor with Langfuse credentials
+ * 2. Creating a NodeTracerProvider with service metadata and span processor
+ * 3. Registering the provider globally for AI SDK to use
+ *
+ * @param config - Langfuse configuration passed from parent application
+ */
+export declare function initializeOpenTelemetry(config: LangfuseConfig): void;
+/**
+ * Flush all pending spans to Langfuse
+ */
+export declare function flushOpenTelemetry(): Promise<void>;
+/**
+ * Shutdown OpenTelemetry and Langfuse span processor
+ */
+export declare function shutdownOpenTelemetry(): Promise<void>;
+/**
+ * Get the Langfuse span processor
+ */
+export declare function getLangfuseSpanProcessor(): LangfuseSpanProcessor | null;
+/**
+ * Get the tracer provider
+ */
+export declare function getTracerProvider(): NodeTracerProvider | null;
+/**
+ * Check if OpenTelemetry is initialized
+ */
+export declare function isOpenTelemetryInitialized(): boolean;
+/**
+ * Get health status for Langfuse observability
+ */
+export declare function getLangfuseHealthStatus(): {
+    isHealthy: boolean | undefined;
+    initialized: boolean;
+    credentialsValid: boolean;
+    enabled: boolean;
+    hasProcessor: boolean;
+    config: {
+        baseUrl: string;
+        environment: string;
+        release: string;
+    } | undefined;
+};