@mastra/mcp-docs-server 1.1.42-alpha.8 → 1.1.43-alpha.0

package/.docs/reference/processors/unicode-normalizer.md

@@ -43,7 +43,7 @@ export const agent = new Agent({
   id: 'normalized-agent',
   name: 'normalized-agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai/gpt-5.4',
+  model: 'openai/gpt-5.5',
   inputProcessors: [
     new UnicodeNormalizer({
       stripControlChars: true,

package/.docs/reference/processors/working-memory-processor.md

@@ -67,7 +67,7 @@ const storage = new PostgresStorage({
 export const agent = new Agent({
   name: 'personalized-agent',
   instructions: 'You are a helpful assistant that remembers user preferences',
-  model: 'openai/gpt-5.4',
+  model: 'openai/gpt-5.5',
   inputProcessors: [
     new WorkingMemory({
       storage,

package/.docs/reference/pubsub/base.md

@@ -0,0 +1,168 @@
+# PubSub
+
+`PubSub` is the abstract base class for Mastra's event system. It defines the contract that every pub/sub backend implements, so the rest of Mastra can publish and subscribe to events without knowing which transport is in use.
+
+Mastra uses pub/sub internally for workflow event processing, streaming, and cross-component communication. Most applications use the default [`EventEmitterPubSub`](https://mastra.ai/reference/pubsub/event-emitter) and never construct a `PubSub` directly. Implement this class only when you need a custom transport.
+
+For built-in implementations, see [`EventEmitterPubSub`](https://mastra.ai/reference/pubsub/event-emitter), [`UnixSocketPubSub`](https://mastra.ai/reference/pubsub/unix-socket-pubsub), [`CachingPubSub`](https://mastra.ai/reference/pubsub/caching-pubsub), [`RedisStreamsPubSub`](https://mastra.ai/reference/pubsub/redis-streams), and [`GoogleCloudPubSub`](https://mastra.ai/reference/pubsub/google-cloud-pubsub).
+
+## Usage example
+
+Extend `PubSub` and implement the four abstract methods to add a custom backend.
+
+```typescript
+import { PubSub } from '@mastra/core/events'
+import type { Event, EventCallback, SubscribeOptions } from '@mastra/core/events'
+
+export class CustomPubSub extends PubSub {
+  async publish(topic: string, event: Omit<Event, 'id' | 'createdAt'>): Promise<void> {
+    // Deliver the event to subscribers of `topic`.
+  }
+
+  async subscribe(topic: string, cb: EventCallback, options?: SubscribeOptions): Promise<void> {
+    // Register `cb` to receive events published to `topic`.
+  }
+
+  async unsubscribe(topic: string, cb: EventCallback): Promise<void> {
+    // Remove a previously registered callback.
+  }
+
+  async flush(): Promise<void> {
+    // Wait for any in-flight deliveries to settle.
+  }
+}
+```
+
+Pass the instance to the [Mastra](https://mastra.ai/reference/core/mastra-class) constructor:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { CustomPubSub } from './pubsub'
+
+export const mastra = new Mastra({
+  pubsub: new CustomPubSub(),
+})
+```
+
+## Delivery modes
+
+A `PubSub` declares which delivery modes it supports through the `supportedModes` property. Mastra reads this to decide whether to run a long-lived worker that pulls events.
+
+| Mode   | Description                                                                                                                   |
+| ------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| `pull` | Consumers actively read from the broker, for example Redis Streams `XREADGROUP`. Mastra runs an orchestration worker to read. |
+| `push` | Events arrive without the consumer asking, either in-process or through an HTTP endpoint. No read loop is required.           |
+
+The default is `['pull']` so that custom implementations keep today's behavior unless they opt in to push delivery.
+
+## Methods
+
+### Core methods
+
+#### `publish(topic, event)`
+
+Publishes an event to a topic. The `id` and `createdAt` fields are assigned by the implementation.
+
+```typescript
+await pubsub.publish('my-topic', {
+  type: 'example',
+  data: { value: 1 },
+  runId: 'run-123',
+})
+```
+
+#### `subscribe(topic, cb, options?)`
+
+Registers a callback to receive events published to a topic. When `options.group` is set, subscribers in the same group compete for messages and each event is delivered to one member. Without a group, every subscriber receives every event.
+
+```typescript
+await pubsub.subscribe('my-topic', (event, ack, nack) => {
+  console.log(event)
+})
+```
+
+#### `unsubscribe(topic, cb)`
+
+Removes a previously registered callback from a topic.
+
+```typescript
+await pubsub.unsubscribe('my-topic', callback)
+```
+
+#### `flush()`
+
+Waits for any in-flight deliveries to settle. Call this before shutdown to avoid dropping events.
+
+```typescript
+await pubsub.flush()
+```
+
+### Replay methods
+
+These methods support resuming a stream after a disconnect. The default implementations fall back to a regular `subscribe`, so backends without history support behave as live-only. [`CachingPubSub`](https://mastra.ai/reference/pubsub/caching-pubsub) overrides them to replay cached events.
+
+#### `getHistory(topic, offset?)`
+
+Returns cached events for a topic, starting at `offset`. Returns an empty array when the backend has no history.
+
+```typescript
+const events = await pubsub.getHistory('my-topic', 0)
+```
+
+Returns: `Promise<Event[]>`
+
+#### `subscribeWithReplay(topic, cb)`
+
+Replays cached events, then subscribes to live events.
+
+```typescript
+await pubsub.subscribeWithReplay('my-topic', event => {
+  console.log(event)
+})
+```
+
+#### `subscribeFromOffset(topic, offset, cb)`
+
+Replays cached events starting at a known position, then subscribes to live events. This is more efficient than a full replay when the client knows its last position.
+
+```typescript
+await pubsub.subscribeFromOffset('my-topic', 42, event => {
+  console.log(event)
+})
+```
+
+## Properties
+
+**supportedModes** (`ReadonlyArray<"pull" | "push">`): Delivery modes the implementation supports. Defaults to \`\["pull"]\`.
+
+## Types
+
+### `Event`
+
+**type** (`string`): Event type identifier.
+
+**id** (`string`): Unique event ID, assigned by the implementation on publish.
+
+**data** (`any`): Event payload.
+
+**runId** (`string`): Run the event belongs to.
+
+**createdAt** (`Date`): Timestamp assigned by the implementation on publish.
+
+**index** (`number`): Sequential position used to resume from a specific offset.
+
+**deliveryAttempt** (`number`): Number of times the event has been delivered. Starts at 1. Defaults to 1 when the backend does not track redelivery.
+
+### `SubscribeOptions`
+
+**group** (`string`): When set, subscribers with the same group compete for messages and each event is delivered to one member. When omitted, every subscriber receives every event.
+
+### `EventCallback`
+
+The callback signature for subscribers: `(event: Event, ack?: () => Promise<void>, nack?: () => Promise<void>) => void`.
+
+**event** (`Event`): The delivered event.
+
+**ack** (`() => Promise<void>`): Acknowledge successful processing. The event is removed from the queue.
+
+**nack** (`() => Promise<void>`): Negative acknowledge. The event is requeued for redelivery after a delay.

package/.docs/reference/pubsub/caching-pubsub.md

@@ -0,0 +1,102 @@
+# CachingPubSub
+
+`CachingPubSub` wraps any [`PubSub`](https://mastra.ai/reference/pubsub/base) implementation and adds event caching and replay. It records every published event per topic in a cache, so a subscriber that connects late or reconnects after a disconnect can replay the events it missed before continuing with live events.
+
+Use it to build resumable streams on top of a transport that does not keep history, such as [`EventEmitterPubSub`](https://mastra.ai/reference/pubsub/event-emitter). Transports that already persist events, such as [`RedisStreamsPubSub`](https://mastra.ai/reference/pubsub/redis-streams), do not need this wrapper.
+
+## Usage example
+
+Wrap an inner pub/sub and provide a server cache to store events.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { CachingPubSub, EventEmitterPubSub } from '@mastra/core/events'
+import { InMemoryServerCache } from '@mastra/core/cache'
+
+const cache = new InMemoryServerCache()
+const pubsub = new CachingPubSub(new EventEmitterPubSub(), cache)
+
+export const mastra = new Mastra({
+  pubsub,
+})
+```
+
+The `withCaching` helper returns the same instance and reads better when wrapping inline:
+
+```typescript
+import { withCaching, EventEmitterPubSub } from '@mastra/core/events'
+import { InMemoryServerCache } from '@mastra/core/cache'
+
+const pubsub = withCaching(new EventEmitterPubSub(), new InMemoryServerCache())
+```
+
+## Constructor parameters
+
+**inner** (`PubSub`): The pub/sub implementation to wrap. All publishes and live subscriptions pass through to this instance.
+
+**cache** (`MastraServerCache`): Cache used to store events per topic for replay.
+
+**options** (`CachingPubSubOptions`): Optional configuration.
+
+## Methods
+
+`CachingPubSub` implements the [`PubSub`](https://mastra.ai/reference/pubsub/base) contract. It overrides the replay methods to read cached events. The methods below describe the caching behavior.
+
+### `publish(topic, event)`
+
+Caches the event with a sequential index, then publishes it to the inner pub/sub.
+
+```typescript
+await pubsub.publish('my-topic', {
+  type: 'example',
+  data: { value: 1 },
+  runId: 'run-123',
+})
+```
+
+### `subscribeWithReplay(topic, cb)`
+
+Replays all cached events for the topic, then subscribes to live events.
+
+```typescript
+await pubsub.subscribeWithReplay('my-topic', event => {
+  console.log(event)
+})
+```
+
+### `subscribeFromOffset(topic, offset, cb)`
+
+Replays cached events starting at `offset`, then subscribes to live events. Use this when the client knows its last position, to avoid replaying the whole history.
+
+```typescript
+await pubsub.subscribeFromOffset('my-topic', 42, event => {
+  console.log(event)
+})
+```
+
+### `getHistory(topic, offset?)`
+
+Returns cached events for the topic, starting at `offset`.
+
+```typescript
+const events = await pubsub.getHistory('my-topic', 0)
+```
+
+Returns: `Promise<Event[]>`
+
+## Functions
+
+### `withCaching(pubsub, cache, options?)`
+
+Convenience wrapper that constructs a `CachingPubSub`. Accepts the same arguments as the constructor and returns the new instance.
+
+```typescript
+import { withCaching, EventEmitterPubSub } from '@mastra/core/events'
+import { InMemoryServerCache } from '@mastra/core/cache'
+
+const pubsub = withCaching(new EventEmitterPubSub(), new InMemoryServerCache(), {
+  keyPrefix: 'events:',
+})
+```
+
+Returns: `CachingPubSub`

package/.docs/reference/pubsub/event-emitter.md

@@ -0,0 +1,72 @@
+# EventEmitterPubSub
+
+`EventEmitterPubSub` is the default [`PubSub`](https://mastra.ai/reference/pubsub/base) implementation. It delivers events in-process using a Node.js [`EventEmitter`](https://nodejs.org/api/events.html#class-eventemitter), so it works without any external service.
+
+Use it for single-process applications. For delivery across processes on one host, see [`UnixSocketPubSub`](https://mastra.ai/reference/pubsub/unix-socket-pubsub). For distributed delivery, see [`RedisStreamsPubSub`](https://mastra.ai/reference/pubsub/redis-streams) or [`GoogleCloudPubSub`](https://mastra.ai/reference/pubsub/google-cloud-pubsub).
+
+Because it is in-process, events are not persisted and are not shared with other processes. Wrap it in [`CachingPubSub`](https://mastra.ai/reference/pubsub/caching-pubsub) when you need replay for resumable streams.
+
+## Usage example
+
+`EventEmitterPubSub` is used automatically when you do not configure a `pubsub` option, so most applications never construct it directly. Create one explicitly only when you want to configure or share it.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { EventEmitterPubSub } from '@mastra/core/events'
+
+export const mastra = new Mastra({
+  pubsub: new EventEmitterPubSub(),
+})
+```
+
+To share an emitter with other parts of your application, pass an existing `EventEmitter`:
+
+```typescript
+import EventEmitter from 'node:events'
+import { EventEmitterPubSub } from '@mastra/core/events'
+
+const emitter = new EventEmitter()
+const pubsub = new EventEmitterPubSub(emitter)
+```
+
+## Constructor parameters
+
+**existingEmitter** (`EventEmitter`): An existing Node.js EventEmitter to use for delivery. When omitted, a new EventEmitter is created.
+
+## Properties
+
+**supportedModes** (`ReadonlyArray<"pull" | "push">`): Returns \`\["pull", "push"]\`. The emitter can serve a pull-style worker or push events directly to listeners.
+
+## Methods
+
+`EventEmitterPubSub` implements the [`PubSub`](https://mastra.ai/reference/pubsub/base) contract. The methods below have behavior specific to this implementation.
+
+### `subscribe(topic, cb, options?)`
+
+Registers a callback for a topic. Without `options.group`, every subscriber receives every event. With a group, events are distributed round-robin across members of that group.
+
+```typescript
+await pubsub.subscribe('workflow.events', (event, ack, nack) => {
+  console.log(event)
+})
+```
+
+### `flush()`
+
+Waits for any pending redeliveries from `nack` to fire before resolving.
+
+```typescript
+await pubsub.flush()
+```
+
+### `close()`
+
+Removes all listeners and cancels pending redeliveries. Call this during graceful shutdown.
+
+```typescript
+await pubsub.close()
+```
+
+## Redelivery
+
+When a grouped subscriber calls `nack`, the event is redelivered to the group after a short delay, and its `deliveryAttempt` count increases. Calling `ack` clears the tracking for that event. Fan-out subscribers receive no-op `ack` and `nack` functions, since each event reaches every subscriber once.

package/.docs/reference/pubsub/google-cloud-pubsub.md

@@ -0,0 +1,94 @@
+# GoogleCloudPubSub
+
+`GoogleCloudPubSub` is a [`PubSub`](https://mastra.ai/reference/pubsub/base) implementation backed by [Google Cloud Pub/Sub](https://cloud.google.com/pubsub/docs). It delivers events across processes and hosts using Google Cloud topics and subscriptions, with ordered delivery and message acknowledgment.
+
+Use it for distributed deployments on Google Cloud. For single-process delivery, use [`EventEmitterPubSub`](https://mastra.ai/reference/pubsub/event-emitter). For Redis, use [`RedisStreamsPubSub`](https://mastra.ai/reference/pubsub/redis-streams).
+
+Each topic maps to a Google Cloud topic. Subscriptions with a group share a named subscription, so members compete for events. Subscriptions without a group create a per-instance subscription, so every instance receives every event.
+
+## Installation
+
+**npm**:
+
+```bash
+npm install @mastra/google-cloud-pubsub
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/google-cloud-pubsub
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/google-cloud-pubsub
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/google-cloud-pubsub
+```
+
+## Usage example
+
+Pass a Google Cloud client configuration, such as a project ID.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { GoogleCloudPubSub } from '@mastra/google-cloud-pubsub'
+
+export const mastra = new Mastra({
+  pubsub: new GoogleCloudPubSub({
+    projectId: 'my-project',
+  }),
+})
+```
+
+## Constructor parameters
+
+**config** (`ClientConfig`): Configuration for the Google Cloud Pub/Sub client, including credentials and project ID. See the \`@google-cloud/pubsub\` client documentation for all fields.
+
+## Methods
+
+`GoogleCloudPubSub` implements the [`PubSub`](https://mastra.ai/reference/pubsub/base) contract. The methods below are specific to this implementation.
+
+### `init(topicName, group?)`
+
+Creates the topic and a subscription if they do not already exist, and returns the subscription. `subscribe` calls this internally, so you rarely call it directly.
+
+```typescript
+await pubsub.init('workflow.events')
+```
+
+### `subscribe(topic, cb, options?)`
+
+Subscribes to a topic. With `options.group`, members of the group share a subscription and compete for events. Without a group, the instance receives every event through its own subscription.
+
+```typescript
+await pubsub.subscribe('workflow.events', (event, ack, nack) => {
+  console.log(event)
+})
+```
+
+### `flush()`
+
+Waits for pending acknowledgments to complete.
+
+```typescript
+await pubsub.flush()
+```
+
+### `destroy(topicName)`
+
+Removes the subscription and topic for a given topic name. Use this to clean up Google Cloud resources.
+
+```typescript
+await pubsub.destroy('workflow.events')
+```
+
+## Acknowledgment
+
+Each delivered event includes `ack` and `nack` functions. Call `ack` after successful processing to remove the event from the subscription. When neither is called, Google Cloud redelivers the event after its acknowledgment deadline expires.

package/.docs/reference/pubsub/redis-streams.md

@@ -0,0 +1,108 @@
+# RedisStreamsPubSub
+
+`RedisStreamsPubSub` is a [`PubSub`](https://mastra.ai/reference/pubsub/base) implementation backed by [Redis Streams](https://redis.io/docs/latest/develop/data-types/streams/). It delivers events across processes and hosts, with persistence, consumer groups, and redelivery on failure.
+
+Use it for distributed deployments where several services share an event stream. For single-process delivery, use [`EventEmitterPubSub`](https://mastra.ai/reference/pubsub/event-emitter). For Google Cloud, use [`GoogleCloudPubSub`](https://mastra.ai/reference/pubsub/google-cloud-pubsub).
+
+Each topic maps to a Redis stream key. Subscriptions with a group use a Redis consumer group, so members share work round-robin. Subscriptions without a group create a private consumer group, so every subscriber receives every event.
+
+`RedisStreamsPubSub` is a pull transport: consumers read events with `XREADGROUP`, so Mastra runs an orchestration worker to read on its behalf.
+
+## Installation
+
+**npm**:
+
+```bash
+npm install @mastra/redis-streams
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/redis-streams
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/redis-streams
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/redis-streams
+```
+
+## Usage example
+
+Provide a Redis connection URL.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { RedisStreamsPubSub } from '@mastra/redis-streams'
+
+export const mastra = new Mastra({
+  pubsub: new RedisStreamsPubSub({
+    url: 'redis://localhost:6379',
+  }),
+})
+```
+
+## Constructor parameters
+
+**url** (`string`): Redis connection URL. Falls back to \`redisOptions.url\`. (Default: `redis://localhost:6379`)
+
+**keyPrefix** (`string`): Prefix for stream keys. Each topic maps to \`\<keyPrefix>:\<topic>\`. (Default: `mastra:topic`)
+
+**blockMs** (`number`): How long, in milliseconds, each read blocks while waiting for new events. (Default: `1000`)
+
+**redisOptions** (`RedisClientOptions`): Options passed to the underlying \`redis\` client for advanced configuration.
+
+**maxStreamLength** (`number`): Approximate maximum number of entries kept per stream. Set to 0 to disable trimming. (Default: `10000`)
+
+**reclaimIntervalMs** (`number`): How often, in milliseconds, a subscription reclaims events that an earlier consumer read but never acknowledged. Set to 0 to disable. (Default: `30000`)
+
+**reclaimIdleMs** (`number`): Minimum idle time, in milliseconds, before a pending event is eligible for reclaim. Keep this well above typical processing time to avoid double delivery. (Default: `60000`)
+
+**maxDeliveryAttempts** (`number`): Maximum times an event is redelivered through \`nack\` before it is dropped. Pass \`Infinity\` to disable the cap. (Default: `5`)
+
+**logger** (`{ debug?: Function; warn?: Function }`): Optional logger for diagnostics. When omitted, suppressed errors are silent.
+
+## Properties
+
+**supportedModes** (`ReadonlyArray<"pull" | "push">`): Returns \`\["pull"]\`.
+
+## Methods
+
+`RedisStreamsPubSub` implements the [`PubSub`](https://mastra.ai/reference/pubsub/base) contract. The methods below have behavior specific to this implementation.
+
+### `subscribe(topic, cb, options?)`
+
+Subscribes to a topic. With `options.group`, members of the group share events through a Redis consumer group. Without a group, the subscriber receives every event through a private consumer group.
+
+```typescript
+await pubsub.subscribe('workflow.events', (event, ack, nack) => {
+  console.log(event)
+})
+```
+
+### `flush()`
+
+Waits for in-flight publishes to complete.
+
+```typescript
+await pubsub.flush()
+```
+
+### `close()`
+
+Closes the Redis connections and stops all subscriptions. Call this during graceful shutdown.
+
+```typescript
+await pubsub.close()
+```
+
+## Redelivery and reclaim
+
+When a subscriber calls `nack`, the event is republished with an incremented `deliveryAttempt` and the original is acknowledged. Once an event reaches `maxDeliveryAttempts`, it is dropped instead of redelivered. Separately, each subscription periodically reclaims events that an earlier consumer in the group read but never acknowledged, controlled by `reclaimIntervalMs` and `reclaimIdleMs`.

package/.docs/reference/pubsub/unix-socket-pubsub.md

@@ -0,0 +1,52 @@
+# UnixSocketPubSub
+
+`UnixSocketPubSub` is a [`PubSub`](https://mastra.ai/reference/pubsub/base) implementation that delivers events across processes on a single host using a Unix domain socket. It elects one process as a broker, and other processes connect to it as clients. If the broker exits, the remaining clients elect a new broker automatically.
+
+Use it when several local processes need to share a stream, such as coordinating thread streams across the Mastra Code terminal interface. For single-process delivery, use [`EventEmitterPubSub`](https://mastra.ai/reference/pubsub/event-emitter). For distributed delivery across hosts, use [`RedisStreamsPubSub`](https://mastra.ai/reference/pubsub/redis-streams) or [`GoogleCloudPubSub`](https://mastra.ai/reference/pubsub/google-cloud-pubsub).
+
+`UnixSocketPubSub` is a push transport: events arrive without a read loop, so Mastra does not run a pull worker for it.
+
+## Usage example
+
+Pass a socket path that every participating process shares.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { UnixSocketPubSub } from '@mastra/core/events'
+
+export const mastra = new Mastra({
+  pubsub: new UnixSocketPubSub('/tmp/mastra/events.sock'),
+})
+```
+
+## Constructor parameters
+
+**socketPath** (`string`): Path to the Unix domain socket. All processes that share a stream must use the same path.
+
+**options** (`UnixSocketPubSubOptions`): Optional configuration.
+
+## Properties
+
+**socketPath** (`string`): The socket path passed to the constructor.
+
+**supportedModes** (`ReadonlyArray<"pull" | "push">`): Returns \`\["push"]\`.
+
+**isBroker** (`boolean`): Whether this instance currently acts as the broker.
+
+**remoteClientCount** (`number`): Number of remote clients connected to this broker. Always 0 when this instance is not the broker.
+
+## Methods
+
+`UnixSocketPubSub` implements the [`PubSub`](https://mastra.ai/reference/pubsub/base) contract. The method below is specific to this implementation.
+
+### `close()`
+
+Closes the socket connection and, when this instance is the broker, releases the broker role. Call this during graceful shutdown.
+
+```typescript
+await pubsub.close()
+```
+
+## Broker election
+
+The first process to bind the socket becomes the broker and routes events between all connected clients. Other processes connect as clients. When the broker exits, an exclusive lock file serializes the next election so exactly one client becomes the new broker, and the remaining clients resubscribe to it. This avoids a split-brain state where two processes both act as broker.

package/.docs/reference/rag/rerank.md

@@ -16,7 +16,7 @@ function rerank(
 ```typescript
 import { rerank } from '@mastra/rag'
 
-const model = 'openai/gpt-5.4'
+const model = 'openai/gpt-5.5'
 
 const rerankedResults = await rerank(vectorSearchResults, 'How do I deploy to production?', model, {
   weights: {

package/.docs/reference/server/nestjs-adapter.md

@@ -114,7 +114,7 @@ import { Mastra } from '@mastra/core/mastra'
             greeter: {
               name: 'greeter',
               description: 'Greets the user',
-              model: config.get('MASTRA_MODEL', '__OPENAI_MODEL_MINI__'),
+              model: config.get('MASTRA_MODEL', 'openai/gpt-5-mini'),
             },
           },
         }),

package/.docs/reference/storage/dsql.md

@@ -241,7 +241,7 @@ export const dsqlAgent = new Agent({
   name: 'DSQL Agent',
   instructions:
     'You are an AI agent with the ability to automatically recall memories from previous interactions.',
-  model: 'openai/gpt-5.4',
+  model: 'openai/gpt-5.5',
   memory: new Memory({
     storage: new DSQLStore({
       id: 'dsql-agent-storage',

package/.docs/reference/storage/libsql.md

@@ -93,6 +93,12 @@ storage: new LibSQLStore({
 
 **authToken** (`string`): Authentication token for remote libSQL databases.
 
+## Managed tables
+
+The storage implementation creates the core storage tables automatically, including `mastra_notifications` for notification inbox records and delivery metadata.
+
+`LibSQLStore` exposes notification storage through `getStore('notifications')`.
+
 ## Initialization
 
 When you pass storage to the Mastra class, `init()` is called automatically to create the [core schema](https://mastra.ai/reference/storage/overview):

package/.docs/reference/storage/mongodb.md

@@ -97,6 +97,9 @@ The storage implementation handles collection creation and management automatica
 - `mastra_traces`: Stores telemetry and tracing data
 - `mastra_scorers`: Stores scoring and evaluation data
 - `mastra_resources`: Stores resource working memory data
+- `mastra_notifications`: Stores notification inbox records and delivery metadata
+
+`MongoDBStore` exposes notification storage through `getStore('notifications')`.
 
 ### Initialization
 
@@ -206,7 +209,7 @@ export const mongodbAgent = new Agent({
   name: 'mongodb-agent',
   instructions:
     'You are an AI agent with the ability to automatically recall memories from previous interactions.',
-  model: 'openai/gpt-5.4',
+  model: 'openai/gpt-5.5',
   memory: new Memory({
     storage: new MongoDBStore({
       uri: process.env.MONGODB_URI!,