@juspay/neurolink 7.48.1 → 7.50.0

package/dist/cli/loop/session.js

@@ -1,12 +1,12 @@
 import chalk from "chalk";
 import readline from "readline";
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
 import { logger } from "../../lib/utils/logger.js";
 import { globalSession } from "../../lib/session/globalSessionState.js";
 import { textGenerationOptionsSchema } from "./optionsSchema.js";
 import { handleError } from "../errorHandler.js";
+import { ConversationSelector } from "./conversationSelector.js";
+import { NeuroLink } from "../../lib/neurolink.js";
+import { displaySessionMessage, verifyConversationContext, getConversationPreview, loadCommandHistory, saveCommandToHistory, displayConversationPreview, parseValue, restoreSessionVariables, } from "../../lib/utils/loopUtils.js";
 // Banner Art
 const NEUROLINK_BANNER = `
 ▗▖  ▗▖▗▄▄▄▖▗▖ ▗▖▗▄▄▖  ▗▄▖ ▗▖   ▗▄▄▄▖▗▖  ▗▖▗▖ ▗▖
@@ -14,33 +14,58 @@ const NEUROLINK_BANNER = `
 ▐▌ ▝▜▌▐▛▀▀▘▐▌ ▐▌▐▛▀▚▖▐▌ ▐▌▐▌     █  ▐▌ ▝▜▌▐▛▚▖ 
 ▐▌  ▐▌▐▙▄▄▖▝▚▄▞▘▐▌ ▐▌▝▚▄▞▘▐▙▄▄▖▗▄█▄▖▐▌  ▐▌▐▌ ▐▌
 `;
-// Global command history file
-const HISTORY_FILE = path.join(os.homedir(), ".neurolink_history");
 export class LoopSession {
     conversationMemoryConfig;
+    options;
     initializeCliParser;
     isRunning = false;
     sessionId;
     commandHistory = [];
     sessionVariablesSchema = textGenerationOptionsSchema;
-    constructor(initializeCliParser, conversationMemoryConfig) {
+    constructor(initializeCliParser, conversationMemoryConfig, options) {
         this.conversationMemoryConfig = conversationMemoryConfig;
+        this.options = options;
         this.initializeCliParser = initializeCliParser;
     }
     async start() {
         // Initialize global session state
         this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
         // Load command history from global file, reverse once for most recent first
-        this.commandHistory = (await this.loadHistory()).reverse();
+        this.commandHistory = (await loadCommandHistory()).reverse();
         this.isRunning = true;
         logger.always(chalk.bold.green(NEUROLINK_BANNER));
         logger.always(chalk.bold.green("Welcome to NeuroLink Loop Mode!"));
+        // Check for direct CLI options
+        const directResumeSessionId = this.options?.directResumeSessionId;
+        const forceNewSession = this.options?.forceNewSession;
+        // Handle conversation discovery and selection if memory is enabled
         if (this.conversationMemoryConfig?.enabled) {
-            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
             logger.always(chalk.gray("Conversation memory enabled"));
+            // Handle direct resume option
+            if (directResumeSessionId) {
+                await this.handleDirectSessionResume(directResumeSessionId);
+            }
+            // Handle force new session option
+            else if (forceNewSession) {
+                logger.always(chalk.blue("Force starting new conversation..."));
+                this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            }
+            // Default behavior: check for existing conversations
+            else {
+                await this.handleConversationSelection();
+            }
+            // Display session information
+            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
             logger.always(chalk.gray(`Max sessions: ${this.conversationMemoryConfig.maxSessions}`));
             logger.always(chalk.gray(`Max turns per session: ${this.conversationMemoryConfig.maxTurnsPerSession}\n`));
         }
+        else {
+            // No conversation memory - just create a new session
+            this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
+        }
+        // Load command history from global file
+        this.commandHistory = (await loadCommandHistory()).reverse();
         logger.always(chalk.gray('Type "help" for a list of commands.'));
         logger.always(chalk.gray('Type "exit", "quit", or ":q" to leave the loop.'));
         while (this.isRunning) {
@@ -61,7 +86,7 @@ export class LoopSession {
                     // Save session commands to history (both memory and file)
                     if (command && command.trim()) {
                         this.commandHistory.unshift(command);
-                        await this.saveCommand(command);
+                        await saveCommandToHistory(command);
                     }
                     continue;
                 }
@@ -81,7 +106,7 @@ export class LoopSession {
                 // Save command to history (both memory and file)
                 if (command && command.trim()) {
                     this.commandHistory.unshift(command);
-                    await this.saveCommand(command);
+                    await saveCommandToHistory(command);
                 }
             }
             catch (error) {
@@ -90,8 +115,96 @@ export class LoopSession {
             }
         }
         // Cleanup on exit
-        globalSession.clearLoopSession();
-        logger.always(chalk.yellow("Loop session ended."));
+        this.cleanup();
+    }
+    /**
+     * Handle direct session resume from CLI option
+     */
+    async handleDirectSessionResume(directResumeSessionId) {
+        logger.always(chalk.blue(`Attempting to resume session: ${directResumeSessionId.slice(0, 12)}...`));
+        try {
+            const restoreResult = await this.restoreSession(directResumeSessionId);
+            if (restoreResult.success) {
+                displaySessionMessage(restoreResult);
+                this.sessionId = directResumeSessionId;
+                // Display conversation preview
+                const preview = await getConversationPreview(directResumeSessionId, 2);
+                displayConversationPreview(preview, 2);
+            }
+            else {
+                displaySessionMessage(restoreResult);
+                logger.always(chalk.yellow("Starting new conversation instead..."));
+                this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to resume session ${directResumeSessionId}:`, error);
+            logger.always(chalk.yellow("Starting new conversation instead..."));
+            this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+        }
+    }
+    /**
+     * Handle conversation selection logic when no direct resume is specified
+     */
+    async handleConversationSelection() {
+        logger.always(chalk.gray("Checking for existing conversations...\n"));
+        try {
+            const conversationSelector = new ConversationSelector();
+            // Check if there are any stored conversations
+            const hasStoredConversations = await conversationSelector.hasStoredConversations();
+            if (hasStoredConversations) {
+                // Show conversation selection menu
+                const selectedSessionId = await conversationSelector.displayConversationMenu();
+                if (selectedSessionId !== "NEW_CONVERSATION") {
+                    // Restore the selected conversation
+                    logger.always(chalk.blue("Restoring conversation..."));
+                    const restoreResult = await this.restoreSession(selectedSessionId);
+                    if (restoreResult.success) {
+                        displaySessionMessage(restoreResult);
+                        this.sessionId = selectedSessionId;
+                        // Display conversation preview
+                        const preview = await getConversationPreview(selectedSessionId, 2);
+                        displayConversationPreview(preview, 2);
+                    }
+                    else {
+                        displaySessionMessage(restoreResult);
+                        logger.always(chalk.yellow("Starting new conversation instead..."));
+                        this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+                    }
+                }
+                else {
+                    // User chose to start new conversation
+                    logger.always(chalk.blue("Starting new conversation..."));
+                    this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+                }
+            }
+            else {
+                // No existing conversations found
+                logger.always(chalk.gray("No existing conversations found."));
+                logger.always(chalk.blue("Starting new conversation..."));
+                this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+            }
+            // Close the conversation selector
+            await conversationSelector.close();
+        }
+        catch (error) {
+            logger.warn("Failed to check for existing conversations:", error);
+            logger.always(chalk.yellow("Starting new conversation..."));
+            this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+        }
+    }
+    /**
+     * Clean up session resources and connections
+     */
+    cleanup() {
+        try {
+            globalSession.clearLoopSession();
+            logger.always(chalk.yellow("Loop session ended."));
+        }
+        catch (error) {
+            // Silently handle cleanup errors to avoid hanging
+            logger.error("Error during cleanup:", error);
+        }
     }
     async handleSessionCommands(command) {
         const parts = command.split(" ");
@@ -113,7 +226,7 @@ export class LoopSession {
                         return true;
                     }
                     const valueStr = parts.slice(2).join(" ");
-                    let value = this.parseValue(valueStr);
+                    let value = parseValue(valueStr);
                     // Validate type
                     if (schema.type === "boolean" && typeof value !== "boolean") {
                         logger.always(chalk.red(`Error: Invalid value for "${key}". Expected a boolean (true/false).`));
@@ -196,21 +309,6 @@ export class LoopSession {
                 return false;
         }
     }
-    parseValue(value) {
-        // Try to parse as number
-        if (!isNaN(Number(value))) {
-            return Number(value);
-        }
-        // Try to parse as boolean
-        if (value.toLowerCase() === "true") {
-            return true;
-        }
-        if (value.toLowerCase() === "false") {
-            return false;
-        }
-        // Return as string
-        return value;
-    }
     showHelp() {
         logger.always(chalk.cyan("Available Loop Mode Commands:"));
         const commands = [
@@ -254,39 +352,6 @@ export class LoopSession {
             }
         }
     }
-    /**
-     * Load command history from the global history file
-     */
-    async loadHistory() {
-        try {
-            const content = await fs.readFile(HISTORY_FILE, "utf8");
-            return content.split("\n").filter((line) => line.trim());
-        }
-        catch {
-            // File doesn't exist yet or can't be read
-            return [];
-        }
-    }
-    /**
-     * Save a command to the global history file
-     */
-    async saveCommand(command) {
-        try {
-            // Skip potentially sensitive commands
-            const sensitivePattern = /\b(api[-_]?key|token|password|secret|authorization)\b/i;
-            if (sensitivePattern.test(command)) {
-                return;
-            }
-            // Use writeFile with flag 'a' and mode 0o600 to ensure permissions on creation
-            await fs.writeFile(HISTORY_FILE, command + "\n", { flag: "a", mode: 0o600 });
-            // Ensure existing file remains private (best-effort)
-            await fs.chmod(HISTORY_FILE, 0o600);
-        }
-        catch (error) {
-            // Log file write errors as warnings, but do not interrupt CLI flow
-            logger.warn("Warning: Could not save command to history:", error);
-        }
-    }
     /**
      * Get command input with history support using readline
      */
@@ -310,4 +375,135 @@ export class LoopSession {
             });
         });
     }
+    // === SESSION RESTORATION METHODS ===
+    /**
+     * Restore a conversation session and set up the global session state
+     */
+    async restoreSession(sessionId, userId) {
+        // Local helper for creating failure results with bound sessionId
+        const createFailure = (error) => ({
+            success: false,
+            sessionId,
+            messageCount: 0,
+            error,
+        });
+        try {
+            logger.debug(`Attempting to restore session: ${sessionId}`);
+            // 1. Create NeuroLink instance and validate conversation in one step
+            const { neurolinkInstance, conversationData } = await this.createAndValidateNeurolinkInstance(sessionId, userId);
+            if (!conversationData) {
+                return createFailure(`Conversation ${sessionId} not found or inaccessible`);
+            }
+            // 2. Set up tool execution context
+            await this.configureToolContext(neurolinkInstance, sessionId, userId);
+            // 3. Restore global session state
+            this.restoreGlobalSessionState(sessionId, neurolinkInstance, conversationData);
+            // 4. Verify conversation context accessibility
+            await verifyConversationContext(sessionId);
+            const result = {
+                success: true,
+                sessionId,
+                messageCount: conversationData.messages?.length || 0,
+                lastActivity: conversationData.updatedAt,
+            };
+            logger.info(`Session restored successfully: ${sessionId}`, {
+                messageCount: result.messageCount,
+                lastActivity: result.lastActivity,
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error(`Failed to restore session ${sessionId}:`, error);
+            return createFailure(error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Create NeuroLink instance and validate conversation in one step
+     * Eliminates redundant instance creation and initialization
+     */
+    async createAndValidateNeurolinkInstance(sessionId, userId) {
+        // Create NeuroLink instance with proper configuration
+        const neurolinkOptions = {};
+        if (this.conversationMemoryConfig?.enabled) {
+            neurolinkOptions.conversationMemory = {
+                enabled: true,
+                maxSessions: this.conversationMemoryConfig.maxSessions,
+                maxTurnsPerSession: this.conversationMemoryConfig.maxTurnsPerSession,
+            };
+            neurolinkOptions.sessionId = sessionId;
+        }
+        const neurolinkInstance = new NeuroLink(neurolinkOptions);
+        await neurolinkInstance.ensureConversationMemoryInitialized();
+        // Use the same instance to validate conversation exists
+        try {
+            const messages = await neurolinkInstance.getConversationHistory(sessionId);
+            if (!messages || messages.length === 0) {
+                logger.debug(`No conversation messages found for session ${sessionId}`);
+                return { neurolinkInstance, conversationData: null };
+            }
+            // Create conversation object with available data
+            const conversationData = {
+                id: sessionId,
+                sessionId,
+                userId: userId || "unknown",
+                messages,
+                createdAt: new Date().toISOString(), // Fallback
+                updatedAt: new Date().toISOString(), // Fallback
+                title: messages[0]?.content?.slice(0, 50) + "..." || "Untitled Conversation",
+            };
+            return { neurolinkInstance, conversationData };
+        }
+        catch (error) {
+            logger.debug(`Error accessing conversation for session ${sessionId}:`, error);
+            return { neurolinkInstance, conversationData: null };
+        }
+    }
+    /**
+     * Configure tool execution context for the restored session
+     */
+    async configureToolContext(neurolinkInstance, sessionId, userId) {
+        const toolContext = {
+            sessionId,
+            userId: userId || "loop-user",
+            source: "loop-mode",
+            restored: true,
+            timestamp: new Date().toISOString(),
+        };
+        neurolinkInstance.setToolContext(toolContext);
+        logger.debug("Tool execution context configured for restored session", {
+            sessionId,
+            userId,
+            hasToolContext: true,
+        });
+        await this.verifyToolAvailability(neurolinkInstance);
+    }
+    /**
+     * Verify that tools are available and working in the restored session
+     */
+    async verifyToolAvailability(neurolinkInstance) {
+        try {
+            const availableTools = await neurolinkInstance.getAllAvailableTools();
+            logger.debug(`Tools available in restored session: ${availableTools.length} tools`, {
+                toolNames: availableTools.slice(0, 5).map((t) => t.name),
+                hasFileTools: availableTools.some((t) => t.name.includes("file") || t.name.includes("File")),
+                hasDirectoryTools: availableTools.some((t) => t.name.includes("directory") || t.name.includes("Directory")),
+            });
+            if (availableTools.length === 0) {
+                logger.warn("No tools available in restored session - this may affect AI capabilities");
+            }
+        }
+        catch (error) {
+            logger.warn("Could not verify tool availability in restored session:", error);
+        }
+    }
+    /**
+     * Restore global session state and session variables
+     */
+    restoreGlobalSessionState(sessionId, neurolinkInstance, conversationData) {
+        globalSession.clearLoopSession();
+        globalSession.restoreLoopSession(sessionId, neurolinkInstance, this.conversationMemoryConfig, {});
+        if (conversationData) {
+            restoreSessionVariables(conversationData);
+        }
+    }
 }

package/dist/core/baseProvider.d.ts

@@ -236,4 +236,13 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns Array of prompt chunks
      */
     static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
+    /**
+     * Create telemetry configuration for Vercel AI SDK experimental_telemetry
+     * This enables automatic OpenTelemetry tracing when telemetry is enabled
+     */
+    protected getStreamTelemetryConfig(options: StreamOptions | TextGenerationOptions, operationType?: "stream" | "generate"): {
+        isEnabled: boolean;
+        functionId?: string;
+        metadata?: Record<string, string | number | boolean>;
+    } | undefined;
 }

package/dist/core/baseProvider.js

@@ -6,6 +6,8 @@ import { DEFAULT_MAX_STEPS, STEP_LIMITS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { nanoid } from "nanoid";
+import { createAnalytics } from "./analytics.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray, buildMultimodalMessagesArray, } from "../utils/messageBuilder.js";
 import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
@@ -98,6 +100,7 @@ export class BaseProvider {
                     // Convert stream options to text generation options
                     const textOptions = {
                         prompt: options.input?.text || "",
+                        input: options.input,
                         systemPrompt: options.systemPrompt,
                         temperature: options.temperature,
                         maxTokens: options.maxTokens,
@@ -111,6 +114,7 @@ export class BaseProvider {
                         evaluationDomain: options.evaluationDomain,
                         toolUsageContext: options.toolUsageContext,
                         context: options.context,
+                        csvOptions: options.csvOptions,
                     };
                     logger.debug(`Calling generate for fake streaming`, {
                         provider: this.providerName,
@@ -229,7 +233,9 @@ export class BaseProvider {
             const input = opts.input;
             const hasImages = !!input?.images?.length;
             const hasContent = !!input?.content?.length;
-            return hasImages || hasContent;
+            const hasCSVFiles = !!input?.csvFiles?.length;
+            const hasFiles = !!input?.files?.length;
+            return hasImages || hasContent || hasCSVFiles || hasFiles;
         };
         let messages;
         if (hasMultimodalInput(options)) {
@@ -242,7 +248,10 @@ export class BaseProvider {
                     text: options.prompt || options.input?.text || "",
                     images: input?.images,
                     content: input?.content,
+                    csvFiles: input?.csvFiles,
+                    files: input?.files,
                 },
+                csvOptions: options.csvOptions,
                 provider: options.provider,
                 model: options.model,
                 temperature: options.temperature,
@@ -258,7 +267,7 @@ export class BaseProvider {
             if (process.env.NEUROLINK_DEBUG === "true") {
                 logger.debug("No multimodal input detected, using standard message builder");
             }
-            messages = buildMessagesArray(options);
+            messages = await buildMessagesArray(options);
         }
         // Convert messages to Vercel AI SDK format
         return messages.map((msg) => {
@@ -297,6 +306,7 @@ export class BaseProvider {
             toolChoice: shouldUseTools ? "auto" : "none",
             temperature: options.temperature,
             maxTokens: options.maxTokens,
+            experimental_telemetry: this.getStreamTelemetryConfig(options, "generate"),
             onStepFinish: ({ toolCalls, toolResults }) => {
                 logger.info("Tool execution completed", { toolResults, toolCalls });
                 // Handle tool execution storage
@@ -1276,9 +1286,8 @@ export class BaseProvider {
      */
     async createStreamAnalytics(result, startTime, options) {
         try {
-            const { createAnalytics } = await import("./analytics.js");
             const analytics = createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
-                requestId: `${this.providerName}-stream-${Date.now()}`,
+                requestId: `${this.providerName}-stream-${nanoid()}`,
                 streamingMode: true,
                 ...options.context,
             });
@@ -1511,7 +1520,7 @@ export class BaseProvider {
         }
         const sessionId = options.context?.sessionId ||
             options.sessionId ||
-            `session-${Date.now()}`;
+            `session-${nanoid()}`;
         const userId = options.context?.userId ||
             options.userId;
         try {
@@ -1558,4 +1567,35 @@ export class BaseProvider {
         }
         return chunks;
     }
+    /**
+     * Create telemetry configuration for Vercel AI SDK experimental_telemetry
+     * This enables automatic OpenTelemetry tracing when telemetry is enabled
+     */
+    getStreamTelemetryConfig(options, operationType = "stream") {
+        // Check if telemetry is enabled via NeuroLink observability config
+        if (!this.neurolink?.isTelemetryEnabled()) {
+            return undefined;
+        }
+        const functionId = `${this.providerName}-${operationType}-${nanoid()}`;
+        const metadata = {
+            provider: this.providerName,
+            model: this.modelName,
+            toolsEnabled: !options.disableTools,
+            neurolink: true,
+        };
+        // Add sessionId if available
+        if ("sessionId" in options && options.sessionId) {
+            const sessionId = options.sessionId;
+            if (typeof sessionId === "string" ||
+                typeof sessionId === "number" ||
+                typeof sessionId === "boolean") {
+                metadata.sessionId = sessionId;
+            }
+        }
+        return {
+            isEnabled: true,
+            functionId,
+            metadata,
+        };
+    }
 }

package/dist/core/evaluation.js

@@ -225,8 +225,11 @@ Completeness: [score]
 Overall: [score]
 Reasoning: [Provide a detailed explanation of your evaluation, explaining why you gave these scores. Include specific observations about the response's strengths and all possible areas for improvement.]
 `;
-        // Generate evaluation
-        const result = await provider.generate(prompt);
+        // Generate evaluation (simple text prompt only - no file processing)
+        const result = await provider.generate({
+            input: { text: prompt },
+            disableTools: true, // Evaluation doesn't need tools
+        });
         if (!result) {
             logger.debug(`[${functionTag}] No response from provider`);
             return getDefaultEvaluation("no-response", Date.now() - startTime, context);

package/dist/factories/providerRegistry.js

@@ -45,9 +45,9 @@ export class ProviderRegistry {
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk) => {
                 const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
-                return new AzureOpenAIProvider(modelName);
+                return new AzureOpenAIProvider(modelName, sdk);
             }, process.env.AZURE_MODEL ||
                 process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||

package/dist/index.d.ts

@@ -21,6 +21,9 @@ import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
 export type { ProviderStatus, MCPStatus } from "./neurolink.js";
 export type { MCPServerInfo } from "./types/mcpTypes.js";
+export type { ObservabilityConfig, LangfuseConfig, OpenTelemetryConfig, } from "./types/observability.js";
+import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus } from "./services/server/ai/observability/instrumentation.js";
+export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, };
 export type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, MiddlewareConfig, } from "./types/middlewareTypes.js";
 export { MiddlewareFactory } from "./middleware/factory.js";
 export declare const VERSION = "1.0.0";
@@ -82,10 +85,13 @@ export declare function createBestAIProvider(requestedProvider?: string, modelNa
 export { initializeMCPEcosystem, listMCPs, executeMCP, getMCPStats, mcpLogger, } from "./mcp/index.js";
 export type { McpMetadata, ExecutionContext, DiscoveredMcp, ToolInfo, ToolExecutionResult, LogLevel, } from "./mcp/index.js";
 export declare function initializeTelemetry(): Promise<boolean>;
-export declare function getTelemetryStatus(): {
+export declare function getTelemetryStatus(): Promise<{
     enabled: boolean;
     initialized: boolean;
-};
+    endpoint?: string;
+    service?: string;
+    version?: string;
+}>;
 export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, EvaluationData, } from "./types/index.js";
 /**
  * BACKWARD COMPATIBILITY: Legacy generateText function

package/dist/index.js

@@ -19,6 +19,9 @@ export { dynamicModelProvider } from "./core/dynamicModels.js";
 // Main NeuroLink wrapper class and diagnostic types
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
+import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, } from "./services/server/ai/observability/instrumentation.js";
+import { initializeTelemetry as init, getTelemetryStatus as getStatus, } from "./telemetry/index.js";
+export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, };
 export { MiddlewareFactory } from "./middleware/factory.js";
 // Version
 export const VERSION = "1.0.0";
@@ -96,20 +99,18 @@ initializeMCPEcosystem, listMCPs, executeMCP, getMCPStats, mcpLogger, } from "./
 // Real-time Services (Phase 1) - Basic SSE functionality only
 // export { createEnhancedChatService } from './chat/index.js';
 // export type * from './services/types.js';
-// Optional Telemetry (Phase 2) - Conditional export based on feature flag
+// Optional Telemetry (Phase 2) - Telemetry service initialization
 export async function initializeTelemetry() {
-    if (process.env.NEUROLINK_TELEMETRY_ENABLED === "true") {
-        const { initializeTelemetry: init } = await import("./telemetry/index.js");
+    try {
         const result = await init();
-        return !!result; // Convert TelemetryService to boolean
+        return !!result;
     }
-    return Promise.resolve(false);
-}
-export function getTelemetryStatus() {
-    if (process.env.NEUROLINK_TELEMETRY_ENABLED === "true") {
-        return { enabled: true, initialized: false };
+    catch {
+        return false;
     }
-    return { enabled: false, initialized: false };
+}
+export async function getTelemetryStatus() {
+    return getStatus();
 }
 /**
  * BACKWARD COMPATIBILITY: Legacy generateText function