ruvector 0.1.90 → 0.1.91

package/bin/cli.js

@@ -7376,6 +7376,208 @@ edgeNetCmd.command('status')
     }
   });
 
+// ============================================
+// REAL AGENT COMMANDS (Actual LLM Execution)
+// ============================================
+
+const agentCmd = program.command('agent').description('Real AI agent execution with LLM APIs (requires ANTHROPIC_API_KEY or OPENAI_API_KEY)');
+
+agentCmd.command('run')
+  .description('Execute a task with a real AI agent (calls actual LLM API)')
+  .argument('<type>', 'Agent type: researcher, coder, reviewer, tester, analyst, optimizer, coordinator, embedder')
+  .argument('<task>', 'Task description for the agent to execute')
+  .option('-p, --provider <provider>', 'LLM provider: anthropic or openai', 'anthropic')
+  .option('-m, --model <model>', 'Model tier: fast, balanced, powerful', 'balanced')
+  .option('-f, --files <files...>', 'Files to include as context')
+  .option('-c, --context <context>', 'Additional context string')
+  .option('--max-tokens <tokens>', 'Maximum tokens in response', '4096')
+  .option('--relay <url>', 'Relay server URL for sync')
+  .option('--json', 'Output as JSON')
+  .action(async (type, task, opts) => {
+    const spinner = ora('Initializing real agent...').start();
+
+    // Check for API key
+    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+    if (!apiKey && type !== 'embedder') {
+      spinner.fail('No API key found');
+      console.log(chalk.red('\n❌ Real agent execution requires an API key.\n'));
+      console.log(chalk.bold('Set one of these environment variables:'));
+      console.log(chalk.cyan('  export ANTHROPIC_API_KEY=your-key-here'));
+      console.log(chalk.cyan('  export OPENAI_API_KEY=your-key-here'));
+      console.log(chalk.dim('\nGet an API key:'));
+      console.log(chalk.dim('  Anthropic: https://console.anthropic.com/'));
+      console.log(chalk.dim('  OpenAI: https://platform.openai.com/api-keys\n'));
+      return;
+    }
+
+    try {
+      // Try to load real-agents module
+      let RealAgentManager;
+      try {
+        const realAgents = await import('@ruvector/edge-net/real-agents');
+        RealAgentManager = realAgents.RealAgentManager;
+      } catch (e) {
+        // Fallback to local path for development
+        try {
+          const realAgentsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-agents.js');
+          const realAgents = await import(realAgentsPath);
+          RealAgentManager = realAgents.RealAgentManager;
+        } catch (e2) {
+          spinner.fail('Real agents module not found');
+          console.log(chalk.yellow('\nInstall @ruvector/edge-net for real agent execution:'));
+          console.log(chalk.cyan('  npm install @ruvector/edge-net\n'));
+          return;
+        }
+      }
+
+      // Determine provider from API key if not specified
+      const provider = opts.provider || (process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai');
+
+      spinner.text = `Spawning ${type} agent (${provider})...`;
+
+      // Initialize manager
+      const manager = new RealAgentManager({
+        provider,
+        apiKey,
+        relayUrl: opts.relay,
+        enableSync: !!opts.relay,
+      });
+      await manager.initialize();
+
+      // Spawn agent
+      const agent = await manager.spawn(type, {
+        provider,
+        model: opts.model,
+      });
+
+      spinner.text = `Executing task with ${type} agent...`;
+
+      // Build context
+      const context = {
+        model: opts.model,
+        files: opts.files || [],
+        additionalContext: opts.context,
+        maxTokens: parseInt(opts.maxTokens) || 4096,
+      };
+
+      // Execute task
+      const startTime = Date.now();
+      const result = await agent.execute(task, context);
+      const duration = Date.now() - startTime;
+
+      spinner.succeed(`Task completed in ${(duration / 1000).toFixed(2)}s`);
+
+      if (opts.json) {
+        console.log(JSON.stringify({
+          success: true,
+          agentId: agent.id,
+          type,
+          provider,
+          model: result.model,
+          duration,
+          result,
+        }, null, 2));
+      } else {
+        console.log(chalk.bold.cyan(`\n🤖 Real Agent Execution Complete\n`));
+        console.log(`${chalk.cyan('Agent ID:')} ${agent.id}`);
+        console.log(`${chalk.cyan('Type:')} ${type}`);
+        console.log(`${chalk.cyan('Provider:')} ${provider}`);
+        console.log(`${chalk.cyan('Model:')} ${result.model}`);
+        console.log(`${chalk.cyan('Duration:')} ${(duration / 1000).toFixed(2)}s`);
+
+        if (agent.cost.inputTokens || agent.cost.outputTokens) {
+          console.log(`${chalk.cyan('Tokens:')} ${agent.cost.inputTokens} in / ${agent.cost.outputTokens} out`);
+        }
+
+        console.log(chalk.bold('\n📝 Response:\n'));
+        console.log(result.content || JSON.stringify(result, null, 2));
+        console.log();
+      }
+
+      await manager.close();
+
+    } catch (e) {
+      spinner.fail(`Agent execution failed: ${e.message}`);
+      if (e.message.includes('401') || e.message.includes('Unauthorized')) {
+        console.log(chalk.yellow('\nCheck your API key is valid and has sufficient credits.'));
+      }
+    }
+  });
+
+agentCmd.command('types')
+  .description('List available agent types')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n🤖 Available Real Agent Types\n'));
+
+    const types = [
+      { type: 'researcher', desc: 'Analyze, search, summarize information', cost: '~$0.01-0.05/task' },
+      { type: 'coder', desc: 'Write, refactor, debug code', cost: '~$0.02-0.10/task' },
+      { type: 'reviewer', desc: 'Review code quality and security', cost: '~$0.01-0.05/task' },
+      { type: 'tester', desc: 'Write tests and validate functionality', cost: '~$0.01-0.05/task' },
+      { type: 'analyst', desc: 'Analyze data and generate reports', cost: '~$0.01-0.05/task' },
+      { type: 'optimizer', desc: 'Profile and improve performance', cost: '~$0.02-0.10/task' },
+      { type: 'coordinator', desc: 'Orchestrate workflows and tasks', cost: '~$0.02-0.10/task' },
+      { type: 'embedder', desc: 'Generate semantic embeddings (no API key needed)', cost: 'Free (local)' },
+    ];
+
+    types.forEach(t => {
+      console.log(`  ${chalk.green('•')} ${chalk.bold(t.type.padEnd(12))} ${t.desc}`);
+      console.log(`    ${chalk.dim('Estimated cost: ' + t.cost)}`);
+    });
+
+    console.log(chalk.bold('\n📋 Model Tiers:\n'));
+    console.log(`  ${chalk.cyan('fast')}     - Quick responses, lower cost (Haiku/GPT-4o-mini)`);
+    console.log(`  ${chalk.cyan('balanced')} - Good quality/speed balance (Sonnet/GPT-4o)`);
+    console.log(`  ${chalk.cyan('powerful')} - Best quality, higher cost (Opus/GPT-4-turbo)`);
+
+    console.log(chalk.bold('\n🔧 Example:\n'));
+    console.log(chalk.dim('  export ANTHROPIC_API_KEY=your-key'));
+    console.log(chalk.cyan('  ruvector agent run coder "Write a function to validate emails" -m fast'));
+    console.log();
+  });
+
+agentCmd.command('balance')
+  .description('Show rUv balance and sync status')
+  .option('--relay <url>', 'Relay server URL', 'ws://localhost:8080')
+  .action(async (opts) => {
+    const spinner = ora('Connecting to relay...').start();
+
+    try {
+      let RelaySyncClient;
+      try {
+        const realAgents = await import('@ruvector/edge-net/real-agents');
+        RelaySyncClient = realAgents.RelaySyncClient;
+      } catch (e) {
+        const realAgentsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-agents.js');
+        const realAgents = await import(realAgentsPath);
+        RelaySyncClient = realAgents.RelaySyncClient;
+      }
+
+      const client = new RelaySyncClient({ relayUrl: opts.relay });
+
+      await Promise.race([
+        client.connect(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 5000)),
+      ]);
+
+      spinner.succeed('Connected to relay');
+
+      console.log(chalk.bold.cyan('\n💰 rUv Balance\n'));
+      console.log(`${chalk.cyan('Balance:')} ${client.getBalance()} rUv`);
+      console.log(`${chalk.cyan('Relay:')} ${opts.relay}`);
+      console.log(`${chalk.cyan('Node ID:')} ${client.nodeId}`);
+      console.log(`${chalk.cyan('Status:')} ${chalk.green('Connected')}`);
+      console.log();
+
+      client.close();
+
+    } catch (e) {
+      spinner.fail(`Connection failed: ${e.message}`);
+      console.log(chalk.dim('\nMake sure the relay server is running:'));
+      console.log(chalk.cyan('  cd examples/edge-net/relay && node index.js\n'));
+    }
+  });
+
 // MCP Server command
 const mcpCmd = program.command('mcp').description('MCP (Model Context Protocol) server for Claude Code integration');
 

package/bin/mcp-server.js

@@ -1124,6 +1124,37 @@ const TOOLS = [
       properties: {},
       required: []
     }
+  },
+  {
+    name: 'agent_execute',
+    description: 'REAL agent execution that calls actual LLM APIs (Anthropic Claude or OpenAI). Requires ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          description: 'Agent type',
+          enum: ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder']
+        },
+        task: { type: 'string', description: 'Task for the agent to execute' },
+        provider: { type: 'string', enum: ['anthropic', 'openai'], description: 'LLM provider (auto-detected from API key)' },
+        model: { type: 'string', enum: ['fast', 'balanced', 'powerful'], default: 'balanced', description: 'Model tier' },
+        context: { type: 'string', description: 'Additional context for the agent' },
+        max_tokens: { type: 'number', default: 4096, description: 'Maximum tokens in response' }
+      },
+      required: ['type', 'task']
+    }
+  },
+  {
+    name: 'agent_balance',
+    description: 'Get rUv credit balance from relay server with multi-device sync status',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        relay_url: { type: 'string', description: 'Relay server URL', default: 'ws://localhost:8080' }
+      },
+      required: []
+    }
   }
 ];
 
@@ -2787,6 +2818,162 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
       }
 
+      case 'agent_execute': {
+        // REAL agent execution with actual LLM API calls
+        const validTypes = ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder'];
+        const validModels = ['fast', 'balanced', 'powerful'];
+
+        const agentType = validTypes.includes(args.type) ? args.type : 'coder';
+        const task = typeof args.task === 'string' ? args.task.slice(0, 10000).trim() : '';
+        const model = validModels.includes(args.model) ? args.model : 'balanced';
+        const maxTokens = Math.min(Math.max(parseInt(args.max_tokens) || 4096, 100), 8192);
+
+        // Check for API key
+        const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+        if (!apiKey && agentType !== 'embedder') {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                error: 'No API key configured',
+                message: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable',
+                help: {
+                  anthropic: 'https://console.anthropic.com/',
+                  openai: 'https://platform.openai.com/api-keys'
+                }
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        try {
+          // Try to load real-agents module
+          let RealAgentManager;
+          try {
+            const realAgents = await import('@ruvector/edge-net/real-agents');
+            RealAgentManager = realAgents.RealAgentManager;
+          } catch (e) {
+            // Fallback to local path for development
+            const realAgentsPath = path.resolve(__dirname, '../../../examples/edge-net/pkg/real-agents.js');
+            const realAgents = await import(realAgentsPath);
+            RealAgentManager = realAgents.RealAgentManager;
+          }
+
+          // Determine provider from API key
+          const provider = args.provider || (process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai');
+
+          // Initialize manager
+          const manager = new RealAgentManager({
+            provider,
+            apiKey,
+          });
+          await manager.initialize();
+
+          // Spawn and execute
+          const agent = await manager.spawn(agentType, { provider, model });
+
+          const context = {
+            model,
+            additionalContext: args.context,
+            maxTokens,
+          };
+
+          const startTime = Date.now();
+          const result = await agent.execute(task, context);
+          const duration = Date.now() - startTime;
+
+          await manager.close();
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                real_execution: true,
+                agent: {
+                  id: agent.id,
+                  type: agentType,
+                  provider,
+                  model: result.model
+                },
+                execution: {
+                  duration_ms: duration,
+                  tokens: agent.cost
+                },
+                response: result.content
+              }, null, 2)
+            }]
+          };
+
+        } catch (execError) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                error: execError.message,
+                real_execution: true,
+                hint: execError.message.includes('401') ? 'Check your API key is valid' : 'Check error message for details'
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      }
+
+      case 'agent_balance': {
+        const relayUrl = args.relay_url || 'ws://localhost:8080';
+
+        try {
+          // Try to load real-agents module
+          let RelaySyncClient;
+          try {
+            const realAgents = await import('@ruvector/edge-net/real-agents');
+            RelaySyncClient = realAgents.RelaySyncClient;
+          } catch (e) {
+            const realAgentsPath = path.resolve(__dirname, '../../../examples/edge-net/pkg/real-agents.js');
+            const realAgents = await import(realAgentsPath);
+            RelaySyncClient = realAgents.RelaySyncClient;
+          }
+
+          const client = new RelaySyncClient({ relayUrl });
+
+          await Promise.race([
+            client.connect(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 5000)),
+          ]);
+
+          const balance = {
+            success: true,
+            balance: client.getBalance(),
+            nodeId: client.nodeId,
+            relayUrl,
+            connected: true,
+            ledgerState: client.ledgerState
+          };
+
+          client.close();
+
+          return { content: [{ type: 'text', text: JSON.stringify(balance, null, 2) }] };
+
+        } catch (connError) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                error: connError.message,
+                relayUrl,
+                hint: 'Start the relay server: cd examples/edge-net/relay && node index.js'
+              }, null, 2)
+            }],
+            isError: true
+          };
+        }
+      }
+
       default:
         return {
           content: [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",