@darksol/terminal 0.9.1 → 0.9.2

package/README.md

@@ -15,7 +15,7 @@ A unified CLI for market intel, trading, AI-powered analysis, on-chain oracle, c
 [![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-gold.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-green.svg)](https://nodejs.org/)
 
-- Current release: **0.9.1**
+- Current release: **0.9.2**
 - Changelog: `CHANGELOG.md`
 
 ## Install

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "DARKSOL Terminal — unified CLI for all DARKSOL services. Market intel, trading, oracle, casino, and more.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -32,6 +32,7 @@ import { clearMemories, exportMemories, getRecentMemories, searchMemories } from
 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');
 
@@ -1137,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)')],
@@ -1153,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')

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',
@@ -41,21 +42,21 @@ const PROVIDERS = {
   },
   minimax: {
     url: 'https://api.minimax.io/v1/chat/completions',
-    defaultModel: 'MiniMax-M2.5',
+    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,
@@ -99,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
@@ -116,6 +117,8 @@ export async function runSetupWizard(opts = {}) {
  * 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',
@@ -204,11 +207,11 @@ async function setupOllama() {
     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('llm.model', model);
-  setConfig('ollamaModel', model);
+  saveModelConfig(model.trim(), 'ollama');
   setConfig('llm.provider', 'ollama');
   setConfig('llmProvider', 'ollama');
 
@@ -216,6 +219,61 @@ async function setupOllama() {
   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
  */

package/src/web/commands.js

@@ -9,6 +9,7 @@ import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
+import { getConfiguredModel, getModelSelectionMeta, getProviderDefaultModel } from '../llm/models.js';
 
 // ══════════════════════════════════════════════════
 // CHAT LOG PERSISTENCE
@@ -416,12 +417,32 @@ export async function handleMenuSelect(id, value, item, ws) {
         })));
         return {};
       }
+      if (value === 'model') {
+        return showModelSelectionMenu(ws);
+      }
       if (value === 'keys') {
         return await handleCommand('keys', ws);
       }
       ws.sendLine('');
       return {};
 
+    case 'config_model':
+      if (value === 'back') {
+        ws.sendLine('');
+        return {};
+      }
+      if (value === '__custom__') {
+        ws.sendPrompt('config_model_input', 'Model:', { provider: getConfig('llm.provider') || 'openai' });
+        return {};
+      }
+      saveSelectedModel(value);
+      chatEngines.delete(ws);
+      ws.sendLine('');
+      ws.sendLine(`  ${ANSI.green}✓ Model set to ${value}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}AI session refreshed.${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+
     case 'main_menu':
       if (value === 'back') {
         ws.sendLine('');
@@ -429,7 +450,6 @@ export async function handleMenuSelect(id, value, item, ws) {
       }
       return await handleCommand(value, ws);
   }
-
   return {};
 }
 
@@ -473,6 +493,23 @@ export async function handlePromptResponse(id, value, meta, ws) {
     return {};
   }
 
+  if (id === 'config_model_input') {
+    const provider = meta?.provider || getConfig('llm.provider') || 'openai';
+    const model = String(value || '').trim();
+    if (!model) {
+      ws.sendLine(`  ${ANSI.red}✗ Model is required${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    saveSelectedModel(model, provider);
+    chatEngines.delete(ws);
+    ws.sendLine(`  ${ANSI.green}✓ Model set to ${model}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}AI session refreshed.${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
   if (id === 'cards_status_id') {
     if (!value) { ws.sendLine(`  ${ANSI.red}✗ Cancelled${ANSI.reset}`); ws.sendLine(''); return {}; }
     return await showCardStatus(value.trim(), ws);
@@ -789,7 +826,9 @@ export function getAIStatus() {
 
   if (connected.length > 0) {
     const names = connected.map(p => SERVICES[p]?.name || p).join(', ');
-    return `  ${green}● AI ready${reset} ${dim}(${names})${reset}\r\n  ${dim}Type ${gold}ai <question>${dim} to start chatting. Chat logs saved to ~/.darksol/chat-logs/${reset}\r\n\r\n`;
+    const provider = getConfig('llm.provider') || connected[0];
+    const model = provider === 'bankr' ? 'gateway managed' : (getConfiguredModel(provider) || getProviderDefaultModel(provider) || 'default');
+    return `  ${green}● AI ready${reset} ${dim}(${names} | ${provider}/${model})${reset}\r\n  ${dim}Type ${gold}ai <question>${dim} to start chatting. Chat logs saved to ~/.darksol/chat-logs/${reset}\r\n\r\n`;
   }
 
   return [
@@ -836,7 +875,7 @@ export async function handleCommand(cmd, ws) {
     case 'mail':
       return await cmdMail(args, ws);
     case 'config':
-      return await cmdConfig(ws);
+      return await cmdConfig(args, ws);
     case 'oracle':
       return await cmdOracle(args, ws);
     case 'cards':
@@ -1794,11 +1833,20 @@ async function cmdFacilitator(args, ws) {
   return {};
 }
 
-async function cmdConfig(ws) {
+async function cmdConfig(args, ws) {
+  const sub = args[0]?.toLowerCase();
+  if (sub === 'model') {
+    return showModelSelectionMenu(ws);
+  }
+
   const chain = getConfig('chain') || 'base';
   const wallet = getConfig('activeWallet') || '(none)';
   const slippage = getConfig('slippage') || '0.5';
   const email = getConfig('mailEmail') || '(none)';
+  const provider = getConfig('llm.provider') || '(not set)';
+  const model = provider === 'bankr'
+    ? 'gateway managed'
+    : getConfiguredModel(provider === '(not set)' ? 'openai' : provider) || '(default)';
 
   ws.sendLine(`${ANSI.gold}  ◆ CONFIG${ANSI.reset}`);
   ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
@@ -1806,12 +1854,15 @@ async function cmdConfig(ws) {
   ws.sendLine(`  ${ANSI.darkGold}Wallet${ANSI.reset}        ${ANSI.white}${wallet}${ANSI.reset}`);
   ws.sendLine(`  ${ANSI.darkGold}Slippage${ANSI.reset}      ${ANSI.white}${slippage}%${ANSI.reset}`);
   ws.sendLine(`  ${ANSI.darkGold}Mail${ANSI.reset}          ${ANSI.white}${email}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.darkGold}LLM Provider${ANSI.reset}  ${ANSI.white}${provider}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.darkGold}LLM Model${ANSI.reset}     ${ANSI.white}${model}${ANSI.reset}`);
   ws.sendLine(`  ${ANSI.darkGold}AI${ANSI.reset}            ${hasAnyLLM() ? `${ANSI.green}● Ready${ANSI.reset}` : `${ANSI.dim}○ Not configured${ANSI.reset}`}`);
   ws.sendLine('');
 
   // Offer interactive config
   ws.sendMenu('config_action', '◆ Configure', [
     { value: 'chain', label: '🔗 Change chain', desc: `Currently: ${chain}` },
+    { value: 'model', label: '🧠 Change model', desc: `Currently: ${model}` },
     { value: 'keys', label: '🔑 LLM / API keys', desc: '' },
     { value: 'back', label: '← Back', desc: '' },
   ]);
@@ -1819,6 +1870,49 @@ async function cmdConfig(ws) {
   return {};
 }
 
+/**
+ * Show model selection menu for current provider
+ */
+function showModelSelectionMenu(ws) {
+  const provider = getConfig('llm.provider') || 'openai';
+  const meta = getModelSelectionMeta(provider);
+
+  if (meta.managed) {
+    ws.sendLine(`  ${ANSI.dim}Bankr selects the backing model automatically.${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  if (meta.textInput) {
+    ws.sendPrompt('config_model_input', 'Model:', { provider });
+    return {};
+  }
+
+  const items = (meta.choices || []).map(choice => ({
+    value: choice.value,
+    label: choice.value,
+    desc: choice.desc,
+  }));
+
+  if (meta.allowCustom) {
+    items.push({ value: '__custom__', label: 'Custom model', desc: 'Type any model string' });
+  }
+
+  items.push({ value: 'back', label: '← Back', desc: '' });
+  ws.sendMenu('config_model', '🧠 Select Model', items);
+  return {};
+}
+
+/**
+ * Save selected model to config
+ */
+function saveSelectedModel(model, provider = getConfig('llm.provider') || 'openai') {
+  setConfig('llm.model', model);
+  if (provider === 'ollama') {
+    setConfig('ollamaModel', model);
+  }
+}
+
 // ══════════════════════════════════════════════════
 // AI CHAT — LLM-powered assistant in the web shell
 // ══════════════════════════════════════════════════