@mastra/memory 1.26.1-alpha.6 → 1.26.1-alpha.7

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/memory
 
+## 1.26.1-alpha.7
+
+### Patch Changes
+
+- Fixed a crash where updating a thread without a title (for example during observational memory buffering) could write a null title and violate the database's not-null constraint when running a newer @mastra/memory against an older storage package. Memory now checks whether the connected storage adapter supports partial thread updates and backfills the existing title for older adapters, so mixed-version deployments keep working. See #21041 for the original title-clobbering fix this makes backward compatible. ([#21257](https://github.com/mastra-ai/mastra/pull/21257))
+
+- Storage adapters now declare support for partial thread updates, letting newer @mastra/memory preserve existing thread titles instead of overwriting them, while remaining safe against older versions. ([#21257](https://github.com/mastra-ai/mastra/pull/21257))
+
+- Updated dependencies [[`dc4a25d`](https://github.com/mastra-ai/mastra/commit/dc4a25d41af4e2fe97a816070eaec6aa963ab53b), [`dc4a25d`](https://github.com/mastra-ai/mastra/commit/dc4a25d41af4e2fe97a816070eaec6aa963ab53b)]:
+  - @mastra/core@1.58.0-alpha.15
+
 ## 1.26.1-alpha.6
 
 ### Patch Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-memory
 description: Documentation for @mastra/memory. Use when working with @mastra/memory APIs, configuration, or implementation.
 metadata:
   package: "@mastra/memory"
-  version: "1.26.1-alpha.6"
+  version: "1.26.1-alpha.7"
 ---
 
 ## When to use
@@ -31,6 +31,18 @@ Read the individual reference documents for detailed explanations and code examp
 - [Working memory](references/docs-memory-working-memory.md) - Learn how to configure working memory in Mastra to store persistent user data, preferences.
 - [Storage overview](references/docs-storage-overview.md) - Configure storage for Mastra to persist runtime state across agents, workflows, observability, evals, schedules, and memory.
 
+### Integrations
+
+- [GitHub](references/integrations-channels-github.md) - Notify a Mastra agent when subscribed GitHub pull requests change.
+- [Aurora DSQL](references/integrations-databases-aurora-dsql.md) - Documentation for the Amazon Aurora DSQL storage implementation in Mastra.
+- [DynamoDB](references/integrations-databases-dynamodb.md) - Documentation for the DynamoDB storage implementation in Mastra, using a single-table design with ElectroDB.
+- [libSQL](references/integrations-databases-libsql.md) - Documentation for the libSQL storage implementation in Mastra.
+- [MongoDB](references/integrations-databases-mongodb.md) - Documentation for the MongoDB storage implementation in Mastra.
+- [OracleDB](references/integrations-databases-oracledb.md) - Documentation for the Oracle Database storage provider in Mastra.
+- [PostgreSQL](references/integrations-databases-postgresql.md) - Documentation for the PostgreSQL storage implementation in Mastra.
+- [Redis](references/integrations-databases-redis.md) - Documentation for the Redis storage implementation in Mastra.
+- [Upstash](references/integrations-databases-upstash.md) - Documentation for the Upstash storage implementation in Mastra.
+
 ### Reference
 
 - [Reference: Mastra.getMemory()](references/reference-core-getMemory.md) - Documentation for the `Mastra.getMemory()` method in Mastra, which retrieves a registered memory instance by its registry key.
@@ -45,15 +57,9 @@ Read the individual reference documents for detailed explanations and code examp
 - [Reference: Observational Memory](references/reference-memory-observational-memory.md) - API reference for Observational Memory in Mastra: a three-tier memory system that uses Observer and Reflector agents to maintain long-term memory across conversations.
 - [Reference: summarizeConversation()](references/reference-memory-summarizeConversation.md) - Documentation for the standalone `summarizeConversation()` function in Mastra, which summarizes messages you pass in and extracts structured values from them.
 - [Reference: Memory.summarizeThread()](references/reference-memory-summarizeThread.md) - Documentation for the `Memory.summarizeThread()` method in Mastra, which summarizes a thread's conversation in one shot and extracts structured values from it.
+- [Migration: AgentNetwork to .network()](references/reference-migrations-agentnetwork.md) - Learn how to migrate from AgentNetwork primitives to .network() in Mastra.
+- [Memory](references/reference-migrations-upgrade-to-v1-memory.md) - Learn how to migrate memory-related changes when upgrading to v1.
 - [Reference: TokenLimiterProcessor](references/reference-processors-token-limiter-processor.md) - Documentation for the TokenLimiterProcessor in Mastra, which limits the number of tokens in messages.
-- [Reference: Aurora DSQL Storage](references/reference-storage-dsql.md) - Documentation for the Amazon Aurora DSQL storage implementation in Mastra.
-- [Reference: DynamoDB storage](references/reference-storage-dynamodb.md) - Documentation for the DynamoDB storage implementation in Mastra, using a single-table design with ElectroDB.
-- [Reference: libSQL storage](references/reference-storage-libsql.md) - Documentation for the libSQL storage implementation in Mastra.
-- [Reference: MongoDB storage](references/reference-storage-mongodb.md) - Documentation for the MongoDB storage implementation in Mastra.
-- [Reference: OracleDB storage](references/reference-storage-oracledb.md) - Documentation for the Oracle Database storage provider in Mastra.
-- [Reference: PostgreSQL storage](references/reference-storage-postgresql.md) - Documentation for the PostgreSQL storage implementation in Mastra.
-- [Reference: Redis Storage](references/reference-storage-redis.md) - Documentation for the Redis storage implementation in Mastra.
-- [Reference: Upstash storage](references/reference-storage-upstash.md) - Documentation for the Upstash storage implementation in Mastra.
 - [Reference: libSQL vector store](references/reference-vectors-libsql.md) - Documentation for the LibSQLVector class in Mastra, which provides vector search using libSQL with vector extensions.
 - [Reference: MongoDB vector store](references/reference-vectors-mongodb.md) - Documentation for the MongoDBVector class in Mastra, which provides vector search using MongoDB Atlas and Atlas Vector Search.
 - [Reference: OracleDB vector store](references/reference-vectors-oracledb.md) - Documentation for the Oracle Database vector provider in Mastra.

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.26.1-alpha.6",
+  "version": "1.26.1-alpha.7",
   "package": "@mastra/memory",
   "exports": {},
   "modules": {

package/dist/docs/references/docs-agents-networks.md

@@ -4,7 +4,7 @@
 
 > **Deprecated:** Agent networks are deprecated and will be removed in a future major release. [Supervisor agents](https://mastra.ai/docs/capabilities/subagents) using `agent.stream()` or `agent.generate()` are now the recommended approach. It provides the same multi-agent coordination with better control, a simpler API, and easier debugging.
 >
-> See the [migration guide](https://mastra.ai/guides/migrations/network-to-supervisor) to upgrade.
+> See the [migration guide](https://mastra.ai/reference/migrations/network-to-supervisor) to upgrade.
 
 A **routing agent** uses an LLM to interpret a request and decide which primitives (subagents, workflows, or tools) to call, in what order, and with what data.
 
@@ -181,4 +181,4 @@ Requirements for automatic resumption:
 ## Related
 
 - [Supervisor agents](https://mastra.ai/docs/capabilities/subagents)
-- [Migration: `.network()` to supervisor agents](https://mastra.ai/guides/migrations/network-to-supervisor)
+- [Migration: `.network()` to supervisor agents](https://mastra.ai/reference/migrations/network-to-supervisor)

package/dist/docs/references/docs-capabilities-subagents.md

@@ -16,7 +16,7 @@ Common use cases:
 - Multi-step tasks that need different expertise at each stage
 - Tasks where you need fine-grained control over delegation behavior
 
-> **Note:** A parent agent that coordinates subagents is often called a supervisor. The supervisor pattern is one approach to building multi-agent systems in Mastra. For other patterns, read the [conceptual overview](https://mastra.ai/guides/concepts/multi-agent-systems).
+> **Note:** A parent agent that coordinates subagents is often called a supervisor. The supervisor pattern is one approach to building multi-agent systems in Mastra. For other patterns, read the [conceptual overview](https://mastra.ai/docs/guides/multi-agent-systems).
 
 ## Quickstart
 
@@ -453,5 +453,5 @@ Version overrides propagate automatically through delegation. See [Subagent vers
 - [Agent.generate() reference](https://mastra.ai/reference/agents/generate)
 - [Agent approval](https://mastra.ai/docs/agents/agent-approval)
 - [Memory in multi-agent systems](https://mastra.ai/docs/memory/overview)
-- [Concept: Multi-agent systems](https://mastra.ai/guides/concepts/multi-agent-systems)
+- [Concept: Multi-agent systems](https://mastra.ai/docs/guides/multi-agent-systems)
 - 📹 [Mastra supervisor agents workshop](https://www.youtube.com/watch?v=FNb2fL9WhQg\&t=1872s)

package/dist/docs/references/docs-memory-memory-processors.md

@@ -313,11 +313,11 @@ Both scenarios are safe - guardrails prevent inappropriate content from being pe
 
 Some storage providers enforce record size limits that base64-encoded file attachments can exceed:
 
-| Provider                                                           | Record size limit |
-| ------------------------------------------------------------------ | ----------------- |
-| [DynamoDB](https://mastra.ai/reference/storage/dynamodb)           | 400 KB            |
-| [Convex](https://mastra.ai/reference/storage/convex)               | 1 MiB             |
-| [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1) | 1 MiB             |
+| Provider                                                                | Record size limit |
+| ----------------------------------------------------------------------- | ----------------- |
+| [DynamoDB](https://mastra.ai/integrations/databases/dynamodb)           | 400 KB            |
+| [Convex](https://mastra.ai/integrations/databases/convex)               | 1 MiB             |
+| [Cloudflare D1](https://mastra.ai/integrations/databases/cloudflare-d1) | 1 MiB             |
 
 PostgreSQL, MongoDB, and libSQL have higher limits and are usually unaffected.
 

package/dist/docs/references/docs-memory-message-history.md

@@ -12,7 +12,7 @@ You can also retrieve message history to display past conversations in your UI.
 >
 > Sending the full history is redundant because Mastra loads messages from storage, and it can cause message ordering bugs when client-side timestamps conflict with stored timestamps.
 >
-> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
+> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
 
 ## Threads and resources
 

package/dist/docs/references/docs-memory-observational-memory.md

@@ -92,7 +92,7 @@ See [configuration options](https://mastra.ai/reference/memory/observational-mem
 >
 > Observational memory still relies on stored conversation history. Sending the full history is redundant and can cause message ordering bugs when client-side timestamps conflict with stored timestamps.
 >
-> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
+> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
 
 > **Note:** OM currently only supports `@mastra/pg`, `@mastra/libsql`, `@mastra/mysql`, `@mastra/mongodb`, `@mastra/convex`, and `@mastra/oracledb` storage adapters. It uses background agents for managing memory. When no model is set, the default model is `google/gemini-2.5-flash`.
 

package/dist/docs/references/docs-storage-overview.md

@@ -190,19 +190,20 @@ You can also route `observability` to a dedicated analytics backend. See the [ob
 
 Each provider page includes installation instructions, configuration parameters, and usage examples:
 
-- [libSQL](https://mastra.ai/reference/storage/libsql)
-- [PostgreSQL](https://mastra.ai/reference/storage/postgresql)
-- [MongoDB](https://mastra.ai/reference/storage/mongodb)
-- [OracleDB](https://mastra.ai/reference/storage/oracledb)
-- [Upstash](https://mastra.ai/reference/storage/upstash)
-- [Redis](https://mastra.ai/reference/storage/redis)
-- [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1)
-- [Cloudflare KV & Durable Objects](https://mastra.ai/reference/storage/cloudflare)
-- [Convex](https://mastra.ai/reference/storage/convex)
-- [DynamoDB](https://mastra.ai/reference/storage/dynamodb)
-- [LanceDB](https://mastra.ai/reference/storage/lance)
-- [Microsoft SQL Server](https://mastra.ai/reference/storage/mssql)
-- [Google Cloud Spanner](https://mastra.ai/reference/storage/spanner)
+- [Cloudflare D1](https://mastra.ai/integrations/databases/cloudflare-d1)
+- [Cloudflare KV & Durable Objects](https://mastra.ai/integrations/databases/cloudflare-kv)
+- [Convex](https://mastra.ai/integrations/databases/convex)
+- [DynamoDB](https://mastra.ai/integrations/databases/dynamodb)
+- [Google Cloud Spanner](https://mastra.ai/integrations/databases/spanner)
+- [LanceDB](https://mastra.ai/integrations/databases/lancedb)
+- [libSQL](https://mastra.ai/integrations/databases/libsql)
+- [Microsoft SQL Server](https://mastra.ai/integrations/databases/mssql)
+- [MongoDB](https://mastra.ai/integrations/databases/mongodb)
+- [Neon Postgres](https://mastra.ai/integrations/databases/neon)
+- [OracleDB](https://mastra.ai/integrations/databases/oracledb)
+- [PostgreSQL](https://mastra.ai/integrations/databases/postgresql)
+- [Redis](https://mastra.ai/integrations/databases/redis)
+- [Upstash](https://mastra.ai/integrations/databases/upstash)
 
 > **Tip:** libSQL is the fastest path for local development because it doesn't require running a separate database server.
 

package/dist/docs/references/integrations-channels-github.md

@@ -0,0 +1,103 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# GitHub
+
+The `@mastra/github-signals` provider lets an agent follow pull requests (PRs). It polls subscribed PRs and sends [notification signals](https://mastra.ai/docs/long-running-agents/signals) to the agent thread when relevant activity occurs.
+
+## Installation
+
+Install GitHub Signals and the memory packages used in this example:
+
+**npm**:
+
+```bash
+npm install @mastra/github-signals @mastra/libsql @mastra/memory
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/github-signals @mastra/libsql @mastra/memory
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/github-signals @mastra/libsql @mastra/memory
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/github-signals @mastra/libsql @mastra/memory
+```
+
+## Prerequisites
+
+GitHub Signals requires:
+
+- A Mastra storage adapter with memory and notification support. The provider stores each subscription in the thread's metadata, so the thread must already exist.
+- The `gitcrawl` command on `PATH`, configured to access the repositories you want to monitor. The provider runs `gitcrawl sync` and reads its SQLite database.
+- The `sqlite3` command on `PATH`.
+- The [GitHub CLI](https://cli.github.com/) installed and authenticated. The provider uses `gh api` to check whether comment authors have access to the repository before notifying the agent.
+
+By default, comments from users with `admin`, `maintain`, or `write` access can trigger notifications. CodeRabbit and Devin bot comments are also allowed. Configure `authorizedPermissions`, `authorizedBots`, or `ignoredBots` when you need different rules.
+
+## Agent and subscription
+
+Create one `GithubSignals` instance and register it on the agent. Register the agent and a storage adapter on the Mastra instance:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Mastra } from '@mastra/core/mastra'
+import { Memory } from '@mastra/memory'
+import { GithubSignals } from '@mastra/github-signals'
+import { LibSQLStore } from '@mastra/libsql'
+
+export const githubSignals = new GithubSignals()
+
+export const devAgent = new Agent({
+  id: 'dev-agent',
+  name: 'Development Agent',
+  instructions: 'Triage pull request activity and help resolve issues.',
+  model: 'openai/gpt-5.6-sol',
+  memory: new Memory(),
+  signals: [githubSignals],
+})
+
+export const mastra = new Mastra({
+  agents: { devAgent },
+  storage: new LibSQLStore({
+    id: 'mastra-storage',
+    url: 'file:./mastra.db',
+  }),
+})
+```
+
+After the agent has created a memory thread, subscribe that thread to a PR. Passing `owner` and `repo` works from any directory:
+
+```typescript
+await githubSignals.subscribeThreadToPR({
+  threadId: 'thread-123',
+  resourceId: 'user-123',
+  pr: {
+    owner: 'acme',
+    repo: 'web-app',
+    number: 42,
+  },
+})
+```
+
+The provider syncs the PR immediately, stores the subscription, and starts polling every five minutes. Set `pollIntervalMs` in the `GithubSignals` constructor to change the interval. If the process restarts, call `startPollingForThread()` for each persisted thread subscription to resume polling.
+
+## Pull request notifications
+
+GitHub Signals notifies the agent when a subscribed PR has:
+
+- A new authorized comment, commit, or other pull request activity.
+- A change in unresolved review threads.
+- Continuous integration (CI) checks that start, fail, or recover.
+- Merge conflicts that appear or are resolved.
+- A state change to closed, reopened, or merged.
+
+The initial sync sends a baseline notification with the current PR state. A merge automatically removes the thread's subscription to that PR.

package/dist/docs/references/{reference-storage-dsql.md → integrations-databases-aurora-dsql.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Aurora DSQL Storage
+# Aurora DSQL
 
 The Aurora DSQL storage implementation provides storage using Amazon Aurora DSQL with IAM authentication.
 

package/dist/docs/references/{reference-storage-dynamodb.md → integrations-databases-dynamodb.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# DynamoDB storage
+# DynamoDB
 
 The DynamoDB storage implementation provides a high-capacity and performant NoSQL database solution for Mastra, using a single-table design pattern with [ElectroDB](https://electrodb.dev/).
 

package/dist/docs/references/{reference-storage-libsql.md → integrations-databases-libsql.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# libSQL storage
+# libSQL
 
 [libSQL](https://docs.turso.tech/libsql) is an open-source, SQLite-compatible database that supports both local and remote deployments. It can be used to store message history, workflow snapshots, traces, and eval scores.
 
@@ -140,4 +140,4 @@ const thread = await memoryStore?.getThreadById({ threadId: '...' })
 
 libSQL supports observability and is ideal for local development. Use the `realtime` [tracing strategy](https://mastra.ai/docs/observability/integrations/exporters/mastra-storage) for immediate visibility while debugging.
 
-For production environments with higher trace volumes, consider using [PostgreSQL](https://mastra.ai/reference/storage/postgresql) or [ClickHouse via composite storage](https://mastra.ai/reference/storage/composite).
+For production environments with higher trace volumes, consider using [PostgreSQL](https://mastra.ai/integrations/databases/postgresql) or [ClickHouse via composite storage](https://mastra.ai/reference/storage/composite).

package/dist/docs/references/{reference-storage-mongodb.md → integrations-databases-mongodb.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# MongoDB storage
+# MongoDB
 
 The MongoDB storage implementation provides a high-capacity storage solution using MongoDB databases with support for both document storage and vector operations.
 

package/dist/docs/references/{reference-storage-oracledb.md → integrations-databases-oracledb.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# OracleDB storage
+# OracleDB
 
 The OracleDB storage provider stores Mastra application state in Oracle Database. It implements Mastra's composite storage interface, so one `OracleStore` instance can back memory, workflow snapshots, observability, scores, scorer definitions, MCP client metadata, and agent registry data.
 

package/dist/docs/references/{reference-storage-postgresql.md → integrations-databases-postgresql.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# PostgreSQL storage
+# PostgreSQL
 
 The PostgreSQL storage implementation provides a production-ready storage solution using PostgreSQL databases.
 

package/dist/docs/references/{reference-storage-redis.md → integrations-databases-redis.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Redis Storage
+# Redis
 
 The Redis storage implementation provides a high-performance storage solution using direct Redis connections via [`node-redis`](https://github.com/redis/node-redis) (the official Redis client for Node.js). It supports standalone Redis, and through custom client configuration, Redis Sentinel and Cluster deployments.
 

package/dist/docs/references/{reference-storage-upstash.md → integrations-databases-upstash.md}

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Upstash storage
+# Upstash
 
 The Upstash storage implementation provides a serverless-friendly storage solution using Upstash's Redis-compatible key-value store.
 

package/dist/docs/references/reference-migrations-agentnetwork.md

@@ -0,0 +1,100 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Migrate from AgentNetwork to `.network()`
+
+As of `v0.20.0` for `@mastra/core`, the following changes apply.
+
+## Upgrade from AI SDK v4 to v5
+
+- Bump all your model provider packages by a major version.
+
+> **Note:** This will ensure that they're all v5 models now.
+
+## Memory is required
+
+- Memory is now required for the agent network to function properly.
+
+> **Note:** You must configure memory for the agent.
+
+## Migration paths
+
+If you were using the `AgentNetwork` primitive, you can replace the `AgentNetwork` with `Agent`.
+
+Before:
+
+```typescript
+import { AgentNetwork } from '@mastra/core/network'
+
+const agent = new AgentNetwork({
+  name: 'agent-network',
+  agents: [agent1, agent2],
+  tools: { tool1, tool2 },
+  model: 'openai/gpt-5.6-sol',
+  instructions: 'You are a network agent that can help users with a variety of tasks.',
+})
+
+await agent.stream('Find me the weather in Tokyo.')
+```
+
+After:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+
+const memory = new Memory()
+
+const agent = new Agent({
+  id: 'agent-network',
+  name: 'agent-network',
+  agents: { agent1, agent2 },
+  tools: { tool1, tool2 },
+  model: 'openai/gpt-5.6-sol',
+  instructions: 'You are a network agent that can help users with a variety of tasks.',
+  memory,
+})
+
+await agent.network('Find me the weather in Tokyo.')
+```
+
+If you were using the `NewAgentNetwork` primitive, you can replace the `NewAgentNetwork` with `Agent`.
+
+Before:
+
+```typescript
+import { NewAgentNetwork } from '@mastra/core/network/vnext'
+
+const agent = new NewAgentNetwork({
+  id: 'agent-network',
+  name: 'agent-network',
+  agents: { agent1, agent2 },
+  workflows: { workflow1 },
+  tools: { tool1, tool2 },
+  model: 'openai/gpt-5.6-sol',
+  instructions: 'You are a network agent that can help users with a variety of tasks.',
+})
+
+await agent.loop('Find me the weather in Tokyo.')
+```
+
+After:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+
+const memory = new Memory()
+
+const agent = new Agent({
+  id: 'agent-network',
+  name: 'agent-network',
+  agents: { agent1, agent2 },
+  workflows: { workflow1 },
+  tools: { tool1, tool2 },
+  model: 'openai/gpt-5.6-sol',
+  instructions: 'You are a network agent that can help users with a variety of tasks.',
+  memory,
+})
+
+await agent.network('Find me the weather in Tokyo.')
+```