TL;DR
A Gemini 4 Hydrogen API está disponível pela API Gemini do Google e por gateways de terceiros compatíveis, como a CometAPI. Escolha a rota primeiro: use o Google para recursos específicos do provedor e controles de conta, ou use a CometAPI quando quiser um gateway de modelos unificado ou um cliente compatível com OpenAI. Comece com uma pequena solicitação de texto, depois adicione streaming, histórico de conversas, arquivos e ferramentas.
Você precisa do Python 3.10 ou superior, de uma chave para a rota selecionada e de acesso a gemini-4-hydrogen. O exemplo opcional em JavaScript usa Node.js 22 ou superior. Mantenha as credenciais no ambiente do servidor ao longo de todo o tutorial.
Principais pontos
- Use
gemini-4-hydrogencomo o ID do modelo para a Gemini 4 Hydrogen API. - Google e CometAPI têm credenciais e faturamento separados. Combine a chave com o endpoint que você selecionar.
- Comece com o GenerateContent nativo; use a interface compatível com OpenAI da CometAPI quando ela se adequar a um cliente de chat existente.
- Mantenha a resposta completa do modelo no histórico de múltiplas interações, incluindo assinaturas, antes de retornar um acompanhamento ou o resultado de uma ferramenta.
- Compare o uso real de tokens e as tarefas concluídas ao escolher uma rota; o exemplo padrão de preço por token aparece na seção de preços.
O que é a API Gemini 4 Hydrogen?
O Google apresentou a Hydrogen em 12 de novembro de 2026. A API aceita prompts e arquivos compatíveis, depois retorna texto gerado ou chamadas de função estruturadas para sua aplicação tratar. Você não precisa hospedar o modelo.
Comece com uma solicitação somente de texto e verifique o texto retornado, o motivo de término e o uso de tokens antes de adicionar ferramentas ou arquivos. Depois que isso funcionar, adicione estado de conversa ou uma ferramenta de negócios somente leitura, em vez de construir todo o fluxo de trabalho de uma vez.
Especificações da API Gemini 4 Hydrogen
| Especificação | Capacidade do modelo documentada pelo Google |
|---|---|
| ID do modelo | gemini-4-hydrogen |
| Entrada | Texto, imagens, áudio, vídeo e documentos compatíveis |
| Saída | Texto, com partes estruturadas de chamada de função quando houver ferramentas |
| Orçamento de contexto unificado | 1,048,576 tokens entre entrada e saída |
| Segmento único de saída em primeiro plano | Até 65,536 tokens, incluindo raciocínio e chamadas de função |
| Recursos de aplicação | Controle do nível de raciocínio, saída estruturada e chamadas de função |
Essas são capacidades do modelo, não uma garantia de que todo gateway expõe todos os recursos do provedor. Os exemplos abaixo usam campos de solicitação padrão e gerações curtas em primeiro plano.
API oficial do Google vs CometAPI
Ambas as rotas oferecem suporte a solicitações Gemini, mas usam endpoints, credenciais e sistemas de faturamento diferentes. Use o Google para recursos específicos do provedor; use a CometAPI para um gateway unificado ou um cliente compatível já existente.
| Decisão | Google Gemini Developer API | Integração do Gemini na CometAPI |
|---|---|---|
| Host da API nativa | generativelanguage.googleapis.com | api.cometapi.com |
| Chave de API neste guia | GEMINI_API_KEY | COMETAPI_KEY |
| Conta e cobrança | Gerenciadas pelo Google | Gerenciadas pela CometAPI |
| Melhor ponto de partida | Recursos específicos do Google e controles de conta | Acesso unificado a modelos ou um cliente compatível com OpenAI |
Mantenha o mesmo prompt e orçamento de saída ao comparar as duas rotas para que os resultados sejam úteis. As alternativas em JavaScript e compatíveis com OpenAI permanecem explicitamente configuradas para a CometAPI.
Como usar a API Gemini 4 Hydrogen passo a passo?
Etapa 1: criar uma chave de API
Para a CometAPI, crie uma conta e gere uma chave no console de tokens de API. Para acesso direto do Google, crie uma chave da API Gemini no Google AI Studio. Confirme o acesso ao modelo e o faturamento ou a cota disponível da conta selecionada.
Armazene a chave com segurança. Uma chave da CometAPI não autentica uma solicitação ao endpoint do Google, e uma chave do Google não autentica uma solicitação da CometAPI.
Defina a chave para a rota escolhida no Bash; você só precisa de uma dessas atribuições.
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
# Or, for direct Google access:
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
Defina a chave correspondente no PowerShell no Windows.
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
# Or, for direct Google access:
$env:GEMINI_API_KEY = "YOUR_GEMINI_API_KEY"
Etapa 2: enviar uma primeira solicitação com cURL
Envie uma solicitação nativa de texto pela CometAPI a partir de um 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": "Explain how an AI coding agent works in five steps."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
Como alternativa, envie a mesma solicitação nativa diretamente ao Google com uma chave da API do 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": "Explain how an AI coding agent works in five steps."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {
"thinkingLevel": "MEDIUM"
}
}
}'
Depois que a solicitação for bem-sucedida, verifique três campos: candidates[0].content.parts para texto visível, finishReason para o status da conclusão e usageMetadata para o uso de tokens. Corrija erros de autenticação ou de solicitação antes de adicionar mais código de aplicação.
Etapa 3: configurar o cliente Python e enviar uma solicitação
Instale os pacotes usados pelos exemplos em Python.
python -m pip install requests openai
Salve este utilitário como hydrogen_client.py. Deixe PROVIDER definido como cometapi para a CometAPI, ou defina como google para acesso direto pela Gemini Developer API. Exemplos nativos posteriores importam este arquivo, mantendo assim a rota selecionada.
Configure o endpoint selecionado e defina utilitários reutilizáveis de solicitação e texto.
import os
import requests
MODEL = "gemini-4-hydrogen"
PROVIDER = "cometapi" # Change to "google" for direct access.
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 candidate returned; inspect 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 visible text; inspect parts and finishReason: "
f"{candidate.get('finishReason')}"
)
return text
Salve o seguinte como hydrogen.py ao lado do utilitário. Ele imprime a resposta, o motivo de conclusão e o uso, para que você possa distinguir uma resposta concluída de uma saída interrompida por limite de tokens.
Envie uma solicitação de texto usando o provedor configurado.
from hydrogen_client import generate, visible_text
data = generate({
"contents": [{"role": "user", "parts": [{
"text": "Explain API rate limiting in three sentences."
}]}],
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"},
},
})
print(visible_text(data))
candidate = data["candidates"][0]
print("Finish reason:", candidate.get("finishReason"))
print("Usage:", data.get("usageMetadata", {}))
Execute o script no terminal onde você definiu a chave de API selecionada.
python hydrogen.py
Leia a resposta e depois verifique finishReason para ver por que a geração parou. Em usageMetadata, verifique quantos tokens a solicitação usou. MAX_TOKENS significa que a resposta pode estar incompleta, mesmo quando a solicitação HTTP é bem-sucedida.
Usar JavaScript ou um cliente compatível com OpenAI
Escolha o exemplo que se adequa à sua aplicação. O exemplo em Node.js envia uma solicitação Gemini nativa. Se você já usa o SDK da OpenAI, avance para o exemplo em Python abaixo.
JavaScript com Node.js
Salve o seguinte como hydrogen.js e execute node hydrogen.js. Ele envia o mesmo formato de solicitação nativa e extrai todas as partes de texto visíveis.
Envie uma solicitação nativa GenerateContent a partir do Node.js.
const apiKey = process.env.COMETAPI_KEY;
if (!apiKey) throw new Error("Set COMETAPI_KEY before running this 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: "Explain how an AI coding agent works."
}
]
}
],
generationConfig: {
maxOutputTokens: 4096,
thinkingConfig: {
thinkingLevel: "MEDIUM"
}
}
})
}
);
if (!response.ok) {
throw new Error(
`API error: ${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 visible text; finishReason=${candidate?.finishReason}`);
}
console.log(text);
}
main().catch(console.error);
Python com o SDK da OpenAI
Se sua aplicação já usa o SDK da OpenAI, a CometAPI também expõe POST /v1/chat/completions. A migração mais simples é alterar a chave de API, a base URL e o ID do modelo. Use essa rota para fluxos de chat comuns; use o endpoint nativo do Gemini quando precisar de campos específicos do provedor Gemini.
Crie uma solicitação Chat Completions pela 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": "Explain how an AI coding agent works."
}
]
)
print(response.choices[0].message.content)
Os exemplos nativos usam contents e generationConfig; Chat Completions usa messages e seus próprios campos de solicitação. Mantenha cada solicitação em um único formato, em vez de copiar campos nativos para uma chamada de SDK que não os aceita.
Recursos avançados da API Gemini 4 Hydrogen
Os exemplos a seguir reutilizam hydrogen_client.py da seção de configuração, portanto funcionam com o provedor selecionado em PROVIDER. O exemplo de streaming abaixo usa o cliente separado de Chat Completions da CometAPI, que se adapta a uma aplicação compatível com OpenAI já existente.
Configurar raciocínio e saída estruturada
Use generationConfig para definir thinkingConfig.thinkingLevel como LOW, MEDIUM, HIGH ou XHIGH. Escolha um orçamento de saída que deixe espaço para o raciocínio e para a resposta visível. Quando a aplicação espera JSON, use responseMimeType e responseSchema em vez de depender apenas de um pedido de formatação em linguagem natural.
Defina o orçamento de saída e o nível de raciocínio para uma solicitação nativa.
{
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"}
}
}
Transmitir respostas pela CometAPI
O streaming retorna conteúdo gerado de forma incremental, em vez de esperar pela resposta completa. É útil para interfaces de chat, assistentes de código e aplicações em que a latência percebida importa.
A CometAPI documenta streaming Chat Completions com stream=true. O exemplo em Python trata fragmentos sem choices, o que pode ocorrer em respostas por streaming.
Imprima o texto conforme ele chega pelo endpoint compatível com 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": (
"Write a Python function that validates an email "
"address and explain the main checks."
)
}
],
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 um cliente nativo, a CometAPI documenta streamGenerateContent com Server-Sent Events. Essa rota retorna objetos de resposta GenerateContent em vez de deltas de Chat Completions. Mantenha o parser alinhado com a rota; o comportamento de streaming pode variar entre o endpoint nativo do Gemini e um gateway compatível com OpenAI. Teste a rota Hydrogen exata usada pela sua aplicação antes de migrar um cliente de streaming existente.
Preservar o histórico de várias interações
Envie as interações anteriores do usuário e do modelo com a próxima solicitação. Mantenha o objeto de conteúdo completo do modelo, em vez de reconstruí-lo a partir do texto visível; isso preserva os metadados retornados para a próxima interação. Salve o exemplo como hydrogen_history.py ao lado do utilitário compartilhado.
Faça duas solicitações relacionadas preservando a primeira resposta completa do modelo.
from hydrogen_client import generate, visible_text
history = [{"role": "user", "parts": [{
"text": "Suggest a simple queue-based background job architecture."
}]}]
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("The first turn did not finish normally.")
history.append(candidate["content"])
history.append({"role": "user", "parts": [{
"text": "Now identify three failure scenarios in that design."
}]})
second = generate({"contents": history, "generationConfig": config})
print(visible_text(second))
print("Finish reason:", second["candidates"][0].get("finishReason"))
Execute python hydrogen_history.py. A segunda resposta deve abordar o design da primeira interação. Mantenha o prefixo da conversa anterior inalterado neste exemplo; aplicações de longa duração precisam de uma política separada para compactação e limites de contexto.
Enviar imagens e PDFs
A Hydrogen é compatível com compreensão de imagens e documentos. No formato de solicitação nativo do Gemini, adicione uma parte inlineData junto com a instrução em texto. Isso é útil para análise de capturas de tela, diagramas de arquitetura, formulários digitalizados e extração de relatórios.
Salve este exemplo como analyze_file.py ao lado de hydrogen_client.py. Ele envia uma imagem local ou PDF, para que você possa reutilizar o mesmo código para ambos os tipos de entrada. Use um arquivo pequeno para a primeira solicitação; Base64 aumenta o tamanho da solicitação.
Analise um PNG, JPEG ou PDF local usando o cliente nativo compartilhado.
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("Choose a PNG, JPEG, or PDF file.")
data = generate({
"contents": [{"role": "user", "parts": [
{"text": "Summarize this file and identify the key findings."},
{"inlineData": {
"mimeType": mime_type,
"data": base64.b64encode(path.read_bytes()).decode("ascii"),
}},
]}],
"generationConfig": {"maxOutputTokens": 4096},
})
print(visible_text(data))
Execute o exemplo de arquivo com seu próprio documento ou imagem.
python analyze_file.py report.pdf
python analyze_file.py diagram.png
Os bytes do arquivo devem corresponder ao MIME type declarado. Renomear a extensão não converte o arquivo. Se um upload for rejeitado, inspecione o erro para verificar limite de tamanho ou formato antes de tentar novamente; não presuma que um URI de arquivo hospedado pelo Google seja acessível por um gateway de terceiros.
Conectar ferramentas controladas pela aplicação
A chamada de função permite que o modelo solicite uma operação que sua aplicação executa. O modelo retorna uma chamada de função estruturada; sua aplicação valida os argumentos, executa a função e envia o resultado de volta.
Este exemplo usa um pequeno banco de dados de pedidos fictício. Salve-o como order_agent.py ao lado do cliente compartilhado. Ele implementa o ciclo de ida e volta, limita o loop a quatro solicitações e preserva o conteúdo completo do modelo — incluindo quaisquer assinaturas retornadas — entre as interações.
Execute um loop limitado de chamadas de função contra um banco de dados de demonstração local.
from hydrogen_client import generate, visible_text
orders = {"DEMO-1001": {"status": "shipped", "carrier": "Example Carrier"}}
tools = [{"functionDeclarations": [{
"name": "lookup_order",
"description": "Retrieve a demonstration order by its order ID.",
"parameters": {
"type": "OBJECT",
"properties": {"order_id": {"type": "STRING"}},
"required": ["order_id"],
},
}]}]
history = [{"role": "user", "parts": [{
"text": "Use lookup_order to check the status of 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 model content returned.")
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) # Preserve all parts and signatures.
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("Unexpected function name.")
if not isinstance(order_id, str) or not order_id:
raise ValueError("order_id must be a non-empty string.")
result = orders.get(order_id, {"error": "Order not found"})
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("Tool-call limit reached before a final answer.")
Execute python order_agent.py. A resposta final deve refletir o registro local para DEMO-1001. Em um serviço real, autorize o usuário antes de acessar um pedido; a escolha de um ID de pedido pelo modelo não é prova de permissão.
Quanto custa a API Gemini 4 Hydrogen?
As tarifas abaixo são em USD por milhão de tokens, verificadas em 17 de novembro de 2026. Elas comparam entrada e saída padrão sem cache, não incluem processamento em lote, prioridade, entrada em cache ou uso de ferramentas faturado separadamente.
| Tipo de token | Padrão global do Google | API Gemini 4 Hydrogen na CometAPI |
|---|---|---|
| Tokens de entrada / 1M | $1.50 | $1.20 |
| Tokens de saída / 1M | $7.50 | $6.00 |
Para 100,000 tokens de entrada e 10,000 tokens de saída faturáveis, a estimativa da CometAPI é 0.1 × $1.20 + 0.01 × $6.00 = $0.18. Os mesmos volumes nas tarifas padrão listadas pelo Google custam $0.225, uma diferença de 20%. Inclua os tokens de raciocínio no uso de saída e verifique o uso faturado da sua conta ao estimar um fluxo de trabalho real.
Como migrar para a API Gemini 4 Hydrogen?
O que muda ao migrar do Gemini 3.8 Flash?
Antes de alterar o ID do modelo, verifique a configuração de raciocínio, o orçamento de contexto e o histórico de conversas que seu cliente envia com cada solicitação.
| Detalhe de integração | Gemini 3.8 Flash | Gemini 4 Hydrogen |
|---|---|---|
| Nível de raciocínio padrão | MEDIUM | HIGH |
| Contabilização de contexto | Limites separados de entrada e saída | Um orçamento compartilhado de entrada/saída |
| Estado de múltiplas interações | Revise o tratamento de histórico do cliente existente | Preserve partes e assinaturas completas do modelo; edições no prefixo exigem tratamento especial |
As mudanças de migração documentadas importam mais quando sua aplicação depende de padrões, compacta histórico ou executa várias rodadas de ferramentas. Defina o raciocínio explicitamente e teste um fluxo de trabalho curto existente antes de alterar o modelo em produção.
Atualizar uma integração existente
Crie uma configuração de teste com o novo ID de modelo mantendo sua chave e endpoint juntos. Execute o mesmo fluxo representativo com ambas as configurações para comparar o comportamento.
- Envie uma solicitação de texto nova e verifique o motivo de conclusão e o uso de tokens.
- Replique uma tarefa de múltiplas interações e um ciclo de chamada de ferramenta usando objetos completos de resposta do modelo.
- Remova controles incompatíveis listados na seção de limitações antes de comparar os resultados das solicitações.
- Exercite seu caminho de reversão em uma conversa nova; não presuma que outro modelo aceite os metadados de raciocínio salvos da Hydrogen.
Decidir se a migração ajuda seu workload
Adote a nova configuração quando ela atender às metas de qualidade e latência com um custo aceitável por tarefa concluída. Se o cliente atual já atende a essas metas, use um piloto limitado para estabelecer um benefício antes de mover todas as solicitações. Mantenha os prompts, entradas e critérios de avaliação consistentes durante a avaliação.
Limitações da API Gemini 4 Hydrogen
O guia do desenvolvedor da Hydrogen descreve restrições que afetam clientes existentes. Trate-as na construção da solicitação em vez de repetir o mesmo payload rejeitado.
- Campos não compatíveis: remova thinkingBudget, thinkingLevel definido como MINIMAL, frequencyPenalty, presencePenalty e candidateCount maior que um.
- Configurações de amostragem ignoradas: temperature personalizado, topP e topK não controlam a saída da Hydrogen.
- Cache: cachedContent explícito não é compatível. Prefixos de prompt estáveis podem usar cache implícito, mas isso não estabelece um desconto de cache específico do gateway.
- Saída longa: o cliente de exemplo neste guia implementa apenas uma solicitação síncrona. Ele não cobre decodificação longa em segundo plano ou fluxos de continuação específicos do provedor.
- Mudanças na conversa: modificar prompts anteriores ou definições de ferramentas pode invalidar o estado de raciocínio. Preserve o prefixo ou implemente o comportamento documentado de incompatibilidade de prefixo para a rota selecionada.
Verificações comuns de configuração
| Sintoma | Primeira verificação |
|---|---|
| 401 ou 403 | Confirme que a credencial pertence ao endpoint e tem acesso ao modelo selecionado. |
| 400 | Leia o corpo do erro; inspecione campos não compatíveis, JSON malformado e metadados da conversa. |
| Sem texto visível | Inspecione promptFeedback, as partes do candidato e finishReason; a resposta pode estar bloqueada, incompleta ou pedindo uma ferramenta. |
| MAX_TOKENS | Trate o texto como potencialmente incompleto e revise o orçamento de saída antes de aceitá-lo. |
| Solicitação de arquivo rejeitada | Verifique o MIME type real e o limite de payload da rota selecionada. |
Para falhas inesperadas, registre o modelo, a rota, o status, o timestamp e o ID da solicitação quando disponível. Mantenha chaves de API e conteúdos de arquivo sensíveis fora de logs rotineiros.
FAQ
Como devo tentar novamente erros de limite de taxa da API Gemini 4 Hydrogen?
Para HTTP 429, reduza a concorrência e tente novamente com backoff exponencial e jitter, com um número máximo fixo de tentativas. Guarde o ID da solicitação quando o gateway o fornecer. Não tente novamente solicitações inválidas ou falhas de autenticação sem alterações; o guia de erros e tentativas da CometAPI diferencia essas falhas das transitórias. Um timeout pode ocorrer após o início do processamento, então proteja qualquer ação do lado da aplicação contra execução duplicada.
Posso chamar a API Gemini 4 Hydrogen diretamente de um aplicativo web?
Direcione as solicitações pelo seu backend. Uma chave embutida em JavaScript no frontend pode ser extraída por visitantes, mesmo se o código estiver empacotado ou minimizado. Deixe o backend autenticar usuários, aplicar limites de uso e enviar a solicitação ao modelo. Para streaming, encaminhe a resposta incremental ao navegador sem expor a chave da API upstream.
Como devo lidar com uma transmissão interrompida da Gemini 4 Hydrogen?
Trate o texto recebido como um resultado parcial até que a resposta seja concluída. Uma nova solicitação inicia uma nova geração; ela não retoma automaticamente o stream interrompido no mesmo token. Mantenha a saída parcial separada de uma resposta repetida e não execute ações a partir de JSON incompleto ou argumentos de ferramenta inacabados. Ofereça uma ação de “tentar novamente” visível em vez de concatenar silenciosamente duas gerações.
Conclusão
Use uma tarefa representativa como seu primeiro teste de aceitação: a solicitação deve ser bem-sucedida, a aplicação deve extrair o resultado pretendido e o uso de tokens registrado deve caber no seu orçamento. Adicione um recurso por vez e mantenha esse teste na sua suíte de integração. Um cliente pequeno e observável é mais fácil de estender do que um fluxo de trabalho grande cujas falhas são difíceis de rastrear.

