@juspay/neurolink 7.49.0 → 7.51.0

package/dist/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

package/dist/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,

package/dist/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";

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;
+};

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

@@ -0,0 +1,170 @@
+/**
+ * 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,
+    };
+}

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

package/dist/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/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/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) {

package/dist/types/content.d.ts

@@ -39,10 +39,23 @@ export type CSVContent = {
         description?: string;
     };
 };
+/**
+ * PDF document content type for multimodal messages
+ */
+export type PDFContent = {
+    type: "pdf";
+    data: Buffer | string;
+    metadata?: {
+        filename?: string;
+        pages?: number;
+        version?: string;
+        description?: string;
+    };
+};
 /**
  * Union type for all content types
  */
-export type Content = TextContent | ImageContent | CSVContent;
+export type Content = TextContent | ImageContent | CSVContent | PDFContent;
 /**
  * Vision capability information for providers
  */

package/dist/types/conversation.d.ts

@@ -157,6 +157,8 @@ export interface NeurolinkOptions {
     conversationMemory?: ConversationMemoryConfig;
     /** Session identifier for conversation context */
     sessionId?: string;
+    /** Observability configuration */
+    observability?: import("./observability.js").ObservabilityConfig;
 }
 /**
  * Session identifier for Redis storage operations

package/dist/types/fileTypes.d.ts

@@ -43,6 +43,10 @@ export type FileProcessingResult = {
         columnNames?: string[];
         sampleData?: string;
         hasEmptyColumns?: boolean;
+        version?: string;
+        estimatedPages?: number | null;
+        provider?: string;
+        apiType?: PDFAPIType;
     };
 };
 /**
@@ -53,6 +57,29 @@ export type CSVProcessorOptions = {
     formatStyle?: "raw" | "markdown" | "json";
     includeHeaders?: boolean;
 };
+/**
+ * PDF API types for different providers
+ */
+export type PDFAPIType = "document" | "files-api" | "unsupported";
+/**
+ * PDF provider configuration
+ */
+export interface PDFProviderConfig {
+    maxSizeMB: number;
+    maxPages: number;
+    supportsNative: boolean;
+    requiresCitations: boolean | "auto";
+    apiType: PDFAPIType;
+}
+/**
+ * PDF processor options
+ */
+export type PDFProcessorOptions = {
+    provider?: string;
+    model?: string;
+    maxSizeMB?: number;
+    bedrockApiMode?: "converse" | "invokeModel";
+};
 /**
  * File detector options
  */
@@ -62,4 +89,21 @@ export type FileDetectorOptions = {
     allowedTypes?: FileType[];
     csvOptions?: CSVProcessorOptions;
     confidenceThreshold?: number;
+    provider?: string;
 };
+/**
+ * Google AI Studio Files API types
+ */
+export interface GoogleFilesAPIUploadResult {
+    file: {
+        name: string;
+        displayName: string;
+        mimeType: string;
+        sizeBytes: string;
+        createTime: string;
+        updateTime: string;
+        expirationTime: string;
+        sha256Hash: string;
+        uri: string;
+    };
+}

package/dist/types/generateTypes.d.ts

@@ -16,6 +16,7 @@ export type GenerateOptions = {
         text: string;
         images?: Array<Buffer | string>;
         csvFiles?: Array<Buffer | string>;
+        pdfFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string>;
         content?: Array<TextContent | ImageContent>;
     };

package/dist/types/observability.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Observability Configuration Types
+ * These configs are passed from the parent application (e.g., Lighthouse)
+ * to enable telemetry and observability features in Neurolink SDK
+ */
+/**
+ * Langfuse observability configuration
+ */
+export interface LangfuseConfig {
+    /** Whether Langfuse is enabled */
+    enabled: boolean;
+    /** Langfuse public key */
+    publicKey: string;
+    /**
+     * Langfuse secret key
+     * @sensitive
+     * WARNING: This is a sensitive credential. Handle securely.
+     * Do NOT log, expose, or share this key. Follow best practices for secret management.
+     */
+    secretKey: string;
+    /** Langfuse base URL (default: https://cloud.langfuse.com) */
+    baseUrl?: string;
+    /** Environment name (e.g., dev, staging, prod) */
+    environment?: string;
+    /** Release/version identifier */
+    release?: string;
+}
+/**
+ * OpenTelemetry configuration
+ */
+export interface OpenTelemetryConfig {
+    /** Whether OpenTelemetry is enabled */
+    enabled: boolean;
+    /** OTLP endpoint URL */
+    endpoint?: string;
+    /** Service name for traces */
+    serviceName?: string;
+    /** Service version */
+    serviceVersion?: string;
+}
+/**
+ * Complete observability configuration for Neurolink SDK
+ */
+export interface ObservabilityConfig {
+    /** Langfuse configuration */
+    langfuse?: LangfuseConfig;
+    /** OpenTelemetry configuration */
+    openTelemetry?: OpenTelemetryConfig;
+}

package/dist/types/observability.js

@@ -0,0 +1,6 @@
+/**
+ * Observability Configuration Types
+ * These configs are passed from the parent application (e.g., Lighthouse)
+ * to enable telemetry and observability features in Neurolink SDK
+ */
+export {};