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')

prompt?:

string

Texte destiné à guider la transcription du modèle

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

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

language?:

string

Code de langue pour la transcription

Exemple d'utilisation

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é :

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 :

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 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

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() : convertit le texte en parole
• voice.send() : envoie des données audio au Provider Voice en temps réel
• voice.on() : enregistre un écouteur d'événements Voice