@mastra/voice-google 0.14.1 → 0.14.2-alpha.1

package/LICENSE.md

@@ -1,10 +1,12 @@
 Portions of this software are licensed as follows:
 
-- All content that resides under any directory named "ee/" within this
+- All content that resides under any directory named `ee/` within this
   repository, including but not limited to:
-  - `packages/core/src/auth/ee/`
-  - `packages/server/src/server/auth/ee/`
-    is licensed under the license defined in `ee/LICENSE`.
+  - `@mastra/core/auth/ee`
+  - `@mastra/core/agent-builder/ee`
+  - `@mastra/editor/ee`
+
+  is licensed under the license defined in [`ee/LICENSE`](https://github.com/mastra-ai/mastra/blob/main/ee/LICENSE).
 
 - All third-party components incorporated into the Mastra Software are
   licensed under the original license provided by the owner of the

package/README.md

@@ -1,8 +1,6 @@
 # @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.
+Add Google Cloud text-to-speech and speech-to-text to Mastra with configurable voices, languages, audio encoding, streaming, and authentication.
 
 ## Installation
 
@@ -10,48 +8,6 @@ Google Cloud Voice integration for Mastra, providing both Text-to-Speech (TTS) a
 npm install @mastra/voice-google
 ```
 
-## Configuration
-
-The module supports multiple authentication methods:
-
-### Option 1: API Key (Development)
-
-Use an API key from [Google Cloud Console](https://console.cloud.google.com/apis/credentials):
-
-```bash
-GOOGLE_API_KEY=your_api_key
-```
-
-### Option 2: Service Account (Recommended)
-
-Use a service account key file:
-
-```bash
-GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
-```
-
-### Option 3: Vertex AI (Recommended for Production)
-
-Use OAuth authentication with Google Cloud Platform for enterprise deployments:
-
-```bash
-# Set project ID
-GOOGLE_CLOUD_PROJECT=your_project_id
-
-# Optional: Set location (defaults to us-central1)
-GOOGLE_CLOUD_LOCATION=us-central1
-
-# Authenticate via gcloud CLI
-gcloud auth application-default login
-```
-
-Or use a service account:
-
-```bash
-GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
-GOOGLE_CLOUD_PROJECT=your_project_id
-```
-
 ## Usage
 
 ### Standard Usage
@@ -84,167 +40,14 @@ const audioStream = await voice.speak('Hello from Mastra!', {
 const text = await voice.listen(audioStream);
 ```
 
-### Vertex AI Mode
-
-For enterprise deployments, use Vertex AI mode which provides better integration with Google Cloud infrastructure:
-
-```typescript
-import { GoogleVoice } from '@mastra/voice-google';
-
-// Initialize with Vertex AI
-const voice = new GoogleVoice({
-  vertexAI: true,
-  project: 'your-gcp-project',
-  location: 'us-central1', // Optional, defaults to 'us-central1'
-  speaker: 'en-US-Studio-O',
-});
-
-// Works the same as standard mode
-const audioStream = await voice.speak('Hello from Vertex AI!');
-const text = await voice.listen(audioStream);
-
-// Check if using Vertex AI
-console.log(voice.isUsingVertexAI()); // true
-console.log(voice.getProject()); // 'your-gcp-project'
-console.log(voice.getLocation()); // 'us-central1'
-```
-
-### Vertex AI with Service Account
-
-```typescript
-import { GoogleVoice } from '@mastra/voice-google';
-
-const voice = new GoogleVoice({
-  vertexAI: true,
-  project: 'your-gcp-project',
-  location: 'us-central1',
-  speechModel: {
-    keyFilename: '/path/to/service-account.json',
-  },
-  listeningModel: {
-    keyFilename: '/path/to/service-account.json',
-  },
-});
-```
-
-### Vertex AI with In-Memory Credentials
-
-```typescript
-import { GoogleVoice } from '@mastra/voice-google';
-
-const voice = new GoogleVoice({
-  vertexAI: true,
-  project: 'your-gcp-project',
-  speechModel: {
-    credentials: {
-      client_email: 'service-account@project.iam.gserviceaccount.com',
-      private_key: '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----',
-    },
-  },
-});
-```
-
-## API Reference
-
-### Constructor Options
-
-| Option           | Type                | Description                                      |
-| ---------------- | ------------------- | ------------------------------------------------ |
-| `speechModel`    | `GoogleModelConfig` | Configuration for TTS                            |
-| `listeningModel` | `GoogleModelConfig` | Configuration for STT                            |
-| `speaker`        | `string`            | Default voice ID (default: `'en-US-Casual-K'`)   |
-| `vertexAI`       | `boolean`           | Enable Vertex AI mode (default: `false`)         |
-| `project`        | `string`            | Google Cloud project ID (required for Vertex AI) |
-| `location`       | `string`            | Google Cloud region (default: `'us-central1'`)   |
-
-### GoogleModelConfig
-
-| Option        | Type     | Description                           |
-| ------------- | -------- | ------------------------------------- |
-| `apiKey`      | `string` | Google Cloud API key                  |
-| `keyFilename` | `string` | Path to service account JSON key file |
-| `credentials` | `object` | In-memory service account credentials |
-
-### Methods
-
-#### `speak(input, options?)`
-
-Converts text to speech.
-
-- `input`: `string | NodeJS.ReadableStream` - Text to convert
-- `options.speaker`: Override default voice
-- `options.languageCode`: Language code (e.g., `'en-US'`)
-- `options.audioConfig`: Audio encoding options
-
-Returns: `Promise<NodeJS.ReadableStream>` - Audio stream
-
-#### `listen(audioStream, options?)`
-
-Converts speech to text.
-
-- `audioStream`: `NodeJS.ReadableStream` - Audio to transcribe
-- `options.config`: Recognition configuration
-
-Returns: `Promise<string>` - Transcribed text
-
-#### `getSpeakers(options?)`
-
-Lists available voices.
-
-- `options.languageCode`: Filter by language (default: `'en-US'`)
-
-Returns: `Promise<Array<{ voiceId: string, languageCodes: string[] }>>`
-
-#### `isUsingVertexAI()`
-
-Returns `true` if Vertex AI mode is enabled.
-
-#### `getProject()`
-
-Returns the configured Google Cloud project ID.
-
-#### `getLocation()`
-
-Returns the configured Google Cloud location/region.
-
-## 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
-- **Vertex AI support for enterprise deployments**
-
-## Required Permissions for Vertex AI
-
-When using Vertex AI, ensure your service account or user has the appropriate IAM roles and OAuth scopes:
-
-### IAM Roles
-
-**For Text-to-Speech:**
-
-- `roles/texttospeech.admin` - Text-to-Speech Admin (full access)
-- `roles/texttospeech.editor` - Text-to-Speech Editor (create and manage)
-- `roles/texttospeech.viewer` - Text-to-Speech Viewer (read-only)
-
-**For Speech-to-Text:**
-
-- `roles/speech.client` - Speech-to-Text Client
-
-### OAuth Scopes
-
-**For synchronous Text-to-Speech synthesis:**
+## Documentation
 
-- `https://www.googleapis.com/auth/cloud-platform` - Full access to Google Cloud Platform services
+- [Google](https://mastra.ai/integrations/voice/google)
 
-**For long-audio Text-to-Speech operations:**
+## Changelog
 
-- `locations.longAudioSynthesize` - Create long-audio synthesis operations
-- `operations.get` - Get operation status
-- `operations.list` - List operations
+See the [package changelog](https://github.com/mastra-ai/mastra/blob/main/voice/google/CHANGELOG.md) for version history and release notes.
 
-## Voice Options
+## Support
 
-View the complete list using the `getSpeakers()` method or [Google Cloud's documentation](https://cloud.google.com/text-to-speech/docs/voices).
+We have an [open community Discord](https://discord.gg/mastra-ai). Come and say hello and let us know if you have any questions or need any help getting things running.

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/base/index.d.ts

@@ -1,4 +1,4 @@
-import { i as IMastraLogger, u as RegisteredLogger } from "../index-S1lgaKO7.js";
+import { i as IMastraLogger, u as RegisteredLogger } from "../index-Biaf3BmX.js";
 //#region src/base/MastraBase.d.ts
 declare class MastraBase {
   #private;

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/index-Biaf3BmX.d.ts

@@ -0,0 +1,319 @@
+import { Transform } from "stream";
+//#region src/logger/adapter.d.ts
+/**
+ * OpenTelemetry-compatible trace correlation fields, injected at the top
+ * level of a logger's native record.
+ *
+ * Field names are part of the platform contract (snake_case, W3C formats):
+ * external consumers (e.g. the Studio logs view reading Railway stdout)
+ * parse structured log lines and look for exactly these keys.
+ */
+interface TraceFields {
+  /** 32-char lowercase hex W3C trace id */
+  trace_id: string;
+  /**
+   * 16-char lowercase hex W3C span id.
+   *
+   * Optional, and omitted rather than emitted empty: the active span may be
+   * one observability never exports (an internal span, or one dropped by
+   * `excludeSpanTypes`), leaving no span id a consumer could look up. The
+   * trace is still addressable in that case, so the line keeps `trace_id` and
+   * drops only this field. Consumers must treat `span_id` as possibly absent.
+   */
+  span_id?: string;
+}
+/**
+ * Destination for log records derived from the logger's native record,
+ * exported to Mastra observability. Structurally compatible with
+ * `LoggerContext` from `@mastra/core/observability`.
+ */
+interface AdapterLogSink {
+  debug(message: string, data?: Record<string, unknown>): void;
+  info(message: string, data?: Record<string, unknown>): void;
+  warn(message: string, data?: Record<string, unknown>): void;
+  error(message: string, data?: Record<string, unknown>): void;
+}
+interface LoggerAdapterOptions {
+  /** Inject trace_id/span_id into the logger's native records. */
+  correlation: boolean;
+  /** Export records derived from the native record to Mastra observability. */
+  export: boolean;
+}
+/**
+ * Context handed to an adaptable logger by Mastra when observability is
+ * wired up. All members are safe to call on every log call (synchronous,
+ * never throw).
+ */
+interface LoggerAdapterContext {
+  /**
+   * Resolve correlation fields for the currently active span, or undefined
+   * when no span is active (in which case no trace fields are added).
+   */
+  resolveTraceFields: () => TraceFields | undefined;
+  /**
+   * Resolve the observability log sink at call time. Returns the
+   * span-correlated sink when a span is active, the global sink otherwise,
+   * and undefined when export is disabled or observability is not
+   * initialized. Records must still be written to the native destination
+   * regardless.
+   */
+  getLogSink: () => AdapterLogSink | undefined;
+  options: LoggerAdapterOptions;
+}
+/**
+ * Capability marker a logger implements to opt into native trace
+ * correlation and observability export. When a configured logger implements
+ * this, Mastra attaches observability directly instead of wrapping the
+ * logger in the deprecated `DualLogger`.
+ */
+interface AdaptableLogger extends IMastraLogger {
+  __attachObservability(ctx: LoggerAdapterContext): void;
+  /**
+   * Stable identity for the attachment target. Loggers whose adapter context
+   * lives in state shared across a root/child family (e.g. PinoLogger's
+   * mixin ref cell) return that shared object, so attaching any family
+   * member is recognized as re-attaching the whole family. Defaults to the
+   * logger instance itself when absent.
+   */
+  __observabilityAttachmentKey?(): object;
+}
+declare function isAdaptableLogger(logger: IMastraLogger): logger is AdaptableLogger;
+/**
+ * Export a tracked exception through the adapter sink, mirroring the
+ * DualLogger dual-write shape (`errorId`/`domain`/`category`/`details`/`cause`
+ * when present on a MastraError-like value). Never throws into the caller.
+ */
+declare function exportTrackedException(ctx: LoggerAdapterContext | undefined, error: Error, metadata?: Record<string, unknown>): void;
+/**
+ * Adapt IMastraLogger's variadic args into the structured `data` payload of
+ * an exported log record. Extracts the first plain object as data,
+ * serializes an Error arg, and collects remaining primitives under `args`
+ * so the derived record preserves all context from the native call.
+ */
+declare function buildLogRecordData(args: unknown[]): Record<string, unknown> | undefined;
+//#endregion
+//#region src/logger/index.d.ts
+declare const RegisteredLogger: {
+  readonly AGENT: 'AGENT';
+  readonly OBSERVABILITY: 'OBSERVABILITY';
+  readonly AUTH: 'AUTH';
+  readonly BROWSER: 'BROWSER';
+  readonly NETWORK: 'NETWORK';
+  readonly WORKFLOW: 'WORKFLOW';
+  readonly LLM: 'LLM';
+  readonly TTS: 'TTS';
+  readonly VOICE: 'VOICE';
+  readonly VECTOR: 'VECTOR';
+  readonly BUNDLER: 'BUNDLER';
+  readonly DEPLOYER: 'DEPLOYER';
+  readonly MEMORY: 'MEMORY';
+  readonly STORAGE: 'STORAGE';
+  readonly EMBEDDINGS: 'EMBEDDINGS';
+  readonly MCP_SERVER: 'MCP_SERVER';
+  readonly SERVER_CACHE: 'SERVER_CACHE';
+  readonly SERVER: 'SERVER';
+  readonly WORKSPACE: 'WORKSPACE';
+  readonly CHANNEL: 'CHANNEL';
+};
+type RegisteredLogger = (typeof RegisteredLogger)[keyof typeof RegisteredLogger];
+declare const LogLevel: {
+  readonly DEBUG: 'debug';
+  readonly INFO: 'info';
+  readonly WARN: 'warn';
+  readonly ERROR: 'error';
+  readonly NONE: 'silent';
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+interface BaseLogMessage {
+  runId?: string;
+  msg: string;
+  level: LogLevel;
+  time: Date;
+  pid: number;
+  hostname: string;
+  name: string;
+}
+declare abstract class LoggerTransport extends Transform {
+  constructor(opts?: any);
+  listLogsByRunId(_args: {
+    runId: string;
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+  listLogs(_args?: {
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    returnPaginationResults?: boolean;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+}
+declare const createCustomTransport: (stream: Transform, listLogs?: LoggerTransport['listLogs'], listLogsByRunId?: LoggerTransport['listLogsByRunId']) => LoggerTransport;
+interface IMastraLogger {
+  debug(message: string, ...args: any[]): void;
+  info(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+  trackException(error: Error, metadata?: Record<string, unknown>): void;
+  getTransports(): Map<string, LoggerTransport>;
+  listLogs(_transportId: string, _params?: {
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+  listLogsByRunId(_args: {
+    transportId: string;
+    runId: string;
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+}
+declare abstract class MastraLogger implements IMastraLogger {
+  protected name: string;
+  protected level: LogLevel;
+  protected transports: Map<string, LoggerTransport>;
+  constructor(options?: {
+    name?: string;
+    level?: LogLevel;
+    transports?: Record<string, LoggerTransport>;
+  });
+  abstract debug(message: string, ...args: any[]): void;
+  abstract info(message: string, ...args: any[]): void;
+  abstract warn(message: string, ...args: any[]): void;
+  abstract error(message: string, ...args: any[]): void;
+  getTransports(): Map<string, LoggerTransport>;
+  trackException(_error: Error, _metadata?: Record<string, unknown>): void;
+  listLogs(transportId: string, params?: {
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+  listLogsByRunId({ transportId, runId, fromDate, toDate, logLevel, filters, page, perPage }: {
+    transportId: string;
+    runId: string;
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+}
+type LogFilterContext = {
+  component?: RegisteredLogger;
+  level: LogLevel;
+  message: string;
+  args: unknown[];
+};
+type LogFilter = (ctx: LogFilterContext) => boolean;
+interface ConsoleLoggerOptions {
+  name?: string;
+  level?: LogLevel;
+  component?: RegisteredLogger;
+  filter?: LogFilter;
+}
+declare class ConsoleLogger extends MastraLogger {
+  #private;
+  protected component?: RegisteredLogger;
+  protected filter?: LogFilter;
+  constructor(options?: ConsoleLoggerOptions);
+  /**
+   * Adapter hook (see `AdaptableLogger`): enables native trace correlation
+   * (trace_id/span_id appended to console output) and observability export
+   * derived from the same record. Called by Mastra during setup.
+   */
+  __attachObservability(ctx: LoggerAdapterContext): void;
+  child(componentOrBindings: RegisteredLogger | Record<string, unknown>): ConsoleLogger;
+  private shouldLog;
+  private prefix;
+  debug(message: string, ...args: any[]): void;
+  info(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+  trackException(error: Error, metadata?: Record<string, unknown>): void;
+  listLogs(_transportId: string, _params?: {
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: never[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+  listLogsByRunId(_args: {
+    transportId: string;
+    runId: string;
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, any>;
+    page?: number;
+    perPage?: number;
+  }): Promise<{
+    logs: never[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  }>;
+}
+//#endregion
+export { buildLogRecordData as _, LogFilter as a, LoggerTransport as c, createCustomTransport as d, AdaptableLogger as f, TraceFields as g, LoggerAdapterOptions as h, IMastraLogger as i, MastraLogger as l, LoggerAdapterContext as m, ConsoleLogger as n, LogFilterContext as o, AdapterLogSink as p, ConsoleLoggerOptions as r, LogLevel as s, BaseLogMessage as t, RegisteredLogger as u, exportTrackedException as v, isAdaptableLogger as y };
+//# sourceMappingURL=index-Biaf3BmX.d.ts.map

package/dist/_types/@internal_voice/dist/_types/@internal_core/dist/request-context/index.d.ts

@@ -44,6 +44,17 @@ declare const MASTRA_VERSIONS_KEY = "mastra__versions";
  * that require the same auth as the Mastra server itself.
  */
 declare const MASTRA_AUTH_TOKEN_KEY = "mastra__authToken";
+/**
+ * Reserved key carrying a delegating agent's `MastraMemory` into a delegated
+ * run, so a sub-agent without its own memory can persist that run's transcript
+ * without the shared sub-agent instance being modified. The value is
+ * `{ agentId, memory }` and only the named agent reads it.
+ *
+ * Holds a live class instance, so it is deliberately run-scoped: it is excluded
+ * from the durable request-context snapshot and is not copied into further
+ * nested delegated runs. Internal to delegation — do not set it yourself.
+ */
+declare const MASTRA_INHERITED_MEMORY_KEY = "mastra__inheritedMemory";
 type VersionSelector = {
   versionId: string;
 } | {
@@ -60,20 +71,54 @@ declare class RequestContext<Values extends Record<string, any> | unknown = unkn
   constructor(iterable?: Values extends Record<string, any> ? RecordToTuple<Partial<Values>> : Iterable<readonly [string, unknown]>);
   /**
    * set a value with strict typing if `Values` is a Record and the key exists in it.
+   *
+   * Declared schema keys stay strictly typed. For runtime-only keys that are not part of
+   * `Values` (for example reserved middleware keys), use {@link setRaw}.
    */
   set<K extends (Values extends Record<string, any> ? keyof Values : string)>(key: K, value: Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : never) : unknown): void;
+  /**
+   * Set a runtime-only key that is not part of the declared `Values` schema.
+   *
+   * The runtime store is an open map: schema validation checks declared keys and
+   * passes undeclared keys through. Use this when writing infrastructure keys
+   * (for example `mastra__resourceId`) or other values that intentionally omit
+   * from `requestContextSchema`.
+   */
+  setRaw(key: string, value: unknown): void;
   /**
    * Get a value with its type
+   *
+   * Declared schema keys stay strictly typed. For runtime-only keys that are not part of
+   * `Values` (for example reserved middleware keys), use {@link getRaw}.
    */
   get<K extends (Values extends Record<string, any> ? keyof Values : string), R = Values extends Record<string, any> ? (K extends keyof Values ? Values[K] : never) : unknown>(key: K): R;
+  /**
+   * Get a runtime-only key that is not part of the declared `Values` schema.
+   *
+   * Returns `unknown` because the schema does not describe these keys — narrow
+   * the result at the call site.
+   */
+  getRaw(key: string): unknown;
   /**
    * Check if a key exists in the container
+   *
+   * Declared schema keys stay strictly typed. For runtime-only keys, use {@link hasRaw}.
    */
   has<K extends (Values extends Record<string, any> ? keyof Values : string)>(key: K): boolean;
+  /**
+   * Check whether a runtime-only key exists in the open map.
+   */
+  hasRaw(key: string): boolean;
   /**
    * Delete a value by key
+   *
+   * Declared schema keys stay strictly typed. For runtime-only keys, use {@link deleteRaw}.
    */
   delete<K extends (Values extends Record<string, any> ? keyof Values : string)>(key: K): boolean;
+  /**
+   * Delete a runtime-only key from the open map.
+   */
+  deleteRaw(key: string): boolean;
   /**
    * Clear all values from the container
    */
@@ -170,5 +215,5 @@ declare class RequestContext<Values extends Record<string, any> | unknown = unkn
   get all(): Values extends Record<string, any> ? Values : Record<string, any>;
 }
 //#endregion
-export { MASTRA_AUTH_TOKEN_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, RequestContext, VersionOverrides, VersionSelector, mergeVersionOverrides };
+export { MASTRA_AUTH_TOKEN_KEY, MASTRA_INHERITED_MEMORY_KEY, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, RequestContext, VersionOverrides, VersionSelector, mergeVersionOverrides };
 //# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_voice/dist/voice/composite-voice.d.ts

@@ -20,7 +20,7 @@ export declare class CompositeVoice extends MastraVoice<unknown, unknown, unknow
     speak(input: string | NodeJS.ReadableStream, options?: {
         speaker?: string;
     } & any): Promise<NodeJS.ReadableStream | void>;
-    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | void | NodeJS.ReadableStream>;
+    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<void | string | NodeJS.ReadableStream>;
     getSpeakers(): Promise<{
         voiceId: string;
     }[]>;

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-voice-google
 description: Documentation for @mastra/voice-google. Use when working with @mastra/voice-google APIs, configuration, or implementation.
 metadata:
   package: "@mastra/voice-google"
-  version: "0.14.1"
+  version: "0.14.2-alpha.1"
 ---
 
 ## When to use
@@ -14,13 +14,13 @@ Use this skill whenever you are working with @mastra/voice-google to obtain the
 
 Read the individual reference documents for detailed explanations and code examples.
 
-### Guides
+### Integrations
 
-- [Voice in Mastra](references/guides-voice-overview.md) - Overview of voice capabilities in Mastra, including text-to-speech, speech-to-text, and real-time speech-to-speech interactions.
+- [Google](references/integrations-voice-google.md) - Add Google Cloud text-to-speech and speech-to-text to Mastra with configurable voices, languages, audio encoding, streaming, and authentication.
 
-### Integrations
+### Reference
 
-- [Google](references/integrations-voice-google.md) - Documentation for the Google Voice implementation, providing text-to-speech and speech-to-text capabilities with support for both API key and Vertex AI authentication.
+- [Voice in Mastra](references/reference-voice-overview.md) - Use Mastra Voice for text-to-speech, speech-to-text, and real-time speech-to-speech interactions through a unified provider interface.
 
 
 Read [assets/SOURCE_MAP.json](assets/SOURCE_MAP.json) for source code references.