# Agent D-ID

> Intégrez un avatar IA parlant dans votre projet PandaSuite avec le composant Agent D-ID. Ce chatbot conversationnel parle à vos visiteurs avec un visage et une voix, ses Client Tools deviennent des événements, et il peut naviguer dans vos écrans, chercher dans vos données et répondre avec Renvoyer une valeur.

https://docs.pandasuite.com/fr/essentials/components/d-id-agent/

**Le composant Agent D-ID intègre dans votre projet un avatar conversationnel IA, un chatbot avec un visage et une voix. Le visiteur lui parle, et l'agent peut agir en retour sur votre projet : changer d'écran, lire vos données, déclencher n'importe quelle action que vous avez configurée.**

> **Note**
>
> Ce composant nécessite un compte [D-ID](https://www.d-id.com/) et un agent
> déjà créé dans le Studio D-ID. L'avatar, la voix, la personnalité et la base
> de connaissances restent chez D-ID : le composant amène cet agent dans votre
> projet et le relie à vos écrans et à vos données. Pour agir sur votre projet,
> l'agent doit être un agent V4 (Expressive).

## Comment l'agent IA et votre projet s'articulent

La plupart des composants attendent que votre projet leur dise quoi faire. Celui-ci fonctionne aussi dans l'autre sens, et c'est l'idée à garder en tête avant tout le reste.

Le partage des rôles est simple :

- **La conversation appartient à D-ID.** L'agent écoute, comprend, décide quoi dire, et le dit avec le visage et la voix que vous avez choisis dans le Studio D-ID. Les exemples ci-dessous prennent un guide de musée, mais le même schéma convient à un catalogue produit, à une application de formation ou à une borne d'accueil.
- **L'application appartient à PandaSuite.** Vos écrans, vos collections, votre [Datastore](https://docs.pandasuite.com/fr/essentials/data/datastore/), vos actions.

L'agent est piloté par un modèle d'intelligence artificielle, et la charnière entre les deux mondes est un **Client Tool**. Chez D-ID, un Client Tool est une capacité que vous promettez à l'agent : un nom, une description, et une liste d'arguments. L'agent ne sait pas comment le tool fonctionne. Il sait seulement que, lorsque la conversation s'y prête, il peut demander son exécution, avec des arguments remplis à partir de ce que le visiteur a dit.

Dans PandaSuite, cette promesse devient un **événement du composant**. L'agent appelle le tool, l'événement se déclenche avec les arguments du tool, et les actions que vous y avez attachées s'exécutent. Si l'agent attend quelque chose en retour, l'une de ces actions lui répond.

Un aller-retour complet ressemble donc à ceci :

**Le visiteur demande** → **L'agent appelle un tool** → **L'événement se déclenche** → **Vos actions s'exécutent** → **Renvoyer une valeur répond** → **L'agent parle**

Tout ce qui suit est une façon de mettre en place une partie de cette boucle.

## Ajouter et configurer le composant

Cliquez sur **Composants** et ajoutez le composant **Agent D-ID** à votre écran. C'est un composant visuel : il affiche l'interface officielle D-ID, avatar et contrôles compris, dans la zone que vous lui donnez.

### Étape 1 : renseigner votre clé API

Dans le panneau **Propriétés**, collez votre **Clé API**. Vous la trouverez dans votre compte D-ID, sous **Settings** > **API Key**.

[Image : Propriétés de l'Agent D-ID : Clé API, Agent et bouton Actualiser, Domaines personnalisés, Connexion automatique, Orientation, Identifiant externe]

> **Info**
>
> La clé API est utilisée dans PandaSuite Studio uniquement : pour lister vos
> agents, pour lire et écrire les tools et le prompt de l'agent, et pour créer la clé d'accès
> qu'utilisera votre projet publié. Elle n'est jamais embarquée dans le projet
> publié, et n'atteint jamais vos visiteurs.

### Étape 2 : choisir votre agent

Cliquez sur **Actualiser** à côté de la propriété **Agent**. Le composant demande à D-ID les agents de votre clé et remplit la liste déroulante. Choisissez celui que vous voulez.

À côté de chaque nom, la liste indique le type de l'agent. Choisissez-en un `expressive` : seuls les agents V4 (Expressive) appellent des Client Tools. Un agent `talk` ou `clip` parle toujours, mais n'agit jamais sur votre projet, et le composant vous le rappelle sous **Client tools**.

Cliquez de nouveau sur **Actualiser** chaque fois que vous créez un nouvel agent dans le Studio D-ID, pour que la liste se mette à jour.

Si la liste reste vide, la clé n'appartient pas au compte propriétaire de l'agent. Vérifiez-la dans votre compte D-ID puis appuyez de nouveau sur **Actualiser**.

### Étape 3 : synchroniser

Double-cliquez sur le composant pour l'ouvrir, puis appuyez sur **Sync**.

Vous êtes maintenant à l'intérieur du composant. **Sync**, les client tools et le prompt de l'agent se trouvent ici. Le panneau **Propriétés** et le panneau **Actions** restent à l'extérieur : utilisez le fil d'Ariane en haut de l'espace de travail pour en ressortir. Vous ferez plusieurs fois l'aller-retour.

La synchronisation est le moment où le composant apprend ce que votre agent sait faire. En une passe, elle :

- rafraîchit la liste de vos agents, comme le fait **Actualiser**, et s'arrête si celui que vous avez choisi n'y est plus,
- lit les **Client Tools** de l'agent et déclare chacun comme un événement du composant,
- lit le prompt de l'agent dans le champ **Agent prompt**,
- crée, ou réutilise, la **Client Key** D-ID qui permet à votre projet publié de parler à l'agent,
- utilise la vignette de l'agent comme image du composant lorsqu'il parvient à la lire, pour que vous le reconnaissiez sur l'espace de travail.

Vous devriez maintenant voir le nom de l'agent en haut du composant, la date de la dernière synchronisation, et la liste de ses client tools avec leurs arguments.

[Image : Composant après une synchronisation : nom de l'agent et date, bouton Sync, champ Agent prompt, et client tools list_screens et change_screen]

> **Info**
>
> Le panneau interne du composant (**Sync**, **Agent prompt**, **Client tools**)
> est en anglais, comme le Studio D-ID auquel il parle. Les propriétés, les
> événements et les actions du composant, eux, suivent la langue de PandaSuite
> Studio.

> **Attention**
>
> Appuyez de nouveau sur **Sync** après avoir changé la propriété **Agent**. La
> configuration est liée à l'agent pour lequel elle a été synchronisée : tant
> que vous ne l'avez pas fait, le composant refuse de s'exécuter et affiche la
> raison.
>
> Appuyez dessus également après avoir modifié un tool ou le prompt chez D-ID.
> Ce cas-là échoue en silence : le composant conserve les définitions de la
> dernière synchronisation, et un argument nouvellement ajouté n'atteint tout
> simplement jamais vos actions.

## Laisser l'agent IA agir sur votre projet

### Un Client Tool est un événement

Après une synchronisation, chaque client tool de l'agent apparaît dans le panneau **Actions** du composant, exactement comme un événement déclencheur natif. Attachez-y les actions de votre choix.

[Image : Sélecteur de déclencheurs : déclencheurs natifs du composant, puis les client tools list_screens et change_screen, déclencheurs à part entière]

Les arguments du tool voyagent avec l'événement. Dans n'importe quelle action de cette liste, ouvrez la fenêtre de data binding et choisissez **Depuis l'événement** : les arguments s'y trouvent, sous leurs propres noms, prêts à être liés. Un argument dont le nom entrerait en conflit avec un nom réservé apparaît sous un alias, que la fiche du tool précise.

**Exemple.** Une application Museum Explorer possède un tool `search_exhibits(query)`. Un visiteur dit « avez-vous quelque chose sur les volcans ? », l'agent appelle `search_exhibits` avec `query` valant `volcans`, et l'événement `search_exhibits` se déclenche dans votre projet en portant ce mot. Vous y attachez une action qui lance une [Recherche](https://docs.pandasuite.com/fr/essentials/components/search/), et vous liez son **Terme de recherche** avec **Depuis l'événement** → **query**.

La recherche se lance, mais l'agent n'entend toujours rien au sujet des volcans. Lui dire ce que vous avez trouvé est une étape distincte, et c'est la section suivante.

### Répondre à l'agent avec Renvoyer une valeur

Certains appels de tool sont des questions. L'agent demande, attend, et énonce ce qu'il reçoit.

Pour répondre, ajoutez l'action [Renvoyer une valeur](https://docs.pandasuite.com/fr/essentials/interactions/interactive-actions/#renvoyer-une-valeur) à la liste d'actions de l'événement et remplissez son paramètre **Réponse**. Liez-le à tout ce que votre projet sait produire : une collection, un champ de Datastore, le résultat d'une recherche, une simple constante.

[Image : Renvoyer une valeur sur le déclencheur list_screens, Réponse liée à la liste des écrans, à côté du panneau Actions et de ses deux tools]

Une liste contient au plus un **Renvoyer une valeur** : une fois que vous l'avez ajouté, Studio ne le propose plus pour cette liste. Placez-le où vous voulez dans la liste. Il répond à l'appel, et les actions qui le suivent s'exécutent quand même : vous pouvez répondre vite puis continuer.

> **Astuce**
>
> Certains tools sont de pures questions et n'ont besoin de rien d'autre. Un tool qui indique simplement à
> l'agent ce que contient votre projet tient en une seule action : **Renvoyer
> une valeur**, avec **Réponse** liée à la collection qui est derrière.

Si un événement ne comporte pas de **Renvoyer une valeur**, l'agent reçoit un simple `ok` une fois la liste d'actions terminée, sauf si l'une de ces actions a échoué, auquel cas l'agent est informé de l'échec de l'appel. C'est la bonne réponse pour un tool qui agit au lieu d'informer, comme un changement d'écran.

### Nommer vos tools dans le prompt de l'agent

C'est l'étape qui surprend, et cela mérite d'être dit clairement : **un tool vers lequel rien dans le prompt ne pointe reste inutilisé.** Un tool parfaitement synchronisé, avec des actions parfaites derrière lui, attend que les instructions donnent à l'agent une raison d'y recourir.

Nommer le tool est la façon la plus sûre, et celle vers laquelle revenir quand l'agent ignore un tool que vous attendiez. Inviter le comportement fonctionne aussi, lorsque la description du tool est elle-même assez explicite : un agent à qui l'on demande de naviguer entre les écrans pour illustrer son propos trouvera un tool décrit par « Change the screen to illustrate what you are saying ». Ce qui ne fonctionne jamais, c'est le silence.

Le champ **Agent prompt** du composant montre les instructions de l'agent telles que D-ID les conserve, lues à la dernière synchronisation. Modifiez-les ici puis appuyez sur **Save prompt** : le texte est enregistré chez D-ID, pour cet agent.

Écrivez les tools dans les instructions en langage clair, comme vous le feriez pour un nouveau guide :

> Quand un visiteur demande ce qu'il y a à voir, appelle `list_screens` et décris les résultats. Quand il en choisit un, appelle `change_screen` avec l'écran correspondant pour que l'application suive la conversation.

> **Note**
>
> D-ID écrit dans les instructions des marques comme `$[knowledge_search]`
> lorsqu'un tool est inséré depuis son propre éditeur. C'est ainsi que D-ID
> nomme le tool dans le prompt : si vous en supprimez une, l'agent cesse
> d'appeler ce tool. Laissez-les telles quelles.

### Créer un Client Tool sans quitter PandaSuite

Vous n'avez pas besoin de quitter PandaSuite pour donner une nouvelle capacité à l'agent. Dans le composant, appuyez sur **Create client tool**. Un panneau s'ouvre avec :

- **Name** : le nom qu'emploiera l'agent. Lettres, chiffres, `_` et `-`, jusqu'à 64 caractères. Ni espaces ni accents : écrivez `list_screens`, pas `list screens`.
- **Description** : ce que fait le tool, dans les termes de l'agent, de 1 à 500 caractères. C'est ce que l'agent lit pour décider s'il doit l'appeler.
- **Arguments** : une ligne par argument, chacune avec un nom, un type, une description et une case **Required**. Un nom d'argument commence par une lettre, puis accepte lettres, chiffres ou `_`. Pas de `-` ici, contrairement au nom du tool.

[Image : Éditeur de client tool de change_screen : Name, Description, un argument Screen de type Page, case Required cochée, puis Save changes]

Appuyez sur **Save changes**. Le tool est créé sur votre compte D-ID, attaché à votre agent et déclaré comme événement du composant d'un seul geste.

Cinq types d'arguments sont disponibles, parce qu'un argument doit être quelque chose qu'un modèle de langage sait produire :

| Type          | Ce que l'agent envoie                       | Usage typique                                                         |
| ------------- | ------------------------------------------- | --------------------------------------------------------------------- |
| **String**    | du texte                                    | une requête de recherche, un nom, une réponse libre                   |
| **Number**    | un nombre                                   | une quantité, une année, une note                                     |
| **Boolean**   | `true` ou `false`                           | un oui ou un non                                                      |
| **Page**      | un écran de votre projet                    | la navigation, les visites guidées, « emmenez-moi aux volcans »       |
| **Reference** | un élément d'une collection de votre projet | une exposition, un produit, une question : « parlez-moi de celle-ci » |

Les trois premiers sont des valeurs ordinaires. Les deux derniers pointent vers votre projet, et c'est là que les choses deviennent intéressantes.

**Page** arrive dans vos actions comme un véritable écran, que vous pouvez lier directement dans **Changer d'écran**. L'agent doit encore savoir quels écrans existent : donnez à un tool `change_screen` un argument de type **Page**, associez-le à un tool `list_screens` qui distribue les écrans, et orientez le prompt vers les deux.

**Reference** fait pour vos données ce que **Page** fait pour vos écrans, et mérite une section à part.

### Laisser l'agent choisir un élément d'une collection

Un grand guide de musée ne donne pas un écran à chaque exposition. Une collection contient les expositions, et un seul écran de détail affiche celle qui est sélectionnée. Pour ouvrir cet écran sur la bonne exposition, l'agent doit désigner un élément de la collection. C'est le rôle d'un argument **Reference**.

Lorsque vous choisissez **Reference** comme type d'un argument, une seconde liste apparaît dessous, **Choose a collection**, qui propose les collections de votre [Datastore](https://docs.pandasuite.com/fr/essentials/data/datastore/). Choisissez celle que désigne l'argument. Si votre projet n'en contient encore aucune, la liste vous le signale : ajoutez d'abord un Datastore.

Dans vos actions, l'argument arrive sous **Depuis l'événement** comme une véritable [Référence](https://docs.pandasuite.com/fr/essentials/data/data-types/#référence), et vous l'utilisez comme n'importe quelle autre. Liez-le tel quel, ouvrez ses champs (la fenêtre de data binding [suit la référence](https://docs.pandasuite.com/fr/essentials/data/data-binding/#suivre-une-référence), donc `exhibit` puis `name` donne le nom de l'exposition choisie), ou enregistrez-le dans une propriété **Référence** de votre Datastore avec **Créer/Modifier une donnée (Local)** pour qu'une [page de détail](https://docs.pandasuite.com/fr/essentials/data/dynamic-page-from-collection-item/) affiche cette exposition.

Comme pour les écrans, l'agent ne peut pas choisir parmi des expositions qu'il n'a jamais vues, et le schéma est le même. Un tool `list_exhibits`, auquel répond **Renvoyer une valeur** avec sa **Réponse** liée à la collection, donne à l'agent chaque exposition avec son identifiant. Un tool `show_exhibit` reprend cet identifiant par son argument `exhibit`. La liste voyage dans la réponse, et seul le choix voyage dans l'argument.

La collection est un réglage de votre projet, pas du tool. Le même tool peut pointer vers une autre collection sur un autre agent ou dans un autre projet, et la changer avec **Edit** ne concerne que ce projet. C'est aussi pourquoi un tool attaché depuis le Studio D-ID affiche `no collection` à côté de son argument : appuyez sur **Edit** et choisissez-en une.

### Ajouter un tool que votre compte possède déjà

Un tool n'appartient pas à un agent. Il vit sur votre compte D-ID, où chacun de vos agents peut l'utiliser : le tool `list_exhibits` écrit pour un guide sert tout aussi bien au suivant. Plutôt que de le recréer, appuyez sur **Add existing tool**. C'est aussi ce que vous suggère le composant si vous tentez de créer un tool sous un nom que votre compte utilise déjà.

Le panneau liste les tools de votre compte que cet agent n'a pas encore. Cherchez, cochez ceux que vous voulez, et appuyez sur **Add to the agent**. Un tool doté d'un argument **Reference** demande d'abord sa collection, puisque ce choix appartient à ce projet. Les tools arrivent ensemble ou pas du tout : si l'un d'eux ne peut pas être ajouté, rien ne change et le panneau vous indique lequel.

Une chose reste en arrière : une valeur fixée sur un argument dans le Studio D-ID. Elle valait pour l'autre agent. Fixez-la de nouveau pour celui-ci dans le Studio D-ID si vous en avez besoin, puis appuyez sur **Sync**.

### Modifier, détacher ou supprimer un tool

Puisque les tools sont partagés, chaque modification pose la même question : concerne-t-elle cet agent, ou tous les agents de votre compte ? Chaque bouton y répond sans ambiguïté.

**Edit** rouvre le panneau sur la définition du tool. Enregistrer réécrit le tool chez D-ID, et tous les agents qui l'utilisent reçoivent la nouvelle version.

**Detach** ne concerne que cet agent. Le tool quitte l'agent, son événement et ses actions quittent votre projet, et le tool reste sur votre compte, prêt à revenir par **Add existing tool**.

**Delete from your account**, en bas du panneau **Edit**, concerne tous les agents. Le tool est retiré de chacun d'eux, puis supprimé chez D-ID, avec son événement et ses actions dans ce projet. Un projet qui l'utilisait avec un autre agent conserve ses actions : à sa prochaine synchronisation, le tool y apparaît comme **Not on the agent**.

**Detach** et **Delete from your account** demandent tous deux un second clic avant d'agir.

Avant toute écriture, le composant relit D-ID et refuse d'écraser ce qui y a changé depuis votre dernière synchronisation. Dans ce cas, appuyez sur **Sync** puis modifiez de nouveau.

Un tool signalé **Not on the agent** est un tool que votre projet connaît encore mais que l'agent n'a plus, par exemple parce qu'il a été détaché dans le Studio D-ID. Son événement et ses actions sont conservés, et vous décidez : **Add to the agent** le remet en place, **Remove** le retire de votre projet sans toucher à D-ID. Renommer un tool chez D-ID ne vous coûte jamais vos actions.

> **Info**
>
> Un tool créé dans le Studio D-ID avec une forme d'arguments que cet éditeur ne
> sait pas exprimer reste modifiable ici pour son nom et sa description. Ses
> arguments se modifient dans le Studio D-ID.

## Piloter l'agent IA depuis votre projet

La conversation n'est pas à sens unique. Utilisez **Agir sur un composant** sur le composant Agent D-ID pour accéder à :

| Action            | Ce qu'elle fait                                                      |
| ----------------- | -------------------------------------------------------------------- |
| **Parler**        | Fait dire à l'agent un **Texte**, que vous pouvez lier à vos données |
| **Lire un audio** | Fait jouer à l'agent un fichier audio depuis une **URL audio**       |
| **Interrompre**   | Arrête immédiatement l'agent de parler                               |
| **Micro**         | **Couper**, **Rétablir** ou **Basculer** le micro du visiteur        |
| **Haut-parleur**  | **Couper**, **Rétablir** ou **Basculer** le son de l'agent           |

**Parler** sert à faire dire un texte à voix haute à l'agent : il accueille un visiteur en le nommant, énonce un résultat, ou commente l'endroit où l'application vient d'arriver. L'agent parle au visiteur avec sa propre voix, et le texte peut venir de n'importe où dans votre projet.

## Réagir à la conversation

### Événements déclencheurs

En plus des client tools, le composant déclenche ces [événements déclencheurs](https://docs.pandasuite.com/fr/essentials/interactions/triggers/) :

| Événement                     | Se déclenche quand                                                                                     | Porte                                           |
| ----------------------------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------------------- |
| **Session démarrée**          | la connexion à l'agent est établie                                                                     |                                                 |
| **Session terminée**          | la connexion est fermée, perdue ou échoue                                                              | **Raison** : `disconnected`, `closed` ou `fail` |
| **L'agent commence à parler** | l'agent commence à parler                                                                              |                                                 |
| **L'agent cesse de parler**   | l'agent cesse de parler                                                                                |                                                 |
| **L'agent réfléchit**         | l'agent commence à générer une réponse                                                                 |                                                 |
| **Erreur**                    | D-ID signale une erreur, ou une action n'a pas pu s'exécuter parce que l'agent n'est pas encore chargé | **Code** et **Message**                         |

### Propriétés exposées

Le composant expose quatre valeurs pour le [data binding](https://docs.pandasuite.com/fr/essentials/data/data-binding/), sous **Depuis un composant**. Pour la plupart des interfaces, les deux premières suffisent :

- **Connecté** : vrai tant que la session est active.
- **Parle** : vrai tant que l'agent parle.

Liez-les à un indicateur d'écoute, à une pulsation autour de l'avatar, ou à la visibilité d'une zone de sous-titres. Les deux valeurs brutes sont là quand vous voulez un contrôle plus fin :

- **État de connexion** : `new`, `connecting`, `connected`, `completed`, `disconnecting`, `disconnected`, `closed`, `fail`. `connected` et `completed` signifient tous deux que la session est active : les navigateurs diffèrent sur celui qu'ils finissent par signaler.
- **Activité** : `IDLE`, `TALKING`, `LOADING`, `BUFFERING`.

## Propriétés du composant

| Propriété                  | Description                                                                                                                                                               |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Clé API**                | Votre clé API D-ID. Utilisée dans PandaSuite Studio uniquement, jamais publiée.                                                                                           |
| **Agent**                  | L'agent à intégrer. Appuyez sur **Actualiser** pour lister les agents de votre clé.                                                                                       |
| **Domaines personnalisés** | Vos propres origines où tourne le projet publié, avec le schéma, par exemple `https://kiosque.example`. Utilisez **+ Add** pour chacune.                                  |
| **Connexion automatique**  | Se connecte à l'agent dès l'affichage du composant, sans attendre que le visiteur appuie sur le bouton de connexion.                                                      |
| **Orientation**            | Disposition **Verticale** ou **Horizontale** de l'interface D-ID.                                                                                                         |
| **Identifiant externe**    | Identifiant optionnel du visiteur ou de la session transmis à D-ID, pour relier la conversation à votre propre utilisateur. Lu une seule fois au chargement du composant. |

> **Astuce**
>
> L'**Identifiant externe** est lu une seule fois, au chargement du composant.
> Liez-le à une valeur qui existe déjà à ce moment-là, par exemple un champ de
> Datastore écrit au lancement, plutôt qu'à une donnée que le visiteur produit
> plus tard sur l'écran.

## Publier votre projet

D-ID restreint un agent aux adresses sur lesquelles il a le droit de tourner. La synchronisation crée une **Client Key** qui couvre ces adresses, ou en réutilise une qui les couvre déjà.

Celles de PandaSuite sont prises en charge pour vous : l'origine de PandaSuite Studio, le viewer web et l'adresse locale utilisée par les viewers iOS et Android. Vous ne déclarez que ce que PandaSuite ne peut pas savoir.

Si vous publiez sur un [domaine personnalisé](https://docs.pandasuite.com/fr/essentials/web-publishing/custom-domain/), ou si vous [intégrez votre projet dans votre propre site](https://docs.pandasuite.com/fr/essentials/web-publishing/embed-into-a-website/), ajoutez cette origine dans **Domaines personnalisés** avec **+ Add**, puis appuyez de nouveau sur **Sync** pour que la clé la couvre.

> **Attention**
>
> Un projet [partagé comme template](https://docs.pandasuite.com/fr/essentials/project-management/share-your-project-as-template/)
> arrive sans la clé API, volontairement. Celui qui le réutilise saisit sa
> propre clé, choisit son propre agent et appuie sur **Sync**. Ses événements et ses
> actions sont conservés, et tout tool absent de son agent lui est proposé à la
> création.

## Un exemple complet : un avatar IA qui guide le visiteur

L'objectif : un visiteur demande à l'avatar ce qu'il y a à voir, et l'application suit la conversation.

Avant de commencer : votre **Clé API** est renseignée, un **Agent** est choisi, vous avez appuyé une fois sur **Sync**, et vous êtes à l'intérieur du composant. Le projet contient une collection d'expositions et un écran par exposition.

**1. Créez le tool qui liste les expositions.**

Dans le composant, appuyez sur **Create client tool**. Nommez-le `list_screens`, décrivez-le par « Lists the PandaSuite project screens », et laissez la liste **Arguments** vide. Appuyez sur **Save changes**.

**2. Répondez-lui.**

Ressortez par le fil d'Ariane, sélectionnez le composant, ouvrez **Actions** et cliquez sur le bouton **+**. Vos client tools figurent dans la liste des déclencheurs, aux côtés de **Session démarrée**. Choisissez `list_screens`, puis ajoutez une seule action : **Renvoyer une valeur**. Liez son paramètre **Réponse** à la liste des écrans de votre projet, sous **Depuis le projet** dans la fenêtre de data binding, pour que l'agent apprenne quels écrans il peut demander.

**3. Créez le tool qui navigue.**

Retournez à l'intérieur du composant et appuyez de nouveau sur **Create client tool**. Nommez-le `change_screen`, décrivez-le par « Change the screen to illustrate what you are saying », et ajoutez un argument : `Screen`, de type **Page**, décrit par « The representation of a PandaSuite screen, obtained by the list\_screens tool », **Required**.

**4. Faites-le naviguer.**

De retour dans **Actions**, sur le déclencheur `change_screen`, ajoutez **Changer d'écran**. Studio l'affiche ensuite sous le nom **Aller à l'écran** : même action, autre nom. Cliquez sur le nom du paramètre de destination pour ouvrir la fenêtre de data binding, puis choisissez **Depuis l'événement** → **Screen**. Aucun **Renvoyer une valeur** n'est nécessaire ici : ce tool agit, il ne renseigne pas, donc le simple `ok` que reçoit l'agent une fois la liste exécutée est la bonne réponse.

**5. Parlez des deux à l'agent.**

Dans **Agent prompt**, ajoutez un paragraphe qui les nomme, puis appuyez sur **Save prompt** :

> Tu es un guide de musée. Quand le visiteur demande ce qu'il y a à voir, appelle `list_screens` et présente les résultats avec tes propres mots. Quand le visiteur en choisit un, appelle `change_screen` avec l'écran correspondant.

**6. Testez.**

L'agent ne fonctionne pas dans l'aperçu du Studio : sauvegardez donc votre projet et ouvrez son **lien de partage** dans un navigateur web. Appuyez sur le bouton de connexion de l'avatar (ou réglez **Connexion automatique** sur **Yes** au préalable), et autorisez le micro lorsque le navigateur le demande. Demandez à l'avatar ce qu'il y a à voir. Il devrait lister vos écrans, et vous emmener sur le bon quand vous le choisissez.

Si rien ne se passe, vérifiez d'abord le prompt : c'est la cause habituelle. Pour voir si un appel arrive, attachez une action **Changer l'état de l'écran** temporaire à l'événement, vous la verrez se déclencher.

## Bonnes pratiques et limites

- **Décrivez les tools pour l'agent, pas pour vous.** Le nom et la description sont les seules choses que l'agent lit pour décider d'appeler un tool. « Ouvrir l'écran d'une exposition » lui vaut un appel ; « nav handler v2 » non.
- **Gardez des réponses courtes.** La réponse parvient à l'agent sous forme de texte, plafonnée à 15 Kio. Au-delà, elle est tronquée en silence, et une réponse structurée tronquée arrive cassée. Renvoyez les quelques champs dont l'agent a besoin pour parler, pas toute votre base.
- **Un tool, une tâche.** Un agent choisit entre ses tools d'après leurs descriptions. Deux tools qui se recouvrent rendent ce choix peu fiable.
- **Le composant lit ses tools une seule fois, à son chargement.** Un tool que vous ajoutez n'atteint pas un projet déjà lancé, et se reconnecter n'y change rien. Synchronisez, sauvegardez votre projet, puis rechargez votre lien de partage.
- **L'agent ne fonctionne pas dans l'aperçu du Studio.** Dans l'aperçu, le composant affiche un message à la place de l'avatar. Pour parler à votre agent, ouvrez votre [lien de partage](https://docs.pandasuite.com/fr/essentials/project-management/test-and-preview-your-project/) dans un navigateur web. Si l'aperçu reste sur **Finding an available agent** sans afficher de message, votre projet utilise une ancienne version du composant : appuyez sur **Mettre à jour le composant** dans ses propriétés.
- **Le micro relève du navigateur.** Les navigateurs n'accordent l'accès au micro que sur une adresse sécurisée en `https`, et seulement après autorisation du visiteur. Testez le projet publié à son adresse réelle.
- **Réexportez une application publiée avant cela.** Tous les viewers transmettent désormais les réponses à l'agent, mais une application continue de tourner avec le viewer avec lequel elle a été exportée. Sur un export plus ancien, l'événement se déclenche et vos actions s'exécutent, mais aucun appel de tool ne rend la main à l'agent, pas même celui qui, sans **Renvoyer une valeur**, se serait contenté de répondre `ok`. Réexporter est le correctif.
- **Avatar, voix, personnalité, salutations et connaissances restent chez D-ID.** Modifiez-les dans le Studio D-ID : ils prennent effet à la connexion suivante, sans aucun **Sync**. **Sync** ne ramène que les tools, le prompt et l'image de l'agent.

## Voir aussi

- [Data binding](https://docs.pandasuite.com/fr/essentials/data/data-binding/) pour alimenter les réponses de l'agent depuis votre projet.
- [Actions interactives](https://docs.pandasuite.com/fr/essentials/interactions/interactive-actions/) pour tout ce qu'un événement peut déclencher.
- [Écrans](https://docs.pandasuite.com/fr/essentials/layout/screens/) et [Collection](https://docs.pandasuite.com/fr/essentials/data/collection/) pour les deux choses dont un agent parle le plus souvent.
- [Composants personnalisés](https://docs.pandasuite.com/fr/essentials/components/custom-components/) si vous voulez construire un composant qui déclare ses propres événements de la même façon.
