agentic-flow 1.2.7 → 1.3.1

package/dist/proxy/anthropic-to-openrouter.js

@@ -3,16 +3,28 @@
 import express from 'express';
 import { logger } from '../utils/logger.js';
 import { getMaxTokensForModel } from './provider-instructions.js';
+import { detectModelCapabilities } from '../utils/modelCapabilities.js';
+import { ToolEmulator, executeEmulation } from './tool-emulation.js';
 export class AnthropicToOpenRouterProxy {
     app;
     openrouterApiKey;
     openrouterBaseUrl;
     defaultModel;
+    capabilities;
     constructor(config) {
         this.app = express();
         this.openrouterApiKey = config.openrouterApiKey;
         this.openrouterBaseUrl = config.openrouterBaseUrl || 'https://openrouter.ai/api/v1';
         this.defaultModel = config.defaultModel || 'meta-llama/llama-3.1-8b-instruct';
+        this.capabilities = config.capabilities;
+        // Debug logging
+        if (this.capabilities) {
+            logger.info('Proxy initialized with capabilities', {
+                model: this.defaultModel,
+                requiresEmulation: this.capabilities.requiresEmulation,
+                strategy: this.capabilities.emulationStrategy
+            });
+        }
         this.setupMiddleware();
         this.setupRoutes();
     }
@@ -66,99 +78,10 @@ export class AnthropicToOpenRouterProxy {
                             : JSON.stringify(firstMsg.content).substring(0, 200)
                     });
                 }
-                // Convert Anthropic format to OpenAI format
-                const openaiReq = this.convertAnthropicToOpenAI(anthropicReq);
-                // VERBOSE LOGGING: Log converted OpenAI request
-                logger.info('=== CONVERTED OPENAI REQUEST ===', {
-                    anthropicModel: anthropicReq.model,
-                    openaiModel: openaiReq.model,
-                    messageCount: openaiReq.messages.length,
-                    systemPrompt: openaiReq.messages[0]?.content?.substring(0, 300),
-                    toolCount: openaiReq.tools?.length || 0,
-                    toolNames: openaiReq.tools?.map(t => t.function.name) || [],
-                    maxTokens: openaiReq.max_tokens,
-                    apiKeyPresent: !!this.openrouterApiKey,
-                    apiKeyPrefix: this.openrouterApiKey?.substring(0, 10)
-                });
-                // Forward to OpenRouter
-                const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
-                    method: 'POST',
-                    headers: {
-                        'Authorization': `Bearer ${this.openrouterApiKey}`,
-                        'Content-Type': 'application/json',
-                        'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
-                        'X-Title': 'Agentic Flow'
-                    },
-                    body: JSON.stringify(openaiReq)
-                });
-                if (!response.ok) {
-                    const error = await response.text();
-                    logger.error('OpenRouter API error', { status: response.status, error });
-                    return res.status(response.status).json({
-                        error: {
-                            type: 'api_error',
-                            message: error
-                        }
-                    });
-                }
-                // VERBOSE LOGGING: Log OpenRouter response status
-                logger.info('=== OPENROUTER RESPONSE RECEIVED ===', {
-                    status: response.status,
-                    statusText: response.statusText,
-                    headers: Object.fromEntries(response.headers.entries())
-                });
-                // Handle streaming vs non-streaming
-                if (anthropicReq.stream) {
-                    logger.info('Handling streaming response...');
-                    // Stream response
-                    res.setHeader('Content-Type', 'text/event-stream');
-                    res.setHeader('Cache-Control', 'no-cache');
-                    res.setHeader('Connection', 'keep-alive');
-                    const reader = response.body?.getReader();
-                    if (!reader) {
-                        throw new Error('No response body');
-                    }
-                    const decoder = new TextDecoder();
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        const chunk = decoder.decode(value);
-                        const anthropicChunk = this.convertOpenAIStreamToAnthropic(chunk);
-                        res.write(anthropicChunk);
-                    }
-                    res.end();
-                }
-                else {
-                    logger.info('Handling non-streaming response...');
-                    // Non-streaming response
-                    const openaiRes = await response.json();
-                    // VERBOSE LOGGING: Log raw OpenAI response
-                    logger.info('=== RAW OPENAI RESPONSE ===', {
-                        id: openaiRes.id,
-                        model: openaiRes.model,
-                        choices: openaiRes.choices?.length,
-                        finishReason: openaiRes.choices?.[0]?.finish_reason,
-                        hasToolCalls: !!(openaiRes.choices?.[0]?.message?.tool_calls),
-                        toolCallCount: openaiRes.choices?.[0]?.message?.tool_calls?.length || 0,
-                        toolCallNames: openaiRes.choices?.[0]?.message?.tool_calls?.map((tc) => tc.function.name) || [],
-                        contentPreview: openaiRes.choices?.[0]?.message?.content?.substring(0, 300),
-                        usage: openaiRes.usage
-                    });
-                    const anthropicRes = this.convertOpenAIToAnthropic(openaiRes);
-                    // VERBOSE LOGGING: Log converted Anthropic response
-                    logger.info('=== CONVERTED ANTHROPIC RESPONSE ===', {
-                        id: anthropicRes.id,
-                        model: anthropicRes.model,
-                        role: anthropicRes.role,
-                        stopReason: anthropicRes.stop_reason,
-                        contentBlocks: anthropicRes.content?.length,
-                        contentTypes: anthropicRes.content?.map((c) => c.type),
-                        toolUseCount: anthropicRes.content?.filter((c) => c.type === 'tool_use').length,
-                        textPreview: anthropicRes.content?.find((c) => c.type === 'text')?.text?.substring(0, 200),
-                        usage: anthropicRes.usage
-                    });
-                    res.json(anthropicRes);
+                // Route to appropriate handler based on capabilities
+                const result = await this.handleRequest(anthropicReq, res);
+                if (result) {
+                    res.json(result);
                 }
             }
             catch (error) {
@@ -182,6 +105,168 @@ export class AnthropicToOpenRouterProxy {
             });
         });
     }
+    async handleRequest(anthropicReq, res) {
+        let model = anthropicReq.model || this.defaultModel;
+        // If SDK is requesting a Claude model but we're using OpenRouter with a different default,
+        // override to use the CLI-specified model
+        if (model.startsWith('claude-') && this.defaultModel && !this.defaultModel.startsWith('claude-')) {
+            logger.info(`Overriding SDK Claude model ${model} with CLI-specified ${this.defaultModel}`);
+            model = this.defaultModel;
+            anthropicReq.model = model;
+        }
+        const capabilities = this.capabilities || detectModelCapabilities(model);
+        // Check if emulation is required
+        if (capabilities.requiresEmulation && anthropicReq.tools && anthropicReq.tools.length > 0) {
+            logger.info(`Using tool emulation for model: ${model}`);
+            return this.handleEmulatedRequest(anthropicReq, capabilities);
+        }
+        return this.handleNativeRequest(anthropicReq, res);
+    }
+    async handleNativeRequest(anthropicReq, res) {
+        // Convert Anthropic format to OpenAI format
+        const openaiReq = this.convertAnthropicToOpenAI(anthropicReq);
+        // VERBOSE LOGGING: Log converted OpenAI request
+        logger.info('=== CONVERTED OPENAI REQUEST ===', {
+            anthropicModel: anthropicReq.model,
+            openaiModel: openaiReq.model,
+            messageCount: openaiReq.messages.length,
+            systemPrompt: openaiReq.messages[0]?.content?.substring(0, 300),
+            toolCount: openaiReq.tools?.length || 0,
+            toolNames: openaiReq.tools?.map(t => t.function.name) || [],
+            maxTokens: openaiReq.max_tokens,
+            apiKeyPresent: !!this.openrouterApiKey,
+            apiKeyPrefix: this.openrouterApiKey?.substring(0, 10)
+        });
+        // Forward to OpenRouter
+        const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.openrouterApiKey}`,
+                'Content-Type': 'application/json',
+                'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
+                'X-Title': 'Agentic Flow'
+            },
+            body: JSON.stringify(openaiReq)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            logger.error('OpenRouter API error', { status: response.status, error });
+            res.status(response.status).json({
+                error: {
+                    type: 'api_error',
+                    message: error
+                }
+            });
+            return null;
+        }
+        // VERBOSE LOGGING: Log OpenRouter response status
+        logger.info('=== OPENROUTER RESPONSE RECEIVED ===', {
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries())
+        });
+        // Handle streaming vs non-streaming
+        if (anthropicReq.stream) {
+            logger.info('Handling streaming response...');
+            // Stream response
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('No response body');
+            }
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value);
+                const anthropicChunk = this.convertOpenAIStreamToAnthropic(chunk);
+                res.write(anthropicChunk);
+            }
+            res.end();
+            return null; // Already sent response
+        }
+        else {
+            logger.info('Handling non-streaming response...');
+            // Non-streaming response
+            const openaiRes = await response.json();
+            // VERBOSE LOGGING: Log raw OpenAI response
+            logger.info('=== RAW OPENAI RESPONSE ===', {
+                id: openaiRes.id,
+                model: openaiRes.model,
+                choices: openaiRes.choices?.length,
+                finishReason: openaiRes.choices?.[0]?.finish_reason,
+                hasToolCalls: !!(openaiRes.choices?.[0]?.message?.tool_calls),
+                toolCallCount: openaiRes.choices?.[0]?.message?.tool_calls?.length || 0,
+                toolCallNames: openaiRes.choices?.[0]?.message?.tool_calls?.map((tc) => tc.function.name) || [],
+                contentPreview: openaiRes.choices?.[0]?.message?.content?.substring(0, 300),
+                usage: openaiRes.usage
+            });
+            const anthropicRes = this.convertOpenAIToAnthropic(openaiRes);
+            // VERBOSE LOGGING: Log converted Anthropic response
+            logger.info('=== CONVERTED ANTHROPIC RESPONSE ===', {
+                id: anthropicRes.id,
+                model: anthropicRes.model,
+                role: anthropicRes.role,
+                stopReason: anthropicRes.stop_reason,
+                contentBlocks: anthropicRes.content?.length,
+                contentTypes: anthropicRes.content?.map((c) => c.type),
+                toolUseCount: anthropicRes.content?.filter((c) => c.type === 'tool_use').length,
+                textPreview: anthropicRes.content?.find((c) => c.type === 'text')?.text?.substring(0, 200),
+                usage: anthropicRes.usage
+            });
+            return anthropicRes;
+        }
+    }
+    async handleEmulatedRequest(anthropicReq, capabilities) {
+        const emulator = new ToolEmulator(anthropicReq.tools || [], capabilities.emulationStrategy);
+        const lastMessage = anthropicReq.messages[anthropicReq.messages.length - 1];
+        const userMessage = typeof lastMessage.content === 'string'
+            ? lastMessage.content
+            : (lastMessage.content.find(c => c.type === 'text')?.text || '');
+        const result = await executeEmulation(emulator, userMessage, async (prompt) => {
+            // Call model with emulation prompt
+            const openaiReq = {
+                model: anthropicReq.model || this.defaultModel,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: anthropicReq.temperature,
+                max_tokens: anthropicReq.max_tokens
+            };
+            const response = await this.callOpenRouter(openaiReq);
+            return response.choices[0].message.content;
+        }, async (toolCall) => {
+            logger.warn(`Tool execution not yet implemented: ${toolCall.name}`);
+            return { error: 'Tool execution not implemented in Phase 2' };
+        }, { maxIterations: 5, verbose: process.env.VERBOSE === 'true' });
+        return {
+            id: `emulated_${Date.now()}`,
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'text', text: result.finalAnswer || 'No response' }],
+            model: anthropicReq.model || this.defaultModel,
+            stop_reason: 'end_turn',
+            usage: { input_tokens: 0, output_tokens: 0 }
+        };
+    }
+    async callOpenRouter(openaiReq) {
+        const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.openrouterApiKey}`,
+                'Content-Type': 'application/json',
+                'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
+                'X-Title': 'Agentic Flow'
+            },
+            body: JSON.stringify(openaiReq)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenRouter API error: ${error}`);
+        }
+        return response.json();
+    }
     convertAnthropicToOpenAI(anthropicReq) {
         logger.info('=== STARTING ANTHROPIC TO OPENAI CONVERSION ===');
         const messages = [];
@@ -507,7 +592,12 @@ export class AnthropicToOpenRouterProxy {
             });
             console.log(`\n✅ Anthropic Proxy running at http://localhost:${port}`);
             console.log(`   OpenRouter Base URL: ${this.openrouterBaseUrl}`);
-            console.log(`   Default Model: ${this.defaultModel}\n`);
+            console.log(`   Default Model: ${this.defaultModel}`);
+            if (this.capabilities?.requiresEmulation) {
+                console.log(`\n   ⚙️  Tool Emulation: ${this.capabilities.emulationStrategy.toUpperCase()} pattern`);
+                console.log(`   📊 Expected reliability: ${this.capabilities.emulationStrategy === 'react' ? '70-85%' : '50-70%'}`);
+            }
+            console.log('');
         });
     }
 }