@juspay/neurolink 9.64.0 → 9.65.0

package/dist/cli/commands/mcp.js

@@ -2286,7 +2286,36 @@ ${tools.length > 0 ? tools.map((t) => `- **${t}**: TODO: Add description`).join(
                 logger.error(chalk.red("Tool name is required. Use --tool <name> or --list to see all tools."));
                 process.exit(1);
             }
+            // `--infer` standalone path: when the user passes `--tool <name> --infer`
+            // and no server scope, emit the heuristic annotations inferred purely
+            // from the tool name/description. This makes `--infer` useful in any
+            // environment (no MCP servers required) and matches user intent —
+            // "show me what NeuroLink would infer for a tool with this name".
             const serverId = argv.server;
+            if (argv.infer &&
+                !serverId &&
+                servers.filter((s) => s.status === "connected").length === 0) {
+                const inferred = inferAnnotations({
+                    name: toolName,
+                    description: "",
+                });
+                const errors = validateAnnotations(inferred);
+                if (errors.length > 0) {
+                    logger.error(chalk.red("Inferred annotations validation errors:"));
+                    for (const error of errors) {
+                        logger.error(chalk.red(`  - ${error}`));
+                    }
+                    process.exit(1);
+                }
+                if (argv.format === "json") {
+                    logger.always(JSON.stringify({ tool: toolName, inferred: true, annotations: inferred }, null, 2));
+                }
+                else {
+                    logger.always(chalk.bold(`\nInferred annotations for ${chalk.cyan(toolName)}:`));
+                    logger.always(JSON.stringify(inferred, null, 2));
+                }
+                return;
+            }
             const foundTool = this.findToolForAnnotation(servers, toolName, serverId);
             if (foundTool === "ambiguous") {
                 logger.error(chalk.red(`Tool '${toolName}' exists on multiple servers. Use --server <id> to specify which server to annotate.`));

package/dist/cli/commands/proxy.js

@@ -565,20 +565,39 @@ export function mapClaudeErrorTypeToStatus(errorType) {
     }
 }
 async function ensureProxyStartAllowed(spinner) {
+    const ignoreLaunchd = process.env.NEUROLINK_PROXY_IGNORE_LAUNCHD === "1" ||
+        process.env.NEUROLINK_PROXY_IGNORE_LAUNCHD === "true";
     const existingState = loadProxyState();
     if (existingState) {
         if (isProcessRunning(existingState.pid)) {
-            if (spinner) {
-                spinner.fail(chalk.red(`Proxy already running on port ${existingState.port} (PID: ${existingState.pid})`));
+            // Test / dev escape hatch: when NEUROLINK_PROXY_IGNORE_LAUNCHD is set,
+            // allow starting a second proxy on the test's requested port even if
+            // a launchd-managed instance is using a different port (its state
+            // file is what we hit here). The shared port-conflict surface remains
+            // — node will fail to bind if the requested port is actually busy.
+            if (!ignoreLaunchd) {
+                if (spinner) {
+                    spinner.fail(chalk.red(`Proxy already running on port ${existingState.port} (PID: ${existingState.pid})`));
+                }
+                logger.always(chalk.yellow("Stop it first or use 'neurolink proxy status' to inspect"));
+                process.exit(process.ppid === 1 ? 0 : 1);
             }
-            logger.always(chalk.yellow("Stop it first or use 'neurolink proxy status' to inspect"));
-            process.exit(process.ppid === 1 ? 0 : 1);
         }
-        clearProxyState();
+        else {
+            clearProxyState();
+        }
     }
     if (process.ppid === 1 || !(await isLaunchdManaging())) {
         return;
     }
+    // Test / dev escape hatch: when starting on an explicit non-default port,
+    // the launchd-managed proxy (typically on its own port) cannot conflict.
+    // Setting `NEUROLINK_PROXY_IGNORE_LAUNCHD=1` lets the test suite start a
+    // standalone proxy alongside the launchd one without removing the daemon.
+    if (process.env.NEUROLINK_PROXY_IGNORE_LAUNCHD === "1" ||
+        process.env.NEUROLINK_PROXY_IGNORE_LAUNCHD === "true") {
+        return;
+    }
     if (spinner) {
         spinner.fail(chalk.red("Proxy is managed by launchd. Manual start would cause port conflicts."));
     }

package/dist/cli/factories/commandFactory.d.ts

@@ -54,6 +54,16 @@ export declare class CLICommandFactory {
      * Saves generated video to file when --videoOutput flag is provided
      */
     private static handleVideoOutput;
+    /**
+     * Helper method to handle avatar video file output.
+     * Saves the generated avatar buffer to --avatarOutput path when provided.
+     */
+    private static handleAvatarOutput;
+    /**
+     * Helper method to handle music audio file output.
+     * Saves the generated music buffer to --musicOutput path when provided.
+     */
+    private static handleMusicOutput;
     /**
      * Helper method to handle PPT file output
      * Displays PPT generation result info
@@ -142,7 +152,7 @@ export declare class CLICommandFactory {
      */
     private static handleGenerateStdinInput;
     /**
-     * Detect output mode (video, ppt, or text) based on CLI arguments
+     * Detect output mode (video, ppt, avatar, music, or text) based on CLI arguments
      */
     private static detectGenerateOutputMode;
     /**

package/dist/cli/factories/commandFactory.js

@@ -90,6 +90,28 @@ export class CLICommandFactory {
                 "lms",
                 "llamacpp",
                 "llama.cpp",
+                "xai",
+                "grok",
+                "groq",
+                "cohere",
+                "together-ai",
+                "together",
+                "fireworks",
+                "perplexity",
+                "pplx",
+                "cloudflare",
+                "workers-ai",
+                "cf-ai",
+                "replicate",
+                "voyage",
+                "voyage-ai",
+                "jina",
+                "jina-ai",
+                "stability",
+                "stability-ai",
+                "sd",
+                "ideogram",
+                "recraft",
             ],
             default: "auto",
             description: "AI provider to use (auto-selects best available). Use 'anthropic-subscription' for Claude subscription plans.",
@@ -366,12 +388,16 @@ export class CLICommandFactory {
             type: "string",
             description: "Path to audio file for STT transcription",
         },
-        // Video Generation options (Veo 3.1)
+        // Video Generation options (Veo 3.1, Kling, Runway, Replicate)
         outputMode: {
             type: "string",
-            choices: ["text", "video", "ppt"],
+            choices: ["text", "video", "ppt", "avatar", "music"],
             default: "text",
-            description: "Output mode: 'text' for standard generation, 'video' for video, 'ppt' for presentation",
+            description: "Output mode: 'text' (default), 'video' (Veo/Kling/Runway/Replicate), 'ppt' (presentation), 'avatar' (D-ID/HeyGen/MuseTalk talking-head), 'music' (Beatoven/ElevenLabs/Lyria/MusicGen)",
+        },
+        videoProvider: {
+            type: "string",
+            description: "Video provider override (e.g., 'vertex' (default), 'kling', 'runway', 'replicate')",
         },
         videoOutput: {
             type: "string",
@@ -381,25 +407,86 @@ export class CLICommandFactory {
         videoResolution: {
             type: "string",
             choices: ["720p", "1080p"],
-            default: "720p",
-            description: "Video output resolution (720p or 1080p)",
+            description: "Video output resolution (720p or 1080p; provider default applied if omitted)",
         },
         videoLength: {
             type: "number",
             choices: [4, 6, 8],
-            default: 4,
-            description: "Video duration in seconds (4, 6, or 8)",
+            description: "Video duration in seconds (4, 6, or 8; provider default applied if omitted)",
         },
         videoAspectRatio: {
             type: "string",
             choices: ["9:16", "16:9"],
-            default: "16:9",
-            description: "Video aspect ratio (9:16 for portrait, 16:9 for landscape)",
+            description: "Video aspect ratio (9:16 for portrait, 16:9 for landscape; provider default applied if omitted)",
         },
         videoAudio: {
             type: "boolean",
-            default: true,
-            description: "Enable/disable audio generation in video",
+            description: "Enable/disable audio generation in video (provider default applied if omitted)",
+        },
+        // Avatar Generation options (D-ID, HeyGen, MuseTalk via Replicate)
+        avatarProvider: {
+            type: "string",
+            description: "Avatar provider (e.g., 'd-id' (default), 'heygen', 'replicate', 'musetalk')",
+        },
+        avatarImage: {
+            type: "string",
+            description: "Path to source portrait image (or HeyGen avatar id when --avatarProvider heygen)",
+        },
+        avatarAudio: {
+            type: "string",
+            description: "Path to narration audio (alternative to --avatarText)",
+        },
+        avatarText: {
+            type: "string",
+            description: "Text the avatar should speak (the provider runs TTS internally)",
+        },
+        avatarVoice: {
+            type: "string",
+            description: "Voice id for TTS-driven avatars (provider-specific catalog id)",
+        },
+        avatarQuality: {
+            type: "string",
+            choices: ["standard", "hd"],
+            description: "Avatar output quality preset (provider default applied if omitted)",
+        },
+        avatarFormat: {
+            type: "string",
+            choices: ["mp4", "webm", "mov"],
+            description: "Avatar video output format (provider default applied if omitted)",
+        },
+        avatarOutput: {
+            type: "string",
+            description: "Path to save generated avatar video (e.g., ./avatar.mp4)",
+        },
+        // Music Generation options (Beatoven, ElevenLabs, Lyria, MusicGen via Replicate)
+        musicProvider: {
+            type: "string",
+            description: "Music provider (e.g., 'beatoven' (default), 'elevenlabs-music', 'lyria', 'replicate', 'musicgen')",
+        },
+        musicDuration: {
+            type: "number",
+            description: "Music duration in seconds (provider-clamped)",
+        },
+        musicFormat: {
+            type: "string",
+            choices: ["mp3", "wav", "flac", "ogg"],
+            description: "Music output format",
+        },
+        musicGenre: {
+            type: "string",
+            description: "Music genre hint (e.g., 'ambient', 'cinematic', 'electronic')",
+        },
+        musicMood: {
+            type: "string",
+            description: "Music mood hint (e.g., 'uplifting', 'tense', 'melancholic')",
+        },
+        musicTempo: {
+            type: "number",
+            description: "Music tempo in BPM",
+        },
+        musicOutput: {
+            type: "string",
+            description: "Path to save generated music (e.g., ./track.mp3)",
         },
         // PPT Generation options
         pptPages: {
@@ -693,11 +780,29 @@ export class CLICommandFactory {
             inputAudio: argv.inputAudio,
             // Video generation options (Veo 3.1)
             outputMode: argv.outputMode,
+            videoProvider: argv.videoProvider,
             videoOutput: argv.videoOutput,
             videoResolution: argv.videoResolution,
             videoLength: argv.videoLength,
             videoAspectRatio: argv.videoAspectRatio,
             videoAudio: argv.videoAudio,
+            // Avatar generation options
+            avatarProvider: argv.avatarProvider,
+            avatarImage: argv.avatarImage,
+            avatarAudio: argv.avatarAudio,
+            avatarText: argv.avatarText,
+            avatarVoice: argv.avatarVoice,
+            avatarQuality: argv.avatarQuality,
+            avatarFormat: argv.avatarFormat,
+            avatarOutput: argv.avatarOutput,
+            // Music generation options
+            musicProvider: argv.musicProvider,
+            musicDuration: argv.musicDuration,
+            musicFormat: argv.musicFormat,
+            musicGenre: argv.musicGenre,
+            musicMood: argv.musicMood,
+            musicTempo: argv.musicTempo,
+            musicOutput: argv.musicOutput,
             // PPT generation options
             pptPages: argv.pptPages,
             pptTheme: argv.pptTheme,
@@ -886,19 +991,13 @@ export class CLICommandFactory {
     static configureVideoMode(enhancedOptions, argv, options) {
         const userEnabledTools = !argv.disableTools; // Tools are enabled by default
         enhancedOptions.disableTools = true;
-        // Auto-set provider to vertex for video generation if not explicitly specified
-        if (!enhancedOptions.provider) {
-            enhancedOptions.provider = "vertex";
+        // Resolve video provider from explicit --videoProvider first, then top-level --provider, then default to vertex.
+        if (!enhancedOptions.videoProvider) {
+            enhancedOptions.videoProvider =
+                enhancedOptions.provider ?? "vertex";
             if (options.debug) {
-                logger.debug("Auto-setting provider to 'vertex' for video generation mode");
-            }
-        }
-        else if (enhancedOptions.provider !== "vertex") {
-            // Warn if user specified a non-vertex provider
-            if (!options.quiet) {
-                logger.always(chalk.yellow(`⚠️  Warning: Video generation only supports Vertex AI. Overriding provider '${enhancedOptions.provider}' to 'vertex'.`));
+                logger.debug(`Auto-setting video provider to '${enhancedOptions.videoProvider}' for video generation mode`);
             }
-            enhancedOptions.provider = "vertex";
         }
         // Auto-set model to veo-3.1 if not explicitly specified
         if (!enhancedOptions.model) {
@@ -1012,6 +1111,68 @@ export class CLICommandFactory {
             handleError(error, "Video Output");
         }
     }
+    /**
+     * Helper method to handle avatar video file output.
+     * Saves the generated avatar buffer to --avatarOutput path when provided.
+     */
+    static async handleAvatarOutput(result, options) {
+        const avatarOutputPath = options.avatarOutput;
+        if (!avatarOutputPath) {
+            return;
+        }
+        if (!result || typeof result !== "object") {
+            return;
+        }
+        const generateResult = result;
+        const avatar = generateResult.avatar;
+        if (!avatar) {
+            if (!options.quiet) {
+                logger.always(chalk.yellow("⚠️  No avatar video available in result. Avatar generation may not be enabled or the request failed."));
+            }
+            return;
+        }
+        try {
+            fs.writeFileSync(avatarOutputPath, avatar.buffer);
+            if (!options.quiet) {
+                const sizeStr = formatFileSize(avatar.size);
+                logger.always(chalk.green(`👤 Avatar video saved to: ${avatarOutputPath} (${sizeStr})`));
+            }
+        }
+        catch (error) {
+            handleError(error, "Avatar Output");
+        }
+    }
+    /**
+     * Helper method to handle music audio file output.
+     * Saves the generated music buffer to --musicOutput path when provided.
+     */
+    static async handleMusicOutput(result, options) {
+        const musicOutputPath = options.musicOutput;
+        if (!musicOutputPath) {
+            return;
+        }
+        if (!result || typeof result !== "object") {
+            return;
+        }
+        const generateResult = result;
+        const music = generateResult.music;
+        if (!music) {
+            if (!options.quiet) {
+                logger.always(chalk.yellow("⚠️  No music available in result. Music generation may not be enabled or the request failed."));
+            }
+            return;
+        }
+        try {
+            fs.writeFileSync(musicOutputPath, music.buffer);
+            if (!options.quiet) {
+                const sizeStr = formatFileSize(music.size);
+                logger.always(chalk.green(`🎵 Music saved to: ${musicOutputPath} (${sizeStr})`));
+            }
+        }
+        catch (error) {
+            handleError(error, "Music Output");
+        }
+    }
     /**
      * Helper method to handle PPT file output
      * Displays PPT generation result info
@@ -1419,6 +1580,19 @@ export class CLICommandFactory {
                         "nvidia-nim",
                         "lm-studio",
                         "llamacpp",
+                        "xai",
+                        "groq",
+                        "cohere",
+                        "together-ai",
+                        "fireworks",
+                        "perplexity",
+                        "cloudflare",
+                        "replicate",
+                        "voyage",
+                        "jina",
+                        "stability",
+                        "ideogram",
+                        "recraft",
                     ],
                 })
                     .option("list", {
@@ -1755,11 +1929,10 @@ export class CLICommandFactory {
         return argv.input;
     }
     /**
-     * Detect output mode (video, ppt, or text) based on CLI arguments
+     * Detect output mode (video, ppt, avatar, music, or text) based on CLI arguments
      */
     static detectGenerateOutputMode(argv, options) {
         const outputMode = options.outputMode;
-        const isVideoMode = outputMode === "video";
         const hasPPTFlags = argv.pptPages !== undefined ||
             argv.pptTheme !== undefined ||
             argv.pptAudience !== undefined ||
@@ -1767,18 +1940,58 @@ export class CLICommandFactory {
             argv.pptOutput !== undefined ||
             argv.pptAspectRatio !== undefined ||
             argv.pptNoImages === true;
-        const hasVideoSignals = outputMode === "video" || argv.videoOutput !== undefined;
+        const hasVideoSignals = outputMode === "video" ||
+            argv.videoOutput !== undefined ||
+            argv.videoProvider !== undefined ||
+            argv.videoLength !== undefined ||
+            argv.videoResolution !== undefined ||
+            argv.videoAspectRatio !== undefined;
         const hasPPTSignals = outputMode === "ppt" || hasPPTFlags;
-        if (hasVideoSignals && hasPPTSignals) {
-            throw new Error("Conflicting output mode signals detected. Use either video mode (--outputMode video, optionally with --videoOutput) or PPT mode (--outputMode ppt / --ppt* flags), not both.");
-        }
-        const isPPTMode = outputMode === "ppt" || hasPPTFlags;
+        const hasAvatarSignals = outputMode === "avatar" ||
+            argv.avatarProvider !== undefined ||
+            argv.avatarImage !== undefined ||
+            argv.avatarText !== undefined ||
+            argv.avatarAudio !== undefined ||
+            argv.avatarVoice !== undefined ||
+            argv.avatarOutput !== undefined;
+        const hasMusicSignals = outputMode === "music" ||
+            argv.musicProvider !== undefined ||
+            argv.musicGenre !== undefined ||
+            argv.musicMood !== undefined ||
+            argv.musicDuration !== undefined ||
+            argv.musicTempo !== undefined ||
+            argv.musicOutput !== undefined;
+        const activeModes = [
+            hasVideoSignals,
+            hasPPTSignals,
+            hasAvatarSignals,
+            hasMusicSignals,
+        ].filter(Boolean).length;
+        if (activeModes > 1) {
+            throw new Error("Conflicting output mode signals detected. Use exactly one of video / ppt / avatar / music modes (or text).");
+        }
+        // Derive mode flags from the full signal set so that flag-only invocations
+        // (e.g. --videoOutput without --output-mode video) are handled correctly.
+        const isVideoMode = hasVideoSignals;
+        const isAvatarMode = hasAvatarSignals;
+        const isMusicMode = hasMusicSignals;
+        const isPPTMode = hasPPTSignals;
         const spinnerMessage = isVideoMode
             ? "🎬 Generating video... (this may take 1-2 minutes)"
             : isPPTMode
                 ? "📊 Generating presentation... (this may take 2-5 minutes)"
-                : "🤖 Generating text...";
-        return { isVideoMode, isPPTMode, spinnerMessage };
+                : isAvatarMode
+                    ? "👤 Generating avatar video... (this may take 1-3 minutes)"
+                    : isMusicMode
+                        ? "🎵 Generating music... (this may take 30s-2 minutes)"
+                        : "🤖 Generating text...";
+        return {
+            isVideoMode,
+            isPPTMode,
+            isAvatarMode,
+            isMusicMode,
+            spinnerMessage,
+        };
     }
     /**
      * Process context for generation command
@@ -1828,11 +2041,12 @@ export class CLICommandFactory {
     /**
      * Build output configuration for generate request
      */
-    static buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions) {
+    static buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions, isAvatarMode = false, isMusicMode = false) {
         if (isVideoMode) {
             return {
                 mode: "video",
                 video: {
+                    provider: enhancedOptions.videoProvider,
                     resolution: enhancedOptions.videoResolution,
                     length: enhancedOptions.videoLength,
                     aspectRatio: enhancedOptions.videoAspectRatio,
@@ -1840,6 +2054,36 @@ export class CLICommandFactory {
                 },
             };
         }
+        if (isAvatarMode) {
+            return {
+                mode: "avatar",
+                avatar: {
+                    provider: enhancedOptions.avatarProvider,
+                    image: enhancedOptions.avatarImage,
+                    audio: enhancedOptions.avatarAudio,
+                    text: enhancedOptions.avatarText,
+                    voice: enhancedOptions.avatarVoice,
+                    quality: enhancedOptions.avatarQuality,
+                    format: enhancedOptions.avatarFormat,
+                    output: enhancedOptions.avatarOutput,
+                },
+            };
+        }
+        if (isMusicMode) {
+            return {
+                mode: "music",
+                music: {
+                    prompt: "", // Filled in from input.text/prompt by baseProvider
+                    provider: enhancedOptions.musicProvider,
+                    duration: enhancedOptions.musicDuration,
+                    format: enhancedOptions.musicFormat,
+                    genre: enhancedOptions.musicGenre,
+                    mood: enhancedOptions.musicMood,
+                    tempo: enhancedOptions.musicTempo,
+                    output: enhancedOptions.musicOutput,
+                },
+            };
+        }
         if (isPPTMode) {
             return {
                 mode: "ppt",
@@ -1859,7 +2103,8 @@ export class CLICommandFactory {
     /**
      * Handle successful generation result
      */
-    static async handleGenerateSuccess(result, options, isVideoMode, isPPTMode, spinner) {
+    static async handleGenerateSuccess(result, options, modes, spinner) {
+        const { isVideoMode, isPPTMode, isAvatarMode, isMusicMode } = modes;
         const genResult = result;
         if (spinner) {
             if (isVideoMode) {
@@ -1868,6 +2113,12 @@ export class CLICommandFactory {
             else if (isPPTMode) {
                 spinner.succeed(chalk.green("✅ Presentation generated successfully!"));
             }
+            else if (isAvatarMode) {
+                spinner.succeed(chalk.green("✅ Avatar video generated successfully!"));
+            }
+            else if (isMusicMode) {
+                spinner.succeed(chalk.green("✅ Music generated successfully!"));
+            }
             else {
                 spinner.succeed(chalk.green("✅ Text generated successfully!"));
             }
@@ -1877,11 +2128,13 @@ export class CLICommandFactory {
             const modelInfo = genResult.model || "default";
             logger.always(chalk.gray(`🔧 Provider: ${providerInfo} | Model: ${modelInfo}`));
         }
-        if (!isVideoMode && !isPPTMode) {
+        if (!isVideoMode && !isPPTMode && !isAvatarMode && !isMusicMode) {
             CLICommandFactory.handleOutput(genResult, options);
         }
         await CLICommandFactory.handleTTSOutput(genResult, options);
         await CLICommandFactory.handleVideoOutput(genResult, options);
+        await CLICommandFactory.handleAvatarOutput(genResult, options);
+        await CLICommandFactory.handleMusicOutput(genResult, options);
         await CLICommandFactory.handlePPTOutput(genResult, options);
         if (options.debug) {
             logger.debug("\n" + chalk.yellow("Debug Information:"));
@@ -1908,7 +2161,7 @@ export class CLICommandFactory {
         argv.input = rawInput;
         const options = CLICommandFactory.processOptions(argv);
         // Detect output mode
-        const { isVideoMode, isPPTMode, spinnerMessage } = CLICommandFactory.detectGenerateOutputMode(argv, options);
+        const { isVideoMode, isPPTMode, isAvatarMode, isMusicMode, spinnerMessage, } = CLICommandFactory.detectGenerateOutputMode(argv, options);
         const spinner = argv.quiet ? null : ora(spinnerMessage).start();
         try {
             // Add delay if specified
@@ -1987,7 +2240,7 @@ export class CLICommandFactory {
             }
             // Build multimodal input and output configuration
             const generateInput = CLICommandFactory.buildGenerateMultimodalInput(inputText, argv);
-            const outputConfig = CLICommandFactory.buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions);
+            const outputConfig = CLICommandFactory.buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions, isAvatarMode, isMusicMode);
             // Read audio file for STT if --input-audio is provided.
             // NEW10: existsSync guard mirrors the stream handler so a missing file
             // produces a friendly error here too instead of a raw ENOENT crash.
@@ -2079,7 +2332,7 @@ export class CLICommandFactory {
             });
             const result = await runGenerate();
             // Handle successful result
-            await CLICommandFactory.handleGenerateSuccess(result, options, isVideoMode, isPPTMode, spinner);
+            await CLICommandFactory.handleGenerateSuccess(result, options, { isVideoMode, isPPTMode, isAvatarMode, isMusicMode }, spinner);
         }
         catch (error) {
             if (spinner) {
@@ -3041,7 +3294,7 @@ export class CLICommandFactory {
                 "        generate|gen)\n" +
                 '            case "${prev}" in\n' +
                 "                --provider|-p)\n" +
-                '                    COMPREPLY=( $(compgen -W "auto openai openai-compatible openrouter or bedrock vertex googleVertex anthropic anthropic-subscription azure google-ai google-ai-studio huggingface ollama mistral litellm sagemaker deepseek ds nvidia-nim nim lm-studio lmstudio llamacpp llama.cpp" -- ${cur}) )\n' +
+                '                    COMPREPLY=( $(compgen -W "auto openai openai-compatible openrouter or bedrock vertex googleVertex anthropic anthropic-subscription azure google-ai google-ai-studio huggingface ollama mistral litellm sagemaker deepseek ds nvidia-nim nim lm-studio lmstudio llamacpp llama.cpp xai grok groq cohere together-ai together fireworks perplexity pplx cloudflare workers-ai cf-ai replicate voyage voyage-ai jina jina-ai stability stability-ai sd ideogram recraft" -- ${cur}) )\n' +
                 "                    return 0\n" +
                 "                    ;;\n" +
                 "                --format|-f|--output-format)\n" +