TL;DR
Gemini 4 Hydrogen API รจ disponibile tramite la Gemini API di Google e gateway di terze parti supportati come CometAPI. Scegli prima la via dโaccesso: usa Google per funzionalitร specifiche del provider e controlli dellโaccount, oppure usa CometAPI quando desideri un gateway unificato per i modelli o un client compatibile con OpenAI. Inizia con una piccola richiesta di testo, poi aggiungi streaming, cronologia della conversazione, file e strumenti.
Ti servono Python 3.10 o successivo, una chiave per la via selezionata e lโaccesso a gemini-4-hydrogen. Lโesempio JavaScript facoltativo richiede Node.js 22 o successivo. Mantieni le credenziali nellโambiente server durante tutto il tutorial.
Key Takeaways
- Usa
gemini-4-hydrogencome ID del modello per la Gemini 4 Hydrogen API. - Google e CometAPI hanno credenziali e fatturazione separate. Abbina la chiave allโendpoint selezionato.
- Inizia con il GenerateContent nativo; usa lโinterfaccia compatibile con OpenAI di CometAPI quando si adatta a un client chat esistente.
- Mantieni nella cronologia multi-turno lโintera risposta del modello, incluse le firme, prima di inviare un seguito o il risultato di uno strumento.
- Confronta lโeffettivo uso di token e i task completati quando scegli la via; lโesempio standard prezzo-per-token รจ nella sezione prezzi.
What Is the Gemini 4 Hydrogen API?
Google ha introdotto Hydrogen il 12 novembre 2026. LโAPI accetta prompt e file supportati, quindi restituisce testo generato o chiamate di funzione strutturate da gestire nella tua applicazione. Non devi fare hosting del modello.
Inizia con una richiesta solo testo e verifica testo restituito, motivo di terminazione e uso di token prima di aggiungere strumenti o file. Una volta che funziona, aggiungi lo stato di conversazione o uno strumento aziendale in sola lettura invece di costruire subito lโintero flusso.
Gemini 4 Hydrogen API specifications
| Specifica | Capacitร del modello documentata da Google |
|---|---|
| Model ID | gemini-4-hydrogen |
| Input | Testo, immagini, audio, video e documenti supportati |
| Output | Testo, con parti di function-call strutturate quando si usano tool |
| Unified context budget | 1.048.576 token tra input e output |
| Single foreground output segment | Fino a 65.536 token, inclusi ragionamento e chiamate di funzione |
| Application features | Controllo del livello di thinking, output strutturato e function calling |
Queste sono capacitร del modello, non una garanzia che ogni gateway esponga ogni funzionalitร del provider. Gli esempi seguenti usano campi di richiesta standard e generazioni brevi in primo piano.
Google Official API vs CometAPI
Entrambe le vie supportano richieste Gemini, ma usano endpoint, credenziali e sistemi di fatturazione differenti. Usa Google per funzionalitร specifiche del provider; usa CometAPI per un gateway unificato o per un client compatibile esistente.
| Decisione | Google Gemini Developer API | Integrazione Gemini di CometAPI |
|---|---|---|
| Host API nativo | generativelanguage.googleapis.com | api.cometapi.com |
| API key in questa guida | GEMINI_API_KEY | COMETAPI_KEY |
| Account e fatturazione | Gestiti tramite Google | Gestiti tramite CometAPI |
| Punto di partenza ideale | Funzionalitร specifiche di Google e controlli account | Accesso unificato ai modelli o client compatibile con OpenAI |
Mantieni lo stesso prompt e budget di output quando confronti le due vie, cosรฌ i risultati sono utili. Le alternative JavaScript e compatibili con OpenAI restano configurate esplicitamente per CometAPI.
How to Use Gemini 4 Hydrogen API Step by Step?
Step 1: Create an API key
Per CometAPI, crea un account e genera una chiave nella console dei token API. Per lโaccesso diretto a Google, crea una chiave Gemini API in Google AI Studio. Conferma lโaccesso al modello e la fatturazione o la quota disponibile dellโaccount selezionato.
Conserva la chiave in modo sicuro. Una chiave CometAPI non puรฒ autenticare una richiesta allโendpoint di Google e una chiave Google non puรฒ autenticare una richiesta CometAPI.
Imposta la chiave per la via scelta in Bash; ti basta una sola di queste assegnazioni.
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
# Or, for direct Google access:
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
Imposta la chiave corrispondente in PowerShell su Windows.
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
# Or, for direct Google access:
$env:GEMINI_API_KEY = "YOUR_GEMINI_API_KEY"
Step 2: Send a first request with cURL
Invia una richiesta di testo nativa tramite CometAPI da un terminale 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"
}
}
}'
In alternativa, invia la stessa richiesta nativa direttamente a Google con una chiave Google API.
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"
}
}
}'
Dopo il successo della richiesta, verifica tre campi: candidates[0].content.parts per il testo visibile, finishReason per lo stato di completamento e usageMetadata per lโuso dei token. Correggi errori di autenticazione o della richiesta prima di aggiungere altro codice applicativo.
Step 3: Configure the Python Client and Send a Request
Installa i pacchetti usati dagli esempi Python.
python -m pip install requests openai
Salva questo helper come hydrogen_client.py. Lascia PROVIDER impostato su cometapi per CometAPI, oppure impostalo su google per lโaccesso diretto alla Gemini Developer API. Gli esempi nativi successivi importano questo file, cosรฌ mantengono la via selezionata.
Configura lโendpoint scelto e definisci helper riutilizzabili per richiesta e testo.
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
Salva quanto segue come hydrogen.py accanto allโhelper. Stampa la risposta, il motivo di completamento e lโuso, cosรฌ puoi distinguere una risposta completa da un output interrotto dal limite di token.
Invia una richiesta di testo usando il provider configurato.
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", {}))
Esegui lo script nel terminale in cui hai impostato la chiave API selezionata.
python hydrogen.py
Leggi la risposta, poi controlla finishReason per capire perchรฉ la generazione si รจ fermata. In usageMetadata, verifica quanti token ha usato la richiesta. MAX_TOKENS significa che la risposta potrebbe essere incompleta, anche quando la richiesta HTTP va a buon fine.
Use JavaScript or an OpenAI-Compatible Client
Scegli lโesempio che si adatta alla tua applicazione. Lโesempio Node.js invia una richiesta Gemini nativa. Se usi giร lโSDK OpenAI, passa allโesempio Python qui sotto.
JavaScript con Node.js
Salva quanto segue come hydrogen.js ed esegui node hydrogen.js. Invia la stessa forma di richiesta nativa ed estrae tutte le parti di testo visibile.
Invia una richiesta nativa GenerateContent da 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 con lโSDK OpenAI
Se la tua applicazione usa giร lโSDK OpenAI, CometAPI espone anche POST /v1/chat/completions. La migrazione piรน semplice รจ cambiare API key, base URL e ID modello. Usa questa via per i flussi chat comuni; usa lโendpoint nativo Gemini quando ti servono campi specifici di Gemini.
Crea una richiesta Chat Completions tramite 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)
Gli esempi nativi usano contents e generationConfig; Chat Completions usa messages e i propri campi di richiesta. Mantieni ogni richiesta in un solo formato invece di copiare campi nativi in una chiamata SDK che non li accetta.
Advanced Gemini 4 Hydrogen API Features
Gli esempi seguenti riutilizzano hydrogen_client.py dalla sezione di setup, quindi funzionano con il provider selezionato in PROVIDER. Lโesempio di streaming sotto usa il client separato CometAPI Chat Completions, che si adatta a unโapplicazione compatibile con OpenAI esistente.
Configure reasoning and structured output
Usa generationConfig per impostare thinkingConfig.thinkingLevel su LOW, MEDIUM, HIGH o XHIGH. Scegli un budget di output che lasci spazio sia al ragionamento sia alla risposta visibile. Quando lโapplicazione si aspetta JSON, usa responseMimeType e responseSchema invece di affidarti solo a una richiesta di formattazione in linguaggio naturale.
Imposta budget di output e livello di ragionamento per una richiesta nativa.
{
"generationConfig": {
"maxOutputTokens": 4096,
"thinkingConfig": {"thinkingLevel": "MEDIUM"}
}
}
Stream responses through CometAPI
Lo streaming restituisce il contenuto generato in modo incrementale invece di attendere la risposta completa. ร utile per interfacce chat, assistenti di coding e applicazioni in cui conta la latenza percepita.
CometAPI documenta lo streaming Chat Completions con stream=true. Lโesempio Python gestisce chunk senza choices, che possono verificarsi nelle risposte in streaming.
Stampa il testo man mano che arriva tramite lโendpoint compatibile 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": (
"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()
Per un client nativo, CometAPI documenta streamGenerateContent con Server-Sent Events. Questa via restituisce oggetti di risposta GenerateContent invece dei delta di Chat Completions. Mantieni il parser allineato alla via; il comportamento dello streaming puรฒ variare tra lโendpoint Gemini nativo e un gateway compatibile con OpenAI. Testa lโesatta via Hydrogen usata dalla tua applicazione prima di migrare un client di streaming esistente.
Preserve multi-turn conversation history
Invia i turni precedenti di utente e modello con la richiesta successiva. Mantieni lโoggetto content completo del modello invece di ricostruirlo dal solo testo visibile; cosรฌ preservi i metadati restituiti per il turno successivo. Salva lโesempio come hydrogen_history.py accanto allโhelper condiviso.
Esegui due richieste correlate preservando la prima risposta completa del modello.
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"))
Esegui python hydrogen_history.py. La seconda risposta dovrebbe riferirsi al design del primo turno. Mantieni il prefisso conversazionale immutato in questo esempio; applicazioni di lunga durata necessitano una politica separata per compattazione e limiti di contesto.
Send images and PDFs
Hydrogen supporta la comprensione di immagini e documenti. Nel formato nativo della richiesta Gemini, aggiungi una parte inlineData insieme allโistruzione di testo. ร utile per analisi di screenshot, diagrammi architetturali, moduli scansionati ed estrazione di report.
Salva questo esempio come analyze_file.py accanto a hydrogen_client.py. Invia unโimmagine locale o un PDF, cosรฌ puoi riutilizzare lo stesso codice per entrambi gli input. Usa un file piccolo per la prima richiesta; la Base64 aumenta la dimensione della richiesta.
Analizza un PNG, JPEG o PDF locale usando il client nativo condiviso.
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))
Esegui lโesempio con un tuo documento o immagine.
python analyze_file.py report.pdf
python analyze_file.py diagram.png
I byte del file devono corrispondere al MIME type dichiarato. Rinominare lโestensione non converte il file. Se un upload viene rifiutato, esamina lโerrore per un limite di dimensione o formato prima di riprovare; non presumere che un URI di file ospitato su Google sia accessibile tramite un gateway di terze parti.
Connect application-controlled tools
Il function calling consente al modello di richiedere unโoperazione che la tua applicazione esegue. Il modello restituisce una chiamata di funzione strutturata; la tua applicazione convalida gli argomenti, esegue la funzione e invia indietro il risultato.
Questo esempio usa un piccolo database ordini fittizio. Salvalo come order_agent.py accanto al client condiviso. Implementa lโandata e ritorno, limita il loop a quattro richieste e preserva il content completo del modelloโincluse eventuali firme restituiteโtra i turni.
Esegui un ciclo limitato di function calling contro un database dimostrativo locale.
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.")
Esegui python order_agent.py. La risposta finale dovrebbe riflettere il record locale per DEMO-1001. In un servizio reale, autorizza lโutente prima di accedere a un ordine; la scelta di un ID ordine da parte del modello non prova lโautorizzazione.
How Much Does Gemini 4 Hydrogen API Cost?
Le tariffe sotto sono in USD per milione di token, verificate il 17 novembre 2026. Confrontano input e output standard non in cache, non batch, non priority, input in cache o uso di tool fatturati separatamente.
| Tipo di token | Google Global Standard | Gemini 4 Hydrogen API in CometAPI |
|---|---|---|
| Input token / 1M | $1.50 | $1.20 |
| Output token / 1M | $7.50 | $6.00 |
Per 100.000 token di input e 10.000 token di output fatturabili, la stima CometAPI รจ 0.1 ร $1.20 + 0.01 ร $6.00 = $0.18. Gli stessi volumi alle tariffe standard elencate da Google costano $0.225, una differenza del 20%. Includi i token di ragionamento nellโuso di output e verifica lโuso fatturato del tuo account quando stimi un flusso reale.
How Do You Migrate to Gemini 4 Hydrogen API?
What Changes When Migrating from Gemini 3.8 Flash?
Prima di cambiare lโID del modello, controlla lโimpostazione di reasoning, il budget di contesto e la cronologia di conversazione che il tuo client invia con ogni richiesta.
| Dettaglio di integrazione | Gemini 3.8 Flash | Gemini 4 Hydrogen |
|---|---|---|
| Default thinking level | MEDIUM | HIGH |
| Context accounting | Limiti separati per input e output | Un unico budget condiviso input/output |
| Stato multi-turno | Rivedi la gestione della cronologia del client esistente | Preserva le parti e le firme complete del modello; le modifiche al prefisso richiedono gestione speciale |
Le modifiche di migrazione documentate contano soprattutto quando la tua applicazione si affida ai default, compatta la cronologia o esegue diversi turni con tool. Imposta esplicitamente il reasoning e testa un flusso breve esistente prima di cambiare il modello in produzione.
Update an existing integration
Crea una configurazione di test con il nuovo ID modello mantenendo insieme la sua chiave e lโendpoint. Esegui lo stesso flusso rappresentativo con entrambe le configurazioni per confrontarne il comportamento.
- Invia una richiesta di testo nuova e verifica motivo di completamento e uso dei token.
- Riproduci unโattivitร multi-turno e un round trip di tool usando oggetti di risposta del modello completi.
- Rimuovi i controlli incompatibili elencati nella sezione limitazioni prima di confrontare gli esiti delle richieste.
- Esercita il percorso di rollback in una conversazione nuova; non dare per scontato che un altro modello accetti i metadati di reasoning salvati di Hydrogen.
Decide whether the migration helps your workload
Adotta la nuova configurazione quando soddisfa gli obiettivi di qualitร e latenza al costo per task completato accettabile. Se il client attuale giร soddisfa tali obiettivi, usa un pilota limitato per stabilire un beneficio prima di spostare ogni richiesta. Mantieni coerenti prompt, input e criteri di valutazione durante lโanalisi.
Gemini 4 Hydrogen API Limitations
La guida per sviluppatori di Hydrogen descrive restrizioni che influenzano i client esistenti. Affrontale nella costruzione della richiesta invece di riprovare lo stesso payload rifiutato.
- Campi non supportati: rimuovi thinkingBudget, thinkingLevel impostato su MINIMAL, frequencyPenalty, presencePenalty e candidateCount maggiore di uno.
- Impostazioni di campionamento ignorate: temperature personalizzata, topP e topK non controllano lโoutput di Hydrogen.
- Caching: cachedContent esplicito non รจ supportato. I prefissi di prompt stabili possono usare caching implicito, ma questo non stabilisce uno sconto di cache specifico del gateway.
- Output lungo: il client di esempio in questa guida implementa solo una richiesta sincrona. Non copre decodifica lunga in background o flussi di continuazione specifici del provider.
- Modifiche alla conversazione: modificare prompt precedenti o definizioni degli strumenti puรฒ invalidare lo stato di reasoning. Preserva il prefisso o implementa il comportamento documentato di mismatch del prefisso per la via selezionata.
Common setup checks
| Sintomo | Primo controllo |
|---|---|
| 401 o 403 | Conferma che la credenziale appartenga allโendpoint e abbia accesso al modello selezionato. |
| 400 | Leggi il body di errore; controlla campi non supportati, JSON malformato e metadati di conversazione. |
| Nessun testo visibile | Esamina promptFeedback, parti del candidato e finishReason; la risposta puรฒ essere bloccata, incompleta o richiedere uno strumento. |
| MAX_TOKENS | Considera il testo potenzialmente incompleto e rivedi il budget di output prima di accettarlo. |
| Richiesta file rifiutata | Verifica il reale MIME type e il limite di payload della via selezionata. |
Per errori imprevisti, registra modello, via, stato, timestamp e request ID quando disponibile. Tieni le API key e contenuti di file sensibili fuori dai log di routine.
FAQ
How should I retry Gemini 4 Hydrogen API rate-limit errors?
Per HTTP 429, riduci la concorrenza e ritenta con backoff esponenziale e jitter, con un numero massimo fisso di tentativi. Conserva il request ID quando fornito dal gateway. Non ritentare richieste non valide o errori di autenticazione senza modifiche; la guida a errori e retry di CometAPI distingue questi dai guasti transitori. Un timeout puรฒ verificarsi dopo lโinizio dellโelaborazione, quindi proteggi qualunque azione lato applicazione da esecuzioni duplicate.
Can I call Gemini 4 Hydrogen API directly from a web app?
Instrada le richieste tramite il tuo backend. Una chiave incorporata nel JavaScript del frontend puรฒ essere estratta dai visitatori, anche se il codice รจ bundle o minificato. Lascia che il backend autentichi gli utenti, applichi limiti di utilizzo e invii la richiesta al modello. Per lo streaming, inoltra la risposta incrementale al browser senza esporre la chiave API upstream.
How should I handle an interrupted Gemini 4 Hydrogen stream?
Tratta il testo ricevuto come risultato parziale finchรฉ la risposta non รจ completa. Una nuova richiesta avvia una nuova generazione; non riprende automaticamente lo stream interrotto allo stesso token. Tieni separato lโoutput parziale da una risposta ritentata e non eseguire azioni da JSON incompleto o argomenti di tool non terminati. Offri unโazione di retry visibile invece di concatenare silenziosamente due generazioni.
Conclusion
Usa un task rappresentativo come primo controllo di accettazione: la richiesta deve riuscire, lโapplicazione deve estrarre il risultato previsto e lโuso di token registrato deve rientrare nel tuo budget. Aggiungi una funzione alla volta e mantieni quel controllo nella tua suite dโintegrazione. Un client piccolo e osservabile รจ piรน facile da estendere di un flusso ampio i cui guasti sono difficili da tracciare.

