Gemini 4 Argon (openai)

If you've written anything against OpenAI's chat API, you already know how this node wants its data. Gemini 4 Argon (openai) hits a Gemini model through an OpenAI-compatible chat-completions endpoint, which means messages arrays, {"role": ..., "content": ...} turns, and tool definitions in the OpenAI {"type": "function", "function": {...}} shape. Same model as the native-schema node next door in the menu; different plumbing.

Why would you care? Because half the LLM snippets people copy off the internet are written for OpenAI's format. If you're pasting a tool definition or a few-shot message history into a field, this is the node where the paste works the first time.

The mechanism

It POSTs to a chat-completions path on KIE's Gemini route. The adapter takes system_prompt first and inserts it as a system message at the head of the array, appends your prompt as the final user message, and sends any history_json items in between. tools_json passes through as tools. Then the assistant text is extracted and returned as one STRING.

Because the endpoint is a documented schedule for tool-calling rather than the Gemini-native contents/parts structure, the field shapes you paste into tools_json and history_json differ from the native node. That's the entire practical difference. Same model, same cost tier, different JSON dialect.

Inputs worth knowing

• prompt - required. The instruction, and the only field you must fill.
• system_prompt - mapped to a real system message, not a user turn. Put the format contract here.
• tools_json - OpenAI-style function definitions. [] unless you're deliberately building tool use; the docs' own example for this endpoint is a weather lookup and a stock-price function, which tells you what shape it expects.
• history_json - an array of prior messages. [] gives you one-shot behaviour, which is what most graphs want.
• stream - a transport switch. The node still returns one finished string, so in ComfyUI it just changes how the bytes arrive.
• expert_override_json - merged into the request body for fields the pack hasn't mapped. Escape hatch, not a secret sauce.

Outputs: text, raw_json, usage_json, credits_consumed, credits_left.

No images socket and no max_tokens on this one. If you need vision or a hard output cap, use the OpenAI-shaped nodes in this pack that expose them.

Installing

cd ComfyUI/custom_nodes
git clone https://github.com/felipederosilva/ComfyUI-KIE-Nodes-Next
cd ComfyUI-KIE-Nodes-Next && pip install -r requirements.txt
# restart ComfyUI

The README also gives you the Manager route (search "KIE.ai Nodes Next") and comfy node install kie-ai-nodes-next. Dependencies are requests, Pillow, numpy, PyYAML - this is a thin HTTP client, not a model pack, so there's nothing to download and no VRAM cost. Your key goes in Settings → KIE.ai Nodes Next → Connection once; the pack verifies it against KIE before replacing a working one and keeps the full value out of workflow JSON and the frontend.

The failure modes that actually happen

Paste invalid JSON into tools_json or history_json and the pack's preflight stops you with a parse error and no spend. That's the good kind of failure.

Get the dialect wrong - drop a Gemini-native tool schema into this node - and the provider rejects it with its own message. If your tool JSON came from Google's docs rather than OpenAI's, try the native node instead.

Nothing happens at all? Check the text output goes somewhere executable. These nodes aren't output nodes; they only run when something downstream asks for their result.

Then the philosophical bit, same as every API node: the prompt leaves your machine and passes Google's moderation, which you cannot patch out because there are no weights to edit. For quick prompt rewrites a local 8B is free and uncensored. Use this one when the text work is genuinely larger than that - long structured payloads, tool-calling experiments, anything where you'd rather not fight a small model's attention span.