@vfarcic/dot-ai 0.125.0 → 0.126.0

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

@@ -17,6 +17,7 @@ const deepseek_1 = require("@ai-sdk/deepseek");
 const ai_sdk_provider_1 = require("@openrouter/ai-sdk-provider");
 const provider_debug_utils_1 = require("./provider-debug-utils");
 const model_config_1 = require("../model-config");
+const ai_tracing_1 = require("../tracing/ai-tracing");
 // Get all supported provider keys dynamically from CURRENT_MODELS
 const SUPPORTED_PROVIDERS = Object.keys(model_config_1.CURRENT_MODELS);
 class VercelProvider {
@@ -30,7 +31,7 @@ class VercelProvider {
         this.apiKey = config.apiKey;
         this.providerType = config.provider;
         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.baseURL = config.baseURL; // PRD #194: Store custom endpoint URL
         this.validateConfiguration();
         this.initializeModel();
@@ -50,7 +51,7 @@ class VercelProvider {
                 case 'openai':
                 case 'openai_pro':
                     provider = (0, openai_1.createOpenAI)({
-                        apiKey: this.apiKey
+                        apiKey: this.apiKey,
                     });
                     break;
                 case 'google':
@@ -64,8 +65,8 @@ class VercelProvider {
                         // Enable 1M token context window for Claude Sonnet 4 (5x increase from 200K)
                         // Required for models like claude-sonnet-4-5-20250929
                         headers: {
-                            'anthropic-beta': 'context-1m-2025-08-07'
-                        }
+                            'anthropic-beta': 'context-1m-2025-08-07',
+                        },
                     });
                     break;
                 case 'xai':
@@ -77,14 +78,14 @@ class VercelProvider {
                     break;
                 case 'deepseek':
                     provider = (0, deepseek_1.createDeepSeek)({
-                        apiKey: this.apiKey
+                        apiKey: this.apiKey,
                     });
                     break;
                 case 'openrouter':
                     // PRD #194: OpenRouter custom endpoint support
                     // Use dedicated OpenRouter provider for proper format conversion
                     provider = (0, ai_sdk_provider_1.createOpenRouter)({
-                        apiKey: this.apiKey
+                        apiKey: this.apiKey,
                     });
                     break;
                 case 'custom':
@@ -95,7 +96,7 @@ class VercelProvider {
                     }
                     provider = (0, openai_1.createOpenAI)({
                         apiKey: this.apiKey,
-                        baseURL: this.baseURL
+                        baseURL: this.baseURL,
                     });
                     break;
                 default:
@@ -130,97 +131,115 @@ class VercelProvider {
         // 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.isInitialized()) {
             throw new Error(`${this.providerType} provider not initialized`);
         }
-        const startTime = Date.now();
-        try {
-            // Use Vercel AI SDK generateText
-            // Note: maxOutputTokens not specified - provider will use model's natural maximum
-            const result = await (0, ai_1.generateText)({
-                model: this.modelInstance,
-                prompt: message,
-            });
-            const response = {
-                content: result.text,
-                usage: {
-                    input_tokens: (result.totalUsage || result.usage).inputTokens || 0,
-                    output_tokens: (result.totalUsage || result.usage).outputTokens || 0
-                }
-            };
-            const durationMs = Date.now() - startTime;
-            // Debug log the interaction if enabled
-            if (this.debugMode) {
-                const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
-                (0, provider_debug_utils_1.debugLogInteraction)(debugId, message, response, operation, this.getProviderType(), this.model, this.debugMode);
-                // PRD #154: Always use new evaluation dataset system
-                const evaluationMetrics = {
-                    // Core execution data
-                    operation,
-                    sdk: this.getProviderType(),
-                    inputTokens: response.usage.input_tokens,
-                    outputTokens: response.usage.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: response.content,
-                    user_intent: evaluationContext?.user_intent || '',
-                    interaction_id: evaluationContext?.interaction_id || '',
-                    // Optional performance data
-                    ...(response.usage.cache_creation_input_tokens && { cacheCreationTokens: response.usage.cache_creation_input_tokens }),
-                    ...(response.usage.cache_read_input_tokens && { cacheReadTokens: response.usage.cache_read_input_tokens })
+        return await (0, ai_tracing_1.withAITracing)({
+            provider: this.providerType,
+            model: this.model,
+            operation: 'chat',
+        }, async () => {
+            const startTime = Date.now();
+            try {
+                // Use Vercel AI SDK generateText
+                // Note: maxOutputTokens not specified - provider will use model's natural maximum
+                const result = await (0, ai_1.generateText)({
+                    model: this.modelInstance,
+                    prompt: message,
+                });
+                const response = {
+                    content: result.text,
+                    usage: {
+                        input_tokens: (result.totalUsage || result.usage).inputTokens || 0,
+                        output_tokens: (result.totalUsage || result.usage).outputTokens || 0,
+                    },
                 };
-                // Calculate cache hit rate if applicable
-                if (response.usage.cache_read_input_tokens && response.usage.input_tokens > 0) {
-                    evaluationMetrics.cacheHitRate = Math.round((response.usage.cache_read_input_tokens / response.usage.input_tokens) * 100);
+                const durationMs = Date.now() - startTime;
+                // Debug log the interaction if enabled
+                if (this.debugMode) {
+                    const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
+                    (0, provider_debug_utils_1.debugLogInteraction)(debugId, message, response, operation, this.getProviderType(), this.model, this.debugMode);
+                    // PRD #154: Always use new evaluation dataset system
+                    const evaluationMetrics = {
+                        // Core execution data
+                        operation,
+                        sdk: this.getProviderType(),
+                        inputTokens: response.usage.input_tokens,
+                        outputTokens: response.usage.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: response.content,
+                        user_intent: evaluationContext?.user_intent || '',
+                        interaction_id: evaluationContext?.interaction_id || '',
+                        // Optional performance data
+                        ...(response.usage.cache_creation_input_tokens && {
+                            cacheCreationTokens: response.usage.cache_creation_input_tokens,
+                        }),
+                        ...(response.usage.cache_read_input_tokens && {
+                            cacheReadTokens: response.usage.cache_read_input_tokens,
+                        }),
+                    };
+                    // Calculate cache hit rate if applicable
+                    if (response.usage.cache_read_input_tokens &&
+                        response.usage.input_tokens > 0) {
+                        evaluationMetrics.cacheHitRate = Math.round((response.usage.cache_read_input_tokens /
+                            response.usage.input_tokens) *
+                            100);
+                    }
+                    (0, provider_debug_utils_1.logEvaluationDataset)(evaluationMetrics, this.debugMode);
                 }
-                (0, provider_debug_utils_1.logEvaluationDataset)(evaluationMetrics, this.debugMode);
+                return response;
             }
-            return response;
-        }
-        catch (error) {
-            // Log the prompt that caused the error for debugging
-            if (this.debugMode) {
-                const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
-                (0, provider_debug_utils_1.debugLogPromptOnly)(debugId, message, operation, this.getProviderType(), this.model, this.debugMode);
-            }
-            // Generate dataset for failed AI interaction
-            if (this.debugMode && evaluationContext) {
-                const failureMetrics = {
-                    operation,
-                    user_intent: evaluationContext.user_intent || '',
-                    ai_response_summary: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    durationMs: Date.now() - startTime,
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    iterationCount: 0,
-                    toolCallCount: 0,
-                    status: 'failed',
-                    completionReason: 'error',
-                    sdk: this.getProviderType(),
-                    modelVersion: this.model,
-                    test_scenario: operation,
-                    interaction_id: evaluationContext.interaction_id || (0, provider_debug_utils_1.generateDebugId)(operation),
-                    failure_analysis: {
-                        failure_type: "error",
-                        failure_reason: `${this.providerType} API error: ${error instanceof Error ? error.message : String(error)}`,
-                        time_to_failure: Date.now() - startTime
-                    }
-                };
-                (0, provider_debug_utils_1.logEvaluationDataset)(failureMetrics, this.debugMode);
+            catch (error) {
+                // Log the prompt that caused the error for debugging
+                if (this.debugMode) {
+                    const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
+                    (0, provider_debug_utils_1.debugLogPromptOnly)(debugId, message, operation, this.getProviderType(), this.model, this.debugMode);
+                }
+                // Generate dataset for failed AI interaction
+                if (this.debugMode && evaluationContext) {
+                    const failureMetrics = {
+                        operation,
+                        user_intent: evaluationContext.user_intent || '',
+                        ai_response_summary: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        durationMs: Date.now() - startTime,
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        iterationCount: 0,
+                        toolCallCount: 0,
+                        status: 'failed',
+                        completionReason: 'error',
+                        sdk: this.getProviderType(),
+                        modelVersion: this.model,
+                        test_scenario: operation,
+                        interaction_id: evaluationContext.interaction_id || (0, provider_debug_utils_1.generateDebugId)(operation),
+                        failure_analysis: {
+                            failure_type: 'error',
+                            failure_reason: `${this.providerType} API error: ${error instanceof Error ? error.message : String(error)}`,
+                            time_to_failure: Date.now() - startTime,
+                        },
+                    };
+                    (0, provider_debug_utils_1.logEvaluationDataset)(failureMetrics, this.debugMode);
+                }
+                throw new Error(`${this.providerType} API error: ${error}`);
             }
-            throw new Error(`${this.providerType} 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 using Vercel AI SDK
@@ -239,285 +258,304 @@ class VercelProvider {
         if (!this.isInitialized()) {
             throw new Error(`${this.providerType} provider not initialized`);
         }
-        const startTime = Date.now();
-        const maxIterations = config.maxIterations || 20;
-        const operation = config.operation || 'tool-loop';
-        // Convert AITool[] to Vercel AI SDK tool format
-        const tools = {};
-        for (let i = 0; i < config.tools.length; i++) {
-            const aiTool = config.tools[i];
-            const isLastTool = i === config.tools.length - 1;
-            const toolDef = (0, ai_1.tool)({
-                description: aiTool.description,
-                inputSchema: (0, ai_1.jsonSchema)(aiTool.inputSchema),
-                execute: async (input) => {
-                    return await config.toolExecutor(aiTool.name, input);
+        return await (0, ai_tracing_1.withAITracing)({
+            provider: this.providerType,
+            model: this.model,
+            operation: 'tool_loop',
+        }, async () => {
+            const startTime = Date.now();
+            const maxIterations = config.maxIterations || 20;
+            const operation = config.operation || 'tool-loop';
+            // Convert AITool[] to Vercel AI SDK tool format
+            const tools = {};
+            for (let i = 0; i < config.tools.length; i++) {
+                const aiTool = config.tools[i];
+                const isLastTool = i === config.tools.length - 1;
+                const toolDef = (0, ai_1.tool)({
+                    description: aiTool.description,
+                    inputSchema: (0, ai_1.jsonSchema)(aiTool.inputSchema),
+                    execute: async (input) => {
+                        return await config.toolExecutor(aiTool.name, input);
+                    },
+                });
+                // Add cache control ONLY to last tool for Anthropic (max 4 cache breakpoints)
+                // This caches the system prompt + all tools together
+                if ((this.providerType === 'anthropic' ||
+                    this.providerType === 'anthropic_haiku') &&
+                    isLastTool) {
+                    toolDef.providerOptions = {
+                        anthropic: {
+                            cacheControl: { type: 'ephemeral' },
+                        },
+                    };
                 }
-            });
-            // Add cache control ONLY to last tool for Anthropic (max 4 cache breakpoints)
-            // This caches the system prompt + all tools together
-            if ((this.providerType === 'anthropic' || this.providerType === 'anthropic_haiku') && isLastTool) {
-                toolDef.providerOptions = {
-                    anthropic: {
-                        cacheControl: { type: 'ephemeral' }
-                    }
-                };
+                // TODO: Check if Google Gemini supports caching in future SDK versions
+                // Google Gemini may have caching capabilities - research providerOptions.google syntax
+                // if (this.providerType === 'google' && isLastTool) {
+                //   (toolDef as any).providerOptions = {
+                //     google: { /* caching config if available */ }
+                //   };
+                // }
+                tools[aiTool.name] = toolDef;
             }
-            // TODO: Check if Google Gemini supports caching in future SDK versions
-            // Google Gemini may have caching capabilities - research providerOptions.google syntax
-            // if (this.providerType === 'google' && isLastTool) {
-            //   (toolDef as any).providerOptions = {
-            //     google: { /* caching config if available */ }
-            //   };
-            // }
-            tools[aiTool.name] = toolDef;
-        }
-        // Build messages array with system prompt caching for Anthropic
-        // Anthropic caching requires system messages in messages array with providerOptions
-        const messages = [];
-        let systemParam;
-        if (this.providerType === 'anthropic' || this.providerType === 'anthropic_haiku') {
-            // For Anthropic: Put system in messages array with cacheControl
+            // Build messages array with system prompt caching for Anthropic
+            // Anthropic caching requires system messages in messages array with providerOptions
+            const messages = [];
+            let systemParam;
+            if (this.providerType === 'anthropic' ||
+                this.providerType === 'anthropic_haiku') {
+                // For Anthropic: Put system in messages array with cacheControl
+                messages.push({
+                    role: 'system',
+                    content: config.systemPrompt,
+                    providerOptions: {
+                        anthropic: {
+                            cacheControl: { type: 'ephemeral' },
+                        },
+                    },
+                });
+                // Don't use system parameter for Anthropic when caching
+                systemParam = undefined;
+            }
+            else {
+                // For OpenAI/Google: Use system parameter (string)
+                systemParam = config.systemPrompt;
+            }
+            // Add user message
             messages.push({
-                role: 'system',
-                content: config.systemPrompt,
-                providerOptions: {
-                    anthropic: {
-                        cacheControl: { type: 'ephemeral' }
-                    }
-                }
+                role: 'user',
+                content: config.userMessage,
             });
-            // Don't use system parameter for Anthropic when caching
-            systemParam = undefined;
-        }
-        else {
-            // For OpenAI/Google: Use system parameter (string)
-            systemParam = config.systemPrompt;
-        }
-        // Add user message
-        messages.push({
-            role: 'user',
-            content: config.userMessage
-        });
-        // TODO: Check if Google Gemini supports system prompt caching in future SDK versions
-        // if (this.providerType === 'google') {
-        //   messages.unshift({
-        //     role: 'system',
-        //     content: config.systemPrompt,
-        //     providerOptions: {
-        //       google: { /* caching config if available */ }
-        //     }
-        //   });
-        //   systemParam = undefined;
-        // }
-        try {
-            // Use Vercel AI SDK's generateText with stopWhen for automatic loop
-            // Default is stepCountIs(1) - we need to increase for multi-step investigation
-            // Note: maxOutputTokens not specified - provider will use model's natural maximum
-            const generateConfig = {
-                model: this.modelInstance,
-                messages,
-                tools,
-                stopWhen: (0, ai_1.stepCountIs)(maxIterations)
-            };
-            // Add system parameter for non-Anthropic providers
-            if (systemParam) {
-                generateConfig.system = systemParam;
-            }
-            const result = await (0, ai_1.generateText)(generateConfig);
-            // Log raw response immediately after generation (before any processing)
-            let debugFiles = null;
-            if (this.debugMode) {
-                // Build the full conversation context like Anthropic provider does
-                let finalPrompt = `System: ${config.systemPrompt}\n\n`;
-                // Always include the original user intent first
-                finalPrompt += `user: ${config.userMessage}\n\n`;
-                // Then add the conversation history if available
-                if (result.response?.messages) {
-                    finalPrompt += result.response.messages
-                        .map(msg => {
-                        if (typeof msg.content === 'string') {
-                            return `${msg.role}: ${msg.content}`;
-                        }
-                        else if (Array.isArray(msg.content)) {
-                            const contentParts = msg.content.map(part => {
-                                if (part.type === 'text') {
-                                    return part.text;
-                                }
-                                else if (part.type === 'tool-call') {
-                                    return `[TOOL_USE: ${part.toolName}]`;
-                                }
-                                else if (part.type === 'tool-result') {
-                                    const resultData = part.output || part.result || part.content;
-                                    if (typeof resultData === 'string') {
-                                        return `[TOOL_RESULT: ${part.toolName}]\n${resultData}`;
+            // TODO: Check if Google Gemini supports system prompt caching in future SDK versions
+            // if (this.providerType === 'google') {
+            //   messages.unshift({
+            //     role: 'system',
+            //     content: config.systemPrompt,
+            //     providerOptions: {
+            //       google: { /* caching config if available */ }
+            //     }
+            //   });
+            //   systemParam = undefined;
+            // }
+            try {
+                // Use Vercel AI SDK's generateText with stopWhen for automatic loop
+                // Default is stepCountIs(1) - we need to increase for multi-step investigation
+                // Note: maxOutputTokens not specified - provider will use model's natural maximum
+                const generateConfig = {
+                    model: this.modelInstance,
+                    messages,
+                    tools,
+                    stopWhen: (0, ai_1.stepCountIs)(maxIterations),
+                };
+                // Add system parameter for non-Anthropic providers
+                if (systemParam) {
+                    generateConfig.system = systemParam;
+                }
+                const result = await (0, ai_1.generateText)(generateConfig);
+                // Log raw response immediately after generation (before any processing)
+                let debugFiles = null;
+                if (this.debugMode) {
+                    // Build the full conversation context like Anthropic provider does
+                    let finalPrompt = `System: ${config.systemPrompt}\n\n`;
+                    // Always include the original user intent first
+                    finalPrompt += `user: ${config.userMessage}\n\n`;
+                    // Then add the conversation history if available
+                    if (result.response?.messages) {
+                        finalPrompt += result.response.messages
+                            .map(msg => {
+                            if (typeof msg.content === 'string') {
+                                return `${msg.role}: ${msg.content}`;
+                            }
+                            else if (Array.isArray(msg.content)) {
+                                const contentParts = msg.content
+                                    .map(part => {
+                                    if (part.type === 'text') {
+                                        return part.text;
                                     }
-                                    else if (resultData) {
-                                        return `[TOOL_RESULT: ${part.toolName}]\n${JSON.stringify(resultData, null, 2)}`;
+                                    else if (part.type === 'tool-call') {
+                                        return `[TOOL_USE: ${part.toolName}]`;
                                     }
-                                    return `[TOOL_RESULT: ${part.toolName}]`;
-                                }
-                                return `[${part.type}]`;
-                            }).join(' ');
-                            return `${msg.role}: ${contentParts}`;
-                        }
-                        return `${msg.role}: [complex_content]`;
-                    })
-                        .join('\n\n');
-                }
-                // Create raw response content that includes ALL data from result
-                let rawResponseContent = `# RAW RESPONSE DATA\n\n`;
-                rawResponseContent += `**result.text**: ${result.text || '[EMPTY]'}\n\n`;
-                if (result.steps && result.steps.length > 0) {
-                    rawResponseContent += `**Steps (${result.steps.length})**:\n`;
-                    result.steps.forEach((step, i) => {
-                        rawResponseContent += `\nStep ${i + 1}:\n`;
-                        rawResponseContent += `- text: ${step.text || '[EMPTY]'}\n`;
-                        if (step.toolCalls) {
-                            rawResponseContent += `- toolCalls: ${step.toolCalls.length}\n`;
-                        }
-                        if (step.toolResults) {
-                            rawResponseContent += `- toolResults: ${step.toolResults.length}\n`;
+                                    else if (part.type === 'tool-result') {
+                                        const resultData = part.output ||
+                                            part.result ||
+                                            part.content;
+                                        if (typeof resultData === 'string') {
+                                            return `[TOOL_RESULT: ${part.toolName}]\n${resultData}`;
+                                        }
+                                        else if (resultData) {
+                                            return `[TOOL_RESULT: ${part.toolName}]\n${JSON.stringify(resultData, null, 2)}`;
+                                        }
+                                        return `[TOOL_RESULT: ${part.toolName}]`;
+                                    }
+                                    return `[${part.type}]`;
+                                })
+                                    .join(' ');
+                                return `${msg.role}: ${contentParts}`;
+                            }
+                            return `${msg.role}: [complex_content]`;
+                        })
+                            .join('\n\n');
+                    }
+                    // Create raw response content that includes ALL data from result
+                    let rawResponseContent = `# RAW RESPONSE DATA\n\n`;
+                    rawResponseContent += `**result.text**: ${result.text || '[EMPTY]'}\n\n`;
+                    if (result.steps && result.steps.length > 0) {
+                        rawResponseContent += `**Steps (${result.steps.length})**:\n`;
+                        result.steps.forEach((step, i) => {
+                            rawResponseContent += `\nStep ${i + 1}:\n`;
+                            rawResponseContent += `- text: ${step.text || '[EMPTY]'}\n`;
+                            if (step.toolCalls) {
+                                rawResponseContent += `- toolCalls: ${step.toolCalls.length}\n`;
+                            }
+                            if (step.toolResults) {
+                                rawResponseContent += `- toolResults: ${step.toolResults.length}\n`;
+                            }
+                        });
+                        rawResponseContent += '\n';
+                    }
+                    // Add the last step's text for easy access
+                    let lastStepText = '';
+                    if (result.steps && result.steps.length > 0) {
+                        for (let i = result.steps.length - 1; i >= 0; i--) {
+                            if (result.steps[i].text && result.steps[i].text.trim()) {
+                                lastStepText = result.steps[i].text;
+                                break;
+                            }
                         }
-                    });
-                    rawResponseContent += '\n';
+                    }
+                    rawResponseContent += `**Last step with text**: ${lastStepText || '[NONE]'}\n\n`;
+                    const usage = result.totalUsage || result.usage;
+                    const rawAiResponse = {
+                        content: rawResponseContent,
+                        usage: {
+                            input_tokens: usage.inputTokens || 0,
+                            output_tokens: usage.outputTokens || 0,
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: 0,
+                        },
+                    };
+                    debugFiles = this.logDebugIfEnabled(`${operation}-raw`, finalPrompt, rawAiResponse);
                 }
-                // Add the last step's text for easy access
-                let lastStepText = '';
-                if (result.steps && result.steps.length > 0) {
-                    for (let i = result.steps.length - 1; i >= 0; i--) {
-                        if (result.steps[i].text && result.steps[i].text.trim()) {
-                            lastStepText = result.steps[i].text;
-                            break;
-                        }
+                // Extract tool call history from steps
+                const toolCallsExecuted = [];
+                for (const step of result.steps || []) {
+                    for (const toolCall of step.toolCalls || []) {
+                        const toolResult = step.toolResults?.find((tr) => tr.toolCallId === toolCall.toolCallId);
+                        toolCallsExecuted.push({
+                            tool: toolCall.toolName,
+                            input: toolCall.args,
+                            output: toolResult?.result,
+                        });
                     }
                 }
-                rawResponseContent += `**Last step with text**: ${lastStepText || '[NONE]'}\n\n`;
+                // Normalize token metrics across providers
+                // NOTE: Vercel AI SDK had token reporting bugs that were fixed in PR #8945 (merged Sept 26, 2025)
+                // - GitHub Issue #8349: cache tokens only reflected last step, not summed across all steps
+                // - GitHub Issue #8795: Token reporting issues with Anthropic provider (streaming)
+                // Our version (5.0.60, released Oct 2, 2025) includes these fixes.
+                // However, testing still shows ~70% fewer tokens reported vs Anthropic native SDK.
+                // Root cause: We were using result.usage (final step only) instead of result.totalUsage (sum of all steps)!
                 const usage = result.totalUsage || result.usage;
-                const rawAiResponse = {
-                    content: rawResponseContent,
-                    usage: {
-                        input_tokens: usage.inputTokens || 0,
-                        output_tokens: usage.outputTokens || 0,
-                        cache_creation_input_tokens: 0,
-                        cache_read_input_tokens: 0
-                    }
-                };
-                debugFiles = this.logDebugIfEnabled(`${operation}-raw`, finalPrompt, rawAiResponse);
-            }
-            // Extract tool call history from steps
-            const toolCallsExecuted = [];
-            for (const step of result.steps || []) {
-                for (const toolCall of step.toolCalls || []) {
-                    const toolResult = step.toolResults?.find((tr) => tr.toolCallId === toolCall.toolCallId);
-                    toolCallsExecuted.push({
-                        tool: toolCall.toolName,
-                        input: toolCall.args,
-                        output: toolResult?.result
-                    });
+                let cacheReadTokens = 0;
+                let cacheCreationTokens = 0;
+                // Anthropic via Vercel uses cachedInputTokens (confirmed in AI SDK 5+)
+                if (usage.cachedInputTokens) {
+                    cacheReadTokens = usage.cachedInputTokens;
                 }
-            }
-            // Normalize token metrics across providers
-            // NOTE: Vercel AI SDK had token reporting bugs that were fixed in PR #8945 (merged Sept 26, 2025)
-            // - GitHub Issue #8349: cache tokens only reflected last step, not summed across all steps
-            // - GitHub Issue #8795: Token reporting issues with Anthropic provider (streaming)
-            // Our version (5.0.60, released Oct 2, 2025) includes these fixes.
-            // However, testing still shows ~70% fewer tokens reported vs Anthropic native SDK.
-            // Root cause: We were using result.usage (final step only) instead of result.totalUsage (sum of all steps)!
-            const usage = result.totalUsage || result.usage;
-            let cacheReadTokens = 0;
-            let cacheCreationTokens = 0;
-            // Anthropic via Vercel uses cachedInputTokens (confirmed in AI SDK 5+)
-            if (usage.cachedInputTokens) {
-                cacheReadTokens = usage.cachedInputTokens;
-            }
-            // OpenAI uses cached_tokens or cachedTokens (automatic caching, no config needed)
-            if ('cachedTokens' in usage || usage.cached_tokens) {
-                cacheReadTokens = usage.cachedTokens || usage.cached_tokens || 0;
-            }
-            // Anthropic native SDK uses separate cache_creation and cache_read fields
-            if (usage.cache_creation_input_tokens) {
-                cacheCreationTokens = usage.cache_creation_input_tokens;
-            }
-            if (usage.cache_read_input_tokens) {
-                cacheReadTokens = usage.cache_read_input_tokens;
-            }
-            // TODO: Check if Google Gemini reports cache metrics in future SDK versions
-            // Google Gemini may return cache-related metrics - check usage object structure
-            // Possible fields: cachedTokens, cacheHits, or provider-specific naming
-            // Add normalization logic here when Gemini caching is confirmed
-            // Extract final text from the last step (result.text might be empty if last step had tool calls)
-            let finalText = result.text;
-            if (!finalText || finalText.trim().length === 0) {
-                // If result.text is empty, find the last text response from steps
-                for (let i = (result.steps || []).length - 1; i >= 0; i--) {
-                    const step = result.steps[i];
-                    if (step.text && step.text.trim().length > 0) {
-                        finalText = step.text;
-                        break;
+                // OpenAI uses cached_tokens or cachedTokens (automatic caching, no config needed)
+                if ('cachedTokens' in usage || usage.cached_tokens) {
+                    cacheReadTokens =
+                        usage.cachedTokens || usage.cached_tokens || 0;
+                }
+                // Anthropic native SDK uses separate cache_creation and cache_read fields
+                if (usage.cache_creation_input_tokens) {
+                    cacheCreationTokens = usage.cache_creation_input_tokens;
+                }
+                if (usage.cache_read_input_tokens) {
+                    cacheReadTokens = usage.cache_read_input_tokens;
+                }
+                // TODO: Check if Google Gemini reports cache metrics in future SDK versions
+                // Google Gemini may return cache-related metrics - check usage object structure
+                // Possible fields: cachedTokens, cacheHits, or provider-specific naming
+                // Add normalization logic here when Gemini caching is confirmed
+                // Extract final text from the last step (result.text might be empty if last step had tool calls)
+                let finalText = result.text;
+                if (!finalText || finalText.trim().length === 0) {
+                    // If result.text is empty, find the last text response from steps
+                    for (let i = (result.steps || []).length - 1; i >= 0; i--) {
+                        const step = result.steps[i];
+                        if (step.text && step.text.trim().length > 0) {
+                            finalText = step.text;
+                            break;
+                        }
                     }
                 }
+                // Log processed summary response (keep existing functionality)
+                if (this.debugMode && debugFiles === null) {
+                    // Only log summary if we haven't already logged raw response
+                    let finalPrompt = `System: ${config.systemPrompt}\n\nuser: ${config.userMessage}`;
+                    const aiResponse = {
+                        content: finalText || '',
+                        usage: {
+                            input_tokens: usage.inputTokens || 0,
+                            output_tokens: usage.outputTokens || 0,
+                            cache_creation_input_tokens: cacheCreationTokens,
+                            cache_read_input_tokens: cacheReadTokens,
+                        },
+                    };
+                    debugFiles = this.logDebugIfEnabled(`${operation}-summary`, finalPrompt, aiResponse);
+                }
+                return (0, provider_debug_utils_1.createAndLogAgenticResult)({
+                    finalMessage: finalText || '',
+                    iterations: result.steps?.length || 1,
+                    toolCallsExecuted,
+                    totalTokens: {
+                        input: usage.inputTokens || 0,
+                        output: usage.outputTokens || 0,
+                        cacheCreation: cacheCreationTokens,
+                        cacheRead: cacheReadTokens,
+                    },
+                    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,
+                });
             }
-            // Log processed summary response (keep existing functionality)
-            if (this.debugMode && debugFiles === null) {
-                // Only log summary if we haven't already logged raw response
-                let finalPrompt = `System: ${config.systemPrompt}\n\nuser: ${config.userMessage}`;
-                const aiResponse = {
-                    content: finalText || '',
-                    usage: {
-                        input_tokens: usage.inputTokens || 0,
-                        output_tokens: usage.outputTokens || 0,
-                        cache_creation_input_tokens: cacheCreationTokens,
-                        cache_read_input_tokens: cacheReadTokens
-                    }
-                };
-                debugFiles = this.logDebugIfEnabled(`${operation}-summary`, finalPrompt, aiResponse);
+            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: 0,
+                    toolCallsExecuted: [],
+                    totalTokens: {
+                        input: 0,
+                        output: 0,
+                        cacheCreation: 0,
+                        cacheRead: 0,
+                    },
+                    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,
+                });
             }
-            return (0, provider_debug_utils_1.createAndLogAgenticResult)({
-                finalMessage: finalText || '',
-                iterations: result.steps?.length || 1,
-                toolCallsExecuted,
-                totalTokens: {
-                    input: usage.inputTokens || 0,
-                    output: usage.outputTokens || 0,
-                    cacheCreation: cacheCreationTokens,
-                    cacheRead: cacheReadTokens
-                },
-                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
-            });
-        }
-        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: 0,
-                toolCallsExecuted: [],
-                totalTokens: {
-                    input: 0,
-                    output: 0,
-                    cacheCreation: 0,
-                    cacheRead: 0
-                },
-                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.VercelProvider = VercelProvider;