Aller au contenu
English

Traitement en arrière-plan

  • Leçon 12
  • 55 min
  • Module 4 : États d'interaction propres à l'IA

Où nous en sommes

Dans la leçon précédente, le bureau a affiché un brouillon en flux continu et nommé chaque façon dont il peut finir. Mais le travail d'IA d'un nouveau billet n'arrive pas en flux : il s'exécute en arrière-plan pendant quelques secondes, et le bureau reçoit seulement « queued », puis plus rien. Dans cette leçon, nous suivons la tâche et nous disons chaque état en mots simples, d'abord en interrogeant le serveur chaque seconde, puis en le laissant nous prévenir. Un café qui donne un téléavertisseur montre les deux façons.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Permettez à l’agent de suivre le travail d’IA d’un nouveau billet de soutien pendant son exécution en arrière-plan. Présentez les états simplement : en attente, en cours, terminé ou échoué. Interrogez d’abord le serveur chaque seconde, puis laissez-le envoyer chaque changement.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 55 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet ticket-desk après Interfaces en flux continu : npm test se termine par Tests 35 passed (35) (35 tests réussis).
  • L’instantané end-of-m04 dans ~/projects/nextia-learning-labs/C22/snapshots/, pour copier les fichiers de cette leçon.

Testé avec Node.js 24.18 sur macOS (Apple silicon), dans Chromium. Les commandes Windows (PowerShell) et Linux sont fournies, mais non testées.

Vous commandez un repas dans un café achalandé. Le cuisinier a besoin de quelques minutes. La personne à la caisse vous donne donc un reçu numéroté, et vous vous asseyez. Vous avez alors deux façons de savoir quand votre repas est prêt.

Vous pouvez aller au comptoir chaque minute et demander : « Le numéro 42 est-il prêt? » Cela fonctionne sans équipement particulier. Mais la plupart des déplacements sont inutiles. Vous apprenez la nouvelle seulement à votre prochaine visite au comptoir. Ou le café vous donne un petit téléavertisseur. Il vibre dès que votre repas est prêt, sans que vous ayez à demander. Certains cafés offrent une troisième option : un serveur qui discute avec vous à table, dans les deux sens, aussi souvent que nécessaire.

Le bureau des billets fait face au même choix. Cette leçon construit la première solution, puis la compare aux deux autres.

Quand un agent enregistre un nouveau billet, l’API des billets ne fait pas le travail d’IA immédiatement. Elle enregistre le billet, place le travail d’IA dans une file d’attente et répond 202 Accepted. Mettre à l’échelle les API et les charges de travail d’IA a déplacé ce travail dans une file, car il prend plusieurs secondes. Dans les appels enregistrés, la classification, la rédaction d’une réponse et le plongement prenaient respectivement 913, 1 097 et 198 ms. Cela représente environ 2,2 s au total. Un processus fait ensuite le travail en arrière-plan.

À la fin du module 3, le formulaire de nouveau billet affichait la réponse 202, puis s’arrêtait :

Saved as T-500001. The AI work is queued (job 1).

Cette phrase reste à l’écran indéfiniment. L’agent ne découvre jamais l’équipe choisie par l’IA, ni si le travail a échoué. « En attente » n’est que le premier état d’une tâche. C’est un travail qu’un serveur exécute plus tard, avec un état qui change. L’agent doit voir ces changements d’état.

Examinez la tâche avec curl. L’API simulée simule la file : 1,5 s d’attente, plus 2 s pour chaque tâche qui précède. Elle utilise ensuite les durées enregistrées des tâches. Envoyez un billet, puis demandez l’état de sa tâche chaque seconde :

Fenêtre de terminal
curl -X POST http://127.0.0.1:8100/v1/tickets -H "Content-Type: application/json" \
-d '{"customer_id": "C-0022", "subject": "Parcel lost", "body": "It did not arrive."}'
curl http://127.0.0.1:8100/v1/jobs/1

La réponse au POST arrive immédiatement, puis celle de la tâche demandée chaque seconde. Voici les sorties réelles de l’équipe du cours, avec les longues lignes raccourcies. Les lignes --- after … (après…) marquent les secondes :

{"ticket_id":"T-500001","job_id":1,"state":"queued","status_url":"/v1/jobs/1","queued_ahead":0,"estimated_wait_seconds":3.7}
--- after 1 s
{"job_id":1,"ticket_id":"T-500001","state":"queued","attempts":0,…,"started_at":null,"finished_at":null,…}
--- after 2 s
{"job_id":1,"ticket_id":"T-500001","state":"running","attempts":1,…,"started_at":"…",…}
--- after 3 s
{"job_id":1,"ticket_id":"T-500001","state":"running","attempts":1,…}
--- after 4 s
{"job_id":1,"ticket_id":"T-500001","state":"succeeded","attempts":1,…,"finished_at":"…","last_error":null,"result":{"team":"shipping","priority":2,"draft_reply":"Thank you for your message. A member of our team will look at your ticket and reply soon.","embedding_version":"embed-small-384-v1"}}

Toutes les valeurs nécessaires à l’écran sont là. state (état) est passé de queued (en attente) à running (en cours), puis à succeeded (réussi). attempts (tentatives) compte les essais, et result (résultat) contient l’équipe et la priorité. Le bureau doit seulement demander, puis afficher la réponse en mots.

L’idée : suivre la tâche et décrire chaque état en mots

Section intitulée « L’idée : suivre la tâche et décrire chaque état en mots »

Une tâche peut avoir six états. Le contrat de l’API les définit. La leçon Cycle de vie d’une tâche du cours sur la mise à l’échelle les a construits côté serveur. Trois sont des étapes normales. Les trois autres sont des fins qui demandent l’attention de l’agent :

État Ce qui s’est passé Ce que dit le bureau Ce que l’agent peut faire
queued La tâche attend un processus. Le travail d’IA attend dans la file. Environ 4 secondes. Annuler le travail d’IA
running Un processus fait le travail d’IA. L’IA travaille sur le billet : équipe, priorité et premier brouillon. rien : attendre
succeeded Le travail est terminé. Le travail d’IA est terminé. Équipe : expédition, priorité 2. rien à faire
failed La réponse de l’IA était incorrecte, et un nouvel essai donne la même réponse. Réessayer n’aidera pas; une personne doit trier le billet. trier le billet manuellement
dead_letter Le fournisseur n’a pas répondu, cinq fois. La tâche a cessé ses tentatives. Le travail d’IA a échoué plusieurs fois et s’est arrêté. Vous pouvez réessayer plus tard. Réessayer
cancelled L’agent a annulé la tâche pendant qu’elle attendait. Le billet est enregistré sans ce travail. rien à faire

Examinez les deux échecs. failed (échoué) et dead_letter (mis de côté) signifient tous deux « aucun résultat ». Mais les conseils sont opposés. Une tâche failed a reçu une mauvaise réponse, et un nouvel essai donne la même mauvaise réponse. Le bureau n’offre donc pas de bouton Réessayer. Une tâche dead_letter a échoué parce que le fournisseur était indisponible. Elle pourrait réussir plus tard, donc le bureau offre Réessayer. Une tâche mise de côté est une tâche que la file cesse de réessayer et réserve à une personne. Le terme anglais dead letter vient des lettres que la poste ne peut pas livrer.

Un flux des états d'une tâche avec ce que l'écran affiche. queued : En attente, Environ 4 secondes, bouton Annuler le travail d'IA. queued mène à running (En cours, aucun bouton) ou à cancelled (enregistré sans le travail d'IA, aucun bouton). running mène à succeeded (Terminé, équipe et priorité), failed (Réessayer n'aidera pas, une personne trie le billet) ou dead_letter (Plusieurs échecs, bouton Réessayer). Réessayer ramène de dead_letter à queued.
Les états de la tâche vus par l'agent : les mots et la seule action pertinente pour chaque état.
Description textuelle du diagramme

Une nouvelle tâche commence dans queued. L’écran indique « En attente », estime l’attente et offre Annuler le travail d’IA. Depuis queued, la tâche passe à running (« En cours », aucun bouton), ou à cancelled (annulé) si l’agent l’annule. Depuis running, elle se termine dans l’un de trois états. succeeded affiche « Terminé » avec l’équipe et la priorité. failed indique que réessayer n’aidera pas, et une personne trie le billet. dead_letter indique que le travail a échoué plusieurs fois. Il offre Réessayer, ce qui remet la tâche dans queued.

La façon la plus simple de suivre une tâche est l’interrogation périodique (polling). Le bureau envoie la même requête GET à intervalle fixe, jusqu’à ce que la tâche atteigne un état final. C’est la visite au comptoir du café chaque minute. TanStack Query le fait pour vous avec une option, refetchInterval. Voici useJobPolling dans src/features/jobs/useJob.ts :

src/features/jobs/useJob.ts (part)
/** Polling: ask for the job every second until it is final. Simple, and it works everywhere. */
export function useJobPolling(id: number, intervalMs = 1000) {
return useQuery({
queryKey: jobKey(id),
queryFn: ({ signal }) => getJob(id, signal),
refetchInterval: (query) => (query.state.data && isFinal(query.state.data.state) ? false : intervalMs),
staleTime: 0,
});
}

Ici, refetchInterval est une fonction, pas un nombre. Après chaque réponse, TanStack Query lui demande : « Quand dois-je demander à nouveau? » Tant que la tâche s’exécute, la réponse est 1 000 ms. Quand la tâche atteint un état final, la réponse est false, et l’interrogation périodique s’arrête. isFinal() dans src/api/jobs.ts liste les quatre états finaux : succeeded, failed, cancelled et dead_letter.

JobStatus.tsx affiche la réponse : une rangée de trois étapes (En attente, En cours, Terminé), la phrase du tableau et le bouton adapté. Le formulaire de nouveau billet affiche maintenant JobStatus sous « Saved as T-500001. » (enregistré sous T-500001), au lieu de l’ancienne phrase.

  1. Dans ~/projects/ticket-desk, copiez les fichiers de cette leçon depuis l’instantané. Cinq fichiers sont nouveaux; le formulaire de nouveau billet, son test et la page des laboratoires changent.

    Fenêtre de terminal
    S=../nextia-learning-labs/C22/snapshots/end-of-m04
    for f in src/api/jobs.ts src/features/jobs/useJob.ts src/features/jobs/JobStatus.tsx \
    src/features/jobs/JobStatus.test.tsx src/labs/JobLab.tsx \
    src/features/jobs/NewTicketForm.tsx src/features/jobs/NewTicketForm.test.tsx src/labs/LabsPage.tsx; do
    cp "$S/$f" "$f"
    done
  2. Exécutez les tests :

    Fenêtre de terminal
    npm test

    La sortie se termine par :

    Test Files 14 passed (14)
    Tests 38 passed (38)

    Les trois nouvelles vérifications sont dans JobStatus.test.tsx. La première, « polls until the job is done, then stops asking » (interroge jusqu’à la fin, puis s’arrête), prend environ 3 secondes. Elle répond queued, running et succeeded, puis attend encore 1,2 s et vérifie qu’aucune requête n’est arrivée.

  3. Démarrez l’API simulée (npm run api) et le bureau (npm run dev) dans deux terminaux. Ouvrez http://localhost:5173/#/new.

  4. Remplissez le formulaire : client C-0022, objet Parcel lost (colis perdu), message My parcel did not arrive. (mon colis n’est pas arrivé). Cliquez ensuite sur Send ticket (envoyer le billet). « Saved as … » (enregistré sous…) apparaît, et les étapes de la tâche commencent à Waiting (en attente).

    Le formulaire de nouveau billet après l'envoi. Sous le formulaire : Enregistré sous T-500001, dans une boîte verte. Puis le titre Travail d'IA pour T-500001, trois étapes En attente, En cours, Terminé, avec En attente en gras. La phrase Le travail d'IA attend dans la file. Environ 4 secondes., et un bouton Annuler le travail d'IA.
    queued : la première réponse de l'API, maintenant suivie de l'état de la tâche et de la seule action utile. L’image est en anglais.
  5. Observez les étapes pendant environ 4 secondes. Working (en cours) passe en gras, puis Done (terminé), et l’équipe apparaît.

    Le panneau de la tâche : Travail d'IA pour T-500001, les étapes En attente, En cours, Terminé, avec Terminé en gras. Une phrase verte Le travail d'IA est terminé., et la ligne Équipe : expédition, priorité 2.
    succeeded : le résultat que l'ancien formulaire ne montrait jamais. L’image est en anglais.
  6. Arrêtez l’API simulée, puis démarrez-la avec node mock-api/server.mjs --jobs fail. Envoyez un autre billet. Cet échec est simulé : chaque tâche se termine dans failed.

    Le panneau d'une tâche échouée : les étapes avec En cours en gras. Une phrase rouge Le travail d'IA a échoué. Réessayer n'aidera pas; une personne doit trier le billet. Et Détails : ai_bad_answer : la réponse de l'IA ne correspondait pas au format attendu. Aucun bouton.
    failed : le bureau explique pourquoi réessayer est inutile et ne le propose pas. L’image est en anglais.
  7. Arrêtez l’API simulée, puis démarrez-la avec --jobs dead_letter. Envoyez un autre billet. Cette tâche s’exécute environ trois fois plus longtemps, puis s’arrête après cinq tentatives.

    Le panneau d'une tâche mise de côté : les étapes avec En cours en gras. Une phrase rouge Le travail d'IA a échoué plusieurs fois et s'est arrêté. Vous pouvez réessayer plus tard. Détails : ai_unavailable : le fournisseur d'IA n'a pas répondu (5 tentatives), et un bouton Réessayer.
    dead_letter : le fournisseur était indisponible, donc réessayer plus tard peut fonctionner. Seul cet état offre Réessayer. L’image est en anglais.
  8. Cliquez sur Try again (réessayer). L’API simulée remet la tâche dans la file. Cette fois, elle réussit : En attente, En cours, Terminé.

  9. Arrêtez l’API simulée, puis démarrez-la avec npm run api. Envoyez un dernier billet et cliquez immédiatement sur Cancel the AI work (annuler le travail d’IA), pendant que la tâche attend. Le panneau indique : « Vous avez annulé le travail d’IA. Le billet est enregistré sans ce travail. »

L’interrogation périodique a deux coûts, et l’équipe du cours a mesuré les deux dans le navigateur. Pour un nouveau billet, le bureau a envoyé 5 requêtes avant de voir la fin de la tâche. La plupart disaient seulement « toujours en attente » ou « toujours en cours ». Et le bureau a vu la fin en retard. La tâche s’est terminée entre deux requêtes. L’écran a donc affiché « terminé » avec un délai médian de 403 ms après le finished_at de la tâche.

Le téléavertisseur du café représente l’autre solution. Les événements envoyés par le serveur (server-sent events) fonctionnent aussi pour les tâches. Le bureau ouvre une requête GET. Le serveur la garde ouverte et écrit un événement à chaque changement d’état. Ici, EventSource est le bon outil : la requête est un GET et n’a besoin d’aucun en-tête. Avec curl, vous voyez les événements arriver pendant que la requête reste ouverte :

Fenêtre de terminal
curl -N http://127.0.0.1:8100/v1/jobs/1/events
event: state
data: {"job_id":1,"ticket_id":"T-500001","state":"queued","attempts":0,…}
event: state
data: {"job_id":1,"ticket_id":"T-500001","state":"running","attempts":1,…}
event: state
data: {"job_id":1,"ticket_id":"T-500001","state":"succeeded","attempts":1,…,"result":{"team":"shipping",…}}

Lors de l’essai de l’équipe du cours, les trois événements sont arrivés 0, 1,5 et 3,6 secondes après la requête. Le serveur a ensuite fermé la connexion. Dans le bureau, useJobEvents dans src/features/jobs/useJob.ts ouvre la connexion et la ferme quand la tâche atteint un état final :

src/features/jobs/useJob.ts (part)
/** Server-sent events: the server sends each new state; no repeated requests. */
export function useJobEvents(id: number): Job | null {
const [job, setJob] = useState<Job | null>(null);
useEffect(() => {
const source = new EventSource(jobEventsUrl(id));
source.addEventListener('state', (e) => {
const next = JSON.parse((e as MessageEvent).data) as Job;
setJob(next);
if (isFinal(next.state)) source.close();
});
return () => source.close();
}, [id]);
return job;
}

Deux appels à close(), pour deux raisons. Le nettoyage ferme la connexion quand le composant quitte l’écran, comme doit le faire tout effet qui utilise une connexion. Le close() après un état final est important : EventSource se reconnecte automatiquement quand une connexion se termine. C’est utile pour un flux qui ne doit jamais s’arrêter. Pour une tâche terminée, cela ouvrirait le flux à nouveau.

Un diagramme de séquence avec trois participants : le bureau avec interrogation périodique, l'API simulée et le bureau avec événements. Une note : la tâche d'un nouveau billet passe de queued à running, puis à succeeded après environ 3,6 s. L'interrogation périodique envoie GET /v1/jobs/1 et reçoit queued. Le bureau avec événements ouvre GET /v1/jobs/1/events, qui reste ouvert, et reçoit l'événement queued. L'interrogation périodique redemande après 1 s (queued) et 2 s (running); le bureau avec événements reçoit running. L'interrogation périodique demande à 3 s (running). La tâche se termine; le bureau avec événements reçoit succeeded, affiché 29 ms plus tard. L'interrogation périodique demande à 4 s et reçoit succeeded, affiché 403 ms plus tard. Une note : 5 requêtes, puis l'interrogation périodique s'arrête.
Une tâche, deux façons de la suivre. L'interrogation périodique demande cinq fois et apprend la fin à sa prochaine requête; les événements arrivent dès qu'ils se produisent.
Description textuelle du diagramme

La tâche d’un nouveau billet attend environ 1,5 s et s’exécute pendant environ 2 s. Le bureau avec interrogation périodique demande à 0, 1, 2, 3 et 4 secondes. Il reçoit queued, queued, running, running et succeeded : cinq requêtes. Le bureau avec événements ouvre une requête, et le serveur y envoie trois événements. queued arrive immédiatement, running au début du travail, et succeeded à sa fin. Dans les essais mesurés, le bureau avec événements affichait la fin 29 ms après la fin de la tâche. Le bureau avec interrogation périodique l’affichait 403 ms après, à sa prochaine requête.

Le laboratoire des tâches du bureau exécute les deux méthodes côte à côte, sur la même tâche. Il se trouve à http://localhost:5173/#/labs/job. Cliquez sur Send a test ticket (envoyer un billet de test) et observez les deux colonnes :

Le laboratoire des tâches : Laboratoire : suivre une tâche en arrière-plan, un bouton Envoyer un billet de test et deux colonnes. À gauche : Interrogation périodique (une requête chaque seconde), État : succeeded, Requêtes : 5. À droite : Événements envoyés par le serveur (une connexion ouverte), État : succeeded, Requêtes : 1, événements reçus : 3.
Le laboratoire après une tâche : cinq requêtes contre une connexion, pour les trois mêmes états. L’image est en anglais.

L’équipe du cours a mesuré le laboratoire avec un script de navigateur, en trois essais. Le graphique montre les médianes et l’étendue des trois essais :

Interrogation périodique contre événements envoyés par le serveur pour la tâche d'un nouveau billet, dans Chromium sur le portable de l'équipe du cours. D'autres travaux s'exécutaient (3 essais : médiane et étendue). Vos temps seront différents; la tendance reste la même.
Description textuelle du graphique

Deux panneaux. Requêtes pour une tâche : l’interrogation chaque seconde a envoyé 5 requêtes dans chacun des 3 essais; les événements envoyés par le serveur ont utilisé 1 requête. Temps entre la fin de la tâche et l’affichage : l’interrogation périodique affichait la fin après un délai médian de 403 ms, entre 198 et 477 ms. Les événements envoyés par le serveur l’affichaient après un délai médian de 29 ms, entre 4 et 30 ms. La tâche elle-même prenait un temps médian de 3,621 ms entre sa création et sa fin.

Le délai de l’interrogation périodique n’est pas fixe. Il dépend du moment où la tâche se termine entre deux requêtes. Il va de 0 à un intervalle complet, soit environ la moitié en moyenne. Dans ces essais, il allait de 198 à 477 ms.

Un WebSocket est le serveur qui discute avec vous à table. C’est une connexion qui reste ouverte, où les deux côtés peuvent envoyer des messages à tout moment. Le navigateur commence par une requête HTTP normale, puis les deux côtés passent au protocole WebSocket. C’est le bon outil quand le navigateur envoie aussi beaucoup de messages. Par exemple : un clavardage où plusieurs personnes écrivent, un document partagé ou un jeu.

Pour l’état d’une tâche, le navigateur n’envoie rien après la première requête. Les messages vont dans un seul sens, du serveur au navigateur. Un WebSocket ajoute donc du travail sans avantage ici. Il faut un serveur qui utilise le protocole WebSocket, des messages que vous concevez et votre propre mécanisme de reconnexion. Il faut aussi des serveurs mandataires qui le laissent passer. Le bureau des billets n’en utilise pas, et ce cours n’en construit pas. Le tableau compare les trois méthodes :

Interrogation périodique Événements envoyés par le serveur WebSocket
Qui parle le navigateur demande, encore et encore le serveur, sur un seul GET ouvert les deux, sur une connexion ouverte
Requêtes pour une tâche (mesurées) 5 1 1 connexion
Délai après un changement jusqu’à un intervalle (médiane mesurée de 403 ms) presque nul (médiane mesurée de 29 ms) presque nul
Ce qu’il faut au serveur un point de terminaison GET normal un point de terminaison qui garde une réponse ouverte et écrit des événements le protocole WebSocket
Si la connexion coupe la prochaine requête fonctionne EventSource se reconnecte automatiquement votre code rétablit la connexion
Utile pour une courte attente, peu d’écrans, le code le plus simple l’état et la progression venant du serveur des messages fréquents dans les deux sens

Commencez par l’interrogation périodique. Elle fonctionne avec tous les serveurs et à travers tous les serveurs mandataires. Elle ne nécessite aucune connexion ouverte, et TanStack Query l’arrête pour vous. Son coût vient des requêtes : 5 pour chaque nouveau billet de soutien, à raison d’une requête par seconde. Le bureau de Grace compte quelques agents, chacun avec au plus une tâche à l’écran. Ce coût reste donc faible.

Utilisez les événements envoyés par le serveur quand le délai compte, ou quand de nombreux écrans attendent en même temps. Avec 200 agents qui interrogent chacun le serveur chaque seconde, l’API répond à 200 requêtes par seconde. La plupart disent « rien n’a changé ». Les événements ont leur propre coût : chaque écran ouvert garde une connexion au serveur pendant toute l’attente. Les navigateurs limitent aussi à environ six les connexions ouvertes vers un même hôte en HTTP/1.1. Un EventSource qui ne se ferme jamais peut donc bloquer les autres requêtes du bureau.

Kwame demande si le bureau pourrait plutôt attendre le travail de l’IA dans le POST, sans créer de tâche. Le cours Mettre à l’échelle les API et les charges de travail d’IA a mesuré pourquoi cette approche ne convient pas. L’API gardait une connexion à la base de données pendant les 2,2 secondes de traitement de chaque billet. Le quota du fournisseur bloquait des appels sous charge. Le 202 et la tâche gardent l’API rapide, et cette leçon rend la tâche visible.

Erreur courante

L'interrogation périodique ne s'arrête jamais

Symptôme (construit) : la tâche affiche Done (terminée), mais le panneau Network (réseau) du navigateur affiche un nouveau GET /v1/jobs/1 chaque seconde. Cela continue tant que le formulaire reste ouvert. Les compteurs de l’API simulée à http://127.0.0.1:8100/admin/stats montrent que le compteur de la route des tâches augmente.

Cause : refetchInterval: 1000, un nombre fixe. TanStack Query interroge alors le serveur indéfiniment, même après que la tâche a atteint un état final.

Solution : donnez à refetchInterval une fonction qui retourne false pour un état final, comme le fait useJobPolling. Le test « interroge jusqu’à la fin de la tâche, puis arrête de demander » compte les requêtes après la fin. Il échoue quand ce nombre augmente.

Conséquence pour le travail d’IA : chaque écran oublié envoie une requête par seconde. Avec beaucoup d’agents, l’API passe son temps à donner des réponses qui ne changent jamais.

Erreur courante

Réessayer une tâche en échec

Symptôme (construit) : le bureau propose Try again (réessayer) pour chaque tâche en échec. Un agent voit une tâche failed (en échec) et clique à répétition. Le billet reste en attente, sans équipe.

Cause : le bureau traitait failed et dead_letter (arrêt après plusieurs échecs) comme un seul état. L’API accepte de relancer une tâche failed, donc rien n’arrête l’agent. Un modèle qui a donné une mauvaise réponse à un billet en donne généralement une mauvaise à nouveau. Chaque nouvelle tentative coûte donc un autre appel et prolonge l’attente. L’API simulée ne peut pas montrer cet aspect : dans la simulation, chaque tâche relancée réussit. Ce résultat est simulé pour rendre visible le parcours de nouvelle tentative.

Solution : affichez le bouton seulement quand une nouvelle tentative peut aider. Dans JobStatus.tsx, Try again apparaît seulement pour dead_letter. Le texte pour failed indique qu’une personne doit trier le billet. Le test « failed et dead letter ont des affichages différents, et seul dead letter propose Try again » le vérifie.

À vous de jouer : interroger toutes les deux secondes

Section intitulée « À vous de jouer : interroger toutes les deux secondes »

Changez une seule condition : l’intervalle. Dans JobStatus.tsx, remplacez useJobPolling(jobId) par useJobPolling(jobId, 2000). Avant d’envoyer un billet, faites une prédiction : combien de requêtes le bureau enverra-t-il pour une tâche? La fin apparaîtra-t-elle plus tard? Envoyez ensuite un billet et comptez les requêtes jobs dans le panneau Network du navigateur.

Afficher la réponse

Le bureau interroge le serveur à 0, 2 et 4 secondes : 3 requêtes au lieu de 5. L’équipe du cours a mesuré les deux intervalles avec un petit script, sans navigateur. Elle a utilisé poll_interval.mjs, avec 5 passages par intervalle et la même tâche simulée de 3 547 ms :

every 1000 ms: requests 5, 5, 5, 5, 5 (median 5); late 471, 466, 468, 465, 467 ms (median 467); job 3547, 3547, 3547, 3547, 3547 ms
every 2000 ms: requests 3, 3, 3, 3, 3 (median 3); late 460, 460, 461, 461, 464 ms (median 461); job 3547, 3547, 3547, 3547, 3547 ms

Le délai n’a pas augmenté ici, et cette surprise mérite une explication. La tâche s’est terminée à 3,55 secondes. Les deux intervalles prévoient une requête à 4 secondes. Ils ont donc tous deux détecté la fin avec environ 0,45 seconde de retard. Prenez plutôt une tâche qui se termine à 2,1 secondes. Sa fin s’affiche avec 0,9 seconde de retard pour un intervalle d’une seconde. Avec un intervalle de deux secondes, le retard atteint 1,9 seconde. Un intervalle plus long réduit les requêtes, mais augmente le délai dans le pire cas. Rétablissez l’intervalle par défaut avant de continuer.

Vérifiez votre compréhension

La tâche d'un nouveau billet se termine dans l'état failed pour un agent et dead_letter pour un autre. Qu'affiche le bureau pour chacun, et pourquoi ces deux états diffèrent-ils?

Afficher la réponse

Pour failed, le bureau indique « Le travail de l’IA a échoué. Réessayer n’aidera pas; une personne doit trier le billet. ». Il affiche le détail ai_bad_answer, sans bouton. L’IA a répondu, mais sa réponse était fausse, et une nouvelle tentative donne la même mauvaise réponse. Pour dead_letter, il indique « Le travail de l’IA a échoué plusieurs fois et s’est arrêté. Vous pouvez réessayer plus tard. ». Il affiche ai_unavailable, 5 tentatives et un bouton Try again. Le fournisseur n’a pas répondu, ce qui peut changer plus tard. Chaque échec reçoit l’action qui peut aider.

Vérifiez votre compréhension

Faites une prédiction : 200 agents ont chacun un nouveau billet à l'écran, et chaque tâche dure environ 4 secondes. Comparez l'interrogation chaque seconde aux événements envoyés par le serveur : requêtes, connexions ouvertes et délai.

Afficher la réponse

Avec l’interrogation périodique, chaque écran envoie environ 5 requêtes par tâche, soit environ 1 000 requêtes au total. Cela représente environ 200 requêtes par seconde pendant l’exécution des tâches. La plupart répondent « aucun changement ». Aucune connexion ne reste ouverte. Chaque écran affiche la fin avec jusqu’à une seconde de retard (médiane mesurée de 403 ms). Avec les événements envoyés par le serveur, chaque écran ouvre 1 requête qui reste ouverte pendant environ 4 secondes. Cela représente 200 connexions ouvertes en même temps. La fin s’affiche presque aussitôt (médiane mesurée de 29 ms). L’interrogation périodique coûte des requêtes; les événements coûtent des connexions ouvertes.

Vérifiez votre compréhension

Tomás veut un WebSocket pour l'état de la tâche, « parce que c'est la méthode moderne ». Que lui répondez-vous?

Afficher la réponse

L’état de la tâche circule dans un seul sens, du serveur vers le navigateur. Le canal bidirectionnel d’un WebSocket n’apporte donc aucun avantage. Il coûte davantage : un serveur qui utilise le protocole WebSocket, des messages conçus par l’équipe et son propre mécanisme de reconnexion. Les serveurs mandataires doivent aussi le laisser passer. Les événements envoyés par le serveur offrent les mêmes mises à jour rapides avec un GET HTTP normal. La reconnexion est intégrée à EventSource. L’interrogation périodique est encore plus simple et suffit pour quelques agents. Choisissez un WebSocket quand le navigateur envoie aussi des messages fréquents, comme dans un clavardage à plusieurs.

Récapitulatif

  • Une tâche est un travail que le serveur effectue plus tard. La réponse 202 n’est que son premier état. Le bureau la suit jusqu’à succeeded (réussie), failed, dead_letter ou cancelled (annulée), et décrit chaque état en mots.
  • Chaque état reçoit la seule action qui peut aider : Cancel (annuler) pendant l’état queued (en attente), Try again seulement pour dead_letter, et une personne pour failed.
  • L’interrogation périodique demande à nouveau à intervalle fixe. refetchInterval retourne false pour un état final, ce qui l’arrête. Mesures : 5 requêtes pour une tâche, fin affichée avec 403 ms de retard (médiane).
  • Les événements envoyés par le serveur gardent un GET ouvert, et le serveur écrit chaque changement. Mesures : 1 requête, 29 ms. Fermez le EventSource à la fin, car il se reconnecte tout seul.
  • Un WebSocket sert aux messages fréquents dans les deux sens. L’état d’une tâche circule dans un seul sens, donc le bureau n’en a pas besoin.

Ensuite, le brouillon et la tâche sont terminés. L’agent peut-il leur faire confiance? Le bureau montre les sources du brouillon, son incertitude et les situations où une personne doit décider. Il décrit aussi les erreurs avec des mots qui indiquent quoi faire.

Leçon suivante : Une rétroaction digne de confiance