@traccia2/sdk 0.0.6 → 0.0.8

package/dist/integrations/langchain-callback.js

@@ -1,370 +1,518 @@
 "use strict";
-/**
- * LangChain callback handler for automatic tracing.
- * Integrates with LangChain's callback system to automatically instrument
- * LLM calls, chains, agents, and tools.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TracciaCallbackHandler = void 0;
-const auto_1 = require("../auto");
 const base_1 = require("@langchain/core/callbacks/base");
-/**
- * LangChain Callback Handler for Traccia SDK.
- * Automatically traces LLM calls, chains, agents, and tools.
- *
- * Extends LangChain's BaseCallbackHandler for proper interface compliance.
- * Compatible with LangChain 0.0.x, 0.1.x, 0.2.x, and 1.x versions.
- *
- * @example
- * import { ChatOpenAI } from '@langchain/openai';
- * import { TracciaCallbackHandler } from '@traccia/sdk/integrations';
- *
- * const handler = new TracciaCallbackHandler();
- * const model = new ChatOpenAI({ callbacks: [handler] });
- *
- * const response = await model.invoke({ input: 'Hello!' });
- * // Automatically traced with spans for LLM calls, tokens, latency, etc.
- */
+const messages_1 = require("@langchain/core/messages");
+const auto_1 = require("../auto");
 class TracciaCallbackHandler extends base_1.BaseCallbackHandler {
-    constructor() {
-        super(...arguments);
-        this.name = 'TracciaCallbackHandler';
+    constructor(params) {
+        super();
+        this.name = "TracciaCallbackHandler";
         this.tracer = (0, auto_1.getTracer)('langchain');
-        this.spanStack = new Map();
-        this.streamingStartTimes = {};
+        this.tags = [];
+        this.completionStartTimes = {};
+        this.runMap = new Map();
+        this.last_trace_id = null;
+        this.tags = params?.tags ?? [];
+        this.promptToParentRunMap = new Map();
     }
-    /**
-     * Extract model name from LLM instance, checking multiple property locations.
-     * Different LLM implementations store the model name in different properties.
-     */
-    extractModelName(llm) {
-        // Check common model name properties
-        if (llm.modelName)
-            return llm.modelName; // ChatOpenAI, ChatAnthropic, etc.
-        if (llm.model)
-            return llm.model; // Ollama, etc.
-        if (llm.name && !llm.name.startsWith('langchain'))
-            return llm.name; // Generic name
-        if (llm._modelType)
-            return llm._modelType; // Fallback to type
-        if (llm.client?.model)
-            return llm.client.model; // Nested model property
-        return 'unknown';
-    }
-    /**
-     * Handle LLM start - called when an LLM begins execution.
-     */
-    async handleLLMStart(llm, prompts, runId, _parentRunId) {
-        const modelName = this.extractModelName(llm);
-        const attributes = {
-            type: 'llm',
-            model: modelName,
-            prompt_count: prompts.length,
-            first_prompt_length: prompts[0]?.length || 0,
-        };
-        // Capture temperature if available
-        if (llm.temperature !== undefined) {
-            attributes.temperature = llm.temperature;
-        }
-        // Capture max tokens if available
-        if (llm.maxTokens !== undefined) {
-            attributes.max_tokens = llm.maxTokens;
-        }
-        if (llm.max_tokens !== undefined) {
-            attributes.max_tokens = llm.max_tokens;
-        }
-        // Capture top_p if available
-        if (llm.topP !== undefined) {
-            attributes.top_p = llm.topP;
-        }
-        // Capture top_k if available
-        if (llm.topK !== undefined) {
-            attributes.top_k = llm.topK;
-        }
-        // Capture base URL for local models (Ollama, etc.)
-        if (llm.baseUrl) {
-            attributes.base_url = llm.baseUrl;
-        }
-        const span = this.tracer.startSpan('llm', { attributes });
-        this.spanStack.set(runId, span);
+    async handleLLMNewToken(_token, _idx, runId, _parentRunId, _tags, _fields) {
+        // if this is the first token, add it to completionStartTimes
+        if (runId && !(runId in this.completionStartTimes)) {
+            console.debug(`LLM first streaming token: ${runId}`);
+            this.completionStartTimes[runId] = new Date();
+        }
     }
-    /**
-     * Handle LLM end - called when an LLM finishes execution.
-     */
-    async handleLLMEnd(output, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            try {
-                // Try multiple ways to get token usage
-                // OpenAI format and new @langchain/core format
-                const tokenUsage = output?.llmOutput?.token_usage ||
-                    output?.llmOutput?.tokenUsage ||
-                    output?.token_usage ||
-                    output?.metadata?.token_usage;
-                if (tokenUsage) {
-                    // Handle standard token counts
-                    const promptTokens = tokenUsage.prompt_tokens ?? tokenUsage.promptTokens;
-                    const completionTokens = tokenUsage.completion_tokens ?? tokenUsage.completionTokens;
-                    const totalTokens = tokenUsage.total_tokens ?? tokenUsage.totalTokens;
-                    if (promptTokens !== undefined) {
-                        span.setAttribute('llm.tokens.prompt', promptTokens);
-                    }
-                    if (completionTokens !== undefined) {
-                        span.setAttribute('llm.tokens.completion', completionTokens);
-                    }
-                    if (totalTokens !== undefined) {
-                        span.setAttribute('llm.tokens.total', totalTokens);
-                    }
-                    // Handle detailed token breakdown for models like GPT-4o vision
-                    // input_token_details contains breakdown of prompt token usage
-                    if (tokenUsage.input_token_details && typeof tokenUsage.input_token_details === 'object') {
-                        for (const [key, value] of Object.entries(tokenUsage.input_token_details)) {
-                            if (typeof value === 'number') {
-                                span.setAttribute(`llm.tokens.input_${key}`, value);
-                            }
-                        }
-                    }
-                    // output_token_details contains breakdown of completion token usage
-                    if (tokenUsage.output_token_details && typeof tokenUsage.output_token_details === 'object') {
-                        for (const [key, value] of Object.entries(tokenUsage.output_token_details)) {
-                            if (typeof value === 'number') {
-                                span.setAttribute(`llm.tokens.output_${key}`, value);
-                            }
-                        }
-                    }
-                }
-                // Capture output text length
-                if (output?.text) {
-                    span.setAttribute('output_length', output.text.length);
-                }
-                else if (output?.generations && Array.isArray(output.generations)) {
-                    const firstGeneration = output.generations[0];
-                    if (firstGeneration?.[0]?.text) {
-                        span.setAttribute('output_length', firstGeneration[0].text.length);
-                    }
-                }
-                else if (output?.message?.content) {
-                    // Ollama format (uses message.content)
-                    const content = output.message.content;
-                    const contentStr = typeof content === 'string' ? content : JSON.stringify(content);
-                    span.setAttribute('output_length', contentStr.length);
-                }
-                else if (typeof output === 'string') {
-                    // Direct string output
-                    span.setAttribute('output_length', output.length);
-                }
-                // Capture finish reason if available
-                if (output?.llmOutput?.finish_reason) {
-                    span.setAttribute('finish_reason', output.llmOutput.finish_reason);
-                }
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, _runType, name) {
+        try {
+            console.debug(`Chain start with Id: ${runId}`);
+            this.tags;
+            const runName = name ?? chain.id.at(-1)?.toString() ?? "Langchain Run";
+            this.registerLangfusePrompt(parentRunId, metadata);
+            // In chains, inputs can be a string or an array of BaseMessage
+            let finalInput = inputs;
+            if (typeof inputs === "object" &&
+                "input" in inputs &&
+                Array.isArray(inputs["input"]) &&
+                inputs["input"].every((m) => m instanceof messages_1.BaseMessage)) {
+                finalInput = inputs["input"].map((m) => this.extractChatMessageContent(m));
+            }
+            else if (typeof inputs === "object" &&
+                "messages" in inputs &&
+                Array.isArray(inputs["messages"]) &&
+                inputs["messages"].every((m) => m instanceof messages_1.BaseMessage)) {
+                finalInput = inputs["messages"].map((m) => this.extractChatMessageContent(m));
+            }
+            else if (typeof inputs === "object" &&
+                "content" in inputs &&
+                typeof inputs["content"] === "string") {
+                finalInput = inputs["content"];
             }
-            catch (error) {
-                // Silently fail on attribute setting
+            this.startAndRegisterSpan({
+                runName,
+                parentRunId,
+                runId,
+                tags,
+                metadata,
+                attributes: {
+                    input: finalInput,
+                },
+            });
+            if (!parentRunId) {
+                // Here we would update the trace, but traccia sdk doesn't support it yet
             }
-            span.end();
-            this.spanStack.delete(runId);
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    /**
-     * Handle LLM error.
-     */
-    async handleLLMError(error, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            span.recordException(error, { source: 'langchain-llm' });
-            span.end();
-            this.spanStack.delete(runId);
+    async handleAgentAction(action, runId, parentRunId) {
+        try {
+            console.debug(`Agent action ${action.tool} with ID: ${runId}`);
+            this.startAndRegisterSpan({
+                runId,
+                parentRunId,
+                runName: action.tool,
+                attributes: {
+                    input: action,
+                },
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    /**
-     * Handle LLM new token - called when a new token is generated during streaming.
-     * Tracks first token latency and token count for streaming scenarios.
-     */
-    async handleLLMNewToken(_token, _idx, runId) {
-        if (runId && !(runId in this.streamingStartTimes)) {
-            // Record the time of the first streaming token
-            this.streamingStartTimes[runId] = new Date();
-            const span = this.spanStack.get(runId);
-            if (span) {
-                try {
-                    span.setAttribute('stream.first_token_generated', true);
-                }
-                catch (error) {
-                    // Silently fail
-                }
+    async handleAgentEnd(action, runId, _parentRunId) {
+        try {
+            console.debug(`Agent finish with ID: ${runId}`);
+            this.handleSpanEnd({
+                runId,
+                attributes: { output: action },
+            });
+        }
+        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.handleSpanEnd({
+                runId,
+                attributes: {
+                    level: "ERROR",
+                    statusMessage: err.toString() + azureRefusalError,
+                },
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    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() ?? "Langchain Generation";
+        const modelParameters = {};
+        const invocationParams = extraParams?.["invocation_params"];
+        for (const [key, value] of Object.entries({
+            temperature: invocationParams?.temperature,
+            max_tokens: invocationParams?.max_tokens,
+            top_p: invocationParams?.top_p,
+            frequency_penalty: invocationParams?.frequency_penalty,
+            presence_penalty: invocationParams?.presence_penalty,
+            request_timeout: invocationParams?.request_timeout,
+        })) {
+            if (value !== undefined && value !== null) {
+                modelParameters[key] = value;
             }
         }
+        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;
+        }
+        const registeredPrompt = this.promptToParentRunMap.get(parentRunId ?? "root");
+        if (registeredPrompt && parentRunId) {
+            this.deregisterLangfusePrompt(parentRunId);
+        }
+        this.startAndRegisterSpan({
+            runId,
+            parentRunId,
+            metadata,
+            tags,
+            runName,
+            attributes: {
+                input: messages,
+                model: extractedModelName,
+                modelParameters: modelParameters,
+                prompt: registeredPrompt,
+            },
+        });
     }
-    /**
-     * Handle chain start - called when a chain begins execution.
-     */
-    async handleChainStart(chain, inputs, runId, _parentRunId) {
-        const chainName = chain.name || chain._chainType || 'chain';
-        const attributes = {
-            type: 'chain',
-            chain_name: chainName,
-            chain_type: chain._chainType,
-            input_keys: Object.keys(inputs || {}).join(','),
-            input_count: Object.keys(inputs || {}).length,
-        };
-        // Capture total input length
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
         try {
-            const inputStr = JSON.stringify(inputs);
-            attributes.input_length = inputStr.length;
+            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 (error) {
-            // Silently fail
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
-        const span = this.tracer.startSpan(`chain:${chainName}`, { attributes });
-        this.spanStack.set(runId, span);
     }
-    /**
-     * Handle chain end - called when a chain finishes execution.
-     */
-    async handleChainEnd(output, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            try {
-                if (output) {
-                    const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
-                    span.setAttribute('output_length', outputStr.length);
-                }
+    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"];
             }
-            catch (error) {
-                // Silently fail
+            else if (typeof outputs === "object" &&
+                "messages" in outputs &&
+                Array.isArray(outputs["messages"]) &&
+                outputs["messages"].every((m) => m instanceof messages_1.BaseMessage)) {
+                finalOutput = {
+                    messages: outputs.messages.map((message) => this.extractChatMessageContent(message)),
+                };
             }
-            span.end();
-            this.spanStack.delete(runId);
+            this.handleSpanEnd({
+                runId,
+                attributes: {
+                    output: finalOutput,
+                },
+            });
+            this.deregisterLangfusePrompt(runId);
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    /**
-     * Handle chain error.
-     */
-    async handleChainError(error, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            span.recordException(error, { source: 'langchain-chain' });
-            span.end();
-            this.spanStack.delete(runId);
+    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));
         }
     }
-    /**
-     * Handle tool start - called when a tool is invoked.
-     */
-    async handleToolStart(tool, input, runId, _parentRunId) {
-        const toolName = tool.name || 'unknown-tool';
-        const attributes = {
-            type: 'tool',
-            tool_name: toolName,
-            tool_description: tool.description || '',
-            input_length: typeof input === 'string' ? input.length : (typeof input === 'object' ? JSON.stringify(input).length : 0),
-        };
-        // Try to capture structured input
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
         try {
-            if (typeof input === 'object') {
-                attributes.input_keys = Object.keys(input).join(',');
-            }
+            console.debug(`Tool start with ID: ${runId}`);
+            this.startAndRegisterSpan({
+                runId,
+                parentRunId,
+                runName: name ?? tool.id.at(-1)?.toString() ?? "Tool execution",
+                attributes: {
+                    input,
+                },
+                metadata,
+                tags,
+            });
         }
-        catch (error) {
-            // Silently fail
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
-        const span = this.tracer.startSpan(`tool:${toolName}`, { attributes });
-        this.spanStack.set(runId, span);
     }
-    /**
-     * Handle tool end - called when a tool finishes execution.
-     */
-    async handleToolEnd(output, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            try {
-                span.setAttribute('output_length', output?.length || 0);
-            }
-            catch (error) {
-                // Silently fail
-            }
-            span.end();
-            this.spanStack.delete(runId);
+    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+        try {
+            console.debug(`Retriever start with ID: ${runId}`);
+            this.startAndRegisterSpan({
+                runId,
+                parentRunId,
+                runName: name ?? retriever.id.at(-1)?.toString() ?? "Retriever",
+                attributes: {
+                    input: query,
+                },
+                tags,
+                metadata,
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    /**
-     * Handle tool error.
-     */
-    async handleToolError(error, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            span.recordException(error, { source: 'langchain-tool' });
-            span.end();
-            this.spanStack.delete(runId);
+    async handleRetrieverEnd(documents, runId, _parentRunId) {
+        try {
+            console.debug(`Retriever end with ID: ${runId}`);
+            this.handleSpanEnd({
+                runId,
+                attributes: {
+                    output: documents,
+                },
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    /**
-     * Handle agent action.
-     */
-    async handleAgentAction(action, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            try {
-                span.setAttribute('agent_action', action.tool);
-            }
-            catch (error) {
-                // Silently fail
-            }
+    async handleRetrieverError(err, runId, _parentRunId) {
+        try {
+            console.debug(`Retriever error: ${err} with ID: ${runId}`);
+            this.handleSpanEnd({
+                runId,
+                attributes: {
+                    level: "ERROR",
+                    statusMessage: err.toString(),
+                },
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    /**
-     * Handle agent finish.
-     */
-    async handleAgentFinish(finish, runId) {
-        const span = this.spanStack.get(runId);
-        if (span) {
-            try {
-                span.setAttribute('agent_finish_output', JSON.stringify(finish.returnValues));
+    async handleToolEnd(output, runId, _parentRunId) {
+        try {
+            console.debug(`Tool end with ID: ${runId}`);
+            this.handleSpanEnd({
+                runId,
+                attributes: { 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.handleSpanEnd({
+                runId,
+                attributes: {
+                    level: "ERROR",
+                    statusMessage: err.toString(),
+                },
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
+    }
+    async handleLLMEnd(output, runId, _parentRunId) {
+        try {
+            console.debug(`LLM end with ID: ${runId}`);
+            const lastResponse = output.generations[output.generations.length - 1][output.generations[output.generations.length - 1].length - 1];
+            const llmUsage = this.extractUsageMetadata(lastResponse) ??
+                output.llmOutput?.["tokenUsage"];
+            const modelName = this.extractModelNameFromMetadata(lastResponse);
+            const usageDetails = {
+                input: llmUsage?.input_tokens ??
+                    ("promptTokens" in llmUsage ? llmUsage?.promptTokens : undefined),
+                output: llmUsage?.output_tokens ??
+                    ("completionTokens" in llmUsage
+                        ? llmUsage?.completionTokens
+                        : undefined),
+                total: llmUsage?.total_tokens ??
+                    ("totalTokens" in llmUsage ? llmUsage?.totalTokens : undefined),
+            };
+            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);
+                    }
+                }
             }
-            catch (error) {
-                // Silently fail
+            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);
+                    }
+                }
+            }
+            const extractedOutput = "message" in lastResponse
+                ? this.extractChatMessageContent(lastResponse["message"])
+                : lastResponse.text;
+            this.handleSpanEnd({
+                runId,
+                attributes: {
+                    model: modelName,
+                    output: extractedOutput,
+                    completionStartTime: runId in this.completionStartTimes
+                        ? this.completionStartTimes[runId]
+                        : undefined,
+                    usageDetails: usageDetails,
+                },
+            });
+            if (runId in this.completionStartTimes) {
+                delete this.completionStartTimes[runId];
             }
-            span.end();
-            this.spanStack.delete(runId);
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
         }
     }
-    // LangChain uses 'on*' prefix for callback methods
-    // Provide aliases for compatibility
-    async onLLMStart(llm, prompts, runId, parentRunId) {
-        return this.handleLLMStart(llm, prompts, runId, parentRunId);
-    }
-    async onLLMEnd(output, runId) {
-        return this.handleLLMEnd(output, runId);
+    async handleLLMError(err, runId, _parentRunId) {
+        try {
+            console.debug(`LLM error ${err} with ID: ${runId}`);
+            const azureRefusalError = this.parseAzureRefusalError(err);
+            this.handleSpanEnd({
+                runId,
+                attributes: {
+                    level: "ERROR",
+                    statusMessage: err.toString() + azureRefusalError,
+                },
+            });
+        }
+        catch (e) {
+            console.debug(e instanceof Error ? e.message : String(e));
+        }
     }
-    async onLLMError(error, runId) {
-        return this.handleLLMError(error, runId);
+    registerLangfusePrompt(parentRunId, metadata) {
+        if (metadata && "langfusePrompt" in metadata && parentRunId) {
+            this.promptToParentRunMap.set(parentRunId, metadata.langfusePrompt);
+        }
     }
-    async onLLMNewToken(_token, idx, runId) {
-        return this.handleLLMNewToken(_token, idx, runId);
+    deregisterLangfusePrompt(runId) {
+        this.promptToParentRunMap.delete(runId);
     }
-    async onChainStart(chain, inputs, runId, parentRunId) {
-        return this.handleChainStart(chain, inputs, runId, parentRunId);
+    startAndRegisterSpan(params) {
+        const { runName, runId, attributes, metadata, tags } = params;
+        const span = this.tracer.startSpan(runName, {
+            attributes: {
+                ...attributes,
+                ...this.joinTagsAndMetaData(tags, metadata)
+            }
+        });
+        this.runMap.set(runId, span);
+        return span;
     }
-    async onChainEnd(output, runId) {
-        return this.handleChainEnd(output, runId);
+    handleSpanEnd(params) {
+        const { runId, attributes = {} } = params;
+        const span = this.runMap.get(runId);
+        if (!span) {
+            console.warn("Span not found in runMap. Skipping operation");
+            return;
+        }
+        for (const [key, value] of Object.entries(attributes)) {
+            span.setAttribute(key, value);
+        }
+        span.end();
+        this.runMap.delete(runId);
     }
-    async onChainError(error, runId) {
-        return this.handleChainError(error, 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;
     }
-    async onToolStart(tool, input, runId, parentRunId) {
-        return this.handleToolStart(tool, input, runId, parentRunId);
+    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.stripLangfuseKeysFromMetadata(finalDict);
     }
-    async onToolEnd(output, runId) {
-        return this.handleToolEnd(output, runId);
+    stripLangfuseKeysFromMetadata(metadata) {
+        if (!metadata) {
+            return;
+        }
+        const langfuseKeys = [
+            "langfusePrompt",
+            "langfuseUserId",
+            "langfuseSessionId",
+        ];
+        return Object.fromEntries(Object.entries(metadata).filter(([key, _]) => !langfuseKeys.includes(key)));
     }
-    async onToolError(error, runId) {
-        return this.handleToolError(error, runId);
+    extractUsageMetadata(generation) {
+        try {
+            const usageMetadata = "message" in generation &&
+                (generation["message"] instanceof messages_1.AIMessage ||
+                    generation["message"] instanceof messages_1.AIMessageChunk)
+                ? generation["message"].usage_metadata
+                : undefined;
+            return usageMetadata;
+        }
+        catch (err) {
+            console.debug(`Error extracting usage metadata: ${err}`);
+            return;
+        }
     }
-    async onAgentAction(action, runId) {
-        return this.handleAgentAction(action, runId);
+    extractModelNameFromMetadata(generation) {
+        try {
+            return "message" in generation &&
+                (generation["message"] instanceof messages_1.AIMessage ||
+                    generation["message"] instanceof messages_1.AIMessageChunk)
+                ? generation["message"].response_metadata.model_name
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
     }
-    async onAgentFinish(finish, runId) {
-        return this.handleAgentFinish(finish, runId);
+    extractChatMessageContent(message) {
+        let response = undefined;
+        if (message.getType() === "human") {
+            response = { content: message.content, role: "user" };
+        }
+        else if (message.getType() === "generic") {
+            response = {
+                content: message.content,
+                role: "human",
+            };
+        }
+        else if (message.getType() === "ai") {
+            response = { content: message.content, role: "assistant" };
+            if ("tool_calls" in message &&
+                Array.isArray(message.tool_calls) &&
+                (message.tool_calls?.length ?? 0) > 0) {
+                response[`tool_calls`] = message[`tool_calls`];
+            }
+            if ("additional_kwargs" in message &&
+                "tool_calls" in message["additional_kwargs"]) {
+                response[`tool_calls`] =
+                    message["additional_kwargs"]["tool_calls"];
+            }
+        }
+        else if (message.getType() === "system") {
+            response = { content: message.content, role: "system" };
+        }
+        else if (message.getType() === "function") {
+            response = {
+                content: message.content,
+                additional_kwargs: message.additional_kwargs,
+                role: message.name,
+            };
+        }
+        else if (message.getType() === "tool") {
+            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) &&
+            response[`tool_calls`] === undefined) {
+            return { ...response, additional_kwargs: message.additional_kwargs };
+        }
+        return response;
     }
 }
 exports.TracciaCallbackHandler = TracciaCallbackHandler;