@darksol/terminal 0.9.0 → 0.9.2

package/src/cli.js

@@ -29,8 +29,10 @@ import { listSkills, installSkill, skillInfo, uninstallSkill } from './services/
 import { runSetupWizard } from './setup/wizard.js';
 import { displaySoul, hasSoul, resetSoul, runSoulSetup } from './soul/index.js';
 import { clearMemories, exportMemories, getRecentMemories, searchMemories } from './memory/index.js';
+import { getAgentStatus, planAgentGoal, runAgentTask } from './agent/index.js';
 import { createRequire } from 'module';
 import { resolve } from 'path';
+import { getConfiguredModel, getProviderDefaultModel } from './llm/models.js';
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require('../package.json');
 
@@ -764,7 +766,7 @@ export function cli(argv) {
   ai
     .command('chat')
     .description('Start interactive AI trading chat')
-    .option('-p, --provider <name>', 'LLM provider (openai, anthropic, openrouter, ollama)')
+    .option('-p, --provider <name>', 'LLM provider (openai, anthropic, openrouter, minimax, ollama)')
     .option('-m, --model <model>', 'Model name')
     .action((opts) => startChat(opts));
 
@@ -883,6 +885,93 @@ export function cli(argv) {
     .command('agent')
     .description('Secure agent signer — PK-isolated wallet for AI agents');
 
+  agent
+    .command('task <goal...>')
+    .description('Run the agent loop against a goal')
+    .option('--max-steps <n>', 'Maximum loop steps', '10')
+    .option('--allow-actions', 'Allow mutating tools such as swap/send/script-run')
+    .action(async (goalParts, opts) => {
+      showMiniBanner();
+      showSection('AGENT TASK');
+      const goal = goalParts.join(' ').trim();
+      info(`Goal: ${goal}`);
+      info(`Mode: ${opts.allowActions ? 'actions enabled' : 'safe mode'}`);
+      console.log('');
+
+      const result = await runAgentTask(goal, {
+        maxSteps: parseInt(opts.maxSteps, 10),
+        allowActions: opts.allowActions,
+        onProgress: (event) => {
+          if (event.type === 'thought') {
+            info(`Step ${event.step}: ${event.action}`);
+            if (event.thought) console.log(`  ${theme.dim(event.thought)}`);
+          }
+          if (event.type === 'observation') {
+            const summary = event.observation?.summary || event.observation?.error || '';
+            if (summary) console.log(`  ${theme.dim(summary)}`);
+            console.log('');
+          }
+        },
+      });
+
+      showSection('AGENT RESULT');
+      kvDisplay([
+        ['Status', result.status],
+        ['Steps', `${result.stepsTaken}/${result.maxSteps}`],
+        ['Stop Reason', result.stopReason],
+      ]);
+      console.log('');
+      if (result.final) {
+        success(result.final);
+        console.log('');
+      }
+    });
+
+  agent
+    .command('plan <goal...>')
+    .description('Generate a concise agent plan for a goal')
+    .action(async (goalParts) => {
+      showMiniBanner();
+      showSection('AGENT PLAN');
+      const goal = goalParts.join(' ').trim();
+      const plan = await planAgentGoal(goal);
+      info(plan.summary);
+      console.log('');
+      plan.steps.forEach((step, index) => console.log(`  ${theme.gold(String(index + 1).padStart(2, ' '))}. ${step}`));
+      console.log('');
+    });
+
+  agent
+    .command('status')
+    .description('Show the latest agent task or plan status')
+    .action(() => {
+      showMiniBanner();
+      showSection('AGENT STATUS');
+      const status = getAgentStatus();
+      if (!status || !status.status) {
+        warn('No agent runs recorded yet.');
+        console.log('');
+        return;
+      }
+
+      kvDisplay([
+        ['Status', status.status || '-'],
+        ['Goal', status.goal || '-'],
+        ['Summary', status.summary || '-'],
+        ['Steps', status.maxSteps ? `${status.stepsTaken || 0}/${status.maxSteps}` : String(status.stepsTaken || 0)],
+        ['Actions', status.allowActions ? 'enabled' : 'safe mode'],
+        ['Started', status.startedAt || '-'],
+        ['Completed', status.completedAt || '-'],
+        ['Updated', status.updatedAt || '-'],
+      ]);
+      if (Array.isArray(status.plan) && status.plan.length > 0) {
+        console.log('');
+        showSection('LAST PLAN');
+        status.plan.forEach((step) => console.log(`  ${theme.dim(step)}`));
+      }
+      console.log('');
+    });
+
   agent
     .command('start [wallet]')
     .description('Start the agent signing proxy')
@@ -1049,6 +1138,8 @@ export function cli(argv) {
         ['Output', cfg.output],
         ['Slippage', `${cfg.slippage}%`],
         ['Gas Multiplier', `${cfg.gasMultiplier}x`],
+        ['LLM Provider', cfg.llm?.provider || theme.dim('(not set)')],
+        ['LLM Model', getConfiguredModel(cfg.llm?.provider || 'openai') || theme.dim('(default)')],
         ['Soul User', cfg.soul?.userName || theme.dim('(not set)')],
         ['Agent Name', cfg.soul?.agentName || 'Darksol'],
         ['Tone', cfg.soul?.tone || theme.dim('(not set)')],
@@ -1065,6 +1156,33 @@ export function cli(argv) {
       console.log('');
     });
 
+  config
+    .command('model [model]')
+    .description('Set the LLM model')
+    .option('-p, --provider <provider>', 'LLM provider (defaults to current provider)')
+    .action((model, opts) => {
+      const provider = opts.provider || getConfig('llm.provider') || 'openai';
+      if (!model) {
+        const current = getConfiguredModel(provider);
+        const fallback = getProviderDefaultModel(provider);
+        info(`Current model for ${provider}: ${current || '(not set)'}`);
+        if (fallback) {
+          info(`Provider default: ${fallback}`);
+        }
+        return;
+      }
+
+      if (opts.provider) {
+        setConfig('llm.provider', provider);
+        setConfig('llmProvider', provider);
+      }
+      setConfig('llm.model', model);
+      if (provider === 'ollama') {
+        setConfig('ollamaModel', model);
+      }
+      success(`LLM model for ${provider}: ${model}`);
+    });
+
   config
     .command('set <key> <value>')
     .description('Set config value')
@@ -1304,7 +1422,7 @@ function showCommandList() {
     ['dca', 'Dollar-cost averaging orders'],
     ['ai chat', 'Standalone AI chat session'],
     ['ai execute', 'Parse + execute a trade via AI'],
-    ['agent start', 'Start secure agent signer'],
+    ['agent task', 'Run bounded agent loop for a goal'],
     ['keys', 'API key vault'],
     ['soul', 'Identity and agent personality'],
     ['memory', 'Persistent cross-session memory'],

package/src/config/keys.js

@@ -84,6 +84,14 @@ export const SERVICES = {
     docsUrl: 'https://openrouter.ai/keys',
     validate: (key) => key.startsWith('sk-or-'),
   },
+  minimax: {
+    name: 'MiniMax',
+    category: 'llm',
+    description: 'MiniMax-M2.5 via OpenAI-compatible chat completions',
+    envVar: 'MINIMAX_API_KEY',
+    docsUrl: 'https://platform.minimax.io/docs/guides/models-intro',
+    validate: (key) => key.length > 10,
+  },
   ollama: {
     name: 'Ollama (Local)',
     category: 'llm',
@@ -420,7 +428,7 @@ export function hasKey(service) {
  */
 export function hasAnyLLM() {
   // Cloud providers — need real validated API keys
-  if (['openai', 'anthropic', 'openrouter', 'bankr'].some(s => hasKey(s))) return true;
+  if (['openai', 'anthropic', 'openrouter', 'minimax', 'bankr'].some(s => hasKey(s))) return true;
   // Ollama — check if explicitly configured via hasKey (validates URL format)
   if (hasKey('ollama')) return true;
   return false;

package/src/config/store.js

@@ -28,6 +28,22 @@ const config = new Conf({
         createdAt: '',
       },
     },
+    agentState: {
+      type: 'object',
+      default: {
+        status: '',
+        goal: '',
+        summary: '',
+        plan: [],
+        stepsTaken: 0,
+        maxSteps: 0,
+        allowActions: false,
+        startedAt: null,
+        completedAt: null,
+        stopReason: '',
+        updatedAt: null,
+      },
+    },
     dca: {
       type: 'object',
       default: {

package/src/llm/engine.js

@@ -3,18 +3,19 @@ import { getKeyFromEnv, getKey } from '../config/keys.js';
 import { getConfig } from '../config/store.js';
 import { SessionMemory, extractMemories, searchMemories } from '../memory/index.js';
 import { formatSystemPrompt as formatSoulSystemPrompt } from '../soul/index.js';
+import { getProviderDefaultModel } from './models.js';
 
 const PROVIDERS = {
   openai: {
     url: 'https://api.openai.com/v1/chat/completions',
-    defaultModel: 'gpt-4o',
+    defaultModel: getProviderDefaultModel('openai'),
     authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
     parseResponse: (data) => data.choices?.[0]?.message?.content,
     parseUsage: (data) => data.usage,
   },
   anthropic: {
     url: 'https://api.anthropic.com/v1/messages',
-    defaultModel: 'claude-sonnet-4-20250514',
+    defaultModel: getProviderDefaultModel('anthropic'),
     authHeader: (key) => ({ 'x-api-key': key, 'anthropic-version': '2023-06-01' }),
     buildBody: (model, messages, systemPrompt) => ({
       model,
@@ -30,7 +31,7 @@ const PROVIDERS = {
   },
   openrouter: {
     url: 'https://openrouter.ai/api/v1/chat/completions',
-    defaultModel: 'anthropic/claude-sonnet-4-20250514',
+    defaultModel: getProviderDefaultModel('openrouter'),
     authHeader: (key) => ({
       Authorization: `Bearer ${key}`,
       'HTTP-Referer': 'https://darksol.net',
@@ -39,16 +40,23 @@ const PROVIDERS = {
     parseResponse: (data) => data.choices?.[0]?.message?.content,
     parseUsage: (data) => data.usage,
   },
+  minimax: {
+    url: 'https://api.minimax.io/v1/chat/completions',
+    defaultModel: getProviderDefaultModel('minimax'),
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    parseResponse: (data) => data.choices?.[0]?.message?.content,
+    parseUsage: (data) => data.usage,
+  },
   ollama: {
     url: null,
-    defaultModel: 'llama3.1',
+    defaultModel: getProviderDefaultModel('ollama'),
     authHeader: () => ({}),
     parseResponse: (data) => data.choices?.[0]?.message?.content || data.message?.content,
     parseUsage: () => ({ input: 0, output: 0 }),
   },
   bankr: {
     url: 'https://llm.bankr.bot/v1/chat/completions',
-    defaultModel: 'claude-sonnet-4.6',
+    defaultModel: getProviderDefaultModel('bankr'),
     authHeader: (key) => ({ 'X-API-Key': key }),
     parseResponse: (data) => data.choices?.[0]?.message?.content,
     parseUsage: (data) => data.usage,
@@ -92,9 +100,7 @@ export class LLMEngine {
       throw new Error(`Unknown LLM provider: ${this.provider}. Supported: ${Object.keys(PROVIDERS).join(', ')}`);
     }
 
-    if (!this.model) {
-      this.model = providerConfig.defaultModel;
-    }
+    this.model = this.model || providerConfig.defaultModel || getProviderDefaultModel(this.provider);
 
     if (this.provider === 'ollama') {
       const host = this.apiKey || getConfig('llm.ollamaHost') || 'http://localhost:11434';

package/src/llm/models.js

@@ -0,0 +1,67 @@
+import { getConfig } from '../config/store.js';
+
+export const MODEL_CATALOG = {
+  openai: {
+    defaultModel: 'gpt-5.4',
+    choices: [
+      { value: 'gpt-5.4', label: 'gpt-5.4', desc: 'flagship, complex reasoning' },
+      { value: 'gpt-5-mini', label: 'gpt-5-mini', desc: 'fast, lower cost' },
+      { value: 'gpt-4o', label: 'gpt-4o', desc: 'previous gen, still good' },
+      { value: 'o3', label: 'o3', desc: 'reasoning model' },
+    ],
+  },
+  anthropic: {
+    defaultModel: 'claude-sonnet-4-6',
+    choices: [
+      { value: 'claude-opus-4-6', label: 'claude-opus-4-6', desc: 'most intelligent, agents+coding' },
+      { value: 'claude-sonnet-4-6', label: 'claude-sonnet-4-6', desc: 'best speed/intelligence balance' },
+      { value: 'claude-haiku-4-5', label: 'claude-haiku-4-5', desc: 'fastest, near-frontier' },
+    ],
+  },
+  openrouter: {
+    defaultModel: 'anthropic/claude-sonnet-4-6',
+    choices: [
+      { value: 'anthropic/claude-sonnet-4-6', label: 'anthropic/claude-sonnet-4-6', desc: 'popular pick' },
+      { value: 'openai/gpt-5.4', label: 'openai/gpt-5.4', desc: 'popular pick' },
+      { value: 'google/gemini-2.5-pro', label: 'google/gemini-2.5-pro', desc: 'popular pick' },
+      { value: 'meta-llama/llama-4-maverick', label: 'meta-llama/llama-4-maverick', desc: 'popular pick' },
+      { value: 'deepseek/deepseek-r1', label: 'deepseek/deepseek-r1', desc: 'popular pick' },
+    ],
+    allowCustom: true,
+  },
+  minimax: {
+    defaultModel: 'MiniMax-M2.5',
+    choices: [
+      { value: 'MiniMax-M2.5', label: 'MiniMax-M2.5', desc: 'flagship, 204K context, ~60 tps' },
+      { value: 'MiniMax-M2.5-highspeed', label: 'MiniMax-M2.5-highspeed', desc: 'same perf, ~100 tps' },
+      { value: 'MiniMax-M2.1', label: 'MiniMax-M2.1', desc: 'code-focused' },
+      { value: 'MiniMax-M2.1-highspeed', label: 'MiniMax-M2.1-highspeed', desc: 'code-focused, faster' },
+      { value: 'MiniMax-M2', label: 'MiniMax-M2', desc: 'agentic, advanced reasoning' },
+    ],
+  },
+  ollama: {
+    defaultModel: 'llama3.1',
+    textInput: true,
+  },
+  bankr: {
+    defaultModel: 'claude-sonnet-4.6',
+    managed: true,
+  },
+};
+
+export function getProviderDefaultModel(provider) {
+  return MODEL_CATALOG[provider]?.defaultModel || null;
+}
+
+export function getConfiguredProvider(fallback = 'openai') {
+  return getConfig('llm.provider') || fallback;
+}
+
+export function getConfiguredModel(provider = getConfiguredProvider()) {
+  const configured = getConfig('llm.model');
+  return configured || getProviderDefaultModel(provider);
+}
+
+export function getModelSelectionMeta(provider = getConfiguredProvider()) {
+  return MODEL_CATALOG[provider] || { defaultModel: null };
+}

package/src/setup/wizard.js

@@ -8,6 +8,7 @@ import { hasSoul, runSoulSetup } from '../soul/index.js';
 import { createServer } from 'http';
 import open from 'open';
 import crypto from 'crypto';
+import { getModelSelectionMeta } from '../llm/models.js';
 
 // ══════════════════════════════════════════════════
 // FIRST-RUN SETUP WIZARD
@@ -52,11 +53,12 @@ export async function runSetupWizard(opts = {}) {
     name: 'provider',
     message: theme.gold('Choose your AI provider:'),
     choices: [
-      { name: '🤖 OpenAI (GPT-4o, GPT-5) — API key or OAuth', value: 'openai' },
-      { name: '🧠 Anthropic (Claude Opus, Sonnet) — API key or OAuth', value: 'anthropic' },
-      { name: '🔀 OpenRouter (any model, one key) — API key', value: 'openrouter' },
-      { name: '🏠 Ollama (local models, free, private) — no key needed', value: 'ollama' },
-      { name: '⏭️  Skip for now', value: 'skip' },
+      { name: 'OpenAI (GPT-4o, GPT-5) - API key or OAuth', value: 'openai' },
+      { name: 'Anthropic (Claude Opus, Sonnet) - API key or OAuth', value: 'anthropic' },
+      { name: 'OpenRouter (any model, one key) - API key', value: 'openrouter' },
+      { name: 'MiniMax (MiniMax-M2.5) - API key', value: 'minimax' },
+      { name: 'Ollama (local models, free, private) - no key needed', value: 'ollama' },
+      { name: 'Skip for now', value: 'skip' },
     ],
   }]);
 
@@ -112,14 +114,17 @@ export async function runSetupWizard(opts = {}) {
 }
 
 /**
- * Setup a cloud provider (OpenAI, Anthropic, OpenRouter)
+ * Setup a cloud provider (OpenAI, Anthropic, OpenRouter, MiniMax)
  */
 async function setupCloudProvider(provider) {
+  await selectAndSaveModel(provider);
+
   const supportsOAuth = ['openai', 'anthropic'].includes(provider);
   const providerName = {
     openai: 'OpenAI',
     anthropic: 'Anthropic',
     openrouter: 'OpenRouter',
+    minimax: 'MiniMax',
   }[provider];
 
   if (supportsOAuth) {
@@ -156,6 +161,7 @@ async function setupAPIKey(provider) {
     openai: 'OpenAI',
     anthropic: 'Anthropic',
     openrouter: 'OpenRouter',
+    minimax: 'MiniMax',
   }[provider];
 
   const { key } = await inquirer.prompt([{
@@ -173,6 +179,7 @@ async function setupAPIKey(provider) {
   success(`${providerName} key saved (encrypted)`);
 
   // Set as default provider
+  setConfig('llm.provider', provider);
   setConfig('llmProvider', provider);
   info(`Default AI provider set to ${provider}`);
 }
@@ -193,22 +200,80 @@ async function setupOllama() {
     default: 'http://localhost:11434',
   }]);
 
+  setConfig('llm.ollamaHost', host);
   setConfig('ollamaHost', host);
 
   const { model } = await inquirer.prompt([{
     type: 'input',
     name: 'model',
     message: theme.gold('Default model:'),
-    default: 'llama3',
+    default: getModelSelectionMeta('ollama').defaultModel,
+    validate: (v) => v.trim().length > 0 || 'Model is required',
   }]);
 
-  setConfig('ollamaModel', model);
+  saveModelConfig(model.trim(), 'ollama');
+  setConfig('llm.provider', 'ollama');
   setConfig('llmProvider', 'ollama');
 
   success(`Ollama configured: ${host} / ${model}`);
   info('Make sure Ollama is running: ollama serve');
 }
 
+async function selectAndSaveModel(provider) {
+  const meta = getModelSelectionMeta(provider);
+  if (!meta || meta.managed) return null;
+
+  if (meta.textInput) {
+    const { model } = await inquirer.prompt([{
+      type: 'input',
+      name: 'model',
+      message: theme.gold('Model:'),
+      default: meta.defaultModel,
+      validate: (v) => v.trim().length > 0 || 'Model is required',
+    }]);
+    saveModelConfig(model.trim(), provider);
+    return model.trim();
+  }
+
+  const choices = (meta.choices || []).map((choice) => ({
+    name: `${choice.value} - ${choice.desc}`,
+    value: choice.value,
+  }));
+
+  if (meta.allowCustom) {
+    choices.push({ name: 'Custom model string', value: '__custom__' });
+  }
+
+  const { selectedModel } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selectedModel',
+    message: theme.gold('Choose model:'),
+    choices,
+    default: meta.defaultModel,
+  }]);
+
+  if (selectedModel === '__custom__') {
+    const { customModel } = await inquirer.prompt([{
+      type: 'input',
+      name: 'customModel',
+      message: theme.gold('Custom model string:'),
+      validate: (v) => v.trim().length > 0 || 'Model is required',
+    }]);
+    saveModelConfig(customModel.trim(), provider);
+    return customModel.trim();
+  }
+
+  saveModelConfig(selectedModel, provider);
+  return selectedModel;
+}
+
+function saveModelConfig(model, provider) {
+  setConfig('llm.model', model);
+  if (provider === 'ollama') {
+    setConfig('ollamaModel', model);
+  }
+}
+
 /**
  * Show instructions for getting API keys
  */
@@ -231,8 +296,14 @@ function showKeyInstructions(provider) {
     console.log(theme.dim('  3. Copy the key (starts with sk-ant-)'));
     console.log(theme.dim('  4. Paste it below'));
     console.log('');
-    console.log(theme.dim('  💡 If you have a Claude Pro/Team subscription,'));
+    console.log(theme.dim('  If you have a Claude Pro/Team subscription,'));
     console.log(theme.dim('     you can use OAuth instead.'));
+  } else if (provider === 'minimax') {
+    showSection('GET A MINIMAX API KEY');
+    console.log(theme.dim('  1. Go to https://platform.minimax.io/docs/guides/models-intro'));
+    console.log(theme.dim('  2. Open your MiniMax developer console / API key page'));
+    console.log(theme.dim('  3. Create or copy an API key'));
+    console.log(theme.dim('  4. Paste it below'));
   }
 
   console.log('');
@@ -432,6 +503,7 @@ async function executeOAuthFlow(provider, clientId, clientSecret) {
             if (tokenData.refresh_token) {
               addKeyDirect(`${provider}_refresh`, tokenData.refresh_token);
             }
+            setConfig('llm.provider', provider);
             setConfig('llmProvider', provider);
 
             res.writeHead(200, { 'Content-Type': 'text/html' });