@juspay/neurolink 9.63.1 → 9.65.0

package/dist/cli/factories/commandFactory.js

@@ -28,6 +28,35 @@ import { SageMakerCommandFactory } from "./sagemakerCommandFactory.js";
  * CLI Command Factory for generate commands
  */
 export class CLICommandFactory {
+    /**
+     * Normalize loop session variables before merging them into provider options.
+     *
+     * The CLI loop schema models some fields (e.g. `stopSequences`,
+     * `enabledToolNames`) as a single comma-separated string for ergonomic
+     * input, but providers expect `string[]`. Without conversion,
+     * `set stopSequences a,b` would be sent as one stop token "a,b" instead
+     * of two ("a", "b"); `set enabledToolNames read,write` would be cast to
+     * a `string[]` containing the single literal "read,write" and silently
+     * filter out every tool. This helper splits and trims those fields so
+     * the spread into `enhancedOptions` produces the correct shape across
+     * generate / batch / stream paths.
+     */
+    static normalizeLoopSessionVariables(vars) {
+        const normalized = { ...vars };
+        if (typeof normalized.stopSequences === "string") {
+            normalized.stopSequences = normalized.stopSequences
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        if (typeof normalized.enabledToolNames === "string") {
+            normalized.enabledToolNames = normalized.enabledToolNames
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        return normalized;
+    }
     // Common options available on all commands
     static commonOptions = {
         // Core generation options
@@ -61,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.",
@@ -337,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",
@@ -352,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: {
@@ -621,6 +737,13 @@ export class CLICommandFactory {
             model: argv.model,
             temperature: argv.temperature,
             maxTokens: argv.maxTokens,
+            // Sampling controls — surfaced here so all three command paths
+            // (generate / stream / batch) get them consistently typed instead
+            // of relying on an ad-hoc cast at each sdk call site.
+            topP: argv.topP,
+            topK: argv.topK,
+            stopSequences: argv.stopSequences,
+            enabledToolNames: argv.enabledToolNames,
             systemPrompt: argv.system,
             timeout: argv.timeout,
             disableTools: argv.disableTools,
@@ -657,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,
@@ -850,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) {
@@ -976,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
@@ -1383,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", {
@@ -1719,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 ||
@@ -1731,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
@@ -1792,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,
@@ -1804,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",
@@ -1823,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) {
@@ -1832,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!"));
             }
@@ -1841,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:"));
@@ -1872,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
@@ -1930,18 +2219,8 @@ export class CLICommandFactory {
             }
             // Initialize SDK and session
             const sdk = globalSession.getOrCreateNeuroLink();
-            const sessionVariables = globalSession.getSessionVariables();
-            const enhancedOptions = {
-                ...options,
-                ...sessionVariables,
-                // enabledToolNames must be string[] for the SDK — normalize from CSV string
-                ...(typeof sessionVariables.enabledToolNames === "string" && {
-                    enabledToolNames: sessionVariables.enabledToolNames
-                        .split(",")
-                        .map((t) => t.trim())
-                        .filter(Boolean),
-                }),
-            };
+            const sessionVariables = CLICommandFactory.normalizeLoopSessionVariables(globalSession.getSessionVariables());
+            const enhancedOptions = { ...options, ...sessionVariables };
             const sessionId = globalSession.getCurrentSessionId();
             const context = sessionId
                 ? { ...options.context, sessionId }
@@ -1961,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.
@@ -1993,6 +2272,9 @@ export class CLICommandFactory {
                 model: enhancedOptions.model,
                 temperature: enhancedOptions.temperature,
                 maxTokens: enhancedOptions.maxTokens,
+                topP: enhancedOptions.topP,
+                topK: enhancedOptions.topK,
+                stopSequences: enhancedOptions.stopSequences,
                 systemPrompt: enhancedOptions.systemPrompt,
                 timeout: enhancedOptions.timeout
                     ? enhancedOptions.timeout * 1000
@@ -2050,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) {
@@ -2166,7 +2448,7 @@ export class CLICommandFactory {
      */
     static async executeRealStream(argv, options, inputText, contextMetadata) {
         const sdk = globalSession.getOrCreateNeuroLink();
-        const sessionVariables = globalSession.getSessionVariables();
+        const sessionVariables = CLICommandFactory.normalizeLoopSessionVariables(globalSession.getSessionVariables());
         const enhancedOptions = { ...options, ...sessionVariables };
         const sessionId = globalSession.getCurrentSessionId();
         const context = sessionId
@@ -2201,6 +2483,9 @@ export class CLICommandFactory {
             model: enhancedOptions.model,
             temperature: enhancedOptions.temperature,
             maxTokens: enhancedOptions.maxTokens,
+            topP: enhancedOptions.topP,
+            topK: enhancedOptions.topK,
+            stopSequences: enhancedOptions.stopSequences,
             systemPrompt: enhancedOptions.systemPrompt,
             timeout: enhancedOptions.timeout
                 ? enhancedOptions.timeout * 1000
@@ -2639,18 +2924,8 @@ export class CLICommandFactory {
             }
             const results = [];
             const sdk = globalSession.getOrCreateNeuroLink();
-            const sessionVariables = globalSession.getSessionVariables();
-            const enhancedOptions = {
-                ...options,
-                ...sessionVariables,
-                // enabledToolNames must be string[] for the SDK — normalize from CSV string
-                ...(typeof sessionVariables.enabledToolNames === "string" && {
-                    enabledToolNames: sessionVariables.enabledToolNames
-                        .split(",")
-                        .map((t) => t.trim())
-                        .filter(Boolean),
-                }),
-            };
+            const sessionVariables = CLICommandFactory.normalizeLoopSessionVariables(globalSession.getSessionVariables());
+            const enhancedOptions = { ...options, ...sessionVariables };
             const sessionId = globalSession.getCurrentSessionId();
             for (let i = 0; i < prompts.length; i++) {
                 if (spinner) {
@@ -2692,6 +2967,9 @@ export class CLICommandFactory {
                         model: enhancedOptions.model,
                         temperature: enhancedOptions.temperature,
                         maxTokens: enhancedOptions.maxTokens,
+                        topP: enhancedOptions.topP,
+                        topK: enhancedOptions.topK,
+                        stopSequences: enhancedOptions.stopSequences,
                         systemPrompt: enhancedOptions.systemPrompt,
                         timeout: enhancedOptions.timeout
                             ? enhancedOptions.timeout * 1000
@@ -3016,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" +

package/dist/cli/loop/optionsSchema.d.ts

@@ -4,4 +4,4 @@ import type { OptionSchema, TextGenerationOptions } from "../../lib/types/index.
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials" | "onFinish" | "onError">, OptionSchema>;

package/dist/cli/loop/optionsSchema.js

@@ -24,6 +24,18 @@ export const textGenerationOptionsSchema = {
         type: "number",
         description: "The maximum number of tokens to generate.",
     },
+    topP: {
+        type: "number",
+        description: "Top-p (nucleus) sampling parameter. Controls diversity of generated tokens (0.0-1.0).",
+    },
+    topK: {
+        type: "number",
+        description: "Top-k sampling parameter. Limits the number of tokens considered (Google/Gemini models only).",
+    },
+    stopSequences: {
+        type: "string",
+        description: "Stop sequences that will halt generation when encountered (comma-separated).",
+    },
     output: {
         type: "string",
         description: "AI response format - specify just the format value (e.g., 'json', 'structured'). Note: This is automatically transformed to { format: value } for the API.",