@vfarcic/dot-ai 0.124.0 → 0.126.0

package/dist/core/providers/anthropic-provider.js

@@ -13,6 +13,8 @@ exports.AnthropicProvider = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const provider_debug_utils_1 = require("./provider-debug-utils");
 const model_config_1 = require("../model-config");
+const ai_tracing_1 = require("../tracing/ai-tracing");
+const api_1 = require("@opentelemetry/api");
 class AnthropicProvider {
     client;
     apiKey;
@@ -21,14 +23,14 @@ class AnthropicProvider {
     constructor(config) {
         this.apiKey = config.apiKey;
         this.model = config.model || this.getDefaultModel();
-        this.debugMode = config.debugMode ?? (process.env.DEBUG_DOT_AI === 'true');
+        this.debugMode = config.debugMode ?? process.env.DEBUG_DOT_AI === 'true';
         this.validateApiKey();
         this.client = new sdk_1.default({
             apiKey: this.apiKey,
             // Enable 1M token context window for Claude Sonnet 4 (5x increase from 200K)
             defaultHeaders: {
-                'anthropic-beta': 'context-1m-2025-08-07'
-            }
+                'anthropic-beta': 'context-1m-2025-08-07',
+            },
         });
     }
     validateApiKey() {
@@ -65,76 +67,87 @@ class AnthropicProvider {
         // Return the actual debug file names created
         return {
             promptFile: `${debugId}_prompt.md`,
-            responseFile: `${debugId}_response.md`
+            responseFile: `${debugId}_response.md`,
         };
     }
     async sendMessage(message, operation = 'generic', evaluationContext) {
         if (!this.client) {
             throw new Error('Anthropic client not initialized');
         }
-        const startTime = Date.now();
-        try {
-            // Make real API call to Anthropic with streaming
-            const stream = await this.client.messages.create({
-                model: this.model,
-                max_tokens: 64000,
-                messages: [{ role: 'user', content: message }],
-                stream: true // Enable streaming by default to support long operations (>10 minutes)
-            });
-            let content = '';
-            let input_tokens = 0;
-            let output_tokens = 0;
-            for await (const chunk of stream) {
-                if (chunk.type === 'message_start') {
-                    input_tokens = chunk.message.usage.input_tokens;
-                }
-                else if (chunk.type === 'content_block_delta') {
-                    if (chunk.delta.type === 'text_delta') {
-                        content += chunk.delta.text;
+        return await (0, ai_tracing_1.withAITracing)({
+            provider: 'anthropic',
+            model: this.model,
+            operation: 'chat',
+        }, async () => {
+            const startTime = Date.now();
+            try {
+                // Make real API call to Anthropic with streaming
+                const stream = await this.client.messages.create({
+                    model: this.model,
+                    max_tokens: 64000,
+                    messages: [{ role: 'user', content: message }],
+                    stream: true, // Enable streaming by default to support long operations (>10 minutes)
+                });
+                let content = '';
+                let input_tokens = 0;
+                let output_tokens = 0;
+                for await (const chunk of stream) {
+                    if (chunk.type === 'message_start') {
+                        input_tokens = chunk.message.usage.input_tokens;
+                    }
+                    else if (chunk.type === 'content_block_delta') {
+                        if (chunk.delta.type === 'text_delta') {
+                            content += chunk.delta.text;
+                        }
+                    }
+                    else if (chunk.type === 'message_delta') {
+                        output_tokens = chunk.usage.output_tokens;
                     }
                 }
-                else if (chunk.type === 'message_delta') {
-                    output_tokens = chunk.usage.output_tokens;
+                const response = {
+                    content,
+                    usage: {
+                        input_tokens,
+                        output_tokens,
+                    },
+                };
+                // Debug log the interaction if enabled
+                this.logDebugIfEnabled(operation, message, response);
+                // PRD #154: Log evaluation dataset if evaluation context is provided
+                if (this.debugMode && evaluationContext?.interaction_id) {
+                    const durationMs = Date.now() - startTime;
+                    const evaluationMetrics = {
+                        // Core execution data
+                        operation,
+                        sdk: this.getProviderType(),
+                        inputTokens: input_tokens,
+                        outputTokens: output_tokens,
+                        durationMs,
+                        // Required fields
+                        iterationCount: 1,
+                        toolCallCount: 0,
+                        status: 'completed',
+                        completionReason: 'stop',
+                        modelVersion: this.model,
+                        // Required evaluation context - NO DEFAULTS, must be provided
+                        test_scenario: operation,
+                        ai_response_summary: content,
+                        user_intent: evaluationContext?.user_intent || '',
+                        interaction_id: evaluationContext?.interaction_id || '',
+                    };
+                    (0, provider_debug_utils_1.logEvaluationDataset)(evaluationMetrics, this.debugMode);
                 }
+                return response;
             }
-            const response = {
-                content,
-                usage: {
-                    input_tokens,
-                    output_tokens
-                }
-            };
-            // Debug log the interaction if enabled
-            this.logDebugIfEnabled(operation, message, response);
-            // PRD #154: Log evaluation dataset if evaluation context is provided
-            if (this.debugMode && evaluationContext?.interaction_id) {
-                const durationMs = Date.now() - startTime;
-                const evaluationMetrics = {
-                    // Core execution data
-                    operation,
-                    sdk: this.getProviderType(),
-                    inputTokens: input_tokens,
-                    outputTokens: output_tokens,
-                    durationMs,
-                    // Required fields
-                    iterationCount: 1,
-                    toolCallCount: 0,
-                    status: 'completed',
-                    completionReason: 'stop',
-                    modelVersion: this.model,
-                    // Required evaluation context - NO DEFAULTS, must be provided
-                    test_scenario: operation,
-                    ai_response_summary: content,
-                    user_intent: evaluationContext?.user_intent || '',
-                    interaction_id: evaluationContext?.interaction_id || '',
-                };
-                (0, provider_debug_utils_1.logEvaluationDataset)(evaluationMetrics, this.debugMode);
+            catch (error) {
+                throw new Error(`Anthropic API error: ${error}`);
             }
-            return response;
-        }
-        catch (error) {
-            throw new Error(`Anthropic API error: ${error}`);
-        }
+        }, (response) => ({
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            cacheReadTokens: response.usage.cache_read_input_tokens,
+            cacheCreationTokens: response.usage.cache_creation_input_tokens,
+        }));
     }
     /**
      * Agentic tool loop implementation
@@ -160,237 +173,294 @@ class AnthropicProvider {
         if (!this.client) {
             throw new Error('Anthropic client not initialized');
         }
-        const startTime = Date.now();
-        // Convert AITool[] to Anthropic Tool format with caching on last tool
-        const tools = config.tools.map((t, index) => {
-            const tool = {
-                name: t.name,
-                description: t.description,
-                input_schema: t.inputSchema
+        return await (0, ai_tracing_1.withAITracing)({
+            provider: 'anthropic',
+            model: this.model,
+            operation: 'tool_loop',
+        }, async () => {
+            const startTime = Date.now();
+            // Convert AITool[] to Anthropic Tool format with caching on last tool
+            const tools = config.tools.map((t, index) => {
+                const tool = {
+                    name: t.name,
+                    description: t.description,
+                    input_schema: t.inputSchema,
+                };
+                // Add cache control to the last tool to cache the entire tools array
+                if (index === config.tools.length - 1) {
+                    tool.cache_control = { type: 'ephemeral' };
+                }
+                return tool;
+            });
+            // Separate system prompt with caching from user message
+            const systemPrompt = [
+                {
+                    type: 'text',
+                    text: config.systemPrompt,
+                    cache_control: { type: 'ephemeral' },
+                },
+            ];
+            // Initialize conversation history with just the user message
+            const conversationHistory = [
+                {
+                    role: 'user',
+                    content: config.userMessage,
+                },
+            ];
+            let iterations = 0;
+            const toolCallsExecuted = [];
+            const totalTokens = {
+                input: 0,
+                output: 0,
+                cacheCreation: 0,
+                cacheRead: 0,
             };
-            // Add cache control to the last tool to cache the entire tools array
-            if (index === config.tools.length - 1) {
-                tool.cache_control = { type: 'ephemeral' };
-            }
-            return tool;
-        });
-        // Separate system prompt with caching from user message
-        const systemPrompt = [
-            {
-                type: 'text',
-                text: config.systemPrompt,
-                cache_control: { type: 'ephemeral' }
-            }
-        ];
-        // Initialize conversation history with just the user message
-        const conversationHistory = [
-            {
-                role: 'user',
-                content: config.userMessage
-            }
-        ];
-        let iterations = 0;
-        const toolCallsExecuted = [];
-        const totalTokens = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
-        const maxIterations = config.maxIterations || 20;
-        const operation = config.operation || 'tool-loop';
-        try {
-            while (iterations < maxIterations) {
-                iterations++;
-                // Build current prompt for debug logging
-                const currentPrompt = `System: ${config.systemPrompt}\n\n${conversationHistory.map(msg => {
-                    let content = '';
-                    if (typeof msg.content === 'string') {
-                        content = msg.content;
-                    }
-                    else if (Array.isArray(msg.content)) {
-                        // Extract text from content blocks
-                        content = msg.content.map(block => {
-                            if (block.type === 'text') {
-                                return block.text;
+            const maxIterations = config.maxIterations || 20;
+            const operation = config.operation || 'tool-loop';
+            try {
+                const tracer = api_1.trace.getTracer('dot-ai-mcp');
+                while (iterations < maxIterations) {
+                    iterations++;
+                    // Wrap entire iteration in a span
+                    // Returns result if investigation complete, null to continue
+                    const iterationResult = await tracer.startActiveSpan('tool_loop_iteration', { kind: api_1.SpanKind.INTERNAL }, async (span) => {
+                        try {
+                            // Build current prompt for debug logging
+                            const currentPrompt = `System: ${config.systemPrompt}\n\n${conversationHistory
+                                .map(msg => {
+                                let content = '';
+                                if (typeof msg.content === 'string') {
+                                    content = msg.content;
+                                }
+                                else if (Array.isArray(msg.content)) {
+                                    // Extract text from content blocks
+                                    content = msg.content
+                                        .map(block => {
+                                        if (block.type === 'text') {
+                                            return block.text;
+                                        }
+                                        else if (block.type === 'tool_use') {
+                                            return `[TOOL_USE: ${block.name}]`;
+                                        }
+                                        else if (block.type === 'tool_result') {
+                                            const content = block.content;
+                                            if (typeof content === 'string') {
+                                                return `[TOOL_RESULT: ${block.tool_use_id}]\n${content}`;
+                                            }
+                                            else if (Array.isArray(content)) {
+                                                const textContent = content
+                                                    .map(c => c.type === 'text' ? c.text : `[${c.type}]`)
+                                                    .join(' ');
+                                                return `[TOOL_RESULT: ${block.tool_use_id}]\n${textContent}`;
+                                            }
+                                            return `[TOOL_RESULT: ${block.tool_use_id}]`;
+                                        }
+                                        return `[${block.type}]`;
+                                    })
+                                        .join(' ');
+                                }
+                                else {
+                                    content = '[complex_content]';
+                                }
+                                return `${msg.role}: ${content}`;
+                            })
+                                .join('\n\n')}`;
+                            // Call Anthropic API with tools and cached system prompt
+                            const response = await this.client.messages.create({
+                                model: this.model,
+                                max_tokens: 4096,
+                                system: systemPrompt,
+                                messages: conversationHistory,
+                                tools: tools,
+                            });
+                            // Track token usage including cache metrics
+                            totalTokens.input += response.usage.input_tokens;
+                            totalTokens.output += response.usage.output_tokens;
+                            // Track cache usage (available when prompt caching is used)
+                            if ('cache_creation_input_tokens' in response.usage) {
+                                totalTokens.cacheCreation +=
+                                    response.usage.cache_creation_input_tokens || 0;
+                            }
+                            if ('cache_read_input_tokens' in response.usage) {
+                                totalTokens.cacheRead +=
+                                    response.usage.cache_read_input_tokens || 0;
+                            }
+                            // Check if AI wants to use tools
+                            const toolUses = response.content.filter((c) => c.type === 'tool_use');
+                            // Log debug for final iteration to capture complete prompts/responses for evaluation
+                            let debugFiles = null;
+                            if (toolUses.length === 0) {
+                                const aiResponse = {
+                                    content: response.content
+                                        .filter((c) => c.type === 'text')
+                                        .map(c => c.text)
+                                        .join('\n\n'),
+                                    usage: {
+                                        input_tokens: response.usage.input_tokens,
+                                        output_tokens: response.usage.output_tokens,
+                                        cache_creation_input_tokens: response.usage
+                                            .cache_creation_input_tokens,
+                                        cache_read_input_tokens: response.usage
+                                            .cache_read_input_tokens,
+                                    },
+                                };
+                                debugFiles = this.logDebugIfEnabled(`${config.operation}-summary`, currentPrompt, aiResponse);
                             }
-                            else if (block.type === 'tool_use') {
-                                return `[TOOL_USE: ${block.name}]`;
+                            // If AI is done (no more tools to call), return the result
+                            if (toolUses.length === 0) {
+                                // AI is done - extract final text message
+                                const textContent = response.content.find((c) => c.type === 'text');
+                                // Return result from span callback
+                                return (0, provider_debug_utils_1.createAndLogAgenticResult)({
+                                    finalMessage: textContent?.text || '',
+                                    iterations,
+                                    toolCallsExecuted,
+                                    totalTokens: {
+                                        input: totalTokens.input,
+                                        output: totalTokens.output,
+                                        cacheCreation: totalTokens.cacheCreation,
+                                        cacheRead: totalTokens.cacheRead,
+                                    },
+                                    status: 'success',
+                                    completionReason: 'investigation_complete',
+                                    modelVersion: this.model,
+                                    operation: `${operation}-summary`,
+                                    sdk: this.getProviderType(),
+                                    startTime,
+                                    debugMode: this.debugMode,
+                                    debugFiles,
+                                    evaluationContext: config.evaluationContext,
+                                    interaction_id: config.interaction_id,
+                                });
                             }
-                            else if (block.type === 'tool_result') {
-                                const content = block.content;
-                                if (typeof content === 'string') {
-                                    return `[TOOL_RESULT: ${block.tool_use_id}]\n${content}`;
+                            // Execute all requested tools in parallel
+                            const toolResults = [];
+                            // Create promises for parallel execution
+                            const toolExecutionPromises = toolUses.map(async (toolUse) => {
+                                try {
+                                    const result = await config.toolExecutor(toolUse.name, toolUse.input);
+                                    return {
+                                        success: true,
+                                        toolUse,
+                                        result,
+                                    };
                                 }
-                                else if (Array.isArray(content)) {
-                                    const textContent = content.map(c => c.type === 'text' ? c.text : `[${c.type}]`).join(' ');
-                                    return `[TOOL_RESULT: ${block.tool_use_id}]\n${textContent}`;
+                                catch (error) {
+                                    return {
+                                        success: false,
+                                        toolUse,
+                                        error: error instanceof Error
+                                            ? error.message
+                                            : String(error),
+                                    };
+                                }
+                            });
+                            // Execute all tools simultaneously
+                            const executionResults = await Promise.all(toolExecutionPromises);
+                            // Process results and build tool_result blocks
+                            for (const executionResult of executionResults) {
+                                if (executionResult.success) {
+                                    toolCallsExecuted.push({
+                                        tool: executionResult.toolUse.name,
+                                        input: executionResult.toolUse.input,
+                                        output: executionResult.result,
+                                    });
+                                    toolResults.push({
+                                        type: 'tool_result',
+                                        tool_use_id: executionResult.toolUse.id,
+                                        content: JSON.stringify(executionResult.result),
+                                    });
+                                }
+                                else {
+                                    // Feed error back to AI as tool result
+                                    toolResults.push({
+                                        type: 'tool_result',
+                                        tool_use_id: executionResult.toolUse.id,
+                                        content: JSON.stringify({
+                                            error: executionResult.error,
+                                        }),
+                                        is_error: true,
+                                    });
                                 }
-                                return `[TOOL_RESULT: ${block.tool_use_id}]`;
                             }
-                            return `[${block.type}]`;
-                        }).join(' ');
-                    }
-                    else {
-                        content = '[complex_content]';
-                    }
-                    return `${msg.role}: ${content}`;
-                }).join('\n\n')}`;
-                // Call Anthropic API with tools and cached system prompt
-                const response = await this.client.messages.create({
-                    model: this.model,
-                    max_tokens: 4096,
-                    system: systemPrompt,
-                    messages: conversationHistory,
-                    tools: tools
-                });
-                // Track token usage including cache metrics
-                totalTokens.input += response.usage.input_tokens;
-                totalTokens.output += response.usage.output_tokens;
-                // Track cache usage (available when prompt caching is used)
-                if ('cache_creation_input_tokens' in response.usage) {
-                    totalTokens.cacheCreation += response.usage.cache_creation_input_tokens || 0;
-                }
-                if ('cache_read_input_tokens' in response.usage) {
-                    totalTokens.cacheRead += response.usage.cache_read_input_tokens || 0;
-                }
-                // Check if AI wants to use tools
-                const toolUses = response.content.filter((c) => c.type === 'tool_use');
-                // Log debug for final iteration to capture complete prompts/responses for evaluation
-                let debugFiles = null;
-                if (toolUses.length === 0) {
-                    const aiResponse = {
-                        content: response.content
-                            .filter((c) => c.type === 'text')
-                            .map(c => c.text)
-                            .join('\n\n'),
-                        usage: {
-                            input_tokens: response.usage.input_tokens,
-                            output_tokens: response.usage.output_tokens,
-                            cache_creation_input_tokens: response.usage.cache_creation_input_tokens,
-                            cache_read_input_tokens: response.usage.cache_read_input_tokens
+                            // Add AI response and tool results to conversation history
+                            conversationHistory.push({ role: 'assistant', content: response.content }, { role: 'user', content: toolResults });
+                            // Invoke iteration callback if provided
+                            if (config.onIteration) {
+                                config.onIteration(iterations, toolCallsExecuted);
+                            }
+                            span.setStatus({ code: api_1.SpanStatusCode.OK });
+                            // Return null to continue the loop
+                            return null;
+                        }
+                        catch (error) {
+                            span.recordException(error);
+                            span.setStatus({
+                                code: api_1.SpanStatusCode.ERROR,
+                                message: error instanceof Error ? error.message : String(error),
+                            });
+                            throw error;
+                        }
+                        finally {
+                            span.end();
                         }
-                    };
-                    debugFiles = this.logDebugIfEnabled(`${config.operation}-summary`, currentPrompt, aiResponse);
-                }
-                if (toolUses.length === 0) {
-                    // AI is done - extract final text message
-                    const textContent = response.content.find((c) => c.type === 'text');
-                    return (0, provider_debug_utils_1.createAndLogAgenticResult)({
-                        finalMessage: textContent?.text || '',
-                        iterations,
-                        toolCallsExecuted,
-                        totalTokens: {
-                            input: totalTokens.input,
-                            output: totalTokens.output,
-                            cacheCreation: totalTokens.cacheCreation,
-                            cacheRead: totalTokens.cacheRead
-                        },
-                        status: 'success',
-                        completionReason: 'investigation_complete',
-                        modelVersion: this.model,
-                        operation: `${operation}-summary`,
-                        sdk: this.getProviderType(),
-                        startTime,
-                        debugMode: this.debugMode,
-                        debugFiles,
-                        evaluationContext: config.evaluationContext,
-                        interaction_id: config.interaction_id
                     });
-                }
-                // Execute all requested tools in parallel
-                const toolResults = [];
-                // Create promises for parallel execution
-                const toolExecutionPromises = toolUses.map(async (toolUse) => {
-                    try {
-                        const result = await config.toolExecutor(toolUse.name, toolUse.input);
-                        return {
-                            success: true,
-                            toolUse,
-                            result
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            success: false,
-                            toolUse,
-                            error: error instanceof Error ? error.message : String(error)
-                        };
-                    }
-                });
-                // Execute all tools simultaneously
-                const executionResults = await Promise.all(toolExecutionPromises);
-                // Process results and build tool_result blocks
-                for (const executionResult of executionResults) {
-                    if (executionResult.success) {
-                        toolCallsExecuted.push({
-                            tool: executionResult.toolUse.name,
-                            input: executionResult.toolUse.input,
-                            output: executionResult.result
-                        });
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: executionResult.toolUse.id,
-                            content: JSON.stringify(executionResult.result)
-                        });
-                    }
-                    else {
-                        // Feed error back to AI as tool result
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: executionResult.toolUse.id,
-                            content: JSON.stringify({ error: executionResult.error }),
-                            is_error: true
-                        });
+                    // If iteration returned a result, investigation is complete
+                    if (iterationResult) {
+                        return iterationResult;
                     }
                 }
-                // Add AI response and tool results to conversation history
-                conversationHistory.push({ role: 'assistant', content: response.content }, { role: 'user', content: toolResults });
-                // Invoke iteration callback if provided
-                if (config.onIteration) {
-                    config.onIteration(iterations, toolCallsExecuted);
-                }
+                // Reached max iterations without completion
+                return (0, provider_debug_utils_1.createAndLogAgenticResult)({
+                    finalMessage: `Investigation incomplete - reached maximum ${maxIterations} iterations`,
+                    iterations,
+                    toolCallsExecuted,
+                    totalTokens: {
+                        input: totalTokens.input,
+                        output: totalTokens.output,
+                        cacheCreation: totalTokens.cacheCreation,
+                        cacheRead: totalTokens.cacheRead,
+                    },
+                    status: 'failed',
+                    completionReason: 'max_iterations',
+                    modelVersion: this.model,
+                    operation: `${operation}-max-iterations`,
+                    sdk: this.getProviderType(),
+                    startTime,
+                    debugMode: this.debugMode,
+                    evaluationContext: config.evaluationContext,
+                    interaction_id: config.interaction_id,
+                });
             }
-            // Reached max iterations without completion
-            return (0, provider_debug_utils_1.createAndLogAgenticResult)({
-                finalMessage: `Investigation incomplete - reached maximum ${maxIterations} iterations`,
-                iterations,
-                toolCallsExecuted,
-                totalTokens: {
-                    input: totalTokens.input,
-                    output: totalTokens.output,
-                    cacheCreation: totalTokens.cacheCreation,
-                    cacheRead: totalTokens.cacheRead
-                },
-                status: 'failed',
-                completionReason: 'max_iterations',
-                modelVersion: this.model,
-                operation: `${operation}-max-iterations`,
-                sdk: this.getProviderType(),
-                startTime,
-                debugMode: this.debugMode,
-                evaluationContext: config.evaluationContext,
-                interaction_id: config.interaction_id
-            });
-        }
-        catch (error) {
-            // Return error result with extended metrics
-            return (0, provider_debug_utils_1.createAndLogAgenticResult)({
-                finalMessage: `Error during investigation: ${error instanceof Error ? error.message : String(error)}`,
-                iterations,
-                toolCallsExecuted,
-                totalTokens: {
-                    input: totalTokens.input,
-                    output: totalTokens.output,
-                    cacheCreation: totalTokens.cacheCreation,
-                    cacheRead: totalTokens.cacheRead
-                },
-                status: 'failed',
-                completionReason: 'error',
-                modelVersion: this.model,
-                operation: `${operation}-error`,
-                sdk: this.getProviderType(),
-                startTime,
-                debugMode: this.debugMode,
-                evaluationContext: config.evaluationContext,
-                interaction_id: config.interaction_id
-            });
-        }
+            catch (error) {
+                // Return error result with extended metrics
+                return (0, provider_debug_utils_1.createAndLogAgenticResult)({
+                    finalMessage: `Error during investigation: ${error instanceof Error ? error.message : String(error)}`,
+                    iterations,
+                    toolCallsExecuted,
+                    totalTokens: {
+                        input: totalTokens.input,
+                        output: totalTokens.output,
+                        cacheCreation: totalTokens.cacheCreation,
+                        cacheRead: totalTokens.cacheRead,
+                    },
+                    status: 'failed',
+                    completionReason: 'error',
+                    modelVersion: this.model,
+                    operation: `${operation}-error`,
+                    sdk: this.getProviderType(),
+                    startTime,
+                    debugMode: this.debugMode,
+                    evaluationContext: config.evaluationContext,
+                    interaction_id: config.interaction_id,
+                });
+            }
+        }, (result) => ({
+            inputTokens: result.totalTokens.input,
+            outputTokens: result.totalTokens.output,
+            cacheReadTokens: result.totalTokens.cacheRead,
+            cacheCreationTokens: result.totalTokens.cacheCreation,
+        }));
     }
 }
 exports.AnthropicProvider = AnthropicProvider;