# Essayer votre compétence dans VS Code

> L'extension Thalovant Skills exécute votre compétence à côté de son code et montre ce qu'elle dit, écrit et affiche pendant que vous la modifiez.

Source: https://docs.thalovant.com/fr/developers/vscode-extension/

---
{/* Previous:  Claude Opus 5.5 - 2026-11-20 - Motive: Thalovant Skills is in the VS Code Marketplace and on Open VSX. */}

Thalovant Skills est une extension VS Code pour les personnes qui écrivent des
compétences. Elle exécute votre compétence dans un vrai cœur OVOS, à côté du
code, avec le Python de la compétence. Vous tapez ce que quelqu'un dirait et
vous voyez chaque réponse de la compétence. Quand vous enregistrez un fichier,
la compétence redémarre avec votre modification.

## Ce qu'il vous faut

| Requis | Version ou forme |
|---|---|
| Éditeur | VS Code 1.95 ou plus récent, ou un éditeur bâti dessus qui installe depuis Open VSX, comme VSCodium |
| Python | 3.11 ou plus récent, celui qu'utilisent les tests de la compétence |
| Une compétence | Un dossier avec un paquet `thalovant_skill_*`, tel que l'écrit `thalovant-skillkit new` |

Il ne faut ni hub, ni enceinte, ni compte. Tout tourne sur votre ordinateur.
L'extension peut créer l'environnement Python de la compétence à votre place.

## Installer l'extension

Dans **Extensions**, cherchez **Thalovant Skills**, puis choisissez **Install**.

  

VS Code installe l'extension depuis le
[Marketplace de Microsoft](https://marketplace.visualstudio.com/items?itemName=thalovant.thalovant-skills).
L'éditeur est **Thalovant**.
Depuis un terminal, lancez `code --install-extension thalovant.thalovant-skills`.

  
  

Ces éditeurs installent l'extension depuis
[Open VSX](https://open-vsx.org/extension/thalovant/thalovant-skills).
Depuis un terminal, VSCodium fait de même avec
`codium --install-extension thalovant.thalovant-skills`.

  
  

Pour installer une version précise depuis son fichier `.vsix` :

1. Téléchargez `thalovant-skills-0.1.1.vsix` depuis les
   [versions de Thalovant Skills](https://github.com/thalovant/thalovant-vscode/releases).

2. Dans VS Code, ouvrez **Extensions**, choisissez **…** en haut de la liste,
   puis **Install from VSIX…**, et choisissez le fichier. Depuis un terminal,
   c'est `code --install-extension thalovant-skills-0.1.1.vsix`.

  

Ouvrez ensuite un dossier qui contient une compétence. La vue **Thalovant**
apparaît dans la barre d'activité, et la barre d'état affiche le nom de la
compétence.

## Démarrer ou ouvrir une compétence

Pour partir de rien, lancez **Thalovant: New Skill…** depuis la palette de
commandes. L'extension demande le sujet de la compétence et sa place dans
l'échelle de repli. Elle écrit ensuite la compétence avec
`thalovant-skillkit new`, lui donne son propre `.venv` avec SkillKit et
OVOScope, et lance ses vérifications. La première installation de la pile
OVOS prend une minute ou deux.

Pour une compétence existante, l'extension choisit son Python dans cet ordre :

1. le réglage `thalovant.python` ;
2. un `.venv` dans le dossier de la compétence ;
3. l'interpréteur qu'utilise l'extension Python.

Si ce Python n'a pas `thalovant-skillkit[testing]`, le simulateur propose
**Set up the environment**. Ce bouton installe le kit et la compétence dans
le `.venv` de la compétence, sans rien changer hors de son dossier.

## Parler à votre compétence

Cliquez sur ▷ dans la barre de titre de l'éditeur, ou appuyez sur
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>V</kbd> (<kbd>Cmd</kbd>+<kbd>Alt</kbd>+<kbd>V</kbd>
sur Mac). Le simulateur s'ouvre à côté du code. Tapez une phrase et appuyez
sur Entrée.

Chaque tour montre toutes les façons dont la compétence a répondu :

| Signe | Ce qu'il montre |
|---|---|
| 🔊 | Ce que dit l'enceinte. **SSML** déplie le jumeau SSML du dialogue, s'il en a un. |
| ✎ | Ce qu'une application ou un écran écrit, quand la compétence passe `written=` à `speak_to`. |
| ▭ | La carte que porte la réponse. La plus récente apparaît aussi sur l'écran simulé. |
| ✓ | L'intention et le gestionnaire qui ont pris la phrase, et la durée du tour. |
| ✗ | L'intention d'une autre compétence l'a prise. |
| ∅ | Personne n'a répondu : aucune intention ne correspond et aucune compétence de repli n'a dit oui. |

Sous chaque tour, **Log** montre les lignes du journal de votre compétence et
les avertissements de tous, et **Bus** montre chaque message du bus pendant le
tour. Quand un gestionnaire lève une exception, le tour montre l'exception, sa
trace et un lien vers la ligne qui l'a levée.

### Appuyer sur une carte

Les boutons de l'écran simulé fonctionnent. Un appui envoie
`thalovant.display.action` à la compétence, comme le fait un satellite. Le
gestionnaire enregistré avec `add_display_action_handler` répond, et sa
réponse apparaît comme un nouveau tour. Les outils de carte sont décrits dans
[Afficher une carte sur un écran](/fr/developers/writing-a-skill/#afficher-une-carte-sur-un-écran).

### Répondre à une question

Quand la compétence demande quelque chose avec `get_response`, le tour
s'arrête à la question et le champ de saisie indique que la compétence attend.
Tapez la réponse : elle va au même gestionnaire, par converse, comme sur un
hub.

### Choisir une langue et un lieu

Le menu des langues, à côté du champ de saisie, liste les locales de la
compétence. La phrase part dans la langue choisie. Le menu 📍 envoie une ville
comme lieu de la requête, pour les compétences qui lisent
`location_of(message)`.

### Garder un tour comme test

**Save as golden** ajoute la phrase à `test/end2end/golden_utterances.jsonl`,
avec l'intention qui l'a prise. **Should not match** l'ajoute comme une phrase
que la compétence doit laisser passer. Les deux apparaissent tout de suite dans
la vue Tests.

## Lancer les énoncés de référence

La vue Tests liste chaque ligne de `test/end2end/golden_utterances*.jsonl` :

```json
{"skill_id": "thalovant-skill-plant-care.thalovant", "utterance": "water the plants", "intent_label": "water.plants.intent", "lang": "en-US"}
{"skill_id": "thalovant-skill-plant-care.thalovant", "utterance": "what time is it", "lang": "en-US", "negative": true}
```

Une ligne réussit quand sa phrase atteint cette compétence, et l'intention
nommée quand `intent_label` est renseigné. Une ligne avec `"negative": true`
réussit quand la compétence laisse passer la phrase. Une ligne en échec dit
qui a pris la phrase à la place. Chaque exécution démarre son propre hub : un
test qui laisse une question ouverte n'atteint pas la conversation du
simulateur.

## Un éditeur qui connaît les locales

Dans les appels qui nomment une ressource de locale, l'éditeur connaît les
fichiers de la compétence. Ces appels sont `speak_dialog`, `dialog`,
`get_response`, `mentions(utterance, "…")`, `@intent_handler("….intent")` et
`display.layout_file(self, "…")` :

| Vous faites | Vous obtenez |
|---|---|
| Taper entre les guillemets | Les dialogues, le vocabulaire, les intentions ou les mises en page de la compétence, avec les locales où chacun manque |
| Survoler un nom | Les lignes de chaque locale, et les locales qui n'ont pas le fichier |
| Aller à la définition | Le fichier, la locale source en premier |
| Nommer ce qu'aucune locale n'a | Un avertissement sur le nom |

Au-dessus de chaque gestionnaire d'intention et de chaque ligne d'un fichier
`.intent`, un lien propose une des phrases de l'intention. Cliquez dessus pour
la dire au simulateur.

## Vérifier à chaque enregistrement

À l'enregistrement, l'extension lance `thalovant-skillkit check` et place
chaque problème dans le panneau Problèmes, sur le fichier et la ligne qu'il
nomme. Par exemple : une traduction manquante, des espaces réservés qui
diffèrent entre les langues, une barre verticale hors d'un groupe.
**Thalovant: Check the Skill Against the Fleet** compare vos phrases
d'intention avec celles de toutes les autres compétences, la comparaison que
décrit [Le vérifier](/fr/developers/writing-a-skill/#le-vérifier).

## Ce que le simulateur ne montre pas

  Le simulateur ne charge que votre compétence. Une phrase qu'une autre
  compétence prend déjà est repérée par la vérification de la flotte, pas par
  le simulateur.

Le simulateur oriente une phrase comme le fait un hub appairé : stop,
converse, Padatious, common query et le niveau de repli bas. Les hubs appairés
n'exécutent pas Adapt : quand votre compétence enregistre des intentions Adapt,
le simulateur nomme celles qu'un hub ne prendra jamais. Réglez
`thalovant.simulator.pipeline` sur `hub-m2v` pour ajouter les étapes model2vec
du hub, sur l'encodeur de Thalovant, au prix d'un téléchargement la première
fois, ou sur `unpaired` pour un environnement qui exécute Adapt.

Une carte de mise en page est dessinée par la bibliothèque de widgets du
satellite. Le simulateur montre ce qu'affiche un écran qui ne sait pas la
dessiner : le `body` de la carte, et les données qui lui sont liées.

Un panneau d'éditeur n'a pas de micro : vous parlez en tapant. Les réponses
peuvent être lues à voix haute avec `thalovant.simulator.speech` réglé sur
`system`, si votre système offre la synthèse vocale.

Exécuter une compétence exécute son code. Le simulateur, les vérifications et
les tests demandent un espace de travail approuvé. La complétion, le survol et
la coloration fonctionnent en mode restreint.

## Réglages

| Réglage | Par défaut | Ce qu'il change |
|---|---|---|
| `thalovant.python` | vide | Le Python qui exécute la compétence. `${skillFolder}` et `${workspaceFolder}` sont remplacés. |
| `thalovant.simulator.pipeline` | `local` | `m2v` ajoute le classifieur du hub. |
| `thalovant.simulator.reloadOnSave` | `true` | Redémarrer la compétence quand un de ses fichiers est enregistré. |
| `thalovant.simulator.languages` | `[]` | Les langues que charge le hub simulé ; vide, ce sont celles de `locale/supported.json`. |
| `thalovant.simulator.location` | `null` | Le lieu envoyé avec chaque phrase. |
| `thalovant.simulator.skillSettings` | `{}` | Les réglages de départ de la compétence, comme une adresse de service ou une clé. |
| `thalovant.simulator.speech` | `off` | `system` lit les réponses à voix haute. |
| `thalovant.check.onSave` | `true` | Lancer `thalovant-skillkit check` à l'enregistrement d'un fichier. |

## Quand elle ne démarre pas

| Le simulateur dit | Ce que cela veut dire en général |
|---|---|
| thalovant-skillkit is not installed | Le Python choisi n'a pas SkillKit. Choisissez **Set up the environment**, ou **Thalovant: Choose the Skill's Python…**. |
| … is Python 3.10; SkillKit needs 3.11 or newer | Indiquez un Python plus récent dans `thalovant.python`, ou laissez **Set up the environment** créer un `.venv` avec un Python plus récent. |
| *compétence* did not load: … | OVOS a refusé la compétence, et le texte après les deux-points est sa raison. **Check the skill** montre en général le fichier et la ligne. |
| No module named … | La compétence importe un paquet absent de son environnement. **Set up the environment** installe les dépendances de la compétence. |
| Un tour finit par « No end to this turn » | Un gestionnaire est bloqué, souvent sur un appel réseau ou sur un `get_response` resté sans réponse. |

Le journal complet de la compétence est dans **Thalovant: Show the Skill Log**.
