agentic-flow 3.0.0-alpha.1 → 3.0.0

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

@@ -1,712 +0,0 @@
-// 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