February, 4 2026 - mastra Release Notes | AnnounceHQ

February, 4 2026 - mastra Release Notes | AnnounceHQ

load_tool

Update provider registry and model documentation with latest models and providers

Fixes: e6fc281
Fixed processors returning { tools: {}, toolChoice: 'none' } being ignored. Previously, when a processor returned empty tools with an explicit toolChoice: 'none' to prevent tool calls, the toolChoice was discarded and defaulted to 'auto'. This fix preserves the explicit 'none' value, enabling patterns like ensuring a final text response when maxSteps is reached.

Fixes: #12601
Internal changes to enable observational memory
Internal changes to enable @mastra/editor
Fix moonshotai/kimi-k2.5 multi-step tool calling failing with "reasoning_content is missing in assistant tool call message"
Changed moonshotai and moonshotai-cn (China version) providers to use Anthropic-compatible API endpoints instead of OpenAI-compatible
- moonshotai: https://api.moonshot.ai/anthropic/v1
- moonshotai-cn: https://api.moonshot.cn/anthropic/v1 This properly handles reasoning_content for kimi-k2.5 model
  
  Fixes: #12530
Fixed custom input processors from disabling workspace skill tools in generate() and stream(). Custom processors now replace only the processors you configured, while memory and skills remain available. Fixes #12612.

Fixes: #12676

Fixed Workspace search index names now use underscores so they work with SQL-based vector stores (PgVector, LibSQL).

Added You can now set a custom index name with searchIndexName.

Why Some SQL vector stores reject hyphens in index names.

Example

// Before - would fail with PgVector
new Workspace({ id: "my-workspace", vectorStore, embedder });

// After - works with all vector stores
new Workspace({ id: "my-workspace", vectorStore, embedder });

// Or use a custom index name
new Workspace({ vectorStore, embedder, searchIndexName: "my_workspace_vectors" });

Fixes: #12673

Added logger support to Workspace filesystem and sandbox providers. Providers extending MastraFilesystem or MastraSandbox now automatically receive the Mastra logger for consistent logging of file operations and command executions.

Fixes: #12606
Added ToolSearchProcessor for dynamic tool discovery.

Agents can now discover and load tools on demand instead of having all tools available upfront. This reduces context token usage by ~94% when working with large tool libraries.

New API:
```
import { ToolSearchProcessor } from "@mastra/core/processors";
import { Agent } from "@mastra/core";

// Create a processor with searchable tools
const toolSearch = new ToolSearchProcessor({
  tools: {
    createIssue: githubTools.createIssue,
    sendEmail: emailTools.send
    // ... hundreds of tools
  },
  search: {
    topK: 5, // Return top 5 results (default: 5)
    minScore: 0.1 // Filter results below this score (default: 0)
  }
});

// Attach processor to agent
const agent = new Agent({
  name: "my-agent",
  inputProcessors: [toolSearch],
  tools: {
    /* always-available tools */
  }
});
```
How it works:

The processor automatically provides two meta-tools to the agent:
- search_tools - Search for available tools by keyword relevance
- load_tool - Load a specific tool into the conversation
The agent discovers what it needs via search and loads tools on demand. Loaded tools are available immediately and persist within the conversation thread.

Why:

When agents have access to 100+ tools (from MCP servers or integrations), including all tool definitions in the context can consume significant tokens (~1,500 tokens per tool). This pattern reduces context usage by giving agents only the tools they need, when they need them.

Fixes: #12290
Catch up evented workflows on parity with default execution engine

Fixes: #12555
Expose token usage from embedding operations
saveMessages now returns usage: { tokens: number } with aggregated token count from all embeddings
recall now returns usage: { tokens: number } from the vector search query embedding
Updated abstract method signatures in MastraMemory to include optional usage in return types

This allows users to track embedding token usage when using the Memory class.

Fixes: #12556
Fixed a security issue where sensitive observability credentials (such as Langfuse API keys) could be exposed in tool execution error logs. The tracingContext is now properly excluded from logged data.

Fixes: #12669
Fixed issue where some models incorrectly call skill names directly as tools instead of using skill-activate. Added clearer system instructions that explicitly state skills are NOT tools and must be activated via skill-activate with the skill name as the "name" parameter. Fixes #12654.

Fixes: #12677
Improved workspace filesystem error handling: return 404 for not-found errors instead of 500, show user-friendly error messages in UI, and add MastraClientError class with status/body properties for better error handling

Fixes: #12533
Improved workspace tool descriptions with clearer usage guidance for read_file, edit_file, and execute_command tools.

Fixes: #12640
Fixed JSON parsing in agent network to handle malformed LLM output. Uses parsePartialJson from AI SDK to recover truncated JSON, missing braces, and unescaped control characters instead of failing immediately. This reduces unnecessary retry round-trips when the routing agent generates slightly malformed JSON for tool/workflow prompts. Fixes #12519.

Fixes: #12526

import { MastraEditor } from "@mastra/editor";
import { Mastra } from "@mastra/core";

// Initialize editor with Mastra
const mastra = new Mastra({
  /* config */
  editor: new MastraEditor()
});

// Store an agent configuration
const agentId = await mastra.storage.stores?.agents?.createAgent({
  name: "customer-support",
  instructions: "Help customers with inquiries",
  model: { provider: "openai", name: "gpt-4" },
  tools: ["search-kb", "create-ticket"],
  workflows: ["escalation-flow"],
  memory: { vector: "pinecone-db" }
});

// Retrieve and use the stored agent
const agent = await mastra.getEditor()?.getStoredAgentById(agentId);
const response = await agent?.generate("How do I reset my password?");

// List all stored agents
const agents = await mastra.getEditor()?.listStoredAgents({ pageSize: 10 });

const store = new ElasticSearchVector({ url, id: "my-index" });

const store = new ElasticSearchVector({
  url,
  id: "my-index",
  auth: { apiKey: process.env.ELASTICSEARCH_API_KEY! }
});

const scorer = createHallucinationScorer({
  model: openai("gpt-4o"),
  options: {
    context: ["The capital of France is Paris.", "France is in Europe."]
  }
});

import { extractToolResults } from "@mastra/evals/scorers";

const scorer = createHallucinationScorer({
  model: openai("gpt-4o"),
  options: {
    getContext: ({ run }) => {
      const toolResults = extractToolResults(run.output);
      return toolResults.map((t) => JSON.stringify({ tool: t.toolName, result: t.result }));
    }
  }
});

import { Memory } from "@mastra/memory";
import { PostgresStore } from "@mastra/pg";

const memory = new Memory({
  storage: new PostgresStore({ connectionString: process.env.DATABASE_URL }),
  options: {
    observationalMemory: true
  }
});

const agent = new Agent({
  name: "my-agent",
  model: openai("gpt-4o"),
  memory
});

Increased default serialization limits for AI tracing. The maxStringLength is now 128KB (previously 1KB) and maxDepth is 8 (previously 6). These changes prevent truncation of large LLM prompts and responses during tracing.

To restore the previous behavior, set serializationOptions in your observability config:
```
serializationOptions: {
  maxStringLength: 1024,
  maxDepth: 6,
}
```
Fixes: #12579
Fix CloudFlare Workers deployment failure caused by fileURLToPath being called at module initialization time.

Moved SNAPSHOTS_DIR calculation from top-level module code into a lazy getter function. In CloudFlare Workers (V8 runtime), import.meta.url is undefined during worker startup, causing the previous code to throw. The snapshot functionality is only used for testing, so deferring initialization has no impact on normal operation.

Fixes: #12540

Added Standard Schema support to @mastra/schema-compat. This enables interoperability with any schema library that implements the Standard Schema specification.

New exports:

toStandardSchema() - Convert Zod, JSON Schema, or AI SDK schemas to Standard Schema format
StandardSchemaWithJSON - Type for schemas implementing both validation and JSON Schema conversion
InferInput, InferOutput - Utility types for type inference

Example usage:

import { toStandardSchema } from "@mastra/schema-compat/schema";
import { z } from "zod";

// Convert a Zod schema to Standard Schema
const zodSchema = z.object({ name: z.string(), age: z.number() });
const standardSchema = toStandardSchema(zodSchema);

// Use validation
const result = standardSchema["~standard"].validate({ name: "John", age: 30 });

// Get JSON Schema
const jsonSchema = standardSchema["~standard"].jsonSchema.output({ target: "draft-07" });