openlayer 0.16.1 → 0.16.3

package/lib/integrations/langchainCallback.mjs

@@ -1,113 +1,625 @@
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
-import { AIMessage, SystemMessage } from '@langchain/core/messages';
-import performanceNow from 'performance-now';
-import { addChatCompletionStepToTrace } from "../tracing/tracer.mjs";
+import { AIMessage, AIMessageChunk, BaseMessage, ChatMessage, FunctionMessage, HumanMessage, SystemMessage, ToolMessage, } from '@langchain/core/messages';
+import { addChatCompletionStepToTrace, addChainStepToTrace, addAgentStepToTrace, addToolStepToTrace, addRetrieverStepToTrace, } from "../tracing/tracer.mjs";
 const LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP = {
     openai: 'OpenAI',
     'openai-chat': 'OpenAI',
     'chat-ollama': 'Ollama',
     vertexai: 'Google',
+    anthropic: 'Anthropic',
+    'azure-openai': 'Azure OpenAI',
+    cohere: 'Cohere',
+    huggingface: 'Hugging Face',
 };
 const PROVIDER_TO_STEP_NAME = {
     OpenAI: 'OpenAI Chat Completion',
     Ollama: 'Ollama Chat Completion',
     Google: 'Google Vertex AI Chat Completion',
+    Anthropic: 'Anthropic Chat Completion',
+    'Azure OpenAI': 'Azure OpenAI Chat Completion',
+    Cohere: 'Cohere Chat Completion',
+    'Hugging Face': 'Hugging Face Chat Completion',
 };
+const LANGSMITH_HIDDEN_TAG = 'langsmith:hidden';
+/**
+ * Comprehensive LangChain callback handler for Openlayer tracing.
+ *
+ * Supports all LangChain components:
+ * - LLMs and Chat Models (with streaming support)
+ * - Chains
+ * - Agents and Tools
+ * - Retrievers
+ * - Error handling and hierarchical tracking
+ *
+ * @example
+ * ```typescript
+ * import { OpenlayerHandler } from 'openlayer/lib/integrations/langchainCallback';
+ *
+ * const handler = new OpenlayerHandler({
+ *   userId: 'user-123',
+ *   sessionId: 'session-456',
+ *   tags: ['production'],
+ *   version: '1.0.0'
+ * });
+ *
+ * const model = new ChatOpenAI({
+ *   callbacks: [handler]
+ * });
+ * ```
+ */
 export class OpenlayerHandler extends BaseCallbackHandler {
-    constructor(kwargs = {}) {
+    constructor(params) {
         super();
         this.name = 'OpenlayerHandler';
-        this.startTime = null;
-        this.endTime = null;
-        this.prompt = null;
-        this.latency = 0;
-        this.model = null;
-        this.modelParameters = null;
-        this.promptTokens = 0;
-        this.completionTokens = 0;
-        this.totalTokens = 0;
-        this.output = '';
-        this.metadata = kwargs;
+        this.completionStartTimes = {};
+        this.promptToParentRunMap = new Map();
+        this.runMap = new Map();
+        this.sessionId = params?.sessionId;
+        this.userId = params?.userId;
+        this.tags = params?.tags ?? [];
+        this.traceMetadata = params?.traceMetadata;
+        this.version = params?.version;
+    }
+    // ============================================================================
+    // LLM Handlers
+    // ============================================================================
+    async handleLLMNewToken(token, _idx, runId, _parentRunId, _tags, _fields) {
+        try {
+            // Track first token timing for streaming
+            if (runId && !(runId in this.completionStartTimes)) {
+                console.debug(`LLM first streaming token: ${runId}`);
+                this.completionStartTimes[runId] = new Date();
+            }
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+        try {
+            console.debug(`LLM start with ID: ${runId}`);
+            this.handleGenerationStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
     }
     async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
-        this.initializeRun(extraParams || {}, metadata || {});
-        this.prompt = this.langchainMassagesToPrompt(messages);
-        this.startTime = performanceNow();
-    }
-    initializeRun(extraParams, metadata) {
-        this.modelParameters = extraParams['invocation_params'] || {};
-        const provider = metadata?.['ls_provider'];
-        if (provider && LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP[provider]) {
-            this.provider = LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP[provider];
-        }
-        this.model = this.modelParameters?.['model'] || metadata['ls_model_name'] || null;
-        this.output = '';
-    }
-    langchainMassagesToPrompt(messages) {
-        let prompt = [];
-        for (const message of messages) {
-            for (const m of message) {
-                if (m instanceof AIMessage) {
-                    prompt.push({ role: 'assistant', content: m.content });
+        try {
+            console.debug(`Chat model start with ID: ${runId}`);
+            const prompts = messages.flatMap((message) => message.map((m) => this.extractChatMessageContent(m)));
+            this.handleGenerationStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleLLMEnd(output, runId, parentRunId) {
+        try {
+            console.debug(`LLM end with ID: ${runId}`);
+            if (output.generations.length === 0) {
+                console.debug('No generations found in LLM output');
+                return;
+            }
+            const lastGeneration = output.generations[output.generations.length - 1];
+            if (!lastGeneration || lastGeneration.length === 0) {
+                console.debug('No responses found in last generation');
+                return;
+            }
+            const lastResponse = lastGeneration[lastGeneration.length - 1];
+            const llmUsage = (lastResponse ? this.extractUsageMetadata(lastResponse) : undefined) ||
+                output.llmOutput?.['tokenUsage'];
+            const modelName = lastResponse ? this.extractModelNameFromMetadata(lastResponse) : undefined;
+            const usageDetails = {
+                input: llmUsage?.input_tokens ?? llmUsage?.promptTokens,
+                output: llmUsage?.output_tokens ?? llmUsage?.completionTokens,
+                total: llmUsage?.total_tokens ?? llmUsage?.totalTokens,
+            };
+            // Handle detailed token usage if available
+            if (llmUsage && 'input_token_details' in llmUsage) {
+                for (const [key, val] of Object.entries(llmUsage['input_token_details'] ?? {})) {
+                    usageDetails[`input_${key}`] = val;
+                    if ('input' in usageDetails && typeof val === 'number') {
+                        usageDetails['input'] = Math.max(0, usageDetails['input'] - val);
+                    }
                 }
-                else if (m instanceof SystemMessage) {
-                    prompt.push({ role: 'system', content: m.content });
+            }
+            if (llmUsage && 'output_token_details' in llmUsage) {
+                for (const [key, val] of Object.entries(llmUsage['output_token_details'] ?? {})) {
+                    usageDetails[`output_${key}`] = val;
+                    if ('output' in usageDetails && typeof val === 'number') {
+                        usageDetails['output'] = Math.max(0, usageDetails['output'] - val);
+                    }
                 }
-                else {
-                    prompt.push({ role: 'user', content: m.content });
+            }
+            // Extract clean output for dashboard display
+            const extractedOutput = lastResponse ?
+                'message' in lastResponse && lastResponse['message'] instanceof BaseMessage ?
+                    lastResponse['message'].content // Just the content, not the full message object
+                    : lastResponse.text || ''
+                : '';
+            // Extract raw output (complete response object for debugging/analysis)
+            const rawOutput = lastResponse ?
+                JSON.stringify({
+                    generation: lastResponse,
+                    llmOutput: output.llmOutput,
+                    fullResponse: output,
+                }, null, 2)
+                : null;
+            this.handleStepEnd({
+                runId,
+                output: extractedOutput,
+                rawOutput,
+                ...(modelName && { modelName }),
+                usageDetails,
+                ...(runId in this.completionStartTimes && { completionStartTime: this.completionStartTimes[runId] }),
+            });
+            if (runId in this.completionStartTimes) {
+                delete this.completionStartTimes[runId];
+            }
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleLLMError(err, runId, parentRunId) {
+        try {
+            console.debug(`LLM error ${err} with ID: ${runId}`);
+            const azureRefusalError = this.parseAzureRefusalError(err);
+            this.handleStepEnd({
+                runId,
+                error: err.toString() + azureRefusalError,
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    // ============================================================================
+    // Chain Handlers
+    // ============================================================================
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+        try {
+            console.debug(`Chain start with ID: ${runId}`);
+            const runName = name ?? chain.id.at(-1)?.toString() ?? 'Langchain Chain';
+            this.registerOpenlayerPrompt(parentRunId, metadata);
+            // Process inputs to handle different formats
+            let finalInput = inputs;
+            if (typeof inputs === 'object' &&
+                'input' in inputs &&
+                Array.isArray(inputs['input']) &&
+                inputs['input'].every((m) => m instanceof BaseMessage)) {
+                finalInput = inputs['input'].map((m) => this.extractChatMessageContent(m));
+            }
+            else if (typeof inputs === 'object' && 'content' in inputs && typeof inputs['content'] === 'string') {
+                finalInput = inputs['content'];
+            }
+            const { step, endStep } = addChainStepToTrace({
+                name: runName,
+                inputs: finalInput,
+                metadata: this.joinTagsAndMetaData(tags, metadata) || {},
+            });
+            this.runMap.set(runId, { step, endStep });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleChainEnd(outputs, runId, parentRunId) {
+        try {
+            console.debug(`Chain end with ID: ${runId}`);
+            let finalOutput = outputs;
+            if (typeof outputs === 'object' && 'output' in outputs && typeof outputs['output'] === 'string') {
+                finalOutput = outputs['output'];
+            }
+            this.handleStepEnd({
+                runId,
+                output: finalOutput,
+            });
+            this.deregisterOpenlayerPrompt(runId);
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleChainError(err, runId, parentRunId) {
+        try {
+            console.debug(`Chain error: ${err} with ID: ${runId}`);
+            const azureRefusalError = this.parseAzureRefusalError(err);
+            this.handleStepEnd({
+                runId,
+                error: err.toString() + azureRefusalError,
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    // ============================================================================
+    // Agent Handlers
+    // ============================================================================
+    async handleAgentAction(action, runId, parentRunId) {
+        try {
+            console.debug(`Agent action ${action.tool} with ID: ${runId}`);
+            const { step, endStep } = addAgentStepToTrace({
+                name: action.tool,
+                inputs: action,
+                tool: action.tool,
+                action: action,
+            });
+            this.runMap.set(runId, { step, endStep });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleAgentEnd(action, runId, parentRunId) {
+        try {
+            console.debug(`Agent finish with ID: ${runId}`);
+            this.handleStepEnd({
+                runId,
+                output: action,
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    // ============================================================================
+    // Tool Handlers
+    // ============================================================================
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+        try {
+            console.debug(`Tool start with ID: ${runId}`);
+            const { step, endStep } = addToolStepToTrace({
+                name: name ?? tool.id.at(-1)?.toString() ?? 'Tool execution',
+                inputs: input,
+                metadata: this.joinTagsAndMetaData(tags, metadata) || {},
+            });
+            this.runMap.set(runId, { step, endStep });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleToolEnd(output, runId, parentRunId) {
+        try {
+            console.debug(`Tool end with ID: ${runId}`);
+            this.handleStepEnd({
+                runId,
+                output: output,
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleToolError(err, runId, parentRunId) {
+        try {
+            console.debug(`Tool error ${err} with ID: ${runId}`);
+            this.handleStepEnd({
+                runId,
+                error: err.toString(),
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    // ============================================================================
+    // Retriever Handlers
+    // ============================================================================
+    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+        try {
+            console.debug(`Retriever start with ID: ${runId}`);
+            const { step, endStep } = addRetrieverStepToTrace({
+                name: name ?? retriever.id.at(-1)?.toString() ?? 'Retriever',
+                inputs: query,
+                metadata: this.joinTagsAndMetaData(tags, metadata) || {},
+            });
+            this.runMap.set(runId, { step, endStep });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleRetrieverEnd(documents, runId, parentRunId) {
+        try {
+            console.debug(`Retriever end with ID: ${runId}`);
+            this.handleStepEnd({
+                runId,
+                output: documents,
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleRetrieverError(err, runId, parentRunId) {
+        try {
+            console.debug(`Retriever error: ${err} with ID: ${runId}`);
+            this.handleStepEnd({
+                runId,
+                error: err.toString(),
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    async handleGenerationStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+        console.debug(`Generation start with ID: ${runId} and parentRunId ${parentRunId}`);
+        const runName = name ?? llm.id?.at?.(-1)?.toString() ?? llm.id?.slice?.(-1)?.[0]?.toString() ?? 'Langchain Generation';
+        // Extract comprehensive model parameters
+        const modelParameters = {};
+        const invocationParams = extraParams?.['invocation_params'];
+        // Standard parameters
+        const standardParams = {
+            temperature: invocationParams?.['temperature'],
+            max_tokens: invocationParams?.['max_tokens'],
+            top_p: invocationParams?.['top_p'],
+            top_k: invocationParams?.['top_k'],
+            frequency_penalty: invocationParams?.['frequency_penalty'],
+            presence_penalty: invocationParams?.['presence_penalty'],
+            request_timeout: invocationParams?.['request_timeout'],
+            stop: invocationParams?.['stop'],
+            seed: invocationParams?.['seed'],
+            response_format: invocationParams?.['response_format'],
+            tools: invocationParams?.['tools'],
+            tool_choice: invocationParams?.['tool_choice'],
+        };
+        for (const [key, value] of Object.entries(standardParams)) {
+            if (value !== undefined && value !== null) {
+                modelParameters[key] = value;
+            }
+        }
+        // Add any additional parameters that weren't in the standard list
+        if (invocationParams && typeof invocationParams === 'object') {
+            for (const [key, value] of Object.entries(invocationParams)) {
+                if (!(key in standardParams) && value !== undefined && value !== null) {
+                    modelParameters[key] = value;
                 }
             }
         }
-        return prompt;
-    }
-    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, runName) {
-        this.initializeRun(extraParams || {}, metadata || {});
-        this.prompt = prompts.map((p) => ({ role: 'user', content: p }));
-        this.startTime = performanceNow();
-    }
-    async handleLLMEnd(output, runId, parentRunId, tags) {
-        this.endTime = performanceNow();
-        this.latency = this.endTime - this.startTime;
-        this.extractTokenInformation(output);
-        this.extractOutput(output);
-        this.addToTrace();
-    }
-    extractTokenInformation(output) {
-        if (this.provider === 'OpenAI') {
-            this.openaiTokenInformation(output);
-        }
-    }
-    openaiTokenInformation(output) {
-        if (output.llmOutput && 'tokenUsage' in output.llmOutput) {
-            this.promptTokens = output.llmOutput?.['tokenUsage']?.promptTokens ?? 0;
-            this.completionTokens = output.llmOutput?.['tokenUsage']?.completionTokens ?? 0;
-            this.totalTokens = output.llmOutput?.['tokenUsage']?.totalTokens ?? 0;
-        }
-    }
-    extractOutput(output) {
-        const lastResponse = output?.generations?.at(-1)?.at(-1) ?? undefined;
-        this.output += lastResponse?.text ?? '';
-    }
-    addToTrace() {
-        let name = 'Chat Completion Model';
-        if (this.provider && this.provider in PROVIDER_TO_STEP_NAME) {
-            name = PROVIDER_TO_STEP_NAME[this.provider] ?? 'Chat Completion Model';
-        }
-        addChatCompletionStepToTrace({
-            name: name,
-            inputs: { prompt: this.prompt },
-            output: this.output,
-            latency: this.latency,
-            tokens: this.totalTokens,
-            promptTokens: this.promptTokens,
-            completionTokens: this.completionTokens,
-            model: this.model,
-            modelParameters: this.modelParameters,
-            metadata: this.metadata,
-            provider: this.provider ?? '',
-            startTime: this.startTime,
-            endTime: this.endTime,
+        let extractedModelName;
+        if (extraParams) {
+            const invocationParamsModelName = extraParams['invocation_params']?.model;
+            const metadataModelName = metadata && 'ls_model_name' in metadata ? metadata['ls_model_name'] : undefined;
+            extractedModelName = invocationParamsModelName ?? metadataModelName;
+        }
+        // Extract provider with multiple fallbacks
+        let provider = metadata?.['ls_provider'];
+        // Fallback provider detection if not in metadata
+        if (!provider) {
+            // Try to detect from model name
+            if (extractedModelName) {
+                if (extractedModelName.includes('gpt') || extractedModelName.includes('openai')) {
+                    provider = 'openai';
+                }
+                else if (extractedModelName.includes('claude')) {
+                    provider = 'anthropic';
+                }
+                else if (extractedModelName.includes('gemini') || extractedModelName.includes('google')) {
+                    provider = 'google';
+                }
+                else if (extractedModelName.includes('llama') || extractedModelName.includes('meta')) {
+                    provider = 'meta';
+                }
+            }
+            // Try to detect from LLM class name
+            if (!provider && llm.id && Array.isArray(llm.id)) {
+                const className = llm.id[0]?.toLowerCase() || '';
+                if (className.includes('openai') || className.includes('chatgpt')) {
+                    provider = 'openai';
+                }
+                else if (className.includes('anthropic') || className.includes('claude')) {
+                    provider = 'anthropic';
+                }
+                else if (className.includes('google') || className.includes('gemini')) {
+                    provider = 'google';
+                }
+            }
+        }
+        const mappedProvider = provider && LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP[provider] ?
+            LANGCHAIN_TO_OPENLAYER_PROVIDER_MAP[provider]
+            : 'Unknown';
+        // Get registered prompt if available
+        const registeredPrompt = this.promptToParentRunMap.get(parentRunId ?? 'root');
+        if (registeredPrompt && parentRunId) {
+            this.deregisterOpenlayerPrompt(parentRunId);
+        }
+        // Create step but don't end it yet - we'll update it in handleLLMEnd
+        const stepName = mappedProvider && PROVIDER_TO_STEP_NAME[mappedProvider] ?
+            PROVIDER_TO_STEP_NAME[mappedProvider]
+            : runName;
+        // For generations, we need to track the start time and other data to use in handleLLMEnd
+        const startTime = performance.now();
+        // Enhanced metadata collection
+        const enhancedMetadata = this.joinTagsAndMetaData(tags, metadata, {
+            // LangChain specific metadata
+            langchain_provider: provider,
+            langchain_model: extractedModelName,
+            langchain_run_id: runId,
+            langchain_parent_run_id: parentRunId,
+            // Invocation details
+            invocation_params: invocationParams,
+            // Timing
+            start_time: new Date().toISOString(),
+            // LLM info
+            llm_class: llm.id ?
+                Array.isArray(llm.id) ?
+                    llm.id.join('.')
+                    : llm.id
+                : 'unknown',
+            // Additional context
+            ...(Object.keys(modelParameters).length > 0 && { model_parameters: modelParameters }),
+            ...(extraParams && { extra_params: extraParams }),
+        });
+        this.runMap.set(runId, {
+            step: {
+                name: stepName,
+                inputs: { prompt: messages },
+                startTime,
+                provider: mappedProvider,
+                model: extractedModelName,
+                modelParameters,
+                metadata: enhancedMetadata,
+                prompt: registeredPrompt,
+            },
+            endStep: () => { }, // Will be replaced in handleLLMEnd
         });
     }
+    handleStepEnd(params) {
+        const { runId, output, rawOutput, error, modelName, usageDetails, completionStartTime } = params;
+        const runData = this.runMap.get(runId);
+        if (!runData) {
+            console.warn('Step not found in runMap. Skipping operation');
+            return;
+        }
+        const { step } = runData;
+        // Handle LLM/Generation steps specially
+        if (step.provider) {
+            const endTime = performance.now();
+            const latency = endTime - step.startTime;
+            addChatCompletionStepToTrace({
+                name: step.name || 'Unknown Generation',
+                inputs: step.inputs || {},
+                output: output || '',
+                latency,
+                tokens: usageDetails?.['total'] || null,
+                promptTokens: usageDetails?.['input'] || null,
+                completionTokens: usageDetails?.['output'] || null,
+                model: modelName || step.model || null,
+                modelParameters: step.modelParameters || null,
+                metadata: error ?
+                    { ...step.metadata, error, rawOutput: rawOutput || null }
+                    : { rawOutput: rawOutput || null, ...step.metadata },
+                provider: step.provider || 'Unknown',
+            });
+        }
+        else {
+            // For other step types, update and end the existing step
+            if (step.log) {
+                step.log({
+                    output: output,
+                    metadata: error ? { ...step.metadata, error } : step.metadata,
+                });
+            }
+            if (runData.endStep) {
+                runData.endStep();
+            }
+        }
+        this.runMap.delete(runId);
+    }
+    registerOpenlayerPrompt(parentRunId, metadata) {
+        if (metadata && 'openlayerPrompt' in metadata && parentRunId) {
+            this.promptToParentRunMap.set(parentRunId, metadata['openlayerPrompt']);
+        }
+    }
+    deregisterOpenlayerPrompt(runId) {
+        this.promptToParentRunMap.delete(runId);
+    }
+    parseAzureRefusalError(err) {
+        let azureRefusalError = '';
+        if (typeof err == 'object' && 'error' in err) {
+            try {
+                azureRefusalError = '\n\nError details:\n' + JSON.stringify(err['error'], null, 2);
+            }
+            catch { }
+        }
+        return azureRefusalError;
+    }
+    joinTagsAndMetaData(tags, metadata1, metadata2) {
+        const finalDict = {};
+        if (tags && tags.length > 0) {
+            finalDict['tags'] = tags;
+        }
+        if (metadata1) {
+            Object.assign(finalDict, metadata1);
+        }
+        if (metadata2) {
+            Object.assign(finalDict, metadata2);
+        }
+        return this.stripOpenlayerKeysFromMetadata(finalDict);
+    }
+    stripOpenlayerKeysFromMetadata(metadata) {
+        if (!metadata) {
+            return;
+        }
+        const openlayerKeys = ['openlayerPrompt', 'openlayerUserId', 'openlayerSessionId'];
+        return Object.fromEntries(Object.entries(metadata).filter(([key, _]) => !openlayerKeys.includes(key)));
+    }
+    extractUsageMetadata(generation) {
+        try {
+            const usageMetadata = ('message' in generation &&
+                (generation['message'] instanceof AIMessage || generation['message'] instanceof AIMessageChunk)) ?
+                generation['message'].usage_metadata
+                : undefined;
+            return usageMetadata;
+        }
+        catch (err) {
+            console.debug(`Error extracting usage metadata: ${err}`);
+            return;
+        }
+    }
+    extractModelNameFromMetadata(generation) {
+        try {
+            return ('message' in generation &&
+                (generation['message'] instanceof AIMessage || generation['message'] instanceof AIMessageChunk)) ?
+                generation['message'].response_metadata?.['model_name']
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    extractChatMessageContent(message) {
+        let response = undefined;
+        if (message instanceof HumanMessage) {
+            response = { content: message.content, role: 'user' };
+        }
+        else if (message instanceof ChatMessage) {
+            response = { content: message.content, role: message.role };
+        }
+        else if (message instanceof AIMessage) {
+            response = { content: message.content, role: 'assistant' };
+            if ('tool_calls' in message && (message.tool_calls?.length ?? 0) > 0) {
+                response['tool_calls'] = message['tool_calls'];
+            }
+        }
+        else if (message instanceof SystemMessage) {
+            response = { content: message.content, role: 'system' };
+        }
+        else if (message instanceof FunctionMessage) {
+            response = {
+                content: message.content,
+                additional_kwargs: message.additional_kwargs,
+                role: message.name,
+            };
+        }
+        else if (message instanceof ToolMessage) {
+            response = {
+                content: message.content,
+                additional_kwargs: message.additional_kwargs,
+                role: message.name,
+            };
+        }
+        else if (!message.name) {
+            response = { content: message.content };
+        }
+        else {
+            response = {
+                role: message.name,
+                content: message.content,
+            };
+        }
+        if (message.additional_kwargs?.function_call || message.additional_kwargs?.tool_calls) {
+            return { ...response, additional_kwargs: message.additional_kwargs };
+        }
+        return response;
+    }
 }
 //# sourceMappingURL=langchainCallback.mjs.map