plazbot-cli/src/commands/agent/ai-config.ts

CLI para Plazbot SDK

import { Command } from 'commander';
import { Agent } from 'plazbot';
import inquirer from 'inquirer';
import { getStoredCredentials } from '../../utils/credentials';
import { logger } from '../../utils/logger';
import { createSpinner, theme, section, kvPair } from '../../utils/ui';
import { AgentCommandOptions } from '../../types/agent';

const MODELS: Record<string, string[]> = {
  openai: ['gpt-4o', 'gpt-4', 'gpt-3.5-turbo', 'o1-preview', 'o1-mini'],
  claude: ['claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
  gemini: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
};

export const aiConfigCommand = new Command('ai-config')
  .description('Configurar proveedor de IA del agente')
  .argument('<agentId>', 'ID del agente')
  .option('--dev', 'Usar ambiente de desarrollo', false)
  .action(async (agentId: string, options: AgentCommandOptions) => {
    try {
      const credentials = await getStoredCredentials();
      const agent = new Agent({
        workspaceId: credentials.workspace,
        apiKey: credentials.apiKey,
        zone: credentials.zone,
        ...(options.dev && { customUrl: "http://localhost:5090" })
      });

      const spinner = createSpinner('Cargando agente...');
      spinner.start();
      const agentData = await agent.getAgentById({ id: agentId });
      spinner.stop();

      console.log(section('Configuracion de IA - ' + (agentData.name || agentId)));

      const currentProviders = agentData.aiProviders || [];
      if (currentProviders.length > 0 && agentData.customAIConfig) {
        console.log(theme.bold('\n  Configuracion actual:'));
        currentProviders.forEach((p: any) => {
          console.log(kvPair('  Proveedor', p.provider));
          console.log(kvPair('  Modelo', p.model));
          console.log(kvPair('  Temperatura', String(p.temperature)));
          console.log(kvPair('  Max Tokens', String(p.maxTokens)));
          console.log(kvPair('  Default', p.isDefault ? 'Si' : 'No'));
        });
      } else {
        console.log(theme.muted('\n  Usando configuracion de IA por defecto (Plazbot)'));
      }

      const { action } = await (inquirer as any).prompt([{
        type: 'list',
        name: 'action',
        message: 'Que deseas hacer?',
        choices: [
          { name: 'Configurar nuevo proveedor', value: 'set' },
          { name: 'Usar configuracion por defecto', value: 'reset' },
          { name: 'Salir', value: 'exit' },
        ],
      }]);

      if (action === 'exit') return;

      if (action === 'reset') {
        const resetConfig = { ...agentData, customAIConfig: false, aiProviders: [] };
        delete resetConfig.id;
        delete resetConfig._id;
        const resetSpinner = createSpinner('Reseteando configuracion...');
        resetSpinner.start();
        await agent.updateAgent(agentId, resetConfig);
        resetSpinner.succeed('Usando configuracion por defecto');
        return;
      }

      // Configurar nuevo proveedor
      const ai = await (inquirer as any).prompt([
        { type: 'list', name: 'provider', message: 'Proveedor:', choices: ['openai', 'claude', 'gemini'] },
      ]);

      const models = MODELS[ai.provider] || MODELS.openai;

      const config = await (inquirer as any).prompt([
        { type: 'list', name: 'model', message: 'Modelo:', choices: models },
        { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v: string) => v.length > 0 || 'Requerido' },
        { type: 'number', name: 'temperature', message: 'Temperatura (0-2):', default: 0.7 },
        { type: 'number', name: 'maxTokens', message: 'Max tokens (1024-16384):', default: 4096 },
      ]);

      const updatedConfig = {
        ...agentData,
        customAIConfig: true,
        aiProviders: [{
          provider: ai.provider,
          model: config.model,
          apiToken: config.apiToken,
          temperature: config.temperature,
          maxTokens: config.maxTokens,
          isDefault: true,
        }],
      };
      delete updatedConfig.id;
      delete updatedConfig._id;
      const updateSpinner = createSpinner('Guardando configuracion...');
      updateSpinner.start();
      await agent.updateAgent(agentId, updatedConfig);
      updateSpinner.succeed(`Proveedor configurado: ${ai.provider} / ${config.model}`);

    } catch (error) {
      const message = error instanceof Error ? error.message : 'Error desconocido';
      logger.error(message);
      process.exit(1);
    }
  });