Report hacker09's Profile 1u3f41

// ==Script==
// @name         Highlight & Gemini Interaction
// @namespace    http://tampermonkey.net/
// @version      0.0
// @description  Highlight text, offers options (text, translate, image), to interact with Gemini AI.
// @author       You
// @match        *://*/*
// @grant        GM_xmlhttpRequest
// @grant        GM_addStyle
// @require      https://code.jquery.com/jquery-3.6.0.min.js
// @require      https://cdn.jsdelivr.net/npm/marked/marked.min.js
// @grant        GM_setValue
// @grant        GM_getValue
// @run-at       document-end
// @connect      google.com
// @connect      generativelanguage.googleapis.com
// ==/Script==

(function() {
    'use strict';

    // Global Variables
    let selectedText = '';
    let geminiOverlay;
    let promptOverlay;
    let inputArea;
    let responseArea;
    let closeButton;
    let translateButton;
    let imageButton;
    let textButton;
    let askButton;
    let imageCheckbox;
    let imageCheckbox2;
    const textModel = 'gemini-1.5-flash';
    const imageModel = 'gemini-2.0-flash-exp-image-generation';
    const imagenModel = 'imagen-3.0-generate-002';
    let generateImageModel = imageModel;

    // API Key Setup
    if ((location.href === 'https://aistudio.google.com/app/apikey' && document.querySelector(".apikey-link") !== null) && (GM_getValue("APIKey") === undefined || GM_getValue("APIKey") === null || GM_getValue("APIKey") === '')) {
        window.onload = setTimeout(function() {
            document.querySelectorAll(".apikey-link")[1].click();
            setTimeout(function() {
                GM_setValue("APIKey", document.querySelector(".apikey-text").innerText);
                alert((GM_getValue("APIKey") !== undefined && GM_getValue("APIKey") !== null && GM_getValue("APIKey") !== '') ? 'API Key automatically added!' : 'Failed to automatically add API Key!');
            }, 500);
        }, 1000);
    }

    // --- HELPER FUNCTION TO EXTRACT TEXT ---
    function tryExtractText(data) {
        const possiblePaths = [
            () => data?.candidates?.[0]?.content?.parts?.[0]?.text,
            () => data?.content,
            () => data?.choices?.[0]?.message?.content,
            () => data?.response?.candidates?.[0]?.content?.parts?.[0]?.text //Another possibility
        ];

        for (const pathFn of possiblePaths) {
            try {
                const text = pathFn();
                if (text) {
                    console.log("Text Extracted with PATH:", pathFn.name);
                    return text;
                }
            } catch (e) {
                console.warn("Path extraction failed", pathFn.name, e);
            }
        }
        return null;
    }

// ... (previous code before callGeminiAPI function)

// Function to handle API requests
function callGeminiAPI(prompt, callback, model = textModel, isImage = false) {
    console.log("callGeminiAPI called with prompt:", prompt, " and model:", model, " and isImage:", isImage);
    let requestData;
    const responseModalities = isImage ? ['TEXT', 'IMAGE'] : ['TEXT'];
    let generateContentEndpoint = isImage ? 'predict' : 'generateContent';

    if (model !== imagenModel) {
        generateContentEndpoint = 'generateContent'; // For other models, it's 'generateContent'
        console.log(`https://generativelanguage.googleapis.com/v1beta/models/${model}:${generateContentEndpoint}?key=`);
        requestData = JSON.stringify({
            contents: [{
                parts: [{
                    text: prompt
                }]
            }],
            generationConfig: {
                response_modalities: responseModalities
            }
        });
    } else {
        console.log(`https://generativelanguage.googleapis.com/v1beta/models/${model}:${generateContentEndpoint}?key=`);
        requestData = JSON.stringify({
            instances: [
                { "prompt": prompt }
            ],
            parameters: {
                numberOfImages: 4,
                personGeneration: "allow_all"
            }
        });
    }

    GM_xmlhttpRequest({
        method: 'POST',
        url: `https://generativelanguage.googleapis.com/v1beta/models/${model}:${generateContentEndpoint}?key=${GM_getValue("APIKey")}`,
        headers: {
            'Content-Type': 'application/json'
        },
        data: requestData,
        onload: function(response) {
            console.log("Gemini API response:", response);
            console.log("Raw response text:", response.responseText);
            generateImageModel = imageModel;
            try {
                const data = JSON.parse(response.responseText);

                if (isImage) { // Handle image responses
                    if (model === imagenModel && data && data.predictions && data.predictions.length > 0) {
                        // Handle Imagen Model response structure (multiple images)
                        const generatedImages = [];
                        for (const prediction of data.predictions) {
                            if (prediction.mimeType && prediction.bytesBase64Encoded) {
                                const imageSrc = `data:${prediction.mimeType};base64,${prediction.bytesBase64Encoded}`;
                                generatedImages.push(imageSrc);
                            }
                        }

                        if (generatedImages.length > 0) {
                            callback({
                                imagesSrc: generatedImages, // Changed to an array of image sources
                                imageText: null // Imagen response typically only returns image data
                            });
                        } else {
                            callback("Error: Imagen response missing image data for all predictions.");
                        }
                    } else if (data && data.candidates && data.candidates[0] && data.candidates[0].content && data.candidates[0].content.parts) {
                        // Handle standard Gemini image responses (single image)
                        const parts = data.candidates[0].content.parts;
                        let imageSrc = null;
                        let imageText = null;

                        for (const part of parts) {
                            if (part.inlineData && part.inlineData.mimeType && part.inlineData.data) {
                                const base64Data = part.inlineData.data;
                                imageSrc = `data:${part.inlineData.mimeType};base64,${base64Data}`;
                            } else if (part.text) {
                                imageText = part.text;
                            }
                        }
                        if (imageSrc) {
                            callback({
                                imageSrc: imageSrc, // Single image source
                                imageText: imageText
                            });
                        } else {
                            callback("Error: No image data found in the response for non-Imagen model.");
                        }
                    } else {
                        callback("Error: Could not retrieve image data. Check JSON structure or model type. See console for raw response.");
                    }
                } else { // Handle non-image responses
                    const extractedText = tryExtractText(data);
                    if (extractedText) {
                        callback(extractedText);
                    } else {
                        callback("Error: Could not retrieve text response from Gemini. Check JSON structure. See console for raw response.");
                    }
                }
            } catch (e) {
                console.error("Error parsing JSON:", e);
                console.log("Raw response text:", response.responseText);
                callback("Error: Could not parse JSON response from Gemini.");
            }
        },
        onerror: function(error) {
            console.error("Gemini API Error:", error);
            callback("Error: Failed to connect to Gemini API.");
        }
    });
}

// ... (rest of your code, especially generateImage function)

// You will also need to modify your generateImage function to handle the array of images:
function generateImage(text, callback) {
    console.log("generateImage called with text:", text);
    const imagePrompt = `Generate an image based on the following text: ${text}`;
    responseArea.innerHTML = "Generating image(s)..."; // Update loading message

    callGeminiAPI(imagePrompt, function(response) {
        if (typeof response == 'object' && response !== null && response.imagesSrc) {
            responseArea.innerHTML = ''; // Clear previous content

            // Loop through each image source and append it
            response.imagesSrc.forEach(src => {
                const img = document.createElement('img');
                img.src = src;
                img.style.maxWidth = '100%'; // Ensure images fit
                img.style.display = 'block'; // Stack images vertically
                img.style.marginBottom = '10px'; // Add some spacing
                responseArea.appendChild(img);
            });

            if (response.imageText) { // This part might not be used for Imagen, but good to keep for consistency
                const textDiv = document.createElement('div');
                textDiv.textContent = response.imageText;
                responseArea.appendChild(textDiv);
            }
            callback(response);
        } else if (typeof response == 'object' && response !== null && response.imageSrc) {
             // Handle single image response from non-Imagen models (if applicable)
            responseArea.innerHTML = '';
            const img = document.createElement('img');
            img.src = response.imageSrc;
            img.style.maxWidth = '100%';
            responseArea.appendChild(img);
            if (response.imageText) {
                const textDiv = document.createElement('div');
                textDiv.textContent = response.imageText;
                responseArea.appendChild(textDiv);
            }
            callback(response);
        } else {
            responseArea.innerHTML = response; // Display error or text response directly
            callback(response);
        }
    }, generateImageModel, true);
}

    // Function to translate text
    function translateText(text, language, callback) {
        console.log("translateText called with text:", text, "and language:", language);
        if (language = null) language = "English";
        const translationPrompt = `Translate the following text to ${language}: ${text}`;

        callGeminiAPI(translationPrompt, function(response) {
            responseArea.innerHTML = response;
            callback(response);
        }, textModel, false);
    }

    // ------------------------------ createGeminiOverlay function ------------------------------
    function createGeminiOverlay() {
        console.log("createGeminiOverlay called");
        geminiOverlay = document.createElement('div');
        geminiOverlay.id = 'geminiOverlay';
        geminiOverlay.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background-color: #fff;
            border: 1px solid #ccc;
            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
            padding: 20px;
            z-index: 10000;
            width: 600px;
            max-height: 80vh;
            overflow-y: auto; /* Enable scrolling if content overflows */
            border-radius: 8px;
            font-family: sans-serif;
            color: black !important;
        `;

        closeButton = document.createElement('button');
        closeButton.textContent = 'X';
        closeButton.style.cssText = `
            position: absolute;
            top: 5px;
            right: 5px;
            background-color: #f44336;
            color: white;
            border: none;
            padding: 5px 10px;
            text-align: center;
            text-decoration: none;
            display: inline-block;
            font-size: 12px;
            cursor: pointer;
            border-radius: 4px;
        `;
        closeButton.addEventListener('click', closeGeminiOverlay);
        geminiOverlay.appendChild(closeButton);

        responseArea = document.createElement('div');
        responseArea.id = 'geminiResponse';
        responseArea.style.cssText = `
            margin-bottom: 10px;
            padding: 10px;
            border: 1px solid #eee;
            border-radius: 4px;
            min-height: 50px;
            font-size: 14px;
            overflow-wrap: break-word;
            white-space: pre-wrap; /* Important for preserving formatting */
        `;
        geminiOverlay.appendChild(responseArea);

        inputArea = document.createElement('textarea');
        inputArea.id = 'geminiInput';
        inputArea.placeholder = 'Ask a question about the text...';
        inputArea.style.cssText = `
            width: 95%;
            padding: 8px;
            margin-bottom: 10px;
            border: 1px solid #ccc;
            border-radius: 4px;
            font-size: 14px;
            resize: vertical;
            min-height: 50px;
        `;
        geminiOverlay.appendChild(inputArea);

        // Button container
        const buttonContainer = document.createElement('div');
        buttonContainer.style.cssText = `
            display: flex;
            justify-content: flex-end;
            gap: 10px;
            margin-top: 10px;
        `;
        geminiOverlay.appendChild(buttonContainer);

        // Image Checkbox
        imageCheckbox = document.createElement('input');
        imageCheckbox.type = 'checkbox';
        imageCheckbox.id = 'generateImageCheckbox';
        const imageCheckboxLabel = document.createElement('label');
        imageCheckboxLabel.textContent = 'Generate Image';
        imageCheckboxLabel.htmlFor = 'generateImageCheckbox';

        buttonContainer.insertBefore(imageCheckboxLabel, buttonContainer.firstChild);
        buttonContainer.insertBefore(imageCheckbox, buttonContainer.firstChild);

        // Image Checkbox 2
        imageCheckbox2 = document.createElement('input');
        imageCheckbox2.type = 'checkbox';
        imageCheckbox2.id = 'generateImageCheckbox2';
        const imageCheckboxLabel2 = document.createElement('label');
        imageCheckboxLabel2.textContent = '$$$ Imagen $$$';
        imageCheckboxLabel2.htmlFor = 'generateImageCheckbox2';

        buttonContainer.insertBefore(imageCheckboxLabel2, buttonContainer.firstChild);
        buttonContainer.insertBefore(imageCheckbox2, buttonContainer.firstChild);

        askButton = document.createElement('button');
        askButton.textContent = 'Ask Gemini';
        askButton.style.cssText = `
            background-color: #4285f4; /* Gemini Blue */
            color: white;
            border: none;
            padding: 8px 16px;
            text-align: center;
            text-decoration: none;
            display: inline-block;
            font-size: 14px;
            cursor: pointer;
            border-radius: 4px;
        `;
        askButton.addEventListener('click', () => {
            console.log("Ask Gemini button clicked");
            const question = inputArea.value;
            const generateImageFlag = imageCheckbox.checked;
            const generateImageFlag2 = imageCheckbox2.checked;
            console.log("generateImageModel: ", generateImageFlag2);
            responseArea.textContent = "Loading...";

            if (question) {
                if (generateImageFlag || generateImageFlag2) {
                    if (generateImageFlag2) generateImageModel = imagenModel;
                    generateImage(selectedText + "\n 's question: " + question, function(response) {
                        // --- START OF MODIFIED SECTION ---
                        if (typeof response == 'object' && response !== null && response.imagesSrc) { // Check for imagesSrc array
                            responseArea.innerHTML = ''; // Clear previous content

                                // Loop through each image source and append it
                                response.imagesSrc.forEach(src => {
                                    const img = document.createElement('img');
                                    img.src = src;
                                    img.style.maxWidth = '100%'; // Ensure images fit
                                    img.style.display = 'block'; // Stack images vertically
                                    img.style.marginBottom = '10px'; // Add some spacing
                                    responseArea.appendChild(img);
                                });

                            if (response.imageText) { // This part might not be used for Imagen
                                const textDiv = document.createElement('div');
                                textDiv.textContent = response.imageText;
                                responseArea.appendChild(textDiv);
                            }
                        } else if (typeof response == 'object' && response !== null && response.imageSrc) {
                            // Fallback for single image (e.g., if you switch back to a Gemini image model)
                            responseArea.innerHTML = '';
                            const img = document.createElement('img');
                            img.src = response.imageSrc;
                            img.style.maxWidth = '100%';
                            responseArea.appendChild(img);
                            if (response.imageText) {
                                const textDiv = document.createElement('div');
                                textDiv.textContent = response.imageText;
                                responseArea.appendChild(textDiv);
                            }
                        }
                        else {
                            responseArea.innerHTML = response; // Display error or text response
                        }
                        // --- END OF MODIFIED SECTION ---
                    });
                } else {
                    callGeminiAPI(selectedText + "\n 's question: " + question, function(response) {
                        responseArea.innerHTML = response;
                    });
                }
            }
        });
        buttonContainer.appendChild(askButton);

        document.body.appendChild(geminiOverlay);

        // Add event listener to close overlay when clicking outside
        document.addEventListener('mousedown', outsideClickListener);
    }

    // ------------------------------ createPromptOverlay function ------------------------------
    function createPromptOverlay() {
        console.log("createPromptOverlay called");

        // Remove existing prompt overlay
        let existingPromptOverlay = document.getElementById('promptOverlay');
        if (existingPromptOverlay) {
            closePromptOverlay();
        }

        promptOverlay = document.createElement('div');
        promptOverlay.id = 'promptOverlay';
        promptOverlay.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background-color: #fff;
            border: 1px solid #ccc;
            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
            padding: 10px;
            z-index: 10001; /* Higher than Gemini overlay */
            border-radius: 5px;
            display: flex;
            gap: 5px;
            color: black !important;
        `;

        textButton = document.createElement('button');
        textButton.textContent = 'Text';
        textButton.addEventListener('click', (event) => {
            console.log("Text button clicked");
            event.stopPropagation();
            closePromptOverlay();
            createGeminiOverlay();
            callGeminiAPI(selectedText, function(response) {
                responseArea.innerHTML = response;
            });
        });
        promptOverlay.appendChild(textButton)

        translateButton = document.createElement('button');
        translateButton.textContent = 'Translate';
        translateButton.addEventListener('click', (event) => {
            console.log("Translate button clicked");
            event.stopPropagation();
            closePromptOverlay();
            createGeminiOverlay();
            const language = prompt("Enter target language (e.g., Spanish, French):");
            if (language) {
                translateText(selectedText, language, function(response) {
                    responseArea.innerHTML = response;
                });
            } else {
                alert("Please enter a language.");
            }
        });
        promptOverlay.appendChild(translateButton);

        imageButton = document.createElement('button');
        imageButton.textContent = 'Image';
        imageButton.addEventListener('click', (event) => {
            console.log("Image button clicked");
            event.stopPropagation();
            closePromptOverlay();
            createGeminiOverlay();
            responseArea.textContent = "Generating image...";

            generateImage(selectedText, function(response) {});
        });
        promptOverlay.appendChild(imageButton);

        document.body.appendChild(promptOverlay);

        return promptOverlay;
    }

    // ------------------------------ Helper Functions (closeOverlay, outsideClickListener) ------------------------------
    function closeGeminiOverlay() {
        console.log("closeGeminiOverlay called");
        if (geminiOverlay) {
            geminiOverlay.remove();
            geminiOverlay = null;
        }
        document.removeEventListener('mousedown', outsideClickListener);
    }

    function closePromptOverlay() {
        console.log("closePromptOverlay called");
        if (promptOverlay) {
            promptOverlay.remove();
            promptOverlay = null;
        }
    }

    function outsideClickListener(event) {
        if (geminiOverlay && !geminiOverlay.contains(event.target)) {
            closeGeminiOverlay();
        }
    }

    // ------------------------------ Event Listener for Mouseup ------------------------------
    document.addEventListener('mouseup', function(event) {
        if (GM_getValue("APIKey") === undefined || GM_getValue("APIKey") === null || GM_getValue("APIKey") === '') {
            GM_setValue("APIKey", prompt('Enter your API key\n*Press OK\n\nYou can get a free API key at https://aistudio.google.com/app/apikey'));
        }
        if (GM_getValue("APIKey") !== null && GM_getValue("APIKey") !== '') {
            selectedText = window.getSelection().toString().trim();
            console.log("mouseup event - selectedText:", selectedText);

            // Check if the click occurred inside the promptOverlay
            if (promptOverlay && promptOverlay.contains(event.target)) {
                console.log("Click inside promptOverlay, not closing.");
                return;
            }

            if (selectedText) {
                createPromptOverlay();
            } else {
                closePromptOverlay();
            }
        }
    });

    // ------------------------------ CSS Styling ------------------------------
    GM_addStyle(`
        #promptOverlay button {
            background-color: #4285f4;
            color: white;
            border: none;
            padding: 8px 12px;
            text-align: center;
            text-decoration: none;
            display: inline-block;
            font-size: 14px;
            cursor: pointer;
            border-radius: 4px;
        }
        #promptOverlay button:hover {
            background-color: #1a73e8;
        }
    `);

})();

    const textModel = 'gemini-1.5-flash-latest';
    const imageModel = 'gemini-2.0-flash-exp-image-generation';
    const imagenModel = 'imagen-3.0-generate-002';

    function callGeminiAPI(prompt, callback, model = textModel, isImage = false) {
        let requestData;
        console.log("callGeminiAPI called with prompt:", prompt, " and model:", model, " and isImage:", isImage);
        const responseModalities = isImage ? ['TEXT', 'IMAGE'] : ['TEXT'];
        let generateContentEndpoint = isImage ? 'predict' : 'generateContent';
        if (model !== imagenModel) {
            generateContentEndpoint = 'generateContent';
            console.log(`https://generativelanguage.googleapis.com/v1beta/models/${model}:${generateContentEndpoint}?key=`);
            requestData = JSON.stringify({
                contents: [{
                    parts: [{
                        text: prompt
                    }]
                }],
                generationConfig: {
                    response_modalities: responseModalities
                }
            });
        } else {
            console.log(`https://generativelanguage.googleapis.com/v1beta/models/${model}:${generateContentEndpoint}?key=`);
            requestData = JSON.stringify({
                instances: [
                    { "prompt": prompt }
                ],
            parameters: {
                numberOfImages: 4,
                personGeneration: "allow_all"
            }
            });
        }
        GM_xmlhttpRequest({
            method: 'POST',
            url: `https://generativelanguage.googleapis.com/v1beta/models/${model}:${generateContentEndpoint}?key=${GM_getValue("APIKey")}`,
            headers: {
                'Content-Type': 'application/json'
            },
            data: requestData,
            onload: function(response) {
                console.log("Gemini API response:", response);
                console.log("Raw response text:", response.responseText);

// ==Script==
// @name         List Gemini Models (with pagination)
// @namespace    http://tampermonkey.net/
// @version      0.2
// @description  Fetches and logs ALL available Gemini models (including paginated results) to the console.
// @author       You
// @match        *://*/*
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @connect      generativelanguage.googleapis.com
// @run-at       document-idle
// ==/Script==

(function() {
    'use strict';

    // API Key Setup
    if ((location.href === 'https://aistudio.google.com/app/apikey' && document.querySelector(".apikey-link") !== null) && (GM_getValue("APIKey") === undefined || GM_getValue("APIKey") === null || GM_getValue("APIKey") === '')) {
        window.onload = setTimeout(function() {
            document.querySelectorAll(".apikey-link")[1].click();
            setTimeout(function() {
                GM_setValue("APIKey", document.querySelector(".apikey-text").innerText);
                alert((GM_getValue("APIKey") !== undefined && GM_getValue("APIKey") !== null && GM_getValue("APIKey") !== '') ? 'API Key automatically added!' : 'Failed to automatically add API Key!');
            }, 500);
        }, 1000);
    }

    async function getApiKey() {
        let storedKey = GM_getValue('APIKey', null);
        if (storedKey) {
            console.log('Gemini API key loaded from Tampermonkey storage.');
            return storedKey;
        }
        const promptKey = prompt('Please enter your Gemini API Key:');
        if (promptKey) {
            GM_setValue('APIKey', promptKey);
            return promptKey;
        }
        return null; // Return null if no key is obtained
    }

    // Helper function to promisify GM_xmlhttpRequest
    function gmXmlhttpRequestPromise(options) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                ...options,
                onload: function(response) {
                    resolve(response);
                },
                onerror: function(error) {
                    reject(error);
                }
            });
        });
    }

    async function listGeminiModels() {
        const apiKey = await getApiKey();
        if (!apiKey) {
            console.error('Gemini API Key not set. Cannot list models.');
            return;
        }

        let allModels = [];
        let pageToken = null;
        let pageCounter = 0;

        console.log('Attempting to list ALL Gemini models (including paginated results)...');

        do {
            pageCounter++;
            let url = `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`;
            if (pageToken) {
                url += `&pageToken=${pageToken}`;
            }

            console.log(`Fetching page ${pageCounter}: ${url}`);

            try {
                const response = await gmXmlhttpRequestPromise({
                    method: "GET",
                    url: url,
                });

                if (response.status === 200) {
                    const data = JSON.parse(response.responseText);

                    // For debugging, you can still log raw per-page responses if needed
                    // console.groupCollapsed(`Gemini Models List - Page ${pageCounter} (Raw Response)`);
                    // console.log(data);
                    // console.groupEnd();

                    if (data && data.models && Array.isArray(data.models)) {
                        allModels = allModels.concat(data.models);
                        pageToken = data.nextPageToken || null; // Get the next page token, or null if no more pages
                        console.log(`Fetched ${data.models.length} models on page ${pageCounter}. Next page token: ${pageToken}`);
                    } else {
                        console.error('Invalid API response format: "models" array not found on page', pageCounter);
                        pageToken = null; // Stop looping on invalid response
                    }
                } else {
                    console.error(`Failed to list Gemini models on page ${pageCounter}. Status: ${response.status}`);
                    console.error(`Response text: ${response.responseText}`);
                    try {
                        const errorData = JSON.parse(response.responseText);
                        console.error('API Error Details:', errorData.error);
                    } catch (e) {
                        // Not JSON, just log raw text
                    }
                    pageToken = null; // Stop looping on error
                }
            } catch (error) {
                console.error(`Network error during API call on page ${pageCounter}:`, error);
                pageToken = null; // Stop looping on network error
            }

            // Add a small delay to avoid hitting rate limits too aggressively
            if (pageToken) {
                await new Promise(resolve => setTimeout(resolve, 500)); // Wait 500ms before next request
            }

        } while (pageToken); // Continue as long as there's a next page token

        console.log(`\n--- Finished Fetching All Gemini Models. Total Models: ${allModels.length} ---`);

        // Now process the complete list of models
        if (allModels.length > 0) {
            console.log('--- Listing All Available Gemini Models ---');
            allModels.forEach(m => {
                console.log(`Name: ${m.name}`);
                console.log(`  Display Name: ${m.displayName || 'N/A'}`);
                console.log(`  Description: ${m.description || 'N/A'}`);
                console.log(`  ed Methods: ${m.edGenerationMethods ? m.edGenerationMethods.(', ') : 'N/A'}`);
                if (m.inputTokenLimitCategories) {
                    console.log(`  Input Categories: ${m.inputTokenLimitCategories.map(c => `${c.tokenLimit} for ${c.category}`).(', ')}`);
                }
                console.log('---');
            });

            const generateContentModels = allModels.filter(m =>
                m.edGenerationMethods && m.edGenerationMethods.includes("generateContent")
            );

            console.log('\n--- Models ing "generateContent" ---');
            if (generateContentModels.length > 0) {
                generateContentModels.forEach(m => {
                    console.log(`Name: ${m.name}`);
                    console.log(`  Display Name: ${m.displayName || 'N/A'}`);
                    console.log(`  Description: ${m.description || 'N/A'}`);
                    if (m.inputTokenLimitCategories) {
                        console.log(`  Input Categories: ${m.inputTokenLimitCategories.map(c => `${c.tokenLimit} for ${c.category}`).(', ')}`);
                    }
                    console.log('---');
                });
            } else {
                console.log('No models found that  "generateContent".');
            }

            // Refined image model check
            const imageModels = allModels.filter(m =>
                m.edGenerationMethods && (
                    (m.edGenerationMethods.includes("generateContent") && (m.name.includes("gemini-pro-vision") || m.name.includes("vision"))) ||
                    (m.edGenerationMethods.includes("generateImages") || m.name.toLowerCase().includes("imagen")) // Explicitly check for generateImages method or "imagen" in name
                )
            );

            console.log('\n--- Models Potentially ing Image Input/Generation ---');
            if (imageModels.length > 0) {
                imageModels.forEach(m => {
                    console.log(`Name: ${m.name}`);
                    console.log(`  Display Name: ${m.displayName || 'N/A'}`);
                    console.log(`  Description: ${m.description || 'N/A'}`);
                    if (m.inputTokenLimitCategories) {
                        console.log(`  Input Categories: ${m.inputTokenLimitCategories.map(c => `${c.tokenLimit} for ${c.category}`).(', ')}`);
                    }
                    console.log('---');
                });
                // Check specifically for Imagen 3
                const foundImagen3 = imageModels.find(m => m.name.toLowerCase().includes("imagen-3.0"));
                if (foundImagen3) {
                    console.log('\n*** CONFIRMED: Imagen 3 model found! ***');
                    console.log(`Imagen 3 Model Name: ${foundImagen3.name}`);
                } else {
                    console.log('Imagen 3 (e.g., imagen-3.0-generate-002) was not explicitly found in the filtered list.');
                }

            } else {
                console.log('No models explicitly mentioning "image", "vision" or "imagen" found, or ing "generateImages" method.');
            }

        } else {
            console.warn('No Gemini models found at all. Check API key and network.');
        }
    }

    // Run the function when the document is ready
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', listGeminiModels);
    } else {
        listGeminiModels();
    }
})();