llmflow 0.3.1

package/providers/anthropic.js

@@ -0,0 +1,195 @@
+const BaseProvider = require('./base');
+
+/**
+ * Anthropic Claude provider.
+ * Handles request/response transformation and different streaming format.
+ */
+class AnthropicProvider extends BaseProvider {
+    constructor(config = {}) {
+        super();
+        this.name = 'anthropic';
+        this.displayName = 'Anthropic Claude';
+        this.hostname = config.hostname || 'api.anthropic.com';
+        this.apiVersion = config.apiVersion || '2023-06-01';
+    }
+
+    getTarget(req) {
+        let path = req.path;
+        
+        // Map OpenAI-style paths to Anthropic paths
+        if (path === '/v1/chat/completions') {
+            path = '/v1/messages';
+        }
+
+        return {
+            hostname: this.hostname,
+            port: 443,
+            path: path,
+            protocol: 'https'
+        };
+    }
+
+    transformRequestHeaders(headers, req) {
+        // Anthropic uses x-api-key instead of Authorization Bearer
+        let apiKey = headers.authorization;
+        if (apiKey && apiKey.startsWith('Bearer ')) {
+            apiKey = apiKey.slice(7);
+        }
+        
+        // Also check for x-api-key header directly
+        apiKey = headers['x-api-key'] || apiKey;
+
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': this.apiVersion
+        };
+    }
+
+    transformRequestBody(body, req) {
+        if (!body || !body.messages) {
+            return body;
+        }
+
+        const transformed = {
+            model: body.model,
+            max_tokens: body.max_tokens || 4096,  // Required field for Anthropic
+            stream: body.stream || false
+        };
+
+        // Extract system message
+        const systemMessages = body.messages.filter(m => m.role === 'system');
+        const otherMessages = body.messages.filter(m => m.role !== 'system');
+
+        if (systemMessages.length > 0) {
+            transformed.system = systemMessages.map(m => m.content).join('\n');
+        }
+
+        // Transform messages (Anthropic expects role to be 'user' or 'assistant')
+        transformed.messages = otherMessages.map(msg => ({
+            role: msg.role === 'assistant' ? 'assistant' : 'user',
+            content: msg.content
+        }));
+
+        // Copy over optional parameters
+        if (body.temperature !== undefined) transformed.temperature = body.temperature;
+        if (body.top_p !== undefined) transformed.top_p = body.top_p;
+        if (body.stop) transformed.stop_sequences = Array.isArray(body.stop) ? body.stop : [body.stop];
+
+        return transformed;
+    }
+
+    normalizeResponse(body, req) {
+        if (!body || body.error) {
+            return { data: body, usage: null, model: req.body?.model };
+        }
+
+        // Extract text content from content blocks
+        let textContent = '';
+        if (Array.isArray(body.content)) {
+            textContent = body.content
+                .filter(block => block.type === 'text')
+                .map(block => block.text)
+                .join('');
+        }
+
+        // Map stop_reason to finish_reason
+        const finishReasonMap = {
+            'end_turn': 'stop',
+            'stop_sequence': 'stop',
+            'max_tokens': 'length'
+        };
+
+        const normalized = {
+            id: body.id,
+            object: 'chat.completion',
+            model: body.model,
+            choices: [{
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: textContent
+                },
+                finish_reason: finishReasonMap[body.stop_reason] || body.stop_reason
+            }],
+            usage: {
+                prompt_tokens: body.usage?.input_tokens || 0,
+                completion_tokens: body.usage?.output_tokens || 0,
+                total_tokens: (body.usage?.input_tokens || 0) + (body.usage?.output_tokens || 0)
+            }
+        };
+
+        return {
+            data: normalized,
+            usage: normalized.usage,
+            model: body.model
+        };
+    }
+
+    parseStreamChunk(chunk) {
+        const lines = chunk.split('\n');
+        let content = '';
+        let usage = null;
+        let done = false;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            
+            // Handle event: lines
+            if (trimmed.startsWith('event:')) {
+                const eventType = trimmed.slice(6).trim();
+                if (eventType === 'message_stop') {
+                    done = true;
+                }
+                continue;
+            }
+
+            if (!trimmed.startsWith('data:')) continue;
+
+            const payload = trimmed.slice(5).trim();
+            if (!payload) continue;
+
+            try {
+                const json = JSON.parse(payload);
+                
+                // Handle different event types
+                if (json.type === 'content_block_delta') {
+                    if (json.delta?.type === 'text_delta') {
+                        content += json.delta.text || '';
+                    }
+                } else if (json.type === 'message_delta') {
+                    if (json.usage) {
+                        usage = {
+                            prompt_tokens: 0, // Not provided in delta
+                            completion_tokens: json.usage.output_tokens || 0,
+                            total_tokens: json.usage.output_tokens || 0
+                        };
+                    }
+                } else if (json.type === 'message_start' && json.message?.usage) {
+                    // Initial usage from message_start
+                    usage = {
+                        prompt_tokens: json.message.usage.input_tokens || 0,
+                        completion_tokens: 0,
+                        total_tokens: json.message.usage.input_tokens || 0
+                    };
+                }
+            } catch {
+                // Ignore parse errors
+            }
+        }
+
+        return { content, usage, done };
+    }
+
+    extractUsage(response) {
+        const usage = response.usage || {};
+        return {
+            prompt_tokens: usage.input_tokens || usage.prompt_tokens || 0,
+            completion_tokens: usage.output_tokens || usage.completion_tokens || 0,
+            total_tokens: (usage.input_tokens || usage.prompt_tokens || 0) + 
+                         (usage.output_tokens || usage.completion_tokens || 0)
+        };
+    }
+}
+
+module.exports = AnthropicProvider;

package/providers/azure.js

@@ -0,0 +1,159 @@
+const BaseProvider = require('./base');
+
+/**
+ * Azure OpenAI provider.
+ * 
+ * Key differences from OpenAI:
+ * - Endpoint: https://{resource}.openai.azure.com/openai/deployments/{deployment}/{endpoint}?api-version={version}
+ * - Uses api-key header instead of Authorization Bearer
+ * - Model name in request is mapped to deployment name in URL
+ * - api-version query parameter is required
+ * - Request/response format is same as OpenAI
+ */
+class AzureOpenAIProvider extends BaseProvider {
+    constructor(config = {}) {
+        super();
+        this.name = 'azure';
+        this.displayName = 'Azure OpenAI';
+        
+        // Azure configuration from environment or config
+        this.resource = config.resource || process.env.AZURE_OPENAI_RESOURCE;
+        this.apiVersion = config.apiVersion || process.env.AZURE_OPENAI_API_VERSION || '2024-02-01';
+        
+        // Optional: deployment name mapping (model -> deployment)
+        this.deploymentMap = config.deploymentMap || {};
+    }
+
+    /**
+     * Map OpenAI model name to Azure deployment name
+     * Azure deployments often have dots removed (gpt-3.5-turbo -> gpt-35-turbo)
+     */
+    getDeploymentName(model) {
+        // Check explicit mapping first
+        if (this.deploymentMap[model]) {
+            return this.deploymentMap[model];
+        }
+        
+        // Check environment variable for specific model
+        const envKey = `AZURE_DEPLOYMENT_${model.replace(/[.-]/g, '_').toUpperCase()}`;
+        if (process.env[envKey]) {
+            return process.env[envKey];
+        }
+        
+        // Default: use model name as deployment (common pattern)
+        // Also try removing dots (gpt-3.5-turbo -> gpt-35-turbo)
+        return model.replace(/\./g, '');
+    }
+
+    /**
+     * Extract Azure resource name from headers or use configured default
+     */
+    getResourceName(headers) {
+        // Allow override via header
+        const headerResource = headers?.['x-azure-resource'] || headers?.['x-llmflow-azure-resource'];
+        if (headerResource) return headerResource;
+        
+        // Use configured resource
+        if (this.resource) return this.resource;
+        
+        // Try environment variable
+        return process.env.AZURE_OPENAI_RESOURCE || 'azure-openai';
+    }
+
+    getTarget(req) {
+        const model = req.body?.model || 'gpt-4';
+        const deployment = this.getDeploymentName(model);
+        const resource = this.getResourceName(req.headers);
+        
+        // Map OpenAI path to Azure path
+        let endpoint = req.path;
+        if (endpoint.startsWith('/v1/')) {
+            endpoint = endpoint.slice(3); // Remove /v1 prefix
+        }
+
+        // Build Azure path: /openai/deployments/{deployment}/{endpoint}?api-version={version}
+        const path = `/openai/deployments/${deployment}${endpoint}?api-version=${this.apiVersion}`;
+
+        return {
+            hostname: `${resource}.openai.azure.com`,
+            port: 443,
+            path: path,
+            protocol: 'https'
+        };
+    }
+
+    transformRequestHeaders(headers, req) {
+        // Azure uses api-key header instead of Authorization Bearer
+        let apiKey = headers?.authorization;
+        if (apiKey && apiKey.startsWith('Bearer ')) {
+            apiKey = apiKey.slice(7);
+        }
+        
+        // Also check for direct api-key header
+        apiKey = headers?.['api-key'] || apiKey;
+
+        return {
+            'Content-Type': 'application/json',
+            'api-key': apiKey
+        };
+    }
+
+    // Request body format is same as OpenAI, no transformation needed
+    transformRequestBody(body, req) {
+        return body;
+    }
+
+    // Response format is same as OpenAI, use base implementation
+    normalizeResponse(body, req) {
+        if (!body || body.error) {
+            return { data: body, usage: null, model: req.body?.model };
+        }
+
+        return {
+            data: body,
+            usage: body.usage || null,
+            model: body.model || req.body?.model || 'unknown'
+        };
+    }
+
+    // Streaming format is same as OpenAI
+    parseStreamChunk(chunk) {
+        const lines = chunk.split('\n');
+        let content = '';
+        let usage = null;
+        let done = false;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data:')) continue;
+
+            const payload = trimmed.slice(5).trim();
+            if (payload === '[DONE]') {
+                done = true;
+                continue;
+            }
+
+            try {
+                const json = JSON.parse(payload);
+                const delta = json.choices?.[0]?.delta?.content;
+                if (delta) content += delta;
+                if (json.usage) usage = json.usage;
+            } catch {
+                // Ignore parse errors
+            }
+        }
+
+        return { content, usage, done };
+    }
+
+    extractUsage(response) {
+        const usage = response.usage || {};
+        return {
+            prompt_tokens: usage.prompt_tokens || 0,
+            completion_tokens: usage.completion_tokens || 0,
+            total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
+        };
+    }
+}
+
+module.exports = AzureOpenAIProvider;

package/providers/base.js

@@ -0,0 +1,145 @@
+/**
+ * Base provider class defining the interface for all LLM providers.
+ * Each provider must implement these methods to handle request/response transformations.
+ */
+class BaseProvider {
+    constructor() {
+        this.name = 'base';
+        this.displayName = 'Base Provider';
+    }
+
+    /**
+     * Get the target configuration for the upstream request
+     * @param {Object} req - Express request object
+     * @returns {Object} { hostname, port, path, protocol }
+     */
+    getTarget(req) {
+        throw new Error('getTarget() must be implemented by provider');
+    }
+
+    /**
+     * Transform request headers for the upstream provider
+     * @param {Object} headers - Original request headers
+     * @param {Object} req - Express request object
+     * @returns {Object} Transformed headers
+     */
+    transformRequestHeaders(headers, req) {
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': headers.authorization
+        };
+    }
+
+    /**
+     * Transform request body for the upstream provider
+     * @param {Object} body - Original request body
+     * @param {Object} req - Express request object
+     * @returns {Object} Transformed body
+     */
+    transformRequestBody(body, req) {
+        return body;
+    }
+
+    /**
+     * Normalize response body to a common format for logging
+     * @param {Object} body - Provider response body
+     * @param {Object} req - Original request for context
+     * @returns {Object} Normalized response with { data, usage, model }
+     */
+    normalizeResponse(body, req) {
+        return {
+            data: body,
+            usage: body.usage || null,
+            model: body.model || req.body?.model || 'unknown'
+        };
+    }
+
+    /**
+     * Parse a streaming chunk and extract content
+     * @param {string} chunk - Raw chunk text
+     * @returns {Object} { content, usage, done }
+     */
+    parseStreamChunk(chunk) {
+        const lines = chunk.split('\n');
+        let content = '';
+        let usage = null;
+        let done = false;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data:')) continue;
+
+            const payload = trimmed.slice(5).trim();
+            if (payload === '[DONE]') {
+                done = true;
+                continue;
+            }
+
+            try {
+                const json = JSON.parse(payload);
+                const delta = json.choices?.[0]?.delta?.content;
+                if (delta) content += delta;
+                if (json.usage) usage = json.usage;
+            } catch {
+                // Ignore parse errors
+            }
+        }
+
+        return { content, usage, done };
+    }
+
+    /**
+     * Assemble a complete response from streaming chunks
+     * @param {string} fullContent - Accumulated content
+     * @param {Object} usage - Token usage info
+     * @param {Object} req - Original request
+     * @param {string} traceId - Trace ID
+     * @returns {Object} Assembled response object
+     */
+    assembleStreamingResponse(fullContent, usage, req, traceId) {
+        return {
+            id: traceId,
+            object: 'chat.completion',
+            model: req.body?.model,
+            choices: [{
+                message: { role: 'assistant', content: fullContent },
+                finish_reason: 'stop'
+            }],
+            usage: usage,
+            _streaming: true
+        };
+    }
+
+    /**
+     * Extract usage information from response
+     * @param {Object} response - Provider response
+     * @returns {Object} { prompt_tokens, completion_tokens, total_tokens }
+     */
+    extractUsage(response) {
+        const usage = response.usage || {};
+        return {
+            prompt_tokens: usage.prompt_tokens || 0,
+            completion_tokens: usage.completion_tokens || 0,
+            total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
+        };
+    }
+
+    /**
+     * Check if streaming is requested
+     * @param {Object} req - Express request object
+     * @returns {boolean}
+     */
+    isStreamingRequest(req) {
+        return req.body && req.body.stream === true;
+    }
+
+    /**
+     * Get the HTTP/HTTPS module to use
+     * @returns {Object} http or https module
+     */
+    getHttpModule() {
+        return require('https');
+    }
+}
+
+module.exports = BaseProvider;