@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/.docs/raw/voice/speech-to-speech.mdx

@@ -1,105 +0,0 @@
----
-title: Speech-to-Speech Capabilities in Mastra | Mastra Docs
-description: Overview of speech-to-speech capabilities in Mastra, including real-time interactions and event-driven architecture.
----
-
-# Speech-to-Speech Capabilities in Mastra
-
-## Introduction
-
-Speech-to-Speech (STS) in Mastra provides a standardized interface for real-time interactions across multiple providers.  
-STS enables continuous bidirectional audio communication through listening to events from Realtime models. Unlike separate TTS and STT operations, STS maintains an open connection that processes speech continuously in both directions.
-
-## Configuration
-
-- **`apiKey`**: Your OpenAI API key. Falls back to the `OPENAI_API_KEY` environment variable.
-- **`model`**: The model ID to use for real-time voice interactions (e.g., `gpt-4o-mini-realtime`).
-- **`speaker`**: The default voice ID for speech synthesis. This allows you to specify which voice to use for the speech output.
-
-```typescript
-const voice = new OpenAIRealtimeVoice({
-  apiKey: "your-openai-api-key",
-  model: "gpt-4o-mini-realtime",
-  speaker: "alloy", // Default voice
-});
-
-// If using default settings the configuration can be simplified to:
-const voice = new OpenAIRealtimeVoice();
-```
-
-## Using STS
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { OpenAIRealtimeVoice } from "@mastra/voice-openai-realtime";
-import { playAudio, getMicrophoneStream } from "@mastra/node-audio";
-
-const agent = new Agent({
-  name: "Agent",
-  instructions: `You are a helpful assistant with real-time voice capabilities.`,
-  model: openai("gpt-4o"),
-  voice: new OpenAIRealtimeVoice(),
-});
-
-// Connect to the voice service
-await agent.voice.connect();
-
-// Listen for agent audio responses
-agent.voice.on("speaker", ({ audio }) => {
-  playAudio(audio);
-});
-
-// Initiate the conversation
-await agent.voice.speak("How can I help you today?");
-
-// Send continuous audio from the microphone
-const micStream = getMicrophoneStream();
-await agent.voice.send(micStream);
-```
-
-For integrating Speech-to-Speech capabilities with agents, refer to the [Adding Voice to Agents](../agents/adding-voice.mdx) documentation.
-
-## Google Gemini Live (Realtime)
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { GeminiLiveVoice } from "@mastra/voice-google-gemini-live";
-import { playAudio, getMicrophoneStream } from "@mastra/node-audio";
-
-const agent = new Agent({
-  name: 'Agent',
-  instructions: 'You are a helpful assistant with real-time voice capabilities.',
-  // Model used for text generation; voice provider handles realtime audio
-  model: openai("gpt-4o"),
-  voice: new GeminiLiveVoice({
-    apiKey: process.env.GOOGLE_API_KEY,
-    model: 'gemini-2.0-flash-exp',
-    speaker: 'Puck',
-    debug: true,
-    // Vertex AI option:
-    // vertexAI: true, 
-    // project: 'your-gcp-project', 
-    // location: 'us-central1',
-    // serviceAccountKeyFile: '/path/to/service-account.json',
-  }),
-});
-
-await agent.voice.connect();
-
-agent.voice.on('speaker', ({ audio }) => {
-  playAudio(audio);
-});
-
-agent.voice.on('writing', ({ role, text }) => {
-  console.log(`${role}: ${text}`);
-});
-
-await agent.voice.speak('How can I help you today?');
-
-const micStream = getMicrophoneStream();
-await agent.voice.send(micStream);
-```
-
-Note:
-- Live API requires `GOOGLE_API_KEY`. Vertex AI requires project/location and service account credentials.
-- Events: `speaker` (audio stream), `writing` (text), `turnComplete`, `usage`, and `error`.

package/.docs/raw/voice/speech-to-text.mdx

@@ -1,86 +0,0 @@
----
-title: Speech-to-Text (STT) in Mastra | Mastra Docs
-description: Overview of Speech-to-Text capabilities in Mastra, including configuration, usage, and integration with voice providers.
----
-
-# Speech-to-Text (STT)
-
-Speech-to-Text (STT) in Mastra provides a standardized interface for converting audio input into text across multiple service providers.
-STT helps create voice-enabled applications that can respond to human speech, enabling hands-free interaction, accessibility for users with disabilities, and more natural human-computer interfaces.
-
-## Configuration
-
-To use STT in Mastra, you need to provide a `listeningModel` when initializing the voice provider. This includes parameters such as:
-
-- **`name`**: The specific STT model to use.
-- **`apiKey`**: Your API key for authentication.
-- **Provider-specific options**: Additional options that may be required or supported by the specific voice provider.
-
-**Note**: All of these parameters are optional. You can use the default settings provided by the voice provider, which will depend on the specific provider you are using.
-
-```typescript
-const voice = new OpenAIVoice({
-  listeningModel: {
-    name: "whisper-1",
-    apiKey: process.env.OPENAI_API_KEY,
-  },
-});
-
-// If using default settings the configuration can be simplified to:
-const voice = new OpenAIVoice();
-```
-
-## Available Providers
-
-Mastra supports several Speech-to-Text providers, each with their own capabilities and strengths:
-
-- [**OpenAI**](/reference/voice/openai/) - High-accuracy transcription with Whisper models
-- [**Azure**](/reference/voice/azure/) - Microsoft's speech recognition with enterprise-grade reliability
-- [**ElevenLabs**](/reference/voice/elevenlabs/) - Advanced speech recognition with support for multiple languages
-- [**Google**](/reference/voice/google/) - Google's speech recognition with extensive language support
-- [**Cloudflare**](/reference/voice/cloudflare/) - Edge-optimized speech recognition for low-latency applications
-- [**Deepgram**](/reference/voice/deepgram/) - AI-powered speech recognition with high accuracy for various accents
-- [**Sarvam**](/reference/voice/sarvam/) - Specialized in Indic languages and accents
-
-Each provider is implemented as a separate package that you can install as needed:
-
-```bash
-pnpm add @mastra/voice-openai  # Example for OpenAI
-```
-
-## Using the Listen Method
-
-The primary method for STT is the `listen()` method, which converts spoken audio into text. Here's how to use it:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
-import { OpenAIVoice } from "@mastra/voice-openai";
-import { getMicrophoneStream } from "@mastra/node-audio";
-
-const voice = new OpenAIVoice();
-
-const agent = new Agent({
-  name: "Voice Agent",
-  instructions:
-    "You are a voice assistant that provides recommendations based on user input.",
-  model: openai("gpt-4o"),
-  voice,
-});
-
-const audioStream = getMicrophoneStream(); // Assume this function gets audio input
-
-const transcript = await agent.voice.listen(audioStream, {
-  filetype: "m4a", // Optional: specify the audio file type
-});
-
-console.log(`User said: ${transcript}`);
-
-const { text } = await agent.generate(
-  `Based on what the user said, provide them a recommendation: ${transcript}`,
-);
-
-console.log(`Recommendation: ${text}`);
-```
-
-Check out the [Adding Voice to Agents](../agents/adding-voice.mdx) documentation to learn how to use STT in an agent.

package/.docs/raw/voice/text-to-speech.mdx

@@ -1,90 +0,0 @@
----
-title: Text-to-Speech (TTS) in Mastra | Mastra Docs
-description: Overview of Text-to-Speech capabilities in Mastra, including configuration, usage, and integration with voice providers.
----
-
-# Text-to-Speech (TTS)
-
-Text-to-Speech (TTS) in Mastra offers a unified API for synthesizing spoken audio from text using various providers.
-By incorporating TTS into your applications, you can enhance user experience with natural voice interactions, improve accessibility for users with visual impairments, and create more engaging multimodal interfaces.
-
-TTS is a core component of any voice application. Combined with STT (Speech-to-Text), it forms the foundation of voice interaction systems. Newer models support STS ([Speech-to-Speech](./speech-to-speech)) which can be used for real-time interactions but come at high cost ($).
-
-## Configuration
-
-To use TTS in Mastra, you need to provide a `speechModel` when initializing the voice provider. This includes parameters such as:
-
-- **`name`**: The specific TTS model to use.
-- **`apiKey`**: Your API key for authentication.
-- **Provider-specific options**: Additional options that may be required or supported by the specific voice provider.
-
-The **`speaker`** option allows you to select different voices for speech synthesis. Each provider offers a variety of voice options with distinct characteristics for **Voice diversity**, **Quality**, **Voice personality**, and **Multilingual support**
-
-**Note**: All of these parameters are optional. You can use the default settings provided by the voice provider, which will depend on the specific provider you are using.
-
-```typescript
-const voice = new OpenAIVoice({
-  speechModel: {
-    name: "tts-1-hd",
-    apiKey: process.env.OPENAI_API_KEY,
-  },
-  speaker: "alloy",
-});
-
-// If using default settings the configuration can be simplified to:
-const voice = new OpenAIVoice();
-```
-
-## Available Providers
-
-Mastra supports a wide range of Text-to-Speech providers, each with their own unique capabilities and voice options. You can choose the provider that best suits your application's needs:
-
-- [**OpenAI**](/reference/voice/openai/) - High-quality voices with natural intonation and expression
-- [**Azure**](/reference/voice/azure/) - Microsoft's speech service with a wide range of voices and languages
-- [**ElevenLabs**](/reference/voice/elevenlabs/) - Ultra-realistic voices with emotion and fine-grained control
-- [**PlayAI**](/reference/voice/playai/) - Specialized in natural-sounding voices with various styles
-- [**Google**](/reference/voice/google/) - Google's speech synthesis with multilingual support
-- [**Cloudflare**](/reference/voice/cloudflare/) - Edge-optimized speech synthesis for low-latency applications
-- [**Deepgram**](/reference/voice/deepgram/) - AI-powered speech technology with high accuracy
-- [**Speechify**](/reference/voice/speechify/) - Text-to-speech optimized for readability and accessibility
-- [**Sarvam**](/reference/voice/sarvam/) - Specialized in Indic languages and accents
-- [**Murf**](/reference/voice/murf/) - Studio-quality voice overs with customizable parameters
-
-Each provider is implemented as a separate package that you can install as needed:
-
-```bash
-pnpm add @mastra/voice-openai  # Example for OpenAI
-```
-
-## Using the Speak Method
-
-The primary method for TTS is the `speak()` method, which converts text to speech. This method can accept options that allows you to specify the speaker and other provider-specific options. Here's how to use it:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
-import { OpenAIVoice } from "@mastra/voice-openai";
-
-const voice = new OpenAIVoice();
-
-const agent = new Agent({
-  name: "Voice Agent",
-  instructions:
-    "You are a voice assistant that can help users with their tasks.",
-  model: openai("gpt-4o"),
-  voice,
-});
-
-const { text } = await agent.generate("What color is the sky?");
-
-// Convert text to speech to an Audio Stream
-const readableStream = await voice.speak(text, {
-  speaker: "default", // Optional: specify a speaker
-  properties: {
-    speed: 1.0, // Optional: adjust speech speed
-    pitch: "default", // Optional: specify pitch if supported
-  },
-});
-```
-
-Check out the [Adding Voice to Agents](../agents/adding-voice.mdx) documentation to learn how to use TTS in an agent.

package/.docs/raw/workflows/control-flow.mdx

@@ -1,265 +0,0 @@
----
-title: "Branching, Merging, Conditions | Workflows | Mastra Docs"
-description: "Control flow in Mastra workflows allows you to manage branching, merging, and conditions to construct workflows that meet your logic requirements."
----
-
-# Control Flow
-
-When you build a workflow, you typically break down operations into smaller tasks that can be linked and reused. **Steps** provide a structured way to manage these tasks by defining inputs, outputs, and execution logic.
-
-- If the schemas match, the `outputSchema` from each step is automatically passed to the `inputSchema` of the next step.
-- If the schemas don't match, use [Input data mapping](./input-data-mapping.mdx) to transform the `outputSchema` into the expected `inputSchema`.
-
-## Chaining steps with `.then()`
-
-Chain steps to execute sequentially using `.then()`:
-
-![Chaining steps with .then()](/image/workflows/workflows-control-flow-then.jpg)
-
-```typescript {8-9,4-5} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const step1 = createStep({...});
-const step2 = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .then(step1)
-  .then(step2)
-  .commit();
-```
-
-This does what you'd expect: it executes `step1`, then it executes `step2`.
-
-## Simultaneous steps with `.parallel()`
-
-Execute steps simultaneously using `.parallel()`:
-
-![Concurrent steps with .parallel()](/image/workflows/workflows-control-flow-parallel.jpg)
-
-```typescript {9,4-5} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const step1 = createStep({...});
-const step2 = createStep({...});
-const step3 = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .parallel([step1, step2])
-  .then(step3)
-  .commit();
-```
-
-This executes `step1` and `step2` concurrently, then continues to `step3` after both complete.
-
-> See [Parallel Execution with Steps](../../examples/workflows/parallel-steps.mdx) for more information.
-
-> 📹 Watch: How to run steps in parallel and optimize your Mastra workflow → [YouTube (3 minutes)](https://youtu.be/GQJxve5Hki4)
-
-## Conditional logic with `.branch()`
-
-Execute steps conditionally using `.branch()`:
-
-![Conditional branching with .branch()](/image/workflows/workflows-control-flow-branch.jpg)
-
-```typescript {8-11,4-5} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const lessThanStep = createStep({...});
-const greaterThanStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .branch([
-    [async ({ inputData: { value } }) => value <= 10, lessThanStep],
-    [async ({ inputData: { value } }) => value > 10, greaterThanStep]
-  ])
-  .commit();
-```
-
-Branch conditions are evaluated sequentially, but steps with matching conditions are executed in parallel.
-
-> See [Workflow with Conditional Branching](../../examples/workflows/conditional-branching.mdx) for more information.
-
-## Looping steps
-
-Workflows support two types of loops. When looping a step, or any step-compatible construct like a nested workflow, the initial `inputData` is sourced from the output of the previous step.
-
-To ensure compatibility, the loop’s initial input must either match the shape of the previous step’s output, or be explicitly transformed using the `map` function.
-
-- Match the shape of the previous step’s output, or
-- Be explicitly transformed using the `map` function.
-
-### Repeating with `.dowhile()`
-
-Executes step repeatedly while a condition is true.
-
-![Repeating with .dowhile()](/image/workflows/workflows-control-flow-dowhile.jpg)
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const counterStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .dowhile(counterStep, async ({ inputData: { number } }) => number < 10)
-  .commit();
-```
-
-### Repeating with `.dountil()`
-
-Executes step repeatedly until a condition becomes true.
-
-![Repeating with .dountil()](/image/workflows/workflows-control-flow-dountil.jpg)
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const counterStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .dountil(counterStep, async ({ inputData: { number } }) => number > 10)
-  .commit();
-```
-
-### Loop management
-
-Loop conditions can be implemented in different ways depending on how you want the loop to end. Common patterns include checking values returned in `inputData`, setting a maximum number of iterations, or aborting execution when a limit is reached.
-
-#### Conditional loops
-
-The `inputData` for a loop step is the output of a previous step. Use the values in `inputData` to determine whether the loop should continue or stop.
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const counterStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-.dountil(nestedWorkflowStep, async ({ inputData: { userResponse } }) => userResponse === "yes")
-.commit();
-```
-
-#### Limiting loops
-
-The `iterationCount` tracks how many times the loop step has run. You can use this to limit the number of iterations and prevent infinite loops. Combine it with `inputData` values to stop the loop after a set number of attempts.
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const counterStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-.dountil(nestedWorkflowStep, async ({ inputData: { userResponse, iterationCount } }) => userResponse === "yes" || iterationCount >= 10)
-.commit();
-```
-
-#### Aborting loops
-
-Use `iterationCount` to limit how many times a loop runs. If the count exceeds your threshold, throw an error to fail the step and stop the workflow.
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const counterStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-.dountil(nestedWorkflowStep, async ({ inputData: { userResponse, iterationCount } }) => {
-  if (iterationCount >= 10) {
-    throw new Error("Maximum iterations reached");
-  }
-  return userResponse === "yes";
-})
-.commit();
-```
-
-### Repeating with `.foreach()`
-
-Sequentially executes the same step for each item from the `inputSchema`.
-
-![Repeating with .foreach()](/image/workflows/workflows-control-flow-foreach.jpg)
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const mapStep = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .foreach(mapStep)
-  .commit();
-```
-
-#### Setting concurrency limits
-
-Use `concurrency` to execute steps in parallel with a limit on the number of concurrent executions.
-
-```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const mapStep = createStep({...})
-
-export const testWorkflow = createWorkflow({...})
-  .foreach(mapStep, { concurrency: 2 })
-  .commit();
-```
-
-## Using a nested workflow
-
-Use a nested workflow as a step by passing it to `.then()`. This runs each of its steps in sequence as part of the parent workflow.
-
-```typescript {4,7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
-import { z } from "zod";
-
-export const nestedWorkflow = createWorkflow({...})
-
-export const testWorkflow = createWorkflow({...})
-  .then(nestedWorkflow)
-  .commit();
-```
-
-## Cloning a workflow
-
-Use `cloneWorkflow` to duplicate an existing workflow. This lets you reuse its structure while overriding parameters like `id`.
-
-```typescript {6,10} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep, cloneWorkflow } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const step1 = createStep({...});
-const parentWorkflow = createWorkflow({...})
-const clonedWorkflow = cloneWorkflow(parentWorkflow, { id: "cloned-workflow" });
-
-export const testWorkflow = createWorkflow({...})
-  .then(step1)
-  .then(clonedWorkflow)
-  .commit();
-```
-
-## Example Run Instance
-
-The following example demonstrates how to start a run with multiple inputs. Each input will pass through the `mapStep` sequentially.
-
-```typescript {6} filename="src/test-workflow.ts" showLineNumbers copy
-import { mastra } from "./mastra";
-
-const run = await mastra.getWorkflow("testWorkflow").createRunAsync();
-
-const result = await run.start({
-  inputData: [{ number: 10 }, { number: 100 }, { number: 200 }]
-});
-```
-
-To execute this run from your terminal:
-
-```bash copy
-npx tsx src/test-workflow.ts
-```