OpenAI: GPT-6 Astra (batch)

GPT-6 Astra est le modèle d’OpenAI pour le raisonnement exigeant, l’ingénierie logicielle, la recherche et le travail documentaire professionnel. Il combine la compréhension du texte et des images avec l’analyse de longs contextes et des processus guidés par des outils, pour produire un résultat textuel dans un contexte de 1 050 000 tokens.

Ailoot Ultra · Traitement par lots POST /v1/batches openai/gpt-6-astra:batch

À propos du modèle

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.

GPT-6 Astra est le modèle d’OpenAI pour ses tâches de raisonnement et ses travaux professionnels les plus exigeants. Le concepteur le développe pour l’ingénierie logicielle, l’utilisation de l’ordinateur, la recherche, le travail scientifique et la création de documents. Il accepte du texte et des images et génère du texte, notamment des explications, du code et des résultats structurés. Ce profil Astra standard est distinct du mode de raisonnement Pro et des profils Sol et Luna.

Travail de bout en bout

Préparez la mission autour du résultat voulu, des sources pertinentes et des critères d’achèvement. Pour l’ingénierie logicielle, incluez le code, l’échec observé, le comportement attendu et les interfaces à préserver. Pour une analyse professionnelle, fournissez les documents, la décision et les conditions que la conclusion doit traiter. Un brief pratique est : « Comparez ces solutions aux exigences, identifiez les dépendances et produisez une note de décision avec des éléments probants pour chaque constatation importante. »

Pour une tâche visuelle, rendez la source lisible et identifiez si elle montre un état d’interface, un graphique ou une exigence de conception. Demandez le détail visible qui soutient une observation. Un résultat de code ou de document doit rester lié à ces éléments probants plutôt qu’à une action externe supposée.

Instructions et poursuite du travail

Les recommandations d’OpenAI pour Astra préconisent des objectifs clairs, des critères de réussite, des règles de preuve et des conditions d’arrêt. Elles signalent une forte sensibilité aux instructions détaillées présentes dans le contexte et les fichiers accessibles : résolvez donc les consignes contradictoires et indiquez la priorité de la tâche de l’utilisateur. Précisez quand le modèle doit utiliser les informations disponibles, faire une hypothèse raisonnable ou demander un détail manquant qui change le résultat.

Le concepteur recommande aussi d’adapter le style de réponse et la profondeur des vérifications. Décrivez le public et la structure finale d’un document, et exigez une validation pertinente pour la modification lors d’une tâche d’ingénierie. Cela donne au modèle un point d’arrivée explicite sans ajouter de travail sans rapport.

Raisonnement et contexte

Astra prend en charge les efforts de raisonnement low, medium, high, xhigh et max et ne prend pas en charge none. L’effort est distinct du mode de raisonnement standard ou Pro du concepteur. La fiche indique un contexte de 1 050 000 tokens, jusqu’à 922 000 tokens d’entrée et jusqu’à 128 000 tokens de sortie. Sa date limite des connaissances est le 30 avril 2026.

Le raisonnement occupe de l’espace de réponse même si les tokens internes bruts ne sont pas exposés comme une réponse ordinaire. Gardez de la place pour le résultat final et vérifiez l’état de fin lorsqu’un budget est épuisé. Une grande fenêtre nécessite toujours des étiquettes de source, des limites de tâche et des observations pertinentes.

Outils et poursuite des tâches

Le concepteur documente les appels de fonctions par Responses ; Chat Completions ne prend pas en charge les appels de fonctions pour Astra. Ses outils pris en charge comprennent la recherche web et dans les fichiers, la génération d’images, un interpréteur de code, les opérations de ligne de commande et d’application de correctifs, les compétences, l’utilisation de l’ordinateur, les connexions MCP et la recherche d’outils. Structured Outputs et le streaming sont aussi répertoriés. La sortie propre à Astra reste du texte, tandis que les opérations d’outils produisent leurs observations ou résultats respectifs.

Le processus documenté de GPT-6 peut poursuivre l’analyse pendant qu’un outil asynchrone s’exécute, intégrer une réorientation en cours de tour, préserver le raisonnement entre les appels et condenser une longue conversation. L’application exécute ses propres outils et gère les résultats en attente. Conservez l’association entre l’appel d’origine et l’observation afin que la tâche utilise des éléments probants réels.

Un résultat final utile est un travail analytique ou du code achevé dont le fondement et les conditions restantes sont explicites. Vérifiez les énoncés dépendant des sources et utilisez des observations réelles de validation pour le travail exécuté. Gardez le profil Astra nommé et sa plage d’effort prise en charge plutôt que d’emprunter un réglage de réponse directe ou les limites d’un autre modèle.

Ailoot Ultra · Traitement par lots POST /v1/batches openai/gpt-6-astra:batch

openai/gpt-6-astra:batch

OpenAI /openai/gpt-6-astra:batch

Premiers pas

Entrées acceptées: Texte
Résultats: Texte

Disponible dans Ailoot · entrées et méthodes

Ailoot Ultra · Traitement par lots POST /v1/batches

Types d’entrée: text
Types de sortie: text
Format de sortie: JSON results[].response.body intégré

Champ	Type	Exigence	Valeurs et limites	Par défaut
Champ`endpoint`	Type`string`	ExigenceObligatoire	Valeurs et limites /v1/chat/completions	Par défaut—
Champ`model`	Type`string`	ExigenceObligatoire	Valeurs et limites openai/gpt-6-astra:batch	Par défaut—
Champ`requests`	Type`batch_item[]`	ExigenceObligatoire	Valeurs et limites Nombre minimal d’éléments: 1	Par défaut—
Champ`requests[].custom_id`	Type`string`	ExigenceObligatoire	Valeurs et limites	Par défaut—
Champ`requests[].body.messages`	Type`message[]`	ExigenceObligatoire	Valeurs et limites	Par défaut—
Champ`completion_window`	Type`string`	ExigenceFacultatif	Valeurs et limites 24h	Par défaut—
Champ`provider`	Type`object\|null`	ExigenceFacultatif	Valeurs et limites	Par défaut—
Champ`requests[].body.model`	Type`string`	ExigenceFacultatif	Valeurs et limites openai/gpt-6-astra:batch, openai/gpt-6-astra	Par défaut—
Champ`provider.only`	Type`string[]`	ExigenceFacultatif	Valeurs et limites openai	Par défaut—
Champ`provider.allow_fallbacks`	Type`boolean\|null`	ExigenceFacultatif	Valeurs et limites false, null	Par défaut—

Paramètres et cycle de vie de la méthode

Paramètre	Contrat
Paramètre`content_type`	Contratapplication/json
Paramètre`required`	Contratendpoint, model, requests
Paramètre`material_types`	Contrattext
Paramètre`representation`	Contratrequests[] intégré ; chaque élément comporte custom_id et body
Paramètre`request_endpoint_profile`	Contrat/v1/chat/completions
Paramètre`file_material`	ContratL’appelant peut charger localement le contenu JSONL UTF-8 effectif dans requests[]. Aucun paramètre purpose de téléversement, input_file_id ni référence à un fichier n’est utilisé. Si les données du client sont absentes ou vides, la préparation s’arrête avant le POST.
Paramètre`serialization_order`	Contratendpoint, model, provider (si fourni), completion_window (si fourni), requests en dernier
Paramètre`optional_controls`	Contratprovider.only, provider.allow_fallbacks, completion_window
Paramètre`schema_scope`	ContratCorps de requêtes Chat Completions textuelles dans l’enveloppe Batch intégrée documentée.

Cycle de vie : asynchronous

GET /v1/batches/{operation_id} · response.id effectivement renvoyé lors de la création d’origine ; même utilisateur, même clé et même groupe

Tarifs

Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.

Mode rapide: Non précisé Lorsque le mode rapide est sélectionné
Mode Flex: Non précisé Lorsque le mode flex est sélectionné
Effort de raisonnement maximal: Non précisé Lorsque l’effort de raisonnement maximal utilise l’ajustement par défaut (default)
Tarification du cache explicite: Non activé Lorsqu’un cache explicite est demandé

Tarifs Ailoot

Prix par configuration

Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.

Configuration	Barème tarifaire	Tokens de contexte, plus de	Tokens de contexte, jusqu’à la limite incluse	Coût
ConfigurationTarifs de base des tokens	Barème tarifaireTarif de base	Tokens de contexte, plus de—	Tokens de contexte, jusqu’à la limite incluseSans borne supérieure	Coût Entrée · Tokens en entrée $0.01 / 1K tokens Sortie · Tokens en sortie $0.05 / 1K tokens Entrée · Lecture du cache $0.001 / 1K tokens Entrée · Écriture dans le cache $0.0125 / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens
ConfigurationPalier 1 de longueur de requête	Barème tarifaire—	Tokens de contexte, plus de0	Tokens de contexte, jusqu’à la limite incluse272 000	Coût Entrée · Tokens en entrée $0.01 / 1K tokens Sortie · Tokens en sortie $0.05 / 1K tokens Entrée · Lecture du cache $0.001 / 1K tokens Entrée · Écriture dans le cache $0.0125 / 1K tokens Entrée · Écriture dans le cache, 1 h — / 1K tokens
ConfigurationPalier 2 de longueur de requête	Barème tarifaire—	Tokens de contexte, plus de272 000	Tokens de contexte, jusqu’à la limite incluseSans borne supérieure	Coût Entrée · Tokens en entrée $0.02 / 1K tokens Sortie · Tokens en sortie $0.075 / 1K tokens Entrée · Lecture du cache $0.002 / 1K tokens Entrée · Écriture dans le cache $0.025 / 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 →

Exemples de requêtes

Ailoot Ultra · Traitement par lots

curl · jeu de données de référence conservéPython HTTP · données JSONL réelles du clientPython · enregistrer chaque résultat finalisé

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json
from pathlib import Path
body=json.loads('{"endpoint":"/v1/chat/completions","model":"openai/gpt-6-astra:batch","requests":[{"custom_id":"req-0001","body":{"messages":[{"role":"user","content":"Hello!"}],"max_tokens":16}}]}')
Path("batch-request.json").write_text(json.dumps(body,ensure_ascii=False),encoding="utf-8")
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/batches \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @batch-request.json -D batch-response-headers.txt -o batch-create-response.json

import json, os
from pathlib import Path
from urllib.request import Request, urlopen

def prepare_requests(customer_path):
    path = Path(customer_path)
    if not path.is_file(): raise ValueError("Customer JSONL file is missing")
    items = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
    if not items: raise ValueError("Customer JSONL contains no requests")
    ids = set()
    for item in items:
        if set(item) != {"custom_id", "body"}: raise ValueError("Each item needs custom_id and body")
        cid = item["custom_id"]
        if not isinstance(cid, str) or not cid.strip() or cid in ids: raise ValueError("custom_id must be nonempty and unique")
        ids.add(cid)
        if not isinstance(item["body"], dict) or not item["body"].get("messages"): raise ValueError("Supply actual text messages")
        supplied_model = item["body"].get("model")
        if supplied_model is not None and supplied_model not in ['openai/gpt-6-astra:batch', 'openai/gpt-6-astra']: raise ValueError("body.model must be an exact documented caller or wire ID")
    return {"endpoint":"/v1/chat/completions", "model":"openai/gpt-6-astra:batch", "requests":items}

if __name__ == "__main__":
    material = os.environ.get("AILOOT_BATCH_REQUESTS_JSONL", "")
    if not material: raise SystemExit("Set AILOOT_BATCH_REQUESTS_JSONL to your actual customer file")
    body = prepare_requests(material)
    key = os.environ.get("AILOOT_API_KEY", "")
    if not key: raise SystemExit("Set AILOOT_API_KEY")
    request = Request("https://api.ailoot.ai/v1/batches", data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers={"Authorization":"Bearer " + key, "Content-Type":"application/json"}, method="POST")
    with urlopen(request) as response:
        raw = response.read()
        Path("batch-create-response.json").write_bytes(raw)
        print(raw.decode("utf-8"))

import json
from pathlib import Path
raw = Path("batch-status-response.json").read_bytes()
response = json.loads(raw)
if response.get("status") != "completed":
    raise SystemExit("Keep the original operation; read its status without resubmitting")
results = response.get("results")
if not isinstance(results, list) or not results:
    raise SystemExit("Preserve the original response; completed results are missing")
Path("batch-results.jsonl").write_text("".join(json.dumps(item, ensure_ascii=False) + "\n" for item in results), encoding="utf-8")
# Preserve batch-status-response.json with aggregate usage and every result/error.

Recevoir et enregistrer les résultats

Ailoot Ultra · Traitement par lots

JSON results[].response.body intégré

GET /v1/batches/{operation_id}

Vérifier l’état de la tâche

curl · état de l’opération d’origine

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
BATCH_OPERATION_ID="$(python3 - <<'PY_ID'
import json
from pathlib import Path
from urllib.parse import quote
response = json.loads(Path("batch-create-response.json").read_text(encoding="utf-8"))
operation = response.get("id")
if not isinstance(operation, str) or not operation: raise SystemExit("No actual original operation ID; preserve the response and do not resubmit")
print(quote(operation, safe=""))
PY_ID
)"
curl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/batches/$BATCH_OPERATION_ID" \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o batch-status-response.json

Conserver tous les résultats terminés

Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.

Conservez l’intégralité du JSON de statut d’origine, chaque résultat/custom_id et le corps complet de la réponse ou de l’erreur. Enregistrez les results[] terminés au format JSONL sans filtrage.

Si la réponse d’origine doit être vérifiée

Conservez l’identifiant de l’opération d’origine. La réponse 503 result_pending_check contient X-Should-Retry:false ; ne soumettez jamais à nouveau un lot d’origine dont l’issue est inconnue.

Champs de la réponse

Champ	Type
Champ`results[].custom_id`	Typestring
Champ`results[].response.body.choices[].message.content`	Typestring\|null
Champ`results[].error`	Typeobject\|null
Champ`usage`	Typeobject\|null
Champ`id`	Typestring
Champ`model`	Typestring
Champ`endpoint`	Typestring
Champ`status`	Typestring
Champ`request_counts`	Typeobject
Champ`results[].id`	Typestring
Champ`results[].response.status_code`	Typeinteger
Champ`results[].response.request_id`	Typestring

Erreurs et étapes suivantes

Réponse	Condition	Étape suivante
Réponse400 · `invalid_request_error`	ConditionEnveloppe intégrée documentée invalide, clés dupliquées, identité d’élément incorrecte ou conflit avec les capacités configurées du modèle.	Étape suivanteCorrigez les champs indiqués avant toute nouvelle soumission.
Réponse401 · `authentication_error`	ConditionClé API invalide.	Étape suivanteUtilisez la clé Ailoot autorisée.
Réponse403 · `permission_error`	ConditionGroupe de traitement par lots indisponible.	Étape suivanteVérifiez les droits d’accès de la clé/du groupe.
Réponse422 · `invalid_request_error`	ConditionLe traitement par lots est facturé sur le solde ; la création via un abonnement est refusée.	Étape suivanteUtilisez le groupe autorisé dont la facturation est prélevée sur le solde.
Réponse422 · `price_unavailable`	ConditionImpossible d’établir un devis pour les données d’entrée du traitement par lots.	Étape suivanteConservez la réponse ; utilisez les données d’entrée documentées pour cette famille.
Réponse402 · `billing_error`	ConditionRéserve pour le traitement par lots indisponible.	Étape suivanteRéglez les conditions d’admission avant une nouvelle requête.
Réponse503 · `price_unavailable`	ConditionPrix de la méthode Batch/tarifs natifs indisponibles.	Étape suivanteConservez la réponse ; ne substituez pas d’autres prix.
Réponse503 · `api_error`	ConditionRoute exacte du fournisseur indisponible.	Étape suivanteConservez la réponse pour réparer la route.
Réponse503 · `result_pending_check`	ConditionLe résultat d’origine nécessite une vérification ; X-Should-Retry:false.	Étape suivanteConservez l’operation_id/id d’origine et consultez son statut ; ne répétez jamais le POST d’origine.
Réponse404 · `not_found`	ConditionOpération de suivi du traitement par lots absente ou appartenant à une autre identité.	Étape suivanteUtilisez l’id exact d’origine avec le même utilisateur, la même clé et le même groupe.

Alias

Alias du modèle

Ailoot Ultra openai/gpt-6-astra:batch

Alias des chemins de méthode

Utilisez les chemins de méthode indiqués ci-dessus.

ID d’appel associés

openai/gpt-6-astra:batch

FAQ · OpenAI: GPT-6 Astra (batch)

Quelles entrées et quels résultats sont disponibles ?: POST /v1/batches · openai/gpt-6-astra:batch: text → text
Quels champs la requête utilise-t-elle ?: POST /v1/batches · openai/gpt-6-astra:batch: endpoint, model, requests, completion_window, provider
Quelles limites s’appliquent ?: POST /v1/batches · openai/gpt-6-astra:batch: requests.min_items: 1

OpenAI: GPT-6 Astra (batch)