🌏 中文版
Release Info
| Item | Value |
|---|---|
| Framework | Mastra (@mastra/core) |
| Version | @mastra/core@1.83.0 |
| Previous version | @mastra/core@1.80.0 |
| Release date | 2026-11-12 |
| Release Notes | Release November 12, 2026 |
| GitHub | mastra-ai/mastra |
| Stars | 29.5k |
Why this release matters
This release splits apart two things that used to live behind the same switch. Before, an Agent's durable: true meant both "the stream can survive a disconnect and reconnect" and "the run's state can be recovered from a checkpoint after the process itself crashes" — two guarantees that sound alike but actually sit at different layers. 1.83.0 makes resumable streaming a default capability of every Agent, durable or not: agent.observe(runId) lets any reader follow a run that's already in flight, and observe().abort() can stop it. But crash recovery from a checkpoint is no longer something durable promises on its own — that now requires wrapping the agent with createDurableAgent({ agent }). The other change worth flagging is the built-in MCP server: exposing an agent to an MCP client used to mean defining your own MCPServer; now @mastra/server opens an endpoint at /api/mcp directly, enabled by default once server.auth is configured, with OAuth discovery and audience checks built in. For teams wiring agents into Claude, ChatGPT, or any other MCP client, that removes a whole layer of manual plumbing.
Simplified: the existing manual MCPServer path (present before 1.83.0, not removed by this release) is omitted — it's just no longer the only option.
Key changes
- Resumable Agent streams, by default for every Agent: every
Agentcan publish a run stream with a replay cache that survives a reconnect;agent.observe(runId),observe().abort(), andagent.abortRunStream(runId)let any reader follow or stop a run across instances, with ownership/TTL enforcement built in → a client disconnecting no longer kills the run by default, and multiple frontends or background workers can track the same run together - Built-in MCP server (
/api/mcp):@mastra/servernow ships an MCP endpoint turned on by default onceserver.authis configured, with noMCPServerto define yourself;server.mcp.oauth(resource,requireAudience,authorizationServers,scopesSupported) handles OAuth discovery and token audience checks, plus a new self-check route atGET /api/mcp/builtin→ exposing agents, workflows, and tools to an MCP client needs one less layer of manual wiring - Workflow Storage Version 2, now broader: the experimental
storageVersion: 2(writing only per-step deltas instead of rewriting the whole run) now works with@mastra/pgand@mastra/libsql, and results can lazily load step history through an asyncsteps()function → long-running workflows write far less, and this is no longer limited to in-memory storage - Resumable AI SDK chat routes:
chatRoute({ resumable: true })now generates a matching POST + reconnect GET endpoint pair that replays or follows an active run throughagent.observe(runId), with explicitserver.apiRoutes: [routes]configuration support → a frontend using the AI SDK'suseChat({ resume: true })can wire straight into this, and a page refresh no longer interrupts a reply that's still streaming - One-off and bounded schedules: schedules now support one-time execution (
runAt) and bounded recurring execution (endAt), withcronmade optional and matching type updates across the server, client, and several storage backends → no more hand-rolling the "turn off the cron after it runs once" cleanup logic
Breaking Changes
Yes, one:
Agent'sdurableoption now controls stream resumption only — it no longer implies crash-recoverable, checkpoint-backed durable execution:- Before:
new Agent({ ..., durable: true })gave you both stream resumption and recovery from a checkpoint after a crash - After:
new Agent({ ..., durable: true })gives you stream resumption only; for crash recovery, switch tocreateDurableAgent({ agent }) - Affected: any project relying on a plain
Agent'sdurable: truefor crash recovery — and note that plain agents now also behave differently on disconnect, since resumable streams are on by default
- Before:
Migration Guide
Upgrading from 1.80.x to 1.83.0
npm install @mastra/core@1.83.0
// Before (pre-1.80.x): durable: true gave you both stream resumption and crash recovery
const agent = new Agent({
name: 'support-agent',
durable: true, // assumed both guarantees came with this
instructions: '...',
});
// After (1.83.0): stream resumption is now a default capability, no flag needed
const agent = new Agent({
name: 'support-agent',
instructions: '...',
});
// For checkpoint-based crash recovery, wrap the agent explicitly
const durableAgent = createDurableAgent({ agent });
After upgrading, check every Agent in your project with durable: true and ask whether it actually needs crash recovery. If it's only there for client-side reconnects, you no longer need the flag at all. But if it genuinely depends on crash recovery — a long-running background task, for instance — forgetting to add createDurableAgent() means silently losing that recovery the next time the process restarts.
Compared to other frameworks
Coincidentally, Agno's v3.2.0, covered here yesterday (Nov 12), is working on a closely related problem: it moved sandboxed agents' cross-replica cancel/resume logic off Redis and onto "Postgres plus a shared checkpoint store." Both frameworks are reinforcing the same direction — making execution state recoverable across instances and restarts — but from different angles. Agno is fixing recovery for the sandbox execution environment itself; Mastra's release here fixes two other layers — who gets to observe or abort a run in flight, plus stream resumption — and deliberately separates that from crash recovery as its own, distinct option. By comparison, Mastra's split here is less about building one unified durable-execution story and more about defining the problem more precisely.
Today's takeaway
I used to treat "resumable" as one concept — if something can reconnect, crash recovery is just an extension of that same idea. Seeing Mastra split the durable option into "stream resumption" and "checkpoint-based crash recovery" as two independent guarantees made it clear these sit at genuinely different layers: stream resumption only needs the server to still remember the run's state, which is a connection-layer concern; crash recovery needs the run's execution state itself persisted to a checkpoint, which is an execution-engine concern. Binding both to one boolean made it unclear, exactly when it mattered most, which guarantee you actually had — which is why this release was willing to break the API rather than keep hiding that distinction.