TL;DR
Gemini 4 Hydrogen API está disponible a través de la API de Gemini de Google y de puertas de enlace de terceros compatibles como CometAPI. Elige primero la ruta: usa Google para funciones específicas del proveedor y controles de cuenta, o usa CometAPI cuando quieras una puerta de enlace de modelos unificada o un cliente compatible con OpenAI. Empieza con una pequeña solicitud de texto y luego añade streaming, historial de conversación, archivos y herramientas.
Necesitas Python 3.10 o posterior, una clave para la ruta elegida y acceso a gemini-4-hydrogen. El ejemplo opcional en JavaScript usa Node.js 22 o posterior. Mantén las credenciales en el entorno del servidor durante todo el tutorial.
Key Takeaways
- Usa
gemini-4-hydrogencomo ID de modelo para la Gemini 4 Hydrogen API. - Google y CometAPI tienen credenciales y facturación separadas. Haz coincidir la clave con el endpoint que selecciones.
- Comienza con GenerateContent nativo; usa la interfaz compatible con OpenAI de CometAPI cuando encaje con un cliente de chat existente.
- Mantén la respuesta completa del modelo en el historial multi-turno, incluidas las firmas, antes de devolver un seguimiento o el resultado de una herramienta.
- Compara el uso real de tokens y las tareas completadas al elegir la ruta; el ejemplo estándar de precio por token aparece en la sección de precios.
What Is the Gemini 4 Hydrogen API?
Google presentó Hydrogen el 12 de noviembre de 2026. La API acepta prompts y archivos compatibles, y devuelve texto generado o llamadas a funciones estructuradas para que tu aplicación las gestione. No necesitas alojar el modelo tú mismo.
Empieza con una solicitud solo de texto y verifica el texto devuelto, el motivo de finalización y el uso de tokens antes de añadir herramientas o archivos. Una vez que esto funcione, añade estado de conversación o una herramienta empresarial de solo lectura en lugar de construir todo el flujo de trabajo de una vez.
Gemini 4 Hydrogen API specifications
| Specification | Google-documented model capability |
|---|---|
| Model ID | gemini-4-hydrogen |
| Input | Texto, imágenes, audio, video y documentos compatibles |
| Output | Texto, con partes de llamadas a funciones estructuradas cuando se usan herramientas |
| Unified context budget | 1,048,576 tokens entre entrada y salida |
| Single foreground output segment | Hasta 65,536 tokens, incluidos el razonamiento y las llamadas a funciones |
| Application features | Control del nivel de razonamiento, salida estructurada y llamadas a funciones |
Estas son capacidades del modelo, no una garantía de que cada gateway exponga todas las funciones del proveedor. Los ejemplos a continuación usan campos estándar de solicitud y generaciones cortas en primer plano.
Google Official API vs CometAPI
Ambas rutas admiten solicitudes a Gemini, pero usan endpoints, credenciales y sistemas de facturación diferentes. Usa Google para funciones específicas del proveedor; usa CometAPI para una puerta de enlace unificada o un cliente compatible existente.
| Decision | Google Gemini Developer API | CometAPI Gemini integration |
|---|---|---|
| Native API host | generativelanguage.googleapis.com | api.cometapi.com |
| API key in this guide | GEMINI_API_KEY | COMETAPI_KEY |
| Account and billing | Gestionadas a través de Google | Gestionadas a través de CometAPI |
| Best starting point | Funciones específicas de Google y controles de cuenta | Acceso unificado a modelos o un cliente existente compatible con OpenAI |
Mantén el mismo prompt y presupuesto de salida al comparar las dos rutas para que los resultados sean útiles. Las alternativas en JavaScript y compatibles con OpenAI se mantienen explícitamente configuradas para CometAPI.
How to Use Gemini 4 Hydrogen API Step by Step?
Step 1: Create an API key
Para CometAPI, crea una cuenta y genera una clave en la consola de tokens de API. Para acceso directo a Google, crea una clave de la API de Gemini en Google AI Studio. Confirma el acceso al modelo y la facturación o el cupo disponible de la cuenta seleccionada.
Guarda la clave de forma segura. Una clave de CometAPI no puede autenticar una solicitud al endpoint de Google, y una clave de Google no puede autenticar una solicitud a CometAPI.
Configura la clave para la ruta elegida en Bash; solo necesitas una de estas asignaciones.
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
# O, para acceso directo a Google:
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
Configura la clave correspondiente en PowerShell en Windows.
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
# O, para acceso directo a Google:
$env:GEMINI_API_KEY = "YOUR_GEMINI_API_KEY"
Step 2: Send a first request with cURL
Envía una solicitud de texto nativa a través de CometAPI desde una terminal Bash.
curl "https://api.cometapi.com/v1beta/models/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Explica cómo funciona un agente de programación de IA en cinco pasos."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
Como alternativa, envía la misma solicitud nativa directamente a Google con una clave de la API de Google.
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Explica cómo funciona un agente de programación de IA en cinco pasos."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
Después de que la solicitud tenga éxito, verifica tres campos: candidates[0].content.parts para el texto visible, finishReason para el estado de finalización y usageMetadata para el uso de tokens. Corrige errores de autenticación o de solicitud antes de añadir más código de aplicación.
Step 3: Configure the Python Client and Send a Request
Instala los paquetes usados por los ejemplos en Python.
python -m pip install requests openai
Guarda este auxiliar como hydrogen_client.py. Deja PROVIDER establecido en cometapi para CometAPI, o cámbialo a google para acceso directo a la Gemini Developer API. Los ejemplos nativos posteriores importan este archivo, por lo que mantienen la ruta seleccionada.
Configura el endpoint seleccionado y define funciones reutilizables para la solicitud y el texto.
import os
import requests
MODEL = "gemini-4-hydrogen"
PROVIDER = "cometapi" # Cambia a "google" para acceso directo.
ROUTES = {
"cometapi": ("https://api.cometapi.com", "COMETAPI_KEY"),
"google": ("https://generativelanguage.googleapis.com", "GEMINI_API_KEY"),
}
BASE_URL, KEY_NAME = ROUTES[PROVIDER]
API_KEY = os.environ[KEY_NAME]
URL = f"{BASE_URL}/v1beta/models/{MODEL}:generateContent"
def generate(payload):
response = requests.post(
URL,
headers={"x-goog-api-key": API_KEY},
json=payload,
timeout=120,
)
response.raise_for_status()
return response.json()
def visible_text(data):
candidates = data.get("candidates") or []
if not candidates:
raise ValueError("No se devolvió ningún candidato; revisa promptFeedback.")
candidate = candidates[0]
parts = candidate.get("content", {}).get("parts", [])
text = "".join(
part.get("text", "") for part in parts
if not part.get("thought", False)
)
if not text:
raise ValueError(
f"No hay texto visible; revisa parts y finishReason: "
f"{candidate.get('finishReason')}"
)
return text
Guarda lo siguiente como hydrogen.py junto al auxiliar. Imprime la respuesta, el motivo de finalización y el uso para que puedas distinguir una respuesta completa de una salida que se detuvo por el límite de tokens.
Envía una solicitud de texto usando el proveedor configurado.
from hydrogen_client import generate, visible_text
data = generate({
"contents": [{"role": "user", "parts": [{
"text": "Explica la limitación de tasa (rate limiting) de una API en tres oraciones."
}]}],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
},
})
print(visible_text(data))
candidate = data["candidates"][0]
print("Motivo de finalización:", candidate.get("finishReason"))
print("Uso:", data.get("usageMetadata", {}))
Ejecuta el script en la terminal donde configuraste la clave de API seleccionada.
python hydrogen.py
Lee la respuesta y luego revisa finishReason para ver por qué se detuvo la generación. En usageMetadata, verifica cuántos tokens usó la solicitud. MAX_TOKENS significa que la respuesta puede estar incompleta, incluso cuando la solicitud HTTP tiene éxito.
Use JavaScript or an OpenAI-Compatible Client
Elige el ejemplo que se ajuste a tu aplicación. El ejemplo en Node.js envía una solicitud nativa de Gemini. Si ya usas el SDK de OpenAI, salta al ejemplo de Python a continuación.
JavaScript with Node.js
Guarda lo siguiente como hydrogen.js y ejecuta node hydrogen.js. Envía la misma forma de solicitud nativa y extrae todas las partes de texto visibles.
Envía una solicitud nativa GenerateContent desde Node.js.
const apiKey = process.env.COMETAPI_KEY;
if (!apiKey) throw new Error("Configura COMETAPI_KEY antes de ejecutar este script.");
const baseUrl = "https://api.cometapi.com";
const model = "gemini-4-hydrogen";
async function main() {
const response = await fetch(
`${baseUrl}/v1beta/models/${model}:generateContent`,
{
method: "POST",
headers: {
"Content-Type": "application/json",
"x-goog-api-key": apiKey
},
body: JSON.stringify({
contents: [
{
role: "user",
parts: [
{
text: "Explica cómo funciona un agente de programación de IA."
}
]
}
],
generationConfig: {
maxOutputTokens: 4096,
thinkingConfig: {
thinkingLevel: "MEDIUM"
}
}
})
}
);
if (!response.ok) {
throw new Error(
`Error de API: ${response.status} ${await response.text()}`
);
}
const data = await response.json();
const candidate = data.candidates?.[0];
const text = (candidate?.content?.parts || [])
.filter(part => !part.thought)
.map(part => part.text || "")
.join("");
if (!text) {
throw new Error(`No hay texto visible; finishReason=${candidate?.finishReason}`);
}
console.log(text);
}
main().catch(console.error);
Python with the OpenAI SDK
Si tu aplicación ya usa el SDK de OpenAI, CometAPI también expone POST /v1/chat/completions. La migración más simple es cambiar la clave de API, la URL base y el ID de modelo. Usa esta ruta para flujos de chat comunes; usa el endpoint nativo de Gemini cuando necesites campos específicos de Gemini.
Crea una solicitud de Chat Completions a través de CometAPI.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
response = client.chat.completions.create(
model="gemini-4-hydrogen",
messages=[
{
"role": "user",
"content": "Explica cómo funciona un agente de programación de IA."
}
]
)
print(response.choices[0].message.content)
Los ejemplos nativos usan contents y generationConfig; Chat Completions usa messages y sus propios campos de solicitud. Mantén cada solicitud en un único formato en lugar de copiar campos nativos en una llamada del SDK que no los acepta.
Advanced Gemini 4 Hydrogen API Features
Los siguientes ejemplos reutilizan hydrogen_client.py de la sección de configuración, por lo que funcionan con el proveedor seleccionado en PROVIDER. El ejemplo de streaming a continuación usa el cliente separado de Chat Completions de CometAPI, que encaja con una aplicación compatible con OpenAI existente.
Configure reasoning and structured output
Usa generationConfig para establecer thinkingConfig.thinkingLevel en LOW, MEDIUM, HIGH o XHIGH. Elige un presupuesto de salida que deje espacio tanto para el razonamiento como para la respuesta visible. Cuando la aplicación espere JSON, usa responseMimeType y responseSchema en lugar de confiar solo en una solicitud de formato en lenguaje natural.
Establece el presupuesto de salida y el nivel de razonamiento para una solicitud nativa.
{
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"}
}
}
Stream responses through CometAPI
El streaming devuelve el contenido generado de forma incremental en lugar de esperar a la respuesta completa. Es útil para interfaces de chat, asistentes de programación y aplicaciones donde la latencia percibida importa.
CometAPI documenta streaming de Chat Completions con stream=true. El ejemplo en Python maneja fragmentos sin choices, que pueden ocurrir en respuestas de streaming.
Imprime el texto a medida que llega a través del endpoint compatible con OpenAI.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1"
)
stream = client.chat.completions.create(
model="gemini-4-hydrogen",
messages=[
{
"role": "user",
"content": (
"Escribe una función en Python que valide un correo electrónico "
"y explica las comprobaciones principales."
)
}
],
stream=True
)
for chunk in stream:
if not chunk.choices:
continue
delta = chunk.choices[0].delta
if delta and delta.content:
print(delta.content, end="", flush=True)
print()
Para un cliente nativo, CometAPI documenta streamGenerateContent con Server-Sent Events. Esa ruta devuelve objetos de respuesta de GenerateContent en lugar de deltas de Chat Completions. Mantén el analizador acorde a la ruta; el comportamiento de streaming puede variar entre el endpoint nativo de Gemini y una puerta de enlace compatible con OpenAI. Prueba la ruta de Hydrogen exacta usada por tu aplicación antes de migrar un cliente de streaming existente.
Preserve multi-turn conversation history
Envía los turnos previos de usuario y modelo con la siguiente solicitud. Mantén el objeto de contenido completo del modelo en lugar de reconstruirlo a partir del texto visible; esto preserva los metadatos devueltos para el siguiente turno. Guarda el ejemplo como hydrogen_history.py junto al auxiliar compartido.
Realiza dos solicitudes relacionadas preservando la primera respuesta completa del modelo.
from hydrogen_client import generate, visible_text
history = [{"role": "user", "parts": [{
"text": "Sugiere una arquitectura simple de trabajos en segundo plano basada en colas."
}]}]
config = {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
}
first = generate({"contents": history, "generationConfig": config})
print(visible_text(first))
candidate = first["candidates"][0]
if candidate.get("finishReason") != "STOP":
raise RuntimeError("El primer turno no finalizó correctamente.")
history.append(candidate["content"])
history.append({"role": "user", "parts": [{
"text": "Ahora identifica tres escenarios de fallo en ese diseño."
}]})
second = generate({"contents": history, "generationConfig": config})
print(visible_text(second))
print("Motivo de finalización:", second["candidates"][0].get("finishReason"))
Ejecuta python hydrogen_history.py. La segunda respuesta debería abordar el diseño del primer turno. Mantén sin cambios el prefijo de conversación anterior en este ejemplo; las aplicaciones de larga ejecución necesitan una política aparte para compactación y límites de contexto.
Send images and PDFs
Hydrogen admite comprensión de imágenes y documentos. En el formato de solicitud nativa de Gemini, añade una parte inlineData junto con la instrucción de texto. Esto es útil para análisis de capturas de pantalla, diagramas de arquitectura, formularios escaneados y extracción de informes.
Guarda este ejemplo como analyze_file.py junto a hydrogen_client.py. Envía una imagen local o PDF, para que puedas reutilizar el mismo código para ambas entradas. Usa un archivo pequeño para la primera solicitud; Base64 incrementa el tamaño de la solicitud.
Analiza un PNG, JPEG o PDF local usando el cliente nativo compartido.
import base64
import sys
from pathlib import Path
from hydrogen_client import generate, visible_text
path = Path(sys.argv[1])
mime_types = {
".png": "image/png", ".jpg": "image/jpeg",
".jpeg": "image/jpeg", ".pdf": "application/pdf",
}
mime_type = mime_types.get(path.suffix.lower())
if mime_type is None:
raise ValueError("Elige un archivo PNG, JPEG o PDF.")
data = generate({
"contents": [{"role": "user", "parts": [
{"text": "Resume este archivo e identifica los hallazgos clave."},
{"inlineData": {
"mimeType": mime_type,
"data": base64.b64encode(path.read_bytes()).decode("ascii"),
}},
]}],
"generationConfig": {"maxOutputTokens": 4096},
})
print(visible_text(data))
Ejecuta el ejemplo de archivo con tu propio documento o imagen.
python analyze_file.py report.pdf
python analyze_file.py diagram.png
Los bytes del archivo deben coincidir con el tipo MIME declarado. Cambiar la extensión no convierte el archivo. Si se rechaza una carga, inspecciona el error en busca de un límite de tamaño o formato antes de reintentar; no asumas que un URI de archivo alojado por Google es accesible a través de una puerta de enlace de terceros.
Connect application-controlled tools
Las llamadas a funciones permiten que el modelo solicite una operación que ejecuta tu aplicación. El modelo devuelve una llamada a función estructurada; tu aplicación valida los argumentos, ejecuta la función y devuelve el resultado.
Este ejemplo usa una pequeña base de datos ficticia de pedidos. Guárdalo como order_agent.py junto al cliente compartido. Implementa el ciclo de ida y vuelta, limita el bucle a cuatro solicitudes y preserva el contenido completo del modelo —incluidas las firmas devueltas— entre turnos.
Ejecuta un bucle acotado de llamadas a funciones contra una base de datos de demostración local.
from hydrogen_client import generate, visible_text
orders = {"DEMO-1001": {"status": "shipped", "carrier": "Example Carrier"}}
tools = [{"functionDeclarations": [{
"name": "lookup_order",
"description": "Recupera un pedido de demostración por su ID de pedido.",
"parameters": {
"type": "OBJECT",
"properties": {"order_id": {"type": "STRING"}},
"required": ["order_id"],
},
}]}]
history = [{"role": "user", "parts": [{
"text": "Usa lookup_order para comprobar el estado de DEMO-1001."
}]}]
for _ in range(4):
data = generate({
"contents": history,
"tools": tools,
"generationConfig": {"maxOutputTokens": 4096},
})
candidates = data.get("candidates") or []
if not candidates or not candidates[0].get("content"):
raise RuntimeError("No se devolvió contenido del modelo.")
model_content = candidates[0]["content"]
calls = [
part["functionCall"] for part in model_content.get("parts", [])
if "functionCall" in part
]
if not calls:
print(visible_text(data))
break
history.append(model_content) # Preserva todas las partes y firmas.
results = []
for call in calls:
args = call.get("args", {})
order_id = args.get("order_id") if isinstance(args, dict) else None
if call.get("name") != "lookup_order":
raise ValueError("Nombre de función inesperado.")
if not isinstance(order_id, str) or not order_id:
raise ValueError("order_id debe ser una cadena no vacía.")
result = orders.get(order_id, {"error": "Pedido no encontrado"})
reply = {"name": call["name"], "response": result}
if "id" in call:
reply["id"] = call["id"]
results.append({"functionResponse": reply})
history.append({"role": "user", "parts": results})
else:
raise RuntimeError("Se alcanzó el límite de llamadas a herramientas antes de una respuesta final.")
Ejecuta python order_agent.py. La respuesta final debería reflejar el registro local para DEMO-1001. En un servicio real, autoriza al usuario antes de acceder a un pedido; la elección de un ID de pedido por parte del modelo no es prueba de permiso.
How Much Does Gemini 4 Hydrogen API Cost?
Las tarifas siguientes son USD por millón de tokens, comprobadas el 17 de noviembre de 2026. Comparan entrada y salida estándar sin caché, no procesamiento por lotes, prioridad, entrada en caché ni uso de herramientas facturadas por separado.
| Token type | Google Global Standard | Gemini 4 Hydrogen API in CometAPI |
|---|---|---|
| Input tokens / 1M | $1.50 | $1.20 |
| Output tokens / 1M | $7.50 | $6.00 |
Para 100,000 tokens de entrada y 10,000 tokens de salida facturables, la estimación de CometAPI es 0.1 × $1.20 + 0.01 × $6.00 = $0.18. Los mismos volúmenes a las tarifas estándar indicadas por Google cuestan $0.225, una diferencia del 20%. Incluye los tokens de razonamiento en el uso de salida y verifica el uso facturado de tu cuenta al estimar un flujo de trabajo real.
How Do You Migrate to Gemini 4 Hydrogen API?
What Changes When Migrating from Gemini 3.8 Flash?
Antes de cambiar el ID del modelo, verifica el ajuste de razonamiento, el presupuesto de contexto y el historial de conversación que tu cliente envía con cada solicitud.
| Integration detail | Gemini 3.8 Flash | Gemini 4 Hydrogen |
|---|---|---|
| Default thinking level | MEDIUM | HIGH |
| Context accounting | Límites separados de entrada y salida | Un único presupuesto compartido de entrada/salida |
| Multi-turn state | Revisa el manejo del historial del cliente existente | Preserva las partes y firmas completas del modelo; las ediciones del prefijo requieren manejo especial |
Los cambios de migración documentados importan especialmente cuando tu aplicación depende de valores predeterminados, compacta el historial o ejecuta varios turnos de herramientas. Establece explícitamente el razonamiento y prueba un flujo de trabajo existente corto antes de cambiar el modelo en producción.
Update an existing integration
Crea una configuración de prueba con el nuevo ID de modelo manteniendo juntos su clave y endpoint. Ejecuta el mismo flujo de trabajo representativo con ambas configuraciones para poder comparar su comportamiento.
- Envía una solicitud de texto nueva y verifica su motivo de finalización y uso de tokens.
- Repite una tarea multi-turno y un ciclo de herramienta usando objetos de respuesta completos del modelo.
- Elimina controles incompatibles enumerados en la sección de limitaciones antes de comparar los resultados de las solicitudes.
- Ejercita tu ruta de reversión en una conversación nueva; no asumas que otro modelo acepta los metadatos de razonamiento guardados de Hydrogen.
Decide whether the migration helps your workload
Adopta la nueva configuración cuando cumpla los objetivos de calidad y latencia de la tarea a un costo aceptable por tarea completada. Si el cliente actual ya cumple esos objetivos, usa un piloto limitado para establecer un beneficio antes de mover todas las solicitudes. Mantén consistentes los prompts, las entradas y los criterios de evaluación durante la evaluación.
Gemini 4 Hydrogen API Limitations
La guía para desarrolladores de Hydrogen describe restricciones que afectan a clientes existentes. Abórdalas en la construcción de la solicitud en lugar de reintentar el mismo payload rechazado.
- Campos no compatibles: elimina thinkingBudget, thinkingLevel establecido en MINIMAL, frequencyPenalty, presencePenalty y candidateCount mayor que uno.
- Ajustes de muestreo ignorados: temperature, topP y topK personalizados no controlan la salida de Hydrogen.
- Caché: cachedContent explícito no es compatible. Los prefijos de prompt estables pueden usar caché implícito, pero eso no establece un descuento de caché específico del gateway.
- Salida larga: el cliente de ejemplo de esta guía solo implementa una solicitud sincrónica. No cubre decodificación larga en segundo plano ni flujos de continuación específicos del proveedor.
- Cambios en la conversación: modificar prompts anteriores o definiciones de herramientas puede invalidar el estado de razonamiento. Preserva el prefijo, o implementa el comportamiento documentado para desajustes de prefijo en la ruta seleccionada.
Common setup checks
| Symptom | First check |
|---|---|
| 401 or 403 | Confirma que la credencial pertenece al endpoint y que tiene acceso al modelo seleccionado. |
| 400 | Lee el cuerpo del error; inspecciona campos no compatibles, JSON mal formado y metadatos de conversación. |
| No visible text | Revisa promptFeedback, las partes de candidate y finishReason; la respuesta puede estar bloqueada, incompleta o solicitando una herramienta. |
| MAX_TOKENS | Trata el texto como potencialmente incompleto y revisa el presupuesto de salida antes de aceptarlo. |
| File request rejected | Verifica el tipo MIME real y el límite de payload de la ruta seleccionada. |
Para fallos inesperados, registra el modelo, la ruta, el estado, la marca de tiempo y el ID de la solicitud cuando esté disponible. Mantén las claves de API y el contenido sensible de archivos fuera de los registros rutinarios.
FAQ
How should I retry Gemini 4 Hydrogen API rate-limit errors?
Para HTTP 429, reduce la concurrencia y reintenta con backoff exponencial y jitter, con un número máximo fijo de intentos. Conserva el ID de la solicitud cuando el gateway lo proporcione. No reintentes sin cambios las solicitudes inválidas ni los fallos de autenticación; la guía de errores y reintentos de CometAPI distingue esos casos de fallos transitorios. Un timeout puede ocurrir después de que el procesamiento haya comenzado, así que protege cualquier acción del lado de la aplicación frente a ejecuciones duplicadas.
Can I call Gemini 4 Hydrogen API directly from a web app?
Encamina las solicitudes a través de tu propio backend. Una clave incrustada en JavaScript del frontend puede ser extraída por los visitantes, incluso si el código está empaquetado o minimizado. Deja que el backend autentique a los usuarios, aplique límites de uso y envíe la solicitud al modelo. Para streaming, reenvía la respuesta incremental al navegador sin exponer la clave de la API ascendente.
How should I handle an interrupted Gemini 4 Hydrogen stream?
Trata el texto recibido como un resultado parcial hasta que la respuesta se complete. Una solicitud nueva inicia una generación nueva; no reanuda automáticamente el stream interrumpido en el mismo token. Mantén la salida parcial separada de una respuesta reintentada y no ejecutes acciones a partir de JSON incompleto o argumentos de herramientas sin terminar. Ofrece una acción de reintento visible en lugar de concatenar silenciosamente dos generaciones.
Conclusion
Usa una tarea representativa como tu primera verificación de aceptación: la solicitud debe tener éxito, la aplicación debe extraer el resultado previsto y el uso de tokens registrado debe ajustarse a tu presupuesto. Añade una función a la vez y mantén esa verificación en tu suite de integración. Un cliente pequeño y observable es más fácil de ampliar que un flujo de trabajo grande cuyas fallas sean difíciles de rastrear.

