@juspay/neurolink 7.49.0 → 7.51.0

package/dist/lib/providers/openAI.js

@@ -9,6 +9,7 @@ import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
+import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
 // Configuration helpers - now using consolidated utility
@@ -248,7 +249,8 @@ export class OpenAIProvider extends BaseProvider {
             const hasMultimodalInput = !!(options.input?.images?.length ||
                 options.input?.content?.length ||
                 options.input?.files?.length ||
-                options.input?.csvFiles?.length);
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`OpenAI: Detected multimodal input, using multimodal message builder`, {
@@ -261,26 +263,7 @@ export class OpenAIProvider extends BaseProvider {
                     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 multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
                 const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
                 // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
                 messages = convertToCoreMessages(mm);
@@ -316,6 +299,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
@@ -491,3 +475,4 @@ export class OpenAIProvider extends BaseProvider {
 }
 // Export for factory registration
 export default OpenAIProvider;
+//# sourceMappingURL=openAI.js.map

package/dist/lib/providers/openaiCompatible.js

@@ -5,6 +5,9 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
+import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 // Constants
 const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
 // Configuration helpers
@@ -157,13 +160,46 @@ export class OpenAICompatibleProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Check for multimodal input (images, PDFs, CSVs, files)
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
+            let messages;
+            if (hasMultimodalInput) {
+                logger.debug(`OpenAI Compatible: 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,
+                    hasPDFFiles: !!options.input?.pdfFiles?.length,
+                    pdfFileCount: options.input?.pdfFiles?.length || 0,
+                });
+                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
+                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 Compatible: Text-only input, using standard message builder`);
+                messages = await buildMessagesArray(options);
+            }
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             const result = streamText({
                 model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                messages: messages,
+                ...(options.maxTokens !== null && options.maxTokens !== undefined
+                    ? { maxTokens: options.maxTokens }
+                    : {}),
+                ...(options.temperature !== null && options.temperature !== undefined
+                    ? { temperature: options.temperature }
+                    : {}),
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
@@ -265,3 +301,4 @@ export class OpenAICompatibleProvider extends BaseProvider {
         ];
     }
 }
+//# sourceMappingURL=openaiCompatible.js.map

package/dist/lib/providers/sagemaker/adaptive-semaphore.js

@@ -213,3 +213,4 @@ export function createAdaptiveSemaphore(initialConcurrency, maxConcurrency = 10,
         minConcurrency,
     });
 }
+//# sourceMappingURL=adaptive-semaphore.js.map

package/dist/lib/providers/sagemaker/client.js

@@ -470,3 +470,4 @@ export async function testSageMakerConnectivity(config, endpointName) {
         client.dispose();
     }
 }
+//# sourceMappingURL=client.js.map

package/dist/lib/providers/sagemaker/config.js

@@ -315,3 +315,4 @@ export function checkSageMakerConfiguration() {
         summary: getConfigurationSummary(),
     };
 }
+//# sourceMappingURL=config.js.map

package/dist/lib/providers/sagemaker/detection.js

@@ -604,3 +604,4 @@ export class SageMakerDetector {
 export function createSageMakerDetector(config) {
     return new SageMakerDetector(config);
 }
+//# sourceMappingURL=detection.js.map

package/dist/lib/providers/sagemaker/diagnostics.js

@@ -135,3 +135,4 @@ export function formatDiagnosticReport(report) {
     lines.push(`${statusIcon} Overall Status: ${statusColor(report.overallStatus.toUpperCase())}`);
     return lines.join("\n");
 }
+//# sourceMappingURL=diagnostics.js.map

package/dist/lib/providers/sagemaker/error-constants.js

@@ -225,3 +225,4 @@ export const ERROR_KEYWORDS = {
     NETWORK: ["network"],
     ENDPOINT_NOT_FOUND: ["endpoint", "not found"],
 };
+//# sourceMappingURL=error-constants.js.map

package/dist/lib/providers/sagemaker/errors.js

@@ -297,3 +297,4 @@ export function getRetryDelay(error, attempt = 1) {
     // Default exponential backoff
     return 1000 * Math.pow(2, attempt - 1);
 }
+//# sourceMappingURL=errors.js.map

package/dist/lib/providers/sagemaker/index.js

@@ -65,3 +65,4 @@ export async function validateSageMakerSetup() {
  * Default export for convenience
  */
 export { AmazonSageMakerProvider as default };
+//# sourceMappingURL=index.js.map

package/dist/lib/providers/sagemaker/language-model.js

@@ -761,3 +761,4 @@ export class SageMakerLanguageModel {
     }
 }
 export default SageMakerLanguageModel;
+//# sourceMappingURL=language-model.js.map

package/dist/lib/providers/sagemaker/parsers.js

@@ -632,3 +632,4 @@ export function estimateTokenUsage(prompt, completion) {
         total: promptTokens + completionTokens,
     };
 }
+//# sourceMappingURL=parsers.js.map

package/dist/lib/providers/sagemaker/streaming.js

@@ -329,3 +329,4 @@ export function estimateTokenUsage(prompt, completion) {
         total: promptTokens + completionTokens,
     };
 }
+//# sourceMappingURL=streaming.js.map

package/dist/lib/providers/sagemaker/structured-parser.js

@@ -623,3 +623,4 @@ export function extractSchemaFromResponseFormat(responseFormat) {
     }
     return undefined;
 }
+//# sourceMappingURL=structured-parser.js.map

package/dist/lib/proxy/awsProxyIntegration.js

@@ -283,3 +283,4 @@ export async function testAWSProxyConnectivity() {
         return false;
     }
 }
+//# sourceMappingURL=awsProxyIntegration.js.map

package/dist/lib/proxy/proxyFetch.js

@@ -322,3 +322,4 @@ export function getProxyStatus() {
         ],
     };
 }
+//# sourceMappingURL=proxyFetch.js.map

package/dist/lib/proxy/utils/noProxyUtils.js

@@ -147,3 +147,4 @@ export function shouldBypassProxySimple(targetUrl, noProxyValue) {
         return false;
     }
 }
+//# sourceMappingURL=noProxyUtils.js.map

package/dist/lib/sdk/toolRegistration.js

@@ -2,6 +2,7 @@
  * NeuroLink SDK Tool Registration API
  * Simple interface for developers to register custom tools
  */
+import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { createMCPServerInfo } from "../utils/mcpDefaults.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
@@ -364,3 +365,4 @@ export function suggestToolNames(baseName) {
     }
     return suggestions.slice(0, 5); // Limit to 5 suggestions
 }
+//# sourceMappingURL=toolRegistration.js.map

package/dist/lib/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;
+};

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

@@ -0,0 +1,171 @@
+/**
+ * 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 { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { logger } from "../../../../utils/logger.js";
+const LOG_PREFIX = "[OpenTelemetry]";
+let tracerProvider = null;
+let langfuseProcessor = null;
+let isInitialized = false;
+let isCredentialsValid = false;
+let currentConfig = null;
+/**
+ * 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 function initializeOpenTelemetry(config) {
+    if (isInitialized) {
+        logger.debug(`${LOG_PREFIX} Already initialized`);
+        return;
+    }
+    if (!config.enabled) {
+        logger.debug(`${LOG_PREFIX} Langfuse disabled, skipping initialization`);
+        isInitialized = true;
+        return;
+    }
+    if (!config.publicKey || !config.secretKey) {
+        logger.warn(`${LOG_PREFIX} Langfuse enabled but missing credentials, skipping initialization`);
+        isInitialized = true;
+        isCredentialsValid = false;
+        return;
+    }
+    try {
+        currentConfig = config;
+        isCredentialsValid = true;
+        // Create Langfuse span processor with configuration
+        langfuseProcessor = new LangfuseSpanProcessor({
+            publicKey: config.publicKey,
+            secretKey: config.secretKey,
+            baseUrl: config.baseUrl || "https://cloud.langfuse.com",
+            environment: config.environment || "dev",
+            release: config.release || "v1.0.0",
+        });
+        // Create resource with service metadata (v2.x API)
+        const resource = resourceFromAttributes({
+            [ATTR_SERVICE_NAME]: "neurolink",
+            [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
+            "deployment.environment": config.environment || "dev",
+        });
+        // Initialize tracer provider with span processor and resource
+        tracerProvider = new NodeTracerProvider({
+            resource,
+            spanProcessors: [langfuseProcessor],
+        });
+        // Register provider globally so Vercel AI SDK can use it
+        tracerProvider.register();
+        isInitialized = true;
+        logger.info(`${LOG_PREFIX} Initialized with Langfuse span processor`, {
+            baseUrl: config.baseUrl || "https://cloud.langfuse.com",
+            environment: config.environment || "dev",
+            release: config.release || "v1.0.0",
+        });
+    }
+    catch (error) {
+        logger.error(`${LOG_PREFIX} Initialization failed`, {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        throw error;
+    }
+}
+/**
+ * Flush all pending spans to Langfuse
+ */
+export async function flushOpenTelemetry() {
+    if (!isInitialized) {
+        logger.debug(`${LOG_PREFIX} Not initialized, skipping flush`);
+        return;
+    }
+    if (!langfuseProcessor) {
+        logger.debug(`${LOG_PREFIX} No processor to flush (Langfuse disabled)`);
+        return;
+    }
+    try {
+        logger.info(`${LOG_PREFIX} Flushing pending spans to Langfuse...`);
+        await langfuseProcessor.forceFlush();
+        logger.info(`${LOG_PREFIX} Successfully flushed spans to Langfuse`);
+    }
+    catch (error) {
+        logger.error(`${LOG_PREFIX} Flush failed`, {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        throw error;
+    }
+}
+/**
+ * Shutdown OpenTelemetry and Langfuse span processor
+ */
+export async function shutdownOpenTelemetry() {
+    if (!isInitialized || !tracerProvider) {
+        return;
+    }
+    try {
+        await tracerProvider.shutdown();
+        tracerProvider = null;
+        langfuseProcessor = null;
+        isInitialized = false;
+        isCredentialsValid = false;
+        logger.debug(`${LOG_PREFIX} Shutdown complete`);
+    }
+    catch (error) {
+        logger.error(`${LOG_PREFIX} Shutdown failed`, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * Get the Langfuse span processor
+ */
+export function getLangfuseSpanProcessor() {
+    return langfuseProcessor;
+}
+/**
+ * Get the tracer provider
+ */
+export function getTracerProvider() {
+    return tracerProvider;
+}
+/**
+ * Check if OpenTelemetry is initialized
+ */
+export function isOpenTelemetryInitialized() {
+    return isInitialized;
+}
+/**
+ * Get health status for Langfuse observability
+ */
+export function getLangfuseHealthStatus() {
+    return {
+        isHealthy: currentConfig?.enabled &&
+            isInitialized &&
+            isCredentialsValid &&
+            langfuseProcessor !== null,
+        initialized: isInitialized,
+        credentialsValid: isCredentialsValid,
+        enabled: currentConfig?.enabled || false,
+        hasProcessor: langfuseProcessor !== null,
+        config: currentConfig
+            ? {
+                baseUrl: currentConfig.baseUrl || "https://cloud.langfuse.com",
+                environment: currentConfig.environment || "dev",
+                release: currentConfig.release || "v1.0.0",
+            }
+            : undefined,
+    };
+}
+//# sourceMappingURL=instrumentation.js.map

package/dist/lib/session/globalSessionState.js

@@ -1,5 +1,31 @@
 import { nanoid } from "nanoid";
 import { NeuroLink } from "../neurolink.js";
+/**
+ * Build observability config from environment variables
+ * Used by CLI to configure NeuroLink instances
+ */
+function buildObservabilityConfigFromEnv() {
+    const langfuseEnabled = process.env.LANGFUSE_ENABLED?.trim().toLowerCase() === "true";
+    const publicKey = process.env.LANGFUSE_PUBLIC_KEY?.trim();
+    const secretKey = process.env.LANGFUSE_SECRET_KEY?.trim();
+    if (!langfuseEnabled || !publicKey || !secretKey) {
+        return undefined;
+    }
+    return {
+        langfuse: {
+            enabled: langfuseEnabled,
+            publicKey,
+            secretKey,
+            baseUrl: process.env.LANGFUSE_BASE_URL?.trim() || "https://cloud.langfuse.com",
+            environment: process.env.LANGFUSE_ENVIRONMENT?.trim() ||
+                process.env.PUBLIC_APP_ENVIRONMENT?.trim() ||
+                "dev",
+            release: process.env.PUBLIC_APP_VERSION?.trim() ||
+                process.env.npm_package_version?.trim() ||
+                "v1.0.0",
+        },
+    };
+}
 export class GlobalSessionManager {
     static instance;
     loopSession = null;
@@ -19,6 +45,11 @@ export class GlobalSessionManager {
                 maxTurnsPerSession: config.maxTurnsPerSession,
             };
         }
+        // Add observability config from environment variables (CLI usage)
+        const observabilityConfig = buildObservabilityConfigFromEnv();
+        if (observabilityConfig) {
+            neurolinkOptions.observability = observabilityConfig;
+        }
         this.loopSession = {
             neurolinkInstance: new NeuroLink(neurolinkOptions),
             sessionId,
@@ -88,7 +119,12 @@ export class GlobalSessionManager {
     }
     getOrCreateNeuroLink() {
         const session = this.getLoopSession();
-        return session ? session.neurolinkInstance : new NeuroLink();
+        if (session) {
+            return session.neurolinkInstance;
+        }
+        // Create new NeuroLink with observability config from environment (CLI usage)
+        const observabilityConfig = buildObservabilityConfigFromEnv();
+        return new NeuroLink(observabilityConfig ? { observability: observabilityConfig } : undefined);
     }
     getCurrentSessionId() {
         return this.getLoopSession()?.sessionId;
@@ -124,3 +160,4 @@ export class GlobalSessionManager {
     }
 }
 export const globalSession = GlobalSessionManager.getInstance();
+//# sourceMappingURL=globalSessionState.js.map

package/dist/lib/telemetry/index.d.ts

@@ -9,6 +9,7 @@ export declare function initializeTelemetry(): Promise<import("./telemetryServic
  */
 export declare function getTelemetryStatus(): Promise<{
     enabled: boolean;
+    initialized: boolean;
     endpoint?: string;
     service?: string;
     version?: string;

package/dist/lib/telemetry/index.js

@@ -21,3 +21,4 @@ export async function getTelemetryStatus() {
     const { TelemetryService } = await import("./telemetryService.js");
     return TelemetryService.getInstance().getStatus();
 }
+//# sourceMappingURL=index.js.map

package/dist/lib/telemetry/telemetryService.d.ts

@@ -10,6 +10,7 @@ export declare class TelemetryService {
     private static instance;
     private sdk?;
     private enabled;
+    private initialized;
     private meter?;
     private tracer?;
     private aiRequestCounter?;
@@ -43,6 +44,7 @@ export declare class TelemetryService {
     isEnabled(): boolean;
     getStatus(): {
         enabled: boolean;
+        initialized: boolean;
         endpoint?: string;
         service?: string;
         version?: string;

package/dist/lib/telemetry/telemetryService.js

@@ -1,14 +1,14 @@
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import { metrics, trace, } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { Resource } from "@opentelemetry/resources";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
     sdk;
     enabled = false;
+    initialized = false;
     meter;
     tracer;
     // Optional Metrics (only created when enabled)
@@ -47,16 +47,12 @@ export class TelemetryService {
     }
     initializeTelemetry() {
         try {
-            const resource = new Resource({
+            const resource = resourceFromAttributes({
                 [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
                 [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
             });
             this.sdk = new NodeSDK({
                 resource,
-                traceExporter: new OTLPTraceExporter({
-                    url: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||
-                        `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}/v1/traces`,
-                }),
                 // Note: Metric reader configured separately
                 instrumentations: [getNodeAutoInstrumentations()],
             });
@@ -102,11 +98,13 @@ export class TelemetryService {
         }
         try {
             await this.sdk?.start();
+            this.initialized = true;
             logger.debug("[Telemetry] SDK started successfully");
         }
         catch (error) {
             logger.error("[Telemetry] Failed to start SDK:", error);
             this.enabled = false;
+            this.initialized = false;
         }
     }
     // AI Operation Tracing (NO-OP when disabled)
@@ -250,6 +248,7 @@ export class TelemetryService {
     getStatus() {
         return {
             enabled: this.enabled,
+            initialized: this.initialized,
             endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
             service: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
             version: process.env.OTEL_SERVICE_VERSION || "3.0.1",
@@ -285,6 +284,7 @@ export class TelemetryService {
         if (this.enabled && this.sdk) {
             try {
                 await this.sdk.shutdown();
+                this.initialized = false;
                 logger.debug("[Telemetry] SDK shutdown completed");
             }
             catch (error) {
@@ -293,3 +293,4 @@ export class TelemetryService {
         }
     }
 }
+//# sourceMappingURL=telemetryService.js.map

package/dist/lib/types/analytics.js

@@ -3,3 +3,4 @@
  * Comprehensive usage tracking, performance metrics, and cost analysis types
  */
 export {};
+//# sourceMappingURL=analytics.js.map

package/dist/lib/types/cli.js

@@ -19,3 +19,4 @@ export function isCommandResult(value) {
         "success" in value &&
         typeof value.success === "boolean");
 }
+//# sourceMappingURL=cli.js.map

package/dist/lib/types/common.js

@@ -49,3 +49,4 @@ export function toErrorInfo(error) {
         message: getErrorMessage(error),
     };
 }
+//# sourceMappingURL=common.js.map

package/dist/lib/types/configTypes.js

@@ -47,3 +47,4 @@ export const DEFAULT_CONFIG = {
     },
     configVersion: "3.0.1",
 };
+//# sourceMappingURL=configTypes.js.map