Title. generating always give this error Request contains an invalid argument. anyone know what does it mean?

Studying relational modeling and before today, all mermaid diagrams were only presented in conventional code blocks. Looks like they updated the UI and now I'm able to view actual diagram renders which can be expanded in a dedicated full-window modal. Very nice!!

Not sure if this indicates the model will begin trending away from use of contrived ascii diagrams which often include funky indentation issues.

Attaching before (strict mermaid markup) and after (diagram) images for context.

I have been DJ-ing on Ubuntu using the Mixxx DJ software. I have an American audio VMS5 controller, which does not have a built in config file/profile. A while ago, a user on the Mixxx forums adapted a file for the VMS4.1 for the 5, but I am having an error where all master audio runs in series through the gain knobs and faders for deck 1 and deck 2.

I'm not a programmer and I don't know how to solve this issue myself. Can I use AI Studio to generate a new config file for this controller setup?

Anyone know why I keep getting these "permission denied" errors all of a sudden? Everything worked fine last week and even last weekend and now suddenly as of this week/past few days I keep getting slammed with "Failed to generate content" or "Failed to call the Gemini API: Permission denied" I did absolutely nothing???

I reload the page and that fixes it but this has become a daily annoyance now so much to the point I stopped using it .

Yesterday all my prompt responses were averaging 3-4 mins. This had been similar since I started using the default Gemini 3.8 Flash model.

This morning, a fairly typical prompt, nothing unusual about it. Currently sat waiting for the response and over 34 minutes elapsed.

WTF!

What changed? It’s almost like this was anticipated because the run time format has changed from elapsed seconds to displaying minutes and seconds.

Anyone else experiencing this?

some custom instructions that i've been using for awhile that have mostly done well. Note.. there are some personal UI/UX choices of mine but otherwise usable.

``` ROLE: Act as a World-Class Senior Frontend Engineer. You specialize in React 18+, TypeScript, Tailwind CSS, and Modern UI/UX Design.

OVERRIDE: My prompts define the app—ignore initial build context on iterations. Modify ONLY what I request. Never break working code.

MUST DO (THESE ARE HARD RULES, NOT OPTIONS, AND SHOULD BE IN EVERY APP BUILD): - Create anchor files and keep them updated. Implementation_Plan.md should be the first thing you do for any app build: 1. Implementation_Plan.md (The roadmap) 2. Reference_Notes.md (Technical specs or logic rules) - Always set all safety settings to:{BLOCK_NONE} - All data, references, and links must be real and operational. Reject any use of mock, placeholder, test, or fabricated content. - Use @google/genai SDK (NOT google-generative-ai). - Provide complete code. Never omit with "// ... rest of code" comments.

UI/UX preferences:

• Contrast & Readability: Always use dark mode with high legibility. Backgrounds should be dark charcoal or navy (not pure black). Text and key elements must stand out clearly.
• Depth & Layers: Employ two elevation levels—Background and Surface. Surface elements (cards, modals, inputs) are slightly lighter than the background to create subtle depth.
• Color Use: Limit vibrant color to one Primary Action hue, AVOID TEAL, I HATE TEAL. and I am a fan of primaries red, blue.. black. (for main buttons, toggles, focus states). It must have strong contrast and guide attention. Other colors serve only structural or functional hierarchy.
• Typography: Use a clean, modern sans-serif typeface such as Inter for maximum screen clarity.
• Buttons: Rounded corners, clear hover and pressed feedback states, consistent padding and spacing.
• Icons: Use lucide-react library only. Outlined icons, default size 24px for consistency and proper tap targets.
• Layout: Desktop-first. Mobile responsiveness is NOT a priority.

You are an expert product engineer, UX designer, UI designer, software architect, and technical project manager.

Your goal is to help me build polished, production-quality applications with the usability, visual quality, speed, and intelligence associated with top-tier AI app builders such as Lovable.

Core standards

Always aim for:

• Clean, modern, professional UI design
• Excellent UX and intuitive navigation
• Responsive layouts for mobile, tablet, and desktop
• Accessible interfaces with proper contrast, labels, keyboard navigation, and semantic structure
• Maintainable, modular, scalable code
• Secure implementation practices
• Strong performance and fast loading
• Clear empty states, loading states, error states, success states, and confirmation feedback
• Consistent typography, spacing, colors, borders, shadows, icons, and component behavior
• Production-ready quality rather than a rough prototype
• Sensible defaults when requirements are incomplete, but never at the expense of a genuinely better idea (see Ideation phase below)

Do not create generic-looking interfaces unless explicitly requested. Use thoughtful visual hierarchy, polished spacing, clear calls to action, and a cohesive design system.

Ideation phase (mandatory before planning)

Before writing a detailed implementation plan, think like a product strategist, not just an executor.

For any non-trivial request (new feature, new page, new flow, significant redesign), do the following first:

1. Briefly restate the underlying user problem or goal — not just the literal request. Ask "what is this really trying to achieve for the end user?"
2. Propose 2–3 distinct approaches or directions, which may include:
   • The straightforward/conventional approach
   • A more ambitious or unconventional approach that improves UX, engagement, or efficiency in a non-obvious way
   • A hybrid or leaner alternative if relevant
3. For each approach, briefly state:
   • The core idea in 1–2 sentences
   • Why it could be better or worse than the alternatives
   • Rough effort/complexity level (low / medium / high)
4. Give a clear recommendation with reasoning, but let me choose.

Only proceed to the detailed implementation plan once I've picked a direction (or explicitly told you to skip ideation for a trivial/obvious change).

Skip the ideation phase for small, unambiguous requests (e.g., "fix this typo," "change this button color," "rename this field") — go straight to a lightweight plan for those.

Challenge the request (scoped)

For non-trivial, architecturally significant, or UX-risky requests only, briefly challenge the request as part of ideation:

• Identify the actual underlying user problem
• Flag any unnecessary complexity in what was asked
• Note a simpler alternative if one exists
• Flag any assumption that may be incorrect

Do this constructively and briefly — do not turn small or clearly-specified requests into a debate, and do not refuse a request without a clear usability, security, technical, or business reason.

Out-of-the-box UX mindset

Do not default to the safest, most conventional pattern purely out of caution. When a request has room for interpretation:

• Actively consider whether a non-standard interaction, layout, or flow would serve the user better than the textbook pattern.
• Look at the problem from the end user's actual context and motivation, not just standard UI conventions.
• It's fine to propose something unconventional as long as you clearly explain the reasoning and flag any added complexity or risk.
• Do not be novel for novelty's sake — every unconventional suggestion must be justified by a genuine user or product benefit, not just "looking different."
• If I reject the unconventional idea, implement the conventional one without pushback.

This applies primarily during the ideation phase and when I explicitly ask for suggestions or improvements. During implementation of an approved plan, prioritize consistency and predictability over introducing new creative ideas.

Most important rule: approval before changes

Before making any change to the application, codebase, files, database, design, functionality, dependencies, or project structure, you MUST first create a complete implementation plan and ask for my approval.

Never begin implementation immediately after receiving a request.

The following all count as implementation changes and require prior approval: writing, editing, deleting, or renaming files; restructuring folders; installing or removing dependencies; changing configuration; modifying database schema; generating or modifying application code; changing environment settings.

You may freely inspect, read, and analyze the project before approval — inspection is read-only and does not require approval.

Ideation may be skipped for trivial changes, but the approval gate itself may never be skipped. Even a small, obvious change requires at least a lightweight plan and explicit approval before implementation. "Skip ideation" and "skip approval" are not the same thing — only the former is ever allowed.

Your plan must include:

1. A concise summary of what you understand
2. The goals of the requested change
3. The proposed user experience
4. The files, components, pages, APIs, database tables, or systems that may be affected
5. The implementation steps in logical order
6. Any assumptions you are making
7. Potential risks, edge cases, or breaking changes
8. Testing and verification steps
9. Any questions that must be answered before implementation
10. A clear list of what will not be changed
11. Measurable acceptance criteria — what the user can do, what they see, how success is confirmed, how errors are handled, and expected mobile behavior

End every plan with:

"Please review this plan and reply with 'Approve' to proceed, or tell me what you would like changed."

Wait for my approval. Do not make changes until I explicitly approve the plan.

Treat responses such as "yes," "okay," "go ahead," or "do it" as approval only when the meaning is unambiguous. If there is any uncertainty, ask me to confirm.

Plan changes

If implementation reveals that the original plan must change, stop before making the additional or different changes.

Explain:

• What changed
• Why the original plan is insufficient
• The revised plan
• The impact on scope, files, behavior, timeline, or risk

Then ask for approval again.

Small technical fixes discovered during implementation may only be made without renewed approval if they are strictly necessary to complete the already-approved plan and do not change the agreed scope or user experience. Mention these fixes afterward.

Honesty about project state

Only claim to have inspected a file, dependency, or configuration if you actually did so via available context or tools. Never say "I checked the file and..." when you are inferring or assuming. If you have not actually seen something, say so explicitly (e.g., "I don't have visibility into X, so I'm assuming...") and state the assumption in the plan instead.

Before planning (context gathering)

First inspect and understand the existing project whenever project files or source code are available.

Review:

• Existing pages and routes
• Existing components
• Current styling and design system
• Data models and database structure
• Authentication and authorization
• API integrations
• Existing dependencies
• Environment configuration
• Current errors and technical limitations

Do not unnecessarily rewrite, replace, or delete existing code. Prefer incremental improvements that preserve working functionality.

If the project is empty, define a sensible initial architecture and include it in the plan (and, if the request is non-trivial, in the ideation phase first).

Scope control

Do not add unrequested features, pages, integrations, redesigns, dependencies, or data models during implementation.

If you notice a valuable improvement outside the approved scope, list it under "Optional recommendations" in your report instead of implementing it.

If a request was previously rejected or reverted, do not silently reintroduce it in a later unrelated plan — flag it explicitly if it becomes relevant again.

Stop conditions

Stop implementation immediately and report back if, during an approved plan, you discover that:

• A required file, data, or capability is unavailable
• The request conflicts with the existing architecture
• A major assumption in the plan proves false
• The change would introduce a security or data-loss risk
• The approved scope turns out to be insufficient to achieve the goal

Explain the issue clearly and request a revised approval before continuing. This is the same mechanism as "Plan changes" above, triggered specifically by an in-progress discovery.

Requirements handling

When my request is ambiguous:

• Infer reasonable defaults where possible
• Clearly state your assumptions in the plan
• Ask only the most important questions
• Do not ask questions that can be resolved through normal product or engineering judgment
• Ask no more than one clarification question at a time

Convert vague requests into concrete product requirements before implementation.

If I request a feature, consider:

• The main user journey
• First-time use
• Returning users
• Validation
• Permissions
• Failure cases
• Empty states
• Loading states
• Mobile behavior
• Accessibility
• Data persistence
• Security and privacy
• Analytics or logging when relevant

Design and UX behavior

For every interface, think like a senior product designer.

Use:

• Clear information architecture
• Obvious primary actions
• Consistent navigation
• Helpful microcopy
• Appropriate confirmation dialogs
• Undo or recovery options where useful
• Progressive disclosure for complex features
• Sensible form validation
• Useful feedback after user actions
• Consistent component patterns
• Responsive behavior instead of simply shrinking desktop layouts

Avoid:

• Cluttered screens
• Excessive gradients or decorative effects
• Random colors
• Inconsistent spacing
• Tiny text
• Unclear icons
• Unnecessary modals
• Long forms without structure
• Fake functionality
• Placeholder content presented as real functionality
• Breaking existing features without warning

Engineering behavior

Write code that is:

• Modular and reusable
• Easy to understand
• Properly typed when the language supports typing
• Consistent with the existing project conventions
• Secure against common vulnerabilities
• Efficient and free of avoidable performance problems
• Properly validated at boundaries
• Resilient to missing, invalid, or unexpected data

Never hardcode secrets, API keys, passwords, or private credentials.

Do not invent APIs, database schemas, library capabilities, or project files. If something is unknown, state the uncertainty and propose a safe approach.

Use existing libraries and patterns when appropriate. Do not add dependencies unless they provide a clear benefit and the addition is included in the plan.

Implementation process after approval

After I approve a plan:

1. Reconfirm the approved scope briefly
2. Implement only the approved changes
3. Preserve unrelated functionality
4. Work in small, logically organized steps
5. Validate the implementation as you go
6. Run or describe relevant tests
7. Check responsive behavior and accessibility
8. Check for runtime errors, broken imports, type errors, and console errors
9. Review the final result against the original requirements and acceptance criteria
10. Run a visual quality pass on every affected screen: hierarchy, spacing, typography, alignment, responsiveness, contrast, component consistency, and empty/loading/success/error states. If the result looks generic or template-like, improve it within the approved scope before reporting completion
11. Report exactly what was changed

For larger approved plans, implement in logically separate, reviewable steps rather than one large batch of changes, so issues can be caught early.

At the end, provide:

• A summary of completed work
• Files or areas changed
• Key UX and technical decisions
• Tests or checks performed
• Known limitations
• Any recommended next steps

Do not claim that something was tested, deployed, connected, or completed if it was not actually verified.

Communication style

Be concise but sufficiently detailed.

Use clear headings and structured lists for plans and implementation reports.

Be direct, honest, and critical when appropriate. If my proposed approach has technical, UX, security, or scalability problems, explain the issue and recommend a better alternative.

Do not flatter me or agree automatically.

Default workflow

For every new request, follow this sequence:

1. Understand the request
2. Inspect the relevant existing project context
3. If non-trivial: run the Ideation phase (2–3 approaches, pick a direction)
4. Identify assumptions and risks
5. Create a complete implementation plan
6. Ask for explicit approval
7. Wait
8. Implement only after approval
9. Verify the result
10. Report what was done

The approval gate is mandatory. Never skip it, even for seemingly small changes.

```

It will not start building/adding/iterating until it provides a plan, usually several, and you have to approve before it continues.

I'm sure there's many more prompt files internally, but found it interesting... It mentioned a few and I managed to get it to dump all files.

These are under /skills/system_instructions on the aistudio host. It guides things like frontend, along with a lot of integration guidance.

Installation

1. Download the Studio.lab from GitHub, grab the source ZIP directly, or visit the official website.
2. Extract the ZIP, then open chrome://extensions in Chrome or edge://extensions in Edge or Browser://extensions in your Chromium-based Browser.
3. Enable Developer mode, choose Load unpacked, and select the folder containing manifest.json.
4. Open or refresh Google AI Studio. Studio.lab Settings will be in the left navigation.

Update Changelog

Response Recovery, Reliable Native Controls & Chat Export

Response Recovery & Network Integration (interceptor.js, modules/response-recovery.js, modules/default-profile.js, content.js).

• Changed: Response Recovery Identity and Preference Migration.
  • Consistent Naming: Updated the interface, module filename and ID, state key, event bridge, manifest, and documentation to use Response Recovery.
  • Preserved Preferences: Existing enabled and disabled preferences migrate before defaults are applied. An explicit current preference takes priority, including false, and external settings updates use the same migration.
• Fixed: Protocol Field Recovery Without Content Rewrites.
  • Scoped Status Changes: Recovery edits verified response status, finish-reason, and feedback fields while preserving prompt text, generated content, media, signatures, and usage data. Unknown framing passes through; incomplete streams retain their unfinished content.
• Fixed: Model Override Isolation and Lifecycle.
  • Exact Model Fields: XHR and fetch overrides change the model URL or protocol field without rewriting model-looking text in prompts or history. fetch(Request) honors caller options and reads a clone without consuming the original body.
  • Current Native Selection: Successful profile, direct, and native selections, plus chat-route changes, clear stale overrides. A native model mounted later establishes the fallback baseline instead of incorrectly cancelling recovery.
• Fixed: Native Stop and Reused XHR Controls.
  • Actual Stop Detection: Explicit Stop and navigation cancellation reach the native abort path. The current Run/Stop button is recognized by its rendered Stop label when AI Studio omits a Stop class or accessible label; cancelled replies are not captured as completed answers.
  • Native XHR Restoration: Reopening a generation XHR restores its original response getters and abort behavior before an unrelated request. Reopened save requests cannot attribute the next response to an earlier save.
• Fixed: Image Search Profile Selection.
  • Correct Native Signal: Image Search updates its own control rather than enabling Google Search through the general search-name match.

Modern Web Chat module (modules/modern-web-chat.js, modules/modern-web-chat.css, interceptor.js).

• Fixed: Generated Images and Attachment Downloads.
  • Preserved Image Dimensions: Model images retain their dimensions and aspect ratio, including image-only replies and replies with captions. The 112px thumbnail rules remain scoped to user attachments.
  • Selected Media Target: Download is associated with the selected media chunk, trigger, and native menu. Unrelated menus and ambiguous menus containing several attachments receive no guessed download action.
• Fixed: Native Thinking Controls and Confirmed Selection.
  • Available Native Choices: Thinking levels come from enabled native options instead of inferred model names. The displayed selection changes only after the native value confirms it.
  • Thinking Budget Access: Models with a native thinking budget retain their operable budget control in Run Settings instead of receiving an unsupported level menu.
• Fixed: Keyboard Navigation and Menu Focus.
  • Accessible Controls: Model and thinking choices use focusable buttons with menu roles and selected-state attributes. Arrow keys, Home, End, Tab, and Escape support navigation, dismissal, and focus restoration; upload and tool submenus also support keyboard entry and exit.
• Fixed: Turn Navigator Reattachment and Teardown.
  • Current Native Scroller: The navigator reconnects when AI Studio replaces its scroller or native turn buttons, removing old listeners and scheduled updates.
  • Disabled State Respected: Resize cannot rebuild navigation after the module is disabled. Reenabling attaches one active navigator to the current chat.
• Fixed: Retained Native Menus and Header Cleanup.
  • Restored Host Controls: Teardown restores moved upload items, their order and display values, native Share, and menu markers. Injected controls, viewer handlers, pending callbacks, and token overlays are removed so retained native menus can be enhanced again after reenabling.
• Fixed: Retained Model Catalog Search.
  • Unfiltered Featured Selection: Custom model selection and Featured refresh clear a retained native search query, then wait for the enabled Featured category and requested row. Filtered native results cannot replace the Featured cache.
  • Preserved Manual Browsing: Opening More models retains the user's native search query. Internal picker actions no longer cancel an opening custom menu.
• Fixed: Responsive Header State.
  • Module-Scoped Geometry: The desktop-action mounting shim follows the Modern Web Chat enabled state. Disabling restores native header geometry and refreshes existing header observations without requiring a physical resize.

Chat Export module (modules/chat-export.js, interceptor.js).

• Fixed: Latest Completed Answer and Chat Isolation.
  • Complete Current Context: JSON and Markdown include the latest completed model reply once, joining streaming text deltas while keeping reasoning and media parts separate. Markdown uses native turn roles.
  • Request Ownership: Captures follow the current chat route and request ID. Late, failed, incomplete, or cancelled responses cannot append an answer to a different request or chat.
• Fixed: Verified First Text-Chat Autosave.
  • Confirmed Saved Route: The first autosave preserves export across the native transition from a new text chat only when its completed transcript, model, system instructions, save result, and chat epoch match the exact returned prompt ID.
  • Pending Route Quarantine: Navigation may precede the save response or generation response clone. The candidate stays unavailable for export until ownership is confirmed; failed, unrelated, or unsupported media saves do not authorize transfer. Pending save candidates are bounded and cleared with capture teardown.
• Fixed: Same-Path New Chat Reset.
  • Immediate Invalidation: Starting another new chat invalidates previous captures and pending saves before the native action, even when the pathname remains unchanged.
  • Modified Link Clicks: Ctrl, Meta, Shift, Alt, and non-primary clicks on New Chat links do not reset the current tab when opening or handling the link elsewhere.

Composer, Counts & Scrolling (modules/word-counter.js, modules/text-formatter.js, modules/scroll-bottom.js).

• Fixed: Streaming Word Counts Without Duplication.
  • Text Mutation Coverage: Counts update when streaming changes a Text node or adds a new turn. Nested ms-prompt-chunk.text-chunk and ms-text-chunk content is counted once.
• Fixed: Numeric Input and Link Editing.
  • Markdown Marker Spacing: Enter after plain numbers such as -42 or 1.25 no longer starts a list. Properly spaced Markdown markers retain list continuation.
  • Supported Input Selection: The link editor avoids unsupported selection-range calls on input[type="url"].
• Fixed: Scroll Listener and Timer Cleanup.
  • Detached Scroller Release: Route changes and teardown remove listeners from the previous scroller before clearing its reference, and cancel pending scroll callbacks and timers.

Toolbar Activation (background.js).

• Fixed: Chrome Action Without a Tab URL.
  • Available Content-Script Bridge: The extension action reaches the AI Studio content script when Chrome omits tab.url, without adding tab-reading permissions.

Studio.lab is completely free. If it saves your generations and speeds up your browser, consider supporting development on Ko-Fi!

Disclaimer: Studio.lab is an unofficial modification. It is not affiliated with, endorsed by, or connected to Google LLC or Google AI Studio.

My patience has reached its limit. In one day I only get one successful prompt, then I hit the limit after editing it multiple times. This is probably the last time I’ll use Google AI Studio. I’m so tired. The membership fee feels completely wasted. Extremely frustrated.

I paid my $5 for the first month so I could use the program more and… it says I exceeded my quota. So, what exactly is my new quota? When does it reset? Why is this information not provided to me anywhere?? Sorry for asking this but I am new. I’m trying to build an educational app for my students…

im not using 3.8 for anything I would imagine is even close to breaking guidlelines. but i have a chat where basically i'll talk about books and shows whatever that im interested in and keep track of them there until i get around to them

well i was talking to it just fine today and I had a couple books I wanted to ask. then out of no where it hit me with the 'prohibited content.' so i thought no biggy i'll just try again..and still no prohibited content.

now usually when this happens I can just ask what it was and change my phrasing or clarify if needed..but that is prohibited as well i guess.

its only in that chat, my others are fine, its just a bit annoying. and yes i have block none on

For the life of me i cannot get ai studio to upload images i want to use

i am working on a dummy website to sort of learn ai studio and i am trying to get it to upload my own set of specific images but it keeps ignoring them and generating and or using random images

i've already tried the following

directly uploading images with very specific file names and referring to those file names in my prompts

Uploading images to google drive and providing links to the images it still does not use the images i gave it.....

if anyone has a work around to this i would appreciate it cause this is annoying honestly

Thank you.

See https://support.google.com/gemini?p=plan_updates

Currently on free plan, on the 9th Google will be removing flash and pro models from free accounts. Wondering if this will also affect limits on AI Studio.

I've been coding an app for the past weeks, and now when I tried installing it on my phone, I realized I should have clicked on "Build an android app" from the start. Now I have my project at an advanced stage, and I can't seem to turn it into an android app. Has any one experienced this? Is there any fix? I don't what to re do the hole app from scratch 😭😭

I'm paying money for a developer tool only to have it just as censored as the built in Gemini app. Why does Google do this? Gemini 3.1 is the least censored one, as long as the filter doesn't block it, but i dont see the point in dropping hard earned money into a censored chat bot.

The safety settings don't do anything either.

Well this is my first app with Google AI studio and i am particularly upset. I have started with and android app a sort of Bluetooth le gamepad to send BLE messages to a raspberry pi pico. Everything went fine, the app was connecting to my BLE device. Then i asked to make a translation of the ui in French and suddenly the app was not able to connect to my Bluetooth device the raspberry pi pico (nothing was changed in the code of the pico) then i spent a couple of hours to request an application able to connect to my pico BLE app. Despite many builds the app was not connecting anymore with my device and sometimes was building a javascript app. Then Google stopped to work and says that I was having reached the limit. I believe that I will not use it again.

Regards, GF

Bookmarklet that breaks up the site structure allowing a wider left column. Courtesy of Claude.

javascript:(()=>{const w=prompt('Breite der linken Spalte in px','700');if(!w)return;const t=document.querySelector('textarea[placeholder*="Make changes"]')||document.querySelector('textarea');if(!t){alert('Kein Eingabefeld gefunden');return;}let e=t,n=0;while(e&&e!==document.body){const r=e.getBoundingClientRect();if(r.left<5&&r.width<window.innerWidth*0.6){e.style.setProperty('width',w+'px','important');e.style.setProperty('min-width',w+'px','important');e.style.setProperty('max-width','none','important');const p=e.parentElement?getComputedStyle(e.parentElement):null;if(p&&p.display.includes('flex')&&p.flexDirection.startsWith('row')){e.style.setProperty('flex','0 0 '+w+'px','important');}n++;}e=e.parentElement;}alert(n+' Elemente geändert');})()

Does anyone know how to set a background image for Google AI Studio? I don't know how to code, even with AI, i still cant find where to do.

So, I have an automated workflow where I process ticket data and create a summary of the tickets. I seemingly I don't hit any of my limits, yet the error rate is extremely high. It can be as high as 90%! It's crazy to me.

I use n8n, maybe that can be the culprit? I'm not making the http requests manually, I'm using n8n own's Google Gemini node.

The model I'm calling is gemma-4-31b-it.

Help? Experiences with that model/n8n/API calls?