Guide d'appel de fonction GPT-6 Astra : Schémas, validation, tentatives et résultats d'outils

L'appel de fonction permet à GPT-6 Astra de demander du code que votre application contrôle. Le modèle choisit une fonction et propose des arguments ; votre environnement d'exécution les valide, effectue l'opération et renvoie le résultat. La fiabilité dépend moins d'une description astucieuse de l'outil que d'une boucle d'exécution disciplinée.

Définir un contrat strict

OpenAI recommande strict: true. Les schémas stricts exigent additionalProperties: false, et chaque propriété doit apparaître dans required. Représentez une valeur optionnelle comme une union incluant null.

const outils = [{ type: "function", name: "lookup_order", description: "Retourne le statut actuel d'une commande visible par l'utilisateur.", strict: true, paramètres : { type: "objet", propriétés : { order_id: { type: "string", description: "Identifiant de commande canonique" }, include_events: { type: ["booléen", "null"] } }, requis : ["order_id", "include_events"], additionalProperties: false } }];

Gardez les fonctions petites et les noms concrets. Un outil `manage_account` volumineux avec de nombreux modes invite des combinaisons invalides et masque les risques. Préférez `get_account`, `update_shipping_address` et `close_account`, avec une approbation autour des opérations importantes.

## La boucle d'exécution

Dans l'API Responses, un appel demandé apparaît dans `response.output` comme un élément avec `type: "function_call"`, `call_id`, `name` et des `arguments` sous forme de chaîne JSON. L'application analyse et valide les arguments, exécute du code de confiance, puis continue avec un `function_call_output` correspondant.

```ts

SORTIE UNIQUEMENT TRADUCTION :
const first = await client.responses.create({
  model: "gpt-6-astra",
  outils,
  input : "Où se trouve la commande ORD-1042 ?"
});

const outputs = [];
pour (const item of first.output) {
  if (item.type !== "function_call") continue;
  const args = JSON.parse(item.arguments);
  const result = await lookupOrder(args);
  outputs.push({
    type: "sortie_appel_fonction",
    call_id: item.call_id,
    output: JSON.stringify(result)
  });
}

const final = await client.responses.create({
  model: "gpt-6-astra",
  previous_response_id: first.id,
  sorties
});

N’exécutez jamais de noms arbitraires provenant du modèle. Résolvez-les par rapport à un registre fixe. Validez à nouveau dans le code de l’application, même en mode strict : la validité du schéma ne prouve pas l’autorisation, l’existence d’un enregistrement, la conformité aux règles métier ou la sécurité.

Concevoir des résultats d'outils utiles

Retournez le résultat complet le plus petit. Incluez des identifiants stables, le statut, des champs typés et des codes d'erreur lisibles par machine. Évitez de vider une ligne entière de base de données ou une trace de pile.

{
  "headers": {
    "name": "Nom",
    "age": "Âge",
    "email": "Email"
  },
  "rows": [
    {
      "name": "Jean Dupont",
      "age": 30,
      "email": "jean.dupont@exemple.com"
    },
    {
      "name": "Marie Martin",
      "age": 25,
      "email": "marie.martin@exemple.com"
    }
  ],
  "videourl": "https://exemple.com/video/formation.mp4"
}

{ "ok": false, "error": { "code": "ORDER_NOT_VISIBLE", "message": "La commande n'a pas été trouvée dans le compte de l'appelant.", "retryable": false } }

Le message aide le modèle à expliquer ; le code aide la couche d'orchestration à décider. Ne révélez pas si un autre locataire possède un identifiant caché.

## Les nouvelles tentatives nécessitent deux politiques

Les tentatives de transport gèrent les timeouts d'API, les erreurs 429 et les échecs transitoires 5xx. Les tentatives d'outil gèrent vos propres échecs de dépendance. Séparez-les.

Les lectures sécurisées peuvent généralement réessayer avec un backoff exponentiel et une gigue. Les écritures nécessitent une clé d'idempotence et une réconciliation. Si la connexion disparaît après `create_refund`, vérifiez si le remboursement existe avant d'appeler à nouveau. Donnez à chaque action logique un identifiant d'opération stable et stockez l'ID d'appel d'outil avec le résultat.

Ne demandez jamais au modèle seul si une nouvelle tentative est sûre. Le registre d'outils doit déclarer la classe de nouvelle tentative, le délai d'attente et le niveau d'effet secondaire.

## Appels parallèles et ordre

Le modèle peut demander plusieurs appels de fonction. L'exécution parallèle est utile pour des lectures indépendantes, comme vérifier la météo dans trois villes. Elle est dangereuse lorsque l'appel B dépend de l'appel A ou lorsque deux écritures touchent le même enregistrement.

Collectez chaque élément d'appel de fonction ; ne supposez pas qu'il n'y en a qu'un seul. Construisez un exécuteur sensible aux dépendances, ou désactivez/évitez le comportement parallèle lorsque l'ordre est important. Renvoyez chaque résultat en utilisant son propre `call_id`.

## Sélection de l'outil de contrôle

`tool_choice` peut permettre la sélection automatique, exiger un outil, empêcher les outils ou forcer une fonction nommée. Utilisez `auto` pour les agents ouverts, forcez un outil lorsqu'une opération API est l'objectif explicite du point de terminaison, et choisissez `none` lorsque le traitement doit rester exclusivement basé sur le modèle.

Pour les actions visibles par l'utilisateur, un modèle en deux phases est robuste : d'abord préparer et afficher un changement proposé ; puis exécuter un outil distinct confirmé. Cela empêche une phrase amicale de devenir une autorisation implicite.

## Tester le contrat

Créez des cas pour les champs manquants, les optionnels nuls, les énumérations invalides, les identifiants non autorisés, les délais d'attente, les soumissions en double, les échecs partiels, les appels multiples, les sorties volumineuses et les chaînes malveillantes dans les résultats d'outils. Évaluez si la réponse finale reflète avec précision l'échec au lieu de prétendre au succès.

Version du schéma de journalisation, ID d'appel, nom de l'outil, arguments nettoyés, durée, résultat et nombre de tentatives. Gardez les secrets et le contenu sensible hors de la télémétrie.

## Liste de vérification pour la révision de la conception du schéma

Examinez chaque outil comme s'il s'agissait d'une API publique. Les énumérations doivent refléter les valeurs réellement prises en charge plutôt que de demander au modèle d'inventer des chaînes. Les dates nécessitent un format et un fuseau horaire déclarés. Les champs numériques nécessitent des unités et des limites. Les identifiants doivent être canoniques, et non des noms de clients libres lorsqu'une étape de recherche peut résoudre l'ambiguïté. Les descriptions doivent indiquer les préconditions et ce que la fonction ne fait pas.

Évitez les pièges booléens tels que `force`, `override` ou `skip_checks`. Ils réduisent des décisions politiques importantes à un seul bit généré par le modèle. Si une opération exceptionnelle est légitime, exposez-la comme un outil distinct à haut risque avec une autorisation et une approbation plus strictes.

Contrats incompatibles avec la version. Les chaînes de réponse en cours d'exécution peuvent encore contenir des appels ou des résultats façonnés par un schéma plus ancien. Votre exécuteur doit explicitement rejeter les versions non prises en charge et renvoyer une erreur récupérable plutôt que de deviner comment traduire une demande sensible.

Enfin, comparez le résultat de la fonction avec l'affirmation destinée à l'utilisateur. Un outil renvoyant `{ok:false}` ne doit jamais devenir « Terminé. » Les évaluations automatisées doivent inspecter à la fois la trace d'appel et le texte final, car une couche d'outil opérationnellement correcte peut encore être mal représentée par le modèle.

## FAQ

### Le mode strict élimine-t-il le code de validation ?

Non. Cela améliore la conformité structurelle. Votre application continue d'appliquer les permissions, les plages, les invariants et la politique métier.

### Le résultat de l'outil doit-il être au format JSON ?

Le champ de sortie est une chaîne de caractères, donc JSON est une convention pratique pour les résultats structurés. Maintenez le contrat cohérent.

### Quand dois-je forcer un outil ?

Lorsque la finalité du point de terminaison nécessite cette opération et que l’utilisateur l’a autorisée. Ne forcez pas d’appels inutiles simplement pour rendre le comportement déterministe en apparence.

### GPT-6 Astra peut-il exécuter lui-même ma fonction ?

Non. Il émet la demande d'appel ; votre application exécute la fonction et renvoie le résultat.

## Conclusion

TEXT:
Un appel de fonction fiable est un protocole : schéma strict, registre fixe, validation d'application, autorisation, exécution contrôlée, résultat structuré et continuation vérifiée. Ajoutez l'idempotence et la classification des tentatives avant d'activer les écritures. Le modèle propose ; votre système reste responsable de chaque effet.