Utiliser GPT-6 Astra avec OmniaKey

Ce tutoriel vous conduit d'un nouveau compte OmniaKey à une première requête GPT-6 Astra réussie. Il couvre les appels d'API côté serveur et le CLI Codex. Une clé API OmniaKey n'est pas un abonnement ChatGPT et ne peut pas être saisie sur le site ChatGPT.

Le guide Astra actuel d'OpenAI commence par l'API Responses. Chat Completions reste disponible pour du texte simple, mais les appels d'outils Astra exigent Responses. Les exemples ci-dessous respectent cette limite et lisent la clé dans une variable d'environnement au lieu de la placer dans le code source.

Avant de commencer

Créer une clé API à portée limitée

Connectez-vous à OmniaKey et ouvrez la page des clés API. Créez une clé distincte pour cette intégration, puis définissez un quota et une date d'expiration adaptés au test. Copiez la clé lorsqu'elle s'affiche.

Le compte doit aussi disposer d'un solde utilisable. La création d'une clé prouve que l'identifiant existe, pas que le compte peut financer une requête.

Traitez la clé comme un mot de passe. Ne la commitez pas dans Git, ne l'intégrez pas à une application dans le navigateur et ne l'incluez ni dans une capture d'écran ni dans une conversation.

Placer la clé dans une variable d'environnement

Sous macOS ou Linux :

export OMNIAKEY_API_KEY="your-omniakey-api-key"

Dans PowerShell :

$env:OMNIAKEY_API_KEY="your-omniakey-api-key"

Les exemples du SDK et de Codex ci-dessous lisent cette même variable.

Envoyer la première requête à l'API Responses

Exécutez cette requête dans un terminal :

curl https://api.omniakey.com/v1/responses \
  -H "Authorization: Bearer $OMNIAKEY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "reasoning": {"effort": "medium"},
    "input": "Examinez ce plan de migration. Retournez les deux risques principaux et un test de validation pour chacun."
  }'

Une réponse réussie contient un tableau output, le texte généré et l'utilisation des tokens. Ce premier appel vérifie ensemble la Base URL, la clé, le solde, l'autorisation du modèle, l'ID du modèle et la route Responses.

Après le succès, ouvrez le tableau de bord d'utilisation et confirmez que le modèle enregistré est gpt-6-astra. Examinez les utilisations réelles en entrée, en cache, en raisonnement et en sortie, plutôt que d'estimer le coût à partir du seul texte visible.

Appeler Astra depuis Python

Installez ou mettez à jour le SDK Python officiel d'OpenAI :

python -m pip install --upgrade openai

Créez astra_example.py :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OMNIAKEY_API_KEY"],
    base_url="https://api.omniakey.com/v1",
)

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input="Expliquez ce rapport d'incident, puis listez les trois vérifications suivantes les plus utiles.",
)

print(response.output_text)

Exécutez-le :

python astra_example.py

response.output_text est le champ pratique du SDK qui contient le texte généré. Conservez la réponse complète si vous avez aussi besoin de l'utilisation, du statut ou des éléments d'appel d'outil.

Appeler Astra depuis Node.js

Installez le SDK :

npm install openai

Créez un fichier côté serveur tel que astra-example.mjs :

import OpenAI from "openai";

const apiKey = process.env.OMNIAKEY_API_KEY;
if (!apiKey) throw new Error("OMNIAKEY_API_KEY is required");

const client = new OpenAI({
  apiKey,
  baseURL: "https://api.omniakey.com/v1",
});

const response = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "medium" },
  input: "Examinez cette conception d'API. Trouvez deux modes de défaillance et un test pour chacun.",
});

console.log(response.output_text);

Exécutez-le depuis le shell où la variable d'environnement est définie :

node astra-example.mjs

Exécutez ce code sur un serveur, une machine locale ou un worker de confiance. Une clé incluse dans un bundle frontend est exposée aux visiteurs.

Utiliser GPT-6 Astra dans le CLI Codex

Un provider Codex personnalisé utilise le Responses wire format. Ajoutez ceci au fichier utilisateur ~/.codex/config.toml :

model = "gpt-6-astra"
model_provider = "omniakey"

[model_providers.omniakey]
name = "OmniaKey"
base_url = "https://api.omniakey.com/v1"
env_key = "OMNIAKEY_API_KEY"
wire_api = "responses"

Lancez Codex depuis un shell où la clé est définie :

export OMNIAKEY_API_KEY="your-omniakey-api-key"
codex

Laissez requires_openai_auth non défini. La référence officielle de configuration de Codex le définit comme l'indicateur d'authentification OpenAI ; ce provider personnalisé s'authentifie plutôt avec env_key.

Vérifiez d'abord le modèle affiché par Codex, puis exécutez une petite tâche en lecture seule avant d'autoriser des modifications. Si une requête cURL directe réussit alors que Codex échoue, examinez d'abord la configuration du client.

Réserver Chat Completions aux clients qui en ont besoin

GPT-6 Astra accepte aussi du texte simple avec Chat Completions. Utilisez cette route si le client n'a pas encore adopté Responses :

curl https://api.omniakey.com/v1/chat/completions \
  -H "Authorization: Bearer $OMNIAKEY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "reasoning_effort": "medium",
    "messages": [
      {"role": "user", "content": "Résumez les deux principaux risques de ce plan de déploiement."}
    ]
  }'

Notez la différence de paramètre : Responses utilise reasoning.effort, tandis que Chat Completions utilise reasoning_effort. N'ajoutez pas d'outils Astra à cet exemple Chat Completions. Le guide OpenAI actuel exige Responses pour les appels d'outils Astra.

Choisir le reasoning effort

Astra prend en charge low, medium, high, xhigh et max, mais pas none. Un effort supérieur peut augmenter le raisonnement, la latence et le coût des tokens de sortie sans garantir une réponse correcte. Utilisez la valeur la plus basse qui réussit votre test d'acceptation.

Donner à Astra une tâche vérifiable

Un bon premier prompt précise le but, le contexte utile, les contraintes et le contrôle de fin :

But : examiner le risque de déploiement de cette migration de base de données.
Contexte : PostgreSQL 15, un seul writer en production, rollback à terminer en moins de cinq minutes.
Contraintes : ne pas proposer de commande destructive ; séparer faits vérifiés et hypothèses.
Terminé lorsque : les trois risques principaux, une mesure et un test d'acceptation pour chacun sont fournis.

Pour le code, indiquez aussi les règles du dépôt et la commande exacte qui prouve l'achèvement. Astra suit attentivement les fichiers d'instructions accessibles. Examinez donc AGENTS.md, les skills et les fichiers semblables avant de lui donner accès aux outils.

Corriger les erreurs de configuration courantes

401, unauthorized ou clé API non valide

Confirmez que OMNIAKEY_API_KEY est définie dans le même shell qui exécute la commande. La variable d'environnement contient uniquement la clé ; Bearer appartient à l'en-tête HTTP. Vérifiez aussi que la clé est active et non expirée.

Solde ou quota insuffisant

Vérifiez le solde du compte et le quota propre à la clé. Un compte approvisionné peut encore échouer si la clé limitée a atteint son plafond.

Modèle introuvable ou indisponible

Utilisez l'ID exact gpt-6-astra. Ouvrez la page actuelle du modèle et confirmez que cette clé est autorisée à l'utiliser. Un nom d'affichage tel que GPT 6 n'est pas un ID d'API.

Paramètre non pris en charge

Supprimez temperature, top_p et top_logprobs. Pour Chat Completions, supprimez aussi logprobs ; dans include de Responses, retirez message.output_text.logprobs. Astra ne prend pas ces paramètres en charge.

Réponse incomplete ou sans texte visible

Augmentez max_output_tokens et examinez output_tokens_details.reasoning_tokens. Les tokens de raisonnement consomment le budget de sortie avant que la réponse visible ne soit terminée.

Le chat fonctionne, mais les outils échouent

Déplacez le workflow vers /v1/responses. Commencez par une requête Responses en texte simple, puis ajoutez un outil à la fois et vérifiez la requête, le résultat, le délai et les autorisations. La liste officielle d'OpenAI décrit les capacités directes du modèle ; une passerelle ou un client peut en exposer moins.

Codex continue d'utiliser un autre modèle

Vérifiez model, model_provider, base_url, env_key et wire_api dans la configuration Codex active. Relancez ensuite Codex depuis le shell où OMNIAKEY_API_KEY est définie.

Vérifier le coût avant la production

Exécutez une tâche représentative, confirmez l'enregistrement d'utilisation et intégrez les nouvelles tentatives au coût total. La page du modèle Astra gère le prix OmniaKey actuel. La revue d'Astra sépare ce prix des tarifs OpenAI directs et explique leur seuil de 272K.

Si un plafond interrompt votre travail, le guide des limites de Codex explique comment vérifier la réinitialisation et choisir entre crédits supplémentaires, autre abonnement et API locale facturée séparément.

Références

Toutes les sources officielles OpenAI ci-dessous sont en anglais. Les liens vers la documentation OmniaKey mènent actuellement aussi à des pages en anglais.

• OpenAI : modèle GPT-6 Astra
• OpenAI : guide d'utilisation de GPT-6 Astra
• OpenAI : référence de configuration de Codex
• Démarrage rapide de l'API OmniaKey (en anglais)
• API OmniaKey compatible OpenAI (en anglais)
• Guide OmniaKey pour le CLI Codex (en anglais)