ruvector 0.1.90 → 0.1.92

package/bin/cli.js

@@ -7376,6 +7376,456 @@ edgeNetCmd.command('status')
     }
   });
 
+// ============================================
+// REAL AGENT COMMANDS (Actual LLM Execution)
+// ============================================
+
+const agentCmd = program.command('agent').description('Real AI agent execution - local ruvllm by default, or cloud APIs (Anthropic/OpenAI)');
+
+agentCmd.command('run')
+  .description('Execute a task with a real AI agent (local ruvllm by default, no API key needed)')
+  .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: local (default), anthropic, openai', 'local')
+  .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 (only required for cloud providers)
+    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+    const isLocal = opts.provider === 'local' || opts.provider === 'ruvllm';
+
+    if (!isLocal && !apiKey && type !== 'embedder') {
+      spinner.fail('No API key found for cloud provider');
+      console.log(chalk.red('\n❌ Cloud provider requires an API key.\n'));
+      console.log(chalk.bold('Options:'));
+      console.log(chalk.green('  1. Use local ruvllm (default, no key needed):'));
+      console.log(chalk.cyan('     ruvector agent run coder "task" -p local\n'));
+      console.log(chalk.yellow('  2. Or set a cloud API key:'));
+      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'));
+    }
+  });
+
+// ============================================
+// REAL WORKER POOL COMMANDS
+// ============================================
+
+const workerCmd = program.command('worker').description('Real worker pool execution with Node.js worker_threads');
+
+workerCmd.command('create')
+  .description('Create a real worker pool for parallel task execution')
+  .option('-s, --size <size>', 'Pool size (number of workers)', String(require('os').cpus().length - 1))
+  .option('--relay <url>', 'Relay server URL for distributed mode')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const spinner = ora('Creating worker pool...').start();
+
+    try {
+      let RealWorkerPool;
+      try {
+        const realWorkers = await import('@ruvector/edge-net/real-workers');
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      } catch (e) {
+        const realWorkersPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-workers.js');
+        const realWorkers = await import(realWorkersPath);
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      }
+
+      const pool = new RealWorkerPool({
+        size: parseInt(opts.size) || require('os').cpus().length - 1,
+      });
+
+      await pool.initialize();
+
+      spinner.succeed(`Worker pool created: ${pool.id}`);
+
+      const info = {
+        id: pool.id,
+        size: pool.size,
+        workers: pool.workers.map(w => ({ id: w.id, status: w.status })),
+        ready: pool.workers.filter(w => w.status === 'ready').length,
+      };
+
+      if (opts.json) {
+        console.log(JSON.stringify(info, null, 2));
+      } else {
+        console.log(chalk.bold.cyan('\n⚡ Real Worker Pool Created\n'));
+        console.log(`${chalk.cyan('Pool ID:')} ${info.id}`);
+        console.log(`${chalk.cyan('Size:')} ${info.size} workers`);
+        console.log(`${chalk.cyan('Ready:')} ${info.ready}/${info.size}`);
+        console.log();
+      }
+
+      if (pool.shutdown) await pool.shutdown();
+      else if (pool.close) await pool.close();
+
+    } catch (e) {
+      spinner.fail(`Failed to create pool: ${e.message}`);
+    }
+  });
+
+workerCmd.command('execute')
+  .description('Execute a task on worker pool')
+  .argument('<type>', 'Task type: compute, analyze, transform, batch')
+  .argument('<data>', 'Task data (JSON string or simple value)')
+  .option('-s, --size <size>', 'Pool size', '4')
+  .option('--timeout <ms>', 'Task timeout in milliseconds', '30000')
+  .option('--json', 'Output as JSON')
+  .action(async (type, data, opts) => {
+    const spinner = ora(`Executing ${type} task...`).start();
+
+    try {
+      let RealWorkerPool;
+      try {
+        const realWorkers = await import('@ruvector/edge-net/real-workers');
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      } catch (e) {
+        const realWorkersPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-workers.js');
+        const realWorkers = await import(realWorkersPath);
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      }
+
+      const pool = new RealWorkerPool({ size: parseInt(opts.size) || 4 });
+      await pool.initialize();
+
+      let taskData;
+      try {
+        taskData = JSON.parse(data);
+      } catch {
+        taskData = { input: data };
+      }
+
+      const startTime = Date.now();
+      const result = await pool.execute(type, taskData, {
+        timeout: parseInt(opts.timeout) || 30000,
+      });
+      const duration = Date.now() - startTime;
+
+      spinner.succeed(`Task completed in ${(duration / 1000).toFixed(2)}s`);
+
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, duration, result }, null, 2));
+      } else {
+        console.log(chalk.bold.cyan('\n⚡ Worker Execution Complete\n'));
+        console.log(`${chalk.cyan('Type:')} ${type}`);
+        console.log(`${chalk.cyan('Duration:')} ${(duration / 1000).toFixed(2)}s`);
+        console.log(`${chalk.cyan('Worker:')} ${result.workerId || 'pool'}`);
+        console.log(chalk.bold('\n📝 Result:\n'));
+        console.log(JSON.stringify(result, null, 2));
+        console.log();
+      }
+
+      if (pool.shutdown) await pool.shutdown();
+      else if (pool.close) await pool.close();
+
+    } catch (e) {
+      spinner.fail(`Execution failed: ${e.message}`);
+    }
+  });
+
+workerCmd.command('info')
+  .description('Show worker pool information')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n⚡ Real Worker Pool System\n'));
+    console.log(chalk.white('Execute parallel tasks using Node.js worker_threads.\n'));
+
+    console.log(chalk.bold('Task Types:'));
+    console.log(chalk.dim('  compute   - CPU-intensive computations'));
+    console.log(chalk.dim('  analyze   - Data analysis tasks'));
+    console.log(chalk.dim('  transform - Data transformation'));
+    console.log(chalk.dim('  batch     - Batch processing'));
+
+    console.log(chalk.bold('\n📋 Examples:\n'));
+    console.log(chalk.cyan('  ruvector worker create --size 8'));
+    console.log(chalk.cyan('  ruvector worker execute compute \'{"n": 1000000}\''));
+    console.log(chalk.cyan('  ruvector worker execute analyze \'{"data": [1,2,3,4,5]}\''));
+    console.log();
+  });
+
+// ============================================
+// REAL WORKFLOW COMMANDS
+// ============================================
+
+const workflowCmd = program.command('workflow').description('Real multi-agent workflow orchestration with LLM execution');
+
+workflowCmd.command('run')
+  .description('Run a multi-agent workflow (uses local ruvllm by default)')
+  .argument('<template>', 'Workflow template: code-review, feature-dev, bug-fix, optimization, research')
+  .argument('<input>', 'Input/context for the workflow')
+  .option('-p, --provider <provider>', 'LLM provider: local (default), anthropic, openai', 'local')
+  .option('-m, --model <model>', 'Model tier: fast, balanced, powerful', 'balanced')
+  .option('--max-steps <n>', 'Maximum workflow steps', '10')
+  .option('--json', 'Output as JSON')
+  .action(async (template, input, opts) => {
+    const spinner = ora(`Running ${template} workflow...`).start();
+
+    try {
+      let RealWorkflowOrchestrator;
+      try {
+        const realWorkflows = await import('@ruvector/edge-net/real-workflows');
+        RealWorkflowOrchestrator = realWorkflows.RealWorkflowOrchestrator;
+      } catch (e) {
+        const realWorkflowsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-workflows.js');
+        const realWorkflows = await import(realWorkflowsPath);
+        RealWorkflowOrchestrator = realWorkflows.RealWorkflowOrchestrator;
+      }
+
+      // Check for API key if using cloud provider
+      const isLocal = opts.provider === 'local' || opts.provider === 'ruvllm';
+      const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+
+      if (!isLocal && !apiKey) {
+        spinner.fail('No API key found for cloud provider');
+        console.log(chalk.yellow('\n  Use local provider (default) or set API key:'));
+        console.log(chalk.cyan('  ruvector workflow run code-review "my code" -p local'));
+        return;
+      }
+
+      const orchestrator = new RealWorkflowOrchestrator({
+        provider: isLocal ? 'local' : (process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai'),
+        apiKey: isLocal ? undefined : apiKey,
+        maxConcurrency: 2,
+      });
+
+      await orchestrator.initialize();
+
+      const startTime = Date.now();
+      const result = await orchestrator.run(template, input, {
+        maxSteps: parseInt(opts.maxSteps) || 10,
+        modelTier: opts.model,
+      });
+      const duration = Date.now() - startTime;
+
+      spinner.succeed(`Workflow completed in ${(duration / 1000).toFixed(2)}s`);
+
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, duration, ...result }, null, 2));
+      } else {
+        console.log(chalk.bold.cyan(`\n🔄 Workflow: ${template}\n`));
+        console.log(`${chalk.cyan('Duration:')} ${(duration / 1000).toFixed(2)}s`);
+        console.log(`${chalk.cyan('Provider:')} ${opts.provider}`);
+        const steps = result.steps || [];
+        const completedSteps = steps.filter(s => s.status === 'completed').length;
+        console.log(`${chalk.cyan('Steps:')} ${completedSteps}/${steps.length}`);
+
+        console.log(chalk.bold('\n📝 Results by Step:\n'));
+        for (const [stepName, stepResult] of Object.entries(result.results || {})) {
+          console.log(chalk.bold.green(`  ${stepName}:`));
+          const preview = typeof stepResult === 'string'
+            ? stepResult.slice(0, 200) + (stepResult.length > 200 ? '...' : '')
+            : JSON.stringify(stepResult).slice(0, 200);
+          console.log(chalk.dim(`    ${preview}\n`));
+        }
+      }
+
+      await orchestrator.close();
+
+    } catch (e) {
+      spinner.fail(`Workflow failed: ${e.message}`);
+    }
+  });
+
+workflowCmd.command('templates')
+  .description('List available workflow templates')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n🔄 Workflow Templates\n'));
+
+    const templates = [
+      { name: 'code-review', desc: 'Analyze, review, test coverage, and optimize code', steps: 4 },
+      { name: 'feature-dev', desc: 'Research, implement, test, and review a feature', steps: 4 },
+      { name: 'bug-fix', desc: 'Analyze, fix, and verify a bug', steps: 3 },
+      { name: 'optimization', desc: 'Profile, identify bottlenecks, optimize, benchmark', steps: 4 },
+      { name: 'research', desc: 'Research, analyze, and create knowledge embeddings', steps: 3 },
+    ];
+
+    templates.forEach(t => {
+      console.log(`  ${chalk.green('•')} ${chalk.bold(t.name.padEnd(14))} ${t.desc}`);
+      console.log(`    ${chalk.dim(`Steps: ${t.steps}`)}`);
+    });
+
+    console.log(chalk.bold('\n📋 Example:\n'));
+    console.log(chalk.cyan('  ruvector workflow run code-review "Review my authentication module"'));
+    console.log(chalk.cyan('  ruvector workflow run feature-dev "Add user profile page" -p anthropic'));
+    console.log();
+  });
+
 // MCP Server command
 const mcpCmd = program.command('mcp').description('MCP (Model Context Protocol) server for Claude Code integration');
 

package/bin/mcp-server.js

@@ -294,7 +294,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.1.58',
+    version: '0.1.92',
   },
   {
     capabilities: {
@@ -1124,6 +1124,37 @@ const TOOLS = [
       properties: {},
       required: []
     }
+  },
+  {
+    name: 'agent_execute',
+    description: 'REAL agent execution using local ruvllm (default, no API key), or cloud APIs (Anthropic/OpenAI). Local runs without needing any API key.',
+    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: ['local', 'ruvllm', 'anthropic', 'openai'], default: 'local', description: 'LLM provider (local by default, no API key needed)' },
+        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,167 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
       }
 
+      case 'agent_execute': {
+        // REAL agent execution with local ruvllm by default, or cloud APIs
+        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);
+
+        // Determine provider (local by default)
+        const provider = args.provider || 'local';
+        const isLocal = provider === 'local' || provider === 'ruvllm';
+
+        // Check for API key (only required for cloud providers)
+        const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+        if (!isLocal && !apiKey && agentType !== 'embedder') {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                error: 'No API key configured for cloud provider',
+                message: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or use local provider (default)',
+                options: {
+                  local: 'Use provider=local (no API key needed)',
+                  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;
+          }
+
+          // Initialize manager with selected provider
+          const manager = new RealAgentManager({
+            provider: isLocal ? 'local' : (apiKey && process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai'),
+            apiKey: isLocal ? undefined : apiKey,
+          });
+          await manager.initialize();
+
+          // Spawn and execute
+          const effectiveProvider = isLocal ? 'local' : (apiKey && process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai');
+          const agent = await manager.spawn(agentType, { provider: effectiveProvider, 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,
+                local_mode: isLocal,
+                agent: {
+                  id: agent.id,
+                  type: agentType,
+                  provider: effectiveProvider,
+                  model: result.model || (isLocal ? 'ruvllm-balanced' : model)
+                },
+                execution: {
+                  duration_ms: duration,
+                  tokens: agent.cost,
+                  fallback: result.fallback || false
+                },
+                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.92",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",