Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-v3-0324· DeepSeekHugging Face LMArena Human Preference 140K

will they accept this edge extension to the store heres the testing notes i submit for…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash’s answer.
  1. User

    will they accept this edge extension to the store

    heres the testing notes i submit for them:

    This extension maps the keyword gem in the browser's address bar (omnibox) to a query on https://gemini.google.com.

    To test:

    Install the extension.

    In the address bar, type: gem What is the weather in Paris? Then press Enter.

    The browser will open https://gemini.google.com/#What%20is%20the%20weather%20in%20Paris%3F.

    The extension’s content script will:

    • Read and remove the search query from the URL,

    • Paste it into Gemini’s chat input,

    • Automatically click the “Submit” button.

    • Gemini will then begin generating response as if the user typed it.

    The extension uses a script to do this because Gemini does not natively have a way to search via URL

  2. DeepSeek Assistant

    Based on your testing notes and the functionality described, your Edge extension has a good chance of being accepted into the Microsoft Edge Add-ons store, but there are a few key considerations:

    Likely Acceptance Factors:

    1. Clear Utility - The extension provides a useful omnibox shortcut for Gemini searches.
    2. Minimal Permissions - If your extension only requires access to gemini.google.com and modifies only its own triggered URLs, it should be low-risk.
    3. Transparent Functionality - Your testing notes clearly explain what the extension does.

    Potential Review Concerns:

    1. Automated Interaction - The automatic form filling and button clicking might be flagged if it appears too much like "automation" (which some stores restrict). You may need to frame this as a "URL-to-search convenience feature" rather than automation.
    2. Gemini's Terms of Service - Ensure this method of interacting with Gemini doesn’t violate Google’s terms (e.g., bypassing rate limits or intended UX).
    3. User Control - If the extension modifies the page without clear user intent (e.g., auto-submitting), reviewers might prefer a more explicit user action (like requiring a manual button press).

    Recommendations:

    • Clarify the Script’s Purpose: In your store description, emphasize that the auto-submit is purely for convenience and mirrors native search engine behavior.
    • Add a Privacy Policy: Even if you don’t collect data, state this explicitly (required for Edge Add-ons).
    • Test Edge-Specific Policies: Microsoft’s policies are similar to Chrome’s but sometimes stricter about "unexpected" page modifications.

    If Rejected:

    They may ask you to:

    1. Remove the auto-submit and let users press Enter manually.
    2. Provide clearer disclosure about the URL manipulation.

    Your extension is simple and useful, so with minor adjustments (if needed), it should be approved. Good luck!

  3. User

    is it possible to do this without automated interafction in a bad way

    i mean gemini.googke.com dont natively support any sort of ?q=searcjgreterm url style url nav

  4. DeepSeek Assistant

    You're right—Gemini doesn't support URL query parameters (like ?q=searchterm) for searches, which is why you resorted to DOM manipulation (auto-filling the input and clicking submit). However, there are a few alternative approaches that might avoid triggering "automation" concerns while still providing a seamless experience:


    Option 1: Use the Gemini API (If Available)

    If Gemini offers an official API (or even an undocumented one), you could:

    • Redirect to gemini.google.com with a URL fragment (e.g., #searchterm).
    • Use the API to fetch results and display them in a popup or new tab.
    • Pros: No DOM interaction needed.
    • Cons: May require an API key or violate terms.

    Option 2: Bookmarklet-Like Behavior (No DOM Scripting)

    Instead of auto-submitting, you could:

    1. Redirect to gemini.google.com#searchterm.
    2. Display instructions (e.g., "Press Enter to search") in a small overlay.
    3. Let the user manually press Enter.
    • Pros: No automation, just a convenience shortcut.
    • Cons: Slightly less seamless.

    Option 3: Open Gemini with Pre-Filled (But Not Submitted) Query

    Modify your script to:

    1. Redirect to gemini.google.com.
    2. Insert the search term into the input field without submitting.
    3. Let the user press Enter themselves.
    • Pros: Still feels fast, avoids "automation" flags.
    • Cons: Requires content_scripts but no forced clicks.

    Option 4: Use a Redirector Service (If Allowed)

    If Gemini ever adds support for POST-based searches (unlikely), you could:

    • Redirect via a service that forwards queries properly.
    • Cons: Adds complexity and potential privacy concerns.

    Best Compromise?

    Since Gemini lacks native URL search support, Option 3 (pre-fill but don’t auto-submit) is the cleanest workaround that avoids full automation while keeping UX smooth.

    Would this work for your use case?

  5. User

    POST

  6. DeepSeek Assistant

    Since Gemini doesn't support URL-based searches (?q=... or #...), and auto-filling + submitting via DOM scripting may trigger store rejections, another approach is to use a POST request—but this has limitations.

    Can You Use POST to Search Gemini?

    1. If Gemini Accepts POST Requests (Unlikely):

      • You could send a POST request directly to Gemini with the search query.
      • If successful, it would return the results page.
      • Problem: Most modern sites (including Google services) block cross-origin POST requests unless explicitly allowed (CORS).
    2. Workaround: Open a Form in a New Tab

      • You can dynamically create a hidden <form> with method="POST" and submit it.
      • Example:
        function searchGemini(query) {
          const form = document.createElement('form');
          form.method = 'POST';
          form.action = 'https://gemini.google.com/search'; // (if such an endpoint exists)
          form.target = '_blank'; // Open in new tab
          
          const input = document.createElement('input');
          input.type = 'hidden';
          input.name = 'q';
          input.value = query;
          form.appendChild(input);
          
          document.body.appendChild(form);
          form.submit();
          document.body.removeChild(form);
        }
        
      • Problem: Gemini likely doesn’t have a public POST endpoint for searches.

    Alternative: Simulate a POST via a Proxy (Not Recommended)

    If you control a backend server, you could:

    1. Send the query to your server.
    2. Have the server forward it to Gemini (e.g., via HTTP requests).
    3. Return the results.
    • Why Not Recommended?
      • Violates Gemini’s ToS (scraping/automation).
      • Adds latency, privacy concerns, and maintenance.

    Best Practical Solution?

    Since POST isn’t viable, your original approach (DOM scripting) is the only way—but to avoid rejection:

    • Make the automation optional (e.g., "Press Enter to search" with an opt-in "Auto-submit" toggle).
    • Just pre-fill the input and let the user press Enter manually (less likely to be flagged).

    Would you like help refining the DOM approach to be more store-friendly?

  7. User

    thers no way to do it ? properly? full fucntion without doing what i did?

  8. DeepSeek Assistant

    You're right—there is no "proper" way to do this without DOM automation because Gemini does not expose a public API or URL parameter scheme for direct searches.

    Why Your Current Approach is the Only Viable One

    1. No URL-Based Search Support

      • Unlike Google Search (?q=...), Gemini does not accept search terms via URL parameters or fragments.
      • Even POST requests won’t work (Gemini blocks external submissions).
    2. No Public API (Yet)

      • Gemini has no official search API for extensions.
      • Unofficial APIs (if any) would violate Google’s ToS.
    3. Bookmarklets/Redirects Don’t Solve It

      • You can’t preload a search without interacting with the page.

    How to Make Your Extension More "Acceptable"

    Since full automation (auto-fill + submit) may trigger store rejections, here’s a middle-ground solution:

    1. Pre-Fill the Query, But Require Manual Submission

    • How it works:
      • User types gem weather in Paris → Redirects to gemini.google.com#weather in Paris.
      • Your extension pastes the query into the input but does NOT auto-submit.
      • User must press Enter manually.
    • Why this helps?
      • No "automated interaction" concerns.
      • Still faster than typing manually.

    2. Add a Toggle for "Auto-Submit" (Off by Default)

    • In your extension options, allow users to enable auto-submit if they want.
    • Default: Disabled (better for store approval).
    • Advanced users can opt-in.

    3. Use a Less "Aggressive" DOM Injection Method

    Instead of instantly submitting:

    • Wait for the page to fully load.
    • Use a visual hint (e.g., a brief flash on the input field) to show it was pre-filled.
    • Avoid setTimeout hacks (reviewers dislike them).

    Final Answer

    No, there’s no "proper" way without DOM scripting—but you can make your extension more likely to be accepted by:

    1. Not auto-submitting by default (let users press Enter).
    2. Making automation optional (opt-in toggle).
    3. Clearly documenting the behavior in your store listing.

    Would you like help tweaking the code to implement this "soft automation" approach?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.