@vfarcic/dot-ai 0.104.0 → 0.106.0

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

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * Anthropic AI Provider Implementation
+ *
+ * Implements AIProvider interface using Anthropic SDK directly.
+ * Supports streaming for long operations and debug logging.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const provider_debug_utils_1 = require("./provider-debug-utils");
+class AnthropicProvider {
+    client;
+    apiKey;
+    model;
+    debugMode;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.model = config.model || this.getDefaultModel();
+        this.debugMode = config.debugMode ?? (process.env.DEBUG_DOT_AI === 'true');
+        this.validateApiKey();
+        this.client = new sdk_1.default({
+            apiKey: this.apiKey,
+        });
+    }
+    validateApiKey() {
+        if (!this.apiKey) {
+            throw new Error('API key is required for Anthropic provider');
+        }
+        if (this.apiKey.length === 0) {
+            throw new Error('Invalid API key: API key cannot be empty');
+        }
+    }
+    getProviderType() {
+        return 'anthropic';
+    }
+    getDefaultModel() {
+        return 'claude-sonnet-4-5-20250929';
+    }
+    isInitialized() {
+        return this.client !== undefined;
+    }
+    async sendMessage(message, operation = 'generic') {
+        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;
+                    }
+                }
+                else if (chunk.type === 'message_delta') {
+                    output_tokens = chunk.usage.output_tokens;
+                }
+            }
+            const response = {
+                content,
+                usage: {
+                    input_tokens,
+                    output_tokens
+                }
+            };
+            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);
+                (0, provider_debug_utils_1.logMetrics)(operation, this.getProviderType(), response.usage, durationMs, this.debugMode);
+            }
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Anthropic API error: ${error}`);
+        }
+    }
+    /**
+     * Agentic tool loop implementation
+     *
+     * NOTE: This method is currently NOT USED in the codebase (as of PRD #136 completion).
+     *
+     * Analysis showed that SDK-based tool loops and JSON-based agentic loops are functionally
+     * equivalent - both allow AI to decide which tools to call and when to stop. The JSON-based
+     * approach we already use provides the same capabilities without the token overhead of
+     * tool schemas in every request.
+     *
+     * This implementation is kept for potential future use cases where SDK-managed tool loops
+     * might provide advantages (e.g., better provider-specific optimizations, simpler code for
+     * highly exploratory workflows).
+     *
+     * ONLY IMPLEMENTED IN ANTHROPIC PROVIDER - VercelAIProvider does not implement this method
+     * as it's not needed for current workflows. If you need toolLoop for other providers, you'll
+     * need to implement it there as well.
+     *
+     * See PRD #136 for full architecture analysis and decision rationale.
+     */
+    async toolLoop(config) {
+        if (!this.client) {
+            throw new Error('Anthropic client not initialized');
+        }
+        const startTime = Date.now();
+        // Convert AITool[] to Anthropic Tool format
+        const tools = config.tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.inputSchema
+        }));
+        // Initialize conversation history
+        const initialContent = config.systemPrompt + '\n\n' + config.userMessage;
+        const conversationHistory = [
+            {
+                role: 'user',
+                content: initialContent
+            }
+        ];
+        let iterations = 0;
+        const toolCallsExecuted = [];
+        const totalTokens = { input: 0, output: 0 };
+        const maxIterations = config.maxIterations || 20;
+        try {
+            while (iterations < maxIterations) {
+                iterations++;
+                // Call Anthropic API with tools
+                const response = await this.client.messages.create({
+                    model: this.model,
+                    max_tokens: 4096,
+                    messages: conversationHistory,
+                    tools: tools
+                });
+                // Track token usage
+                totalTokens.input += response.usage.input_tokens;
+                totalTokens.output += response.usage.output_tokens;
+                // Check if AI wants to use tools
+                const toolUses = response.content.filter((c) => c.type === 'tool_use');
+                if (toolUses.length === 0) {
+                    // AI is done - extract final text message
+                    const textContent = response.content.find((c) => c.type === 'text');
+                    const result = {
+                        finalMessage: textContent?.text || '',
+                        iterations,
+                        toolCallsExecuted,
+                        totalTokens
+                    };
+                    // Log metrics for the entire tool loop
+                    const durationMs = Date.now() - startTime;
+                    if (this.debugMode) {
+                        const operation = config.operation || 'tool-loop';
+                        (0, provider_debug_utils_1.logMetrics)(operation, this.getProviderType(), {
+                            input_tokens: totalTokens.input,
+                            output_tokens: totalTokens.output
+                        }, durationMs, this.debugMode);
+                    }
+                    return result;
+                }
+                // Execute all requested tools
+                const toolResults = [];
+                for (const toolUse of toolUses) {
+                    try {
+                        const result = await config.toolExecutor(toolUse.name, toolUse.input);
+                        toolCallsExecuted.push({
+                            tool: toolUse.name,
+                            input: toolUse.input,
+                            output: result
+                        });
+                        toolResults.push({
+                            type: 'tool_result',
+                            tool_use_id: toolUse.id,
+                            content: JSON.stringify(result)
+                        });
+                    }
+                    catch (error) {
+                        // Feed error back to AI as tool result
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        toolResults.push({
+                            type: 'tool_result',
+                            tool_use_id: toolUse.id,
+                            content: JSON.stringify({ error: errorMessage }),
+                            is_error: true
+                        });
+                    }
+                }
+                // 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);
+                }
+            }
+            throw new Error(`Tool loop exceeded max iterations (${maxIterations})`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('exceeded max iterations')) {
+                throw error;
+            }
+            throw new Error(`Anthropic tool loop error: ${error}`);
+        }
+    }
+    async sendMessageWithTools(message, tools, toolExecutor, operation = 'tool-call') {
+        if (!this.client) {
+            throw new Error('Anthropic client not initialized');
+        }
+        // Convert AITool[] to Anthropic Tool format
+        const anthropicTools = tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.inputSchema
+        }));
+        try {
+            // Single API call with tools
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 4096,
+                messages: [{ role: 'user', content: message }],
+                tools: anthropicTools
+            });
+            const toolCalls = [];
+            let textContent = '';
+            // Process response content
+            for (const block of response.content) {
+                if (block.type === 'text') {
+                    textContent += block.text;
+                }
+                else if (block.type === 'tool_use') {
+                    // Execute the tool
+                    try {
+                        const result = await toolExecutor(block.name, block.input);
+                        toolCalls.push({
+                            tool: block.name,
+                            input: block.input,
+                            output: result
+                        });
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        toolCalls.push({
+                            tool: block.name,
+                            input: block.input,
+                            error: errorMessage
+                        });
+                    }
+                }
+            }
+            const aiResponse = {
+                content: textContent,
+                usage: {
+                    input_tokens: response.usage.input_tokens,
+                    output_tokens: response.usage.output_tokens
+                },
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+            };
+            // Debug log if enabled
+            if (this.debugMode) {
+                const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
+                (0, provider_debug_utils_1.debugLogInteraction)(debugId, message, aiResponse, operation, this.getProviderType(), this.model, this.debugMode);
+            }
+            return aiResponse;
+        }
+        catch (error) {
+            throw new Error(`Anthropic tool call error: ${error}`);
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/core/providers/provider-debug-utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared debugging utilities for AI providers
+ *
+ * Common functions for logging metrics and debugging AI interactions
+ * when DEBUG_DOT_AI=true
+ */
+import { AIResponse } from '../ai-provider.interface';
+/**
+ * Create debug directory if it doesn't exist
+ */
+export declare function ensureDebugDirectory(): string;
+/**
+ * Generate unique identifier for debug files with operation context
+ */
+export declare function generateDebugId(operation: string): string;
+/**
+ * Log metrics for token usage and execution time when DEBUG_DOT_AI=true
+ */
+export declare function logMetrics(operation: string, provider: string, usage: {
+    input_tokens: number;
+    output_tokens: number;
+}, durationMs: number, debugMode: boolean): void;
+/**
+ * Save AI interaction for debugging when DEBUG_DOT_AI=true
+ */
+export declare function debugLogInteraction(debugId: string, prompt: string, response: AIResponse, operation: string, provider: string, model: string, debugMode: boolean): void;
+//# sourceMappingURL=provider-debug-utils.d.ts.map

package/dist/core/providers/provider-debug-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-debug-utils.d.ts","sourceRoot":"","sources":["../../../src/core/providers/provider-debug-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAM7C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,EACtD,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,OAAO,GACjB,IAAI,CAoBN;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,IAAI,CAkCN"}

package/dist/core/providers/provider-debug-utils.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Shared debugging utilities for AI providers
+ *
+ * Common functions for logging metrics and debugging AI interactions
+ * when DEBUG_DOT_AI=true
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDebugDirectory = ensureDebugDirectory;
+exports.generateDebugId = generateDebugId;
+exports.logMetrics = logMetrics;
+exports.debugLogInteraction = debugLogInteraction;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+/**
+ * Create debug directory if it doesn't exist
+ */
+function ensureDebugDirectory() {
+    const debugDir = path.join(process.cwd(), 'tmp', 'debug-ai');
+    if (!fs.existsSync(debugDir)) {
+        fs.mkdirSync(debugDir, { recursive: true });
+    }
+    return debugDir;
+}
+/**
+ * Generate unique identifier for debug files with operation context
+ */
+function generateDebugId(operation) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '').split('T');
+    const dateTime = timestamp[0] + 'T' + timestamp[1].substring(0, 6);
+    const randomHex = crypto.randomBytes(4).toString('hex');
+    return `${dateTime}_${randomHex}_${operation}`;
+}
+/**
+ * Log metrics for token usage and execution time when DEBUG_DOT_AI=true
+ */
+function logMetrics(operation, provider, usage, durationMs, debugMode) {
+    if (!debugMode)
+        return;
+    try {
+        const debugDir = ensureDebugDirectory();
+        const metricsFile = path.join(debugDir, 'metrics.jsonl');
+        const entry = JSON.stringify({
+            timestamp: new Date().toISOString(),
+            provider,
+            operation,
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            durationMs
+        }) + '\n';
+        fs.appendFileSync(metricsFile, entry);
+    }
+    catch (error) {
+        console.warn('Failed to log metrics:', error);
+    }
+}
+/**
+ * Save AI interaction for debugging when DEBUG_DOT_AI=true
+ */
+function debugLogInteraction(debugId, prompt, response, operation, provider, model, debugMode) {
+    if (!debugMode)
+        return;
+    try {
+        const debugDir = ensureDebugDirectory();
+        // Save prompt with descriptive naming
+        const promptFile = path.join(debugDir, `${debugId}_prompt.md`);
+        fs.writeFileSync(promptFile, `# AI Prompt - ${operation}\n\nTimestamp: ${new Date().toISOString()}\nProvider: ${provider}\nModel: ${model}\nOperation: ${operation}\n\n---\n\n${prompt}`);
+        // Save response with matching naming
+        const responseFile = path.join(debugDir, `${debugId}_response.md`);
+        const responseContent = `# AI Response - ${operation}
+
+Timestamp: ${new Date().toISOString()}
+Provider: ${provider}
+Model: ${model}
+Operation: ${operation}
+Input Tokens: ${response.usage.input_tokens}
+Output Tokens: ${response.usage.output_tokens}
+
+---
+
+${response.content}`;
+        fs.writeFileSync(responseFile, responseContent);
+        console.log(`🐛 DEBUG: AI interaction logged to tmp/debug-ai/${debugId}_*.md`);
+    }
+    catch (error) {
+        console.warn('Failed to log AI debug interaction:', error);
+    }
+}

package/dist/core/providers/vercel-provider.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Vercel AI Provider Implementation
+ *
+ * Implements AIProvider interface using Vercel AI SDK.
+ * Supports OpenAI and Google Gemini providers through unified interface.
+ */
+import { AIProvider, AIResponse, AIProviderConfig, AITool, ToolExecutor, ToolLoopConfig, AgenticResult } from '../ai-provider.interface';
+export declare class VercelProvider implements AIProvider {
+    private providerType;
+    private model;
+    private apiKey;
+    private debugMode;
+    private modelInstance;
+    constructor(config: AIProviderConfig);
+    private validateConfiguration;
+    private initializeModel;
+    getProviderType(): string;
+    getDefaultModel(): string;
+    isInitialized(): boolean;
+    sendMessage(message: string, operation?: string): Promise<AIResponse>;
+    /**
+     * Agentic tool loop - NOT IMPLEMENTED for Vercel provider
+     *
+     * This method is intentionally not implemented because:
+     * 1. toolLoop() is currently NOT USED anywhere in the codebase (see PRD #136)
+     * 2. JSON-based agentic loops already provide equivalent functionality
+     * 3. No current workflows require SDK-managed tool loops
+     *
+     * If future requirements necessitate toolLoop() for non-Anthropic providers,
+     * this would need to be implemented using Vercel AI SDK's tool calling API.
+     *
+     * See AnthropicProvider.toolLoop() and PRD #136 for implementation reference.
+     */
+    toolLoop(_config: ToolLoopConfig): Promise<AgenticResult>;
+    /**
+     * Single-shot tool calling - NOT IMPLEMENTED for Vercel provider
+     *
+     * Same reasoning as toolLoop(): not currently needed in codebase.
+     * JSON-based approach achieves same functionality without SDK overhead.
+     *
+     * See AnthropicProvider.sendMessageWithTools() for reference implementation.
+     */
+    sendMessageWithTools(_message: string, _tools: AITool[], _toolExecutor: ToolExecutor, _operation?: string): Promise<AIResponse & {
+        toolCalls?: any[];
+    }>;
+}
+//# sourceMappingURL=vercel-provider.d.ts.map

package/dist/core/providers/vercel-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-provider.d.ts","sourceRoot":"","sources":["../../../src/core/providers/vercel-provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,EACL,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,MAAM,EACN,YAAY,EACZ,cAAc,EACd,aAAa,EACd,MAAM,0BAA0B,CAAC;AAclC,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,aAAa,CAAM;gBAEf,MAAM,EAAE,gBAAgB;IAUpC,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,eAAe;IAgCvB,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,MAAM;IAIzB,aAAa,IAAI,OAAO;IAIlB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAkB,GAAG,OAAO,CAAC,UAAU,CAAC;IAuCtF;;;;;;;;;;;;OAYG;IACG,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;IAQ/D;;;;;;;OAOG;IACG,oBAAoB,CACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,aAAa,EAAE,YAAY,EAC3B,UAAU,GAAE,MAAoB,GAC/B,OAAO,CAAC,UAAU,GAAG;QAAE,SAAS,CAAC,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;CAO/C"}

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

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Vercel AI Provider Implementation
+ *
+ * Implements AIProvider interface using Vercel AI SDK.
+ * Supports OpenAI and Google Gemini providers through unified interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelProvider = void 0;
+const ai_1 = require("ai");
+const openai_1 = require("@ai-sdk/openai");
+const google_1 = require("@ai-sdk/google");
+const anthropic_1 = require("@ai-sdk/anthropic");
+const provider_debug_utils_1 = require("./provider-debug-utils");
+/**
+ * Provider-specific default models
+ */
+const PROVIDER_MODELS = {
+    openai: 'gpt-5',
+    google: 'gemini-2.5-pro',
+    anthropic: 'claude-sonnet-4-5-20250929'
+};
+class VercelProvider {
+    providerType;
+    model;
+    apiKey;
+    debugMode;
+    modelInstance; // Vercel AI SDK model instance
+    constructor(config) {
+        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.validateConfiguration();
+        this.initializeModel();
+    }
+    validateConfiguration() {
+        if (!this.apiKey) {
+            throw new Error(`API key is required for ${this.providerType} provider`);
+        }
+        if (!['openai', 'google', 'anthropic'].includes(this.providerType)) {
+            throw new Error(`Unsupported provider: ${this.providerType}. Must be 'openai', 'google', or 'anthropic'`);
+        }
+    }
+    initializeModel() {
+        try {
+            switch (this.providerType) {
+                case 'openai': {
+                    const provider = (0, openai_1.createOpenAI)({
+                        apiKey: this.apiKey
+                    });
+                    this.modelInstance = provider(this.model);
+                    break;
+                }
+                case 'google': {
+                    const provider = (0, google_1.createGoogleGenerativeAI)({
+                        apiKey: this.apiKey
+                    });
+                    this.modelInstance = provider(this.model);
+                    break;
+                }
+                case 'anthropic': {
+                    const provider = (0, anthropic_1.createAnthropic)({
+                        apiKey: this.apiKey
+                    });
+                    this.modelInstance = provider(this.model);
+                    break;
+                }
+                default:
+                    throw new Error(`Cannot initialize model for provider: ${this.providerType}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize ${this.providerType} model: ${error}`);
+        }
+    }
+    getProviderType() {
+        return this.providerType;
+    }
+    getDefaultModel() {
+        return PROVIDER_MODELS[this.providerType];
+    }
+    isInitialized() {
+        return this.modelInstance !== undefined;
+    }
+    async sendMessage(message, operation = 'generic') {
+        if (!this.isInitialized()) {
+            throw new Error(`${this.providerType} provider not initialized`);
+        }
+        const startTime = Date.now();
+        try {
+            // Use Vercel AI SDK generateText
+            // Note: maxTokens omitted - let SDK/provider use model-specific optimal defaults
+            const result = await (0, ai_1.generateText)({
+                model: this.modelInstance,
+                prompt: message,
+            });
+            const response = {
+                content: result.text,
+                usage: {
+                    input_tokens: result.usage.inputTokens || 0,
+                    output_tokens: 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);
+                (0, provider_debug_utils_1.logMetrics)(operation, this.getProviderType(), response.usage, durationMs, this.debugMode);
+            }
+            return response;
+        }
+        catch (error) {
+            throw new Error(`${this.providerType} API error: ${error}`);
+        }
+    }
+    /**
+     * Agentic tool loop - NOT IMPLEMENTED for Vercel provider
+     *
+     * This method is intentionally not implemented because:
+     * 1. toolLoop() is currently NOT USED anywhere in the codebase (see PRD #136)
+     * 2. JSON-based agentic loops already provide equivalent functionality
+     * 3. No current workflows require SDK-managed tool loops
+     *
+     * If future requirements necessitate toolLoop() for non-Anthropic providers,
+     * this would need to be implemented using Vercel AI SDK's tool calling API.
+     *
+     * See AnthropicProvider.toolLoop() and PRD #136 for implementation reference.
+     */
+    async toolLoop(_config) {
+        if (!this.isInitialized()) {
+            throw new Error(`${this.providerType} provider not initialized`);
+        }
+        throw new Error(`toolLoop() not implemented for ${this.providerType} provider. Use AnthropicProvider for tool-based workflows, or use JSON-based agentic loops (recommended).`);
+    }
+    /**
+     * Single-shot tool calling - NOT IMPLEMENTED for Vercel provider
+     *
+     * Same reasoning as toolLoop(): not currently needed in codebase.
+     * JSON-based approach achieves same functionality without SDK overhead.
+     *
+     * See AnthropicProvider.sendMessageWithTools() for reference implementation.
+     */
+    async sendMessageWithTools(_message, _tools, _toolExecutor, _operation = 'tool-call') {
+        if (!this.isInitialized()) {
+            throw new Error(`${this.providerType} provider not initialized`);
+        }
+        throw new Error(`sendMessageWithTools() not implemented for ${this.providerType} provider. Use AnthropicProvider for tool-based workflows, or use JSON-based approach (recommended).`);
+    }
+}
+exports.VercelProvider = VercelProvider;

package/dist/core/schema.d.ts

@@ -5,6 +5,7 @@
  * Fetches structured OpenAPI schemas from Kubernetes API server and validates manifests
  */
 import { ResourceExplanation } from './discovery';
+import { AIProvider } from './ai-provider.interface';
 export interface FieldConstraints {
     minimum?: number;
     maximum?: number;
@@ -97,9 +98,6 @@ export interface ResourceSolution {
     patternInfluences?: PatternInfluence[];
     usedPatterns?: boolean;
 }
-export interface AIRankingConfig {
-    claudeApiKey: string;
-}
 export interface ClusterOptions {
     namespaces: string[];
     storageClasses: string[];
@@ -151,12 +149,11 @@ export declare class ManifestValidator {
  * ResourceRecommender determines which resources best meet user needs using AI
  */
 export declare class ResourceRecommender {
-    private claudeIntegration;
-    private config;
+    private aiProvider;
     private patternService?;
     private capabilityService?;
     private policyService?;
-    constructor(config: AIRankingConfig);
+    constructor(aiProvider?: AIProvider);
     /**
      * Find the best resource solution(s) for user intent using two-phase analysis
      */
@@ -239,7 +236,7 @@ export declare class ResourceRecommender {
         .replace('{patterns}', patternsContext);
   
   
-      const response = await this.claudeIntegration.sendMessage(selectionPrompt, 'resource-selection');
+      const response = await this.aiProvider.sendMessage(selectionPrompt, 'resource-selection');
       
       try {
         // Extract JSON from response with robust parsing