agentic-flow 1.1.5 → 1.1.8

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

@@ -0,0 +1,345 @@
+// 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 {
+    app;
+    geminiApiKey;
+    geminiBaseUrl;
+    defaultModel;
+    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();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const chunk = decoder.decode(value);
+                        const anthropicChunk = this.convertGeminiStreamToAnthropic(chunk);
+                        res.write(anthropicChunk);
+                    }
+                    res.end();
+                }
+                else {
+                    // Non-streaming response
+                    const geminiRes = await response.json();
+                    const anthropicRes = this.convertGeminiToAnthropic(geminiRes);
+                    logger.info('Gemini proxy response sent', {
+                        model: this.defaultModel,
+                        usage: anthropicRes.usage
+                    });
+                    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;
+            }
+        }
+        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) {
+            throw new Error('No candidates in Gemini response');
+        }
+        const content = candidate.content;
+        const rawText = content?.parts?.map((part) => part.text).join('') || '';
+        // Parse structured commands from Gemini's 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
+        contentBlocks.push(...toolUses);
+        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 newline-delimited JSON
+        const lines = chunk.split('\n').filter(line => line.trim());
+        const anthropicChunks = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                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
+            }
+        }
+        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/anthropic-to-openrouter.js

@@ -2,6 +2,7 @@
 // Converts Anthropic API format to OpenRouter format
 import express from 'express';
 import { logger } from '../utils/logger.js';
+import { getInstructionsForModel, formatInstructions } from './provider-instructions.js';
 export class AnthropicToOpenRouterProxy {
     app;
     openrouterApiKey;
@@ -42,7 +43,9 @@ export class AnthropicToOpenRouterProxy {
                 logger.info('Converting Anthropic request to OpenRouter', {
                     anthropicModel: anthropicReq.model,
                     openaiModel: openaiReq.model,
-                    messageCount: openaiReq.messages.length
+                    messageCount: openaiReq.messages.length,
+                    apiKeyPresent: !!this.openrouterApiKey,
+                    apiKeyPrefix: this.openrouterApiKey?.substring(0, 10)
                 });
                 // Forward to OpenRouter
                 const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
@@ -120,13 +123,20 @@ export class AnthropicToOpenRouterProxy {
     }
     convertAnthropicToOpenAI(anthropicReq) {
         const messages = [];
-        // Add system message if present
+        // Get model-specific tool instructions
+        const modelId = anthropicReq.model || this.defaultModel;
+        const provider = this.extractProvider(modelId);
+        const instructions = getInstructionsForModel(modelId, provider);
+        const toolInstructions = formatInstructions(instructions);
+        // Add system message with optimized tool instructions
+        let systemContent = toolInstructions;
         if (anthropicReq.system) {
-            messages.push({
-                role: 'system',
-                content: anthropicReq.system
-            });
+            systemContent += '\n\n' + anthropicReq.system;
         }
+        messages.push({
+            role: 'system',
+            content: systemContent
+        });
         // Override model - if request has a Claude model, use defaultModel instead
         const requestedModel = anthropicReq.model || '';
         const shouldOverrideModel = requestedModel.startsWith('claude-') || !requestedModel;
@@ -160,20 +170,79 @@ export class AnthropicToOpenRouterProxy {
             stream: anthropicReq.stream
         };
     }
+    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 rawText = choice.message?.content || choice.text || '';
+        // Parse structured commands from model's 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
+        contentBlocks.push(...toolUses);
         return {
             id: openaiRes.id || `msg_${Date.now()}`,
             type: 'message',
             role: 'assistant',
             model: openaiRes.model,
-            content: [
+            content: contentBlocks.length > 0 ? contentBlocks : [
                 {
                     type: 'text',
-                    text: choice.message?.content || choice.text || ''
+                    text: rawText
                 }
             ],
             stop_reason: this.mapFinishReason(choice.finish_reason),
@@ -211,6 +280,11 @@ export class AnthropicToOpenRouterProxy {
         }
         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',

package/dist/proxy/provider-instructions.js

@@ -0,0 +1,198 @@
+// Provider-specific and model-specific tool instructions
+// Optimized for different LLM families to improve tool calling success rate
+// Base structured command format (works for most models)
+export const BASE_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+Example: Create a file
+<file_write path="hello.js">
+function hello() {
+  console.log("Hello!");
+}
+</file_write>
+`,
+    emphasis: 'IMPORTANT: Use these structured commands in your response. The system will automatically execute them.'
+};
+// Anthropic models - Native tool calling, minimal instructions needed
+export const ANTHROPIC_INSTRUCTIONS = {
+    format: 'native',
+    commands: {
+        write: 'Use Write tool with file_path and content parameters',
+        read: 'Use Read tool with file_path parameter',
+        bash: 'Use Bash tool with command parameter'
+    },
+    emphasis: 'You have native access to file system tools. Use them directly.'
+};
+// OpenAI/GPT models - Prefer function calling style
+export const OPENAI_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+When you need to create a file, respond with:
+<file_write path="example.txt">
+File content here
+</file_write>
+
+The system will create the file for you.
+`,
+    emphasis: 'CRITICAL: You must use these exact XML tag formats. Do not just describe the file - actually use the tags.'
+};
+// Google/Gemini models - Detailed, explicit instructions
+export const GOOGLE_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+Step-by-step file creation:
+1. Determine the filename
+2. Write the content
+3. Use this exact format:
+
+<file_write path="your_file.txt">
+Your content here
+</file_write>
+
+The file will be automatically created.
+`,
+    emphasis: 'IMPORTANT: Always use the XML tags. Just writing code blocks will NOT create files. You MUST use <file_write> tags.'
+};
+// Meta/Llama models - Clear, concise instructions
+export const META_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+To create files, use:
+<file_write path="file.txt">content</file_write>
+
+To read files, use:
+<file_read path="file.txt"/>
+
+To run commands, use:
+<bash_command>ls -la</bash_command>
+`,
+    emphasis: 'Use these tags to perform actual file operations. Code blocks alone will not create files.'
+};
+// DeepSeek models - Technical, precise instructions
+export const DEEPSEEK_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+File system operations use XML-like structured commands:
+
+<file_write path="example.py">
+def main():
+    print("Hello")
+</file_write>
+
+These commands are parsed and executed by the system.
+`,
+    emphasis: 'Use structured commands for file I/O. Standard code blocks are for display only.'
+};
+// Mistral models - Direct, action-oriented
+export const MISTRAL_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+ACTION REQUIRED: To create actual files, you must use these tags:
+
+<file_write path="file.txt">
+content
+</file_write>
+
+Do not just show code - use the tags to create real files.
+`,
+    emphasis: 'CRITICAL: File operations require XML tags. Code blocks alone will not create files on disk.'
+};
+// X.AI/Grok models - Balanced, clear instructions
+export const XAI_INSTRUCTIONS = {
+    format: 'xml',
+    commands: {
+        write: '<file_write path="filename.ext">\ncontent here\n</file_write>',
+        read: '<file_read path="filename.ext"/>',
+        bash: '<bash_command>\ncommand here\n</bash_command>'
+    },
+    examples: `
+File system commands:
+- Create: <file_write path="file.txt">content</file_write>
+- Read: <file_read path="file.txt"/>
+- Execute: <bash_command>command</bash_command>
+`,
+    emphasis: 'Use structured commands to interact with the file system.'
+};
+// Map provider/model patterns to instruction sets
+export function getInstructionsForModel(modelId, provider) {
+    const normalizedModel = modelId.toLowerCase();
+    // Anthropic models - native tool calling
+    if (normalizedModel.includes('claude') || provider === 'anthropic') {
+        return ANTHROPIC_INSTRUCTIONS;
+    }
+    // OpenAI models
+    if (normalizedModel.includes('gpt') || normalizedModel.includes('openai') || provider === 'openai') {
+        return OPENAI_INSTRUCTIONS;
+    }
+    // Google/Gemini models
+    if (normalizedModel.includes('gemini') || normalizedModel.includes('gemma') || provider === 'google') {
+        return GOOGLE_INSTRUCTIONS;
+    }
+    // Meta/Llama models
+    if (normalizedModel.includes('llama') || provider === 'meta-llama' || provider === 'meta') {
+        return META_INSTRUCTIONS;
+    }
+    // DeepSeek models
+    if (normalizedModel.includes('deepseek') || provider === 'deepseek') {
+        return DEEPSEEK_INSTRUCTIONS;
+    }
+    // Mistral models
+    if (normalizedModel.includes('mistral') || provider === 'mistralai') {
+        return MISTRAL_INSTRUCTIONS;
+    }
+    // X.AI/Grok models
+    if (normalizedModel.includes('grok') || provider === 'x-ai') {
+        return XAI_INSTRUCTIONS;
+    }
+    // Qwen models
+    if (normalizedModel.includes('qwen')) {
+        return DEEPSEEK_INSTRUCTIONS; // Similar to DeepSeek
+    }
+    // Default to base instructions
+    return BASE_INSTRUCTIONS;
+}
+// Generate formatted instruction string for injection
+export function formatInstructions(instructions) {
+    if (instructions.format === 'native') {
+        return `${instructions.emphasis}\n\n${instructions.commands.write}\n${instructions.commands.read}\n${instructions.commands.bash}`;
+    }
+    let formatted = `${instructions.emphasis}\n\n`;
+    formatted += `Available commands:\n`;
+    formatted += `${instructions.commands.write}\n`;
+    formatted += `${instructions.commands.read}\n`;
+    formatted += `${instructions.commands.bash}\n`;
+    if (instructions.examples) {
+        formatted += `\n${instructions.examples}`;
+    }
+    return formatted;
+}

package/docs/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}

package/docs/.claude-flow/metrics/performance.json

@@ -0,0 +1,9 @@
+{
+  "startTime": 1759642689232,
+  "totalTasks": 1,
+  "successfulTasks": 1,
+  "failedTasks": 0,
+  "totalAgents": 0,
+  "activeAgents": 0,
+  "neuralEvents": 0
+}