@juspay/neurolink 1.5.2 → 1.6.0

package/dist/cli/commands/ollama.js

@@ -0,0 +1,323 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+export const ollamaCommand = {
+    command: 'ollama <command>',
+    describe: 'Manage Ollama local AI models',
+    builder: (yargs) => {
+        return yargs
+            .command('list-models', 'List installed Ollama models', {}, listModelsHandler)
+            .command('pull <model>', 'Download an Ollama model', {
+            model: {
+                describe: 'Model name to download',
+                type: 'string',
+                demandOption: true
+            }
+        }, pullModelHandler)
+            .command('remove <model>', 'Remove an Ollama model', {
+            model: {
+                describe: 'Model name to remove',
+                type: 'string',
+                demandOption: true
+            }
+        }, removeModelHandler)
+            .command('status', 'Check Ollama service status', {}, statusHandler)
+            .command('start', 'Start Ollama service', {}, startHandler)
+            .command('stop', 'Stop Ollama service', {}, stopHandler)
+            .command('setup', 'Interactive Ollama setup', {}, setupHandler)
+            .demandCommand(1, 'Please specify a command');
+    },
+    handler: () => { } // No-op handler as subcommands handle everything
+};
+async function listModelsHandler() {
+    const spinner = ora('Fetching installed models...').start();
+    try {
+        const output = execSync('ollama list', { encoding: 'utf8' });
+        spinner.succeed('Installed models:');
+        if (output.trim()) {
+            console.log(output);
+        }
+        else {
+            console.log(chalk.yellow('No models installed. Use "neurolink ollama pull <model>" to download a model.'));
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to list models. Is Ollama installed?');
+        console.error(chalk.red('Error:', error.message));
+        console.log(chalk.blue('\nTip: Install Ollama from https://ollama.ai'));
+        process.exit(1);
+    }
+}
+async function pullModelHandler(argv) {
+    const { model } = argv;
+    console.log(chalk.blue(`Downloading model: ${model}`));
+    console.log(chalk.gray('This may take several minutes...'));
+    try {
+        execSync(`ollama pull ${model}`, { stdio: 'inherit' });
+        console.log(chalk.green(`\n✅ Successfully downloaded ${model}`));
+        console.log(chalk.blue(`\nTest it with: npx @juspay/neurolink generate-text "Hello!" --provider ollama --model ${model}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`\n❌ Failed to download ${model}`));
+        console.error(chalk.red('Error:', error.message));
+        process.exit(1);
+    }
+}
+async function removeModelHandler(argv) {
+    const { model } = argv;
+    // Confirm removal
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to remove model "${model}"?`,
+            default: false
+        }
+    ]);
+    if (!confirm) {
+        console.log(chalk.yellow('Removal cancelled.'));
+        return;
+    }
+    const spinner = ora(`Removing model ${model}...`).start();
+    try {
+        execSync(`ollama rm ${model}`, { encoding: 'utf8' });
+        spinner.succeed(`Successfully removed ${model}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to remove ${model}`);
+        console.error(chalk.red('Error:', error.message));
+        process.exit(1);
+    }
+}
+async function statusHandler() {
+    const spinner = ora('Checking Ollama service status...').start();
+    try {
+        // Try to run a simple command
+        execSync('ollama list', { encoding: 'utf8' });
+        spinner.succeed('Ollama service is running');
+        // Get additional info
+        try {
+            const response = execSync('curl -s http://localhost:11434/api/tags', { encoding: 'utf8' });
+            const data = JSON.parse(response);
+            if (data.models && data.models.length > 0) {
+                console.log(chalk.green(`\n${data.models.length} models available`));
+            }
+        }
+        catch {
+            // Curl might not be available, that's ok
+        }
+    }
+    catch (error) {
+        spinner.fail('Ollama service is not running');
+        console.log(chalk.yellow('\nStart Ollama with: ollama serve'));
+        console.log(chalk.blue('Or restart the Ollama app if using the desktop version'));
+        process.exit(1);
+    }
+}
+async function startHandler() {
+    console.log(chalk.blue('Starting Ollama service...'));
+    try {
+        // Check if already running
+        try {
+            execSync('ollama list', { encoding: 'utf8' });
+            console.log(chalk.yellow('Ollama service is already running!'));
+            return;
+        }
+        catch {
+            // Not running, continue to start
+        }
+        // Different approaches for different platforms
+        if (process.platform === 'darwin') {
+            // macOS
+            console.log(chalk.gray('Starting Ollama on macOS...'));
+            try {
+                execSync('open -a Ollama');
+                console.log(chalk.green('✅ Ollama app started'));
+            }
+            catch {
+                // Try service command
+                execSync('ollama serve > /dev/null 2>&1 &', { stdio: 'ignore' });
+                console.log(chalk.green('✅ Ollama service started'));
+            }
+        }
+        else if (process.platform === 'linux') {
+            // Linux
+            console.log(chalk.gray('Starting Ollama service on Linux...'));
+            try {
+                execSync('systemctl start ollama', { encoding: 'utf8' });
+                console.log(chalk.green('✅ Ollama service started'));
+            }
+            catch {
+                // Try direct command
+                execSync('ollama serve > /dev/null 2>&1 &', { stdio: 'ignore' });
+                console.log(chalk.green('✅ Ollama service started'));
+            }
+        }
+        else {
+            // Windows
+            console.log(chalk.gray('Starting Ollama on Windows...'));
+            execSync('start ollama serve', { stdio: 'ignore' });
+            console.log(chalk.green('✅ Ollama service started'));
+        }
+        console.log(chalk.blue('\nWait a few seconds for the service to initialize...'));
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to start Ollama service'));
+        console.error(chalk.red('Error:', error.message));
+        console.log(chalk.blue('\nTry starting Ollama manually or check installation'));
+        process.exit(1);
+    }
+}
+async function stopHandler() {
+    const spinner = ora('Stopping Ollama service...').start();
+    try {
+        if (process.platform === 'darwin') {
+            // macOS
+            try {
+                execSync('pkill ollama', { encoding: 'utf8' });
+            }
+            catch {
+                execSync('killall Ollama', { encoding: 'utf8' });
+            }
+        }
+        else if (process.platform === 'linux') {
+            // Linux
+            try {
+                execSync('systemctl stop ollama', { encoding: 'utf8' });
+            }
+            catch {
+                execSync('pkill ollama', { encoding: 'utf8' });
+            }
+        }
+        else {
+            // Windows
+            execSync('taskkill /F /IM ollama.exe', { encoding: 'utf8' });
+        }
+        spinner.succeed('Ollama service stopped');
+    }
+    catch (error) {
+        spinner.fail('Failed to stop Ollama service');
+        console.error(chalk.red('It may not be running or requires manual stop'));
+    }
+}
+async function setupHandler() {
+    console.log(chalk.blue('🦙 Welcome to Ollama Setup!\n'));
+    // Check if Ollama is installed
+    const checkSpinner = ora('Checking Ollama installation...').start();
+    let isInstalled = false;
+    try {
+        execSync('ollama --version', { encoding: 'utf8' });
+        isInstalled = true;
+        checkSpinner.succeed('Ollama is installed');
+    }
+    catch {
+        checkSpinner.fail('Ollama is not installed');
+    }
+    if (!isInstalled) {
+        console.log(chalk.yellow('\nOllama needs to be installed first.'));
+        console.log(chalk.blue('\nInstallation instructions:'));
+        if (process.platform === 'darwin') {
+            console.log('\nFor macOS:');
+            console.log(chalk.gray('  brew install ollama'));
+            console.log(chalk.gray('  # or download from https://ollama.ai'));
+        }
+        else if (process.platform === 'linux') {
+            console.log('\nFor Linux:');
+            console.log(chalk.gray('  curl -fsSL https://ollama.ai/install.sh | sh'));
+        }
+        else {
+            console.log('\nFor Windows:');
+            console.log(chalk.gray('  Download from https://ollama.ai'));
+        }
+        const { proceedAnyway } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'proceedAnyway',
+                message: 'Would you like to continue with setup anyway?',
+                default: false
+            }
+        ]);
+        if (!proceedAnyway) {
+            console.log(chalk.blue('\nInstall Ollama and run setup again!'));
+            return;
+        }
+    }
+    // Check if service is running
+    let serviceRunning = false;
+    try {
+        execSync('ollama list', { encoding: 'utf8' });
+        serviceRunning = true;
+        console.log(chalk.green('\n✅ Ollama service is running'));
+    }
+    catch {
+        console.log(chalk.yellow('\n⚠️  Ollama service is not running'));
+        const { startService } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'startService',
+                message: 'Would you like to start the Ollama service?',
+                default: true
+            }
+        ]);
+        if (startService) {
+            await startHandler();
+            serviceRunning = true;
+        }
+    }
+    if (serviceRunning) {
+        // List available models
+        console.log(chalk.blue('\n📦 Popular Ollama models:'));
+        console.log('  • llama2 (7B) - General purpose');
+        console.log('  • codellama (7B) - Code generation');
+        console.log('  • mistral (7B) - Fast and efficient');
+        console.log('  • tinyllama (1B) - Lightweight');
+        console.log('  • phi (2.7B) - Microsoft\'s compact model');
+        const { downloadModel } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'downloadModel',
+                message: 'Would you like to download a model?',
+                default: true
+            }
+        ]);
+        if (downloadModel) {
+            const { selectedModel } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedModel',
+                    message: 'Select a model to download:',
+                    choices: [
+                        { name: 'llama2 (7B) - Recommended for general use', value: 'llama2' },
+                        { name: 'codellama (7B) - Best for code generation', value: 'codellama' },
+                        { name: 'mistral (7B) - Fast and efficient', value: 'mistral' },
+                        { name: 'tinyllama (1B) - Lightweight, fast', value: 'tinyllama' },
+                        { name: 'phi (2.7B) - Microsoft\'s compact model', value: 'phi' },
+                        { name: 'Other (enter manually)', value: 'other' }
+                    ]
+                }
+            ]);
+            let modelToDownload = selectedModel;
+            if (selectedModel === 'other') {
+                const { customModel } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'customModel',
+                        message: 'Enter the model name:',
+                        validate: (input) => input.trim().length > 0 || 'Model name is required'
+                    }
+                ]);
+                modelToDownload = customModel;
+            }
+            await pullModelHandler({ model: modelToDownload });
+        }
+    }
+    // Final instructions
+    console.log(chalk.green('\n✅ Setup complete!\n'));
+    console.log(chalk.blue('Next steps:'));
+    console.log('1. List models: ' + chalk.gray('neurolink ollama list-models'));
+    console.log('2. Generate text: ' + chalk.gray('neurolink generate-text "Hello!" --provider ollama'));
+    console.log('3. Use specific model: ' + chalk.gray('neurolink generate-text "Hello!" --provider ollama --model codellama'));
+    console.log(chalk.gray('\nFor more information, see: https://docs.neurolink.ai/providers/ollama'));
+}
+export default ollamaCommand;

package/dist/cli/index.js

@@ -7,14 +7,13 @@
  * Implementation: ~300 lines using simple JS utility functions
  */
 import { NeuroLink } from '../lib/neurolink.js';
-import yargs from 'yargs'; // Keep default import
+import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import ora from 'ora';
 import chalk from 'chalk';
 import fs from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 import { addMCPCommands } from './commands/mcp.js';
+import ollamaCommand from './commands/ollama.js';
 // Load environment variables from .env file
 try {
     // Try to import and configure dotenv
@@ -25,9 +24,6 @@ catch (error) {
     // dotenv is not available (dev dependency only) - this is fine for production
     // Environment variables should be set externally in production
 }
-// Get current directory for ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 // Utility Functions (Simple, Zero Maintenance)
 function formatOutput(result, format = 'text') {
     if (format === 'json') {
@@ -156,8 +152,8 @@ const cli = yargs(args)
     if (argv.debug) {
         process.env.NEUROLINK_DEBUG = 'true';
     }
-    else if (typeof argv.debug !== 'undefined') {
-        // Only set to false if debug flag was explicitly provided
+    else {
+        // Always set to false when debug is not enabled (including when not provided)
         process.env.NEUROLINK_DEBUG = 'false';
     }
     // Keep existing quiet middleware
@@ -224,7 +220,7 @@ const cli = yargs(args)
     demandOption: true,
 })
     .option('provider', {
-    choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'],
+    choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'],
     default: 'auto',
     description: 'AI provider to use (auto-selects best available)'
 })
@@ -306,7 +302,7 @@ const cli = yargs(args)
     .command('stream <prompt>', 'Stream text generation in real-time', (yargsInstance) => yargsInstance
     .usage('Usage: $0 stream <prompt> [options]')
     .positional('prompt', { type: 'string', description: 'Text prompt for streaming', demandOption: true })
-    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'], default: 'auto', description: 'AI provider to use' })
+    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'], default: 'auto', description: 'AI provider to use' })
     .option('temperature', { type: 'number', default: 0.7, description: 'Creativity level' })
     .option('debug', { type: 'boolean', default: false, description: 'Enable debug mode with interleaved logging' })
     .example('$0 stream "Tell me a story"', 'Stream a story in real-time'), async (argv) => {
@@ -342,7 +338,7 @@ const cli = yargs(args)
     .positional('file', { type: 'string', description: 'File with prompts (one per line)', demandOption: true })
     .option('output', { type: 'string', description: 'Output file for results (default: stdout)' })
     .option('delay', { type: 'number', default: 1000, description: 'Delay between requests in milliseconds' })
-    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'], default: 'auto', description: 'AI provider to use' })
+    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'], default: 'auto', description: 'AI provider to use' })
     .option('timeout', { type: 'number', default: 30000, description: 'Timeout for each request in milliseconds' })
     .option('temperature', { type: 'number', description: 'Global temperature for batch jobs' })
     .option('max-tokens', { type: 'number', description: 'Global max tokens for batch jobs' })
@@ -423,7 +419,7 @@ const cli = yargs(args)
         const spinner = argv.quiet ? null : ora('🔍 Checking AI provider status...\n').start();
         // Middleware sets argv.verbose if NEUROLINK_DEBUG is true and --verbose is not specified
         // Removed the spinner.stopAndPersist logic from here as it's handled before spinner start
-        const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'];
+        const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'];
         const results = [];
         for (const p of providers) {
             if (spinner)
@@ -457,13 +453,13 @@ const cli = yargs(args)
         }
     })
         .command('list', 'List available AI providers', (y) => y.usage('Usage: $0 provider list'), async () => {
-        console.log('Available providers: openai, bedrock, vertex, anthropic, azure, google-ai');
+        console.log('Available providers: openai, bedrock, vertex, anthropic, azure, google-ai, huggingface, ollama, mistral');
     })
         .command('configure <providerName>', 'Display configuration guidance for a provider', (y) => y
         .usage('Usage: $0 provider configure <providerName>')
         .positional('providerName', {
         type: 'string',
-        choices: ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'],
+        choices: ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'],
         description: 'Name of the provider to configure',
         demandOption: true,
     })
@@ -495,7 +491,7 @@ const cli = yargs(args)
     const spinner = argv.quiet ? null : ora('🔍 Checking AI provider status...\n').start();
     // Middleware sets argv.verbose if NEUROLINK_DEBUG is true and --verbose is not specified
     // Removed the spinner.stopAndPersist logic from here as it's handled before spinner start
-    const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'];
+    const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'];
     const results = [];
     for (const p of providers) {
         if (spinner)
@@ -615,6 +611,8 @@ const cli = yargs(args)
     .completion('completion', 'Generate shell completion script');
 // Add MCP commands
 addMCPCommands(cli);
+// Add Ollama command
+cli.command(ollamaCommand);
 // Use an async IIFE to allow top-level await for parseAsync
 (async () => {
     try {

package/dist/core/factory.js

@@ -1,4 +1,4 @@
-import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio } from '../providers/index.js';
+import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI } from '../providers/index.js';
 import { getBestProvider } from '../utils/providerUtils.js';
 import { logger } from '../utils/logger.js';
 const componentIdentifier = 'aiProviderFactory';
@@ -47,8 +47,23 @@ export class AIProviderFactory {
                 case 'google-studio':
                     provider = new GoogleAIStudio(modelName);
                     break;
+                case 'huggingface':
+                case 'hugging-face':
+                case 'hf':
+                    provider = new HuggingFace(modelName);
+                    break;
+                case 'ollama':
+                case 'local':
+                case 'local-ollama':
+                    provider = new Ollama(modelName || undefined);
+                    break;
+                case 'mistral':
+                case 'mistral-ai':
+                case 'mistralai':
+                    provider = new MistralAI(modelName);
+                    break;
                 default:
-                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai`);
+                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai, huggingface, ollama, mistral`);
             }
             logger.debug(`[${functionTag}] Provider creation succeeded`, {
                 providerName,

package/dist/core/types.d.ts

@@ -9,7 +9,10 @@ export declare enum AIProviderName {
     VERTEX = "vertex",
     ANTHROPIC = "anthropic",
     AZURE = "azure",
-    GOOGLE_AI = "google-ai"
+    GOOGLE_AI = "google-ai",
+    HUGGINGFACE = "huggingface",
+    OLLAMA = "ollama",
+    MISTRAL = "mistral"
 }
 /**
  * Supported Models for Amazon Bedrock

package/dist/core/types.js

@@ -9,6 +9,9 @@ export var AIProviderName;
     AIProviderName["ANTHROPIC"] = "anthropic";
     AIProviderName["AZURE"] = "azure";
     AIProviderName["GOOGLE_AI"] = "google-ai";
+    AIProviderName["HUGGINGFACE"] = "huggingface";
+    AIProviderName["OLLAMA"] = "ollama";
+    AIProviderName["MISTRAL"] = "mistral";
 })(AIProviderName || (AIProviderName = {}));
 /**
  * Supported Models for Amazon Bedrock

package/dist/lib/core/factory.js

@@ -1,4 +1,4 @@
-import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio } from '../providers/index.js';
+import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI } from '../providers/index.js';
 import { getBestProvider } from '../utils/providerUtils.js';
 import { logger } from '../utils/logger.js';
 const componentIdentifier = 'aiProviderFactory';
@@ -47,8 +47,23 @@ export class AIProviderFactory {
                 case 'google-studio':
                     provider = new GoogleAIStudio(modelName);
                     break;
+                case 'huggingface':
+                case 'hugging-face':
+                case 'hf':
+                    provider = new HuggingFace(modelName);
+                    break;
+                case 'ollama':
+                case 'local':
+                case 'local-ollama':
+                    provider = new Ollama(modelName || undefined);
+                    break;
+                case 'mistral':
+                case 'mistral-ai':
+                case 'mistralai':
+                    provider = new MistralAI(modelName);
+                    break;
                 default:
-                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai`);
+                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai, huggingface, ollama, mistral`);
             }
             logger.debug(`[${functionTag}] Provider creation succeeded`, {
                 providerName,

package/dist/lib/core/types.d.ts

@@ -9,7 +9,10 @@ export declare enum AIProviderName {
     VERTEX = "vertex",
     ANTHROPIC = "anthropic",
     AZURE = "azure",
-    GOOGLE_AI = "google-ai"
+    GOOGLE_AI = "google-ai",
+    HUGGINGFACE = "huggingface",
+    OLLAMA = "ollama",
+    MISTRAL = "mistral"
 }
 /**
  * Supported Models for Amazon Bedrock

package/dist/lib/core/types.js

@@ -9,6 +9,9 @@ export var AIProviderName;
     AIProviderName["ANTHROPIC"] = "anthropic";
     AIProviderName["AZURE"] = "azure";
     AIProviderName["GOOGLE_AI"] = "google-ai";
+    AIProviderName["HUGGINGFACE"] = "huggingface";
+    AIProviderName["OLLAMA"] = "ollama";
+    AIProviderName["MISTRAL"] = "mistral";
 })(AIProviderName || (AIProviderName = {}));
 /**
  * Supported Models for Amazon Bedrock

package/dist/lib/mcp/servers/ai-providers/ai-analysis-tools.js

@@ -12,12 +12,12 @@ import { getBestProvider, getAvailableProviders } from '../../../utils/providerU
 const AnalyzeUsageSchema = z.object({
     sessionId: z.string().optional(),
     timeRange: z.enum(['1h', '24h', '7d', '30d']).default('24h'),
-    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai']).optional(),
+    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai', 'azure', 'huggingface', 'ollama', 'mistral']).optional(),
     includeTokenBreakdown: z.boolean().default(true),
     includeCostEstimation: z.boolean().default(true)
 });
 const BenchmarkSchema = z.object({
-    providers: z.array(z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai'])).optional(),
+    providers: z.array(z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai', 'azure', 'huggingface', 'ollama', 'mistral'])).optional(),
     testPrompts: z.array(z.string()).optional(),
     iterations: z.number().min(1).max(5).default(2),
     metrics: z.array(z.enum(['latency', 'quality', 'cost', 'tokens'])).default(['latency', 'quality']),
@@ -25,7 +25,7 @@ const BenchmarkSchema = z.object({
 });
 const OptimizeParametersSchema = z.object({
     prompt: z.string().min(1, 'Prompt is required for optimization'),
-    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai']).optional(),
+    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai', 'azure', 'huggingface', 'ollama', 'mistral']).optional(),
     targetLength: z.number().positive().optional(),
     style: z.enum(['creative', 'balanced', 'precise', 'factual']).default('balanced'),
     optimizeFor: z.enum(['speed', 'quality', 'cost', 'tokens']).default('quality'),
@@ -59,7 +59,7 @@ export const analyzeAIUsageTool = {
 
         Generate a realistic analysis including:
         1. A summary of usage statistics (totalRequests, totalTokens).
-        2. A breakdown of usage by provider (OpenAI, Bedrock, Vertex).
+        2. A breakdown of usage by provider (OpenAI, Bedrock, Vertex, Google AI, Anthropic, Azure, Hugging Face, Ollama, Mistral).
         3. Key insights and actionable recommendations for cost and performance optimization.
 
         Return the result as a valid JSON object with keys: "analysis", "insights".

package/dist/lib/mcp/servers/ai-providers/ai-core-server.js

@@ -38,7 +38,7 @@ export const aiCoreServer = createMCPServer({
  */
 const TextGenerationSchema = z.object({
     prompt: z.string().min(1, 'Prompt is required'),
-    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai']).optional(),
+    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai', 'azure', 'huggingface', 'ollama', 'mistral']).optional(),
     model: z.string().optional(),
     temperature: z.number().min(0).max(2).optional(),
     maxTokens: z.number().positive().optional(),
@@ -144,12 +144,14 @@ aiCoreServer.registerTool({
             // Use existing provider selection logic
             const availableProviders = getAvailableProviders();
             const selectedProvider = getBestProvider(params.preferred);
-            // Get provider capabilities (mock for now, can be enhanced)
+            // Get provider capabilities
             const getProviderCapabilities = (provider) => ({
-                multimodal: provider === 'openai' || provider === 'vertex',
-                streaming: provider === 'openai' || provider === 'anthropic',
-                maxTokens: provider === 'anthropic' ? 100000 : 4000,
-                costEfficient: provider === 'openai' || provider === 'vertex'
+                multimodal: provider === 'openai' || provider === 'vertex' || provider === 'google-ai',
+                streaming: provider === 'openai' || provider === 'anthropic' || provider === 'azure' || provider === 'mistral',
+                maxTokens: provider === 'anthropic' ? 100000 : provider === 'huggingface' ? 2048 : 4000,
+                costEfficient: provider === 'google-ai' || provider === 'vertex' || provider === 'huggingface' || provider === 'ollama',
+                localExecution: provider === 'ollama',
+                openSource: provider === 'huggingface' || provider === 'ollama'
             });
             const capabilities = getProviderCapabilities(selectedProvider);
             const executionTime = Date.now() - startTime;
@@ -224,9 +226,11 @@ aiCoreServer.registerTool({
                         status: isAvailable ? 'available' : 'unavailable',
                         capabilities: params.includeCapabilities ? {
                             textGeneration: true,
-                            multimodal: provider === 'openai' || provider === 'vertex',
-                            streaming: provider === 'openai' || provider === 'anthropic',
-                            maxTokens: provider === 'anthropic' ? 100000 : 4000
+                            multimodal: provider === 'openai' || provider === 'vertex' || provider === 'google-ai',
+                            streaming: provider === 'openai' || provider === 'anthropic' || provider === 'azure' || provider === 'mistral',
+                            maxTokens: provider === 'anthropic' ? 100000 : provider === 'huggingface' ? 2048 : 4000,
+                            localExecution: provider === 'ollama',
+                            openSource: provider === 'huggingface' || provider === 'ollama'
                         } : undefined,
                         lastChecked: new Date().toISOString()
                     });