Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
", "aboutText": "Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.\n\nPour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.\n\nPour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.\n\nLes outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.\n\nLe guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.\n\nPour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.\n\nSes limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.\n\nLes limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.", "editorialOverlay": { "copy_fields": { "practical_html": "Exemple technique en anglais
Diagnose an unsaved form value\n\nReview this form flow: the input displays draft.name; typing updates draft.name; Save sends original.name; after reload the old name reappears. Explain the mismatch and propose a minimal correction in framework-neutral pseudocode. Include a regression scenario that types a new name, saves, reloads, and checks the stored value. Do not claim any browser action occurred.A cause explanation, corrected Save pseudocode and an end-to-end regression scenario.The submitted value comes from the edited draft, and the reload check verifies persistence rather than just the visible input.gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestext, imagetext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites user, assistant | Par défaut— |
Champmessages[].content | Typestring|content_block[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champsystem | Typestring|content_block[] | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceObligatoire | Valeurs et limites Minimum: 1 La limite s’applique à: plafond exact du modèle ou de la fiche sélectionnés | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champstop_sequences | Typestring[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools | Typetool[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].name | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: outil fourni | Par défaut— |
Champtools[].description | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtools[].input_schema | TypeJSON_schema | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtool_choice | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champthinking.type | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champthinking.budget_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champoutput_config.effort | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmetadata | Typeobject | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champcache_control | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Texte · Texte UTF8
messages[].content ou bloc type=text
Texte + image
{type:image,source:{type:base64,media_type,data}} ou source type=url
| Paramètre | Contrat |
|---|---|
Paramètrematerial_types | Contrattext, image |
Paramètrerequired | Contratmodel, messages, max_tokens |
Paramètreoptional_controls | Contratnull |
Paramètrecontent_type | Contratapplication/json |
Paramètretext_file_material | Contratcontenu UTF-8 réel inséré sous forme de texte ; les identifiants de fichiers et les URLs nécessitent une prise en charge exacte distincte |
Cycle de vie : exact retained published method
Les structures des méthodes et les identifiants sont exacts ; la capacité du fournisseur est distincte de l’admission.
POST /v1/messagesAiloot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
Les barèmes de référence du modèle ne modifient ni la sélection de méthode, ni les devis, ni les coûts. Les frais actifs utilisent les tarifs de la méthode Ailoot sélectionnée.
Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationOpenAI Chat · Tarifs de base par token | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
| ConfigurationAnthropic Messages · Tarifs de base par token | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "gemini-3.8-flash", "max_tokens": 1024, "messages": []}')\nf=Path(os.environ["AILOOT_TEXT_FILE"])\nif not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")\ntext=f.read_text(encoding="utf-8")\nif not text.strip():raise SystemExit("Source material must contain text")\np["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\\n\\n"+text}]\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\nset -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"\nexport AILOOT_IMAGE_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "gemini-3.8-flash", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')\nimport base64\nf=Path(os.environ["AILOOT_IMAGE_FILE"])\nif not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")\nraw=f.read_bytes()\nmime="image/png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "image/jpeg" if raw.startswith(b"\\xff\\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None\nif not mime:raise SystemExit("Use PNG JPEG or WebP")\nb64=base64.b64encode(raw).decode()\np["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\nimport anthropic\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)\nmsg = client.messages.create(\n model="gemini-3.8-flash",\n max_tokens=1024,\n messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],\n)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(msg.to_dict(mode="json"))\nimport Anthropic from "@anthropic-ai/sdk";\n\nif (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");\nconst client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });\nconst msg = await client.messages.create({\n model: "gemini-3.8-flash",\n max_tokens: 1024,\n messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],\n});\nimport { writeFileSync } from "node:fs";\n\nfunction saveResult(data, stem = "result") {\n writeFileSync(stem + ".json", JSON.stringify(data, null, 2));\n console.log(JSON.stringify(data, null, 2));\n const saveBlob = (encoded, suffix, label) => {\n const raw = Buffer.from(encoded, "base64");\n const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;\n const file = `${stem}-${label}.${ext}`;\n writeFileSync(file, raw); console.log("Saved", file);\n };\n for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));\n for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));\n for (const [i, item] of (data.output || []).entries()) {\n console.log("Output", i, JSON.stringify(item));\n if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);\n }\n for (const [ci, candidate] of (data.candidates || []).entries()) {\n for (const [pi, part] of (candidate.content?.parts || []).entries()) {\n console.log("Candidate/part", ci, pi, JSON.stringify(part));\n const blob = part.inlineData || part.inline_data;\n if (blob?.data) {\n const mime = blob.mimeType || blob.mime_type;\n const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";\n saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);\n }\n }\n }\n}\n\nsaveResult(msg);\nimport anthropic,os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.messages.stream(model='gemini-3.8-flash',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_message()\n save_result(final.to_dict(mode="json"),"stream-result")\njson ou SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez tous les blocs de contenu, les signatures de raisonnement et les identifiants réels d’utilisation d’outils. Assemblez tous les deltas de blocs SSE ; un premier bloc de texte ne constitue pas la sortie complète.
Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.
| Champ | Type |
|---|---|
Champid | Typestring |
Champmodel | Typestring |
Champcontent[] | Typetext|thinking|tool_use|other content block |
Champstop_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1beta/models/{model}:generateContenttext, imagetext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champpath.model | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | Par défaut— |
Champcontents | Typecontent[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champcontents[].role | Typestring | ExigenceFacultatif | Valeurs et limites user, model | Par défaut— |
Champcontents[].parts | Typepart[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
ChampsystemInstruction | Typecontent | ExigenceFacultatif | Valeurs et limites | Par défaut— |
ChampgenerationConfig.maxOutputTokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
ChampgenerationConfig.temperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.topP | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.topK | Typeinteger | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.stopSequences | Typestring[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.thinkingConfig.includeThoughts | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.thinkingConfig.thinkingBudget | Typeinteger | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].functionDeclarations | Typefunction_declaration[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChamptoolConfig.functionCallingConfig.mode | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampsafetySettings | Typeobject[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampsessionId | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Texte · Texte UTF8
contents[].parts[].text
Texte + image
parts[].inlineData={mimeType,data}
| Paramètre | Contrat |
|---|---|
Paramètrematerial_types | Contrattext, image |
Paramètrerequired | Contratcontents |
Paramètreoptional_controls | Contratnull |
Paramètrecontent_type | Contratapplication/json |
Paramètretext_file_material | Contratcontenu UTF-8 réel inséré sous forme de texte ; les identifiants de fichiers et les URLs nécessitent une prise en charge exacte distincte |
Cycle de vie : exact retained published method
Les structures des méthodes et les identifiants sont exacts ; la capacité du fournisseur est distincte de l’admission.
POST /v1beta/models/{model}:generateContentAiloot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
Les barèmes de référence du modèle ne modifient ni la sélection de méthode, ni les devis, ni les coûts. Les frais actifs utilisent les tarifs de la méthode Ailoot sélectionnée.
Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationOpenAI Chat · Tarifs de base par token | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
| ConfigurationAnthropic Messages · Tarifs de base par token | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"contents": []}')\nf=Path(os.environ["AILOOT_TEXT_FILE"])\nif not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")\ntext=f.read_text(encoding="utf-8")\nif not text.strip():raise SystemExit("Source material must contain text")\np["contents"]=[{"role":"user","parts":[{"text":"Summarize this material and quote supporting source passages.\\n\\n"+text}]}]\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-3.8-flash:generateContent \\\n -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(json.loads(Path("result.json").read_text(encoding="utf-8")))\nPY_RESULT\nset -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"\nexport AILOOT_IMAGE_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"contents": [{"role": "user", "parts": [{"text": "Read labels and numbers in this image; flag unreadable text."}]}]}')\nimport base64\nf=Path(os.environ["AILOOT_IMAGE_FILE"])\nif not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")\nraw=f.read_bytes()\nmime="image/png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "image/jpeg" if raw.startswith(b"\\xff\\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None\nif not mime:raise SystemExit("Use PNG JPEG or WebP")\nb64=base64.b64encode(raw).decode()\np["contents"][0]["parts"].append({"inlineData":{"mimeType":mime,"data":b64}})\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-3.8-flash:generateContent \\\n -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(json.loads(Path("result.json").read_text(encoding="utf-8")))\nPY_RESULT\nfrom google import genai\nfrom google.genai import types\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient = genai.Client(\n api_key=os.environ["AILOOT_API_KEY"],\n http_options=types.HttpOptions(base_url="https://api.ailoot.ai"),\n)\nresp = client.models.generate_content(model="gemini-3.8-flash", contents="Explain the difference between an observation and a hypothesis in three sentences.")\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(resp.to_json_dict())\nimport { GoogleGenAI } from "@google/genai";\n\nif (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");\nconst ai = new GoogleGenAI({ apiKey: process.env.AILOOT_API_KEY, httpOptions: { baseUrl: "https://api.ailoot.ai" } });\nconst resp = await ai.models.generateContent({ model: "gemini-3.8-flash", contents: "Explain the difference between an observation and a hypothesis in three sentences." });\nimport { writeFileSync } from "node:fs";\n\nfunction saveResult(data, stem = "result") {\n writeFileSync(stem + ".json", JSON.stringify(data, null, 2));\n console.log(JSON.stringify(data, null, 2));\n const saveBlob = (encoded, suffix, label) => {\n const raw = Buffer.from(encoded, "base64");\n const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;\n const file = `${stem}-${label}.${ext}`;\n writeFileSync(file, raw); console.log("Saved", file);\n };\n for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));\n for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));\n for (const [i, item] of (data.output || []).entries()) {\n console.log("Output", i, JSON.stringify(item));\n if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);\n }\n for (const [ci, candidate] of (data.candidates || []).entries()) {\n for (const [pi, part] of (candidate.content?.parts || []).entries()) {\n console.log("Candidate/part", ci, pi, JSON.stringify(part));\n const blob = part.inlineData || part.inline_data;\n if (blob?.data) {\n const mime = blob.mimeType || blob.mime_type;\n const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";\n saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);\n }\n }\n }\n}\n\nsaveResult(resp);\nfrom google import genai\nfrom google.genai import types\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=genai.Client(api_key=os.environ["AILOOT_API_KEY"],http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\ncount=0\nwith Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for chunk in client.models.generate_content_stream(model='gemini-3.8-flash',contents="Explain observations and hypotheses in three sentences."):\n payload=chunk.to_json_dict()\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n save_result(payload,"stream-chunk-"+str(count))\n count+=1\njson ou streaming pris en charge
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez tous les candidats et toutes les parties, y compris les appels de fonctions, les signatures de raisonnement et les données d’utilisation ; assemblez les fragments du flux dans l’ordre.
Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.
| Champ | Type |
|---|---|
ChampresponseId | Typestring |
ChampmodelVersion | Typestring |
Champcandidates[].content.parts[] | Typetext|inlineData|functionCall|other part |
Champcandidates[].finishReason | Typestring |
ChampusageMetadata | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites Model-specific | Par défaut— |
Champmessages[].content | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Conversation textuelle | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Texte · Texte UTF8
messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages |
Paramètrematerial_types | Contrattext |
Paramètremessages | Contrattableau de messages avec une structure role/content |
Paramètrefile_material | Contratdocument UTF-8 réel inséré sous forme de texte littéral ; aucun identifiant de fichier déduit |
Paramètreoptional_controls | Contratstream |
Paramètrecontrol_scope | ContratConversation textuelle ; stream est un booléen dont la valeur par défaut est false. |
Paramètreoutput_modalities | Contrattext |
Paramètrehosted_operations | Contratfalse |
Paramètremultimodal_input_binding | Contratnull |
Alias de méthode : /chat/completions
Cycle de vie : synchronous_or_streamed
Envoyez l’identifiant exact du modèle avec messages.
La longueur du contexte n’est pas un plafond de sortie.
Un fichier texte peut fournir du texte littéral ; les entrées image/audio/objets fichier nécessitent une liaison exacte.
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model":"gemini-3.8-flash","messages":[{"role":"user","content":"hello"}],"stream":false}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model="gemini-3.8-flash", messages=[{"role":"user","content":"hello"}], stream=False)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\njson ou SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez chaque choix avec son contenu, ses appels d’outils et son raisonnement. En SSE, assemblez les deltas par index de choix et d’outil, puis conservez le motif final de terminaison et les données d’utilisation.
Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.
| Champ | Type |
|---|---|
Champchoices[].index | Typeinteger |
Champchoices[].message.content | Typestring|null |
Champchoices[].message.tool_calls | Typetool_call[] |
Champchoices[].message.reasoning_content | Typestring |
Champchoices[].message.reasoning_details | Typeobject|array |
Champchoices[].finish_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites user, assistant | Par défaut— |
Champmessages[].content | Typestring | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Texte · Texte UTF-8
chaîne messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages, max_tokens |
Paramètreoptional_controls | Contratstream |
Paramètrematerial_types | Contrattext |
Paramètretext_file_material | ContratLisez le document UTF-8 réel et placez son texte dans l’entrée indiquée ou dans la chaîne de contenu du message. |
Cycle de vie : synchronous_or_streamed
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
{\n "model": "gemini-3.8-flash",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'gemini-3.8-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'gemini-3.8-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON ou SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez tous les blocs de contenu, les signatures de raisonnement et les identifiants réels d’utilisation d’outils. Assemblez tous les deltas de blocs SSE ; un premier bloc de texte ne constitue pas la sortie complète.
Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.
| Champ | Type |
|---|---|
Champid | Typestring |
Champmodel | Typestring |
Champcontent[] | Typetext|thinking|tool_use|other content block |
Champstop_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
google/gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites google/gemini-3.8-flash | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites Exemples : system, user, assistant, tool, function Conditions: Ces rôles sont explicitement représentés par les types de compatibilité du code source ; l’ensemble exact des rôles reste propre à chaque modèle. Model-specific | Par défaut— |
Champmessages[].content | Typestring|content_part[]|null | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].tool_calls | Typetool_call[] | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].tool_call_id | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: role=tool ; utilisez l’identifiant réellement renvoyé | Par défaut— |
Champmessages[].name | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].reasoning_content | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Réinjectez le raisonnement réellement renvoyé lorsque ce modèle l’utilise | Par défaut— |
Champmessages[].reasoning_details | Typeobject|array | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champmax_completion_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champstream_options.include_usage | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champstop | Typestring|string[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools | Typefunction_tool[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].type | Typestring | ExigenceFacultatif | Valeurs et limites function Model-specific | Par défaut— |
Champtools[].function.name | Typestring | ExigenceObligatoire | Valeurs et limites S’applique lorsque: outil de fonction fourni | Par défaut— |
Champtools[].function.description | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtools[].function.parameters | TypeJSON_schema | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtool_choice | Typestring|object | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champparallel_tool_calls | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champresponse_format | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning_effort | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champservice_tier | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champinstructions | Typestring | ExigenceFacultatif | Valeurs et limites Champ de compatibilité | Par défaut— |
Champfunctions | Typefunction[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champfunction_call | Typestring|object | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champprompt_cache_options | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmodalities | Typestring[] | ExigenceFacultatif | Valeurs et limites text | Par défaut— |
Champprovider | Typeobject | ExigenceFacultatif | Valeurs et limites Conditions: provider.options est rejeté sur cette route textuelle Ultra | Par défaut— |
Champcache_control.ttl | Typestring | ExigenceFacultatif | Valeurs et limites Conditions: 1h est rejeté dans les emplacements réels du cache de prompt | Par défaut— |
Texte · Texte UTF8
messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages |
Paramètrematerial_types | Contrattext |
Paramètremessages | Contrattableau de messages avec une structure role/content |
Paramètrefile_material | Contratdocument UTF-8 réel inséré sous forme de texte littéral ; aucun identifiant de fichier déduit |
Paramètreoptional_controls | Contratstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Paramètrecontrol_scope | Contratpropre au modèle ; les outils de fonctions de l’utilisateur diffèrent des outils hébergés |
Paramètreoutput_modalities | Contrattext |
Paramètrehosted_operations | Contratfalse |
Paramètremultimodal_input_binding | Contratnull |
Cycle de vie : synchronous_or_streamed
Envoyez l’identifiant exact du modèle avec messages.
La longueur du contexte n’est pas un plafond de sortie.
Un fichier texte peut fournir du texte littéral ; les entrées image/audio/objets fichier nécessitent une liaison exacte.
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "google/gemini-3.8-flash", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='google/gemini-3.8-flash',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='google/gemini-3.8-flash',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson ou SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez chaque choix avec son contenu, ses appels d’outils et son raisonnement. En SSE, assemblez les deltas par index de choix et d’outil, puis conservez le motif final de terminaison et les données d’utilisation.
Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.
| Champ | Type |
|---|---|
Champchoices[].index | Typeinteger |
Champchoices[].message.content | Typestring|null |
Champchoices[].message.tool_calls | Typetool_call[] |
Champchoices[].message.reasoning_content | Typestring |
Champchoices[].message.reasoning_details | Typeobject|array |
Champchoices[].finish_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
google/gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites google/gemini-3.8-flash | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites user, assistant | Par défaut— |
Champmessages[].content | Typestring | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Texte · Texte UTF-8
chaîne messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages, max_tokens |
Paramètreoptional_controls | Contratstream |
Paramètrematerial_types | Contrattext |
Paramètretext_file_material | ContratLisez le document UTF-8 réel et placez son texte dans l’entrée indiquée ou dans la chaîne de contenu du message. |
Cycle de vie : synchronous_or_streamed
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
{\n "model": "google/gemini-3.8-flash",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'google/gemini-3.8-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'google/gemini-3.8-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON ou SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez tous les blocs de contenu, les signatures de raisonnement et les identifiants réels d’utilisation d’outils. Assemblez tous les deltas de blocs SSE ; un premier bloc de texte ne constitue pas la sortie complète.
Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.
| Champ | Type |
|---|---|
Champid | Typestring |
Champmodel | Typestring |
Champcontent[] | Typetext|thinking|tool_use|other content block |
Champstop_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
~google/gemini-flash-latestGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites ~google/gemini-flash-latest | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites Exemples : system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific | Par défaut— |
Champmessages[].content | Typestring|content_part[]|null | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].tool_calls | Typetool_call[] | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].tool_call_id | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: role=tool; use actual returned ID | Par défaut— |
Champmessages[].name | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].reasoning_content | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Round-trip actual returned reasoning where this model uses it | Par défaut— |
Champmessages[].reasoning_details | Typeobject|array | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champmax_completion_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champstream_options.include_usage | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champstop | Typestring|string[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools | Typefunction_tool[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].type | Typestring | ExigenceFacultatif | Valeurs et limites function Model-specific | Par défaut— |
Champtools[].function.name | Typestring | ExigenceObligatoire | Valeurs et limites S’applique lorsque: function tool supplied | Par défaut— |
Champtools[].function.description | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtools[].function.parameters | TypeJSON_schema | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtool_choice | Typestring|object | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champparallel_tool_calls | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champresponse_format | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning_effort | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champservice_tier | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champinstructions | Typestring | ExigenceFacultatif | Valeurs et limites Champ de compatibilité | Par défaut— |
Champfunctions | Typefunction[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champfunction_call | Typestring|object | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champprompt_cache_options | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmodalities | Typestring[] | ExigenceFacultatif | Valeurs et limites text | Par défaut— |
Champprovider | Typeobject | ExigenceFacultatif | Valeurs et limites Conditions: provider.options is rejected on this Ultra text route | Par défaut— |
Champcache_control.ttl | Typestring | ExigenceFacultatif | Valeurs et limites Conditions: 1h is rejected in actual prompt-cache locations | Par défaut— |
Texte · UTF8 text
messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages |
Paramètrematerial_types | Contrattext |
Paramètremessages | Contratmessage array with role/content shape |
Paramètrefile_material | Contratactual UTF-8 document inserted as literal text; no file ID inferred |
Paramètreoptional_controls | Contratstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Paramètrecontrol_scope | Contratmodel-specific; user function tools differ from hosted tools |
Paramètreoutput_modalities | Contrattext |
Paramètrehosted_operations | Contratfalse |
Paramètremultimodal_input_binding | Contratnull |
Cycle de vie : synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base par jeton | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "~google/gemini-flash-latest", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='~google/gemini-flash-latest',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='~google/gemini-flash-latest',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson or SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Champ | Type |
|---|---|
Champchoices[].index | Typeinteger |
Champchoices[].message.content | Typestring|null |
Champchoices[].message.tool_calls | Typetool_call[] |
Champchoices[].message.reasoning_content | Typestring |
Champchoices[].message.reasoning_details | Typeobject|array |
Champchoices[].finish_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Étape suivanteCorrect the indicated fields before a new creation request. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
~google/gemini-flash-latestGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour l’ingénierie logicielle soutenue, les agents et les tâches de connaissance complexes. Il accepte le texte, les images, l’audio, la vidéo et le PDF, renvoie du texte et propose les niveaux de raisonnement low, medium ou high avec des outils et des sorties structurées. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 tokens.
Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour les travaux prolongés d’ingénierie logicielle, les agents à plusieurs étapes et les processus complexes mobilisant les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en ingénierie logicielle et dans les tâches intellectuelles réalisées par des agents. Il accepte le texte, les images, l’audio, la vidéo et le PDF : une tâche peut ainsi combiner un objectif écrit avec les éléments réels nécessaires pour le résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple de reproduction montrent l’échec. Pour un débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur stockée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une longue séquence d’investigation et d’utilisation d’outils conserve une condition d’achèvement précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion low, medium et high règlent la quantité de raisonnement ; medium est la valeur par défaut documentée. Low convient à un brouillon rapide ou à une analyse délimitée, tandis que high vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau minimal. Une tâche de débogage soutenue et une simple extraction de champs nécessitent donc des choix de raisonnement différents plutôt qu’un réglage identique pour chaque requête.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche dans les fichiers, l’ancrage par recherche, l’ancrage Google Maps et URL context, avec Computer Use indiqué comme une capacité en preview. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir un objectif clair et une définition de paramètres : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles preuves étayent la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des réglages de niveau de réflexion à la place de l’ancienne configuration de budget de raisonnement et recommande de supprimer les paramètres d’échantillonnage obsolètes ainsi que les tours model préremplis. Il exige aussi de préserver les signatures de réflexion dans le flux sans état concerné et d’associer les réponses des fonctions à leurs appels par identité et par nom. Ces détails comptent lors de la poursuite d’une tâche à plusieurs étapes : le tour suivant a besoin du contexte antérieur réel plutôt que d’un récit réécrit qui perd le résultat de l’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour user.
Pour le travail de connaissance multimodal, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et précisez leur contribution attendue à la réponse. Une comparaison documentaire peut demander un tableau des différences avec les passages sources ; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles étayent. Une analyse vidéo peut demander une description des événements justifiant un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et l’interaction audio Live appartiennent à des profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 tokens d’entrée et 65 536 tokens de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, tandis que le raisonnement ou un long livrable final doivent tenir dans l’allocation de sortie documentée. Google indique également le caching, le traitement par lots et les traitements Flex et Priority pour ce profil du fabricant. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste relié à sa source.
Les limites possibles comprennent les hallucinations, des lenteurs ou délais d’attente dépassés occasionnels et une consommation de tokens supérieure à un niveau d’effort plus élevé. Sa limite de connaissances est mars 2026, certains domaines restant limités à janvier 2025. Fournissez des preuves actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations ultérieures. Vérifiez les citations de sources, les calculs et le code proposé par rapport aux entrées réelles et aux résultats d’exécution. Le livrable final utile doit distinguer un constat étayé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites ~google/gemini-flash-latest | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites user, assistant | Par défaut— |
Champmessages[].content | Typestring | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Texte · UTF-8 text
messages[].content string
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages, max_tokens |
Paramètreoptional_controls | Contratstream |
Paramètrematerial_types | Contrattext |
Paramètretext_file_material | ContratRead the actual UTF-8 document and put its text in the indicated input or message content string. |
Cycle de vie : synchronous_or_streamed
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base par jeton | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.003 / 1K tokens Sortie · Tokens en sortie $0.015 / 1K tokens Entrée · Lecture du cache $0.0003 / 1K tokens Entrée · Écriture dans le cache — / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens |
Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. Fonctionnement de la réservation et du débit →
{\n "model": "~google/gemini-flash-latest",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': '~google/gemini-flash-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': '~google/gemini-flash-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON or SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Champ | Type |
|---|---|
Champid | Typestring |
Champmodel | Typestring |
Champcontent[] | Typetext|thinking|tool_use|other content block |
Champstop_reason | Typestring|null |
Champusage | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Étape suivanteCorrect the indicated fields before a new creation request. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
Exemple technique en anglais
Diagnose an unsaved form value\n\nReview this form flow: the input displays draft.name; typing updates draft.name; Save sends original.name; after reload the old name reappears. Explain the mismatch and propose a minimal correction in framework-neutral pseudocode. Include a regression scenario that types a new name, saves, reloads, and checks the stored value. Do not claim any browser action occurred.A cause explanation, corrected Save pseudocode and an end-to-end regression scenario.The submitted value comes from the edited draft, and the reload check verifies persistence rather than just the visible input.