Appels d'outils : le modèle propose, votre application décide
Validez les actions demandées par le modèle et renvoyez des résultats utiles.

Une proposition, pas une autorisation
Le modèle peut demander une fonction avec des arguments, mais l'application décide de son exécution. Il ne remplace pas votre système d'autorisation. Consulter une commande et effectuer un remboursement n'ont pas le même niveau de risque.
Commencez par une fonction précise
Définissez un nom clair, une fonction limitée et un schéma d'arguments. Une recherche en lecture seule constitue un bon premier essai. Vérifiez que le modèle et l'interface choisis prennent en charge les outils : les formats de message peuvent varier. N'incluez jamais de secrets dans le prompt.
Un outil devrait accomplir une tâche claire, comme lire l’état d’une commande, plutôt que consulter, modifier et notifier en même temps. Décrivez types, sens et champs requis. Validez côté serveur les valeurs absentes ou invalides, y compris pour les champs facultatifs. Les modèles traitent parfois les définitions différemment : testez celui qui sera déployé.
Le modèle propose des outils ; l’application vérifie les autorisations avant leur exécution.Validez avant d'agir
Analysez et validez les arguments côté serveur, puis vérifiez les droits de l'utilisateur sur la ressource. Ajoutez des limites et des délais, et demandez confirmation pour les actions sensibles. Le résultat d'un outil est également une donnée non fiable : les instructions d'une page ne doivent pas remplacer vos règles.
Un identifiant de commande proposé par le modèle ne prouve pas que l’utilisateur peut la consulter. Le serveur vérifie l’identité, la propriété de la ressource et les règles métier. Un appel d’outil ne contourne pas les droits existants. Pour suppression, paiement, message ou autre effet de bord, présentez l’action et obtenez la confirmation adaptée avant une opération traçable.
Pages, fichiers, résultats de recherche et réponses tierces peuvent contenir des instructions sans rapport ou malveillantes. Distinguez les données des instructions et empêchez-les de modifier les règles d’autorisation ou de demander des secrets. Retournez seulement les informations nécessaires, éventuellement tronquées ou anonymisées. Le code déterministe de l’application garde la responsabilité de l’action finale.
Retournez un résultat et gardez une trace
Renvoyez un résultat concis dans le format attendu, puis laissez le modèle poursuivre si le protocole le permet. Consignez le nom de l'outil, son résultat et un identifiant de requête, sans identifiants secrets ni données privées inutiles. Testez les arguments invalides, les pannes et les appels répétés.
Une tâche peut nécessiter plusieurs appels, mais pas une boucle infinie. Fixez délais, nombre d’appels et échéance globale. Retournez un échec explicite si un service est indisponible afin que le modèle ou l’interface choisisse la suite. Ne faites pas passer un échec pour un succès et ne répétez pas une action coûteuse ou sensible à l’insu de l’utilisateur.
Essayez arguments absents ou invalides, ressource interdite, délai dépassé et appels répétés. Ajoutez un résultat d’outil contenant des instructions malveillantes et vérifiez que les droits ne changent pas. Consignez nom, résultat et identifiant de requête sans secrets complets ni données privées inutiles. Une confirmation sensible ne doit pas pouvoir être contournée par le modèle.
Traiter les propositions du modèle comme des données non fiables
Le nom d’un outil et ses arguments sont une proposition du modèle, pas une autorisation. Vérifiez les champs, types, longueurs et valeurs permises, ainsi que les droits de l’utilisateur. N’insérez jamais directement la sortie du modèle dans une requête SQL, une commande ou une URL arbitraire.
Gardez les outils spécialisés et appliquez les permissions côté serveur. Traitez les pages et documents externes comme des données non fiables et ne renvoyez que les informations nécessaires à la tâche.
Prévoir les échecs et la confirmation humaine
Prévoyez les délais dépassés, résultats vides, refus d’accès et indisponibilités. Signalez honnêtement l’échec au lieu d’inventer une réussite. Limitez les nouvelles tentatives et protégez les opérations ayant des effets contre les doublons.
Pour une action importante, présentez précisément l’opération à confirmer et appliquez l’autorisation côté serveur. Le modèle ne peut pas déclarer lui-même que l’utilisateur a consenti. Journalisez l’identifiant, l’outil, le type de résultat et la durée sans enregistrer systématiquement des secrets.
Commencer par un outil en lecture seule
Pour consulter une commande, identifiez d’abord l’utilisateur connecté. Le serveur vérifie que la commande lui appartient avant de retourner son état. En cas d’absence ou de refus d’accès, l’assistant ne doit pas inventer la réponse.
Testez une commande valide, celle d’un autre utilisateur, un identifiant manquant ou invalide et un délai dépassé. Avant d’ajouter une écriture, vérifiez aussi l’annulation de la confirmation, le double clic et les résultats incertains.
Essayez d’abord une consultation
Pour un outil qui consulte une commande par identifiant, limitez les paramètres, vérifiez côté serveur que l’utilisateur peut voir la commande et retournez un état succinct plutôt que tout le dossier. Testez ensuite un identifiant absent et la commande d’une autre personne. Une future fonction d’annulation doit demander la confirmation adaptée avant d’agir.
Avant une action importante, montrez à l’utilisateur la cible, l’opération et son effet probable. Le serveur vérifie ensuite de nouveau les droits et l’état actuel. La confirmation concerne cette action précise ; une réponse antérieure du modèle ne constitue pas une autorisation. Annoncez le résultat réel, succès ou échec.