voyageai-cli 1.30.1 → 1.30.3

package/src/commands/doctor.js

@@ -121,7 +121,7 @@ async function checkApiConnection() {
       });
       
       // Send minimal request body
-      req.write(JSON.stringify({ model: 'voyage-3-lite', input: ['test'] }));
+      req.write(JSON.stringify({ model: 'voyage-4-lite', input: ['test'] }));
       req.end();
     });
     

package/src/commands/embed.js

@@ -1,11 +1,13 @@
 'use strict';
 
 const { getDefaultModel } = require('../lib/catalog');
-const { generateEmbeddings } = require('../lib/api');
-const { resolveTextInput } = require('../lib/input');
+const { generateEmbeddings, generateMultimodalEmbeddings } = require('../lib/api');
+const { resolveTextInput, readMediaAsBase64, isImageFile, isVideoFile } = require('../lib/input');
 const ui = require('../lib/ui');
 const { showCostSummary } = require('../lib/cost-display');
 
+const MULTIMODAL_MODEL = 'voyage-multimodal-3.5';
+
 /**
  * Register the embed command on a Commander program.
  * @param {import('commander').Command} program
@@ -18,6 +20,8 @@ function registerEmbed(program) {
     .option('-t, --input-type <type>', 'Input type: query or document')
     .option('-d, --dimensions <n>', 'Output dimensions', (v) => parseInt(v, 10))
     .option('-f, --file <path>', 'Read text from file')
+    .option('--image <path>', 'Embed an image file (uses voyage-multimodal-3.5)')
+    .option('--video <path>', 'Embed a video file (uses voyage-multimodal-3.5)')
     .option('--truncation', 'Enable truncation for long inputs')
     .option('--no-truncation', 'Disable truncation')
     .option('--output-dtype <type>', 'Output data type: float, int8, uint8, binary, ubinary', 'float')
@@ -28,6 +32,121 @@ function registerEmbed(program) {
     .action(async (text, opts) => {
       try {
         const telemetry = require('../lib/telemetry');
+        const isMultimodal = !!(opts.image || opts.video);
+
+        // Validate: --image/--video are incompatible with --file
+        if (isMultimodal && opts.file) {
+          console.error(ui.error('Cannot combine --image or --video with --file. Use --image/--video for multimodal, or --file for text.'));
+          process.exit(1);
+        }
+
+        // Multimodal path: --image and/or --video
+        if (isMultimodal) {
+          const model = opts.model === getDefaultModel() ? MULTIMODAL_MODEL : opts.model;
+          const useColor = !opts.json;
+          const useSpinner = useColor && !opts.quiet;
+
+          // Build content array
+          const contentItems = [];
+          const mediaMeta = [];
+
+          // Add text if provided
+          if (text) {
+            contentItems.push({ type: 'text', text });
+          }
+
+          // Add image
+          if (opts.image) {
+            if (!isImageFile(opts.image)) {
+              console.error(ui.error(`Not a supported image format: ${opts.image}`));
+              process.exit(1);
+            }
+            const media = readMediaAsBase64(opts.image);
+            contentItems.push({ type: 'image_base64', image_base64: media.base64DataUrl });
+            mediaMeta.push({ type: 'image', path: opts.image, mime: media.mimeType, size: media.sizeBytes });
+          }
+
+          // Add video
+          if (opts.video) {
+            if (!isVideoFile(opts.video)) {
+              console.error(ui.error(`Not a supported video format: ${opts.video}`));
+              process.exit(1);
+            }
+            const media = readMediaAsBase64(opts.video);
+            contentItems.push({ type: 'video_base64', video_base64: media.base64DataUrl });
+            mediaMeta.push({ type: 'video', path: opts.video, mime: media.mimeType, size: media.sizeBytes });
+          }
+
+          if (contentItems.length === 0) {
+            console.error(ui.error('No content provided. Pass text, --image, or --video.'));
+            process.exit(1);
+          }
+
+          const done = telemetry.timer('cli_embed', {
+            model,
+            multimodal: true,
+            hasText: !!text,
+            hasImage: !!opts.image,
+            hasVideo: !!opts.video,
+          });
+
+          let spin;
+          if (useSpinner) {
+            spin = ui.spinner('Generating multimodal embeddings...');
+            spin.start();
+          }
+
+          const mmOpts = { model };
+          if (opts.inputType) mmOpts.inputType = opts.inputType;
+          if (opts.dimensions) mmOpts.outputDimension = opts.dimensions;
+
+          const result = await generateMultimodalEmbeddings([contentItems], mmOpts);
+
+          if (spin) spin.stop();
+
+          if (opts.outputFormat === 'array') {
+            console.log(JSON.stringify(result.data[0].embedding));
+            return;
+          }
+
+          if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+          }
+
+          // Friendly output
+          if (!opts.quiet) {
+            console.log(ui.label('Model', ui.cyan(model)));
+            console.log(ui.label('Mode', ui.cyan('multimodal')));
+            for (const m of mediaMeta) {
+              const sizeStr = m.size < 1024 * 1024
+                ? `${(m.size / 1024).toFixed(1)} KB`
+                : `${(m.size / (1024 * 1024)).toFixed(1)} MB`;
+              console.log(ui.label(m.type === 'image' ? 'Image' : 'Video', `${m.path} ${ui.dim(`(${m.mime}, ${sizeStr})`)}`));
+            }
+            if (text) {
+              console.log(ui.label('Text', ui.dim(text.slice(0, 80) + (text.length > 80 ? '...' : ''))));
+            }
+            if (result.usage) {
+              console.log(ui.label('Tokens', ui.dim(String(result.usage.total_tokens))));
+            }
+            const dims = result.data[0]?.embedding?.length || 'N/A';
+            console.log(ui.label('Dimensions', ui.bold(String(dims))));
+            console.log('');
+          }
+
+          const vector = result.data[0].embedding;
+          const preview = vector.slice(0, 5).map(v => v.toFixed(6)).join(', ');
+          console.log(`[${preview}, ...] (${vector.length} dims)`);
+
+          console.log('');
+          console.log(ui.success('Multimodal embedding generated'));
+
+          done({ dimensions: result.data[0]?.embedding?.length });
+          return;
+        }
+
+        // Standard text embedding path
         const texts = await resolveTextInput(text, opts.file);
 
         // --estimate: show cost comparison, optionally switch model

package/src/commands/index-workspace.js

@@ -1,7 +1,11 @@
 'use strict';
 
 const path = require('path');
-const ora = require('ora');
+let ora;
+async function getOra() {
+  if (!ora) { ora = (await import('ora')).default; }
+  return ora;
+}
 const pc = require('picocolors');
 
 /**
@@ -31,7 +35,7 @@ function registerIndexWorkspace(program) {
       const { handleIndexWorkspace } = require('../mcp/tools/workspace');
       const resolvedPath = workspacePath ? path.resolve(workspacePath) : process.cwd();
 
-      const spinner = ora(`Indexing ${resolvedPath}...`).start();
+      const spinner = (await getOra())(`Indexing ${resolvedPath}...`).start();
 
       try {
         const result = await handleIndexWorkspace({
@@ -74,7 +78,7 @@ function registerIndexWorkspace(program) {
 
         // Create index if requested
         if (opts.createIndex) {
-          const indexSpinner = ora('Creating vector search index...').start();
+          const indexSpinner = (await getOra())('Creating vector search index...').start();
           try {
             const { createVectorIndex } = require('../lib/mongo');
             await createVectorIndex(
@@ -112,7 +116,7 @@ function registerIndexWorkspace(program) {
       telemetry.send('cli_search_code_run', { language: opts.language });
 
       const { handleSearchCode } = require('../mcp/tools/workspace');
-      const spinner = ora('Searching...').start();
+      const spinner = (await getOra())('Searching...').start();
 
       try {
         const result = await handleSearchCode({
@@ -198,7 +202,7 @@ function registerIndexWorkspace(program) {
         process.exit(1);
       }
 
-      const spinner = ora('Finding relevant context...').start();
+      const spinner = (await getOra())('Finding relevant context...').start();
 
       try {
         const result = await handleExplainCode({

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');
 
@@ -273,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 = '';
@@ -1399,9 +1406,58 @@ function createPlaygroundServer() {
             res.end(JSON.stringify({ error: 'inputs must be a non-empty array' }));
             return;
           }
+
+          // Optimize video inputs: downsample to 1fps to fit within 32k token context
+          const os = require('os');
+          const path = require('path');
+          const fs = require('fs');
+          const { execFileSync } = require('child_process');
+          const optimizedInputs = [];
+          for (const input of inputs) {
+            const content = input.content;
+            if (content && Array.isArray(content)) {
+              const optimizedContent = [];
+              for (const item of content) {
+                if (item.type === 'video_base64' && item.video_base64) {
+                  // Downsample video to 1fps using ffmpeg to reduce token count
+                  try {
+                    const b64 = item.video_base64.replace(/^data:[^;]+;base64,/, '');
+                    const tmpIn = path.join(os.tmpdir(), `vai_vid_in_${Date.now()}.mp4`);
+                    const tmpOut = path.join(os.tmpdir(), `vai_vid_out_${Date.now()}.mp4`);
+                    fs.writeFileSync(tmpIn, Buffer.from(b64, 'base64'));
+                    try {
+                      execFileSync('ffmpeg', [
+                        '-y', '-i', tmpIn,
+                        '-vf', 'fps=1',
+                        '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+                        '-an',  // strip audio
+                        tmpOut
+                      ], { timeout: 30000, stdio: 'pipe' });
+                      const optimizedBuf = fs.readFileSync(tmpOut);
+                      const optimizedB64 = `data:video/mp4;base64,${optimizedBuf.toString('base64')}`;
+                      optimizedContent.push({ type: 'video_base64', video_base64: optimizedB64 });
+                    } finally {
+                      try { fs.unlinkSync(tmpIn); } catch (_) {}
+                      try { fs.unlinkSync(tmpOut); } catch (_) {}
+                    }
+                  } catch (err) {
+                    // If optimization fails, send original and let API error naturally
+                    console.warn('[Playground] Video optimization failed:', err.message);
+                    optimizedContent.push(item);
+                  }
+                } else {
+                  optimizedContent.push(item);
+                }
+              }
+              optimizedInputs.push({ ...input, content: optimizedContent });
+            } else {
+              optimizedInputs.push(input);
+            }
+          }
+
           const { apiRequest } = require('../lib/api');
           const mmBody = {
-            inputs,
+            inputs: optimizedInputs,
             model: model || 'voyage-multimodal-3.5',
           };
           if (input_type) mmBody.input_type = input_type;
@@ -1583,9 +1639,13 @@ function createPlaygroundServer() {
                   else if (output.text) summary = output.text.slice(0, 100) + (output.text.length > 100 ? '...' : '');
                   else summary = JSON.stringify(output).slice(0, 200);
                 }
+                // Extract usage data for cost tracking (then strip from output payload)
+                const _usage = (output && output._usage) ? output._usage : undefined;
+                const cleanOutput = _usage ? { ...output } : output;
+                if (cleanOutput && cleanOutput._usage) delete cleanOutput._usage;
                 res.write(`event: step_complete\ndata: ${JSON.stringify({
-                  stepId, timeMs, summary,
-                  output: JSON.stringify(output).length < 5000 ? output : { _truncated: true, summary },
+                  stepId, timeMs, summary, _usage,
+                  output: JSON.stringify(cleanOutput).length < 5000 ? cleanOutput : { _truncated: true, summary },
                 })}\n\n`);
               },
               onStepSkip: (stepId, reason) => {
@@ -1604,6 +1664,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`);

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/api.js

@@ -195,6 +195,36 @@ async function generateEmbeddings(texts, options = {}) {
   return apiRequest('/embeddings', body);
 }
 
+/**
+ * Generate multimodal embeddings for inputs containing text, images, and/or video.
+ * Uses the /multimodalembeddings endpoint with a different input format.
+ * @param {Array<Array<{type: string, text?: string, image_base64?: string, video_base64?: string}>>} inputs
+ *   Array of content arrays. Each content array is a list of content items for one input.
+ *   Example: [[{type: 'text', text: 'hello'}, {type: 'image_base64', image_base64: 'data:image/png;base64,...'}]]
+ * @param {object} options
+ * @param {string} [options.model] - Model name (default: voyage-multimodal-3.5)
+ * @param {string} [options.inputType] - Input type (query|document)
+ * @param {number} [options.outputDimension] - Output dimensions
+ * @returns {Promise<object>} API response with embeddings
+ */
+async function generateMultimodalEmbeddings(inputs, options = {}) {
+  const model = options.model || 'voyage-multimodal-3.5';
+
+  const body = {
+    inputs: inputs.map(contentArray => ({ content: contentArray })),
+    model,
+  };
+
+  if (options.inputType) {
+    body.input_type = options.inputType;
+  }
+  if (options.outputDimension) {
+    body.output_dimension = options.outputDimension;
+  }
+
+  return apiRequest('/multimodalembeddings', body);
+}
+
 module.exports = {
   API_BASE,
   ATLAS_API_BASE,
@@ -204,4 +234,5 @@ module.exports = {
   requireApiKey,
   apiRequest,
   generateEmbeddings,
+  generateMultimodalEmbeddings,
 };