agentic-flow 2.0.1 → 2.0.2-alpha

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

@@ -1,439 +0,0 @@
-// Anthropic to Gemini Proxy Server
-// Converts Anthropic API format to Google Gemini format
-import express from 'express';
-import { logger } from '../utils/logger.js';
-export class AnthropicToGeminiProxy {
-    constructor(config) {
-        this.app = express();
-        this.geminiApiKey = config.geminiApiKey;
-        this.geminiBaseUrl = config.geminiBaseUrl || 'https://generativelanguage.googleapis.com/v1beta';
-        this.defaultModel = config.defaultModel || 'gemini-2.0-flash-exp';
-        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('Gemini 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-gemini-proxy' });
-        });
-        // Anthropic Messages API → Gemini generateContent
-        this.app.post('/v1/messages', async (req, res) => {
-            try {
-                const anthropicReq = req.body;
-                // Convert Anthropic format to Gemini format
-                const geminiReq = this.convertAnthropicToGemini(anthropicReq);
-                logger.info('Converting Anthropic request to Gemini', {
-                    anthropicModel: anthropicReq.model,
-                    geminiModel: this.defaultModel,
-                    messageCount: geminiReq.contents.length,
-                    stream: anthropicReq.stream,
-                    apiKeyPresent: !!this.geminiApiKey,
-                    apiKeyPrefix: this.geminiApiKey?.substring(0, 10)
-                });
-                // Determine endpoint based on streaming
-                const endpoint = anthropicReq.stream ? 'streamGenerateContent' : 'generateContent';
-                const url = `${this.geminiBaseUrl}/models/${this.defaultModel}:${endpoint}?key=${this.geminiApiKey}`;
-                // 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 });
-                    return res.status(response.status).json({
-                        error: {
-                            type: 'api_error',
-                            message: error
-                        }
-                    });
-                }
-                // Handle streaming vs non-streaming
-                if (anthropicReq.stream) {
-                    // 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();
-                    let chunkCount = 0;
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        const chunk = decoder.decode(value);
-                        chunkCount++;
-                        logger.info('Gemini stream chunk received', { chunkCount, chunkLength: chunk.length, chunkPreview: chunk.substring(0, 200) });
-                        const anthropicChunk = this.convertGeminiStreamToAnthropic(chunk);
-                        logger.info('Anthropic stream chunk generated', { chunkCount, anthropicLength: anthropicChunk.length, anthropicPreview: anthropicChunk.substring(0, 200) });
-                        res.write(anthropicChunk);
-                    }
-                    logger.info('Gemini stream complete', { totalChunks: chunkCount });
-                    res.end();
-                }
-                else {
-                    // Non-streaming response
-                    const geminiRes = await response.json();
-                    // DEBUG: Log raw Gemini response
-                    logger.info('Raw Gemini API response', {
-                        hasResponse: !!geminiRes,
-                        hasCandidates: !!geminiRes.candidates,
-                        candidatesLength: geminiRes.candidates?.length,
-                        firstCandidate: geminiRes.candidates?.[0],
-                        fullResponse: JSON.stringify(geminiRes).substring(0, 500)
-                    });
-                    const anthropicRes = this.convertGeminiToAnthropic(geminiRes);
-                    logger.info('Gemini proxy response sent', {
-                        model: this.defaultModel,
-                        usage: anthropicRes.usage,
-                        contentBlocks: anthropicRes.content?.length,
-                        hasText: anthropicRes.content?.some((c) => c.type === 'text'),
-                        firstContent: anthropicRes.content?.[0]
-                    });
-                    res.json(anthropicRes);
-                }
-            }
-            catch (error) {
-                logger.error('Gemini 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 Gemini proxy`
-                }
-            });
-        });
-    }
-    convertAnthropicToGemini(anthropicReq) {
-        const contents = [];
-        // Add system message as first user message if present
-        // Gemini doesn't have a dedicated system role, so we prepend it to the first user message
-        let systemPrefix = '';
-        if (anthropicReq.system) {
-            systemPrefix = `System: ${anthropicReq.system}\n\n`;
-        }
-        // Add tool instructions for Gemini to understand file operations
-        // Since Gemini doesn't have native tool calling, we instruct it to use structured XML-like commands
-        const toolInstructions = `
-IMPORTANT: You have access to file system operations through structured commands. Use these exact formats:
-
-<file_write path="filename.ext">
-content here
-</file_write>
-
-<file_read path="filename.ext"/>
-
-<bash_command>
-command here
-</bash_command>
-
-When you need to create, edit, or read files, use these structured commands in your response.
-The system will automatically execute these commands and provide results.
-
-`;
-        // Prepend tool instructions to system prompt
-        if (systemPrefix) {
-            systemPrefix = toolInstructions + systemPrefix;
-        }
-        else {
-            systemPrefix = toolInstructions;
-        }
-        // Convert Anthropic messages to Gemini format
-        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)) {
-                // Extract text from content blocks
-                text = msg.content
-                    .filter(block => block.type === 'text')
-                    .map(block => block.text)
-                    .join('\n');
-            }
-            else {
-                text = '';
-            }
-            // Add system prefix to first user message
-            if (i === 0 && msg.role === 'user' && systemPrefix) {
-                text = systemPrefix + text;
-            }
-            contents.push({
-                role: msg.role === 'assistant' ? 'model' : 'user',
-                parts: [{ text }]
-            });
-        }
-        const geminiReq = {
-            contents
-        };
-        // Add generation config if temperature or max_tokens specified
-        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;
-            }
-        }
-        // Convert MCP/Anthropic tools to Gemini tools format
-        if (anthropicReq.tools && anthropicReq.tools.length > 0) {
-            geminiReq.tools = [{
-                    functionDeclarations: anthropicReq.tools.map(tool => {
-                        // Clean schema: Remove $schema and additionalProperties fields that Gemini doesn't support
-                        const cleanSchema = (schema) => {
-                            if (!schema || typeof schema !== 'object')
-                                return schema;
-                            const { $schema, additionalProperties, ...rest } = schema;
-                            const cleaned = { ...rest };
-                            // Recursively clean nested objects
-                            if (cleaned.properties) {
-                                cleaned.properties = Object.fromEntries(Object.entries(cleaned.properties).map(([key, value]) => [
-                                    key,
-                                    cleanSchema(value)
-                                ]));
-                            }
-                            // Clean items if present
-                            if (cleaned.items) {
-                                cleaned.items = cleanSchema(cleaned.items);
-                            }
-                            return cleaned;
-                        };
-                        return {
-                            name: tool.name,
-                            description: tool.description || '',
-                            parameters: cleanSchema(tool.input_schema) || {
-                                type: 'object',
-                                properties: {},
-                                required: []
-                            }
-                        };
-                    })
-                }];
-            logger.info('Forwarding MCP tools to Gemini', {
-                toolCount: anthropicReq.tools.length,
-                toolNames: anthropicReq.tools.map(t => t.name)
-            });
-        }
-        return geminiReq;
-    }
-    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 };
-    }
-    convertGeminiToAnthropic(geminiRes) {
-        const candidate = geminiRes.candidates?.[0];
-        if (!candidate) {
-            logger.error('No candidates in Gemini response', { geminiRes });
-            throw new Error('No candidates in Gemini response');
-        }
-        const content = candidate.content;
-        const parts = content?.parts || [];
-        logger.info('Converting Gemini to Anthropic', {
-            hasParts: !!parts,
-            partsCount: parts.length,
-            partTypes: parts.map((p) => Object.keys(p))
-        });
-        // Extract text and function calls
-        let rawText = '';
-        const functionCalls = [];
-        for (const part of parts) {
-            if (part.text) {
-                rawText += part.text;
-                logger.info('Found text in part', { textLength: part.text.length, textPreview: part.text.substring(0, 100) });
-            }
-            if (part.functionCall) {
-                functionCalls.push(part.functionCall);
-            }
-        }
-        logger.info('Extracted content from Gemini', {
-            rawTextLength: rawText.length,
-            functionCallsCount: functionCalls.length,
-            rawTextPreview: rawText.substring(0, 200)
-        });
-        // Parse structured commands from Gemini's text response
-        const { cleanText, toolUses } = this.parseStructuredCommands(rawText);
-        // Build content array with text and tool uses
-        const contentBlocks = [];
-        if (cleanText) {
-            contentBlocks.push({
-                type: 'text',
-                text: cleanText
-            });
-        }
-        // Add tool uses from structured commands
-        contentBlocks.push(...toolUses);
-        // Add tool uses from Gemini function calls (MCP tools)
-        if (functionCalls.length > 0) {
-            for (const functionCall of functionCalls) {
-                contentBlocks.push({
-                    type: 'tool_use',
-                    id: `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                    name: functionCall.name,
-                    input: functionCall.args || {}
-                });
-            }
-            logger.info('Converted Gemini function calls to Anthropic format', {
-                functionCallCount: functionCalls.length,
-                functionNames: functionCalls.map((fc) => fc.name)
-            });
-        }
-        return {
-            id: `msg_${Date.now()}`,
-            type: 'message',
-            role: 'assistant',
-            model: this.defaultModel,
-            content: contentBlocks.length > 0 ? contentBlocks : [
-                {
-                    type: 'text',
-                    text: rawText
-                }
-            ],
-            stop_reason: this.mapFinishReason(candidate.finishReason),
-            usage: {
-                input_tokens: geminiRes.usageMetadata?.promptTokenCount || 0,
-                output_tokens: geminiRes.usageMetadata?.candidatesTokenCount || 0
-            }
-        };
-    }
-    convertGeminiStreamToAnthropic(chunk) {
-        // Gemini streaming returns Server-Sent Events format: "data: {json}"
-        const lines = chunk.split('\n').filter(line => line.trim());
-        const anthropicChunks = [];
-        for (const line of lines) {
-            try {
-                // Parse SSE format: "data: {json}"
-                if (line.startsWith('data: ')) {
-                    const jsonStr = line.substring(6); // Remove "data: " prefix
-                    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`);
-                    }
-                    // Check for finish
-                    if (candidate?.finishReason) {
-                        anthropicChunks.push('event: message_stop\ndata: {}\n\n');
-                    }
-                }
-            }
-            catch (e) {
-                // Ignore parse errors
-                logger.debug('Failed to parse Gemini stream chunk', { line, error: e.message });
-            }
-        }
-        return anthropicChunks.join('');
-    }
-    mapFinishReason(reason) {
-        const mapping = {
-            'STOP': 'end_turn',
-            'MAX_TOKENS': 'max_tokens',
-            'SAFETY': 'stop_sequence',
-            'RECITATION': 'stop_sequence',
-            'OTHER': 'end_turn'
-        };
-        return mapping[reason || 'STOP'] || 'end_turn';
-    }
-    start(port) {
-        this.app.listen(port, () => {
-            logger.info('Anthropic to Gemini proxy started', {
-                port,
-                geminiBaseUrl: this.geminiBaseUrl,
-                defaultModel: this.defaultModel
-            });
-            console.log(`\n✅ Gemini Proxy running at http://localhost:${port}`);
-            console.log(`   Gemini Base URL: ${this.geminiBaseUrl}`);
-            console.log(`   Default Model: ${this.defaultModel}\n`);
-        });
-    }
-}
-// CLI entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-    const port = parseInt(process.env.PORT || '3001');
-    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 AnthropicToGeminiProxy({
-        geminiApiKey,
-        geminiBaseUrl: process.env.GEMINI_BASE_URL,
-        defaultModel: process.env.COMPLETION_MODEL || process.env.REASONING_MODEL
-    });
-    proxy.start(port);
-}

package/dist/proxy/quic-proxy.d.ts

@@ -1,57 +0,0 @@
-import { QuicConfig } from '../transport/quic.js';
-import { AnthropicToOpenRouterProxy } from './anthropic-to-openrouter.js';
-export interface QuicProxyConfig {
-    openrouterApiKey: string;
-    openrouterBaseUrl?: string;
-    defaultModel?: string;
-    transport?: 'quic' | 'http2' | 'auto';
-    enableQuic?: boolean;
-    quic?: QuicConfig;
-    fallbackToHttp2?: boolean;
-    fallbackTimeout?: number;
-}
-export declare class QuicEnabledProxy extends AnthropicToOpenRouterProxy {
-    private quicClient?;
-    private quicPool?;
-    private transport;
-    private quicEnabled;
-    private fallbackToHttp2;
-    constructor(config: QuicProxyConfig);
-    /**
-     * Check if QUIC is enabled via environment variable
-     */
-    private checkQuicFeatureFlag;
-    /**
-     * Initialize QUIC client and connection pool
-     */
-    private initializeQuic;
-    /**
-     * Select transport protocol based on configuration and availability
-     */
-    private selectTransport;
-    /**
-     * Send request using selected transport
-     */
-    protected sendRequest(url: string, options: RequestInit): Promise<Response>;
-    /**
-     * Send request over QUIC
-     */
-    private sendQuicRequest;
-    /**
-     * Send request over HTTP/2 (standard fetch)
-     */
-    private sendHttp2Request;
-    /**
-     * Get transport statistics
-     */
-    getTransportStats(): any;
-    /**
-     * Shutdown and cleanup
-     */
-    shutdown(): Promise<void>;
-}
-/**
- * Create QUIC-enabled proxy with configuration
- */
-export declare function createQuicProxy(config: QuicProxyConfig): QuicEnabledProxy;
-//# sourceMappingURL=quic-proxy.d.ts.map

package/dist/proxy/quic-proxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quic-proxy.d.ts","sourceRoot":"","sources":["../../src/proxy/quic-proxy.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkC,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElF,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,MAAM,WAAW,eAAe;IAE9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACtC,UAAU,CAAC,EAAE,OAAO,CAAC;IAGrB,IAAI,CAAC,EAAE,UAAU,CAAC;IAGlB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,gBAAiB,SAAQ,0BAA0B;IAC9D,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAqB;IACtC,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,eAAe,CAAU;gBAErB,MAAM,EAAE,eAAe;IAgBnC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAK5B;;OAEG;YACW,cAAc;IAsB5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAiBvB;;OAEG;cACa,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgBjF;;OAEG;YACW,eAAe;IA0E7B;;OAEG;YACW,gBAAgB;IAK9B;;OAEG;IACH,iBAAiB,IAAI,GAAG;IAexB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAWhC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CAUzE"}