moda-ai 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1280 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api = require('@opentelemetry/api');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var exporterTraceOtlpProto = require('@opentelemetry/exporter-trace-otlp-proto');
+var resources = require('@opentelemetry/resources');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var crypto = require('crypto');
+var async_hooks = require('async_hooks');
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_OPTIONS = {
+    baseUrl: 'https://ingest.moda.so/v1/traces',
+    environment: 'production',
+    enabled: true,
+    debug: false,
+    batchSize: 100,
+    flushInterval: 5000,
+};
+
+/**
+ * Internal SDK state (shared module to avoid circular dependencies)
+ */
+const state = {
+    initialized: false,
+    apiKey: null,
+    options: { ...DEFAULT_OPTIONS },
+};
+/**
+ * Check if debug mode is enabled
+ */
+function isDebugEnabled() {
+    return state.options.debug;
+}
+/**
+ * Update state options
+ */
+function setStateOptions(options) {
+    state.options = options;
+}
+/**
+ * Reset state to initial values
+ */
+function resetState() {
+    state.initialized = false;
+    state.apiKey = null;
+    state.options = { ...DEFAULT_OPTIONS };
+}
+
+/**
+ * Compute SHA256 hash of input string
+ * @param input - String to hash
+ * @returns Hexadecimal hash string
+ */
+function sha256(input) {
+    return crypto.createHash('sha256').update(input).digest('hex');
+}
+/**
+ * Compute truncated SHA256 hash
+ * @param input - String to hash
+ * @param length - Number of characters to return (default: 16)
+ * @returns Truncated hexadecimal hash string
+ */
+function sha256Short(input, length = 16) {
+    return sha256(input).slice(0, length);
+}
+
+/**
+ * Extract text content from various message content formats
+ */
+function extractTextContent(content) {
+    if (content === null || content === undefined) {
+        return '';
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string') {
+                return part;
+            }
+            if (part.type === 'text' && part.text) {
+                return part.text;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+/**
+ * Normalize OpenAI messages to generic Message format
+ */
+function normalizeOpenAIMessages(messages) {
+    return messages.map((msg) => ({
+        role: msg.role,
+        content: normalizeOpenAIContent(msg.content),
+        name: msg.name,
+        tool_call_id: msg.tool_call_id,
+    }));
+}
+/**
+ * Normalize OpenAI content to string or ContentPart array
+ */
+function normalizeOpenAIContent(content) {
+    if (content === null) {
+        return '';
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    return content.map((part) => {
+        if (part.type === 'text') {
+            return { type: 'text', text: part.text };
+        }
+        if (part.type === 'image_url') {
+            return { type: 'image_url', image_url: part.image_url };
+        }
+        return { type: 'text', text: '' };
+    });
+}
+/**
+ * Normalize Anthropic messages to generic Message format
+ */
+function normalizeAnthropicMessages(messages, systemPrompt) {
+    const normalized = [];
+    if (systemPrompt) {
+        normalized.push({
+            role: 'system',
+            content: systemPrompt,
+        });
+    }
+    for (const msg of messages) {
+        normalized.push({
+            role: msg.role,
+            content: normalizeAnthropicContent(msg.content),
+        });
+    }
+    return normalized;
+}
+/**
+ * Normalize Anthropic content to string or ContentPart array
+ */
+function normalizeAnthropicContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    return content.map((block) => {
+        switch (block.type) {
+            case 'text':
+                return { type: 'text', text: block.text };
+            case 'image':
+                return { type: 'image', source: block.source };
+            case 'tool_use':
+                return {
+                    type: 'tool_use',
+                    text: JSON.stringify({ id: block.id, name: block.name, input: block.input }),
+                };
+            case 'tool_result':
+                return {
+                    type: 'tool_result',
+                    text: typeof block.content === 'string'
+                        ? block.content
+                        : JSON.stringify(block.content),
+                };
+            case 'thinking':
+                return { type: 'thinking', text: block.thinking };
+            default:
+                return { type: 'text', text: '' };
+        }
+    });
+}
+/**
+ * Find the first user message in a message array
+ */
+function findFirstUserMessage(messages) {
+    return messages.find((m) => m.role === 'user');
+}
+/**
+ * Extract system prompt from messages
+ */
+function extractSystemPrompt(messages) {
+    const systemMessage = messages.find((m) => m.role === 'system');
+    if (!systemMessage)
+        return undefined;
+    return extractTextContent(systemMessage.content);
+}
+/**
+ * Format messages for span attributes (OpenLLMetry compatible)
+ */
+function formatMessagesForSpan(messages) {
+    const attributes = {};
+    messages.forEach((msg, index) => {
+        attributes[`llm.prompts.${index}.role`] = msg.role;
+        attributes[`llm.prompts.${index}.content`] = extractTextContent(msg.content);
+    });
+    return attributes;
+}
+/**
+ * Format completion for span attributes
+ */
+function formatCompletionForSpan(role, content, index = 0) {
+    return {
+        [`llm.completions.${index}.role`]: role,
+        [`llm.completions.${index}.content`]: content,
+    };
+}
+
+/**
+ * AsyncLocalStorage instance for managing Moda context across async operations
+ */
+const storage = new async_hooks.AsyncLocalStorage();
+/**
+ * Get the current Moda context from AsyncLocalStorage
+ * @returns Current context or empty object if not set
+ */
+function getContext() {
+    return storage.getStore() ?? {};
+}
+/**
+ * Set the conversation ID in the current context.
+ * Note: This creates a new context with only the conversationId.
+ * For nested contexts, use withConversationId instead.
+ */
+let globalContext = {};
+/**
+ * Set a global conversation ID that persists across async boundaries.
+ * This is useful when you want to track a conversation across multiple API calls
+ * without wrapping them in a callback.
+ *
+ * @param id - The conversation ID to set
+ */
+function setConversationId(id) {
+    globalContext = { ...globalContext, conversationId: id };
+}
+/**
+ * Clear the global conversation ID.
+ */
+function clearConversationId() {
+    const { conversationId: _, ...rest } = globalContext;
+    globalContext = rest;
+}
+/**
+ * Set a global user ID that persists across async boundaries.
+ *
+ * @param id - The user ID to set
+ */
+function setUserId(id) {
+    globalContext = { ...globalContext, userId: id };
+}
+/**
+ * Clear the global user ID.
+ */
+function clearUserId() {
+    const { userId: _, ...rest } = globalContext;
+    globalContext = rest;
+}
+/**
+ * Get the combined context (AsyncLocalStorage + global)
+ * AsyncLocalStorage takes precedence over global context
+ */
+function getEffectiveContext() {
+    const localContext = getContext();
+    return {
+        ...globalContext,
+        ...localContext,
+    };
+}
+/**
+ * Run a callback with a specific conversation ID in the AsyncLocalStorage context.
+ * The conversation ID will be available to all async operations within the callback.
+ *
+ * @param id - The conversation ID to set
+ * @param callback - The function to run with the context
+ * @returns The return value of the callback
+ *
+ * @example
+ * ```typescript
+ * await withConversationId('my-conv-123', async () => {
+ *   await openai.chat.completions.create({ ... });
+ *   await openai.chat.completions.create({ ... });
+ *   // Both calls will have the same conversation ID
+ * });
+ * ```
+ */
+function withConversationId(id, callback) {
+    const currentContext = getEffectiveContext();
+    return storage.run({ ...currentContext, conversationId: id }, callback);
+}
+/**
+ * Run a callback with a specific user ID in the AsyncLocalStorage context.
+ *
+ * @param id - The user ID to set
+ * @param callback - The function to run with the context
+ * @returns The return value of the callback
+ */
+function withUserId(id, callback) {
+    const currentContext = getEffectiveContext();
+    return storage.run({ ...currentContext, userId: id }, callback);
+}
+/**
+ * Run a callback with both conversation ID and user ID in context.
+ *
+ * @param conversationId - The conversation ID to set
+ * @param userId - The user ID to set
+ * @param callback - The function to run with the context
+ * @returns The return value of the callback
+ */
+function withContext(conversationId, userId, callback) {
+    return storage.run({ conversationId, userId }, callback);
+}
+/**
+ * Get the global context (without AsyncLocalStorage context).
+ * Useful for accessing the explicitly set conversationId and userId.
+ */
+function getGlobalContext() {
+    return globalContext;
+}
+
+/**
+ * Compute a stable conversation ID from message history.
+ *
+ * The algorithm:
+ * 1. If an explicit ID is provided (via context or parameter), use it
+ * 2. Find the first user message in the conversation
+ * 3. Compute SHA256 hash of: system prompt + first user message
+ * 4. Return conv_[hash[:16]]
+ *
+ * This ensures that multi-turn conversations with the same starting point
+ * always get the same conversation ID, enabling proper thread tracking.
+ *
+ * @param messages - Array of messages in the conversation
+ * @param systemPrompt - Optional system prompt (separate from messages, e.g., Anthropic style)
+ * @param explicitId - Optional explicit conversation ID to override computation
+ * @returns Conversation ID in format conv_[16-char-hash] or the explicit ID
+ */
+function computeConversationId(messages, systemPrompt, explicitId) {
+    // Priority 1: Explicit ID provided as parameter
+    if (explicitId) {
+        return explicitId;
+    }
+    // Priority 2: ID set in context (global or AsyncLocalStorage)
+    const context = getEffectiveContext();
+    if (context.conversationId) {
+        return context.conversationId;
+    }
+    // Priority 3: Compute from messages
+    const firstUserMessage = findFirstUserMessage(messages);
+    if (!firstUserMessage) {
+        // No user message found, generate random ID
+        return `conv_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+    }
+    // Get system prompt from messages if not provided separately
+    const effectiveSystemPrompt = systemPrompt ?? extractSystemPrompt(messages);
+    const firstUserContent = extractTextContent(firstUserMessage.content);
+    // Create seed for hashing
+    const seed = JSON.stringify({
+        system: effectiveSystemPrompt ?? null,
+        first_user: firstUserContent,
+    });
+    const hash = sha256Short(seed, 16);
+    return `conv_${hash}`;
+}
+/**
+ * Generate a random conversation ID
+ * Useful for cases where automatic computation is not desired
+ */
+function generateRandomConversationId() {
+    return `conv_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+}
+/**
+ * Validate conversation ID format
+ * @param id - Conversation ID to validate
+ * @returns true if the ID matches expected format
+ */
+function isValidConversationId(id) {
+    // Accept any string, but prefer conv_* format
+    return typeof id === 'string' && id.length > 0;
+}
+
+/**
+ * Base class for LLM client instrumentations.
+ * Provides common functionality for creating spans and setting attributes.
+ */
+class BaseInstrumentation {
+    vendor;
+    tracer = api.trace.getTracer('moda-sdk', '0.1.0');
+    constructor(vendor) {
+        this.vendor = vendor;
+    }
+    /**
+     * Create span attributes for an LLM call
+     */
+    createSpanAttributes(messages, model, systemPrompt) {
+        const context = getEffectiveContext();
+        const conversationId = computeConversationId(messages, systemPrompt);
+        const attributes = {
+            'llm.vendor': this.vendor,
+            'llm.request.type': 'chat',
+            'llm.request.model': model,
+            'moda.conversation_id': conversationId,
+        };
+        if (context.userId) {
+            attributes['moda.user_id'] = context.userId;
+        }
+        // Add message attributes
+        const messageAttrs = formatMessagesForSpan(messages);
+        Object.assign(attributes, messageAttrs);
+        return attributes;
+    }
+    /**
+     * Add completion attributes to a span
+     */
+    addCompletionAttributes(span, role, content, index = 0) {
+        const attrs = formatCompletionForSpan(role, content, index);
+        for (const [key, value] of Object.entries(attrs)) {
+            span.setAttribute(key, value);
+        }
+    }
+    /**
+     * Add usage metrics to a span
+     */
+    addUsageAttributes(span, usage) {
+        if (!usage)
+            return;
+        const promptTokens = usage.prompt_tokens ?? usage.input_tokens;
+        const completionTokens = usage.completion_tokens ?? usage.output_tokens;
+        const totalTokens = usage.total_tokens ?? (promptTokens && completionTokens ? promptTokens + completionTokens : undefined);
+        if (promptTokens !== undefined) {
+            span.setAttribute('llm.usage.prompt_tokens', promptTokens);
+        }
+        if (completionTokens !== undefined) {
+            span.setAttribute('llm.usage.completion_tokens', completionTokens);
+        }
+        if (totalTokens !== undefined) {
+            span.setAttribute('llm.usage.total_tokens', totalTokens);
+        }
+    }
+    /**
+     * Set span error status
+     */
+    setSpanError(span, error) {
+        span.setStatus({
+            code: api.SpanStatusCode.ERROR,
+            message: error.message,
+        });
+        span.recordException(error);
+    }
+    /**
+     * Set span success status
+     */
+    setSpanSuccess(span) {
+        span.setStatus({ code: api.SpanStatusCode.OK });
+    }
+    /**
+     * Log debug message if debug mode is enabled
+     */
+    debug(message, ...args) {
+        if (isDebugEnabled()) {
+            console.log(`[Moda:${this.vendor}] ${message}`, ...args);
+        }
+    }
+}
+
+// Store original methods for unpatching
+let originalChatCompletionsCreate = null;
+let patched$1 = false;
+/**
+ * OpenAI client instrumentation.
+ * Automatically tracks all chat completion calls with conversation threading.
+ */
+class OpenAIInstrumentation extends BaseInstrumentation {
+    constructor() {
+        super('openai');
+    }
+    /**
+     * Patch the OpenAI client to add instrumentation
+     */
+    patch() {
+        if (patched$1) {
+            this.debug('Already patched');
+            return;
+        }
+        try {
+            // Dynamic import to handle optional dependency
+            const openaiModule = require('openai');
+            const OpenAI = openaiModule.default || openaiModule;
+            if (!OpenAI || !OpenAI.prototype) {
+                this.debug('OpenAI module not found or invalid');
+                return;
+            }
+            const instrumentation = this;
+            // Patch the Chat.Completions.create method
+            // We need to patch at the prototype level of the internal class
+            const originalConstructor = OpenAI;
+            // Override the constructor to patch instances
+            const patchedOpenAI = function (...args) {
+                const instance = new originalConstructor(...args);
+                instrumentation.patchInstance(instance);
+                return instance;
+            };
+            // Copy static properties
+            Object.setPrototypeOf(patchedOpenAI, originalConstructor);
+            patchedOpenAI.prototype = originalConstructor.prototype;
+            // Replace in module cache
+            if (openaiModule.default) {
+                openaiModule.default = patchedOpenAI;
+            }
+            // Also patch existing instances by patching the prototype
+            this.patchPrototype(OpenAI);
+            patched$1 = true;
+            this.debug('Patched successfully');
+        }
+        catch (error) {
+            // OpenAI not installed, skip silently
+            this.debug('Could not patch OpenAI:', error);
+        }
+    }
+    /**
+     * Patch an OpenAI instance
+     */
+    patchInstance(instance) {
+        if (!instance.chat?.completions?.create) {
+            return;
+        }
+        const instrumentation = this;
+        const original = instance.chat.completions.create.bind(instance.chat.completions);
+        instance.chat.completions.create = async function (params, options) {
+            return instrumentation.tracedCreate(original, params, options);
+        };
+    }
+    /**
+     * Patch the OpenAI prototype to catch all instances
+     */
+    patchPrototype(OpenAI) {
+        const instrumentation = this;
+        // Store original Chat class create method
+        try {
+            const chatProto = OpenAI.Chat?.Completions?.prototype;
+            if (chatProto && chatProto.create) {
+                originalChatCompletionsCreate = chatProto.create;
+                chatProto.create = async function (params, options) {
+                    const original = originalChatCompletionsCreate.bind(this);
+                    return instrumentation.tracedCreate(original, params, options);
+                };
+            }
+        }
+        catch {
+            // Prototype structure may vary
+        }
+    }
+    /**
+     * Wrap a create call with tracing
+     */
+    async tracedCreate(original, params, options) {
+        const messages = params.messages;
+        const model = params.model;
+        const isStreaming = params.stream === true;
+        // Normalize messages
+        const normalizedMessages = normalizeOpenAIMessages(messages);
+        // Create span attributes
+        const attributes = this.createSpanAttributes(normalizedMessages, model);
+        // Add streaming flag
+        attributes['llm.request.streaming'] = isStreaming;
+        // Create span
+        const span = this.tracer.startSpan('openai.chat.completions.create', {
+            attributes,
+        });
+        try {
+            if (isStreaming) {
+                return await this.handleStreamingResponse(original, params, options, span);
+            }
+            else {
+                return await this.handleNonStreamingResponse(original, params, options, span);
+            }
+        }
+        catch (error) {
+            this.setSpanError(span, error);
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Handle non-streaming response
+     */
+    async handleNonStreamingResponse(original, params, options, span) {
+        const response = await original(params, options);
+        // Extract completion
+        const choice = response.choices?.[0];
+        if (choice?.message) {
+            const content = choice.message.content || '';
+            const role = choice.message.role || 'assistant';
+            this.addCompletionAttributes(span, role, content);
+            // Add finish reason
+            if (choice.finish_reason) {
+                span.setAttribute('llm.response.finish_reason', choice.finish_reason);
+            }
+        }
+        // Add model from response
+        if (response.model) {
+            span.setAttribute('llm.response.model', response.model);
+        }
+        // Add usage metrics
+        this.addUsageAttributes(span, response.usage);
+        this.setSpanSuccess(span);
+        return response;
+    }
+    /**
+     * Handle streaming response
+     */
+    async handleStreamingResponse(original, params, options, span) {
+        const stream = await original(params, options);
+        const instrumentation = this;
+        // Wrap the stream to capture content
+        let fullContent = '';
+        let finishReason = null;
+        let model = null;
+        let usage = null;
+        // Create async iterator wrapper
+        const wrappedStream = {
+            [Symbol.asyncIterator]: async function* () {
+                try {
+                    for await (const chunk of stream) {
+                        // Capture content
+                        const delta = chunk.choices?.[0]?.delta;
+                        if (delta?.content) {
+                            fullContent += delta.content;
+                        }
+                        // Capture finish reason
+                        if (chunk.choices?.[0]?.finish_reason) {
+                            finishReason = chunk.choices[0].finish_reason;
+                        }
+                        // Capture model
+                        if (chunk.model) {
+                            model = chunk.model;
+                        }
+                        // Capture usage (OpenAI includes it in the last chunk with stream_options)
+                        if (chunk.usage) {
+                            usage = chunk.usage;
+                        }
+                        yield chunk;
+                    }
+                    // After stream completes, add attributes
+                    instrumentation.addCompletionAttributes(span, 'assistant', fullContent);
+                    if (finishReason) {
+                        span.setAttribute('llm.response.finish_reason', finishReason);
+                    }
+                    if (model) {
+                        span.setAttribute('llm.response.model', model);
+                    }
+                    if (usage) {
+                        instrumentation.addUsageAttributes(span, usage);
+                    }
+                    instrumentation.setSpanSuccess(span);
+                }
+                catch (error) {
+                    instrumentation.setSpanError(span, error);
+                    throw error;
+                }
+            },
+            // Forward other stream methods
+            ...stream,
+        };
+        // If the stream has a controller/abort method, forward it
+        if (stream.controller) {
+            wrappedStream.controller = stream.controller;
+        }
+        return wrappedStream;
+    }
+    /**
+     * Unpatch the OpenAI client
+     */
+    unpatch() {
+        if (!patched$1) {
+            return;
+        }
+        try {
+            const openaiModule = require('openai');
+            const OpenAI = openaiModule.default || openaiModule;
+            if (originalChatCompletionsCreate && OpenAI.Chat?.Completions?.prototype) {
+                OpenAI.Chat.Completions.prototype.create = originalChatCompletionsCreate;
+            }
+            patched$1 = false;
+            originalChatCompletionsCreate = null;
+            this.debug('Unpatched successfully');
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+// Export singleton instance
+const openAIInstrumentation = new OpenAIInstrumentation();
+
+// Store original methods for unpatching
+let originalMessagesCreate = null;
+let patched = false;
+/**
+ * Anthropic client instrumentation.
+ * Automatically tracks all message creation calls with conversation threading.
+ */
+class AnthropicInstrumentation extends BaseInstrumentation {
+    constructor() {
+        super('anthropic');
+    }
+    /**
+     * Patch the Anthropic client to add instrumentation
+     */
+    patch() {
+        if (patched) {
+            this.debug('Already patched');
+            return;
+        }
+        try {
+            // Dynamic import to handle optional dependency
+            const anthropicModule = require('@anthropic-ai/sdk');
+            const Anthropic = anthropicModule.default || anthropicModule;
+            if (!Anthropic || !Anthropic.prototype) {
+                this.debug('Anthropic module not found or invalid');
+                return;
+            }
+            // Patch the Messages.create method at prototype level
+            this.patchPrototype(Anthropic);
+            patched = true;
+            this.debug('Patched successfully');
+        }
+        catch (error) {
+            // Anthropic not installed, skip silently
+            this.debug('Could not patch Anthropic:', error);
+        }
+    }
+    /**
+     * Patch the Anthropic prototype to catch all instances
+     */
+    patchPrototype(Anthropic) {
+        const instrumentation = this;
+        try {
+            const messagesProto = Anthropic.Messages?.prototype;
+            if (messagesProto && messagesProto.create) {
+                originalMessagesCreate = messagesProto.create;
+                messagesProto.create = async function (params, options) {
+                    const original = originalMessagesCreate.bind(this);
+                    return instrumentation.tracedCreate(original, params, options);
+                };
+            }
+        }
+        catch {
+            // Try alternative approach - patch on client construction
+            const originalConstructor = Anthropic;
+            // We'll wrap the constructor
+            const patchedAnthropic = function (...args) {
+                const instance = new originalConstructor(...args);
+                instrumentation.patchInstance(instance);
+                return instance;
+            };
+            Object.setPrototypeOf(patchedAnthropic, originalConstructor);
+            patchedAnthropic.prototype = originalConstructor.prototype;
+        }
+    }
+    /**
+     * Patch an Anthropic instance
+     */
+    patchInstance(instance) {
+        if (!instance.messages?.create) {
+            return;
+        }
+        const instrumentation = this;
+        const original = instance.messages.create.bind(instance.messages);
+        instance.messages.create = async function (params, options) {
+            return instrumentation.tracedCreate(original, params, options);
+        };
+    }
+    /**
+     * Wrap a create call with tracing
+     */
+    async tracedCreate(original, params, options) {
+        const messages = params.messages;
+        const model = params.model;
+        const systemPrompt = this.extractSystemPrompt(params.system);
+        const isStreaming = params.stream === true;
+        // Normalize messages
+        const normalizedMessages = normalizeAnthropicMessages(messages, systemPrompt);
+        // Create span attributes
+        const attributes = this.createSpanAttributes(normalizedMessages, model, systemPrompt);
+        // Add streaming flag
+        attributes['llm.request.streaming'] = isStreaming;
+        // Add max tokens if specified
+        if (params.max_tokens) {
+            attributes['llm.request.max_tokens'] = params.max_tokens;
+        }
+        // Create span
+        const span = this.tracer.startSpan('anthropic.messages.create', {
+            attributes,
+        });
+        try {
+            if (isStreaming) {
+                return await this.handleStreamingResponse(original, params, options, span);
+            }
+            else {
+                return await this.handleNonStreamingResponse(original, params, options, span);
+            }
+        }
+        catch (error) {
+            this.setSpanError(span, error);
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Extract system prompt from Anthropic's system parameter
+     * Can be a string or array of content blocks
+     */
+    extractSystemPrompt(system) {
+        if (!system)
+            return undefined;
+        if (typeof system === 'string') {
+            return system;
+        }
+        if (Array.isArray(system)) {
+            return system
+                .filter((block) => block.type === 'text')
+                .map((block) => block.text)
+                .join('\n');
+        }
+        return undefined;
+    }
+    /**
+     * Handle non-streaming response
+     */
+    async handleNonStreamingResponse(original, params, options, span) {
+        const response = await original(params, options);
+        // Extract completion content
+        const content = this.extractResponseContent(response.content);
+        this.addCompletionAttributes(span, 'assistant', content);
+        // Add stop reason
+        if (response.stop_reason) {
+            span.setAttribute('llm.response.finish_reason', response.stop_reason);
+        }
+        // Add model from response
+        if (response.model) {
+            span.setAttribute('llm.response.model', response.model);
+        }
+        // Add usage metrics (Anthropic uses input_tokens/output_tokens)
+        this.addUsageAttributes(span, response.usage);
+        this.setSpanSuccess(span);
+        return response;
+    }
+    /**
+     * Handle streaming response
+     */
+    async handleStreamingResponse(original, params, options, span) {
+        const stream = await original(params, options);
+        const instrumentation = this;
+        // Wrap the stream to capture content
+        let fullContent = '';
+        let stopReason = null;
+        let model = null;
+        let usage = null;
+        // Create async iterator wrapper
+        const wrappedStream = {
+            [Symbol.asyncIterator]: async function* () {
+                try {
+                    for await (const event of stream) {
+                        // Handle different event types
+                        switch (event.type) {
+                            case 'message_start':
+                                if (event.message?.model) {
+                                    model = event.message.model;
+                                }
+                                if (event.message?.usage) {
+                                    usage = { ...usage, ...event.message.usage };
+                                }
+                                break;
+                            case 'content_block_delta':
+                                if (event.delta?.type === 'text_delta' && event.delta?.text) {
+                                    fullContent += event.delta.text;
+                                }
+                                break;
+                            case 'message_delta':
+                                if (event.delta?.stop_reason) {
+                                    stopReason = event.delta.stop_reason;
+                                }
+                                if (event.usage) {
+                                    usage = { ...usage, ...event.usage };
+                                }
+                                break;
+                        }
+                        yield event;
+                    }
+                    // After stream completes, add attributes
+                    instrumentation.addCompletionAttributes(span, 'assistant', fullContent);
+                    if (stopReason) {
+                        span.setAttribute('llm.response.finish_reason', stopReason);
+                    }
+                    if (model) {
+                        span.setAttribute('llm.response.model', model);
+                    }
+                    if (usage) {
+                        instrumentation.addUsageAttributes(span, usage);
+                    }
+                    instrumentation.setSpanSuccess(span);
+                }
+                catch (error) {
+                    instrumentation.setSpanError(span, error);
+                    throw error;
+                }
+            },
+            // Forward other stream methods
+            ...stream,
+        };
+        return wrappedStream;
+    }
+    /**
+     * Extract text content from Anthropic response content blocks
+     */
+    extractResponseContent(content) {
+        if (!content || !Array.isArray(content)) {
+            return '';
+        }
+        return content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text || '')
+            .join('\n');
+    }
+    /**
+     * Unpatch the Anthropic client
+     */
+    unpatch() {
+        if (!patched) {
+            return;
+        }
+        try {
+            const anthropicModule = require('@anthropic-ai/sdk');
+            const Anthropic = anthropicModule.default || anthropicModule;
+            if (originalMessagesCreate && Anthropic.Messages?.prototype) {
+                Anthropic.Messages.prototype.create = originalMessagesCreate;
+            }
+            patched = false;
+            originalMessagesCreate = null;
+            this.debug('Unpatched successfully');
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+// Export singleton instance
+const anthropicInstrumentation = new AnthropicInstrumentation();
+
+/**
+ * List of all available instrumentations
+ */
+const instrumentations = [
+    openAIInstrumentation,
+    anthropicInstrumentation,
+];
+/**
+ * Register all LLM client instrumentations.
+ * This is called automatically by Moda.init()
+ */
+function registerInstrumentations() {
+    for (const instrumentation of instrumentations) {
+        try {
+            instrumentation.patch();
+        }
+        catch (error) {
+            // Individual instrumentation failures should not break the SDK
+            console.warn(`[Moda] Failed to register instrumentation:`, error);
+        }
+    }
+}
+
+let provider = null;
+let exporter = null;
+/**
+ * Check if the SDK is initialized
+ */
+function isInitialized() {
+    return state.initialized;
+}
+/**
+ * Initialize the Moda SDK.
+ *
+ * This sets up OpenTelemetry tracing with an OTLP exporter pointed at Moda's
+ * ingestion endpoint and registers instrumentations for OpenAI and Anthropic.
+ *
+ * @param apiKey - Your Moda API key (format: moda_xxx)
+ * @param options - Configuration options
+ *
+ * @example
+ * ```typescript
+ * import { Moda } from '@moda/sdk';
+ *
+ * Moda.init('moda_your_api_key', {
+ *   environment: 'production',
+ *   debug: false,
+ * });
+ * ```
+ */
+function init(apiKey, options = {}) {
+    if (state.initialized) {
+        if (state.options.debug) {
+            console.warn('[Moda] SDK already initialized. Call shutdown() before re-initializing.');
+        }
+        return;
+    }
+    if (!apiKey || typeof apiKey !== 'string') {
+        throw new Error('[Moda] API key is required');
+    }
+    // Merge options with defaults
+    const mergedOptions = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+    state.apiKey = apiKey;
+    setStateOptions(mergedOptions);
+    if (!mergedOptions.enabled) {
+        if (mergedOptions.debug) {
+            console.log('[Moda] SDK disabled via options');
+        }
+        state.initialized = true;
+        return;
+    }
+    // Create resource with service info
+    const resource = new resources.Resource({
+        [semanticConventions.ATTR_SERVICE_NAME]: 'moda-sdk',
+        [semanticConventions.ATTR_SERVICE_VERSION]: '0.1.0',
+        'moda.environment': mergedOptions.environment,
+    });
+    // Create OTLP exporter with Moda API key in headers
+    exporter = new exporterTraceOtlpProto.OTLPTraceExporter({
+        url: mergedOptions.baseUrl,
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/x-protobuf',
+        },
+    });
+    // Create tracer provider
+    provider = new sdkTraceNode.NodeTracerProvider({
+        resource,
+    });
+    // Use BatchSpanProcessor for production, SimpleSpanProcessor for debug
+    const processor = mergedOptions.debug
+        ? new sdkTraceBase.SimpleSpanProcessor(exporter)
+        : new sdkTraceBase.BatchSpanProcessor(exporter, {
+            maxQueueSize: mergedOptions.batchSize * 2,
+            maxExportBatchSize: mergedOptions.batchSize,
+            scheduledDelayMillis: mergedOptions.flushInterval,
+        });
+    provider.addSpanProcessor(processor);
+    provider.register();
+    // Register LLM instrumentations
+    registerInstrumentations();
+    state.initialized = true;
+    if (mergedOptions.debug) {
+        console.log('[Moda] SDK initialized successfully');
+        console.log(`[Moda] Endpoint: ${mergedOptions.baseUrl}`);
+        console.log(`[Moda] Environment: ${mergedOptions.environment}`);
+    }
+}
+/**
+ * Force flush all pending spans to the Moda backend.
+ * Call this before your application exits to ensure all telemetry is sent.
+ *
+ * @example
+ * ```typescript
+ * // Before shutting down
+ * await Moda.flush();
+ * process.exit(0);
+ * ```
+ */
+async function flush() {
+    if (!state.initialized || !provider) {
+        return;
+    }
+    try {
+        await provider.forceFlush();
+        if (state.options.debug) {
+            console.log('[Moda] Flushed all pending spans');
+        }
+    }
+    catch (error) {
+        if (state.options.debug) {
+            console.error('[Moda] Error flushing spans:', error);
+        }
+        throw error;
+    }
+}
+/**
+ * Shutdown the SDK and release all resources.
+ * This flushes any pending spans and stops the tracer provider.
+ *
+ * @example
+ * ```typescript
+ * process.on('SIGTERM', async () => {
+ *   await Moda.shutdown();
+ *   process.exit(0);
+ * });
+ * ```
+ */
+async function shutdown() {
+    if (!state.initialized) {
+        return;
+    }
+    try {
+        if (provider) {
+            await provider.shutdown();
+        }
+        if (state.options.debug) {
+            console.log('[Moda] SDK shutdown complete');
+        }
+    }
+    catch (error) {
+        if (state.options.debug) {
+            console.error('[Moda] Error during shutdown:', error);
+        }
+        throw error;
+    }
+    finally {
+        resetState();
+        provider = null;
+        exporter = null;
+    }
+}
+/**
+ * Get the OpenTelemetry tracer for creating custom spans.
+ * Returns a no-op tracer if the SDK is not initialized.
+ */
+function getTracer() {
+    return api.trace.getTracer('moda-sdk', '0.1.0');
+}
+
+/**
+ * @moda/sdk - Official TypeScript/Node.js SDK for Moda LLM observability
+ *
+ * @example
+ * ```typescript
+ * import { Moda } from '@moda/sdk';
+ *
+ * // Initialize the SDK
+ * Moda.init('moda_your_api_key');
+ *
+ * // All OpenAI/Anthropic calls are now automatically tracked
+ * const openai = new OpenAI();
+ * await openai.chat.completions.create({ ... });
+ *
+ * // Flush before exit
+ * await Moda.flush();
+ * ```
+ */
+// Core SDK functions
+/**
+ * Main Moda SDK object with all public methods
+ */
+const Moda = {
+    /**
+     * Initialize the Moda SDK with your API key
+     * @see {@link init}
+     */
+    init,
+    /**
+     * Force flush all pending spans to the Moda backend
+     * @see {@link flush}
+     */
+    flush,
+    /**
+     * Shutdown the SDK and release all resources
+     * @see {@link shutdown}
+     */
+    shutdown,
+    /**
+     * Check if the SDK is initialized
+     * @see {@link isInitialized}
+     */
+    isInitialized,
+    /**
+     * Set a global conversation ID for subsequent LLM calls
+     * @see {@link setConversationId}
+     */
+    setConversationId,
+    /**
+     * Clear the global conversation ID
+     * @see {@link clearConversationId}
+     */
+    clearConversationId,
+    /**
+     * Set a global user ID for subsequent LLM calls
+     * @see {@link setUserId}
+     */
+    setUserId,
+    /**
+     * Clear the global user ID
+     * @see {@link clearUserId}
+     */
+    clearUserId,
+    /**
+     * Get the OpenTelemetry tracer for custom spans
+     * @see {@link getTracer}
+     */
+    getTracer,
+    /**
+     * Get or set the global conversation ID.
+     * Setting to null clears the conversation ID.
+     *
+     * @example
+     * ```typescript
+     * Moda.conversationId = 'session_123';
+     * await client.chat.completions.create({...});
+     * Moda.conversationId = null; // clear
+     * ```
+     */
+    get conversationId() {
+        return getGlobalContext().conversationId ?? null;
+    },
+    set conversationId(id) {
+        if (id) {
+            setConversationId(id);
+        }
+        else {
+            clearConversationId();
+        }
+    },
+    /**
+     * Get or set the global user ID.
+     * Setting to null clears the user ID.
+     *
+     * @example
+     * ```typescript
+     * Moda.userId = 'user_456';
+     * await client.chat.completions.create({...});
+     * Moda.userId = null; // clear
+     * ```
+     */
+    get userId() {
+        return getGlobalContext().userId ?? null;
+    },
+    set userId(id) {
+        if (id) {
+            setUserId(id);
+        }
+        else {
+            clearUserId();
+        }
+    },
+};
+
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.Moda = Moda;
+exports.clearConversationId = clearConversationId;
+exports.clearUserId = clearUserId;
+exports.computeConversationId = computeConversationId;
+exports.default = Moda;
+exports.flush = flush;
+exports.generateRandomConversationId = generateRandomConversationId;
+exports.getContext = getContext;
+exports.getEffectiveContext = getEffectiveContext;
+exports.getGlobalContext = getGlobalContext;
+exports.getTracer = getTracer;
+exports.init = init;
+exports.isInitialized = isInitialized;
+exports.isValidConversationId = isValidConversationId;
+exports.setConversationId = setConversationId;
+exports.setUserId = setUserId;
+exports.shutdown = shutdown;
+exports.withContext = withContext;
+exports.withConversationId = withConversationId;
+exports.withUserId = withUserId;
+//# sourceMappingURL=index.cjs.map