voyageai-cli 1.30.2 → 1.30.5

package/README.md

@@ -512,6 +512,26 @@ echo "your-key" | vai config set api-key --stdin
 vai config set mongodb-uri "mongodb+srv://..."
 ```
 
+#### All Config Keys
+
+| CLI Key | Description | Example |
+|---------|-------------|---------|
+| `api-key` | Voyage AI API key | `vai config set api-key pa-...` |
+| `mongodb-uri` | MongoDB Atlas connection string | `vai config set mongodb-uri "mongodb+srv://..."` |
+| `base-url` | Override API endpoint (Atlas AI or Voyage) | `vai config set base-url https://ai.mongodb.com/v1` |
+| `default-model` | Default embedding model | `vai config set default-model voyage-3` |
+| `default-dimensions` | Default output dimensions | `vai config set default-dimensions 512` |
+| `default-db` | Default MongoDB database for workflows/commands | `vai config set default-db my_knowledge_base` |
+| `default-collection` | Default MongoDB collection for workflows/commands | `vai config set default-collection documents` |
+| `llm-provider` | LLM provider for chat/generate (`anthropic`, `openai`, `ollama`) | `vai config set llm-provider anthropic` |
+| `llm-api-key` | LLM provider API key | `vai config set llm-api-key sk-...` |
+| `llm-model` | LLM model override | `vai config set llm-model claude-sonnet-4-5-20250929` |
+| `llm-base-url` | LLM endpoint override (e.g. for Ollama) | `vai config set llm-base-url http://localhost:11434` |
+| `show-cost` | Show cost estimates after operations | `vai config set show-cost true` |
+| `telemetry` | Enable/disable anonymous usage telemetry | `vai config set telemetry false` |
+
+Config is stored in `~/.vai/config.json`. Use `vai config get` to see all values (secrets are masked) or `vai config get <key>` for a specific value. The desktop app's Settings → Database page also reads and writes this file.
+
 ### Shell Completions
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voyageai-cli",
-  "version": "1.30.2",
+  "version": "1.30.5",
   "description": "CLI for Voyage AI embeddings, reranking, and MongoDB Atlas Vector Search",
   "bin": {
     "vai": "./src/cli.js"
@@ -34,7 +34,8 @@
     "url": "https://github.com/mrlynn/voyageai-cli/issues"
   },
   "scripts": {
-    "test": "node --test test/**/*.test.js"
+    "test": "node --test test/**/*.test.js",
+    "release": "./scripts/release.sh"
   },
   "engines": {
     "node": ">=20.0.0"

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

@@ -541,6 +541,87 @@ function createPlaygroundServer() {
         return;
       }
 
+      // API: Settings — read/write ~/.vai/config.json
+      if (req.method === 'GET' && req.url === '/api/settings') {
+        const { loadConfig, KEY_MAP, SECRET_KEYS, maskSecret } = require('../lib/config');
+        const config = loadConfig();
+
+        // Build response: CLI key name → masked/raw value, for every known key
+        const reverseMap = {};
+        for (const [cliKey, internalKey] of Object.entries(KEY_MAP)) {
+          reverseMap[internalKey] = cliKey;
+        }
+
+        const settings = {};
+        for (const [internalKey, cliKey] of Object.entries(reverseMap)) {
+          const value = config[internalKey];
+          settings[cliKey] = {
+            value: value != null ? (SECRET_KEYS.has(internalKey) ? maskSecret(value) : value) : null,
+            isSet: value != null,
+            isSecret: SECRET_KEYS.has(internalKey),
+            internalKey,
+          };
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(settings));
+        return;
+      }
+
+      if (req.method === 'PUT' && req.url === '/api/settings') {
+        const { loadConfig, saveConfig, KEY_MAP, SECRET_KEYS } = require('../lib/config');
+        const body = await readBody(req);
+        let updates;
+        try {
+          updates = JSON.parse(body);
+        } catch {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Invalid JSON' }));
+          return;
+        }
+
+        const config = loadConfig();
+        const applied = [];
+
+        for (const [cliKey, value] of Object.entries(updates)) {
+          const internalKey = KEY_MAP[cliKey];
+          if (!internalKey) {
+            continue; // Skip unknown keys
+          }
+          // Don't overwrite secrets with masked values
+          if (SECRET_KEYS.has(internalKey) && typeof value === 'string' && value.includes('...')) {
+            continue;
+          }
+          if (value === null || value === '') {
+            delete config[internalKey];
+          } else {
+            config[internalKey] = value;
+          }
+          applied.push(cliKey);
+        }
+
+        saveConfig(config);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ applied, message: `Updated ${applied.length} setting(s)` }));
+        return;
+      }
+
+      // API: Settings reveal — return unmasked value for a specific secret key
+      if (req.method === 'GET' && req.url.startsWith('/api/settings/reveal/')) {
+        const { loadConfig, KEY_MAP, SECRET_KEYS } = require('../lib/config');
+        const cliKey = req.url.replace('/api/settings/reveal/', '');
+        const internalKey = KEY_MAP[cliKey];
+        if (!internalKey || !SECRET_KEYS.has(internalKey)) {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Not found or not a secret key' }));
+          return;
+        }
+        const config = loadConfig();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ value: config[internalKey] || null }));
+        return;
+      }
+
       // API: Settings origins — where each config value comes from
       if (req.method === 'GET' && req.url === '/api/settings/origins') {
         const { resolveLLMConfig } = require('../lib/llm');
@@ -561,8 +642,8 @@ function createPlaygroundServer() {
           provider: resolveOrigin('VAI_LLM_PROVIDER', 'llmProvider', chatConf.provider),
           model: resolveOrigin('VAI_LLM_MODEL', 'llmModel', chatConf.model),
           llmApiKey: resolveOrigin('VAI_LLM_API_KEY', 'llmApiKey'),
-          db: proj.db ? 'project' : 'default',
-          collection: proj.collection ? 'project' : 'default',
+          db: resolveOrigin(null, 'defaultDb', proj.db),
+          collection: resolveOrigin(null, 'defaultCollection', proj.collection),
         };
 
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1406,9 +1487,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;
@@ -1590,9 +1720,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) => {

package/src/commands/workflow.js

@@ -529,6 +529,36 @@ function registerWorkflow(program) {
       }
     });
 
+  // ── workflow integration-test ──
+  wfCmd
+    .command('integration-test')
+    .description('Run live integration tests against use-case domain datasets')
+    .option('--domain <slug>', 'Test only a specific domain (devdocs, healthcare, finance, legal)')
+    .option('--workflow <name>', 'Test only a specific workflow')
+    .option('--no-seed', 'Skip seeding (assumes data already exists)')
+    .option('--teardown', 'Drop test collections after running')
+    .option('--sample-docs <path>', 'Override base path for sample documents')
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (opts) => {
+      // Delegate to the integration test runner
+      const { execFileSync } = require('child_process');
+      const runnerPath = path.join(__dirname, '../../test/integration/run.js');
+      const args = [];
+      if (opts.domain) args.push('--domain', opts.domain);
+      if (opts.workflow) args.push('--workflow', opts.workflow);
+      if (opts.seed === false) args.push('--no-seed');
+      if (opts.teardown) args.push('--teardown');
+      if (opts.sampleDocs) args.push('--sample-docs', opts.sampleDocs);
+      if (opts.json) args.push('--json');
+
+      try {
+        execFileSync(process.execPath, [runnerPath, ...args], { stdio: 'inherit' });
+      } catch (err) {
+        if (err.status) process.exit(err.status);
+        throw err;
+      }
+    });
+
   // ── workflow validate <file> ──
   wfCmd
     .command('validate <file>')

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,
 };

package/src/lib/config.js

@@ -18,7 +18,9 @@ const KEY_MAP = {
   'llm-api-key': 'llmApiKey',
   'llm-model': 'llmModel',
   'llm-base-url': 'llmBaseUrl',
-  'show-cost': 'show-cost',
+  'default-db': 'defaultDb',
+  'default-collection': 'defaultCollection',
+  'show-cost': 'showCost',
   'telemetry': 'telemetry',
 };
 

package/src/lib/cost-display.js

@@ -89,7 +89,7 @@ function showCombinedCostSummary(operations, opts = {}) {
  * @returns {boolean}
  */
 function isEnabled() {
-  const val = getConfigValue('show-cost');
+  const val = getConfigValue('showCost') || getConfigValue('show-cost');
   return val === true || val === 'true';
 }
 

package/src/lib/input.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const fs = require('fs');
+const path = require('path');
 
 /**
  * Read text input from argument, --file flag, or stdin.
@@ -37,4 +38,94 @@ async function resolveTextInput(textArg, filePath) {
   process.exit(1);
 }
 
-module.exports = { resolveTextInput };
+/**
+ * MIME type mappings for supported image formats.
+ */
+const IMAGE_MIME_TYPES = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.tiff': 'image/tiff',
+  '.tif': 'image/tiff',
+};
+
+/**
+ * MIME type mappings for supported video formats.
+ */
+const VIDEO_MIME_TYPES = {
+  '.mp4': 'video/mp4',
+  '.mpeg': 'video/mpeg',
+  '.mpg': 'video/mpeg',
+  '.mov': 'video/quicktime',
+  '.avi': 'video/x-msvideo',
+  '.mkv': 'video/x-matroska',
+  '.webm': 'video/webm',
+  '.flv': 'video/x-flv',
+  '.wmv': 'video/x-ms-wmv',
+};
+
+/**
+ * Check if a file path is a supported image format.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function isImageFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext in IMAGE_MIME_TYPES;
+}
+
+/**
+ * Check if a file path is a supported video format.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function isVideoFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext in VIDEO_MIME_TYPES;
+}
+
+/**
+ * Read a media file (image or video) and return it as a base64 data URL.
+ * @param {string} filePath - Path to the media file
+ * @returns {{ base64DataUrl: string, mimeType: string, sizeBytes: number }}
+ */
+function readMediaAsBase64(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = IMAGE_MIME_TYPES[ext] || VIDEO_MIME_TYPES[ext];
+
+  if (!mimeType) {
+    const supported = [
+      ...Object.keys(IMAGE_MIME_TYPES),
+      ...Object.keys(VIDEO_MIME_TYPES),
+    ].join(', ');
+    throw new Error(
+      `Unsupported media format "${ext}". Supported: ${supported}`
+    );
+  }
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const buffer = fs.readFileSync(filePath);
+  const base64 = buffer.toString('base64');
+  const base64DataUrl = `data:${mimeType};base64,${base64}`;
+
+  return {
+    base64DataUrl,
+    mimeType,
+    sizeBytes: buffer.length,
+  };
+}
+
+module.exports = {
+  resolveTextInput,
+  readMediaAsBase64,
+  isImageFile,
+  isVideoFile,
+  IMAGE_MIME_TYPES,
+  VIDEO_MIME_TYPES,
+};