agentic-flow 2.0.2 → 2.0.4

package/dist/proxy/http3-proxy-old.js

@@ -1,331 +0,0 @@
-/**
- * HTTP/3 (QUIC) Proxy for LLM Streaming
- *
- * Features:
- * - Zero RTT: Faster connection establishment (50-70% faster than HTTP/2)
- * - No head-of-line blocking: Independent streams
- * - Better mobile: Handles network switches gracefully
- * - Built-in encryption: TLS 1.3 mandatory
- * - Leverages existing QUIC transport implementation
- *
- * Performance: 50-70% faster than HTTP/2, 70-80% faster than HTTP/1.1
- */
-import { QuicTransport } from '../transport/quic.js';
-import { logger } from '../utils/logger.js';
-export class HTTP3Proxy {
-    transport;
-    config;
-    isRunning = false;
-    constructor(config) {
-        this.config = config;
-        this.transport = new QuicTransport({
-            host: 'localhost',
-            port: config.port,
-            cert: config.cert,
-            key: config.key,
-            alpn: ['h3'], // HTTP/3 ALPN identifier
-            maxConcurrentStreams: config.maxConcurrentStreams || 100
-        });
-        logger.info('HTTP/3 proxy created', {
-            port: config.port,
-            maxStreams: config.maxConcurrentStreams
-        });
-    }
-    async start() {
-        try {
-            await this.transport.listen();
-            this.isRunning = true;
-            // Handle incoming QUIC streams
-            this.transport.on('stream', async (stream) => {
-                try {
-                    const headers = await this.readHeaders(stream);
-                    const path = headers[':path'];
-                    const method = headers[':method'];
-                    logger.debug('HTTP/3 stream request', { path, method });
-                    if (path === '/v1/messages' && method === 'POST') {
-                        await this.handleMessagesRequest(stream, headers);
-                    }
-                    else if (path === '/health') {
-                        await this.handleHealthCheck(stream);
-                    }
-                    else {
-                        await this.sendErrorResponse(stream, 404, 'Not Found');
-                    }
-                }
-                catch (error) {
-                    logger.error('HTTP/3 stream error', { error: error.message });
-                    await this.sendErrorResponse(stream, 500, error.message);
-                }
-            });
-            this.transport.on('error', (error) => {
-                logger.error('HTTP/3 transport error', { error: error.message });
-            });
-            logger.info('HTTP/3 proxy started', {
-                port: this.config.port,
-                protocol: 'HTTP/3 (QUIC)',
-                url: `https://localhost:${this.config.port}`
-            });
-            console.log(`\n✅ HTTP/3 (QUIC) Proxy running at https://localhost:${this.config.port}`);
-            console.log(`   Protocol: HTTP/3 over QUIC (50-70% faster than HTTP/2)`);
-            console.log(`   Features: Zero RTT, No HOL blocking, Mobile-optimized\n`);
-        }
-        catch (error) {
-            logger.error('Failed to start HTTP/3 proxy', { error: error.message });
-            throw error;
-        }
-    }
-    async readHeaders(stream) {
-        // Read HTTP/3 headers from QUIC stream
-        // This is a simplified implementation - real HTTP/3 uses QPACK compression
-        const headerData = await stream.read();
-        if (!headerData) {
-            return {};
-        }
-        try {
-            // For simplicity, assume JSON-encoded headers
-            // Real HTTP/3 would use QPACK binary format
-            return JSON.parse(headerData.toString());
-        }
-        catch {
-            // Fallback: parse basic HTTP-style headers
-            const lines = headerData.toString().split('\r\n');
-            const headers = {};
-            for (const line of lines) {
-                const [key, ...valueParts] = line.split(': ');
-                if (key && valueParts.length > 0) {
-                    headers[key.toLowerCase()] = valueParts.join(': ');
-                }
-            }
-            return headers;
-        }
-    }
-    async handleHealthCheck(stream) {
-        await stream.writeHeaders({
-            ':status': '200',
-            'content-type': 'application/json'
-        });
-        await stream.write(JSON.stringify({
-            status: 'ok',
-            service: 'http3-proxy',
-            protocol: 'HTTP/3',
-            transport: 'QUIC'
-        }));
-        await stream.end();
-    }
-    async handleMessagesRequest(stream, headers) {
-        try {
-            // Read request body from QUIC stream
-            const bodyData = await stream.read();
-            const anthropicReq = JSON.parse(bodyData.toString());
-            logger.info('HTTP/3 messages request', {
-                model: anthropicReq.model,
-                stream: anthropicReq.stream,
-                messageCount: anthropicReq.messages?.length
-            });
-            // Convert Anthropic format to Gemini format
-            const geminiReq = this.convertAnthropicToGemini(anthropicReq);
-            // Determine endpoint
-            const endpoint = anthropicReq.stream ? 'streamGenerateContent' : 'generateContent';
-            const streamParam = anthropicReq.stream ? '&alt=sse' : '';
-            const geminiBaseUrl = this.config.geminiBaseUrl || 'https://generativelanguage.googleapis.com/v1beta';
-            const url = `${geminiBaseUrl}/models/gemini-2.0-flash-exp:${endpoint}?key=${this.config.geminiApiKey}${streamParam}`;
-            // Forward to Gemini
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(geminiReq)
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                logger.error('Gemini API error', { status: response.status, error });
-                await this.sendErrorResponse(stream, response.status, error);
-                return;
-            }
-            // Handle streaming vs non-streaming
-            if (anthropicReq.stream) {
-                // Stream response over QUIC
-                await stream.writeHeaders({
-                    ':status': '200',
-                    'content-type': 'text/event-stream',
-                    'cache-control': 'no-cache'
-                });
-                const reader = response.body?.getReader();
-                if (!reader) {
-                    throw new Error('No response body');
-                }
-                const decoder = new TextDecoder();
-                let chunkCount = 0;
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    const chunk = decoder.decode(value);
-                    chunkCount++;
-                    const anthropicChunk = this.convertGeminiStreamToAnthropic(chunk);
-                    await stream.write(anthropicChunk);
-                }
-                logger.info('HTTP/3 stream complete', { totalChunks: chunkCount });
-                await stream.end();
-            }
-            else {
-                // Non-streaming response
-                const geminiRes = await response.json();
-                const anthropicRes = this.convertGeminiToAnthropic(geminiRes);
-                await stream.writeHeaders({
-                    ':status': '200',
-                    'content-type': 'application/json'
-                });
-                await stream.write(JSON.stringify(anthropicRes));
-                await stream.end();
-            }
-        }
-        catch (error) {
-            logger.error('HTTP/3 request error', { error: error.message });
-            await this.sendErrorResponse(stream, 500, error.message);
-        }
-    }
-    async sendErrorResponse(stream, status, message) {
-        try {
-            await stream.writeHeaders({
-                ':status': status.toString(),
-                'content-type': 'application/json'
-            });
-            await stream.write(JSON.stringify({
-                error: {
-                    type: 'proxy_error',
-                    message
-                }
-            }));
-            await stream.end();
-        }
-        catch (error) {
-            logger.error('Failed to send error response', { error: error.message });
-        }
-    }
-    convertAnthropicToGemini(anthropicReq) {
-        const contents = [];
-        let systemPrefix = '';
-        if (anthropicReq.system) {
-            systemPrefix = `System: ${anthropicReq.system}\n\n`;
-        }
-        for (let i = 0; i < anthropicReq.messages.length; i++) {
-            const msg = anthropicReq.messages[i];
-            let text;
-            if (typeof msg.content === 'string') {
-                text = msg.content;
-            }
-            else if (Array.isArray(msg.content)) {
-                text = msg.content
-                    .filter((block) => block.type === 'text')
-                    .map((block) => block.text)
-                    .join('\n');
-            }
-            else {
-                text = '';
-            }
-            if (i === 0 && msg.role === 'user' && systemPrefix) {
-                text = systemPrefix + text;
-            }
-            contents.push({
-                role: msg.role === 'assistant' ? 'model' : 'user',
-                parts: [{ text }]
-            });
-        }
-        const geminiReq = { contents };
-        if (anthropicReq.temperature !== undefined || anthropicReq.max_tokens !== undefined) {
-            geminiReq.generationConfig = {};
-            if (anthropicReq.temperature !== undefined) {
-                geminiReq.generationConfig.temperature = anthropicReq.temperature;
-            }
-            if (anthropicReq.max_tokens !== undefined) {
-                geminiReq.generationConfig.maxOutputTokens = anthropicReq.max_tokens;
-            }
-        }
-        return geminiReq;
-    }
-    convertGeminiStreamToAnthropic(chunk) {
-        const lines = chunk.split('\n').filter(line => line.trim());
-        const anthropicChunks = [];
-        for (const line of lines) {
-            try {
-                if (line.startsWith('data: ')) {
-                    const jsonStr = line.substring(6);
-                    const parsed = JSON.parse(jsonStr);
-                    const candidate = parsed.candidates?.[0];
-                    const text = candidate?.content?.parts?.[0]?.text;
-                    if (text) {
-                        anthropicChunks.push(`event: content_block_delta\ndata: ${JSON.stringify({
-                            type: 'content_block_delta',
-                            delta: { type: 'text_delta', text }
-                        })}\n\n`);
-                    }
-                    if (candidate?.finishReason) {
-                        anthropicChunks.push('event: message_stop\ndata: {}\n\n');
-                    }
-                }
-            }
-            catch (e) {
-                logger.debug('Failed to parse stream chunk', { line });
-            }
-        }
-        return anthropicChunks.join('');
-    }
-    convertGeminiToAnthropic(geminiRes) {
-        const candidate = geminiRes.candidates?.[0];
-        if (!candidate) {
-            throw new Error('No candidates in Gemini response');
-        }
-        const content = candidate.content;
-        const parts = content?.parts || [];
-        let rawText = '';
-        for (const part of parts) {
-            if (part.text) {
-                rawText += part.text;
-            }
-        }
-        return {
-            id: `msg_${Date.now()}`,
-            type: 'message',
-            role: 'assistant',
-            model: 'gemini-2.0-flash-exp',
-            content: [
-                {
-                    type: 'text',
-                    text: rawText
-                }
-            ],
-            stop_reason: 'end_turn',
-            usage: {
-                input_tokens: geminiRes.usageMetadata?.promptTokenCount || 0,
-                output_tokens: geminiRes.usageMetadata?.candidatesTokenCount || 0
-            }
-        };
-    }
-    async stop() {
-        if (this.isRunning) {
-            await this.transport.close();
-            this.isRunning = false;
-            logger.info('HTTP/3 proxy stopped');
-        }
-    }
-}
-// CLI entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-    const port = parseInt(process.env.PORT || '4433');
-    const geminiApiKey = process.env.GOOGLE_GEMINI_API_KEY;
-    if (!geminiApiKey) {
-        console.error('❌ Error: GOOGLE_GEMINI_API_KEY environment variable required');
-        process.exit(1);
-    }
-    const proxy = new HTTP3Proxy({
-        port,
-        geminiApiKey,
-        cert: process.env.TLS_CERT || './certs/cert.pem',
-        key: process.env.TLS_KEY || './certs/key.pem',
-        geminiBaseUrl: process.env.GEMINI_BASE_URL
-    });
-    proxy.start().catch((error) => {
-        console.error('❌ Failed to start HTTP/3 proxy:', error);
-        process.exit(1);
-    });
-}