protoagent 0.0.1

package/dist/config/mcp-manager.js

@@ -0,0 +1,240 @@
+/**
+ * MCP (Model Context Protocol) Manager
+ * Handles connections to MCP servers and tool execution
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { DEFAULT_MCP_CONFIG } from './mcp-types.js';
+import path from 'path';
+import fs from 'fs/promises';
+import { getConfigDirectory } from './manager.js';
+export class MCPManager {
+    constructor(config) {
+        this.connections = new Map();
+        this.processes = new Map();
+        this.config = config || DEFAULT_MCP_CONFIG;
+    }
+    /**
+     * Load MCP configuration from file
+     */
+    async loadConfig() {
+        try {
+            const configPath = path.join(getConfigDirectory(), 'mcp-config.json');
+            const configData = await fs.readFile(configPath, 'utf-8');
+            this.config = { ...DEFAULT_MCP_CONFIG, ...JSON.parse(configData) };
+        }
+        catch (error) {
+            // If no config file exists, use defaults
+            console.log('📡 Using default MCP configuration');
+            this.config = DEFAULT_MCP_CONFIG;
+        }
+    }
+    /**
+     * Save MCP configuration to file
+     */
+    async saveConfig() {
+        try {
+            const configPath = path.join(getConfigDirectory(), 'mcp-config.json');
+            await fs.writeFile(configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('❌ Failed to save MCP configuration:', error);
+        }
+    }
+    /**
+     * Connect to a specific MCP server
+     */
+    async connectToServer(serverName) {
+        const serverConfig = this.config.servers[serverName];
+        if (!serverConfig || !serverConfig.enabled) {
+            console.log(`⚠️  Server ${serverName} is not configured or disabled`);
+            return null;
+        }
+        try {
+            console.log(`🔌 Connecting to MCP server: ${serverName}`);
+            // Create transport for stdio communication
+            const transport = new StdioClientTransport({
+                command: serverConfig.command,
+                args: serverConfig.args || [],
+                env: {
+                    ...Object.fromEntries(Object.entries(process.env).filter(([_, v]) => v !== undefined)),
+                    ...serverConfig.env
+                }
+            });
+            // Create MCP client
+            const client = new Client({
+                name: 'protoagent',
+                version: '1.0.0'
+            }, {
+                capabilities: {
+                    tools: {}
+                }
+            });
+            // Connect to the server
+            await client.connect(transport);
+            // Get server capabilities
+            const serverCapabilities = await client.listTools();
+            const capabilities = serverCapabilities.tools.map(tool => tool.name);
+            const connection = {
+                name: serverName,
+                client,
+                capabilities,
+                connected: true
+            };
+            this.connections.set(serverName, connection);
+            console.log(`✅ Connected to ${serverName} with ${capabilities.length} tools`);
+            return connection;
+        }
+        catch (error) {
+            console.error(`❌ Failed to connect to MCP server ${serverName}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Connect to all enabled MCP servers
+     */
+    async connectToAllServers() {
+        console.log('🚀 Initializing MCP connections...');
+        const enabledServers = Object.keys(this.config.servers).filter(name => this.config.servers[name].enabled);
+        if (enabledServers.length === 0) {
+            console.log('ℹ️  No MCP servers enabled');
+            return;
+        }
+        const connectionPromises = enabledServers.map(serverName => this.connectToServer(serverName).catch(error => {
+            console.error(`Failed to connect to ${serverName}:`, error);
+            return null;
+        }));
+        const results = await Promise.all(connectionPromises);
+        const successfulConnections = results.filter(conn => conn !== null);
+        console.log(`📡 MCP Status: ${successfulConnections.length}/${enabledServers.length} servers connected`);
+    }
+    /**
+     * Get all available tools from connected servers
+     */
+    async getAllTools() {
+        const allTools = [];
+        for (const [serverName, connection] of this.connections) {
+            if (!connection.connected)
+                continue;
+            try {
+                const tools = await connection.client.listTools();
+                for (const tool of tools.tools) {
+                    allTools.push({
+                        server: serverName,
+                        name: tool.name,
+                        description: tool.description,
+                        schema: tool.inputSchema
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`❌ Failed to get tools from ${serverName}:`, error);
+            }
+        }
+        return allTools;
+    }
+    /**
+     * Execute a tool on a specific MCP server
+     */
+    async callTool(serverName, toolName, args) {
+        const connection = this.connections.get(serverName);
+        if (!connection || !connection.connected) {
+            throw new Error(`Server ${serverName} is not connected`);
+        }
+        try {
+            console.log(`🛠️  Calling ${serverName}:${toolName}`);
+            const result = await connection.client.callTool({
+                name: toolName,
+                arguments: args
+            });
+            return result;
+        }
+        catch (error) {
+            console.error(`❌ Tool execution failed ${serverName}:${toolName}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Find which server has a specific tool
+     */
+    findToolServer(toolName) {
+        for (const [serverName, connection] of this.connections) {
+            if (connection.capabilities.includes(toolName)) {
+                return serverName;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get connection status
+     */
+    getConnectionStatus() {
+        const status = {};
+        for (const [serverName, connection] of this.connections) {
+            status[serverName] = connection.connected;
+        }
+        return status;
+    }
+    /**
+     * Add a custom MCP server configuration
+     */
+    async addCustomServer(config) {
+        this.config.servers[config.name] = config;
+        await this.saveConfig();
+        console.log(`✅ Added custom MCP server: ${config.name}`);
+    }
+    /**
+     * Remove a custom MCP server
+     */
+    async removeCustomServer(serverName) {
+        const serverConfig = this.config.servers[serverName];
+        if (serverConfig?.isBuiltIn) {
+            throw new Error('Cannot remove built-in MCP servers');
+        }
+        // Disconnect if connected
+        const connection = this.connections.get(serverName);
+        if (connection) {
+            await this.disconnectServer(serverName);
+        }
+        delete this.config.servers[serverName];
+        await this.saveConfig();
+        console.log(`✅ Removed custom MCP server: ${serverName}`);
+    }
+    /**
+     * Disconnect from a specific server
+     */
+    async disconnectServer(serverName) {
+        const connection = this.connections.get(serverName);
+        if (connection) {
+            try {
+                await connection.client.close();
+                connection.connected = false;
+                this.connections.delete(serverName);
+                console.log(`🔌 Disconnected from ${serverName}`);
+            }
+            catch (error) {
+                console.error(`❌ Error disconnecting from ${serverName}:`, error);
+            }
+        }
+    }
+    /**
+     * Disconnect from all servers
+     */
+    async disconnectAll() {
+        console.log('🔌 Disconnecting from all MCP servers...');
+        const disconnectPromises = Array.from(this.connections.keys()).map(serverName => this.disconnectServer(serverName));
+        await Promise.all(disconnectPromises);
+    }
+    /**
+     * Get server configuration
+     */
+    getServerConfig(serverName) {
+        return this.config.servers[serverName] || null;
+    }
+    /**
+     * List all configured servers
+     */
+    listServers() {
+        return { ...this.config.servers };
+    }
+}

package/dist/config/mcp-types.js

@@ -0,0 +1,28 @@
+/**
+ * MCP (Model Context Protocol) configuration types
+ */
+// Built-in server configurations
+export const BUILTIN_MCP_SERVERS = {
+    filesystem: {
+        name: 'filesystem',
+        description: 'File system operations via MCP',
+        command: 'npx',
+        args: ['@modelcontextprotocol/server-filesystem'],
+        enabled: true,
+        isBuiltIn: true
+    },
+    'sequential-thinking': {
+        name: 'sequential-thinking',
+        description: 'Sequential thinking and reasoning tools',
+        command: 'npx',
+        args: ['@modelcontextprotocol/server-sequential-thinking'],
+        enabled: true,
+        isBuiltIn: true
+    }
+};
+export const DEFAULT_MCP_CONFIG = {
+    servers: { ...BUILTIN_MCP_SERVERS },
+    globalTimeout: 30000, // 30 seconds
+    maxConcurrentConnections: 5,
+    retryAttempts: 3
+};

package/dist/config/providers.js

@@ -0,0 +1,170 @@
+/**
+ * OpenAI provider configuration for ProtoAgent
+ */
+export const openaiModels = {
+    models: [
+        'gpt-5-nano-2025-08-07',
+        'gpt-5-mini-2025-08-07',
+        'gpt-5-2025-08-07',
+        'gpt-4o-mini-2024-07-18',
+        'gpt-4o',
+        'gpt-4o-2024-11-20',
+        'gpt-4-turbo',
+        'gpt-3.5-turbo'
+    ],
+    defaultModel: 'gpt-5-mini-2025-08-07'
+};
+export const openaiModelConfigs = {
+    'gpt-5-nano-2025-08-07': {
+        name: 'GPT-5 Nano',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.00000005, outputTokens: 0.0000004 } // $0.05/$0.40 per 1M tokens
+    },
+    'gpt-5-mini-2025-08-07': {
+        name: 'GPT-5 Mini',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.00000025, outputTokens: 0.000002 } // $0.25/$2.00 per 1M tokens
+    },
+    'gpt-5-2025-08-07': {
+        name: 'GPT-5',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.00000125, outputTokens: 0.00001 } // $1.25/$10.00 per 1M tokens
+    },
+    'gpt-4o-mini-2024-07-18': {
+        name: 'GPT-4o Mini',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.00000015, outputTokens: 0.0000006 } // $0.15/$0.60 per 1M tokens
+    },
+    'gpt-4o': {
+        name: 'GPT-4o',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.0000025, outputTokens: 0.00001 } // $2.50/$10.00 per 1M tokens
+    },
+    'gpt-4o-2024-11-20': {
+        name: 'GPT-4o (2024-11-20)',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.0000025, outputTokens: 0.00001 } // $2.50/$10.00 per 1M tokens
+    },
+    'gpt-4-turbo': {
+        name: 'GPT-4 Turbo',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.00001, outputTokens: 0.00003 } // $10.00/$30.00 per 1M tokens
+    },
+    'gpt-3.5-turbo': {
+        name: 'GPT-3.5 Turbo',
+        contextWindow: 16385,
+        pricing: { inputTokens: 0.0000005, outputTokens: 0.0000015 } // $0.50/$1.50 per 1M tokens
+    }
+};
+export const openaiProvider = {
+    id: 'openai',
+    name: 'OpenAI',
+    models: openaiModels.models,
+    defaultModel: 'gpt-5-mini-2025-08-07',
+    modelConfigs: openaiModelConfigs,
+    auth: {
+        type: 'api_key',
+        envVar: 'OPENAI_API_KEY',
+        label: 'OpenAI API Key',
+        helpUrl: 'https://platform.openai.com/api-keys'
+    }
+};
+export const geminiModels = {
+    models: [
+        'models/gemini-2.5-pro',
+        'models/gemini-2.5-flash',
+        'models/gemini-2.5-flash-lite',
+        'models/gemini-2.0-flash',
+        'models/gemini-2.0-flash-lite'
+    ],
+    defaultModel: 'models/gemini-2.5-flash'
+};
+export const geminiModelConfigs = {
+    'models/gemini-2.5-pro': {
+        name: 'Gemini 2.5 Pro',
+        contextWindow: 2000000,
+        pricing: { inputTokens: 0.00000125, outputTokens: 0.00001 } // $1.25/$10.00 per 1M tokens (<=200k prompts)
+    },
+    'models/gemini-2.5-flash': {
+        name: 'Gemini 2.5 Flash',
+        contextWindow: 1000000,
+        pricing: { inputTokens: 0.0000003, outputTokens: 0.0000025 } // $0.30/$2.50 per 1M tokens
+    },
+    'models/gemini-2.5-flash-lite': {
+        name: 'Gemini 2.5 Flash Lite',
+        contextWindow: 1000000,
+        pricing: { inputTokens: 0.0000001, outputTokens: 0.0000004 } // $0.10/$0.40 per 1M tokens
+    },
+    'models/gemini-2.0-flash': {
+        name: 'Gemini 2.0 Flash',
+        contextWindow: 1000000,
+        pricing: { inputTokens: 0.0000001, outputTokens: 0.0000004 } // $0.10/$0.40 per 1M tokens (text/image/video)
+    },
+    'models/gemini-2.0-flash-lite': {
+        name: 'Gemini 2.0 Flash Lite',
+        contextWindow: 1000000,
+        pricing: { inputTokens: 0.000000075, outputTokens: 0.0000003 } // $0.075/$0.30 per 1M tokens
+    }
+};
+export const geminiProvider = {
+    id: 'gemini',
+    name: 'Gemini',
+    models: geminiModels.models,
+    defaultModel: geminiModels.defaultModel,
+    modelConfigs: geminiModelConfigs,
+    auth: {
+        type: 'api_key',
+        envVar: 'GEMINI_API_KEY',
+        label: 'Gemini API Key',
+        helpUrl: 'https://aistudio.google.com/app/apikey'
+    },
+    baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/'
+};
+export const cerebrasModels = {
+    models: [
+        'gpt-oss-120b',
+        'qwen-3-coder-480b'
+    ],
+    defaultModel: 'gpt-oss-120b'
+};
+export const cerebrasModelConfigs = {
+    'gpt-oss-120b': {
+        name: 'GPT OSS 120B',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.00000035, outputTokens: 0.00000075 } // $0.35/$0.75 per 1M tokens
+    },
+    'qwen-3-coder-480b': {
+        name: 'Qwen 3 Coder 480B',
+        contextWindow: 128000,
+        pricing: { inputTokens: 0.000002, outputTokens: 0.000002 } // $2.00/$2.00 per 1M tokens
+    }
+};
+export const cerebrasProvider = {
+    id: 'cerebras',
+    name: 'Cerebras',
+    models: cerebrasModels.models,
+    defaultModel: cerebrasModels.defaultModel,
+    modelConfigs: cerebrasModelConfigs,
+    auth: {
+        type: 'api_key',
+        envVar: 'CEREBRAS_API_KEY',
+        label: 'Cerebras API Key',
+        helpUrl: 'https://cloud.cerebras.ai/platform'
+    },
+    baseURL: 'https://api.cerebras.ai/v1'
+};
+/**
+ * Get model configuration for any provider
+ */
+export function getModelConfig(provider, model) {
+    switch (provider) {
+        case 'openai':
+            return openaiModelConfigs[model] || null;
+        case 'gemini':
+            return geminiModelConfigs[model] || null;
+        case 'cerebras':
+            return cerebrasModelConfigs[model] || null;
+        default:
+            return null;
+    }
+}

package/dist/config/setup.js

@@ -0,0 +1,175 @@
+/**
+ * Interactive configuration setup for ProtoAgent
+ */
+import inquirer from 'inquirer';
+import { openaiProvider, geminiProvider, cerebrasProvider } from './providers.js';
+import { saveConfig, getConfigDirectory } from './manager.js';
+/**
+ * Run interactive configuration setup
+ */
+export async function setupConfig() {
+    console.log('\n🤖 Welcome to ProtoAgent!');
+    console.log("Let's set up your model configuration.\n");
+    // Step 1: Select provider and model
+    const modelChoices = [
+        new inquirer.Separator('--- OpenAI Models ---'),
+        ...openaiProvider.models.map(model => ({
+            name: model === openaiProvider.defaultModel ? `${model} (recommended)` : model,
+            value: { provider: 'openai', model }
+        })),
+        new inquirer.Separator('--- Gemini Models ---'),
+        ...geminiProvider.models.map(model => ({
+            name: model === geminiProvider.defaultModel ? `${model} (recommended)` : model,
+            value: { provider: 'gemini', model }
+        })),
+        new inquirer.Separator('--- Cerebras Models ---'),
+        ...cerebrasProvider.models.map(model => ({
+            name: model === cerebrasProvider.defaultModel ? `${model} (recommended)` : model,
+            value: { provider: 'cerebras', model }
+        }))
+    ];
+    const { selection } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selection',
+            message: 'Select a model:',
+            choices: modelChoices,
+            default: { provider: 'openai', model: openaiProvider.defaultModel }
+        }
+    ]);
+    const provider = selection.provider;
+    const model = selection.model;
+    // Step 2: Get API credentials
+    let apiKey = '';
+    let credentials = {
+        OPENAI_API_KEY: '',
+        GEMINI_API_KEY: '',
+        CEREBRAS_API_KEY: ''
+    };
+    if (provider === 'openai') {
+        console.log(`\n📝 ${openaiProvider.auth.label} Setup`);
+        console.log("You'll need an API key from OpenAI.");
+        console.log(`Get your API key from: ${openaiProvider.auth.helpUrl}`);
+        const response = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: `Enter your ${openaiProvider.auth.label}:`,
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'API key is required';
+                    }
+                    if (!input.trim().startsWith('sk-')) {
+                        return 'OpenAI API keys should start with "sk-"';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        apiKey = response.apiKey;
+        credentials.OPENAI_API_KEY = apiKey;
+    }
+    else if (provider === 'gemini') {
+        console.log(`\n📝 ${geminiProvider.auth.label} Setup`);
+        console.log("You'll need an API key from Gemini.");
+        console.log(`Get your API key from: ${geminiProvider.auth.helpUrl}`);
+        const response = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: `Enter your ${geminiProvider.auth.label}:`,
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'API key is required';
+                    }
+                    // Gemini keys may have different format, so just check non-empty
+                    return true;
+                }
+            }
+        ]);
+        apiKey = response.apiKey;
+        credentials.GEMINI_API_KEY = apiKey;
+    }
+    else if (provider === 'cerebras') {
+        console.log(`\n📝 ${cerebrasProvider.auth.label} Setup`);
+        console.log("You'll need an API key from Cerebras.");
+        console.log(`Get your API key from: ${cerebrasProvider.auth.helpUrl}`);
+        const response = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: `Enter your ${cerebrasProvider.auth.label}:`,
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'API key is required';
+                    }
+                    // Cerebras keys may have different format, so just check non-empty
+                    return true;
+                }
+            }
+        ]);
+        apiKey = response.apiKey;
+        credentials.CEREBRAS_API_KEY = apiKey;
+    }
+    // Step 3: Confirm configuration
+    console.log('\n📋 Configuration Summary:');
+    let providerName = '';
+    if (provider === 'openai') {
+        providerName = openaiProvider.name;
+    }
+    else if (provider === 'gemini') {
+        providerName = geminiProvider.name;
+    }
+    else if (provider === 'cerebras') {
+        providerName = cerebrasProvider.name;
+    }
+    console.log(`Provider: ${providerName}`);
+    console.log(`Model: ${model}`);
+    console.log(`API Key: ${'*'.repeat(Math.min(apiKey.length, 20))}...`);
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Save this configuration?',
+            default: true
+        }
+    ]);
+    if (!confirm) {
+        console.log('Configuration cancelled.');
+        process.exit(0);
+    }
+    // Step 4: Save configuration
+    const config = {
+        provider,
+        model,
+        credentials
+    };
+    try {
+        await saveConfig(config);
+        console.log(`\n✅ Configuration saved successfully!`);
+        console.log(`Config location: ${getConfigDirectory()}/config.json`);
+        console.log("\nYou're all set! ProtoAgent is ready to use.\n");
+        return config;
+    }
+    catch (error) {
+        console.error(`\n❌ Failed to save configuration: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Prompt to reconfigure
+ */
+export async function promptReconfigure() {
+    const { reconfigure } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'reconfigure',
+            message: 'Would you like to reconfigure ProtoAgent?',
+            default: false
+        }
+    ]);
+    return reconfigure;
+}