@juspay/neurolink 1.2.4 → 1.5.0

package/dist/cli/commands/mcp.js

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Management Commands
+ * Real MCP server connectivity and management
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs';
+import { spawn } from 'child_process';
+import path from 'path';
+// Default MCP config file location
+const MCP_CONFIG_FILE = path.join(process.cwd(), '.mcp-config.json');
+// Load MCP configuration
+function loadMCPConfig() {
+    if (!fs.existsSync(MCP_CONFIG_FILE)) {
+        return { mcpServers: {} };
+    }
+    try {
+        const content = fs.readFileSync(MCP_CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid MCP config file: ${error.message}`);
+    }
+}
+// Save MCP configuration
+function saveMCPConfig(config) {
+    fs.writeFileSync(MCP_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+// Check if MCP server process is running
+async function checkMCPServerStatus(serverConfig) {
+    try {
+        if (serverConfig.transport === 'stdio') {
+            // For stdio servers, we need to actually try connecting
+            const child = spawn(serverConfig.command, serverConfig.args || [], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, ...serverConfig.env },
+                cwd: serverConfig.cwd
+            });
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    child.kill();
+                    resolve(false);
+                }, 3000);
+                child.on('spawn', () => {
+                    clearTimeout(timeout);
+                    child.kill();
+                    resolve(true);
+                });
+                child.on('error', () => {
+                    clearTimeout(timeout);
+                    resolve(false);
+                });
+            });
+        }
+        else if (serverConfig.transport === 'sse' && serverConfig.url) {
+            // For SSE servers, check if URL is accessible
+            try {
+                const response = await fetch(serverConfig.url, { method: 'HEAD' });
+                return response.ok;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+// Connect to MCP server and get capabilities
+async function getMCPServerCapabilities(serverConfig) {
+    if (serverConfig.transport === 'stdio') {
+        // Spawn MCP server and send initialize request
+        const child = spawn(serverConfig.command, serverConfig.args || [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...serverConfig.env },
+            cwd: serverConfig.cwd
+        });
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                child.kill();
+                reject(new Error('Timeout connecting to MCP server'));
+            }, 5000);
+            let responseData = '';
+            child.stdout?.on('data', (data) => {
+                responseData += data.toString();
+                // Look for JSON-RPC response
+                try {
+                    const lines = responseData.split('\n');
+                    for (const line of lines) {
+                        if (line.trim() && line.includes('"result"')) {
+                            const response = JSON.parse(line.trim());
+                            if (response.result && response.result.capabilities) {
+                                clearTimeout(timeout);
+                                child.kill();
+                                resolve(response.result);
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Continue parsing
+                }
+            });
+            child.on('spawn', () => {
+                // Send initialize request
+                const initRequest = {
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'initialize',
+                    params: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {},
+                        clientInfo: {
+                            name: 'neurolink-cli',
+                            version: '1.0.0'
+                        }
+                    }
+                };
+                child.stdin?.write(JSON.stringify(initRequest) + '\n');
+            });
+            child.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    throw new Error('SSE transport not yet implemented for capabilities');
+}
+// List available tools from MCP server
+async function listMCPServerTools(serverConfig) {
+    if (serverConfig.transport === 'stdio') {
+        const child = spawn(serverConfig.command, serverConfig.args || [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...serverConfig.env },
+            cwd: serverConfig.cwd
+        });
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                child.kill();
+                reject(new Error('Timeout listing MCP server tools'));
+            }, 5000);
+            let responseData = '';
+            let initialized = false;
+            child.stdout?.on('data', (data) => {
+                responseData += data.toString();
+                try {
+                    const lines = responseData.split('\n');
+                    for (const line of lines) {
+                        if (line.trim() && line.includes('"result"')) {
+                            const response = JSON.parse(line.trim());
+                            if (response.id === 1 && response.result.capabilities) {
+                                // Initialize successful, now list tools
+                                initialized = true;
+                                const listToolsRequest = {
+                                    jsonrpc: '2.0',
+                                    id: 2,
+                                    method: 'tools/list',
+                                    params: {}
+                                };
+                                child.stdin?.write(JSON.stringify(listToolsRequest) + '\n');
+                            }
+                            else if (response.id === 2 && response.result.tools) {
+                                clearTimeout(timeout);
+                                child.kill();
+                                resolve(response.result.tools);
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Continue parsing
+                }
+            });
+            child.on('spawn', () => {
+                // Send initialize request first
+                const initRequest = {
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'initialize',
+                    params: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {},
+                        clientInfo: {
+                            name: 'neurolink-cli',
+                            version: '1.0.0'
+                        }
+                    }
+                };
+                child.stdin?.write(JSON.stringify(initRequest) + '\n');
+            });
+            child.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    throw new Error('SSE transport not yet implemented for tool listing');
+}
+// MCP Commands for yargs
+export function addMCPCommands(yargs) {
+    return yargs.command('mcp <subcommand>', 'Manage MCP (Model Context Protocol) servers', (yargsBuilder) => {
+        yargsBuilder
+            .usage('Usage: $0 mcp <subcommand> [options]')
+            // List MCP servers
+            .command('list', 'List configured MCP servers', (y) => y
+            .usage('Usage: $0 mcp list [options]')
+            .option('status', { type: 'boolean', description: 'Check server status' })
+            .example('$0 mcp list', 'List all MCP servers')
+            .example('$0 mcp list --status', 'List servers with status check'), async (argv) => {
+            const config = loadMCPConfig();
+            const servers = Object.entries(config.mcpServers);
+            if (servers.length === 0) {
+                console.log(chalk.yellow('📭 No MCP servers configured'));
+                console.log(chalk.blue('💡 Add a server with: neurolink mcp add <name> <command>'));
+                return;
+            }
+            console.log(chalk.blue(`📋 Configured MCP servers (${servers.length}):\n`));
+            for (const [name, serverConfig] of servers) {
+                console.log(chalk.bold(`🔧 ${name}`));
+                console.log(`   Command: ${serverConfig.command} ${(serverConfig.args || []).join(' ')}`);
+                console.log(`   Transport: ${serverConfig.transport}`);
+                if (argv.status) {
+                    const spinner = ora(`Checking ${name}...`).start();
+                    try {
+                        const isRunning = await checkMCPServerStatus(serverConfig);
+                        if (isRunning) {
+                            spinner.succeed(`${name}: ${chalk.green('✅ Available')}`);
+                        }
+                        else {
+                            spinner.fail(`${name}: ${chalk.red('❌ Not available')}`);
+                        }
+                    }
+                    catch (error) {
+                        spinner.fail(`${name}: ${chalk.red('❌ Error')} - ${error.message}`);
+                    }
+                }
+                console.log(); // Empty line
+            }
+        })
+            // Add MCP server
+            .command('add <name> <command>', 'Add a new MCP server', (y) => y
+            .usage('Usage: $0 mcp add <name> <command> [options]')
+            .positional('name', { type: 'string', description: 'Server name', demandOption: true })
+            .positional('command', { type: 'string', description: 'Command to run server', demandOption: true })
+            .option('args', { type: 'array', description: 'Command arguments' })
+            .option('transport', { choices: ['stdio', 'sse'], default: 'stdio', description: 'Transport type' })
+            .option('url', { type: 'string', description: 'URL for SSE transport' })
+            .option('env', { type: 'string', description: 'Environment variables (JSON)' })
+            .option('cwd', { type: 'string', description: 'Working directory' })
+            .example('$0 mcp add filesystem "npx @modelcontextprotocol/server-filesystem"', 'Add filesystem server')
+            .example('$0 mcp add github "npx @modelcontextprotocol/server-github"', 'Add GitHub server'), async (argv) => {
+            const config = loadMCPConfig();
+            const serverConfig = {
+                name: argv.name,
+                command: argv.command,
+                args: argv.args || [],
+                transport: argv.transport,
+                url: argv.url,
+                cwd: argv.cwd
+            };
+            if (argv.env) {
+                try {
+                    serverConfig.env = JSON.parse(argv.env);
+                }
+                catch (error) {
+                    console.error(chalk.red('❌ Invalid JSON for environment variables'));
+                    process.exit(1);
+                }
+            }
+            config.mcpServers[argv.name] = serverConfig;
+            saveMCPConfig(config);
+            console.log(chalk.green(`✅ Added MCP server: ${argv.name}`));
+            console.log(chalk.blue(`💡 Test it with: neurolink mcp test ${argv.name}`));
+        })
+            // Remove MCP server
+            .command('remove <name>', 'Remove an MCP server', (y) => y
+            .usage('Usage: $0 mcp remove <name>')
+            .positional('name', { type: 'string', description: 'Server name to remove', demandOption: true })
+            .example('$0 mcp remove filesystem', 'Remove filesystem server'), async (argv) => {
+            const config = loadMCPConfig();
+            if (!config.mcpServers[argv.name]) {
+                console.error(chalk.red(`❌ MCP server '${argv.name}' not found`));
+                process.exit(1);
+            }
+            delete config.mcpServers[argv.name];
+            saveMCPConfig(config);
+            console.log(chalk.green(`✅ Removed MCP server: ${argv.name}`));
+        })
+            // Test MCP server
+            .command('test <name>', 'Test connection to an MCP server', (y) => y
+            .usage('Usage: $0 mcp test <name>')
+            .positional('name', { type: 'string', description: 'Server name to test', demandOption: true })
+            .example('$0 mcp test filesystem', 'Test filesystem server'), async (argv) => {
+            const config = loadMCPConfig();
+            const serverConfig = config.mcpServers[argv.name];
+            if (!serverConfig) {
+                console.error(chalk.red(`❌ MCP server '${argv.name}' not found`));
+                process.exit(1);
+            }
+            console.log(chalk.blue(`🔍 Testing MCP server: ${argv.name}\n`));
+            const spinner = ora('Connecting...').start();
+            try {
+                // Test basic connectivity
+                const isRunning = await checkMCPServerStatus(serverConfig);
+                if (!isRunning) {
+                    spinner.fail(chalk.red('❌ Server not available'));
+                    return;
+                }
+                spinner.text = 'Getting capabilities...';
+                const capabilities = await getMCPServerCapabilities(serverConfig);
+                spinner.text = 'Listing tools...';
+                const tools = await listMCPServerTools(serverConfig);
+                spinner.succeed(chalk.green('✅ Connection successful!'));
+                console.log(chalk.blue('\n📋 Server Capabilities:'));
+                console.log(`   Protocol Version: ${capabilities.protocolVersion || 'Unknown'}`);
+                if (capabilities.capabilities.tools) {
+                    console.log(`   Tools: ✅ Supported`);
+                }
+                if (capabilities.capabilities.resources) {
+                    console.log(`   Resources: ✅ Supported`);
+                }
+                console.log(chalk.blue('\n🛠️  Available Tools:'));
+                if (tools.length === 0) {
+                    console.log('   No tools available');
+                }
+                else {
+                    tools.forEach((tool) => {
+                        console.log(`   • ${tool.name}: ${tool.description || 'No description'}`);
+                    });
+                }
+            }
+            catch (error) {
+                spinner.fail(chalk.red('❌ Connection failed'));
+                console.error(chalk.red(`Error: ${error.message}`));
+            }
+        })
+            // Install popular MCP servers
+            .command('install <server>', 'Install popular MCP servers', (y) => y
+            .usage('Usage: $0 mcp install <server>')
+            .positional('server', {
+            type: 'string',
+            choices: ['filesystem', 'github', 'postgres', 'brave-search', 'puppeteer'],
+            description: 'Server to install',
+            demandOption: true
+        })
+            .example('$0 mcp install filesystem', 'Install filesystem server')
+            .example('$0 mcp install github', 'Install GitHub server'), async (argv) => {
+            const serverName = argv.server;
+            const config = loadMCPConfig();
+            // Pre-configured popular MCP servers
+            const serverConfigs = {
+                filesystem: {
+                    name: 'filesystem',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-filesystem', '/'],
+                    transport: 'stdio'
+                },
+                github: {
+                    name: 'github',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-github'],
+                    transport: 'stdio'
+                },
+                postgres: {
+                    name: 'postgres',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-postgres'],
+                    transport: 'stdio'
+                },
+                'brave-search': {
+                    name: 'brave-search',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-brave-search'],
+                    transport: 'stdio'
+                },
+                puppeteer: {
+                    name: 'puppeteer',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-puppeteer'],
+                    transport: 'stdio'
+                }
+            };
+            const serverConfig = serverConfigs[serverName];
+            if (!serverConfig) {
+                console.error(chalk.red(`❌ Unknown server: ${serverName}`));
+                process.exit(1);
+            }
+            console.log(chalk.blue(`📦 Installing MCP server: ${serverName}`));
+            config.mcpServers[serverName] = serverConfig;
+            saveMCPConfig(config);
+            console.log(chalk.green(`✅ Installed MCP server: ${serverName}`));
+            console.log(chalk.blue(`💡 Test it with: neurolink mcp test ${serverName}`));
+        })
+            // Execute tool from MCP server
+            .command('exec <server> <tool>', 'Execute a tool from an MCP server', (y) => y
+            .usage('Usage: $0 mcp exec <server> <tool> [options]')
+            .positional('server', { type: 'string', description: 'Server name', demandOption: true })
+            .positional('tool', { type: 'string', description: 'Tool name', demandOption: true })
+            .option('params', { type: 'string', description: 'Tool parameters (JSON)' })
+            .example('$0 mcp exec filesystem read_file --params \'{"path": "README.md"}\'', 'Read file using filesystem server'), async (argv) => {
+            const config = loadMCPConfig();
+            const serverConfig = config.mcpServers[argv.server];
+            if (!serverConfig) {
+                console.error(chalk.red(`❌ MCP server '${argv.server}' not found`));
+                process.exit(1);
+            }
+            let params = {};
+            if (argv.params) {
+                try {
+                    params = JSON.parse(argv.params);
+                }
+                catch (error) {
+                    console.error(chalk.red('❌ Invalid JSON for parameters'));
+                    process.exit(1);
+                }
+            }
+            console.log(chalk.blue(`🔧 Executing tool: ${argv.tool} on server: ${argv.server}`));
+            // This would need full MCP client implementation
+            // For now, show what would happen
+            console.log(chalk.yellow('⚠️  Tool execution not yet implemented'));
+            console.log(`Tool: ${argv.tool}`);
+            console.log(`Parameters: ${JSON.stringify(params, null, 2)}`);
+        })
+            .demandCommand(1, 'Please specify an MCP subcommand')
+            .example('$0 mcp list', 'List configured MCP servers')
+            .example('$0 mcp install filesystem', 'Install filesystem MCP server')
+            .example('$0 mcp test filesystem', 'Test filesystem server connection');
+    });
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * NeuroLink CLI - Enhanced Simplified Approach
+ *
+ * Professional CLI experience with minimal maintenance overhead.
+ * Features: Spinners, colors, batch processing, provider testing, rich help
+ * Implementation: ~300 lines using simple JS utility functions
+ */
+export {};

package/dist/cli/index.js

@@ -14,6 +14,7 @@ import chalk from 'chalk';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { addMCPCommands } from './commands/mcp.js';
 // Load environment variables from .env file
 try {
     // Try to import and configure dotenv
@@ -98,6 +99,8 @@ function handleError(error, context) {
         console.error(chalk.yellow('💡 Set API key: export OPENAI_API_KEY=sk-...'));
         console.error(chalk.yellow('💡 Or set AWS credentials & region: export AWS_ACCESS_KEY_ID=... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-east-1'));
         console.error(chalk.yellow('💡 Or set Google credentials: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json'));
+        console.error(chalk.yellow('💡 Or set Anthropic API key: export ANTHROPIC_API_KEY=sk-ant-...'));
+        console.error(chalk.yellow('💡 Or set Azure OpenAI credentials: export AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=...'));
     }
     if (error.message.toLowerCase().includes('rate limit')) {
         console.error(chalk.yellow('💡 Try again in a few moments or use --provider vertex'));
@@ -140,9 +143,9 @@ const cli = yargs(args)
     .alias('V', 'version')
     .strictOptions()
     .strictCommands()
-    .demandCommand(1, 'You need at least one command before moving on')
+    .demandCommand(1, '')
     .epilogue('For more info: https://github.com/juspay/neurolink')
-    .showHelpOnFail(false)
+    .showHelpOnFail(true, 'Specify --help for available options')
     .middleware((argv) => {
     // Middleware for NEUROLINK_QUIET is fine
     if (process.env.NEUROLINK_QUIET === 'true' && typeof argv.quiet === 'undefined') {
@@ -209,7 +212,7 @@ const cli = yargs(args)
     demandOption: true,
 })
     .option('provider', {
-    choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure'],
+    choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'],
     default: 'auto',
     description: 'AI provider to use (auto-selects best available)'
 })
@@ -263,6 +266,8 @@ const cli = yargs(args)
             if (result.usage)
                 console.log(chalk.blue(`ℹ️  ${result.usage.totalTokens} tokens used`));
         }
+        // Explicitly exit to prevent hanging, especially with Google AI Studio
+        process.exit(0);
     }
     catch (error) {
         if (argv.format === 'json' && originalConsole.log) {
@@ -283,7 +288,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'], default: 'auto', description: 'AI provider to use' })
+    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'], default: 'auto', description: 'AI provider to use' })
     .option('temperature', { type: 'number', default: 0.7, description: 'Creativity level' })
     .example('$0 stream "Tell me a story"', 'Stream a story in real-time'), async (argv) => {
     if (!argv.quiet)
@@ -310,7 +315,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'], default: 'auto', description: 'AI provider to use' })
+    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'], 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' })
@@ -390,7 +395,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'];
+        const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'];
         const results = [];
         for (const p of providers) {
             if (spinner)
@@ -424,13 +429,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');
+        console.log('Available providers: openai, bedrock, vertex, anthropic, azure, google-ai');
     })
         .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'],
+        choices: ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'],
         description: 'Name of the provider to configure',
         demandOption: true,
     })
@@ -462,7 +467,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'];
+    const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai'];
     const results = [];
     for (const p of providers) {
         if (spinner)
@@ -564,6 +569,8 @@ const cli = yargs(args)
     }
 })
     .completion('completion', 'Generate shell completion script');
+// Add MCP commands
+addMCPCommands(cli);
 // 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 } from '../providers/index.js';
+import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio } from '../providers/index.js';
 import { getBestProvider } from '../utils/providerUtils.js';
 const componentIdentifier = 'aiProviderFactory';
 /**
@@ -42,8 +42,12 @@ export class AIProviderFactory {
                 case 'azure-openai':
                     provider = new AzureOpenAIProvider();
                     break;
+                case 'google-ai':
+                case 'google-studio':
+                    provider = new GoogleAIStudio(modelName);
+                    break;
                 default:
-                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure`);
+                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai`);
             }
             console.log(`[${functionTag}] Provider creation succeeded`, {
                 providerName,

package/dist/core/types.d.ts

@@ -8,7 +8,8 @@ export declare enum AIProviderName {
     OPENAI = "openai",
     VERTEX = "vertex",
     ANTHROPIC = "anthropic",
-    AZURE = "azure"
+    AZURE = "azure",
+    GOOGLE_AI = "google-ai"
 }
 /**
  * Supported Models for Amazon Bedrock
@@ -36,10 +37,19 @@ export declare enum VertexModels {
     CLAUDE_4_0_SONNET = "claude-sonnet-4@20250514",
     GEMINI_2_5_FLASH = "gemini-2.5-flash-preview-05-20"
 }
+/**
+ * Supported Models for Google AI Studio
+ */
+export declare enum GoogleAIModels {
+    GEMINI_1_5_PRO_LATEST = "gemini-1.5-pro-latest",
+    GEMINI_1_5_FLASH_LATEST = "gemini-1.5-flash-latest",
+    GEMINI_2_0_FLASH_EXP = "gemini-2.0-flash-exp",
+    GEMINI_1_0_PRO = "gemini-1.0-pro"
+}
 /**
  * Union type of all supported model names
  */
-export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels;
+export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels | GoogleAIModels;
 /**
  * Provider configuration specifying provider and its available models
  */

package/dist/core/types.js

@@ -8,6 +8,7 @@ export var AIProviderName;
     AIProviderName["VERTEX"] = "vertex";
     AIProviderName["ANTHROPIC"] = "anthropic";
     AIProviderName["AZURE"] = "azure";
+    AIProviderName["GOOGLE_AI"] = "google-ai";
 })(AIProviderName || (AIProviderName = {}));
 /**
  * Supported Models for Amazon Bedrock
@@ -38,6 +39,16 @@ export var VertexModels;
     VertexModels["CLAUDE_4_0_SONNET"] = "claude-sonnet-4@20250514";
     VertexModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash-preview-05-20";
 })(VertexModels || (VertexModels = {}));
+/**
+ * Supported Models for Google AI Studio
+ */
+export var GoogleAIModels;
+(function (GoogleAIModels) {
+    GoogleAIModels["GEMINI_1_5_PRO_LATEST"] = "gemini-1.5-pro-latest";
+    GoogleAIModels["GEMINI_1_5_FLASH_LATEST"] = "gemini-1.5-flash-latest";
+    GoogleAIModels["GEMINI_2_0_FLASH_EXP"] = "gemini-2.0-flash-exp";
+    GoogleAIModels["GEMINI_1_0_PRO"] = "gemini-1.0-pro";
+})(GoogleAIModels || (GoogleAIModels = {}));
 /**
  * Default provider configurations
  */