> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# voice.listen()

La méthode `listen()` est une fonction centrale disponible dans tous les Providers Voice de Mastra qui convertit la parole en texte. Elle reçoit un flux audio en entrée et renvoie le texte transcrit.

## Paramètres

**audioStream** (`NodeJS.ReadableStream`): Flux audio à transcrire. Il peut s'agir d'un flux de fichier ou de microphone.

**options** (`object`): Options propres au Provider pour la reconnaissance vocale

## Valeur renvoyée

Renvoie l'une des valeurs suivantes :

- `Promise<string>` : une promesse résolue avec le texte transcrit
- `Promise<NodeJS.ReadableStream>` : une promesse résolue avec un flux de texte transcrit (pour la transcription en streaming)
- `Promise<void>` : pour les Providers en temps réel qui émettent des événements 'writing' au lieu de renvoyer directement du texte

## Options propres au Provider

Chaque Provider Voice peut prendre en charge des options supplémentaires propres à son implémentation. En voici quelques exemples :

### OpenAI

**options** (`Options`): Options de configuration.

**options.filetype** (`string`): Format du fichier audio (par exemple, 'mp3', 'wav', 'm4a')

**options.prompt** (`string`): Texte destiné à guider la transcription du modèle

**options.language** (`string`): Code de langue (par exemple, 'en', 'fr', 'de')

### Google

**options** (`Options`): Options de configuration.

**options.stream** (`boolean`): Indique si la reconnaissance en streaming doit être utilisée

**options.config** (`object`): Configuration de la reconnaissance provenant de l'API Google Cloud Speech-to-Text

### Deepgram

**options** (`Options`): Options de configuration.

**options.model** (`string`): Modèle Deepgram à utiliser pour la transcription

**options.language** (`string`): Code de langue pour la transcription

## Exemple d'utilisation

```typescript
import { OpenAIVoice } from '@mastra/voice-openai'
import { getMicrophoneStream } from '@mastra/node-audio'
import { createReadStream } from 'fs'
import path from 'path'

// Initialize a voice provider
const voice = new OpenAIVoice({
  listeningModel: {
    name: 'whisper-1',
    apiKey: process.env.OPENAI_API_KEY,
  },
})

// Basic usage with a file stream
const audioFilePath = path.join(process.cwd(), 'audio.mp3')
const audioStream = createReadStream(audioFilePath)
const transcript = await voice.listen(audioStream, {
  filetype: 'mp3',
})
console.log('Transcribed text:', transcript)

// Using a microphone stream
const microphoneStream = getMicrophoneStream() // Assume this function gets audio input
const transcription = await voice.listen(microphoneStream)

// With provider-specific options
const transcriptWithOptions = await voice.listen(audioStream, {
  language: 'en',
  prompt: 'This is a conversation about artificial intelligence.',
})
```

## Utilisation avec `CompositeVoice`

Avec `CompositeVoice`, la méthode `listen()` délègue l'opération au Provider d'écoute configuré :

```typescript
import { CompositeVoice } from '@mastra/core/voice'
import { OpenAIVoice } from '@mastra/voice-openai'
import { PlayAIVoice } from '@mastra/voice-playai'

const voice = new CompositeVoice({
  input: new OpenAIVoice(),
  output: new PlayAIVoice(),
})

// This will use the OpenAIVoice provider
const transcript = await voice.listen(audioStream)
```

### Utilisation des Model Providers AI SDK

Vous pouvez également utiliser directement des modèles de transcription AI SDK avec `CompositeVoice` :

```typescript
import { CompositeVoice } from '@mastra/core/voice'
import { openai } from '@ai-sdk/openai'
import { groq } from '@ai-sdk/groq'

// Use AI SDK transcription models
const voice = new CompositeVoice({
  input: openai.transcription('whisper-1'), // AI SDK model
  output: new PlayAIVoice(), // Mastra provider
})

// Works the same way
const transcript = await voice.listen(audioStream)

// Provider-specific options can be passed through
const transcriptWithOptions = await voice.listen(audioStream, {
  providerOptions: {
    openai: {
      language: 'en',
      prompt: 'This is about AI',
    },
  },
})
```

Consultez la [référence de CompositeVoice](https://mastra.zisheng.pro/fr/reference/voice/composite-voice) pour en savoir plus sur l'intégration d'AI SDK.

## Providers Voice en temps réel

Avec des Providers Voice en temps réel tels que `OpenAIRealtimeVoice`, la méthode `listen()` se comporte différemment :

- Au lieu de renvoyer le texte transcrit, elle émet des événements 'writing' contenant ce texte
- Vous devez enregistrer un écouteur d'événements pour recevoir la transcription

```typescript
import { OpenAIRealtimeVoice } from '@mastra/voice-openai-realtime'
import { getMicrophoneStream } from '@mastra/node-audio'

const voice = new OpenAIRealtimeVoice()
await voice.connect()

// Register event listener for transcription
voice.on('writing', ({ text, role }) => {
  console.log(`${role}: ${text}`)
})

// This will emit 'writing' events instead of returning text
const microphoneStream = getMicrophoneStream()
await voice.listen(microphoneStream)
```

## Remarques

- Tous les Providers Voice ne prennent pas en charge la conversion de la parole en texte (par exemple, PlayAI et Speechify)
- Le comportement de `listen()` peut varier légèrement d'un Provider à l'autre, mais toutes les implémentations suivent la même interface de base
- Avec un Provider Voice en temps réel, la méthode peut ne pas renvoyer directement du texte, mais émettre plutôt un événement 'writing'
- Le format audio pris en charge dépend du Provider. Les formats courants incluent MP3, WAV et M4A
- Certains Providers prennent en charge la transcription en streaming, où le texte est renvoyé à mesure qu'il est transcrit
- Pour des performances optimales, pensez à fermer ou terminer le flux audio lorsque vous n'en avez plus besoin

## Méthodes associées

- [voice.speak()](https://mastra.zisheng.pro/fr/reference/voice/voice.speak) : convertit le texte en parole
- [voice.send()](https://mastra.zisheng.pro/fr/reference/voice/voice.send) : envoie des données audio au Provider Voice en temps réel
- [voice.on()](https://mastra.zisheng.pro/fr/reference/voice/voice.on) : enregistre un écouteur d'événements Voice