TAS — Texte et Parole, dans les Deux Sens (API Speakee)

Un seul script gère les deux directions :

Texte → Parole (TTS) : 40+ langues, 100+ voix, UID de voix personnalisé, découpage de longs textes, mode conversation multi-voix, assemblage ffmpeg, QA audio.
Audio → Texte (STT) : transcrire n'importe quel fichier audio/vidéo en texte, horodatages des mots et sous-titres SRT/WebVTT, avec découpage automatique des longs enregistrements.

Tout est fait par le script fourni — ne le réimplémentez jamais en ligne et n'installez JAMAIS rien (pas de whisper, pas de torch, pas de faster-whisper, pas de pip) :

<chemin de base de la compétence>/scripts/tas.py

Emplacements d'installation typiques : ~/.config/opencode/skills/tas/scripts/tas.py (opencode), ~/.claude/skills/tas/scripts/tas.py (Claude Code), et ~/.agents/skills/tas/scripts/tas.py (l'interface en ligne de commande skills, npx skills add). La compétence s'appelle tas — chargez-la avec le nom tas, jamais tts.

Règles non-négociables (s'appliquent à CHAQUE demande)

Utilisez le script fourni. Pas de snippets curl/python ad-hoc pour TTS ou STT.
N'installez JAMAIS rien. N'exécutez pas pip install faster-whisper, pip install whisper, pip install torch, ni ne téléchargez de modèle. Le script effectue la STT entièrement via l'API Speakee avec la bibliothèque standard Python — pas de modèle local, pas de téléchargement local, pas de pip.
Vérifiez avant de livrer. tts et conversation exécutent automatiquement une QA audio ; un QA: FAIL doit être corrigé, jamais livré.
Signalez le résultat : chemin final, durée, taille et état de la QA (TTS) ; chemin final du SRT/VTT/texte et nombre de répliques (STT).
Pré-vérifiez toujours. La langue, le modèle et la voix sont validés avant toute requête ; n'envoyez jamais une voix devinée.
Laissez le cache activé sauf si l'utilisateur demande autrement. Il accélère les ré-exécutions et reprend les conversations interrompues.
Ne devinez jamais un nom de voix. Résolvez-le avec voices / suggest, ou passez l'UUID.
Respectez l'API gratuite : par défaut --workers 4 ; réduisez-le en cas de HTTP 429.
Laissez le script normaliser le texte. Le Markdown, les URL, le HTML et les emoji sont supprimés par défaut ; utilisez --raw uniquement lorsque l'utilisateur veut du texte littéral.
Ne pré-découpez jamais un long texte. Le script découpe aux limites des phrases et fusionne automatiquement.
Passez toujours -l <code> pour la STT lorsque la langue est connue. La détection automatique n'est pas fiable (Whisper confond bengali/gujarati) ; -l bn est requis pour un bengali correct.
Utilisez --json lorsqu'un autre outil ou script consomme le résultat.

Commandes

Commande	Objectif
`tts`	synthétiser un bloc de texte (TTS)
`uid`	synthétiser avec un UID de voix personnalisé (`language=uid`)
`conversation`	dialogue multi-locuteurs → un MP3 assemblé et vérifié
`stt`	transcrire un fichier audio/vidéo → texte (+ SRT/VTT optionnel)
`transcribe`	alias pour `stt`
`subtitle`	transcrire et écrire un SRT
`verify`	exécuter une QA audio sur n'importe quel fichier
`voices -l <code>`	lister les voix pour une langue
`suggest -l <code>`	lister les voix avec des recommandations marquées
`presets`	lister les préréglages de voix intégrés
`languages`	lister les langues prises en charge
`models`	lister les modèles (`sonic-3.5` par défaut)
`cache-clear`	supprimer le cache de synthèse

Workflow A — Texte vers Parole (TTS)

Étape 1 — Cadrage

Identifiez : la langue (ou laissez la détection automatique fonctionner), le ton (actualités / histoire / assistant / livre audio), un seul locuteur ou un dialogue, le chemin de sortie souhaité, et si des sous-titres (--srt) ou des métadonnées (--title/--artist) sont nécessaires.

Étape 2 — Choisir la langue et la voix

python3 "$S" languages                 # 43 codes
python3 "$S" suggest -l bn             # voix recommandées en premier
python3 "$S" presets                   # ensembles de voix sélectionnés

Si l'utilisateur a un UID de voix personnalisé, utilisez le mode uid. Sinon, préférez un préréglage ou une voix recommandée plutôt que la voix par défaut.

Étape 3 — Synthétiser

Locuteur unique :

python3 "$S" tts "Votre TEXTE" -l bn -o sortie.mp3
python3 "$S" tts --text-file article.md -l en --preset news -o article.mp3

Dialogue :

python3 "$S" conversation dialogue.txt -l bn \
  --map "Humain=Nayem,IA=Pooja - Assistant Quotidien" \
  --loudnorm --srt dialogue.srt -o dialogue.mp3

Utilisez --dry-run d'abord pour les exécutions longues ou coûteuses.

Étape 4 — Vérifier

La QA s'exécute automatiquement. Pour revérifier un fichier :

python3 "$S" verify sortie.mp3

Vérifie : décodage, durée, niveau sonore intégré (ebur128), crête réelle/écrêtage, et silence de début/fin/interne. Le code de sortie 5 signifie ÉCHEC.

Étape 5 — Livrer

Signalez :

sortie.mp3 — 2,8 s, 0,04 Mo, QA RÉUSSIE (-18,9 LUFS, crête -4,2 dBFS)

Ne collez pas le JSON brut sauf demande explicite.

Étape 6 — Réutiliser

Les ré-exécutions utilisent le cache (~/.cache/speakee-tas). Utilisez --force pour regénérer, cache-clear pour tout effacer.

Workflow B — Parole vers Texte (STT)

Utilisez ceci lorsque l'utilisateur a un fichier audio ou vidéo et souhaite une transcription, des sous-titres, des légendes ou un SRT. N'installez pas Whisper — le script fourni appelle directement le point d'accès /api/stt de Speakee.

Étape 1 — Confirmer le fichier

python3 "$S" verify /chemin/vers/audio.mp3   # optionnel : confirme le décodage
ls -la /chemin/vers/audio.mp3

Étape 2 — Choisir la langue

# Détection automatique (peu fiable — Whisper confond bengali/gujarati) :
python3 "$S" stt audio.mp3

# PRÉFÉREZ TOUJOURS une langue explicite quand elle est connue :
python3 "$S" stt audio.mp3 -l bn

Important : passez -l <code> pour l'écriture correcte. Pour le bengali, utilisez -l bn ; la détection automatique renvoie le gujarati pour de l'audio bengali. Les avertissements de faible confiance (< 0.5) signifient que la langue détectée est probablement erronée.

Étape 3 — Transcrire + créer les sous-titres

# Écrire SRT + VTT à côté de l'entrée, et sauvegarder la transcription :
python3 "$S" stt audio.mp3 -l bn \
  --srt --srt-path audio.srt --vtt --vtt-path audio.vtt \
  -o audio.txt

# Raccourci : juste le SRT (commande subtitle) :
python3 "$S" subtitle audio.mp3 -l bn -o audio.srt

# JSON lisible par machine (pour d'autres outils) :
python3 "$S" stt audio.mp3 -l bn --json -o resultat.json

# Longs enregistrements : découpage automatique ~120 s ; forcer des morceaux plus petits ou un seul téléchargement :
python3 "$S" stt audio.mp3 -l bn --chunk-seconds 60
python3 "$S" stt audio.mp3 -l bn --no-chunk     # uniquement si < ~3,5 Mo

Étape 4 — Livrer

Signalez :

audio.srt — 111 répliques (8,05 min, Bengali)
audio.txt — transcription sauvegardée

Drapeaux STT : --srt, --srt-path, --vtt, --vtt-path, --no-word-timestamps (plus rapide, timing estimé), --chunk-seconds, --no-chunk, --workers, --max-chars, --max-line-seconds.

Mode conversation (TTS)

Format du script, une réplique par ligne :

Le spectacle commence.                <- pas de préfixe "Intervenant:" -> voix de narrateur
Humain: Mon frère, combien font 2+2 ?
IA: Votre question a été acceptée.

Les étiquettes d'intervenant sont des jetons courts avant : (≤16 caractères, pas d'espaces).
Les lignes sans préfixe Intervenant: sont le narrateur/commentateur. Le narrateur est mappé avec la clé spéciale narrator, donc une 3ème voix distincte est --map "narrator=VoixC,Humain=VoixA,IA=VoixB".
--map "intervenant=voix" accepte un nom de voix (flou) ou un UUID.
Sans --map, des voix distinctes sont attribuées automatiquement.
Les voix doivent être distinctes. Si deux intervenants correspondent à la même voix, le script affiche un AVERTISSEMENT ; mappez chaque intervenant à une voix différente. Donnez toujours à l'IA et à l'humain des voix différentes (et une 3ème voix pour le narrateur lorsqu'une ligne de commentateur/narrateur est présente).
--silence 0.35 écart entre les tours ; --loudnorm normalise à −16 LUFS.
--manifest FICHIER enregistre chaque segment ; --srt FICHIER écrit les sous-titres.
--no-stitch conserve les fichiers de segments individuels au lieu d'un seul MP3.
--workers contrôle les requêtes parallèles (par défaut 4).

Options (les plus utilisées)

Drapeau	Défaut	Signification
`-l, --language`	auto-détection	Code ISO ou `uid`
`-m, --model`	`sonic-3.5`	`sonic-3.5` / `sonic-3` / `sonic-turbo` / `sonic-2`
`-v, --voice_id`	préréglage/défaut	nom de voix ou UUID
`-o, --out`	automatique	fichier / répertoire de sortie (`--no-stitch`)
`-s, --speed`	`1.2`	0,5–2,0
`--preset`	—	`news`, `story`, `assistant`, `audiobook`
`--chunk-limit`	`1200`	caractères par requête
`--retries`	`4`	tentatives avec backoff exponentiel
`--workers`	`4`	requêtes parallèles
`--no-cache` / `--force`	désactivé	ignorer le cache / regénérer
`--no-verify`	désactivé	ignorer la QA automatique (non recommandé)
`--dry-run`	désactivé	afficher le plan, ne pas faire de requêtes
`--json`	désactivé	sortie lisible par machine

Options STT

Drapeau	Défaut	Signification
`-l, --language`	`auto`	Code ISO (utilisez `bn` pour le bengali)
`--chunk-seconds`	`120`	secondes audio par téléchargement
`--no-chunk`	désactivé	une seule requête (max ~3,5 Mo)
`--workers`	`2`	téléchargements parallèles
`--srt` / `--srt-path`	désactivé	écrire un SRT
`--vtt` / `--vtt-path`	désactivé	écrire un WebVTT
`--no-word-timestamps`	désactivé	plus rapide ; le timing des sous-titres est estimé
`--max-chars`	`42`	nombre max de caractères par réplique
`--max-line-seconds`	`6.0`	secondes max par réplique
`--timeout` / `--retries`	`300` / `3`	délai d'attente / tentatives par requête

Mise en cache et sécurité

Les segments sont mis en cache par hachage du contenu dans ~/.cache/speakee-tas ; les ré-exécutions et les tentatives reprennent automatiquement.
Les fichiers de concaténation temporaires sont toujours supprimés ; les répertoires temporaires --no-cache sont nettoyés à la sortie.
Les réponses sont validées (Content-Type: audio/* + en-tête MP3), donc le JSON d'erreur n'est jamais sauvegardé en tant qu'audio.
HTTP 429 respecte Retry-After ; les 5xx/timeouts réessayent avec backoff ; les 4xx permanents échouent immédiatement avec le message du serveur.
La STT s'exécute entièrement en cours de processus avec la bibliothèque standard Python — pas d'installation réseau, pas de téléchargement de modèle, pas de pip.
Codes de sortie : 0 ok, 1 erreur, 2 utilisation, 3 validation, 4 réseau/API, 5 QA audio échouée.

Fichiers de référence

references/api.md — points d'accès, charge utile, validation, tentatives, mise en cache.
references/voices.md — catalogue langue/voix, mode UID, préréglages.
references/troubleshooting.md — symptômes, correctifs, modes d'échec courants.
assets/presets.json — préréglages de voix sélectionnés (modifiez pour ajouter les vôtres).

nayem-48ai/tas

Qu'est-ce que tas ?

Demander à votre IA préférée

Documentation