agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/agentic-flow/src/proxy/anthropic-to-requesty.js

@@ -0,0 +1,712 @@
+// Anthropic to Requesty Proxy Server
+// Converts Anthropic API format to Requesty format
+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 AnthropicToRequestyProxy {
+    app;
+    requestyApiKey;
+    requestyBaseUrl;
+    defaultModel;
+    capabilities;
+    constructor(config) {
+        this.app = express();
+        this.requestyApiKey = config.requestyApiKey;
+        this.requestyBaseUrl = config.requestyBaseUrl || 'https://router.requesty.ai/v1';
+        this.defaultModel = config.defaultModel || 'deepseek/deepseek-chat';
+        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();
+    }
+    setupMiddleware() {
+        // Parse JSON bodies
+        this.app.use(express.json({ limit: '50mb' }));
+        // Logging middleware
+        this.app.use((req, res, next) => {
+            logger.debug('Proxy request', {
+                method: req.method,
+                path: req.path,
+                headers: Object.keys(req.headers)
+            });
+            next();
+        });
+    }
+    setupRoutes() {
+        // Health check
+        this.app.get('/health', (req, res) => {
+            res.json({ status: 'ok', service: 'anthropic-to-requesty-proxy' });
+        });
+        // Anthropic Messages API → Requesty Chat Completions
+        this.app.post('/v1/messages', async (req, res) => {
+            console.log('🔵 REQUEST RECEIVED AT PROXY - /v1/messages');
+            logger.info('🔵 REQUEST RECEIVED AT PROXY - /v1/messages');
+            try {
+                const anthropicReq = req.body;
+                console.log('🔵 Request body parsed successfully');
+                // VERBOSE LOGGING: Log incoming Anthropic request
+                // Handle system prompt which can be string OR array of content blocks
+                const systemPreview = typeof anthropicReq.system === 'string'
+                    ? anthropicReq.system.substring(0, 200)
+                    : Array.isArray(anthropicReq.system)
+                        ? JSON.stringify(anthropicReq.system).substring(0, 200)
+                        : undefined;
+                logger.info('=== INCOMING ANTHROPIC REQUEST ===', {
+                    model: anthropicReq.model,
+                    systemPrompt: systemPreview,
+                    systemType: typeof anthropicReq.system,
+                    messageCount: anthropicReq.messages?.length,
+                    toolCount: anthropicReq.tools?.length || 0,
+                    toolNames: anthropicReq.tools?.map(t => t.name) || [],
+                    maxTokens: anthropicReq.max_tokens,
+                    temperature: anthropicReq.temperature,
+                    stream: anthropicReq.stream
+                });
+                // Log first user message for debugging
+                if (anthropicReq.messages && anthropicReq.messages.length > 0) {
+                    const firstMsg = anthropicReq.messages[0];
+                    logger.info('First user message:', {
+                        role: firstMsg.role,
+                        contentPreview: typeof firstMsg.content === 'string'
+                            ? firstMsg.content.substring(0, 200)
+                            : JSON.stringify(firstMsg.content).substring(0, 200)
+                    });
+                }
+                // Route to appropriate handler based on capabilities
+                const result = await this.handleRequest(anthropicReq, res);
+                if (result) {
+                    res.json(result);
+                }
+            }
+            catch (error) {
+                logger.error('Proxy error', { error: error.message, stack: error.stack });
+                res.status(500).json({
+                    error: {
+                        type: 'proxy_error',
+                        message: error.message
+                    }
+                });
+            }
+        });
+        // Fallback for other Anthropic API endpoints
+        this.app.use((req, res) => {
+            logger.warn('Unsupported endpoint', { path: req.path, method: req.method });
+            res.status(404).json({
+                error: {
+                    type: 'not_found',
+                    message: `Endpoint ${req.path} not supported by proxy`
+                }
+            });
+        });
+    }
+    async handleRequest(anthropicReq, res) {
+        let model = anthropicReq.model || this.defaultModel;
+        // If SDK is requesting a Claude model but we're using Requesty 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.requestyApiKey,
+            apiKeyPrefix: this.requestyApiKey?.substring(0, 10)
+        });
+        // Forward to Requesty
+        const response = await fetch(`${this.requestyBaseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.requestyApiKey}`,
+                '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('Requesty API error', { status: response.status, error });
+            res.status(response.status).json({
+                error: {
+                    type: 'api_error',
+                    message: error
+                }
+            });
+            return null;
+        }
+        // VERBOSE LOGGING: Log Requesty response status
+        const headerEntries = [];
+        response.headers.forEach((value, key) => {
+            headerEntries.push([key, value]);
+        });
+        logger.info('=== REQUESTY RESPONSE RECEIVED ===', {
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(headerEntries)
+        });
+        // 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
+            // Cap max_tokens at 8192 for OpenAI models via Requesty
+            let maxTokens = anthropicReq.max_tokens;
+            if (maxTokens && maxTokens > 8192) {
+                maxTokens = 8192;
+            }
+            const openaiReq = {
+                model: anthropicReq.model || this.defaultModel,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: anthropicReq.temperature,
+                max_tokens: maxTokens
+            };
+            const response = await this.callRequesty(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 callRequesty(openaiReq) {
+        // Add timeout for Requesty API calls (60 seconds)
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 60000);
+        try {
+            const response = await fetch(`${this.requestyBaseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.requestyApiKey}`,
+                    'Content-Type': 'application/json',
+                    'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
+                    'X-Title': 'Agentic Flow'
+                },
+                body: JSON.stringify(openaiReq),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`Requesty API error: ${error}`);
+            }
+            return response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error('Requesty API request timed out after 60 seconds');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Sanitize JSON Schema to be OpenAI-compatible
+     * Fixes array properties without items, removes unsupported keywords
+     */
+    sanitizeJsonSchema(schema, path = 'root') {
+        if (!schema || typeof schema !== 'object') {
+            return schema;
+        }
+        // Create a shallow copy to avoid mutations
+        const sanitized = { ...schema };
+        // Fix array types without items
+        if (sanitized.type === 'array' && !sanitized.items) {
+            logger.warn(`Schema sanitization: Adding missing 'items' for array at ${path}`);
+            sanitized.items = { type: 'string' };
+        }
+        // Remove JSON Schema 2020-12 keywords not supported by OpenAI
+        const unsupportedKeywords = [
+            '$schema', '$id', '$ref', '$defs', 'definitions',
+            'if', 'then', 'else', 'dependentSchemas', 'dependentRequired',
+            'prefixItems', 'unevaluatedItems', 'unevaluatedProperties',
+            'minContains', 'maxContains', 'patternProperties',
+            'additionalItems', 'contains'
+        ];
+        for (const keyword of unsupportedKeywords) {
+            if (keyword in sanitized) {
+                logger.warn(`Schema sanitization: Removing unsupported keyword '${keyword}' at ${path}`);
+                delete sanitized[keyword];
+            }
+        }
+        // Recursively sanitize nested properties
+        if (sanitized.properties && typeof sanitized.properties === 'object') {
+            sanitized.properties = {};
+            for (const [key, value] of Object.entries(schema.properties)) {
+                sanitized.properties[key] = this.sanitizeJsonSchema(value, `${path}.properties.${key}`);
+            }
+        }
+        // Recursively sanitize array items
+        if (sanitized.items && typeof sanitized.items === 'object') {
+            sanitized.items = this.sanitizeJsonSchema(sanitized.items, `${path}.items`);
+        }
+        // Recursively sanitize allOf, anyOf, oneOf
+        for (const combinator of ['allOf', 'anyOf', 'oneOf']) {
+            if (Array.isArray(sanitized[combinator])) {
+                sanitized[combinator] = sanitized[combinator].map((subschema, index) => this.sanitizeJsonSchema(subschema, `${path}.${combinator}[${index}]`));
+            }
+        }
+        return sanitized;
+    }
+    convertAnthropicToOpenAI(anthropicReq) {
+        logger.info('=== STARTING ANTHROPIC TO OPENAI CONVERSION ===');
+        const messages = [];
+        // Get model-specific tool instructions
+        const modelId = anthropicReq.model || this.defaultModel;
+        const provider = this.extractProvider(modelId);
+        logger.info('Model detection:', {
+            requestedModel: anthropicReq.model,
+            defaultModel: this.defaultModel,
+            finalModelId: modelId,
+            extractedProvider: provider
+        });
+        // CRITICAL: Requesty models use native OpenAI tool calling
+        // - If MCP tools are provided, Requesty handles them via function calling
+        // - Do NOT inject XML instructions - they cause malformed output
+        // - Let Requesty models use tools via OpenAI's tool_calls format
+        let systemContent = '';
+        // Check if we have MCP tools (function calling)
+        const hasMcpTools = anthropicReq.tools && anthropicReq.tools.length > 0;
+        logger.info('Tool detection:', {
+            hasMcpTools,
+            toolCount: anthropicReq.tools?.length || 0,
+            toolNames: anthropicReq.tools?.map(t => t.name) || []
+        });
+        if (hasMcpTools) {
+            // MCP tools present - Requesty will handle via function calling
+            systemContent = 'You are a helpful AI assistant. When you need to perform actions, use the available tools by calling functions. Always explain what you\'re doing.';
+            logger.info('Using MCP tools system prompt (with function calling support)');
+        }
+        else {
+            // No tools - simple response mode
+            systemContent = 'You are a helpful AI assistant. Provide clear, well-formatted code and explanations.';
+            logger.info('Using simple system prompt (no tools)');
+        }
+        if (anthropicReq.system) {
+            // System can be string OR array of content blocks
+            let originalSystem;
+            if (typeof anthropicReq.system === 'string') {
+                originalSystem = anthropicReq.system;
+            }
+            else if (Array.isArray(anthropicReq.system)) {
+                // Extract text from content blocks
+                originalSystem = anthropicReq.system
+                    .filter(block => block.type === 'text' && block.text)
+                    .map(block => block.text)
+                    .join('\n');
+            }
+            else {
+                originalSystem = '';
+            }
+            logger.info('Appending original system prompt:', {
+                systemType: typeof anthropicReq.system,
+                isArray: Array.isArray(anthropicReq.system),
+                originalSystemLength: originalSystem.length,
+                originalSystemPreview: originalSystem.substring(0, 200)
+            });
+            if (originalSystem) {
+                systemContent += '\n\n' + originalSystem;
+            }
+        }
+        messages.push({
+            role: 'system',
+            content: systemContent
+        });
+        logger.info('System message created:', {
+            systemContentLength: systemContent.length,
+            systemContentPreview: systemContent.substring(0, 300)
+        });
+        // Override model - if request has a Claude model, use defaultModel instead
+        const requestedModel = anthropicReq.model || '';
+        const shouldOverrideModel = requestedModel.startsWith('claude-') || !requestedModel;
+        const finalModel = shouldOverrideModel ? this.defaultModel : requestedModel;
+        // Convert Anthropic messages to OpenAI format
+        for (const msg of anthropicReq.messages) {
+            let content;
+            if (typeof msg.content === 'string') {
+                content = msg.content;
+            }
+            else if (Array.isArray(msg.content)) {
+                // Extract text from content blocks
+                content = msg.content
+                    .filter(block => block.type === 'text')
+                    .map(block => block.text)
+                    .join('\n');
+            }
+            else {
+                content = '';
+            }
+            messages.push({
+                role: msg.role,
+                content
+            });
+        }
+        // Get appropriate max_tokens for this model
+        let maxTokens = getMaxTokensForModel(finalModel, anthropicReq.max_tokens);
+        // Cap at 8192 for OpenAI models via Requesty
+        if (maxTokens && maxTokens > 8192) {
+            maxTokens = 8192;
+        }
+        const openaiReq = {
+            model: finalModel,
+            messages,
+            max_tokens: maxTokens,
+            temperature: anthropicReq.temperature,
+            stream: anthropicReq.stream
+        };
+        // Convert MCP/Anthropic tools to OpenAI tools format
+        if (anthropicReq.tools && anthropicReq.tools.length > 0) {
+            logger.info('Converting MCP tools to OpenAI format...', {
+                totalTools: anthropicReq.tools.length
+            });
+            // Requesty has strict limits - only send a subset of tools to avoid timeouts
+            // Requesty also rejects empty tools arrays, so we either send tools or omit the parameter
+            const MAX_TOOLS_FOR_REQUESTY = 10; // Very conservative limit - Requesty timeouts with more
+            const toolsToConvert = anthropicReq.tools.slice(0, MAX_TOOLS_FOR_REQUESTY);
+            if (anthropicReq.tools.length > MAX_TOOLS_FOR_REQUESTY) {
+                logger.warn(`Limiting tools to ${MAX_TOOLS_FOR_REQUESTY} for Requesty (${anthropicReq.tools.length} available)`);
+            }
+            // Only set tools if we have at least one (Requesty rejects empty arrays)
+            if (toolsToConvert.length > 0) {
+                openaiReq.tools = toolsToConvert.map(tool => {
+                    // Sanitize the input schema to fix array properties without items
+                    const rawSchema = tool.input_schema || {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    };
+                    const sanitizedSchema = this.sanitizeJsonSchema(rawSchema, `tool.${tool.name}`);
+                    const openaiTool = {
+                        type: 'function',
+                        function: {
+                            name: tool.name,
+                            description: tool.description || '',
+                            parameters: sanitizedSchema
+                        }
+                    };
+                    return openaiTool;
+                });
+                logger.info('Forwarding MCP tools to Requesty', {
+                    toolCount: openaiReq.tools.length,
+                    toolNames: openaiReq.tools.map(t => t.function.name).slice(0, 5)
+                });
+            }
+            else {
+                logger.info('No tools to send (omitting tools parameter entirely for Requesty)');
+                // Don't set openaiReq.tools at all - Requesty rejects empty arrays
+            }
+        }
+        else {
+            logger.info('No MCP tools to convert');
+        }
+        logger.info('=== CONVERSION COMPLETE ===', {
+            messageCount: openaiReq.messages.length,
+            hasMcpTools: !!openaiReq.tools,
+            toolCount: openaiReq.tools?.length || 0,
+            maxTokens: openaiReq.max_tokens,
+            model: openaiReq.model
+        });
+        return openaiReq;
+    }
+    parseStructuredCommands(text) {
+        const toolUses = [];
+        let cleanText = text;
+        // Parse file_write commands
+        const fileWriteRegex = /<file_write path="([^"]+)">([\s\S]*?)<\/file_write>/g;
+        let match;
+        while ((match = fileWriteRegex.exec(text)) !== null) {
+            toolUses.push({
+                type: 'tool_use',
+                id: `tool_${Date.now()}_${toolUses.length}`,
+                name: 'Write',
+                input: {
+                    file_path: match[1],
+                    content: match[2].trim()
+                }
+            });
+            cleanText = cleanText.replace(match[0], `[File written: ${match[1]}]`);
+        }
+        // Parse file_read commands
+        const fileReadRegex = /<file_read path="([^"]+)"\/>/g;
+        while ((match = fileReadRegex.exec(text)) !== null) {
+            toolUses.push({
+                type: 'tool_use',
+                id: `tool_${Date.now()}_${toolUses.length}`,
+                name: 'Read',
+                input: {
+                    file_path: match[1]
+                }
+            });
+            cleanText = cleanText.replace(match[0], `[Reading file: ${match[1]}]`);
+        }
+        // Parse bash commands
+        const bashRegex = /<bash_command>([\s\S]*?)<\/bash_command>/g;
+        while ((match = bashRegex.exec(text)) !== null) {
+            toolUses.push({
+                type: 'tool_use',
+                id: `tool_${Date.now()}_${toolUses.length}`,
+                name: 'Bash',
+                input: {
+                    command: match[1].trim()
+                }
+            });
+            cleanText = cleanText.replace(match[0], `[Executing: ${match[1].trim()}]`);
+        }
+        return { cleanText: cleanText.trim(), toolUses };
+    }
+    convertOpenAIToAnthropic(openaiRes) {
+        const choice = openaiRes.choices?.[0];
+        if (!choice) {
+            throw new Error('No choices in OpenAI response');
+        }
+        const message = choice.message || {};
+        const rawText = message.content || choice.text || '';
+        const toolCalls = message.tool_calls || [];
+        logger.info('=== CONVERTING OPENAI TO ANTHROPIC ===', {
+            hasMessage: !!message,
+            hasContent: !!rawText,
+            contentLength: rawText?.length,
+            hasToolCalls: toolCalls.length > 0,
+            toolCallCount: toolCalls.length,
+            finishReason: choice.finish_reason
+        });
+        // CRITICAL: Use ONLY native OpenAI tool_calls format
+        // Do NOT parse XML from text - models output malformed XML
+        // Requesty handles tools via OpenAI function calling standard
+        const contentBlocks = [];
+        // Add tool uses from OpenAI tool_calls (MCP tools via function calling)
+        if (toolCalls.length > 0) {
+            logger.info('Processing tool calls from OpenAI response...');
+            for (const toolCall of toolCalls) {
+                try {
+                    logger.info('Tool call details:', {
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        argumentsRaw: toolCall.function.arguments
+                    });
+                    contentBlocks.push({
+                        type: 'tool_use',
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input: JSON.parse(toolCall.function.arguments || '{}')
+                    });
+                }
+                catch (error) {
+                    logger.error('Failed to parse tool call arguments', {
+                        toolCall,
+                        error: error.message
+                    });
+                }
+            }
+            logger.info('Converted Requesty tool calls to Anthropic format', {
+                toolCallCount: toolCalls.length,
+                toolNames: toolCalls.map((tc) => tc.function.name)
+            });
+        }
+        // Add text response if present
+        if (rawText && rawText.trim()) {
+            logger.info('Adding text content block', {
+                textLength: rawText.length,
+                textPreview: rawText.substring(0, 200)
+            });
+            contentBlocks.push({
+                type: 'text',
+                text: rawText
+            });
+        }
+        // If no content blocks, add empty text
+        if (contentBlocks.length === 0) {
+            logger.warn('No content blocks found, adding empty text block');
+            contentBlocks.push({
+                type: 'text',
+                text: rawText || ''
+            });
+        }
+        logger.info('Final content blocks:', {
+            blockCount: contentBlocks.length,
+            blockTypes: contentBlocks.map(b => b.type)
+        });
+        const result = {
+            id: openaiRes.id || `msg_${Date.now()}`,
+            type: 'message',
+            role: 'assistant',
+            model: openaiRes.model,
+            content: contentBlocks,
+            stop_reason: this.mapFinishReason(choice.finish_reason),
+            usage: {
+                input_tokens: openaiRes.usage?.prompt_tokens || 0,
+                output_tokens: openaiRes.usage?.completion_tokens || 0
+            }
+        };
+        logger.info('Conversion complete, returning Anthropic response');
+        return result;
+    }
+    convertOpenAIStreamToAnthropic(chunk) {
+        // Convert OpenAI SSE format to Anthropic SSE format
+        const lines = chunk.split('\n').filter(line => line.trim());
+        const anthropicChunks = [];
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                if (data === '[DONE]') {
+                    anthropicChunks.push('event: message_stop\ndata: {}\n\n');
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(data);
+                    const delta = parsed.choices?.[0]?.delta;
+                    if (delta?.content) {
+                        anthropicChunks.push(`event: content_block_delta\ndata: ${JSON.stringify({
+                            type: 'content_block_delta',
+                            delta: { type: 'text_delta', text: delta.content }
+                        })}\n\n`);
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors
+                }
+            }
+        }
+        return anthropicChunks.join('');
+    }
+    extractProvider(modelId) {
+        // Extract provider from model ID (e.g., "openai/gpt-4" -> "openai")
+        const parts = modelId.split('/');
+        return parts.length > 1 ? parts[0] : '';
+    }
+    mapFinishReason(reason) {
+        const mapping = {
+            'stop': 'end_turn',
+            'length': 'max_tokens',
+            'content_filter': 'stop_sequence',
+            'function_call': 'tool_use'
+        };
+        return mapping[reason || 'stop'] || 'end_turn';
+    }
+    start(port) {
+        this.app.listen(port, () => {
+            logger.info('Anthropic to Requesty proxy started', {
+                port,
+                requestyBaseUrl: this.requestyBaseUrl,
+                defaultModel: this.defaultModel
+            });
+            console.log(`\n✅ Anthropic Proxy running at http://localhost:${port}`);
+            console.log(`   Requesty Base URL: ${this.requestyBaseUrl}`);
+            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('');
+        });
+    }
+}
+// CLI entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const port = parseInt(process.env.PORT || '3000');
+    const requestyApiKey = process.env.REQUESTY_API_KEY;
+    if (!requestyApiKey) {
+        console.error('❌ Error: REQUESTY_API_KEY environment variable required');
+        process.exit(1);
+    }
+    const proxy = new AnthropicToRequestyProxy({
+        requestyApiKey,
+        requestyBaseUrl: process.env.ANTHROPIC_PROXY_BASE_URL,
+        defaultModel: process.env.COMPLETION_MODEL || process.env.REASONING_MODEL
+    });
+    proxy.start(port);
+}
+//# sourceMappingURL=anthropic-to-requesty.js.map