@mastra/mcp-docs-server 1.0.0-beta.1 → 1.0.0-beta.11

package/.docs/organized/changelogs/%40mastra%2Fcore.md

@@ -1,302 +1,502 @@
 # @mastra/core
 
-## 1.0.0-beta.1
+## 1.0.0-beta.11
+
+### Minor Changes
+
+- Respect structured outputs for v2 models so tool schemas aren’t stripped ([#11038](https://github.com/mastra-ai/mastra/pull/11038))
 
 ### Patch Changes
 
-- Set correct peer dependency range for `@mastra/observability` ([#9908](https://github.com/mastra-ai/mastra/pull/9908))
+- Fix type safety for message ordering - restrict `orderBy` to only accept `'createdAt'` field ([#11069](https://github.com/mastra-ai/mastra/pull/11069))
 
-- Add visual styles and labels for more workflow node types ([#9777](https://github.com/mastra-ai/mastra/pull/9777))
+  Messages don't have an `updatedAt` field, but the previous type allowed ordering by it, which would return empty results. This change adds compile-time type safety by making `StorageOrderBy` generic and restricting `StorageListMessagesInput.orderBy` to only accept `'createdAt'`. The API validation schemas have also been updated to reject invalid orderBy values at runtime.
 
-## 1.0.0-beta.0
+- Loosen tools types in processInputStep / prepareStep. ([#11071](https://github.com/mastra-ai/mastra/pull/11071))
 
-### Major Changes
+- Added the ability to provide a base path for Mastra Studio. ([#10441](https://github.com/mastra-ai/mastra/pull/10441))
+
+  ```ts
+  import { Mastra } from '@mastra/core';
+
+  export const mastra = new Mastra({
+    server: {
+      studioBase: '/my-mastra-studio',
+    },
+  });
+  ```
+
+  This will make Mastra Studio available at `http://localhost:4111/my-mastra-studio`.
 
-- Moving scorers under the eval domain, api method consistency, prebuilt evals, scorers require ids. ([#9589](https://github.com/mastra-ai/mastra/pull/9589))
+- Expand `processInputStep` processor method and integrate `prepareStep` as a processor ([#10774](https://github.com/mastra-ai/mastra/pull/10774))
 
-- **BREAKING CHANGE**: Scorers for Agents will now use `MastraDBMessage` instead of `UIMessage` ([#9702](https://github.com/mastra-ai/mastra/pull/9702))
-  - Scorer input/output types now use `MastraDBMessage[]` with nested `content` object structure
-  - Added `getTextContentFromMastraDBMessage()` helper function to extract text content from `MastraDBMessage` objects
-  - Added `createTestMessage()` helper function for creating `MastraDBMessage` objects in tests with optional tool invocations support
-  - Updated `extractToolCalls()` to access tool invocations from nested `content` structure
-  - Updated `getUserMessageFromRunInput()` and `getAssistantMessageFromRunOutput()` to use new message structure
-  - Removed `createUIMessage()`
+  **New Features:**
+  - `prepareStep` callback now runs through the standard `processInputStep` pipeline
+  - Processors can now modify per-step: `model`, `tools`, `toolChoice`, `activeTools`, `messages`, `systemMessages`, `providerOptions`, `modelSettings`, and `structuredOutput`
+  - Processor chaining: each processor receives accumulated state from previous processors
+  - System messages are isolated per-step (reset at start of each step)
 
-- Every Mastra primitive (agent, MCPServer, workflow, tool, processor, scorer, and vector) now has a get, list, and add method associated with it. Each primitive also now requires an id to be set. ([#9675](https://github.com/mastra-ai/mastra/pull/9675))
+  **Breaking Change:**
+  - `prepareStep` messages format changed from AI SDK v5 model messages to `MastraDBMessage` format
+  - Migration: Use `messageList.get.all.aiV5.model()` if you need the old format
 
-  Primitives that are added to other primitives are also automatically added to the Mastra instance
+- Multiple Processor improvements including: ([#10947](https://github.com/mastra-ai/mastra/pull/10947))
+  - Workflows can now return tripwires, they bubble up from agents that return tripwires in a step
+  - You can write processors as workflows using the existing Workflow primitive, every processor flow is now a workflow.
+  - tripwires that you throw can now return additional information including ability to retry the step
+  - New processor method `processOutputStep` added which runs after every step.
 
-- Update handlers to use `listWorkflowRuns` instead of `getWorkflowRuns`. Fix type names from `StoragelistThreadsByResourceIdInput/Output` to `StorageListThreadsByResourceIdInput/Output`. ([#9507](https://github.com/mastra-ai/mastra/pull/9507))
+  **What's new:**
 
-- **BREAKING:** Remove `getMessagesPaginated()` and add `perPage: false` support ([#9670](https://github.com/mastra-ai/mastra/pull/9670))
+  **1. Retry mechanism with LLM feedback** - Processors can now request retries with feedback that gets sent back to the LLM:
 
-  Removes deprecated `getMessagesPaginated()` method. The `listMessages()` API and score handlers now support `perPage: false` to fetch all records without pagination limits.
+  ```typescript
+  processOutputStep: async ({ text, abort, retryCount }) => {
+    if (isLowQuality(text)) {
+      abort('Response quality too low', { retry: true, metadata: { score: 0.6 } });
+    }
+    return [];
+  };
+  ```
+
+  Configure with `maxProcessorRetries` (default: 3). Rejected steps are preserved in `result.steps[n].tripwire`. Retries are only available in `processOutputStep` and `processInputStep`. It will replay the step with additional context added.
+
+  **2. Workflow orchestration for processors** - Processors can now be composed using workflow primitives:
+
+  ```typescript
+  import { createStep, createWorkflow } from '@mastra/core/workflows';
+  import {
+    ProcessorStepSchema,
+  } from '@mastra/core/processors';
 
-  **Storage changes:**
-  - `StoragePagination.perPage` type changed from `number` to `number | false`
-  - All storage implementations support `perPage: false`:
-    - Memory: `listMessages()`
-    - Scores: `listScoresBySpan()`, `listScoresByRunId()`, `listScoresByExecutionId()`
-  - HTTP query parser accepts `"false"` string (e.g., `?perPage=false`)
+  const moderationWorkflow = createWorkflow({ id: 'moderation', inputSchema: ProcessorStepSchema, outputSchema: ProcessorStepSchema })
+    .then(createStep(new lengthValidator({...})))
+    .parallel([createStep(new piiDetector({...}), createStep(new toxicityChecker({...}))])
+    .commit();
 
-  **Memory changes:**
-  - `memory.query()` parameter type changed from `StorageGetMessagesArg` to `StorageListMessagesInput`
-  - Uses flat parameters (`page`, `perPage`, `include`, `filter`, `vectorSearchString`) instead of `selectBy` object
+  const agent = new Agent({ inputProcessors: [moderationWorkflow] });
+  ```
 
-  **Stricter validation:**
-  - `listMessages()` requires non-empty, non-whitespace `threadId` (throws error instead of returning empty results)
+  Every processor array that gets passed to an agent gets added as a workflow
+  <img width="614" height="673" alt="image" src="https://github.com/user-attachments/assets/0d79f1fd-8fca-4d86-8b45-22fddea984a8" />
 
-  **Migration:**
+  **3. Extended tripwire API** - `abort()` now accepts options for retry control and typed metadata:
 
   ```typescript
-  // Storage/Memory: Replace getMessagesPaginated with listMessages
-  - storage.getMessagesPaginated({ threadId, selectBy: { pagination: { page: 0, perPage: 20 } } })
-  + storage.listMessages({ threadId, page: 0, perPage: 20 })
-  + storage.listMessages({ threadId, page: 0, perPage: false })  // Fetch all
-
-  // Memory: Replace selectBy with flat parameters
-  - memory.query({ threadId, selectBy: { last: 20, include: [...] } })
-  + memory.query({ threadId, perPage: 20, include: [...] })
-
-  // Client SDK
-  - thread.getMessagesPaginated({ selectBy: { pagination: { page: 0 } } })
-  + thread.listMessages({ page: 0, perPage: 20 })
+  abort('reason', { retry: true, metadata: { score: 0.8, category: 'quality' } });
   ```
 
-- # Major Changes ([#9695](https://github.com/mastra-ai/mastra/pull/9695))
+  **4. New `processOutputStep` method** - Per-step output processing with access to step number, finish reason, tool calls, and retry count.
+
+  **5. Workflow tripwire status** - Workflows now have a `'tripwire'` status distinct from `'failed'`, properly bubbling up processor rejections.
 
-  ## Storage Layer
+## 1.0.0-beta.10
+
+### Patch Changes
 
-  ### BREAKING: Removed `storage.getMessages()`
+- Add support for typed structured output in agent workflow steps ([#11014](https://github.com/mastra-ai/mastra/pull/11014))
 
-  The `getMessages()` method has been removed from all storage implementations. Use `listMessages()` instead, which provides pagination support.
+  When wrapping an agent with `createStep()` and providing a `structuredOutput.schema`, the step's `outputSchema` is now correctly inferred from the provided schema instead of defaulting to `{ text: string }`.
 
-  **Migration:**
+  This enables type-safe chaining of agent steps with structured output to subsequent steps:
 
   ```typescript
-  // Before
-  const messages = await storage.getMessages({ threadId: 'thread-1' });
+  const articleSchema = z.object({
+    title: z.string(),
+    summary: z.string(),
+    tags: z.array(z.string()),
+  });
 
-  // After
-  const result = await storage.listMessages({
-    threadId: 'thread-1',
-    page: 0,
-    perPage: 50,
+  // Agent step with structured output - outputSchema is now articleSchema
+  const agentStep = createStep(agent, {
+    structuredOutput: { schema: articleSchema },
+  });
+
+  // Next step can receive the structured output directly
+  const processStep = createStep({
+    id: 'process',
+    inputSchema: articleSchema, // Matches agent's outputSchema
+    outputSchema: z.object({ tagCount: z.number() }),
+    execute: async ({ inputData }) => ({
+      tagCount: inputData.tags.length, // Fully typed!
+    }),
   });
-  const messages = result.messages; // Access messages array
-  console.log(result.total); // Total count
-  console.log(result.hasMore); // Whether more pages exist
+
+  workflow.then(agentStep).then(processStep).commit();
   ```
 
-  ### Message ordering default
+  When `structuredOutput` is not provided, the agent step continues to use the default `{ text: string }` output schema.
 
-  `listMessages()` defaults to ASC (oldest first) ordering by `createdAt`, matching the previous `getMessages()` behavior.
+- Fixed a bug where multiple tools streaming output simultaneously could fail with "WritableStreamDefaultWriter is locked" errors. Tool streaming now works reliably during concurrent tool executions. ([#10830](https://github.com/mastra-ai/mastra/pull/10830))
 
-  **To use DESC ordering (newest first):**
+- Add delete workflow run API ([#10991](https://github.com/mastra-ai/mastra/pull/10991))
 
   ```typescript
-  const result = await storage.listMessages({
-    threadId: 'thread-1',
-    orderBy: { field: 'createdAt', direction: 'DESC' },
-  });
+  await workflow.deleteWorkflowRunById(runId);
   ```
 
-  ## Client SDK
+- Fixed CachedToken tracking in all Observability Exporters. Also fixed TimeToFirstToken in Langfuse, Braintrust, PostHog exporters. Fixed trace formatting in Posthog Exporter. ([#11029](https://github.com/mastra-ai/mastra/pull/11029))
+
+- fix: persist data-\* chunks from writer.custom() to memory storage ([#10884](https://github.com/mastra-ai/mastra/pull/10884))
+  - Add persistence for custom data chunks (`data-*` parts) emitted via `writer.custom()` in tools
+  - Data chunks are now saved to message storage so they survive page refreshes
+  - Update `@assistant-ui/react` to v0.11.47 with native `DataMessagePart` support
+  - Convert `data-*` parts to `DataMessagePart` format (`{ type: 'data', name: string, data: T }`)
+  - Update related `@assistant-ui/*` packages for compatibility
+
+- Fixed double validation bug that prevented Zod transforms from working correctly in tool schemas. ([#11025](https://github.com/mastra-ai/mastra/pull/11025))
+
+  When tools with Zod `.transform()` or `.pipe()` in their `outputSchema` were executed through the Agent pipeline, validation was happening twice - once in Tool.execute() (correct) and again in CoreToolBuilder (incorrect). The second validation received already-transformed data but expected pre-transform data, causing validation errors.
+
+  This fix enables proper use of Zod transforms in both `inputSchema` (for normalizing/cleaning input data) and `outputSchema` (for transforming output data to be LLM-friendly).
+
+- Updated dependencies [[`5d7000f`](https://github.com/mastra-ai/mastra/commit/5d7000f757cd65ea9dc5b05e662fd83dfd44e932)]:
+  - @mastra/observability@1.0.0-beta.4
 
-  ### BREAKING: Renamed `client.getThreadMessages()` → `client.listThreadMessages()`
+## 1.0.0-beta.9
 
-  **Migration:**
+### Minor Changes
+
+- Add stored agents support ([#10953](https://github.com/mastra-ai/mastra/pull/10953))
+
+  Agents can now be stored in the database and loaded at runtime. This lets you persist agent configurations and dynamically create executable Agent instances from storage.
 
   ```typescript
-  // Before
-  const response = await client.getThreadMessages(threadId, { agentId });
+  import { Mastra } from '@mastra/core';
+  import { LibSQLStore } from '@mastra/libsql';
+
+  const mastra = new Mastra({
+    storage: new LibSQLStore({ url: ':memory:' }),
+    tools: { myTool },
+    scorers: { myScorer },
+  });
 
-  // After
-  const response = await client.listThreadMessages(threadId, { agentId });
+  // Create agent in storage via API or directly
+  await mastra.getStorage().createAgent({
+    agent: {
+      id: 'my-agent',
+      name: 'My Agent',
+      instructions: 'You are helpful',
+      model: { provider: 'openai', name: 'gpt-4' },
+      tools: { myTool: {} },
+      scorers: { myScorer: { sampling: { type: 'ratio', rate: 0.5 } } },
+    },
+  });
+
+  // Load and use the agent
+  const agent = await mastra.getStoredAgentById('my-agent');
+  const response = await agent.generate({ messages: 'Hello!' });
+
+  // List all stored agents with pagination
+  const { agents, total, hasMore } = await mastra.listStoredAgents({
+    page: 0,
+    perPage: 10,
+  });
   ```
 
-  The response format remains the same.
+  Also adds a memory registry to Mastra so stored agents can reference memory instances by key.
+
+### Patch Changes
+
+- Add agentId and agentName attributes to MODEL_GENERATION spans. This allows users to correlate gen_ai.usage metrics with specific agents when analyzing LLM operation spans. The attributes are exported as gen_ai.agent.id and gen_ai.agent.name in the OtelExporter. ([#10984](https://github.com/mastra-ai/mastra/pull/10984))
+
+- Fix JSON parsing errors when LLMs output unescaped newlines in structured output strings ([#10965](https://github.com/mastra-ai/mastra/pull/10965))
+
+  Some LLMs (particularly when not using native JSON mode) output actual newline characters inside JSON string values instead of properly escaped `\n` sequences. This breaks JSON parsing and causes structured output to fail.
 
-  ## Type Changes
+  This change adds preprocessing to escape unescaped control characters (`\n`, `\r`, `\t`) within JSON string values before parsing, making structured output more robust across different LLM providers.
 
-  ### BREAKING: Removed `StorageGetMessagesArg` type
+- Fix toolCallId propagation in agent network tool execution. The toolCallId property was undefined at runtime despite being required by TypeScript type definitions in AgentToolExecutionContext. Now properly passes the toolCallId through to the tool's context during network tool execution. ([#10951](https://github.com/mastra-ai/mastra/pull/10951))
 
-  Use `StorageListMessagesInput` instead:
+- Exports `convertFullStreamChunkToMastra` from the stream module for AI SDK stream chunk transformations. ([#10911](https://github.com/mastra-ai/mastra/pull/10911))
+
+## 1.0.0-beta.8
+
+### Patch Changes
+
+- Fix saveScore not persisting ID correctly, breaking getScoreById retrieval ([#10915](https://github.com/mastra-ai/mastra/pull/10915))
+
+  **What Changed**
+  - saveScore now correctly returns scores that can be retrieved with getScoreById
+  - Validation errors now include contextual information (scorer, entity, trace details) for easier debugging
+
+  **Impact**
+  Previously, calling getScoreById after saveScore would return null because the generated ID wasn't persisted to the database. This is now fixed across all store implementations, ensuring consistent behavior and data integrity.
+
+- `setState` is now async ([#10944](https://github.com/mastra-ai/mastra/pull/10944))
+  - `setState` must now be awaited: `await setState({ key: value })`
+  - State updates are merged automatically—no need to spread the previous state
+  - State data is validated against the step's `stateSchema` when `validateInputs` is enabled (default: `true`)
+
+- Add human-in-the-loop support for workflows used in agent ([#10871](https://github.com/mastra-ai/mastra/pull/10871))
+
+## 1.0.0-beta.7
+
+### Minor Changes
+
+- Add `disableInit` option to all storage adapters ([#10851](https://github.com/mastra-ai/mastra/pull/10851))
+
+  Adds a new `disableInit` config option to all storage providers that allows users to disable automatic table creation/migrations at runtime. This is useful for CI/CD pipelines where you want to run migrations during deployment with elevated credentials, then run the application with `disableInit: true` so it doesn't attempt schema changes at runtime.
 
   ```typescript
-  // Before
-  import type { StorageGetMessagesArg } from '@mastra/core';
+  // CI/CD script - run migrations
+  const storage = new PostgresStore({
+    connectionString: DATABASE_URL,
+    id: 'pg-storage',
+  });
+  await storage.init();
+
+  // Runtime - skip auto-init
+  const storage = new PostgresStore({
+    connectionString: DATABASE_URL,
+    id: 'pg-storage',
+    disableInit: true,
+  });
+  ```
+
+### Patch Changes
 
-  // After
-  import type { StorageListMessagesInput } from '@mastra/core';
+- Add time-to-first-token (TTFT) support for Langfuse integration ([#10781](https://github.com/mastra-ai/mastra/pull/10781))
+
+  Adds `completionStartTime` to model generation spans, which Langfuse uses to calculate TTFT metrics. The timestamp is automatically captured when the first content chunk arrives during streaming.
+
+  ```typescript
+  // completionStartTime is now automatically captured and sent to Langfuse
+  // enabling TTFT metrics in your Langfuse dashboard
+  const result = await agent.stream('Hello');
   ```
 
-- - Removes modelSettings.abortSignal in favour of top-level abortSignal only. Also removes the deprecated output field - use structuredOutput.schema instead. ([`9e1911d`](https://github.com/mastra-ai/mastra/commit/9e1911db2b4db85e0e768c3f15e0d61e319869f6))
-  - The deprecated generateVNext() and streamVNext() methods have been removed since they're now the stable generate() and stream() methods.
-  - The deprecated `output` option has been removed entirely, in favour of `structuredOutput`.
+- Updated OtelExporters, Bridge, and Arize packages to better implement GenAI v1.38.0 Otel Semantic Conventions. See: ([#10591](https://github.com/mastra-ai/mastra/pull/10591))
+  https://github.com/open-telemetry/semantic-conventions/blob/v1.38.0/docs/gen-ai/README.md
+
+- Standardize error IDs across all storage and vector stores using centralized helper functions (`createStorageErrorId` and `createVectorErrorId`). This ensures consistent error ID patterns (`MASTRA_STORAGE_{STORE}_{OPERATION}_{STATUS}` and `MASTRA_VECTOR_{STORE}_{OPERATION}_{STATUS}`) across the codebase for better error tracking and debugging. ([#10913](https://github.com/mastra-ai/mastra/pull/10913))
 
-  Method renames to clarify the API surface:
-  - getDefaultGenerateOptions → getDefaultGenerateOptionsLegacy
-  - getDefaultStreamOptions → getDefaultStreamOptionsLegacy
-  - getDefaultVNextStreamOptions → getDefaultStreamOptions
+- fix: generate unique text IDs for Anthropic/Google providers ([#10740](https://github.com/mastra-ai/mastra/pull/10740))
 
-- Bump minimum required Node.js version to 22.13.0 ([#9706](https://github.com/mastra-ai/mastra/pull/9706))
+  Workaround for duplicate text-start/text-end IDs in multi-step agentic flows.
 
-- Replace `getThreadsByResourceIdPaginated` with `listThreadsByResourceId` across memory handlers. Update client SDK to use `listThreads()` with `offset`/`limit` parameters instead of deprecated `getMemoryThreads()`. Consolidate `/api/memory/threads` routes to single paginated endpoint. ([#9508](https://github.com/mastra-ai/mastra/pull/9508))
+  The `@ai-sdk/anthropic` and `@ai-sdk/google` providers use numeric indices ("0", "1", etc.) for text block IDs that reset for each LLM call. This caused duplicate IDs when an agent does TEXT → TOOL → TEXT, breaking message ordering and storage.
 
-- Add new list methods to storage API: `listMessages`, `listMessagesById`, `listThreadsByResourceId`, and `listWorkflowRuns`. Most methods are currently wrappers around existing methods. Full implementations will be added when migrating away from legacy methods. ([#9489](https://github.com/mastra-ai/mastra/pull/9489))
+  The fix replaces numeric IDs with UUIDs, maintaining a map per step so text-start, text-delta, and text-end chunks for the same block share the same UUID. OpenAI's UUIDs pass through unchanged.
 
-- Update tool execution signature ([#9587](https://github.com/mastra-ai/mastra/pull/9587))
+  Related: #9909
 
-  Consolidated the 3 different execution contexts to one
+- Fix sub-agent requestContext propagation in listAgentTools ([#10844](https://github.com/mastra-ai/mastra/pull/10844))
+
+  Sub-agents with dynamic model configurations were broken because `requestContext` was not being passed to `getModel()` when creating agent tools. This caused sub-agents using function-based model configurations to receive an empty context instead of the parent's context.
+
+  No code changes required for consumers - this fix restores expected behavior for dynamic model configurations in sub-agents.
+
+- Fix ToolStream type error when piping streams with different types ([#10845](https://github.com/mastra-ai/mastra/pull/10845))
+
+  Changes `ToolStream` to extend `WritableStream<unknown>` instead of `WritableStream<T>`. This fixes the TypeScript error when piping `objectStream` or `fullStream` to `writer` in workflow steps.
+
+  Before:
 
   ```typescript
-  // before depending on the context the tool was executed in
-  tool.execute({ context: data });
-  tool.execute({ context: { inputData: data } });
-  tool.execute(data);
+  // TypeError: ToolStream<ChunkType> is not assignable to WritableStream<Partial<StoryPlan>>
+  await response.objectStream.pipeTo(writer);
+  ```
 
-  // now, for all contexts
-  tool.execute(data, context);
+  After:
+
+  ```typescript
+  // Works without type errors
+  await response.objectStream.pipeTo(writer);
   ```
 
+- feat: add native Perplexity provider support ([#10885](https://github.com/mastra-ai/mastra/pull/10885))
+
+- When sending the first message to a new thread with PostgresStore, users would get a "Thread not found" error. This happened because the thread was created in memory but not persisted to the database before the MessageHistory output processor tried to save messages. ([#10881](https://github.com/mastra-ai/mastra/pull/10881))
+
   **Before:**
 
-  ```typescript
-  inputSchema: z.object({ something: z.string() }),
-  execute: async ({ context, tracingContext, runId, ... }) => {
-    return doSomething(context.string);
-  }
+  ```ts
+  threadObject = await memory.createThread({
+    // ...
+    saveThread: false, // thread not in DB yet
+  });
+  // Later: MessageHistory calls saveMessages() -> PostgresStore throws "Thread not found"
   ```
 
   **After:**
 
-  ```typescript
-  inputSchema: z.object({ something: z.string() }),
-  execute: async (inputData, context) => {
-    const { agent, mcp, workflow, ...sharedContext } = context
-
-    // context that only an agent would get like toolCallId, messages, suspend, resume, etc
-    if (agent) {
-      doSomething(inputData.something, agent)
-    // context that only a workflow would get like runId, state, suspend, resume, etc
-    } else if (workflow) {
-      doSomething(inputData.something, workflow)
-    // context that only a workflow would get like "extra", "elicitation"
-    } else if (mcp) {
-      doSomething(inputData.something, mcp)
-    } else {
-      // Running a tool in no execution context
-      return doSomething(inputData.something);
-    }
-  }
+  ```ts
+  threadObject = await memory.createThread({
+    // ...
+    saveThread: true, // thread persisted immediately
+  });
+  // MessageHistory can now save messages without error
   ```
 
-- The `@mastra/core` package no longer allows top-level imports except for `Mastra` and `type Config`. You must use subpath imports for all other imports. ([#9544](https://github.com/mastra-ai/mastra/pull/9544))
+- Emit error chunk and call onError when agent workflow step fails ([#10907](https://github.com/mastra-ai/mastra/pull/10907))
 
-  For example:
+  When a workflow step fails (e.g., tool not found), the error is now properly emitted as an error chunk to the stream and the onError callback is called. This fixes the issue where agent.generate() would throw "promise 'text' was not resolved or rejected" instead of the actual error message.
 
-  ```diff
-    import { Mastra, type Config } from "@mastra/core";
-  - import { Agent } from "@mastra/core";
-  - import { createTool } from "@mastra/core";
-  - import { createStep } from "@mastra/core";
+- fix(core): use agent description when converting agent to tool ([#10879](https://github.com/mastra-ai/mastra/pull/10879))
 
-  + import { Agent } from "@mastra/core/agent";
-  + import { createTool } from "@mastra/core/tools";
-  + import { createStep } from "@mastra/core/workflows";
+- Adds native @ai-sdk/deepseek provider support instead of using the OpenAI-compatible fallback. ([#10822](https://github.com/mastra-ai/mastra/pull/10822))
+
+  ```typescript
+  const agent = new Agent({
+    model: 'deepseek/deepseek-reasoner',
+  });
+
+  // With provider options for reasoning
+  const response = await agent.generate('Solve this problem', {
+    providerOptions: {
+      deepseek: {
+        thinking: { type: 'enabled' },
+      },
+    },
+  });
   ```
 
-- This simplifies the Memory API by removing the confusing rememberMessages method and renaming query to recall for better clarity. ([#9701](https://github.com/mastra-ai/mastra/pull/9701))
+  Also updates the doc generation scripts so DeepSeek provider options show up in the generated docs.
 
-  The rememberMessages method name implied it might persist data when it was actually just retrieving messages, same as query. Having two methods that did essentially the same thing was unnecessary.
+- Return state too if `includeState: true` is in `outputOptions` and workflow run is not successful ([#10806](https://github.com/mastra-ai/mastra/pull/10806))
 
-  Before:
+- feat: Add partial response support for agent and workflow list endpoints ([#10886](https://github.com/mastra-ai/mastra/pull/10886))
 
-  ```typescript
-  // Two methods that did the same thing
-  memory.rememberMessages({ threadId, resourceId, config, vectorMessageSearch });
-  memory.query({ threadId, resourceId, perPage, vectorSearchString });
+  Add optional `partial` query parameter to `/api/agents` and `/api/workflows` endpoints to return minimal data without schemas, reducing payload size for list views:
+  - When `partial=true`: tool schemas (inputSchema, outputSchema) are omitted
+  - When `partial=true`: workflow steps are replaced with stepCount integer
+  - When `partial=true`: workflow root schemas (inputSchema, outputSchema) are omitted
+  - Maintains backward compatibility when partial parameter is not provided
+
+  ## Server Endpoint Usage
+
+  ```http
+  # Get partial agent data (no tool schemas)
+  GET /api/agents?partial=true
+
+  # Get full agent data (default behavior)
+  GET /api/agents
+
+  # Get partial workflow data (stepCount instead of steps, no schemas)
+  GET /api/workflows?partial=true
+
+  # Get full workflow data (default behavior)
+  GET /api/workflows
   ```
 
-  After:
+  ## Client SDK Usage
 
   ```typescript
-  // Single unified method with clear purpose
-  memory.recall({ threadId, resourceId, perPage, vectorMessageSearch, threadConfig });
+  import { MastraClient } from '@mastra/client-js';
+
+  const client = new MastraClient({ baseUrl: 'http://localhost:4111' });
+
+  // Get partial agent list (smaller payload)
+  const partialAgents = await client.listAgents({ partial: true });
+
+  // Get full agent list with tool schemas
+  const fullAgents = await client.listAgents();
+
+  // Get partial workflow list (smaller payload)
+  const partialWorkflows = await client.listWorkflows({ partial: true });
+
+  // Get full workflow list with steps and schemas
+  const fullWorkflows = await client.listWorkflows();
   ```
 
-  All usages have been updated across the codebase including tests. The agent now calls recall directly with the appropriate parameters.
+- Fix processInputStep so it runs correctly. ([#10909](https://github.com/mastra-ai/mastra/pull/10909))
 
-- Rename RuntimeContext to RequestContext ([#9511](https://github.com/mastra-ai/mastra/pull/9511))
+- Updated dependencies [[`6c59a40`](https://github.com/mastra-ai/mastra/commit/6c59a40e0ad160467bd13d63a8a287028d75b02d), [`3076c67`](https://github.com/mastra-ai/mastra/commit/3076c6778b18988ae7d5c4c5c466366974b2d63f), [`0bada2f`](https://github.com/mastra-ai/mastra/commit/0bada2f2c1234932cf30c1c47a719ffb64b801c5), [`cc60ff6`](https://github.com/mastra-ai/mastra/commit/cc60ff616541a3b0fb531a7e469bf9ae7bb90528)]:
+  - @mastra/observability@1.0.0-beta.3
 
-- Implement listMessages API for replacing previous methods ([#9531](https://github.com/mastra-ai/mastra/pull/9531))
+## 1.0.0-beta.6
 
-- Rename `defaultVNextStreamOptions` to `defaultOptions`. Add "Legacy" suffix to v1 option properties and methods (`defaultGenerateOptions` → `defaultGenerateOptionsLegacy`, `defaultStreamOptions` → `defaultStreamOptionsLegacy`). ([#9535](https://github.com/mastra-ai/mastra/pull/9535))
+### Major Changes
 
-- Remove `getThreadsByResourceId` and `getThreadsByResourceIdPaginated` methods from storage interfaces in favor of `listThreadsByResourceId`. The new method uses `offset`/`limit` pagination and a nested `orderBy` object structure (`{ field, direction }`). ([#9536](https://github.com/mastra-ai/mastra/pull/9536))
+- Changed `.branch()` result schema to make all branch output fields optional. ([#10693](https://github.com/mastra-ai/mastra/pull/10693))
 
-- Remove `getMessagesById` method from storage interfaces in favor of `listMessagesById`. The new method only returns V2-format messages and removes the format parameter, simplifying the API surface. Users should migrate from `getMessagesById({ messageIds, format })` to `listMessagesById({ messageIds })`. ([#9534](https://github.com/mastra-ai/mastra/pull/9534))
+  **Breaking change**: Branch outputs are now optional since only one branch executes at runtime. Update your workflow schemas to handle optional branch results.
 
-- Experimental auth -> auth ([#9660](https://github.com/mastra-ai/mastra/pull/9660))
+  **Before:**
 
-- Renamed a bunch of observability/tracing-related things to drop the AI prefix. ([#9744](https://github.com/mastra-ai/mastra/pull/9744))
+  ```typescript
+  const workflow = createWorkflow({...})
+    .branch([
+      [condition1, stepA],  // outputSchema: { result: z.string() }
+      [condition2, stepB],  // outputSchema: { data: z.number() }
+    ])
+    .map({
+      finalResult: { step: stepA, path: 'result' }  // Expected non-optional
+    });
+  ```
+
+  **After:**
+
+  ```typescript
+  const workflow = createWorkflow({...})
+    .branch([
+      [condition1, stepA],
+      [condition2, stepB],
+    ])
+    .map({
+      finalResult: {
+        step: stepA,
+        path: 'result'  // Now optional - provide fallback
+      }
+    });
+  ```
 
-- Removed MastraMessageV3 intermediary format, now we go from MastraDBMessage->aiv5 formats and back directly ([#9094](https://github.com/mastra-ai/mastra/pull/9094))
+  **Why**: Branch conditionals execute only one path, so non-executed branches don't produce outputs. The type system now correctly reflects this runtime behavior.
 
-- **Breaking Change**: Remove legacy v1 watch events and consolidate on v2 implementation. ([#9252](https://github.com/mastra-ai/mastra/pull/9252))
+  Related issue: https://github.com/mastra-ai/mastra/issues/10642
 
-  This change simplifies the workflow watching API by removing the legacy v1 event system and promoting v2 as the standard (renamed to just `watch`).
+### Minor Changes
 
-  ### What's Changed
-  - Removed legacy v1 watch event handlers and types
-  - Renamed `watch-v2` to `watch` throughout the codebase
-  - Removed `.watch()` method from client-js SDK (`Workflow` and `AgentBuilder` classes)
-  - Removed `/watch` HTTP endpoints from server and deployer
-  - Removed `WorkflowWatchResult` and v1 `WatchEvent` types
+- Memory system now uses processors. Memory processors (`MessageHistory`, `SemanticRecall`, `WorkingMemory`) are now exported from `@mastra/memory/processors` and automatically added to the agent pipeline based on your memory config. Core processors (`ToolCallFilter`, `TokenLimiter`) remain in `@mastra/core/processors`. ([#9254](https://github.com/mastra-ai/mastra/pull/9254))
 
-- Remove various deprecated APIs from agent class. ([#9257](https://github.com/mastra-ai/mastra/pull/9257))
-  - `agent.llm` → `agent.getLLM()`
-  - `agent.tools` → `agent.getTools()`
-  - `agent.instructions` → `agent.getInstructions()`
-  - `agent.speak()` → `agent.voice.speak()`
-  - `agent.getSpeakers()` → `agent.voice.getSpeakers()`
-  - `agent.listen` → `agent.voice.listen()`
-  - `agent.fetchMemory` → `(await agent.getMemory()).query()`
-  - `agent.toStep` → Add agent directly to the step, workflows handle the transformation
+- Add reserved keys in RequestContext for secure resourceId/threadId setting from middleware ([#10657](https://github.com/mastra-ai/mastra/pull/10657))
 
-- **BREAKING CHANGE**: Pagination APIs now use `page`/`perPage` instead of `offset`/`limit` ([#9592](https://github.com/mastra-ai/mastra/pull/9592))
+  This allows middleware to securely set `resourceId` and `threadId` via reserved keys in RequestContext (`MASTRA_RESOURCE_ID_KEY` and `MASTRA_THREAD_ID_KEY`), which take precedence over client-provided values for security.
 
-  All storage and memory pagination APIs have been updated to use `page` (0-indexed) and `perPage` instead of `offset` and `limit`, aligning with standard REST API patterns.
+- feat(workflows): add suspendData parameter to step execute function ([#10734](https://github.com/mastra-ai/mastra/pull/10734))
 
-  **Affected APIs:**
-  - `Memory.listThreadsByResourceId()`
-  - `Memory.listMessages()`
-  - `Storage.listWorkflowRuns()`
+  Adds a new `suspendData` parameter to workflow step execute functions that provides access to the data originally passed to `suspend()` when the step was suspended. This enables steps to access context about why they were suspended when they are later resumed.
 
-  **Migration:**
+  **New Features:**
+  - `suspendData` parameter automatically populated in step execute function when resuming
+  - Type-safe access to suspend data matching the step's `suspendSchema`
+  - Backward compatible - existing workflows continue to work unchanged
+
+  **Example:**
 
   ```typescript
-  // Before
-  await memory.listThreadsByResourceId({
-    resourceId: 'user-123',
-    offset: 20,
-    limit: 10,
+  const step = createStep({
+    suspendSchema: z.object({ reason: z.string() }),
+    resumeSchema: z.object({ approved: z.boolean() }),
+    execute: async ({ suspend, suspendData, resumeData }) => {
+      if (!resumeData?.approved) {
+        return await suspend({ reason: 'Approval required' });
+      }
+
+      // Access original suspend data when resuming
+      console.log(`Resuming after: ${suspendData?.reason}`);
+      return { result: 'Approved' };
+    },
   });
+  ```
 
-  // After
-  await memory.listThreadsByResourceId({
-    resourceId: 'user-123',
-    page: 2, // page = Math.floor(offset / limit)
-    perPage: 10,
-  });
+- feat(storage): support querying messages from multiple threads ([#10663](https://github.com/mastra-ai/mastra/pull/10663))
+  - Fixed TypeScript errors where `threadId: string | string[]` was being passed to places expecting `Scalar` type
+  - Added proper multi-thread support for `listMessages` across all adapters when `threadId` is an array
+  - Updated `_getIncludedMessages` to look up message threadId by ID (since message IDs are globally unique)
+  - **upstash**: Added `msg-idx:{messageId}` index for O(1) message lookups (backwards compatible with fallback to scan for old messages, with automatic backfill)
 
-  // Before
-  await memory.listMessages({
-    threadId: 'thread-456',
-    offset: 20,
-    limit: 10,
-  });
+- Adds trace tagging support to the BrainTrust and Langfuse tracing exporters. ([#10765](https://github.com/mastra-ai/mastra/pull/10765))
+
+- Add `messageList` parameter to `processOutputStream` for accessing remembered messages during streaming ([#10608](https://github.com/mastra-ai/mastra/pull/10608))
+
+- Unify transformScoreRow functions across storage adapters ([#10648](https://github.com/mastra-ai/mastra/pull/10648))
 
+  Added a unified `transformScoreRow` function in `@mastra/core/storage` that provides schema-driven row transformation for score data. This eliminates code duplication across 10 storage adapters while maintaining store-specific behavior through configurable options:
+  - `preferredTimestampFields`: Preferred source fields for timestamps (PostgreSQL, Cloudflare D1)
+  - `convertTimestamps`: Convert timestamp strings to Date objects (MSSQL, MongoDB, ClickHouse)
+  - `nullValuePattern`: Skip values matching pattern (ClickHouse's `'_null_'`)
+  - `fieldMappings`: Map source column names to schema fields (LibSQL's `additionalLLMContext`)
 
-... 5128 more lines hidden. See full changelog in package directory.
+... 6146 more lines hidden. See full changelog in package directory.