@mastra/voice-google 0.0.0-commonjs-20250227130920

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+
+> @mastra/voice-google@0.1.1-alpha.0 build C:\Users\Ward\projects\mastra\mastra\voice\google
+> tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.3.6
+TSC Build start
+TSC ⚡️ Build success in 2797ms
+DTS Build start
+CLI Target: es2022
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: C:\Users\Ward\projects\mastra\mastra\voice\google\dist\_tsup-dts-rollup.d.ts
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: C:\Users\Ward\projects\mastra\mastra\voice\google\dist\_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 5320ms
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist\index.js 5.45 KB
+ESM ⚡️ Build success in 141ms
+CJS dist\index.cjs 5.48 KB
+CJS ⚡️ Build success in 142ms

package/CHANGELOG.md

@@ -0,0 +1,83 @@
+# @mastra/voice-google
+
+## 0.0.0-commonjs-20250227130920
+
+### Patch Changes
+
+- 4a712fc: Add support for commonjs
+- Updated dependencies [ed55f1d]
+- Updated dependencies [06aa827]
+- Updated dependencies [8d13b14]
+- Updated dependencies [4a712fc]
+- Updated dependencies [108793c]
+- Updated dependencies [5f28f44]
+  - @mastra/core@0.0.0-commonjs-20250227130920
+
+## 0.1.1-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [06aa827]
+  - @mastra/core@0.4.3-alpha.0
+
+## 0.1.0
+
+### Patch Changes
+
+- 5e0f727: deprecate @mastra/speech-google for @mastra/voice-google
+- Updated dependencies [7fceae1]
+- Updated dependencies [8d94c3e]
+- Updated dependencies [99dcdb5]
+- Updated dependencies [6cb63e0]
+- Updated dependencies [f626fbb]
+- Updated dependencies [e752340]
+- Updated dependencies [eb91535]
+  - @mastra/core@0.4.2
+
+## 0.1.0-alpha.4
+
+### Patch Changes
+
+- Updated dependencies [8d94c3e]
+- Updated dependencies [99dcdb5]
+- Updated dependencies [e752340]
+- Updated dependencies [eb91535]
+  - @mastra/core@0.4.2-alpha.2
+
+## 0.1.0-alpha.3
+
+### Patch Changes
+
+- Updated dependencies [6cb63e0]
+  - @mastra/core@0.4.2-alpha.1
+
+## 0.1.0-alpha.2
+
+### Patch Changes
+
+- 5e0f727: deprecate @mastra/speech-google for @mastra/voice-google
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial release of @mastra/voice-google
+- Combines functionality from deprecated @mastra/speech-google
+- Adds Speech-to-Text capabilities
+- Implements new MastraVoice interface from @mastra/core
+
+### Notes
+
+This package replaces @mastra/speech-google, which reached version 0.1.3-alpha.1. Key features from the previous package:
+
+- Neural Text-to-Speech synthesis
+- Multiple voice options
+- Streaming support
+- Integration with Google Cloud services
+
+The new package adds:
+
+- Speech-to-Text recognition
+- Combined speech and listening models
+- Improved voice management
+- Better type safety and error handling

package/LICENSE

@@ -0,0 +1,44 @@
+Elastic License 2.0 (ELv2)
+
+**Acceptance**
+By using the software, you agree to all of the terms and conditions below.
+
+**Copyright License**
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below
+
+**Limitations**
+You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor’s trademarks is subject to applicable law.
+
+**Patents**
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+**Notices**
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
+
+**No Other Rights**
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+**Termination**
+If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
+
+**No Liability**
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
+
+**Definitions**
+The _licensor_ is the entity offering these terms, and the _software_ is the software the licensor makes available under these terms, including any portion of it.
+
+_you_ refers to the individual or entity agreeing to these terms.
+
+_your company_ is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. _control_ means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+_your licenses_ are all the licenses granted to you for the software under these terms.
+
+_use_ means anything you do with the software requiring one of your licenses.
+
+_trademark_ means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,61 @@
+# @mastra/voice-google
+
+Google Cloud Voice integration for Mastra, providing both Text-to-Speech (TTS) and Speech-to-Text capabilities.
+
+> Note: This package replaces the deprecated @mastra/speech-google package, combining both speech synthesis and recognition capabilities.
+
+## Installation
+
+```bash
+npm install @mastra/voice-google
+```
+
+## Configuration
+
+The module requires the following environment variable:
+
+```bash
+GOOGLE_API_KEY=your_api_key
+```
+
+## Usage
+
+```typescript
+import { GoogleVoice } from '@mastra/voice-google';
+
+// Initialize with configuration
+const voice = new GoogleVoice({
+  speechModel: {
+    apiKey: 'your-api-key', // Optional, can use GOOGLE_API_KEY env var
+  },
+  listeningModel: {
+    apiKey: 'your-api-key', // Optional, can use GOOGLE_API_KEY env var
+  },
+  speaker: 'en-US-Standard-F', // Default voice
+});
+
+// List available voices
+const voices = await voice.getSpeakers();
+
+// Generate speech
+const audioStream = await voice.speak('Hello from Mastra!', {
+  speaker: 'en-US-Standard-F',
+  languageCode: 'en-US',
+});
+
+// Transcribe speech
+const text = await voice.listen(audioStream);
+```
+
+## Features
+
+- Neural Text-to-Speech synthesis
+- Speech-to-Text recognition
+- Multiple voice options across different languages
+- Streaming support for both speech and transcription
+- High-quality audio processing
+- Natural-sounding voice synthesis
+
+## Voice Options
+
+View the complete list using the `getSpeakers()` method or [Google Cloud's documentation](https://cloud.google.com/text-to-speech/docs/voices).

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,73 @@
+import type { google } from '@google-cloud/text-to-speech/build/protos/protos';
+import type { google as google_2 } from '@google-cloud/speech/build/protos/protos';
+import { MastraVoice } from '@mastra/core/voice';
+
+/**
+ * Configuration for Google Cloud Voice models
+ * @interface GoogleModelConfig
+ * @property {string} [apiKey] - Optional Google Cloud API key. If not provided, will use GOOGLE_API_KEY environment variable
+ */
+export declare interface GoogleModelConfig {
+    apiKey?: string;
+}
+
+/**
+ * GoogleVoice class provides Text-to-Speech and Speech-to-Text capabilities using Google Cloud services
+ * @class GoogleVoice
+ * @extends MastraVoice
+ */
+export declare class GoogleVoice extends MastraVoice {
+    private ttsClient;
+    private speechClient;
+    /**
+     * Creates an instance of GoogleVoice
+     * @param {Object} config - Configuration options
+     * @param {GoogleModelConfig} [config.speechModel] - Configuration for speech synthesis
+     * @param {GoogleModelConfig} [config.listeningModel] - Configuration for speech recognition
+     * @param {string} [config.speaker] - Default voice ID to use for speech synthesis
+     * @throws {Error} If no API key is provided via config or environment variable
+     */
+    constructor({ listeningModel, speechModel, speaker, }?: {
+        listeningModel?: GoogleModelConfig;
+        speechModel?: GoogleModelConfig;
+        speaker?: string;
+    });
+    /**
+     * Gets a list of available voices
+     * @returns {Promise<Array<{voiceId: string, languageCodes: string[]}>>} List of available voices and their supported languages. Default language is en-US.
+     */
+    getSpeakers({ languageCode }?: {
+        languageCode?: string;
+    }): Promise<{
+        voiceId: string;
+        languageCodes: string[];
+    }[]>;
+    private streamToString;
+    /**
+     * Converts text to speech
+     * @param {string | NodeJS.ReadableStream} input - Text or stream to convert to speech
+     * @param {Object} [options] - Speech synthesis options
+     * @param {string} [options.speaker] - Voice ID to use
+     * @param {string} [options.languageCode] - Language code for the voice
+     * @param {TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig']} [options.audioConfig] - Audio configuration options
+     * @returns {Promise<NodeJS.ReadableStream>} Stream of synthesized audio. Default encoding is LINEAR16.
+     */
+    speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+        languageCode?: string;
+        audioConfig?: google.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig'];
+    }): Promise<NodeJS.ReadableStream>;
+    /**
+     * Converts speech to text
+     * @param {NodeJS.ReadableStream} audioStream - Audio stream to transcribe. Default encoding is LINEAR16.
+     * @param {Object} [options] - Recognition options
+     * @param {SpeechTypes.cloud.speech.v1.IRecognitionConfig} [options.config] - Recognition configuration
+     * @returns {Promise<string>} Transcribed text
+     */
+    listen(audioStream: NodeJS.ReadableStream, options?: {
+        stream?: boolean;
+        config?: google_2.cloud.speech.v1.IRecognitionConfig;
+    }): Promise<string>;
+}
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,73 @@
+import type { google } from '@google-cloud/text-to-speech/build/protos/protos';
+import type { google as google_2 } from '@google-cloud/speech/build/protos/protos';
+import { MastraVoice } from '@mastra/core/voice';
+
+/**
+ * Configuration for Google Cloud Voice models
+ * @interface GoogleModelConfig
+ * @property {string} [apiKey] - Optional Google Cloud API key. If not provided, will use GOOGLE_API_KEY environment variable
+ */
+export declare interface GoogleModelConfig {
+    apiKey?: string;
+}
+
+/**
+ * GoogleVoice class provides Text-to-Speech and Speech-to-Text capabilities using Google Cloud services
+ * @class GoogleVoice
+ * @extends MastraVoice
+ */
+export declare class GoogleVoice extends MastraVoice {
+    private ttsClient;
+    private speechClient;
+    /**
+     * Creates an instance of GoogleVoice
+     * @param {Object} config - Configuration options
+     * @param {GoogleModelConfig} [config.speechModel] - Configuration for speech synthesis
+     * @param {GoogleModelConfig} [config.listeningModel] - Configuration for speech recognition
+     * @param {string} [config.speaker] - Default voice ID to use for speech synthesis
+     * @throws {Error} If no API key is provided via config or environment variable
+     */
+    constructor({ listeningModel, speechModel, speaker, }?: {
+        listeningModel?: GoogleModelConfig;
+        speechModel?: GoogleModelConfig;
+        speaker?: string;
+    });
+    /**
+     * Gets a list of available voices
+     * @returns {Promise<Array<{voiceId: string, languageCodes: string[]}>>} List of available voices and their supported languages. Default language is en-US.
+     */
+    getSpeakers({ languageCode }?: {
+        languageCode?: string;
+    }): Promise<{
+        voiceId: string;
+        languageCodes: string[];
+    }[]>;
+    private streamToString;
+    /**
+     * Converts text to speech
+     * @param {string | NodeJS.ReadableStream} input - Text or stream to convert to speech
+     * @param {Object} [options] - Speech synthesis options
+     * @param {string} [options.speaker] - Voice ID to use
+     * @param {string} [options.languageCode] - Language code for the voice
+     * @param {TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig']} [options.audioConfig] - Audio configuration options
+     * @returns {Promise<NodeJS.ReadableStream>} Stream of synthesized audio. Default encoding is LINEAR16.
+     */
+    speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+        languageCode?: string;
+        audioConfig?: google.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig'];
+    }): Promise<NodeJS.ReadableStream>;
+    /**
+     * Converts speech to text
+     * @param {NodeJS.ReadableStream} audioStream - Audio stream to transcribe. Default encoding is LINEAR16.
+     * @param {Object} [options] - Recognition options
+     * @param {SpeechTypes.cloud.speech.v1.IRecognitionConfig} [options.config] - Recognition configuration
+     * @returns {Promise<string>} Transcribed text
+     */
+    listen(audioStream: NodeJS.ReadableStream, options?: {
+        stream?: boolean;
+        config?: google_2.cloud.speech.v1.IRecognitionConfig;
+    }): Promise<string>;
+}
+
+export { }

package/dist/index.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+var stream = require('stream');
+var speech = require('@google-cloud/speech');
+var textToSpeech = require('@google-cloud/text-to-speech');
+var voice = require('@mastra/core/voice');
+
+// src/index.ts
+var DEFAULT_VOICE = "en-US-Casual-K";
+var GoogleVoice = class extends voice.MastraVoice {
+  ttsClient;
+  speechClient;
+  /**
+   * Creates an instance of GoogleVoice
+   * @param {Object} config - Configuration options
+   * @param {GoogleModelConfig} [config.speechModel] - Configuration for speech synthesis
+   * @param {GoogleModelConfig} [config.listeningModel] - Configuration for speech recognition
+   * @param {string} [config.speaker] - Default voice ID to use for speech synthesis
+   * @throws {Error} If no API key is provided via config or environment variable
+   */
+  constructor({
+    listeningModel,
+    speechModel,
+    speaker
+  } = {}) {
+    const defaultApiKey = process.env.GOOGLE_API_KEY;
+    const defaultSpeaker = DEFAULT_VOICE;
+    super({
+      speechModel: {
+        name: "",
+        apiKey: speechModel?.apiKey ?? defaultApiKey
+      },
+      listeningModel: {
+        name: "",
+        apiKey: listeningModel?.apiKey ?? defaultApiKey
+      },
+      speaker: speaker ?? defaultSpeaker
+    });
+    const apiKey = defaultApiKey || speechModel?.apiKey || listeningModel?.apiKey;
+    if (!apiKey) {
+      throw new Error(
+        "Google API key is not set, set GOOGLE_API_KEY environment variable or pass apiKey to constructor"
+      );
+    }
+    this.ttsClient = new textToSpeech.TextToSpeechClient({
+      apiKey: this.speechModel?.apiKey || defaultApiKey
+    });
+    this.speechClient = new speech.SpeechClient({
+      apiKey: this.listeningModel?.apiKey || defaultApiKey
+    });
+  }
+  /**
+   * Gets a list of available voices
+   * @returns {Promise<Array<{voiceId: string, languageCodes: string[]}>>} List of available voices and their supported languages. Default language is en-US.
+   */
+  async getSpeakers({ languageCode = "en-US" } = {}) {
+    return this.traced(async () => {
+      const [response] = await this.ttsClient.listVoices({ languageCode });
+      return (response?.voices || []).filter((voice) => voice.name && voice.languageCodes).map((voice) => ({
+        voiceId: voice.name,
+        languageCodes: voice.languageCodes
+      }));
+    }, "voice.google.getSpeakers")();
+  }
+  async streamToString(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+  }
+  /**
+   * Converts text to speech
+   * @param {string | NodeJS.ReadableStream} input - Text or stream to convert to speech
+   * @param {Object} [options] - Speech synthesis options
+   * @param {string} [options.speaker] - Voice ID to use
+   * @param {string} [options.languageCode] - Language code for the voice
+   * @param {TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig']} [options.audioConfig] - Audio configuration options
+   * @returns {Promise<NodeJS.ReadableStream>} Stream of synthesized audio. Default encoding is LINEAR16.
+   */
+  async speak(input, options) {
+    return this.traced(async () => {
+      const text = typeof input === "string" ? input : await this.streamToString(input);
+      const request = {
+        input: { text },
+        voice: {
+          name: options?.speaker || this.speaker,
+          languageCode: options?.languageCode || options?.speaker?.split("-").slice(0, 2).join("-") || "en-US"
+        },
+        audioConfig: options?.audioConfig || { audioEncoding: "LINEAR16" }
+      };
+      const [response] = await this.ttsClient.synthesizeSpeech(request);
+      if (!response.audioContent) {
+        throw new Error("No audio content returned.");
+      }
+      if (typeof response.audioContent === "string") {
+        throw new Error("Audio content is a string.");
+      }
+      const stream$1 = new stream.PassThrough();
+      stream$1.end(Buffer.from(response.audioContent));
+      return stream$1;
+    }, "voice.google.speak")();
+  }
+  /**
+   * Converts speech to text
+   * @param {NodeJS.ReadableStream} audioStream - Audio stream to transcribe. Default encoding is LINEAR16.
+   * @param {Object} [options] - Recognition options
+   * @param {SpeechTypes.cloud.speech.v1.IRecognitionConfig} [options.config] - Recognition configuration
+   * @returns {Promise<string>} Transcribed text
+   */
+  async listen(audioStream, options) {
+    return this.traced(async () => {
+      const chunks = [];
+      for await (const chunk of audioStream) {
+        chunks.push(Buffer.from(chunk));
+      }
+      const buffer = Buffer.concat(chunks);
+      let request = {
+        config: {
+          encoding: "LINEAR16",
+          languageCode: "en-US",
+          ...options?.config
+        },
+        audio: {
+          content: buffer.toString("base64")
+        }
+      };
+      console.log(`BEFORE REQUEST`);
+      const [response] = await this.speechClient.recognize(request);
+      console.log(`AFTER REQUEST`);
+      if (!response.results || response.results.length === 0) {
+        throw new Error("No transcription results returned");
+      }
+      const transcription = response.results.map((result) => {
+        if (!result.alternatives || result.alternatives.length === 0) {
+          return "";
+        }
+        return result.alternatives[0].transcript || "";
+      }).filter((text) => text.length > 0).join(" ");
+      if (!transcription) {
+        throw new Error("No valid transcription found in results");
+      }
+      return transcription;
+    }, "voice.google.listen")();
+  }
+};
+
+exports.GoogleVoice = GoogleVoice;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export { GoogleModelConfig } from './_tsup-dts-rollup.cjs';
+export { GoogleVoice } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { GoogleModelConfig } from './_tsup-dts-rollup.js';
+export { GoogleVoice } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -0,0 +1,146 @@
+import { PassThrough } from 'stream';
+import { SpeechClient } from '@google-cloud/speech';
+import { TextToSpeechClient } from '@google-cloud/text-to-speech';
+import { MastraVoice } from '@mastra/core/voice';
+
+// src/index.ts
+var DEFAULT_VOICE = "en-US-Casual-K";
+var GoogleVoice = class extends MastraVoice {
+  ttsClient;
+  speechClient;
+  /**
+   * Creates an instance of GoogleVoice
+   * @param {Object} config - Configuration options
+   * @param {GoogleModelConfig} [config.speechModel] - Configuration for speech synthesis
+   * @param {GoogleModelConfig} [config.listeningModel] - Configuration for speech recognition
+   * @param {string} [config.speaker] - Default voice ID to use for speech synthesis
+   * @throws {Error} If no API key is provided via config or environment variable
+   */
+  constructor({
+    listeningModel,
+    speechModel,
+    speaker
+  } = {}) {
+    const defaultApiKey = process.env.GOOGLE_API_KEY;
+    const defaultSpeaker = DEFAULT_VOICE;
+    super({
+      speechModel: {
+        name: "",
+        apiKey: speechModel?.apiKey ?? defaultApiKey
+      },
+      listeningModel: {
+        name: "",
+        apiKey: listeningModel?.apiKey ?? defaultApiKey
+      },
+      speaker: speaker ?? defaultSpeaker
+    });
+    const apiKey = defaultApiKey || speechModel?.apiKey || listeningModel?.apiKey;
+    if (!apiKey) {
+      throw new Error(
+        "Google API key is not set, set GOOGLE_API_KEY environment variable or pass apiKey to constructor"
+      );
+    }
+    this.ttsClient = new TextToSpeechClient({
+      apiKey: this.speechModel?.apiKey || defaultApiKey
+    });
+    this.speechClient = new SpeechClient({
+      apiKey: this.listeningModel?.apiKey || defaultApiKey
+    });
+  }
+  /**
+   * Gets a list of available voices
+   * @returns {Promise<Array<{voiceId: string, languageCodes: string[]}>>} List of available voices and their supported languages. Default language is en-US.
+   */
+  async getSpeakers({ languageCode = "en-US" } = {}) {
+    return this.traced(async () => {
+      const [response] = await this.ttsClient.listVoices({ languageCode });
+      return (response?.voices || []).filter((voice) => voice.name && voice.languageCodes).map((voice) => ({
+        voiceId: voice.name,
+        languageCodes: voice.languageCodes
+      }));
+    }, "voice.google.getSpeakers")();
+  }
+  async streamToString(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+  }
+  /**
+   * Converts text to speech
+   * @param {string | NodeJS.ReadableStream} input - Text or stream to convert to speech
+   * @param {Object} [options] - Speech synthesis options
+   * @param {string} [options.speaker] - Voice ID to use
+   * @param {string} [options.languageCode] - Language code for the voice
+   * @param {TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig']} [options.audioConfig] - Audio configuration options
+   * @returns {Promise<NodeJS.ReadableStream>} Stream of synthesized audio. Default encoding is LINEAR16.
+   */
+  async speak(input, options) {
+    return this.traced(async () => {
+      const text = typeof input === "string" ? input : await this.streamToString(input);
+      const request = {
+        input: { text },
+        voice: {
+          name: options?.speaker || this.speaker,
+          languageCode: options?.languageCode || options?.speaker?.split("-").slice(0, 2).join("-") || "en-US"
+        },
+        audioConfig: options?.audioConfig || { audioEncoding: "LINEAR16" }
+      };
+      const [response] = await this.ttsClient.synthesizeSpeech(request);
+      if (!response.audioContent) {
+        throw new Error("No audio content returned.");
+      }
+      if (typeof response.audioContent === "string") {
+        throw new Error("Audio content is a string.");
+      }
+      const stream = new PassThrough();
+      stream.end(Buffer.from(response.audioContent));
+      return stream;
+    }, "voice.google.speak")();
+  }
+  /**
+   * Converts speech to text
+   * @param {NodeJS.ReadableStream} audioStream - Audio stream to transcribe. Default encoding is LINEAR16.
+   * @param {Object} [options] - Recognition options
+   * @param {SpeechTypes.cloud.speech.v1.IRecognitionConfig} [options.config] - Recognition configuration
+   * @returns {Promise<string>} Transcribed text
+   */
+  async listen(audioStream, options) {
+    return this.traced(async () => {
+      const chunks = [];
+      for await (const chunk of audioStream) {
+        chunks.push(Buffer.from(chunk));
+      }
+      const buffer = Buffer.concat(chunks);
+      let request = {
+        config: {
+          encoding: "LINEAR16",
+          languageCode: "en-US",
+          ...options?.config
+        },
+        audio: {
+          content: buffer.toString("base64")
+        }
+      };
+      console.log(`BEFORE REQUEST`);
+      const [response] = await this.speechClient.recognize(request);
+      console.log(`AFTER REQUEST`);
+      if (!response.results || response.results.length === 0) {
+        throw new Error("No transcription results returned");
+      }
+      const transcription = response.results.map((result) => {
+        if (!result.alternatives || result.alternatives.length === 0) {
+          return "";
+        }
+        return result.alternatives[0].transcript || "";
+      }).filter((text) => text.length > 0).join(" ");
+      if (!transcription) {
+        throw new Error("No valid transcription found in results");
+      }
+      return transcription;
+    }, "voice.google.listen")();
+  }
+};
+
+export { GoogleVoice };

package/eslint.config.js

@@ -0,0 +1,6 @@
+import { createConfig } from '@internal/lint/eslint';
+
+const config = await createConfig();
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...config];

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mastra/voice-google",
+  "version": "0.0.0-commonjs-20250227130920",
+  "description": "Mastra Google voice integration",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@google-cloud/speech": "^6.7.0",
+    "@google-cloud/text-to-speech": "^5.0.1",
+    "zod": "^3.24.1",
+    "@mastra/core": "^0.0.0-commonjs-20250227130920"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8",
+    "eslint": "^9.20.1",
+    "@internal/lint": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake",
+    "build:watch": "pnpm build --watch",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,133 @@
+import { createWriteStream, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Readable } from 'node:stream';
+import { describe, expect, it, beforeAll } from 'vitest';
+
+import { GoogleVoice } from './index';
+
+describe('GoogleVoice Integration Tests', () => {
+  let voice: GoogleVoice;
+  const outputDir = join(process.cwd(), 'test-outputs');
+
+  beforeAll(() => {
+    // Create output directory if it doesn't exist
+    try {
+      mkdirSync(outputDir, { recursive: true });
+    } catch (err) {
+      console.error(err);
+      // Ignore if directory already exists
+    }
+
+    voice = new GoogleVoice();
+  });
+
+  describe('getSpeakers', () => {
+    it('should list available voices', async () => {
+      const voices = await voice.getSpeakers();
+      expect(voices.length).toBeGreaterThan(0);
+      expect(voices[0]).toHaveProperty('voiceId');
+      expect(voices[0]).toHaveProperty('languageCodes');
+    }, 10000);
+  });
+
+  describe('speak', () => {
+    it('should generate audio from text and save to file', async () => {
+      const audioStream = await voice.speak('Hello World', {
+        speaker: 'en-US-Standard-F',
+      });
+
+      return new Promise((resolve, reject) => {
+        const outputPath = join(outputDir, 'speech-test.wav');
+        const fileStream = createWriteStream(outputPath);
+        const chunks: Buffer[] = [];
+
+        audioStream.on('data', (chunk: Buffer) => chunks.push(chunk));
+        audioStream.pipe(fileStream);
+
+        fileStream.on('finish', () => {
+          expect(chunks.length).toBeGreaterThan(0);
+          resolve(undefined);
+        });
+
+        audioStream.on('error', reject);
+        fileStream.on('error', reject);
+      });
+    }, 10000);
+
+    it('should work with default voice', async () => {
+      const audioStream = await voice.speak('Test with default voice');
+
+      return new Promise((resolve, reject) => {
+        const outputPath = join(outputDir, 'speech-test-default.wav');
+        const fileStream = createWriteStream(outputPath);
+        const chunks: Buffer[] = [];
+
+        audioStream.on('data', (chunk: Buffer) => chunks.push(chunk));
+        audioStream.pipe(fileStream);
+
+        fileStream.on('finish', () => {
+          expect(chunks.length).toBeGreaterThan(0);
+          resolve(undefined);
+        });
+
+        audioStream.on('error', reject);
+        fileStream.on('error', reject);
+      });
+    }, 10000);
+
+    it('should handle stream input', async () => {
+      const textStream = Readable.from(['Hello', ' from', ' stream', ' input!']);
+
+      const audioStream = await voice.speak(textStream);
+
+      return new Promise((resolve, reject) => {
+        const outputPath = join(outputDir, 'speech-stream-input-test.wav');
+        const fileStream = createWriteStream(outputPath);
+        const chunks: Buffer[] = [];
+
+        audioStream.on('data', (chunk: Buffer) => chunks.push(chunk));
+        audioStream.pipe(fileStream);
+
+        fileStream.on('finish', () => {
+          expect(chunks.length).toBeGreaterThan(0);
+          resolve(undefined);
+        });
+
+        audioStream.on('error', reject);
+        fileStream.on('error', reject);
+      });
+    }, 10000);
+  });
+
+  describe('listen', () => {
+    it('should transcribe audio stream to text', async () => {
+      const audioStream = Readable.from(readFileSync(join(outputDir, 'speech-test.wav')));
+
+      const result = await voice.listen(audioStream);
+      console.log(result);
+      expect(typeof result).toBe('string');
+      expect(result).toContain('hello world');
+    }, 10000);
+
+    // it('should support streaming transcription', async () => {
+    //   const audioStream = Readable.from(
+    //     readFileSync(join(outputDir, 'speech-test.mp3'))
+    //   );
+
+    //   const outputStream = await voice.listen(audioStream, { stream: true });
+    //   expect(outputStream).toBeInstanceOf(PassThrough);
+
+    //   return new Promise((resolve, reject) => {
+    //     const chunks: string[] = [];
+    //     (outputStream as PassThrough).on('data', (chunk: string) => chunks.push(chunk));
+    //     (outputStream as PassThrough).on('end', () => {
+    //       expect(chunks.length).toBeGreaterThan(0);
+    //       const transcription = chunks.join('');
+    //       expect(transcription).toContain('hello world');
+    //       resolve(undefined);
+    //     });
+    //     (outputStream as PassThrough).on('error', reject);
+    //   });
+    // });
+  });
+});

package/src/index.ts

@@ -0,0 +1,199 @@
+import { PassThrough } from 'stream';
+
+import { SpeechClient } from '@google-cloud/speech';
+import type { google as SpeechTypes } from '@google-cloud/speech/build/protos/protos';
+import { TextToSpeechClient } from '@google-cloud/text-to-speech';
+import type { google as TextToSpeechTypes } from '@google-cloud/text-to-speech/build/protos/protos';
+import { MastraVoice } from '@mastra/core/voice';
+
+/**
+ * Configuration for Google Cloud Voice models
+ * @interface GoogleModelConfig
+ * @property {string} [apiKey] - Optional Google Cloud API key. If not provided, will use GOOGLE_API_KEY environment variable
+ */
+export interface GoogleModelConfig {
+  apiKey?: string;
+}
+
+const DEFAULT_VOICE = 'en-US-Casual-K';
+
+/**
+ * GoogleVoice class provides Text-to-Speech and Speech-to-Text capabilities using Google Cloud services
+ * @class GoogleVoice
+ * @extends MastraVoice
+ */
+export class GoogleVoice extends MastraVoice {
+  private ttsClient: TextToSpeechClient;
+  private speechClient: SpeechClient;
+
+  /**
+   * Creates an instance of GoogleVoice
+   * @param {Object} config - Configuration options
+   * @param {GoogleModelConfig} [config.speechModel] - Configuration for speech synthesis
+   * @param {GoogleModelConfig} [config.listeningModel] - Configuration for speech recognition
+   * @param {string} [config.speaker] - Default voice ID to use for speech synthesis
+   * @throws {Error} If no API key is provided via config or environment variable
+   */
+  constructor({
+    listeningModel,
+    speechModel,
+    speaker,
+  }: {
+    listeningModel?: GoogleModelConfig;
+    speechModel?: GoogleModelConfig;
+    speaker?: string;
+  } = {}) {
+    const defaultApiKey = process.env.GOOGLE_API_KEY;
+    const defaultSpeaker = DEFAULT_VOICE;
+
+    super({
+      speechModel: {
+        name: '',
+        apiKey: speechModel?.apiKey ?? defaultApiKey,
+      },
+      listeningModel: {
+        name: '',
+        apiKey: listeningModel?.apiKey ?? defaultApiKey,
+      },
+      speaker: speaker ?? defaultSpeaker,
+    });
+
+    const apiKey = defaultApiKey || speechModel?.apiKey || listeningModel?.apiKey;
+    if (!apiKey) {
+      throw new Error(
+        'Google API key is not set, set GOOGLE_API_KEY environment variable or pass apiKey to constructor',
+      );
+    }
+
+    this.ttsClient = new TextToSpeechClient({
+      apiKey: this.speechModel?.apiKey || defaultApiKey,
+    });
+
+    this.speechClient = new SpeechClient({
+      apiKey: this.listeningModel?.apiKey || defaultApiKey,
+    });
+  }
+
+  /**
+   * Gets a list of available voices
+   * @returns {Promise<Array<{voiceId: string, languageCodes: string[]}>>} List of available voices and their supported languages. Default language is en-US.
+   */
+  async getSpeakers({ languageCode = 'en-US' }: { languageCode?: string } = {}) {
+    return this.traced(async () => {
+      const [response] = await this.ttsClient.listVoices({ languageCode: languageCode });
+      return (response?.voices || [])
+        .filter(voice => voice.name && voice.languageCodes)
+        .map(voice => ({
+          voiceId: voice.name!,
+          languageCodes: voice.languageCodes!,
+        }));
+    }, 'voice.google.getSpeakers')();
+  }
+
+  private async streamToString(stream: NodeJS.ReadableStream): Promise<string> {
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+  }
+
+  /**
+   * Converts text to speech
+   * @param {string | NodeJS.ReadableStream} input - Text or stream to convert to speech
+   * @param {Object} [options] - Speech synthesis options
+   * @param {string} [options.speaker] - Voice ID to use
+   * @param {string} [options.languageCode] - Language code for the voice
+   * @param {TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig']} [options.audioConfig] - Audio configuration options
+   * @returns {Promise<NodeJS.ReadableStream>} Stream of synthesized audio. Default encoding is LINEAR16.
+   */
+  async speak(
+    input: string | NodeJS.ReadableStream,
+    options?: {
+      speaker?: string;
+      languageCode?: string;
+      audioConfig?: TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest['audioConfig'];
+    },
+  ): Promise<NodeJS.ReadableStream> {
+    return this.traced(async () => {
+      const text = typeof input === 'string' ? input : await this.streamToString(input);
+
+      const request: TextToSpeechTypes.cloud.texttospeech.v1.ISynthesizeSpeechRequest = {
+        input: { text },
+        voice: {
+          name: options?.speaker || this.speaker,
+          languageCode: options?.languageCode || options?.speaker?.split('-').slice(0, 2).join('-') || 'en-US',
+        },
+        audioConfig: options?.audioConfig || { audioEncoding: 'LINEAR16' },
+      };
+
+      const [response] = await this.ttsClient.synthesizeSpeech(request);
+
+      if (!response.audioContent) {
+        throw new Error('No audio content returned.');
+      }
+
+      if (typeof response.audioContent === 'string') {
+        throw new Error('Audio content is a string.');
+      }
+
+      const stream = new PassThrough();
+      stream.end(Buffer.from(response.audioContent));
+      return stream;
+    }, 'voice.google.speak')();
+  }
+
+  /**
+   * Converts speech to text
+   * @param {NodeJS.ReadableStream} audioStream - Audio stream to transcribe. Default encoding is LINEAR16.
+   * @param {Object} [options] - Recognition options
+   * @param {SpeechTypes.cloud.speech.v1.IRecognitionConfig} [options.config] - Recognition configuration
+   * @returns {Promise<string>} Transcribed text
+   */
+  async listen(
+    audioStream: NodeJS.ReadableStream,
+    options?: { stream?: boolean; config?: SpeechTypes.cloud.speech.v1.IRecognitionConfig },
+  ): Promise<string> {
+    return this.traced(async () => {
+      const chunks: Buffer[] = [];
+      for await (const chunk of audioStream) {
+        chunks.push(Buffer.from(chunk));
+      }
+      const buffer = Buffer.concat(chunks);
+
+      let request = {
+        config: {
+          encoding: 'LINEAR16',
+          languageCode: 'en-US',
+          ...options?.config,
+        },
+        audio: {
+          content: buffer.toString('base64'),
+        },
+      };
+      console.log(`BEFORE REQUEST`);
+      const [response] = await this.speechClient.recognize(request as SpeechTypes.cloud.speech.v1.IRecognizeRequest);
+      console.log(`AFTER REQUEST`);
+
+      if (!response.results || response.results.length === 0) {
+        throw new Error('No transcription results returned');
+      }
+
+      const transcription = response.results
+        .map((result: any) => {
+          if (!result.alternatives || result.alternatives.length === 0) {
+            return '';
+          }
+          return result.alternatives[0].transcript || '';
+        })
+        .filter((text: string) => text.length > 0)
+        .join(' ');
+
+      if (!transcription) {
+        throw new Error('No valid transcription found in results');
+      }
+
+      return transcription;
+    }, 'voice.google.listen')();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.node.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});