@mastra/mcp-docs-server 0.13.44 → 0.13.45

package/.docs/raw/reference/voice/voice.listen.mdx

@@ -7,41 +7,6 @@ description: "Documentation for the listen() method available in all Mastra voic
 
 The `listen()` method is a core function available in all Mastra voice providers that converts speech to text. It takes an audio stream as input and returns the transcribed text.
 
-## Usage Example
-
-```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.",
-});
-```
-
 ## Parameters
 
 <PropertiesTable
@@ -143,30 +108,42 @@ Each voice provider may support additional options specific to their implementat
   ]}
 />
 
-## Realtime Voice Providers
-
-When using realtime voice providers like `OpenAIRealtimeVoice`, the `listen()` method behaves differently:
-
-- Instead of returning transcribed text, it emits 'writing' events with the transcribed text
-- You need to register an event listener to receive the transcription
+## Usage Example
 
 ```typescript
-import { OpenAIRealtimeVoice } from "@mastra/voice-openai-realtime";
+import { OpenAIVoice } from "@mastra/voice-openai";
 import { getMicrophoneStream } from "@mastra/node-audio";
+import { createReadStream } from "fs";
+import path from "path";
 
-const voice = new OpenAIRealtimeVoice();
-await voice.connect();
+// Initialize a voice provider
+const voice = new OpenAIVoice({
+  listeningModel: {
+    name: "whisper-1",
+    apiKey: process.env.OPENAI_API_KEY,
+  },
+});
 
-// Register event listener for transcription
-voice.on("writing", ({ text, role }) => {
-  console.log(`${role}: ${text}`);
+// 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);
 
-// This will emit 'writing' events instead of returning text
-const microphoneStream = getMicrophoneStream();
-await voice.listen(microphoneStream);
+// 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.",
+});
 ```
 
+
 ## Using with CompositeVoice
 
 When using `CompositeVoice`, the `listen()` method delegates to the configured listening provider:
@@ -177,14 +154,70 @@ import { OpenAIVoice } from "@mastra/voice-openai";
 import { PlayAIVoice } from "@mastra/voice-playai";
 
 const voice = new CompositeVoice({
-  listenProvider: new OpenAIVoice(),
-  speakProvider: new PlayAIVoice(),
+  input: new OpenAIVoice(),
+  output: new PlayAIVoice(),
 });
 
 // This will use the OpenAIVoice provider
 const transcript = await voice.listen(audioStream);
 ```
 
+### Using AI SDK Model Providers
+
+You can also use AI SDK transcription models directly with `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',
+    }
+  }
+});
+```
+
+See the [CompositeVoice reference](/reference/voice/composite-voice) for more details on AI SDK integration.
+
+
+## Realtime Voice Providers
+
+When using realtime voice providers like `OpenAIRealtimeVoice`, the `listen()` method behaves differently:
+
+- Instead of returning transcribed text, it emits 'writing' events with the transcribed text
+- You need to register an event listener to receive the 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);
+```
+
 ## Notes
 
 - Not all voice providers support speech-to-text functionality (e.g., PlayAI, Speechify)
@@ -194,6 +227,7 @@ const transcript = await voice.listen(audioStream);
 - Some providers support streaming transcription, where text is returned as it's transcribed
 - For best performance, consider closing or ending the audio stream when you're done with it
 
+
 ## Related Methods
 
 - [voice.speak()](./voice.speak) - Converts text to speech

package/.docs/raw/reference/voice/voice.speak.mdx

@@ -7,31 +7,6 @@ description: "Documentation for the speak() method available in all Mastra voice
 
 The `speak()` method is a core function available in all Mastra voice providers that converts text to speech. It takes text input and returns an audio stream that can be played or saved.
 
-## Usage Example
-
-```typescript
-import { OpenAIVoice } from "@mastra/voice-openai";
-// Initialize a voice provider
-const voice = new OpenAIVoice({
-  speaker: "alloy", // Default voice
-});
-// Basic usage with default settings
-const audioStream = await voice.speak("Hello, world!");
-// Using a different voice for this specific request
-const audioStreamWithDifferentVoice = await voice.speak("Hello again!", {
-  speaker: "nova",
-});
-// Using provider-specific options
-const audioStreamWithOptions = await voice.speak("Hello with options!", {
-  speaker: "echo",
-  speed: 1.2, // OpenAI-specific option
-});
-// Using a text stream as input
-import { Readable } from "stream";
-const textStream = Readable.from(["Hello", " from", " a", " stream!"]);
-const audioStreamFromTextStream = await voice.speak(textStream);
-```
-
 ## Parameters
 
 <PropertiesTable
@@ -153,6 +128,81 @@ Each voice provider may support additional options specific to their implementat
   ]}
 />
 
+## Usage Example
+
+```typescript
+import { OpenAIVoice } from "@mastra/voice-openai";
+// Initialize a voice provider
+const voice = new OpenAIVoice({
+  speaker: "alloy", // Default voice
+});
+// Basic usage with default settings
+const audioStream = await voice.speak("Hello, world!");
+// Using a different voice for this specific request
+const audioStreamWithDifferentVoice = await voice.speak("Hello again!", {
+  speaker: "nova",
+});
+// Using provider-specific options
+const audioStreamWithOptions = await voice.speak("Hello with options!", {
+  speaker: "echo",
+  speed: 1.2, // OpenAI-specific option
+});
+// Using a text stream as input
+import { Readable } from "stream";
+const textStream = Readable.from(["Hello", " from", " a", " stream!"]);
+const audioStreamFromTextStream = await voice.speak(textStream);
+```
+
+## Using with CompositeVoice
+
+When using `CompositeVoice`, the `speak()` method delegates to the configured speaking provider:
+
+```typescript
+import { CompositeVoice } from "@mastra/core/voice";
+import { OpenAIVoice } from "@mastra/voice-openai";
+import { PlayAIVoice } from "@mastra/voice-playai";
+
+const voice = new CompositeVoice({
+  output: new PlayAIVoice(),
+  input: new OpenAIVoice(),
+});
+
+// This will use the PlayAIVoice provider
+const audioStream = await voice.speak("Hello, world!");
+```
+
+### Using AI SDK Model Providers
+
+You can also use AI SDK speech models directly with `CompositeVoice`:
+
+```typescript
+import { CompositeVoice } from "@mastra/core/voice";
+import { openai } from "@ai-sdk/openai";
+import { elevenlabs } from "@ai-sdk/elevenlabs";
+
+// Use AI SDK speech models
+const voice = new CompositeVoice({
+  output: elevenlabs.speech('eleven_turbo_v2'),  // AI SDK model
+  input: openai.transcription('whisper-1'),      // AI SDK model
+});
+
+// Works the same way
+const audioStream = await voice.speak("Hello from AI SDK!");
+
+// Provider-specific options can be passed through
+const audioWithOptions = await voice.speak("Hello with options!", {
+  speaker: 'Rachel',  // ElevenLabs voice
+  providerOptions: {
+    elevenlabs: {
+      stability: 0.5,
+      similarity_boost: 0.75,
+    }
+  }
+});
+```
+
+See the [CompositeVoice reference](/reference/voice/composite-voice) for more details on AI SDK integration.
+
 ## Realtime Voice Providers
 
 When using realtime voice providers like `OpenAIRealtimeVoice`, the `speak()` method behaves differently:
@@ -181,21 +231,6 @@ voice.on("speaker", (stream) => {
 await voice.speak("Hello, this is realtime speech!");
 ```
 
-## Using with CompositeVoice
-
-When using `CompositeVoice`, the `speak()` method delegates to the configured speaking provider:
-
-```typescript
-import { CompositeVoice } from "@mastra/core/voice";
-import { OpenAIVoice } from "@mastra/voice-openai";
-import { PlayAIVoice } from "@mastra/voice-playai";
-const voice = new CompositeVoice({
-  speakProvider: new PlayAIVoice(),
-  listenProvider: new OpenAIVoice(),
-});
-// This will use the PlayAIVoice provider
-const audioStream = await voice.speak("Hello, world!");
-```
 
 ## Notes
 

package/.docs/raw/voice/overview.mdx

@@ -898,6 +898,30 @@ const voice = new GeminiLiveVoice({
 Visit the [Google Gemini Live Reference](/reference/voice/google-gemini-live) for more information on the Google Gemini Live voice provider.
 
   </TabItem>
+  <TabItem value="aisdk" label="AI SDK">
+
+```typescript
+// AI SDK Voice Configuration
+import { CompositeVoice } from "@mastra/core/voice";
+import { openai } from "@ai-sdk/openai";
+import { elevenlabs } from "@ai-sdk/elevenlabs";
+
+// Use AI SDK models directly - no need to install separate packages
+const voice = new CompositeVoice({
+  input: openai.transcription('whisper-1'),      // AI SDK transcription
+  output: elevenlabs.speech('eleven_turbo_v2'),  // AI SDK speech
+});
+
+// Works seamlessly with your agent
+const voiceAgent = new Agent({
+  id: "aisdk-voice-agent",
+  name: "AI SDK Voice Agent",
+  instructions: "You are a helpful assistant with voice capabilities.",
+  model: openai("gpt-4o"),
+  voice,
+});
+```
+  </TabItem>
 </Tabs>
 
 ### Using Multiple Voice Providers
@@ -951,6 +975,49 @@ const responseAudio = await voice.speak(`You said: ${transcript}`, {
 playAudio(responseAudio);
 ```
 
+### Using AI SDK Model Providers
+
+You can also use AI SDK models directly with `CompositeVoice`:
+
+```typescript
+import { CompositeVoice } from "@mastra/core/voice";
+import { openai } from "@ai-sdk/openai";
+import { elevenlabs } from "@ai-sdk/elevenlabs";
+import { playAudio, getMicrophoneStream } from "@mastra/node-audio";
+
+// Use AI SDK models directly - no provider setup needed
+const voice = new CompositeVoice({
+  input: openai.transcription('whisper-1'),      // AI SDK transcription
+  output: elevenlabs.speech('eleven_turbo_v2'),  // AI SDK speech
+});
+
+// Works the same way as Mastra providers
+const audioStream = getMicrophoneStream();
+const transcript = await voice.listen(audioStream);
+
+console.log("Transcribed text:", transcript);
+
+// Convert text to speech
+const responseAudio = await voice.speak(`You said: ${transcript}`, {
+  speaker: "Rachel", // ElevenLabs voice
+});
+
+playAudio(responseAudio);
+```
+
+You can also mix AI SDK models with Mastra providers:
+
+```typescript
+import { CompositeVoice } from "@mastra/core/voice";
+import { PlayAIVoice } from "@mastra/voice-playai";
+import { groq } from "@ai-sdk/groq";
+
+const voice = new CompositeVoice({
+  input: groq.transcription('whisper-large-v3'),  // AI SDK for STT
+  output: new PlayAIVoice(),                       // Mastra provider for TTS
+});
+```
+
 For more information on the CompositeVoice, refer to the [CompositeVoice Reference](/reference/voice/composite-voice).
 
 ## More Resources

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

@@ -112,6 +112,70 @@ export const testWorkflow = createWorkflow({
 
 > 📹 Watch: How to run steps in parallel and optimize your Mastra workflow → [YouTube (3 minutes)](https://youtu.be/GQJxve5Hki4)
 
+### Output structure
+
+When steps run in parallel, the output is an object where each key is the step's `id` and the value is that step's output. This allows you to access each parallel step's result independently.
+
+```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+const step1 = createStep({
+  id: "format-step",
+  inputSchema: z.object({ message: z.string() }),
+  outputSchema: z.object({ formatted: z.string() }),
+  execute: async ({ inputData }) => ({
+    formatted: inputData.message.toUpperCase()
+  })
+});
+
+const step2 = createStep({
+  id: "count-step",
+  inputSchema: z.object({ message: z.string() }),
+  outputSchema: z.object({ count: z.number() }),
+  execute: async ({ inputData }) => ({
+    count: inputData.message.length
+  })
+});
+
+const step3 = createStep({
+  id: "combine-step",
+  // The inputSchema must match the structure of parallel outputs
+  inputSchema: z.object({
+    "format-step": z.object({ formatted: z.string() }),
+    "count-step": z.object({ count: z.number() })
+  }),
+  outputSchema: z.object({ result: z.string() }),
+  execute: async ({ inputData }) => {
+    // Access each parallel step's output by its id
+    const formatted = inputData["format-step"].formatted;
+    const count = inputData["count-step"].count;
+    return {
+      result: `${formatted} (${count} characters)`
+    };
+  }
+});
+
+export const testWorkflow = createWorkflow({
+  id: "parallel-output-example",
+  inputSchema: z.object({ message: z.string() }),
+  outputSchema: z.object({ result: z.string() })
+})
+  .parallel([step1, step2])
+  .then(step3)
+  .commit();
+
+// When executed with { message: "hello" }
+// The parallel output structure will be:
+// {
+//   "format-step": { formatted: "HELLO" },
+//   "count-step": { count: 5 }
+// }
+```
+
+**Key points:**
+- Each parallel step's output is keyed by its `id`
+- All parallel steps execute simultaneously
+- The next step receives an object containing all parallel step outputs
+- You must define the `inputSchema` of the following step to match this structure
+
 ## Conditional logic with `.branch()`
 
 Use `.branch()` to choose which step to run based on a condition. All steps in a branch need the same `inputSchema` and `outputSchema` because branching requires consistent schemas so workflows can follow different paths.
@@ -158,6 +222,85 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
+### Output structure
+
+When using conditional branching, only one branch executes based on which condition evaluates to `true` first. The output structure is similar to `.parallel()`, where the result is keyed by the executed step's `id`.
+
+```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+const step1 = createStep({
+  id: "initial-step",
+  inputSchema: z.object({ value: z.number() }),
+  outputSchema: z.object({ value: z.number() }),
+  execute: async ({ inputData }) => inputData
+});
+
+const highValueStep = createStep({
+  id: "high-value-step",
+  inputSchema: z.object({ value: z.number() }),
+  outputSchema: z.object({ result: z.string() }),
+  execute: async ({ inputData }) => ({
+    result: `High value: ${inputData.value}`
+  })
+});
+
+const lowValueStep = createStep({
+  id: "low-value-step",
+  inputSchema: z.object({ value: z.number() }),
+  outputSchema: z.object({ result: z.string() }),
+  execute: async ({ inputData }) => ({
+    result: `Low value: ${inputData.value}`
+  })
+});
+
+const finalStep = createStep({
+  id: "final-step",
+  // The inputSchema must account for either branch's output
+  inputSchema: z.object({
+    "high-value-step": z.object({ result: z.string() }).optional(),
+    "low-value-step": z.object({ result: z.string() }).optional()
+  }),
+  outputSchema: z.object({ message: z.string() }),
+  execute: async ({ inputData }) => {
+    // Only one branch will have executed
+    const result = inputData["high-value-step"]?.result || 
+                   inputData["low-value-step"]?.result;
+    return { message: result };
+  }
+});
+
+export const testWorkflow = createWorkflow({
+  id: "branch-output-example",
+  inputSchema: z.object({ value: z.number() }),
+  outputSchema: z.object({ message: z.string() })
+})
+  .then(step1)
+  .branch([
+    [async ({ inputData }) => inputData.value > 10, highValueStep],
+    [async ({ inputData }) => inputData.value <= 10, lowValueStep]
+  ])
+  .then(finalStep)
+  .commit();
+
+// When executed with { value: 15 }
+// Only the high-value-step executes, output structure:
+// {
+//   "high-value-step": { result: "High value: 15" }
+// }
+
+// When executed with { value: 5 }
+// Only the low-value-step executes, output structure:
+// {
+//   "low-value-step": { result: "Low value: 5" }
+// }
+```
+
+**Key points:**
+- Only one branch executes based on condition evaluation order
+- The output is keyed by the executed step's `id`
+- Subsequent steps should handle all possible branch outputs
+- Use optional fields in the `inputSchema` when the next step needs to handle multiple possible branches
+- Conditions are evaluated in the order they're defined
+
 ## Input data mapping
 
 When using `.then()`, `.parallel()`, or `.branch()`, it is sometimes necessary to transform the output of a previous step to match the input of the next. In these cases you can use `.map()` to access the `inputData` and transform it to create a suitable data shape for the next step.
@@ -188,6 +331,43 @@ The `.map()` method provides additional helper functions for more complex mappin
 - [`getInitData()`](/reference/workflows/workflow-methods/map#using-getinitdata): Access the workflow's initial input data
 - [`mapVariable()`](/reference/workflows/workflow-methods/map#using-mapvariable): Use declarative object syntax to extract and rename fields
 
+### Parallel and Branch outputs
+
+When working with `.parallel()` or `.branch()` outputs, you can use `.map()` to transform the data structure before passing it to the next step. This is especially useful when you need to flatten or restructure the output.
+
+```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+export const testWorkflow = createWorkflow({...})
+  .parallel([step1, step2])
+  .map(async ({ inputData }) => {
+    // Transform the parallel output structure
+    return {
+      combined: `${inputData["step1"].value} - ${inputData["step2"].value}`
+    };
+  })
+  .then(nextStep)
+  .commit();
+```
+
+You can also use the helper functions provided by `.map()`:
+
+```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+export const testWorkflow = createWorkflow({...})
+  .branch([
+    [condition1, stepA],
+    [condition2, stepB]
+  ])
+  .map(async ({ inputData, getStepResult }) => {
+    // Access specific step results
+    const stepAResult = getStepResult("stepA");
+    const stepBResult = getStepResult("stepB");
+    
+    // Return the result from whichever branch executed
+    return stepAResult || stepBResult;
+  })
+  .then(nextStep)
+  .commit();
+```
+
 ## Looping steps
 
 Workflows support different looping methods that let you repeat steps until or while a condition is met, or iterate over arrays. Loops can be combined with other control methods like `.then()`.

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @mastra/mcp-docs-server
 
+## 0.13.45
+
+### Patch Changes
+
+- Ensure changelog truncation includes at least 2 versions before cutting off ([#10576](https://github.com/mastra-ai/mastra/pull/10576))
+
+- Updated dependencies [[`5657314`](https://github.com/mastra-ai/mastra/commit/5657314a1f9d49019bb53f357fa48f75a69247ca), [`e5aca78`](https://github.com/mastra-ai/mastra/commit/e5aca78bb7f263bb8b470bedae81efe9805d7544), [`33a607a`](https://github.com/mastra-ai/mastra/commit/33a607a1f716c2029d4a1ff1603dd756129a33b3), [`cc10fc1`](https://github.com/mastra-ai/mastra/commit/cc10fc192d9f527c71a23cc9def10d8718935ee1), [`1f7ee84`](https://github.com/mastra-ai/mastra/commit/1f7ee841a643ef12d90392125881f06fdf877293), [`e7d5149`](https://github.com/mastra-ai/mastra/commit/e7d514995260b63b2108308e85c64de37dcd0f71), [`f195082`](https://github.com/mastra-ai/mastra/commit/f1950822a2425d5ccae78c5d010e02ddb027a869), [`d9986dd`](https://github.com/mastra-ai/mastra/commit/d9986dd3513f7ca3244a8e599a440ccf4d8bc28b), [`a45b0f0`](https://github.com/mastra-ai/mastra/commit/a45b0f0cd19eab1fe4deceae3abf029442c22f74), [`f6e8eb3`](https://github.com/mastra-ai/mastra/commit/f6e8eb3dac53b70b06e906b2818b1d2a5b0486d7), [`ce57a2b`](https://github.com/mastra-ai/mastra/commit/ce57a2b62fd0d5f6532e4ecd1ba9ba93ac9b95fc), [`3236f35`](https://github.com/mastra-ai/mastra/commit/3236f352ae13cc8552c2965164e97bd125dae48d), [`ce57a2b`](https://github.com/mastra-ai/mastra/commit/ce57a2b62fd0d5f6532e4ecd1ba9ba93ac9b95fc), [`0230321`](https://github.com/mastra-ai/mastra/commit/02303217870bedea0ef009bea9a952f24ed38aaf), [`7b541f4`](https://github.com/mastra-ai/mastra/commit/7b541f49eda6f5a87b738198edbd136927599475), [`0eea842`](https://github.com/mastra-ai/mastra/commit/0eea8423cbdd37f2111593c6f7d2efcde4b7e4ce), [`8812fb8`](https://github.com/mastra-ai/mastra/commit/8812fb86ec16fa7096d92dbf82b4fd187b56fa61), [`63ae8a2`](https://github.com/mastra-ai/mastra/commit/63ae8a22c0c09bbb8b9779f5f38934cd75f616af), [`bf810c5`](https://github.com/mastra-ai/mastra/commit/bf810c5c561bd8ef221c0f6bd84e69770b9a38cc), [`ac7ef07`](https://github.com/mastra-ai/mastra/commit/ac7ef07633caee89707142171d2873c888ffef85), [`522f0b4`](https://github.com/mastra-ai/mastra/commit/522f0b45330719858794eabffffde4f343f55549), [`bf810c5`](https://github.com/mastra-ai/mastra/commit/bf810c5c561bd8ef221c0f6bd84e69770b9a38cc), [`8b51d55`](https://github.com/mastra-ai/mastra/commit/8b51d55bae531edf7e383958d7ecee04df31f5d5), [`2131ac5`](https://github.com/mastra-ai/mastra/commit/2131ac571d5065f0a656c57494bca98691bb7609)]:
+  - @mastra/core@0.24.6
+  - @mastra/mcp@0.14.4
+
+## 0.13.45-alpha.0
+
+### Patch Changes
+
+- Ensure changelog truncation includes at least 2 versions before cutting off ([#10576](https://github.com/mastra-ai/mastra/pull/10576))
+
+- Updated dependencies [[`5657314`](https://github.com/mastra-ai/mastra/commit/5657314a1f9d49019bb53f357fa48f75a69247ca), [`e5aca78`](https://github.com/mastra-ai/mastra/commit/e5aca78bb7f263bb8b470bedae81efe9805d7544), [`33a607a`](https://github.com/mastra-ai/mastra/commit/33a607a1f716c2029d4a1ff1603dd756129a33b3), [`cc10fc1`](https://github.com/mastra-ai/mastra/commit/cc10fc192d9f527c71a23cc9def10d8718935ee1), [`1f7ee84`](https://github.com/mastra-ai/mastra/commit/1f7ee841a643ef12d90392125881f06fdf877293), [`e7d5149`](https://github.com/mastra-ai/mastra/commit/e7d514995260b63b2108308e85c64de37dcd0f71), [`f195082`](https://github.com/mastra-ai/mastra/commit/f1950822a2425d5ccae78c5d010e02ddb027a869), [`d9986dd`](https://github.com/mastra-ai/mastra/commit/d9986dd3513f7ca3244a8e599a440ccf4d8bc28b), [`a45b0f0`](https://github.com/mastra-ai/mastra/commit/a45b0f0cd19eab1fe4deceae3abf029442c22f74), [`f6e8eb3`](https://github.com/mastra-ai/mastra/commit/f6e8eb3dac53b70b06e906b2818b1d2a5b0486d7), [`ce57a2b`](https://github.com/mastra-ai/mastra/commit/ce57a2b62fd0d5f6532e4ecd1ba9ba93ac9b95fc), [`3236f35`](https://github.com/mastra-ai/mastra/commit/3236f352ae13cc8552c2965164e97bd125dae48d), [`ce57a2b`](https://github.com/mastra-ai/mastra/commit/ce57a2b62fd0d5f6532e4ecd1ba9ba93ac9b95fc), [`0230321`](https://github.com/mastra-ai/mastra/commit/02303217870bedea0ef009bea9a952f24ed38aaf), [`7b541f4`](https://github.com/mastra-ai/mastra/commit/7b541f49eda6f5a87b738198edbd136927599475), [`0eea842`](https://github.com/mastra-ai/mastra/commit/0eea8423cbdd37f2111593c6f7d2efcde4b7e4ce), [`8812fb8`](https://github.com/mastra-ai/mastra/commit/8812fb86ec16fa7096d92dbf82b4fd187b56fa61), [`63ae8a2`](https://github.com/mastra-ai/mastra/commit/63ae8a22c0c09bbb8b9779f5f38934cd75f616af), [`bf810c5`](https://github.com/mastra-ai/mastra/commit/bf810c5c561bd8ef221c0f6bd84e69770b9a38cc), [`ac7ef07`](https://github.com/mastra-ai/mastra/commit/ac7ef07633caee89707142171d2873c888ffef85), [`522f0b4`](https://github.com/mastra-ai/mastra/commit/522f0b45330719858794eabffffde4f343f55549), [`bf810c5`](https://github.com/mastra-ai/mastra/commit/bf810c5c561bd8ef221c0f6bd84e69770b9a38cc), [`8b51d55`](https://github.com/mastra-ai/mastra/commit/8b51d55bae531edf7e383958d7ecee04df31f5d5), [`2131ac5`](https://github.com/mastra-ai/mastra/commit/2131ac571d5065f0a656c57494bca98691bb7609)]:
+  - @mastra/core@0.24.6-alpha.0
+  - @mastra/mcp@0.14.4-alpha.0
+
 ## 0.13.44
 
 ### Patch Changes

package/dist/{chunk-TUAHUTTB.js → chunk-VE65X75W.js}

@@ -271,15 +271,35 @@ var SOURCE_DIRS = ["packages", "speech", "stores", "voice", "integrations", "dep
   fromRepoRoot
 );
 var CHANGELOGS_DEST = fromPackageRoot(".docs/organized/changelogs");
-var MAX_LINES = 300;
+var MAX_LINES = 500;
+var MIN_VERSIONS = 2;
+var VERSION_HEADER_REGEX = /^## \d+\.\d+\.\d+/;
 function truncateContent(content, maxLines) {
   const lines = content.split("\n");
   if (lines.length <= maxLines) return content;
-  const visibleLines = lines.slice(0, maxLines);
-  const hiddenCount = lines.length - maxLines;
-  return visibleLines.join("\n") + `
+  const versionIndices = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (VERSION_HEADER_REGEX.test(lines[i])) {
+      versionIndices.push(i);
+    }
+  }
+  const versionsInMaxLines = versionIndices.filter((idx) => idx < maxLines).length;
+  let cutoffLine;
+  if (versionsInMaxLines >= MIN_VERSIONS) {
+    cutoffLine = maxLines;
+  } else if (versionIndices.length > MIN_VERSIONS) {
+    cutoffLine = versionIndices[MIN_VERSIONS];
+  } else {
+    cutoffLine = lines.length;
+  }
+  const visibleLines = lines.slice(0, cutoffLine);
+  const hiddenCount = lines.length - cutoffLine;
+  if (hiddenCount > 0) {
+    return visibleLines.join("\n") + `
 
 ... ${hiddenCount} more lines hidden. See full changelog in package directory.`;
+  }
+  return visibleLines.join("\n");
 }
 async function processPackageDir(packagePath, outputDir) {
   let packageName;

package/dist/prepare-docs/package-changes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-changes.d.ts","sourceRoot":"","sources":["../../src/prepare-docs/package-changes.ts"],"names":[],"mappings":"AA8DA;;GAEG;AACH,wBAAsB,qBAAqB,kBAmC1C"}
+{"version":3,"file":"package-changes.d.ts","sourceRoot":"","sources":["../../src/prepare-docs/package-changes.ts"],"names":[],"mappings":"AAiGA;;GAEG;AACH,wBAAsB,qBAAqB,kBAmC1C"}

package/dist/prepare-docs/prepare.js

@@ -1 +1 @@
-export { prepare } from '../chunk-TUAHUTTB.js';
+export { prepare } from '../chunk-VE65X75W.js';