@rv404/mcp-launchpad 1.0.0

package/dist/backends/gemini.js

@@ -0,0 +1,702 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Google AI Gemini API configuration (uses API key)
+const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY;
+const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
+// Default output directory for generated images (auto-saves there if no outputPath specified)
+const DEFAULT_IMAGE_OUTPUT_DIR = process.env.GEMINI_IMAGE_OUTPUT_DIR;
+// Local store registry (like the Python CLI)
+const CONFIG_DIR = path.join(os.homedir(), '.gemini-file-search');
+const STORES_FILE = path.join(CONFIG_DIR, 'stores.json');
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+function loadStores() {
+    if (!fs.existsSync(STORES_FILE)) {
+        return {};
+    }
+    const content = fs.readFileSync(STORES_FILE, 'utf-8');
+    return JSON.parse(content);
+}
+function saveStores(stores) {
+    ensureConfigDir();
+    fs.writeFileSync(STORES_FILE, JSON.stringify(stores, null, 2));
+}
+function getStoreId(name) {
+    const stores = loadStores();
+    if (!(name in stores)) {
+        const available = Object.keys(stores).join(', ') || 'none';
+        throw new Error(`Store '${name}' not found. Available stores: ${available}`);
+    }
+    return stores[name].id;
+}
+// ============================================================================
+// Action Definitions
+// ============================================================================
+const actions = [
+    // Image Generation
+    {
+        name: 'generate_image',
+        description: 'Generate images using Google Imagen 4. Creates high-quality images from text descriptions.',
+        params: [
+            { name: 'prompt', type: 'string', required: true, description: 'Detailed text description of the image to generate' },
+            { name: 'aspectRatio', type: 'string', required: false, description: 'Aspect ratio: 1:1, 16:9, 9:16, 4:3, 3:4 (default: 1:1)' },
+            { name: 'negativePrompt', type: 'string', required: false, description: 'What to exclude or avoid in the generated image' },
+            { name: 'sampleCount', type: 'number', required: false, description: 'Number of image variations (1-4, default: 1)' },
+            { name: 'outputPath', type: 'string', required: false, description: 'File path to save the generated image (default: returns base64)' },
+        ],
+    },
+    // File Search - Store Management
+    {
+        name: 'create_store',
+        description: 'Create a new File Search store for indexing documents. Returns the store ID.',
+        params: [
+            { name: 'name', type: 'string', required: true, description: 'Local name for the store (used to reference it in other commands)' },
+            { name: 'displayName', type: 'string', required: false, description: 'Display name in Google Cloud (defaults to name)' },
+        ],
+    },
+    {
+        name: 'list_stores',
+        description: 'List all registered File Search stores with their metadata.',
+        params: [],
+    },
+    {
+        name: 'delete_store',
+        description: 'Delete a File Search store. The store must be empty (no indexed files).',
+        params: [
+            { name: 'name', type: 'string', required: true, description: 'Name of the store to delete' },
+        ],
+    },
+    // File Search - Indexing
+    {
+        name: 'index_file',
+        description: 'Index a single file into a File Search store. Supports text files, code, JSON, etc.',
+        params: [
+            { name: 'storeName', type: 'string', required: true, description: 'Name of the store to index into' },
+            { name: 'filePath', type: 'string', required: true, description: 'Absolute path to the file to index' },
+        ],
+    },
+    {
+        name: 'index_directory',
+        description: 'Index all supported files in a directory into a File Search store.',
+        params: [
+            { name: 'storeName', type: 'string', required: true, description: 'Name of the store to index into' },
+            { name: 'directoryPath', type: 'string', required: true, description: 'Absolute path to the directory to index' },
+            { name: 'extensions', type: 'string', required: false, description: 'Comma-separated file extensions to include (e.g., ".py,.js,.ts"). Defaults to common code/text files.' },
+            { name: 'excludeDirs', type: 'string', required: false, description: 'Comma-separated directory names to exclude (e.g., "node_modules,.git,venv")' },
+        ],
+    },
+    // File Search - Querying
+    {
+        name: 'query_store',
+        description: 'Query a File Search store with a natural language question. Returns an answer with citations.',
+        params: [
+            { name: 'storeName', type: 'string', required: true, description: 'Name of the store to query' },
+            { name: 'question', type: 'string', required: true, description: 'Natural language question to ask about the indexed content' },
+            { name: 'model', type: 'string', required: false, description: 'Gemini model to use (default: gemini-2.5-flash)' },
+            { name: 'filter', type: 'string', required: false, description: 'Metadata filter (e.g., "file_extension=.py")' },
+        ],
+    },
+];
+// ============================================================================
+// Image Generation
+// ============================================================================
+async function generateImage(params) {
+    let { prompt, aspectRatio = '1:1', negativePrompt, sampleCount = 1, outputPath, } = params;
+    if (!prompt || typeof prompt !== 'string') {
+        throw new Error('prompt is required and must be a string');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    // If no outputPath provided but DEFAULT_IMAGE_OUTPUT_DIR is set, generate a filename
+    if (!outputPath && DEFAULT_IMAGE_OUTPUT_DIR) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const sanitizedPrompt = prompt.slice(0, 30).replace(/[^a-zA-Z0-9]/g, '_').replace(/_+/g, '_');
+        outputPath = path.join(DEFAULT_IMAGE_OUTPUT_DIR, `${timestamp}_${sanitizedPrompt}.png`);
+    }
+    // Build the prompt with negative prompt if provided
+    let fullPrompt = prompt;
+    if (negativePrompt && typeof negativePrompt === 'string') {
+        fullPrompt = prompt + '. Avoid: ' + negativePrompt;
+    }
+    // Use Imagen 4 model via Google AI API
+    const endpoint = BASE_URL + '/models/imagen-4.0-generate-001:predict?key=' + GOOGLE_API_KEY;
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            instances: [{ prompt: fullPrompt }],
+            parameters: {
+                sampleCount: Math.min(Math.max(Number(sampleCount) || 1, 1), 4),
+                aspectRatio,
+                outputOptions: {
+                    mimeType: 'image/png',
+                },
+            },
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Imagen API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    // Handle both response formats (:predict uses predictions, legacy uses generatedImages)
+    const predictions = data.predictions || [];
+    const generatedImages = data.generatedImages || [];
+    // Normalize to unified format
+    const images = predictions.length > 0
+        ? predictions.map(p => ({ imageBytes: p.bytesBase64Encoded }))
+        : generatedImages.map(g => ({ imageBytes: g.image.imageBytes }));
+    if (images.length === 0) {
+        throw new Error('No images generated. The prompt may have been filtered for safety reasons.');
+    }
+    // If outputPath is provided, save the image(s) to disk
+    if (outputPath && typeof outputPath === 'string' && images.length > 0) {
+        const savedFiles = [];
+        for (let i = 0; i < images.length; i++) {
+            const imageData = images[i].imageBytes;
+            const imageBuffer = Buffer.from(imageData, 'base64');
+            let filePath = outputPath;
+            if (images.length > 1) {
+                const ext = path.extname(outputPath);
+                const base = outputPath.slice(0, -ext.length);
+                filePath = base + '_' + (i + 1) + ext;
+            }
+            // Ensure directory exists
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, imageBuffer);
+            savedFiles.push(filePath);
+        }
+        return {
+            success: true,
+            savedFiles,
+            count: savedFiles.length,
+            message: 'Saved ' + savedFiles.length + ' image(s) to disk',
+        };
+    }
+    // Return the raw response with base64 data
+    return {
+        success: true,
+        images: images.map(img => ({ base64: img.imageBytes })),
+        count: images.length,
+    };
+}
+// ============================================================================
+// File Search - Store Management
+// ============================================================================
+async function createStore(params) {
+    const { name, displayName } = params;
+    if (!name || typeof name !== 'string') {
+        throw new Error('name is required and must be a string');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    // Validate store name
+    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+        throw new Error('Store name must start with a letter and contain only letters, numbers, hyphens, and underscores');
+    }
+    if (name.length > 64) {
+        throw new Error('Store name too long (max 64 characters)');
+    }
+    // Check if store already exists locally
+    const stores = loadStores();
+    if (name in stores) {
+        throw new Error(`Store '${name}' already exists. Use a different name or delete it first.`);
+    }
+    // Create the store via API
+    const endpoint = `${BASE_URL}/fileSearchStores?key=${GOOGLE_API_KEY}`;
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            displayName: displayName || name,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create store: ${errorText}`);
+    }
+    const storeData = await response.json();
+    // Register locally
+    stores[name] = {
+        id: storeData.name,
+        metadata: {
+            display_name: displayName || name,
+            created_at: new Date().toISOString(),
+            file_count: 0,
+            total_size: 0,
+            indexed_files: [],
+        },
+    };
+    saveStores(stores);
+    return {
+        success: true,
+        name,
+        storeId: storeData.name,
+        message: `Store '${name}' created successfully`,
+    };
+}
+async function listStores() {
+    const stores = loadStores();
+    const storeList = Object.entries(stores).map(([name, data]) => ({
+        name,
+        id: data.id,
+        ...data.metadata,
+    }));
+    return {
+        stores: storeList,
+        count: storeList.length,
+    };
+}
+async function deleteStore(params) {
+    const { name } = params;
+    if (!name || typeof name !== 'string') {
+        throw new Error('name is required and must be a string');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    const stores = loadStores();
+    if (!(name in stores)) {
+        throw new Error(`Store '${name}' not found`);
+    }
+    const storeId = stores[name].id;
+    // Delete from Google Cloud
+    const endpoint = `${BASE_URL}/${storeId}?key=${GOOGLE_API_KEY}`;
+    const response = await fetch(endpoint, {
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to delete store: ${errorText}`);
+    }
+    // Remove from local registry
+    delete stores[name];
+    saveStores(stores);
+    return {
+        success: true,
+        message: `Store '${name}' deleted successfully`,
+    };
+}
+// ============================================================================
+// File Search - Indexing
+// ============================================================================
+// Supported file extensions
+const SUPPORTED_EXTENSIONS = new Set([
+    // Code files
+    '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs', '.rb',
+    '.php', '.swift', '.kt', '.scala', '.c', '.cpp', '.h', '.hpp',
+    '.cs', '.vb', '.fs', '.r', '.m', '.mm', '.pl', '.pm', '.lua',
+    '.sh', '.bash', '.zsh', '.ps1', '.bat', '.cmd',
+    // Config/data files
+    '.json', '.yaml', '.yml', '.xml', '.toml', '.ini', '.cfg', '.conf',
+    '.properties',
+    // Documentation
+    '.md', '.markdown', '.txt', '.rst', '.adoc', '.tex',
+    // Web
+    '.html', '.htm', '.css', '.scss', '.sass', '.less',
+    // Database
+    '.sql',
+    // Other
+    '.csv', '.log', '.gitignore', '.dockerfile',
+]);
+// Directories to skip by default
+const DEFAULT_EXCLUDES = new Set([
+    'node_modules', '.git', '.svn', '.hg', 'venv', '.venv', 'env',
+    '__pycache__', '.pytest_cache', '.mypy_cache', 'dist', 'build',
+    '.next', '.nuxt', 'vendor', 'target', 'bin', 'obj',
+]);
+// Sensitive paths to never index
+const SENSITIVE_DIRS = new Set([
+    '.ssh', '.gnupg', '.gpg', '.aws', '.azure', '.gcloud',
+    '.env', '.secrets', 'secrets',
+]);
+const SENSITIVE_PATTERNS = [
+    /\.env(\..+)?$/i,
+    /\.pem$/i,
+    /\.key$/i,
+    /\.p12$/i,
+    /\.pfx$/i,
+    /id_rsa/i,
+    /id_ed25519/i,
+    /credentials\.json$/i,
+    /service[_-]?account.*\.json$/i,
+    /.*secret.*\.json$/i,
+];
+function isSensitivePath(filePath) {
+    const parts = filePath.split(path.sep).map(p => p.toLowerCase());
+    // Check for sensitive directories
+    for (const dir of SENSITIVE_DIRS) {
+        if (parts.includes(dir.toLowerCase())) {
+            return true;
+        }
+    }
+    // Check for sensitive file patterns
+    const filename = path.basename(filePath);
+    for (const pattern of SENSITIVE_PATTERNS) {
+        if (pattern.test(filename)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function indexFile(params) {
+    const { storeName, filePath } = params;
+    if (!storeName || typeof storeName !== 'string') {
+        throw new Error('storeName is required');
+    }
+    if (!filePath || typeof filePath !== 'string') {
+        throw new Error('filePath is required');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    // Security check
+    if (isSensitivePath(filePath)) {
+        throw new Error(`Refusing to index sensitive file: ${filePath}`);
+    }
+    const storeId = getStoreId(storeName);
+    // Read file content
+    const fileContent = fs.readFileSync(filePath);
+    const fileSize = fs.statSync(filePath).size;
+    const fileName = path.basename(filePath);
+    // Determine MIME type based on extension
+    const ext = path.extname(filePath).toLowerCase();
+    let mimeType = 'text/plain';
+    if (['.json'].includes(ext)) {
+        mimeType = 'application/json';
+    }
+    else if (['.html', '.htm'].includes(ext)) {
+        mimeType = 'text/html';
+    }
+    else if (['.xml'].includes(ext)) {
+        mimeType = 'application/xml';
+    }
+    else if (['.md', '.markdown'].includes(ext)) {
+        mimeType = 'text/markdown';
+    }
+    else if (['.css'].includes(ext)) {
+        mimeType = 'text/css';
+    }
+    else if (['.js', '.ts', '.jsx', '.tsx'].includes(ext)) {
+        mimeType = 'text/javascript';
+    }
+    else if (['.py'].includes(ext)) {
+        mimeType = 'text/x-python';
+    }
+    // Step 1: Upload file to Files API first
+    // Use media upload endpoint
+    const uploadEndpoint = `https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}`;
+    // Generate a safe file ID (alphanumeric and dashes only, max 40 chars)
+    const safeFileName = fileName
+        .replace(/[^a-zA-Z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase()
+        .slice(0, 35);
+    const fileId = `${safeFileName}-${Date.now().toString(36)}`;
+    const uploadResponse = await fetch(uploadEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': mimeType,
+            'X-Goog-Upload-Protocol': 'raw',
+            'X-Goog-Upload-Command': 'upload, finalize',
+        },
+        body: fileContent,
+    });
+    if (!uploadResponse.ok) {
+        const errorText = await uploadResponse.text();
+        throw new Error(`Failed to upload file to Files API: ${errorText}`);
+    }
+    const uploadData = await uploadResponse.json();
+    const uploadedFileName = uploadData.file?.name;
+    if (!uploadedFileName) {
+        throw new Error('File upload succeeded but no file name returned');
+    }
+    // Step 2: Import the uploaded file into the FileSearchStore
+    const importEndpoint = `${BASE_URL}/${storeId}:importFile?key=${GOOGLE_API_KEY}`;
+    const importResponse = await fetch(importEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            fileName: uploadedFileName,
+        }),
+    });
+    if (!importResponse.ok) {
+        const errorText = await importResponse.text();
+        throw new Error(`Failed to import file to store: ${errorText}`);
+    }
+    // Update local metadata
+    const stores = loadStores();
+    if (storeName in stores) {
+        const metadata = stores[storeName].metadata;
+        metadata.file_count = (metadata.file_count || 0) + 1;
+        metadata.total_size = (metadata.total_size || 0) + fileSize;
+        metadata.indexed_files = metadata.indexed_files || [];
+        if (!metadata.indexed_files.includes(filePath)) {
+            metadata.indexed_files.push(filePath);
+        }
+        metadata.last_indexed = new Date().toISOString();
+        saveStores(stores);
+    }
+    return {
+        success: true,
+        file: fileName,
+        size: fileSize,
+        uploadedAs: uploadedFileName,
+        message: `File '${fileName}' indexed successfully`,
+    };
+}
+async function indexDirectory(params) {
+    const { storeName, directoryPath, extensions, excludeDirs } = params;
+    if (!storeName || typeof storeName !== 'string') {
+        throw new Error('storeName is required');
+    }
+    if (!directoryPath || typeof directoryPath !== 'string') {
+        throw new Error('directoryPath is required');
+    }
+    if (!fs.existsSync(directoryPath)) {
+        throw new Error(`Directory not found: ${directoryPath}`);
+    }
+    if (!fs.statSync(directoryPath).isDirectory()) {
+        throw new Error(`Not a directory: ${directoryPath}`);
+    }
+    // Build extension set
+    let includeExtensions = SUPPORTED_EXTENSIONS;
+    if (extensions && typeof extensions === 'string') {
+        includeExtensions = new Set(extensions.split(',').map(e => e.trim().toLowerCase()));
+    }
+    // Build exclusion set
+    const excludeSet = new Set(DEFAULT_EXCLUDES);
+    if (excludeDirs && typeof excludeDirs === 'string') {
+        excludeDirs.split(',').forEach(d => excludeSet.add(d.trim()));
+    }
+    // Collect files to index
+    const filesToIndex = [];
+    function walkDir(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip excluded directories
+                if (excludeSet.has(entry.name) || isSensitivePath(fullPath)) {
+                    continue;
+                }
+                walkDir(fullPath);
+            }
+            else if (entry.isFile()) {
+                // Check extension
+                const ext = path.extname(entry.name).toLowerCase();
+                if (!includeExtensions.has(ext)) {
+                    continue;
+                }
+                // Skip sensitive files
+                if (isSensitivePath(fullPath)) {
+                    continue;
+                }
+                filesToIndex.push(fullPath);
+            }
+        }
+    }
+    walkDir(directoryPath);
+    if (filesToIndex.length === 0) {
+        return {
+            success: true,
+            indexed: 0,
+            errors: [],
+            message: 'No supported files found to index',
+        };
+    }
+    // Index files one by one
+    const results = {
+        indexed: 0,
+        failed: 0,
+        errors: [],
+        files: [],
+    };
+    for (const file of filesToIndex) {
+        try {
+            await indexFile({ storeName, filePath: file });
+            results.indexed++;
+            results.files.push(path.basename(file));
+        }
+        catch (error) {
+            results.failed++;
+            results.errors.push({
+                file: path.basename(file),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        success: true,
+        indexed: results.indexed,
+        failed: results.failed,
+        errors: results.errors,
+        message: `Indexed ${results.indexed} files (${results.failed} failed)`,
+    };
+}
+// ============================================================================
+// File Search - Querying
+// ============================================================================
+async function queryStore(params) {
+    const { storeName, question, model = 'gemini-2.5-flash', filter } = params;
+    if (!storeName || typeof storeName !== 'string') {
+        throw new Error('storeName is required');
+    }
+    if (!question || typeof question !== 'string') {
+        throw new Error('question is required');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    const storeId = getStoreId(storeName);
+    // Build the FileSearch tool configuration
+    const fileSearchConfig = {
+        fileSearchStoreNames: [storeId],
+    };
+    if (filter && typeof filter === 'string') {
+        fileSearchConfig.metadataFilter = filter;
+    }
+    // Call generateContent with File Search tool
+    const endpoint = `${BASE_URL}/models/${model}:generateContent?key=${GOOGLE_API_KEY}`;
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            contents: [
+                {
+                    parts: [{ text: question }],
+                },
+            ],
+            tools: [
+                {
+                    fileSearch: fileSearchConfig,
+                },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Query failed: ${errorText}`);
+    }
+    const data = await response.json();
+    // Extract the answer
+    let answer = '';
+    if (data.candidates && data.candidates[0]?.content?.parts) {
+        for (const part of data.candidates[0].content.parts) {
+            if (part.text) {
+                answer += part.text;
+            }
+        }
+    }
+    // Extract citations from grounding metadata
+    const citations = [];
+    const groundingMetadata = data.candidates?.[0]?.groundingMetadata;
+    if (groundingMetadata?.groundingChunks) {
+        for (const chunk of groundingMetadata.groundingChunks) {
+            const ctx = chunk.retrievedContext;
+            if (ctx) {
+                let fileName = 'Unknown';
+                if (ctx.uri) {
+                    fileName = ctx.uri.split('/').pop() || ctx.uri;
+                }
+                else if (ctx.title) {
+                    fileName = ctx.title;
+                }
+                citations.push({
+                    file: fileName,
+                    text: ctx.text,
+                });
+            }
+        }
+    }
+    return {
+        success: true,
+        answer: answer.trim(),
+        citations,
+        model,
+        storeName,
+    };
+}
+// ============================================================================
+// Backend Export
+// ============================================================================
+export const geminiBackend = {
+    name: 'gemini',
+    description: 'Google Gemini services: Imagen 4 image generation and File Search RAG.',
+    actions,
+    async execute(action, params) {
+        switch (action) {
+            // Image Generation
+            case 'generate_image':
+                return generateImage(params);
+            // File Search - Store Management
+            case 'create_store':
+                return createStore(params);
+            case 'list_stores':
+                return listStores();
+            case 'delete_store':
+                return deleteStore(params);
+            // File Search - Indexing
+            case 'index_file':
+                return indexFile(params);
+            case 'index_directory':
+                return indexDirectory(params);
+            // File Search - Querying
+            case 'query_store':
+                return queryStore(params);
+            default:
+                throw new Error('Unknown action: ' + action);
+        }
+    },
+    async healthCheck() {
+        const startTime = Date.now();
+        try {
+            if (!GOOGLE_API_KEY) {
+                return {
+                    status: 'unavailable',
+                    latency_ms: Date.now() - startTime,
+                    error: 'GOOGLE_API_KEY environment variable is not set'
+                };
+            }
+            // Quick check that the API key format looks valid
+            if (GOOGLE_API_KEY.length < 20) {
+                return {
+                    status: 'unavailable',
+                    latency_ms: Date.now() - startTime,
+                    error: 'GOOGLE_API_KEY appears to be invalid (too short)'
+                };
+            }
+            return { status: 'healthy', latency_ms: Date.now() - startTime };
+        }
+        catch (error) {
+            return {
+                status: 'unavailable',
+                latency_ms: Date.now() - startTime,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    },
+};
+//# sourceMappingURL=gemini.js.map