voyageai-cli 1.30.0 → 1.30.2

package/src/commands/mcp-server.js

@@ -53,21 +53,35 @@ function registerMcpServer(program) {
   // Subcommand: install
   cmd
     .command('install [targets...]')
-    .description('Install vai MCP server into AI tool configs (claude, claude-code, cursor, windsurf, vscode, or "all")')
+    .description('Install vai MCP server into AI tool configs (claude, claude-code, cursor, windsurf, vscode, vscode-insiders, or "all")')
     .option('--force', 'Overwrite existing vai entry', false)
     .option('--transport <mode>', 'Transport mode: stdio or http', 'stdio')
     .option('--port <number>', 'HTTP port (http transport only)', (v) => parseInt(v, 10))
     .option('--api-key <key>', 'Voyage API key to embed in config')
+    .option('--mongodb-uri <uri>', 'MongoDB URI to embed in config')
+    .option('--db <name>', 'Default database name')
+    .option('--collection <name>', 'Default collection name')
+    .option('--workspace-path <path>', 'Workspace path for workspace-level config')
+    .option('--verbose', 'Enable verbose MCP logging')
+    .option('--show-tips', 'Show integration tips after install', true)
     .action((targets, opts) => {
       const { TARGETS, installTarget } = require('../mcp/install');
 
       if (!targets.length) {
         console.log('Usage: vai mcp install <target|all>');
-        console.log(`Available targets: ${Object.keys(TARGETS).join(', ')}, all`);
+        console.log(`\nAvailable targets:`);
+        for (const [key, target] of Object.entries(TARGETS)) {
+          const note = target.requiresWorkspace ? ' (workspace-level)' : '';
+          console.log(`  ${key.padEnd(18)} ${target.name}${note}`);
+        }
+        console.log(`  ${'all'.padEnd(18)} Install to all global targets`);
         return;
       }
 
-      const keys = targets.includes('all') ? Object.keys(TARGETS) : targets;
+      // Filter out workspace-only targets for 'all'
+      const keys = targets.includes('all')
+        ? Object.entries(TARGETS).filter(([_, t]) => !t.requiresWorkspace).map(([k]) => k)
+        : targets;
 
       for (const key of keys) {
         try {
@@ -76,8 +90,22 @@ function registerMcpServer(program) {
             transport: opts.transport,
             port: opts.port,
             apiKey: opts.apiKey,
+            mongodbUri: opts.mongodbUri,
+            db: opts.db,
+            collection: opts.collection,
+            workspacePath: opts.workspacePath,
+            verbose: opts.verbose,
           });
           console.log(result.installed ? `✅ ${result.message}` : `⚠️  ${result.message}`);
+
+          // Show tips if available and requested
+          if (result.tips && opts.showTips) {
+            console.log('');
+            for (const tip of result.tips) {
+              console.log(`   ${tip}`);
+            }
+            console.log('');
+          }
         } catch (err) {
           console.error(`❌ ${key}: ${err.message}`);
         }
@@ -123,6 +151,88 @@ function registerMcpServer(program) {
       }
       console.log('');
     });
+
+  // Subcommand: diagnose
+  cmd
+    .command('diagnose [target]')
+    .description('Diagnose MCP installation issues for a specific target')
+    .action((target) => {
+      const { diagnose, TARGETS } = require('../mcp/install');
+
+      if (!target) {
+        console.log('Usage: vai mcp diagnose <target>');
+        console.log(`Available targets: ${Object.keys(TARGETS).join(', ')}`);
+        return;
+      }
+
+      console.log(`\nvai MCP Diagnostics — ${target}\n`);
+
+      const results = diagnose(target);
+      for (const r of results) {
+        const icon = r.level === 'ok' ? '✅' : r.level === 'warning' ? '⚠️ ' : '❌';
+        console.log(`  ${icon} ${r.message}`);
+      }
+      console.log('');
+    });
+
+  // Subcommand: sample-config
+  cmd
+    .command('sample-config <target>')
+    .description('Generate sample MCP config for a target (cursor, vscode, etc.)')
+    .option('--transport <mode>', 'Transport mode: stdio or http', 'stdio')
+    .option('--port <number>', 'HTTP port', (v) => parseInt(v, 10))
+    .action((target, opts) => {
+      const { generateSampleConfig, TARGETS } = require('../mcp/install');
+
+      if (!TARGETS[target]) {
+        console.error(`Unknown target: ${target}. Available: ${Object.keys(TARGETS).join(', ')}`);
+        process.exit(1);
+      }
+
+      const sample = generateSampleConfig(target, {
+        transport: opts.transport,
+        port: opts.port,
+      });
+
+      if (!sample) {
+        console.error('Failed to generate sample config');
+        process.exit(1);
+      }
+
+      console.log(`\n# Sample MCP config for ${TARGETS[target].name}`);
+      console.log(`# Add this to your config file:\n`);
+      console.log(sample);
+    });
+
+  // Subcommand: info
+  cmd
+    .command('info <target>')
+    .description('Show detailed information about a target')
+    .action((target) => {
+      const { getTargetInfo } = require('../mcp/install');
+
+      const info = getTargetInfo(target);
+      if (!info) {
+        console.error(`Unknown target: ${target}`);
+        process.exit(1);
+      }
+
+      console.log(`\n${info.name}\n`);
+      console.log(`  Config path:    ${info.configPath || 'N/A (workspace-level only)'}`);
+      if (info.workspaceConfigPath) {
+        console.log(`  Workspace path: ${info.workspaceConfigPath}`);
+      }
+      if (info.requiresWorkspace) {
+        console.log(`  Note:           Requires --workspace-path option`);
+      }
+      if (info.tips.length > 0) {
+        console.log(`\n  Tips:`);
+        for (const tip of info.tips) {
+          console.log(`    ${tip}`);
+        }
+      }
+      console.log('');
+    });
 }
 
 module.exports = { registerMcpServer };

package/src/commands/playground.js

@@ -134,7 +134,7 @@ function registerPlayground(program) {
  */
 function createPlaygroundServer() {
   const { getApiBase, requireApiKey, generateEmbeddings } = require('../lib/api');
-  const { MODEL_CATALOG } = require('../lib/catalog');
+  const { MODEL_CATALOG, BENCHMARK_SCORES } = require('../lib/catalog');
   const { cosineSimilarity } = require('../lib/math');
   const { getConfigValue } = require('../lib/config');
 
@@ -247,6 +247,24 @@ function createPlaygroundServer() {
         return;
       }
 
+      // Serve vendor assets (bundled JS libraries)
+      const vendorMatch = req.url.match(/^\/vendor\/([a-zA-Z0-9_.-]+\.js)$/);
+      if (req.method === 'GET' && vendorMatch) {
+        const vendorPath = path.join(__dirname, '..', 'playground', 'vendor', vendorMatch[1]);
+        if (fs.existsSync(vendorPath)) {
+          const data = fs.readFileSync(vendorPath);
+          res.writeHead(200, {
+            'Content-Type': 'application/javascript; charset=utf-8',
+            'Cache-Control': 'public, max-age=86400',
+          });
+          res.end(data);
+        } else {
+          res.writeHead(404);
+          res.end('Vendor asset not found');
+        }
+        return;
+      }
+
       // API: Models
       if (req.method === 'GET' && req.url === '/api/models') {
         const models = MODEL_CATALOG.filter(m => !m.legacy && !m.local && !m.unreleased);
@@ -255,6 +273,13 @@ function createPlaygroundServer() {
         return;
       }
 
+      // API: Full Model Catalog (for Models tab)
+      if (req.method === 'GET' && req.url === '/api/models/catalog') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ models: MODEL_CATALOG, benchmarks: BENCHMARK_SCORES }));
+        return;
+      }
+
       // API: Generate code
       if (req.method === 'POST' && req.url === '/api/generate') {
         let body = '';
@@ -460,6 +485,62 @@ function createPlaygroundServer() {
         return;
       }
 
+      // API: MCP status — installation status across all tools
+      if (req.method === 'GET' && req.url === '/api/mcp/status') {
+        try {
+          const { statusAll } = require('../mcp/install');
+          const results = statusAll();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(results));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
+      // API: MCP install — install vai into a target tool
+      if (req.method === 'POST' && req.url === '/api/mcp/install') {
+        try {
+          const body = await readBody(req);
+          const { target, force } = JSON.parse(body);
+          if (!target) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'target is required' }));
+            return;
+          }
+          const { installTarget } = require('../mcp/install');
+          const result = installTarget(target, { force: force || false });
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
+      // API: MCP uninstall — remove vai from a target tool
+      if (req.method === 'POST' && req.url === '/api/mcp/uninstall') {
+        try {
+          const body = await readBody(req);
+          const { target } = JSON.parse(body);
+          if (!target) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'target is required' }));
+            return;
+          }
+          const { uninstallTarget } = require('../mcp/install');
+          const result = uninstallTarget(target);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
       // API: Settings origins — where each config value comes from
       if (req.method === 'GET' && req.url === '/api/settings/origins') {
         const { resolveLLMConfig } = require('../lib/llm');
@@ -1420,15 +1501,23 @@ function createPlaygroundServer() {
         // API: Validate a workflow definition
         if (req.url === '/api/workflows/validate') {
           const { validateWorkflow } = require('../lib/workflow');
-          const { definition } = parsed;
+          const { definition, mode } = parsed;
           if (!definition) {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'definition is required' }));
             return;
           }
-          const errors = validateWorkflow(definition);
+          const validationMode = mode || 'strict';
+          const result = validateWorkflow(definition, { mode: validationMode });
+          
           res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ valid: errors.length === 0, errors }));
+          
+          if (validationMode === 'draft') {
+            res.end(JSON.stringify(result));
+          } else {
+            // Backward compatible format for strict mode
+            res.end(JSON.stringify({ valid: result.length === 0, errors: result }));
+          }
           return;
         }
 
@@ -1522,6 +1611,7 @@ function createPlaygroundServer() {
               totalTimeMs: result.totalTimeMs,
               layers: result.layers,
               steps: result.steps,
+              formatters: result.formatters || null,
             })}\n\n`);
           } catch (err) {
             res.write(`event: error\ndata: ${JSON.stringify({ error: err.message })}\n\n`);
@@ -1532,6 +1622,32 @@ function createPlaygroundServer() {
         }
       }
 
+      // ── Export API endpoints ──
+      const exportMatch = req.url.match(/^\/api\/export\/(workflow|chat|search|benchmark)$/);
+      if (req.method === 'POST' && exportMatch) {
+        const context = exportMatch[1];
+        try {
+          const body = JSON.parse(await readBody(req));
+          const { exportArtifact } = require('../lib/export');
+          const result = await exportArtifact({
+            context,
+            format: body.format || 'json',
+            data: body.data || {},
+            options: body.options || {},
+          });
+          const isBinary = Buffer.isBuffer(result.content);
+          res.writeHead(200, {
+            'Content-Type': result.mimeType,
+            'Content-Disposition': `attachment; filename="${result.suggestedFilename}"`,
+          });
+          res.end(isBinary ? result.content : result.content);
+        } catch (err) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+
       // 404
       res.writeHead(404, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: 'Not found' }));

package/src/commands/quickstart.js

@@ -83,7 +83,7 @@ We'll embed these ${SAMPLE_DOCS.length} sample documents:
   console.log(pc.bold('\nStep 2: Embedding Documents'));
   console.log(pc.dim('─'.repeat(40)));
   console.log(`
-Running: ${pc.cyan('vai embed --model voyage-3-lite')}
+Running: ${pc.cyan('vai embed --model voyage-4-lite')}
 `);
   
   let embeddings;
@@ -91,7 +91,7 @@ Running: ${pc.cyan('vai embed --model voyage-3-lite')}
     process.stdout.write('  Embedding documents... ');
     const result = await embed({
       texts: SAMPLE_DOCS,
-      model: 'voyage-3-lite',
+      model: 'voyage-4-lite',
       inputType: 'document',
     });
     embeddings = result.embeddings;
@@ -99,7 +99,7 @@ Running: ${pc.cyan('vai embed --model voyage-3-lite')}
     console.log(`
   ${pc.green('✓')} Created ${embeddings.length} embeddings
   ${pc.dim(`  Dimensions: ${embeddings[0].length}`)}
-  ${pc.dim(`  Model: voyage-3-lite`)}
+  ${pc.dim(`  Model: voyage-4-lite`)}
 `);
   } catch (err) {
     console.log(pc.red('✗'));
@@ -123,7 +123,7 @@ Query: "${pc.cyan(query)}"
     process.stdout.write('  Embedding query... ');
     const queryResult = await embed({
       texts: [query],
-      model: 'voyage-3-lite',
+      model: 'voyage-4-lite',
       inputType: 'query',
     });
     const queryEmbedding = queryResult.embeddings[0];

package/src/commands/workflow.js

@@ -48,8 +48,13 @@ async function promptForInputs(definition, existingInputs) {
   const { buildInputSteps } = require('../lib/workflow');
   const { createCLIRenderer } = require('../lib/wizard-cli');
   const { runWizard } = require('../lib/wizard');
+  const { loadInputCache } = require('../lib/workflow-input-cache');
 
-  const allSteps = buildInputSteps(definition);
+  // Load cached inputs from last run to use as defaults
+  const workflowName = definition.name || '';
+  const cachedInputs = loadInputCache(workflowName);
+
+  const allSteps = buildInputSteps(definition, cachedInputs);
   // Only prompt for inputs not already provided
   const steps = allSteps.filter(s => !(s.id in existingInputs));
   if (steps.length === 0) return existingInputs;
@@ -93,6 +98,7 @@ function registerWorkflow(program) {
     .option('--db <name>', 'Override default database')
     .option('--collection <name>', 'Override default collection')
     .option('--json', 'Output results as JSON', false)
+    .option('-o, --output <format>', 'Output format: json, table, markdown, text, csv, value:<path>')
     .option('--quiet', 'Suppress progress output', false)
     .option('--dry-run', 'Show execution plan without running', false)
     .option('--verbose', 'Show step details', false)
@@ -232,33 +238,24 @@ function registerWorkflow(program) {
 
         wfDone();
 
+        // Cache inputs for next run
+        try {
+          const { saveInputCache } = require('../lib/workflow-input-cache');
+          saveInputCache(workflowName, opts.input);
+        } catch { /* non-critical, don't fail the run */ }
+
         // Output
-        if (opts.json) {
+        const { formatWorkflowOutput, autoDetectFormat } = require('../lib/workflow-formatters');
+        const fmtHints = definition.formatters || {};
+
+        if (opts.json || opts.output === 'json') {
           console.log(JSON.stringify(result.output, null, 2));
+        } else if (opts.output) {
+          console.log(formatWorkflowOutput(result.output, opts.output, fmtHints));
         } else if (result.output) {
-          // Pretty-print top results if they exist
-          const output = result.output;
-          if (output.results && Array.isArray(output.results)) {
-            const top = output.results.slice(0, 5);
-            console.log(pc.bold('Top results:'));
-            for (let i = 0; i < top.length; i++) {
-              const r = top[i];
-              const source = r.source || r.text?.slice(0, 50) || `result ${i + 1}`;
-              const score = r.score != null ? ` (${r.score.toFixed(2)})` : '';
-              console.log(`  ${pc.dim(`[${i + 1}]`)} ${source}${pc.dim(score)}`);
-            }
-          } else if (output.summary) {
-            console.log(output.summary);
-          } else if (output.comparison) {
-            console.log(pc.bold('Cost comparison:'));
-            for (const item of output.comparison) {
-              if (item && item.model) {
-                console.log(`  ${pc.cyan(item.model)}: $${item.totalCost} total (embed: $${item.embeddingCost}, queries: $${item.monthlyQueryCost}/mo)`);
-              }
-            }
-          } else {
-            console.log(JSON.stringify(output, null, 2));
-          }
+          // Auto-detect best format from output shape and workflow hints
+          const bestFormat = autoDetectFormat(result.output, fmtHints);
+          console.log(formatWorkflowOutput(result.output, bestFormat, fmtHints));
         }
       } catch (err) {
         console.error(ui.error(err.message));
@@ -862,8 +859,9 @@ function registerWorkflow(program) {
   // ── workflow create ──
   wfCmd
     .command('create')
-    .description('Scaffold a publish-ready npm package from a workflow')
+    .description('Interactive workflow builder -- scaffold a validated, publish-ready workflow package')
     .option('--from <file>', 'Existing workflow JSON to package')
+    .option('--from-description <desc>', 'Generate a workflow skeleton from a text description')
     .option('--name <name>', 'Package name (without vai-workflow- prefix)')
     .option('--author <name>', 'Author name')
     .option('--description <desc>', 'Package description')
@@ -871,8 +869,9 @@ function registerWorkflow(program) {
     .option('--scope <scope>', 'Package scope (e.g. "vaicli" for @vaicli/vai-workflow-*)')
     .option('--output <dir>', 'Output directory')
     .action(async (opts) => {
-      const { scaffoldPackage, toPackageName, CATEGORIES, emptyWorkflowTemplate } = require('../lib/workflow-scaffold');
-      const { loadWorkflow } = require('../lib/workflow');
+      const { scaffoldPackage, toPackageName, CATEGORIES } = require('../lib/workflow-scaffold');
+      const { loadWorkflow, validateWorkflow, buildExecutionPlan } = require('../lib/workflow');
+      const { runInteractiveBuilder, workflowFromDescription } = require('../lib/workflow-builder');
 
       let definition;
       let name = opts.name;
@@ -894,50 +893,85 @@ function registerWorkflow(program) {
         if (!description) {
           description = definition.description;
         }
-      } else if (process.stdin.isTTY) {
-        // Interactive mode
+      } else if (opts.fromDescription) {
+        // Generate from text description
         try {
+          definition = workflowFromDescription(opts.fromDescription);
+          name = name || definition.name;
+          description = description || definition.description;
+
           const p = require('@clack/prompts');
-          p.intro(pc.bold('Create a new workflow package'));
-
-          const answers = await p.group({
-            name: () => p.text({ message: 'Workflow name', placeholder: 'my-workflow', validate: v => v ? undefined : 'Required' }),
-            description: () => p.text({ message: 'Description', placeholder: 'A brief description of what this workflow does' }),
-            category: () => p.select({
-              message: 'Category',
-              options: CATEGORIES.map(c => ({ value: c, label: c })),
-            }),
-            author: () => p.text({ message: 'Author', placeholder: 'Your Name', defaultValue: getGitAuthor() }),
-          });
-
-          if (p.isCancel(answers)) {
-            p.cancel('Cancelled.');
-            process.exit(0);
+          p.intro(pc.bold('Generated workflow from description'));
+
+          // Show what was generated
+          p.log.info(`Name: ${pc.cyan(definition.name)}`);
+          p.log.info(`Steps: ${definition.steps.map(s => `${pc.cyan(s.id)} (${s.tool})`).join(' -> ')}`);
+          p.log.info(`Inputs: ${Object.keys(definition.inputs).join(', ') || 'none'}`);
+
+          // Show execution plan
+          try {
+            const layers = buildExecutionPlan(definition.steps);
+            p.log.info(pc.bold('Execution plan:'));
+            for (let i = 0; i < layers.length; i++) {
+              p.log.message(`  Layer ${i + 1}: ${layers[i].join(', ')}`);
+            }
+          } catch (e) { /* skip */ }
+
+          // Validate
+          const errors = validateWorkflow(definition);
+          if (errors.length > 0) {
+            p.log.warn('Validation issues:');
+            for (const err of errors) {
+              p.log.warn(`  ${err}`);
+            }
+          } else {
+            p.log.success('Workflow validates successfully!');
           }
 
-          name = answers.name;
-          description = answers.description;
-          category = answers.category;
-          author = answers.author;
-          definition = emptyWorkflowTemplate();
-          definition.name = name;
-          definition.description = description || '';
-          // Add a placeholder step so validation passes
-          definition.steps = [{
-            id: 'search',
-            tool: 'query',
-            name: 'Search',
-            inputs: { query: '{{ inputs.query }}' },
-          }];
-          definition.inputs = {
-            query: { type: 'string', required: true, description: 'Search query' },
-          };
+          // Ask for category if not provided
+          if (!category) {
+            const { guessCategory, extractTools } = require('../lib/workflow-scaffold');
+            category = guessCategory(extractTools(definition));
+          }
+
+          // Ask for author if not provided
+          if (!author) {
+            author = getGitAuthor();
+          }
+
+          // Confirm or edit
+          const proceed = await p.confirm({ message: 'Scaffold this workflow as a package?', initialValue: true });
+          if (p.isCancel(proceed) || !proceed) {
+            // Write just the workflow.json for manual editing
+            const fs = require('fs');
+            const filename = `${definition.name}.vai-workflow.json`;
+            fs.writeFileSync(filename, JSON.stringify(definition, null, 2) + '\n');
+            p.log.info(`Wrote ${pc.cyan(filename)} for manual editing.`);
+            p.outro('Edit the file and run `vai workflow create --from <file>` when ready.');
+            return;
+          }
         } catch (err) {
+          console.error(ui.error(`Generation failed: ${err.message}`));
+          process.exit(1);
+        }
+      } else if (process.stdin.isTTY) {
+        // Full interactive builder
+        try {
+          const result = await runInteractiveBuilder();
+          definition = result.definition;
+          name = name || result.name;
+          description = description || result.description;
+          category = category || result.category;
+          author = author || result.author;
+        } catch (err) {
+          if (err.message && err.message.includes('cancelled')) {
+            process.exit(0);
+          }
           console.error(ui.error(`Interactive mode failed: ${err.message}`));
           process.exit(1);
         }
       } else {
-        console.error(ui.error('Provide --from <file> or run interactively (TTY required).'));
+        console.error(ui.error('Provide --from <file>, --from-description "text", or run interactively (TTY required).'));
         process.exit(1);
       }
 
@@ -965,8 +999,8 @@ function registerWorkflow(program) {
         }
         console.log();
         console.log('Next steps:');
-        console.log(`  1. ${opts.from ? '' : pc.dim('Edit workflow.json with your workflow definition')}${opts.from ? 'Review README.md' : ''}`);
-        console.log(`  2. cd ${pkgName}`);
+        console.log(`  1. ${opts.from ? 'Review README.md' : `cd ${pkgName} && review workflow.json`}`);
+        console.log(`  2. ${pc.dim('vai workflow validate')} ${pkgName}/workflow.json`);
         console.log(`  3. npm publish`);
         console.log();
       } catch (err) {
@@ -1021,6 +1055,39 @@ function registerWorkflow(program) {
       console.log(`  ${pc.dim('Run with:')} vai workflow run ${filename} --input query="your question"`);
       console.log(`  ${pc.dim('Validate:')} vai workflow validate ${filename}`);
     });
+
+  // ── workflow clear-cache [name] ──
+  wfCmd
+    .command('clear-cache [name]')
+    .description('Clear cached workflow inputs (from previous runs)')
+    .action((name) => {
+      const { clearInputCache, loadInputCache, slugify, CACHE_PATH } = require('../lib/workflow-input-cache');
+      const fs = require('fs');
+
+      if (name) {
+        const cached = loadInputCache(name);
+        const keys = Object.keys(cached);
+        if (keys.length === 0) {
+          console.log(pc.dim(`No cached inputs for "${name}".`));
+          return;
+        }
+        clearInputCache(name);
+        console.log(ui.success(`Cleared cached inputs for "${name}" (${keys.length} field${keys.length === 1 ? '' : 's'}).`));
+      } else {
+        // Clear all
+        let count = 0;
+        try {
+          const raw = fs.readFileSync(CACHE_PATH, 'utf-8');
+          count = Object.keys(JSON.parse(raw)).length;
+        } catch { /* no file */ }
+        if (count === 0) {
+          console.log(pc.dim('No cached workflow inputs.'));
+          return;
+        }
+        clearInputCache();
+        console.log(ui.success(`Cleared cached inputs for ${count} workflow${count === 1 ? '' : 's'}.`));
+      }
+    });
 }
 
 /**

package/src/lib/catalog.js

@@ -39,8 +39,10 @@ const MODEL_CATALOG = [
   { name: 'voyage-4-nano', type: 'embedding', context: '32K', dimensions: '512 (default), 128, 256', price: 'Open-weight (free)', pricePerMToken: 0, bestFor: 'Open-weight / edge / local', shortFor: 'Open / edge', local: true, unreleased: true, family: 'voyage-4', architecture: 'dense', sharedSpace: 'voyage-4', huggingface: 'https://huggingface.co/voyageai/voyage-4-nano', rtebScore: null },
   // Legacy models
   { name: 'voyage-3-large', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.18/1M tokens', pricePerMToken: 0.18, bestFor: 'Previous gen quality', shortFor: 'Previous gen quality', legacy: true, rtebScore: null },
-  { name: 'voyage-3.5', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.06/1M tokens', pricePerMToken: 0.06, bestFor: 'Previous gen balanced', shortFor: 'Previous gen balanced', legacy: true, rtebScore: null },
-  { name: 'voyage-3.5-lite', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.02/1M tokens', pricePerMToken: 0.02, bestFor: 'Previous gen budget', shortFor: 'Previous gen budget', legacy: true, rtebScore: null },
+  { name: 'voyage-3', type: 'embedding', context: '32K', dimensions: '1024', price: '$0.06/1M tokens', pricePerMToken: 0.06, bestFor: 'Previous gen balanced', shortFor: 'Previous gen balanced', legacy: true, rtebScore: null },
+  { name: 'voyage-3-lite', type: 'embedding', context: '32K', dimensions: '512', price: '$0.02/1M tokens', pricePerMToken: 0.02, bestFor: 'Previous gen budget', shortFor: 'Previous gen budget', legacy: true, rtebScore: null },
+  { name: 'voyage-3.5', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.06/1M tokens', pricePerMToken: 0.06, bestFor: 'Previous gen balanced (3.5)', shortFor: 'Previous gen 3.5', legacy: true, rtebScore: null },
+  { name: 'voyage-3.5-lite', type: 'embedding', context: '32K', dimensions: '1024 (default), 256, 512, 2048', price: '$0.02/1M tokens', pricePerMToken: 0.02, bestFor: 'Previous gen budget (3.5)', shortFor: 'Previous gen 3.5-lite', legacy: true, rtebScore: null },
   { name: 'voyage-code-2', type: 'embedding', context: '16K', dimensions: '1536', price: '$0.12/1M tokens', pricePerMToken: 0.12, bestFor: 'Legacy code', shortFor: 'Legacy code', legacy: true },
   { name: 'voyage-multimodal-3', type: 'embedding-multimodal', context: '32K', dimensions: '1024', price: '$0.12/1M tokens', pricePerMToken: 0.12, bestFor: 'Legacy multimodal', shortFor: 'Legacy multimodal', legacy: true, multimodal: true },
   { name: 'rerank-2', type: 'reranking', context: '16K', dimensions: '—', price: '$0.05/1M tokens', pricePerMToken: 0.05, bestFor: 'Legacy reranker', shortFor: 'Legacy reranker', legacy: true },