@mastra/core 1.26.0-alpha.11 → 1.26.0-alpha.13

package/dist/docs/references/docs-agents-structured-output.md

@@ -210,6 +210,28 @@ const response = await testAgent.generate('Tell me about TypeScript.', {
 })
 ```
 
+If you want that structuring model to also see the current conversation history, set `useAgent: true` alongside `model`. Mastra will reuse the parent agent with the separate structuring model and attach read-only memory context when a thread is available.
+
+```typescript
+const response = await testAgent.generate('Return my profile as structured data.', {
+  memory: {
+    thread: 'thread-123',
+    resource: 'user-123',
+  },
+  structuredOutput: {
+    schema: z.object({
+      favoriteColor: z.string(),
+      hometown: z.string(),
+      petName: z.string(),
+    }),
+    model: 'openai/gpt-5.4',
+    useAgent: true,
+  },
+})
+```
+
+Leave `useAgent` unset if you want the separate structuring model to work only from the current response and not inherit prior conversation memory.
+
 ### Multi-step approach with `prepareStep`
 
 For models that don't support tools and structured outputs together, you can use `prepareStep` to handle them in separate steps.

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

@@ -34,6 +34,7 @@ Each provider page includes installation instructions, configuration parameters,
 - [PostgreSQL](https://mastra.ai/reference/storage/postgresql)
 - [MongoDB](https://mastra.ai/reference/storage/mongodb)
 - [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)

package/dist/docs/references/reference-storage-redis.md

@@ -0,0 +1,266 @@
+# Redis Storage
+
+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.
+
+## Installation
+
+```bash
+npm install @mastra/redis
+```
+
+## Usage
+
+### Using Connection String
+
+```typescript
+import { RedisStore } from '@mastra/redis'
+
+const storage = new RedisStore({
+  id: 'redis-storage',
+  connectionString: 'redis://localhost:6379',
+})
+
+await storage.init()
+```
+
+### Using Host/Port Configuration
+
+```typescript
+import { RedisStore } from '@mastra/redis'
+
+const storage = new RedisStore({
+  id: 'redis-storage',
+  host: 'localhost',
+  port: 6379,
+  password: 'your-password',
+  db: 0,
+})
+
+await storage.init()
+```
+
+### Using Pre-configured Client
+
+For advanced configurations like Sentinel or Cluster, you can pass a pre-configured redis client:
+
+```typescript
+import { RedisStore } from '@mastra/redis'
+import { createClient } from 'redis'
+
+const client = createClient({
+  url: 'redis://localhost:6379',
+  socket: {
+    reconnectStrategy: retries => Math.min(retries * 50, 2000),
+  },
+})
+
+// Connect the client before passing to RedisStore
+await client.connect()
+
+const storage = new RedisStore({
+  id: 'redis-storage',
+  client,
+})
+```
+
+## Parameters
+
+**id** (`string`): Unique identifier for the storage instance
+
+**connectionString** (`string`): Redis connection URL (e.g., \`redis\://localhost:6379\` or \`redis\://:password\@localhost:6379\`)
+
+**host** (`string`): Redis host address
+
+**port** (`number`): Redis port number (Default: `6379`)
+
+**password** (`string`): Redis password for authentication
+
+**db** (`number`): Redis database number (Default: `0`)
+
+**client** (`RedisClient`): Pre-configured redis client (from the \`redis\` package) for advanced setups
+
+> **Note:** You must provide either `connectionString`, `host`, or `client`. These options are mutually exclusive.
+
+## Additional Notes
+
+### Key Structure
+
+The Redis storage implementation uses the following key patterns:
+
+- Threads: `mastra_threads:id:{threadId}`
+- Messages: `mastra_messages:threadId:{threadId}:id:{messageId}`
+- Message index: `msg-idx:{messageId}` (for fast lookups)
+- Thread messages sorted set: `thread:{threadId}:messages`
+- Workflow snapshots: `mastra_workflow_snapshot:namespace:{ns}:workflow_name:{name}:run_id:{id}`
+- Scores: `mastra_scorers:id:{scoreId}`
+- Resources: `mastra_resources:{resourceId}`
+
+### Redis Sentinel
+
+For high-availability deployments using Redis Sentinel, create a custom client:
+
+```typescript
+import { RedisStore } from '@mastra/redis'
+import { createClient } from 'redis'
+
+const client = createClient({
+  url: 'redis://sentinel-host:26379',
+  // Configure sentinel options as needed for your setup
+})
+
+await client.connect()
+
+const storage = new RedisStore({
+  id: 'redis-sentinel-storage',
+  client,
+})
+```
+
+### Redis Cluster
+
+For Redis Cluster deployments, use the cluster client:
+
+```typescript
+import { RedisStore } from '@mastra/redis'
+import { createCluster } from 'redis'
+
+const cluster = createCluster({
+  rootNodes: [
+    { url: 'redis://node-1:6379' },
+    { url: 'redis://node-2:6379' },
+    { url: 'redis://node-3:6379' },
+  ],
+})
+
+await cluster.connect()
+
+const storage = new RedisStore({
+  id: 'redis-cluster-storage',
+  client: cluster,
+})
+```
+
+### Accessing the Underlying Client
+
+You can access the underlying redis client for custom operations:
+
+```typescript
+const storage = new RedisStore({
+  id: 'redis-storage',
+  connectionString: 'redis://localhost:6379',
+})
+
+await storage.init()
+
+const client = storage.getClient()
+
+// Custom Redis operations
+await client.set('custom-key', 'value')
+const value = await client.get('custom-key')
+```
+
+### Closing Connections
+
+When shutting down your application, close the Redis connection:
+
+```typescript
+await storage.close()
+```
+
+## Usage Example
+
+### Adding memory to an agent
+
+```typescript
+import { Memory } from '@mastra/memory'
+import { Agent } from '@mastra/core/agent'
+import { RedisStore } from '@mastra/redis'
+
+export const redisAgent = new Agent({
+  id: 'redis-agent',
+  name: 'Redis Agent',
+  instructions:
+    'You are an AI agent with the ability to automatically recall memories from previous interactions.',
+  model: 'openai/gpt-4o',
+  memory: new Memory({
+    storage: new RedisStore({
+      id: 'redis-agent-storage',
+      connectionString: process.env.REDIS_URL!,
+    }),
+    options: {
+      lastMessages: 10,
+    },
+  }),
+})
+```
+
+### Using the agent
+
+```typescript
+import 'dotenv/config'
+
+import { mastra } from './mastra'
+
+const threadId = '123'
+const resourceId = 'user-456'
+
+const agent = mastra.getAgent('redisAgent')
+
+const message = await agent.stream('My name is Mastra', {
+  memory: {
+    thread: threadId,
+    resource: resourceId,
+  },
+})
+
+await message.textStream.pipeTo(new WritableStream())
+
+const stream = await agent.stream("What's my name?", {
+  memory: {
+    thread: threadId,
+    resource: resourceId,
+  },
+  memoryOptions: {
+    lastMessages: 5,
+  },
+})
+
+for await (const chunk of stream.textStream) {
+  process.stdout.write(chunk)
+}
+```
+
+### Using with Mastra instance
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { RedisStore } from '@mastra/redis'
+
+const storage = new RedisStore({
+  id: 'mastra-storage',
+  host: 'localhost',
+  port: 6379,
+})
+
+const mastra = new Mastra({
+  storage, // init() called automatically
+})
+```
+
+If using storage directly without Mastra, call `init()` explicitly:
+
+```typescript
+import { RedisStore } from '@mastra/redis'
+
+const storage = new RedisStore({
+  id: 'redis-storage',
+  host: 'localhost',
+  port: 6379,
+})
+
+await storage.init()
+
+// Access domain-specific stores via getStore()
+const memoryStore = await storage.getStore('memory')
+const thread = await memoryStore?.getThreadById({ threadId: '...' })
+```

package/dist/docs/references/reference-tools-tavily.md

@@ -0,0 +1,307 @@
+# Tavily tools
+
+**Added in:** `@mastra/tavily@0.1.0-alpha.0`
+
+The `@mastra/tavily` package wraps the [Tavily](https://app.tavily.com) API as Mastra-compatible tools. It exposes factory functions for search, extract, crawl, and map — each returning a tool created with [`createTool()`](https://mastra.ai/reference/tools/create-tool) that includes full Zod input/output schemas.
+
+## Installation
+
+**npm**:
+
+```sh
+npm install @mastra/tavily @tavily/core zod
+```
+
+**pnpm**:
+
+```sh
+pnpm add @mastra/tavily @tavily/core zod
+```
+
+**Yarn**:
+
+```sh
+yarn add @mastra/tavily @tavily/core zod
+```
+
+**Bun**:
+
+```sh
+bun add @mastra/tavily @tavily/core zod
+```
+
+## Quick start
+
+Use `createTavilyTools()` to get all four tools with shared configuration:
+
+```typescript
+import { createTavilyTools } from '@mastra/tavily'
+
+const tools = createTavilyTools()
+// Or pass an explicit API key:
+// const tools = createTavilyTools({ apiKey: 'tvly-...' })
+```
+
+Each tool can also be created individually:
+
+```typescript
+import { createTavilySearchTool, createTavilyExtractTool } from '@mastra/tavily'
+
+const searchTool = createTavilySearchTool()
+const extractTool = createTavilyExtractTool({ apiKey: 'tvly-...' })
+```
+
+By default, all tools read `TAVILY_API_KEY` from the environment. You can pass `{ apiKey }` explicitly to override.
+
+## Configuration
+
+All factory functions accept `TavilyClientOptions` from `@tavily/core`:
+
+**apiKey** (`string`): Tavily API key. Falls back to the \`TAVILY\_API\_KEY\` environment variable.
+
+**clientSource** (`string`): Attribution string sent with each request. (Default: `'mastra'`)
+
+**apiBaseURL** (`string`): Base URL for the Tavily API.
+
+**proxies** (`object`): Proxy configuration passed to the underlying HTTP client.
+
+**projectId** (`string`): Tavily project ID for request scoping.
+
+## `createTavilyTools()`
+
+Returns an object containing all four tools with a shared configuration.
+
+```typescript
+import { createTavilyTools } from '@mastra/tavily'
+
+const tools = createTavilyTools({ apiKey: 'tvly-...' })
+// tools.tavilySearch, tools.tavilyExtract, tools.tavilyCrawl, tools.tavilyMap
+```
+
+**Returns:** `{ tavilySearch, tavilyExtract, tavilyCrawl, tavilyMap }`
+
+## `createTavilySearchTool()`
+
+Creates a tool that searches the web using Tavily. Returns relevant results with content snippets, optional AI-generated answers, and images.
+
+**Tool ID:** `tavily-search`
+
+```typescript
+import { createTavilySearchTool } from '@mastra/tavily'
+
+const searchTool = createTavilySearchTool()
+```
+
+### Input
+
+**query** (`string`): The search query.
+
+**searchDepth** (`'basic' | 'advanced' | 'fast' | 'ultra-fast'`): Search depth. Use 'basic' for standard results, 'advanced' for more thorough results, or 'fast'/'ultra-fast' for low latency.
+
+**maxResults** (`number`): Maximum number of results to return (1-20).
+
+**includeAnswer** (`boolean | 'basic' | 'advanced'`): Include an AI-generated answer summary.
+
+**includeImages** (`boolean`): Include query-related images in the response.
+
+**includeImageDescriptions** (`boolean`): Include descriptions for returned images.
+
+**includeRawContent** (`false | 'markdown' | 'text'`): Include cleaned HTML content of each result. Pass false to disable, or 'markdown'/'text' for format.
+
+**includeDomains** (`string[]`): Restrict results to these domains.
+
+**excludeDomains** (`string[]`): Exclude results from these domains.
+
+**timeRange** (`'day' | 'week' | 'month' | 'year'`): Filter results by recency.
+
+### Output
+
+**query** (`string`): The original search query.
+
+**answer** (`string`): AI-generated answer summary.
+
+**images** (`{ url: string; description?: string }[]`): Related images.
+
+**results** (`SearchResult[]`): Array of search results.
+
+**results.title** (`string`): Result title.
+
+**results.url** (`string`): Result URL.
+
+**results.content** (`string`): Content snippet.
+
+**results.score** (`number`): Relevance score.
+
+**results.rawContent** (`string`): Full-page content (when requested).
+
+**responseTime** (`number`): Server response time in seconds.
+
+## `createTavilyExtractTool()`
+
+Creates a tool that extracts content from one or more URLs. Returns raw page content in markdown or text format with up to 20 URLs per request.
+
+**Tool ID:** `tavily-extract`
+
+```typescript
+import { createTavilyExtractTool } from '@mastra/tavily'
+
+const extractTool = createTavilyExtractTool()
+```
+
+### Input
+
+**urls** (`string[]`): URLs to extract content from (1-20).
+
+**extractDepth** (`'basic' | 'advanced'`): Extraction depth. Use 'advanced' to retrieve tables and embedded content.
+
+**query** (`string`): User intent for reranking extracted content chunks by relevance.
+
+**includeImages** (`boolean`): Include images extracted from the pages.
+
+**format** (`'markdown' | 'text'`): Output format for extracted content. (Default: `'markdown'`)
+
+### Output
+
+**results** (`ExtractResult[]`): Successfully extracted pages.
+
+**results.url** (`string`): Page URL.
+
+**results.rawContent** (`string`): Extracted page content.
+
+**results.images** (`string[]`): Extracted image URLs.
+
+**failedResults** (`FailedResult[]`): URLs that failed extraction.
+
+**failedResults.url** (`string`): Failed URL.
+
+**failedResults.error** (`string`): Error message.
+
+**responseTime** (`number`): Server response time in seconds.
+
+## `createTavilyCrawlTool()`
+
+Creates a tool that crawls a website starting from a URL. Extracts content from discovered pages with configurable depth, breadth, and domain constraints.
+
+**Tool ID:** `tavily-crawl`
+
+```typescript
+import { createTavilyCrawlTool } from '@mastra/tavily'
+
+const crawlTool = createTavilyCrawlTool()
+```
+
+### Input
+
+**url** (`string`): The root URL to begin the crawl.
+
+**maxDepth** (`number`): Maximum depth of the crawl from the base URL.
+
+**maxBreadth** (`number`): Maximum number of links to follow per page.
+
+**limit** (`number`): Total number of pages the crawler processes before stopping.
+
+**instructions** (`string`): Natural language instructions for the crawler.
+
+**selectPaths** (`string[]`): Regex patterns to select specific URL paths.
+
+**selectDomains** (`string[]`): Regex patterns to restrict to specific domains.
+
+**excludePaths** (`string[]`): Regex patterns to exclude specific URL paths.
+
+**excludeDomains** (`string[]`): Regex patterns to exclude specific domains.
+
+**allowExternal** (`boolean`): Whether to follow links to external domains.
+
+**extractDepth** (`'basic' | 'advanced'`): Extraction depth. Use 'advanced' to retrieve tables and embedded content.
+
+**includeImages** (`boolean`): Include images from crawled pages.
+
+**format** (`'markdown' | 'text'`): Output format for extracted content. (Default: `'markdown'`)
+
+### Output
+
+**baseUrl** (`string`): The root URL that was crawled.
+
+**results** (`CrawlResult[]`): Content extracted from discovered pages.
+
+**results.url** (`string`): Page URL.
+
+**results.rawContent** (`string`): Extracted page content.
+
+**results.images** (`string[]`): Image URLs found on the page.
+
+**responseTime** (`number`): Server response time in seconds.
+
+## `createTavilyMapTool()`
+
+Creates a tool that maps a website's structure starting from a URL. Discovers and returns a list of URLs without extracting page content. Use this to understand site structure before targeted extraction.
+
+**Tool ID:** `tavily-map`
+
+```typescript
+import { createTavilyMapTool } from '@mastra/tavily'
+
+const mapTool = createTavilyMapTool()
+```
+
+### Input
+
+**url** (`string`): The root URL to begin mapping.
+
+**maxDepth** (`number`): Maximum depth of the mapping from the base URL.
+
+**maxBreadth** (`number`): Maximum number of links to follow per page.
+
+**limit** (`number`): Total number of links the mapper processes before stopping.
+
+**instructions** (`string`): Natural language instructions for the mapper.
+
+**selectPaths** (`string[]`): Regex patterns to select specific URL paths.
+
+**selectDomains** (`string[]`): Regex patterns to restrict to specific domains.
+
+**excludePaths** (`string[]`): Regex patterns to exclude specific URL paths.
+
+**excludeDomains** (`string[]`): Regex patterns to exclude specific domains.
+
+**allowExternal** (`boolean`): Whether to include external domain links.
+
+### Output
+
+**baseUrl** (`string`): The root URL that was mapped.
+
+**results** (`string[]`): Discovered URLs.
+
+**responseTime** (`number`): Server response time in seconds.
+
+## Agent example
+
+The following example demonstrates a research agent that combines search and extract:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { createTavilySearchTool, createTavilyExtractTool } from '@mastra/tavily'
+
+const agent = new Agent({
+  id: 'web-search-agent',
+  name: 'Web Search Agent',
+  model: 'anthropic/claude-sonnet-4-6',
+  instructions:
+    'You are a web search assistant. Use search tool to find relevant pages, then use extract tool to get full content from the best results.',
+  tools: {
+    search: createTavilySearchTool(),
+    extract: createTavilyExtractTool(),
+  },
+})
+```
+
+## Environment variables
+
+| Variable         | Description                                                                                 |
+| ---------------- | ------------------------------------------------------------------------------------------- |
+| `TAVILY_API_KEY` | Your Tavily API key. Used as the default when `apiKey` is not passed to a factory function. |
+
+## Related
+
+- [`createTool()`](https://mastra.ai/reference/tools/create-tool)
+- [Tavily API documentation](https://docs.tavily.com)

package/dist/docs/references/reference.md

@@ -201,6 +201,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [MongoDB Storage](https://mastra.ai/reference/storage/mongodb)
 - [MSSQL Storage](https://mastra.ai/reference/storage/mssql)
 - [PostgreSQL Storage](https://mastra.ai/reference/storage/postgresql)
+- [Redis Storage](https://mastra.ai/reference/storage/redis)
 - [Upstash Storage](https://mastra.ai/reference/storage/upstash)
 - [ChunkType](https://mastra.ai/reference/streaming/ChunkType)
 - [MastraModelOutput](https://mastra.ai/reference/streaming/agents/MastraModelOutput)
@@ -217,6 +218,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [createVectorQueryTool()](https://mastra.ai/reference/tools/vector-query-tool)
 - [MCPClient](https://mastra.ai/reference/tools/mcp-client)
 - [MCPServer](https://mastra.ai/reference/tools/mcp-server)
+- [Tavily Tools](https://mastra.ai/reference/tools/tavily)
 - [Amazon S3 Vector Store](https://mastra.ai/reference/vectors/s3vectors)
 - [Astra Vector Store](https://mastra.ai/reference/vectors/astra)
 - [Chroma Vector Store](https://mastra.ai/reference/vectors/chroma)

package/dist/evals/index.cjs

@@ -1,22 +1,22 @@
 'use strict';
 
-var chunk5IIRXFH2_cjs = require('../chunk-5IIRXFH2.cjs');
-var chunkRSFZN7OV_cjs = require('../chunk-RSFZN7OV.cjs');
+var chunkYQ5QJC3S_cjs = require('../chunk-YQ5QJC3S.cjs');
+var chunk2NQ2TF5F_cjs = require('../chunk-2NQ2TF5F.cjs');
 var chunkSBWFQ2CA_cjs = require('../chunk-SBWFQ2CA.cjs');
 
 
 
 Object.defineProperty(exports, "runEvals", {
   enumerable: true,
-  get: function () { return chunk5IIRXFH2_cjs.runEvals; }
+  get: function () { return chunkYQ5QJC3S_cjs.runEvals; }
 });
 Object.defineProperty(exports, "MastraScorer", {
   enumerable: true,
-  get: function () { return chunkRSFZN7OV_cjs.MastraScorer; }
+  get: function () { return chunk2NQ2TF5F_cjs.MastraScorer; }
 });
 Object.defineProperty(exports, "createScorer", {
   enumerable: true,
-  get: function () { return chunkRSFZN7OV_cjs.createScorer; }
+  get: function () { return chunk2NQ2TF5F_cjs.createScorer; }
 });
 Object.defineProperty(exports, "extractTrajectory", {
   enumerable: true,

package/dist/evals/index.js

@@ -1,5 +1,5 @@
-export { runEvals } from '../chunk-KSTYF5BD.js';
-export { MastraScorer, createScorer } from '../chunk-72TFCXLB.js';
+export { runEvals } from '../chunk-SQAGQFGX.js';
+export { MastraScorer, createScorer } from '../chunk-DLDGEMBE.js';
 export { extractTrajectory, extractTrajectoryFromTrace, extractWorkflowTrajectory, listScoresResponseSchema, saveScorePayloadSchema, scoreResultSchema, scoreRowDataSchema, scoringEntityTypeSchema, scoringExtractStepResultSchema, scoringHookInputSchema, scoringInputSchema, scoringInputWithExtractStepResultAndAnalyzeStepResultSchema, scoringInputWithExtractStepResultAndScoreAndReasonSchema, scoringInputWithExtractStepResultSchema, scoringPromptsSchema, scoringSourceSchema, scoringValueSchema } from '../chunk-XV2GQXYR.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/evals/scoreTraces/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkWBPTY4Y7_cjs = require('../../chunk-WBPTY4Y7.cjs');
+var chunk7IMHDDED_cjs = require('../../chunk-7IMHDDED.cjs');
 var chunkSBWFQ2CA_cjs = require('../../chunk-SBWFQ2CA.cjs');
 var chunk2NAHFM32_cjs = require('../../chunk-2NAHFM32.cjs');
 var chunk4U7ZLI36_cjs = require('../../chunk-4U7ZLI36.cjs');
@@ -234,7 +234,7 @@ function transformTraceToScorerInputAndOutput(trace) {
 }
 
 // src/evals/scoreTraces/scoreTracesWorkflow.ts
-var getTraceStep = chunkWBPTY4Y7_cjs.createStep({
+var getTraceStep = chunk7IMHDDED_cjs.createStep({
   id: "__process-trace-scoring",
   inputSchema: v4.z.object({
     targets: v4.z.array(
@@ -429,7 +429,7 @@ async function attachScoreToSpan({
   } catch {
   }
 }
-var scoreTracesWorkflow = chunkWBPTY4Y7_cjs.createWorkflow({
+var scoreTracesWorkflow = chunk7IMHDDED_cjs.createWorkflow({
   id: "__batch-scoring-traces",
   inputSchema: v4.z.object({
     targets: v4.z.array(

package/dist/evals/scoreTraces/index.js

@@ -1,4 +1,4 @@
-import { createStep, createWorkflow } from '../../chunk-DELWJ5NK.js';
+import { createStep, createWorkflow } from '../../chunk-WYPOS74A.js';
 import { saveScorePayloadSchema } from '../../chunk-XV2GQXYR.js';
 import { getEntityTypeForSpan } from '../../chunk-YK76RFQG.js';
 import { MastraError } from '../../chunk-FJEVLHJT.js';