@mastra/mcp-docs-server 1.0.0-beta.9 → 1.0.0

package/.docs/raw/agents/processors.mdx

@@ -1,6 +1,8 @@
 ---
-title: "Processors | Agents | Mastra Docs"
+title: "Processors | Agents"
 description: "Learn how to use input and output processors to transform, validate, and control messages in Mastra agents."
+packages:
+  - "@mastra/core"
 ---
 
 # Processors
@@ -12,6 +14,8 @@ Processors are configured as:
 - **`inputProcessors`**: Run before messages reach the language model.
 - **`outputProcessors`**: Run after the language model generates a response, but before it's returned to users.
 
+You can use individual `Processor` objects or compose them into workflows using Mastra's workflow primitives. Workflows give you advanced control over processor execution order, parallel processing, and conditional logic.
+
 Some processors implement both input and output logic and can be used in either array depending on where the transformation should occur.
 
 ## When to use processors
@@ -33,18 +37,17 @@ Mastra includes several processors for common use cases. You can also create cus
 
 Import and instantiate the processor, then pass it to the agent's `inputProcessors` or `outputProcessors` array:
 
-```typescript {3,9-15} title="src/mastra/agents/moderated-agent.ts" showLineNumbers copy
-import { openai } from "@ai-sdk/openai";
+```typescript {2,8-14} title="src/mastra/agents/moderated-agent.ts"
 import { Agent } from "@mastra/core/agent";
 import { ModerationProcessor } from "@mastra/core/processors";
 
 export const moderatedAgent = new Agent({
   name: "moderated-agent",
   instructions: "You are a helpful assistant",
-  model: openai("gpt-4o-mini"),
+  model: "openai/gpt-4o-mini",
   inputProcessors: [
     new ModerationProcessor({
-      model: openai("gpt-4.1-nano"),
+      model: "openai/gpt-4.1-nano",
       categories: ["hate", "harassment", "violence"],
       threshold: 0.7,
       strategy: "block",
@@ -75,7 +78,7 @@ When memory is enabled on an agent, memory processors are automatically added to
 ```
 [Memory Processors] → [Your inputProcessors]
 ```
-Memory loads conversation history first, then your processors run.
+Memory loads message history first, then your processors run.
 
 **Output processors:**
 ```
@@ -91,7 +94,7 @@ Custom processors implement the `Processor` interface:
 
 ### Custom input processor
 
-```typescript title="src/mastra/processors/custom-input.ts" showLineNumbers copy
+```typescript title="src/mastra/processors/custom-input.ts"
 import type {
   Processor,
   MastraDBMessage,
@@ -139,7 +142,7 @@ The framework handles both return formats, so modifying system messages is optio
 
 To modify system messages (e.g., trim verbose prompts for smaller models), return an object with both `messages` and `systemMessages`:
 
-```typescript title="src/mastra/processors/system-trimmer.ts" showLineNumbers copy
+```typescript title="src/mastra/processors/system-trimmer.ts"
 import type { Processor, CoreMessage, MastraDBMessage } from "@mastra/core";
 
 export class SystemTrimmer implements Processor {
@@ -168,9 +171,83 @@ This is useful for:
 - Filtering or modifying semantic recall content to prevent "prompt too long" errors
 - Dynamically adjusting system instructions based on the conversation
 
+### Per-step processing with processInputStep
+
+While `processInput` runs once at the start of agent execution, `processInputStep` runs at **each step** of the agentic loop (including tool call continuations). This enables per-step configuration changes like dynamic model switching or tool choice modifications.
+
+```typescript title="src/mastra/processors/step-processor.ts"
+import type { Processor, ProcessInputStepArgs, ProcessInputStepResult } from "@mastra/core";
+
+export class DynamicModelProcessor implements Processor {
+  id = "dynamic-model";
+
+  async processInputStep({
+    stepNumber,
+    model,
+    toolChoice,
+    messageList,
+  }: ProcessInputStepArgs): Promise<ProcessInputStepResult> {
+    // Use a fast model for initial response
+    if (stepNumber === 0) {
+      return { model: "openai/gpt-4o-mini" };
+    }
+
+    // Disable tools after 5 steps to force completion
+    if (stepNumber > 5) {
+      return { toolChoice: "none" };
+    }
+
+    // No changes for other steps
+    return {};
+  }
+}
+```
+
+The `processInputStep` method receives:
+- `stepNumber`: Current step in the agentic loop (0-indexed)
+- `steps`: Results from previous steps
+- `messages`: Current messages snapshot (read-only)
+- `systemMessages`: Current system messages (read-only)
+- `messageList`: The full MessageList instance for mutations
+- `model`: Current model being used
+- `tools`: Current tools available for this step
+- `toolChoice`: Current tool choice setting
+- `activeTools`: Currently active tools
+- `providerOptions`: Provider-specific options
+- `modelSettings`: Model settings like temperature
+- `structuredOutput`: Structured output configuration
+
+The method can return any combination of:
+- `model`: Change the model for this step
+- `tools`: Replace or add tools (use spread to merge: `{ tools: { ...tools, newTool } }`)
+- `toolChoice`: Change tool selection behavior
+- `activeTools`: Filter which tools are available
+- `messages`: Replace messages (applied to messageList)
+- `systemMessages`: Replace all system messages
+- `providerOptions`: Modify provider options
+- `modelSettings`: Modify model settings
+- `structuredOutput`: Modify structured output configuration
+
+#### Using prepareStep callback
+
+For simpler per-step logic, you can use the `prepareStep` callback on `generate()` or `stream()` instead of creating a full processor:
+
+```typescript
+await agent.generate("Complex task", {
+  prepareStep: async ({ stepNumber, model }) => {
+    if (stepNumber === 0) {
+      return { model: "openai/gpt-4o-mini" };
+    }
+    if (stepNumber > 5) {
+      return { toolChoice: "none" };
+    }
+  },
+});
+```
+
 ### Custom output processor
 
-```typescript title="src/mastra/processors/custom-output.ts" showLineNumbers copy
+```typescript title="src/mastra/processors/custom-output.ts"
 import type {
   Processor,
   MastraDBMessage,
@@ -204,6 +281,70 @@ export class CustomOutputProcessor implements Processor {
 }
 ```
 
+#### Adding metadata in output processors
+
+You can add custom metadata to messages in `processOutputResult`. This metadata is accessible via the response object:
+
+```typescript title="src/mastra/processors/metadata-processor.ts"
+import type { Processor, MastraDBMessage } from "@mastra/core";
+
+export class MetadataProcessor implements Processor {
+  id = "metadata-processor";
+
+  async processOutputResult({
+    messages,
+  }: {
+    messages: MastraDBMessage[];
+  }): Promise<MastraDBMessage[]> {
+    return messages.map((msg) => {
+      if (msg.role === "assistant") {
+        return {
+          ...msg,
+          content: {
+            ...msg.content,
+            metadata: {
+              ...msg.content.metadata,
+              processedAt: new Date().toISOString(),
+              customData: "your data here",
+            },
+          },
+        };
+      }
+      return msg;
+    });
+  }
+}
+```
+
+Access the metadata with `generate()`:
+
+```typescript
+const result = await agent.generate("Hello");
+
+// The response includes uiMessages with processor-added metadata
+const assistantMessage = result.response?.uiMessages?.find((m) => m.role === "assistant");
+console.log(assistantMessage?.metadata?.customData);
+```
+
+Access the metadata when streaming:
+
+```typescript
+const stream = await agent.stream("Hello");
+
+for await (const chunk of stream.fullStream) {
+  if (chunk.type === "finish") {
+    // Access response with processor-added metadata from the finish chunk
+    const uiMessages = chunk.payload.response?.uiMessages;
+    const assistantMessage = uiMessages?.find((m) => m.role === "assistant");
+    console.log(assistantMessage?.metadata?.customData);
+  }
+}
+
+// Or via the response promise after consuming the stream
+const response = await stream.response;
+console.log(response.uiMessages);
+```
+
 ## Built-in Utility Processors
 
 Mastra provides utility processors for common tasks:
@@ -215,14 +356,13 @@ Mastra provides utility processors for common tasks:
 
 Prevents context window overflow by removing older messages when the total token count exceeds a specified limit.
 
-```typescript copy showLineNumbers {9-12}
+```typescript {7-10}
 import { Agent } from "@mastra/core/agent";
 import { TokenLimiter } from "@mastra/core/processors";
-import { openai } from "@ai-sdk/openai";
 
 const agent = new Agent({
   name: "my-agent",
-  model: openai("gpt-4o"),
+  model: "openai/gpt-4o",
   inputProcessors: [
     // Ensure the total tokens don't exceed ~127k
     new TokenLimiter(127000),
@@ -232,7 +372,7 @@ const agent = new Agent({
 
 The `TokenLimiter` uses the `o200k_base` encoding by default (suitable for GPT-4o). You can specify other encodings for different models:
 
-```typescript copy showLineNumbers {6-9}
+```typescript {6-9}
 import cl100k_base from "js-tiktoken/ranks/cl100k_base";
 
 const agent = new Agent({
@@ -250,14 +390,13 @@ const agent = new Agent({
 
 Removes tool calls from messages sent to the LLM, saving tokens by excluding potentially verbose tool interactions.
 
-```typescript copy showLineNumbers {5-14}
+```typescript {7-16}
 import { Agent } from "@mastra/core/agent";
 import { ToolCallFilter, TokenLimiter } from "@mastra/core/processors";
-import { openai } from "@ai-sdk/openai";
 
 const agent = new Agent({
   name: "my-agent",
-  model: openai("gpt-4o"),
+  model: "openai/gpt-4o",
   inputProcessors: [
     // Example 1: Remove all tool calls/results
     new ToolCallFilter(),
@@ -271,9 +410,87 @@ const agent = new Agent({
 });
 ```
 
-> **Note:** The example above filters tool calls and limits tokens for the LLM, but these filtered messages will still be saved to memory. To also filter messages before they're saved to memory, manually add memory processors before utility processors. See [Memory Processors](/docs/v1/memory/memory-processors#manual-control-and-deduplication) for details.
+:::note
+
+The example above filters tool calls and limits tokens for the LLM, but these filtered messages will still be saved to memory. To also filter messages before they're saved to memory, manually add memory processors before utility processors. See [Memory Processors](/docs/v1/memory/memory-processors#manual-control-and-deduplication) for details.
+
+:::
+
+## Using workflows as processors
+
+You can use Mastra workflows as processors to create complex processing pipelines with parallel execution, conditional branching, and error handling:
+
+```typescript title="src/mastra/processors/moderation-workflow.ts"
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { ProcessorStepSchema } from "@mastra/core/processors";
+import { Agent } from "@mastra/core/agent";
+
+// Create a workflow that runs multiple checks in parallel
+const moderationWorkflow = createWorkflow({
+  id: "moderation-pipeline",
+  inputSchema: ProcessorStepSchema,
+  outputSchema: ProcessorStepSchema,
+})
+  .then(createStep(new LengthValidator({ maxLength: 10000 })))
+  .parallel([
+    createStep(new PIIDetector({ strategy: "redact" })),
+    createStep(new ToxicityChecker({ threshold: 0.8 })),
+  ])
+  .commit();
+
+// Use the workflow as an input processor
+const agent = new Agent({
+  id: "moderated-agent",
+  name: "Moderated Agent",
+  model: "openai/gpt-4o",
+  inputProcessors: [moderationWorkflow],
+});
+```
+
+When an agent is registered with Mastra, processor workflows are automatically registered as workflows, allowing you to view and debug them in the [Studio](/docs/v1/getting-started/studio).
+
+## Retry mechanism
+
+Processors can request that the LLM retry its response with feedback. This is useful for implementing quality checks, output validation, or iterative refinement:
+
+```typescript title="src/mastra/processors/quality-checker.ts"
+import type { Processor } from "@mastra/core";
+
+export class QualityChecker implements Processor {
+  id = "quality-checker";
+
+  async processOutputStep({ text, abort, retryCount }) {
+    const qualityScore = await evaluateQuality(text);
+
+    if (qualityScore < 0.7 && retryCount < 3) {
+      // Request a retry with feedback for the LLM
+      abort("Response quality score too low. Please provide a more detailed answer.", {
+        retry: true,
+        metadata: { score: qualityScore },
+      });
+    }
+
+    return [];
+  }
+}
+
+const agent = new Agent({
+  id: "quality-agent",
+  name: "Quality Agent",
+  model: "openai/gpt-4o",
+  outputProcessors: [new QualityChecker()],
+  maxProcessorRetries: 3, // Maximum retry attempts (default: 3)
+});
+```
+
+The retry mechanism:
+- Only works in `processOutputStep` and `processInputStep` methods
+- Replays the step with the abort reason added as context for the LLM
+- Tracks retry count via the `retryCount` parameter
+- Respects `maxProcessorRetries` limit on the agent
 
 ## Related documentation
 
 - [Guardrails](/docs/v1/agents/guardrails) - Security and validation processors
 - [Memory Processors](/docs/v1/memory/memory-processors) - Memory-specific processors and automatic integration
+- [Processor Interface](/reference/v1/processors/processor-interface) - Full API reference for processors

package/.docs/raw/agents/structured-output.mdx

@@ -1,6 +1,8 @@
 ---
 title: "Structured Output | Agents"
 description: "Learn how to generate structured data from agents using schemas and validation."
+packages:
+  - "@mastra/core"
 ---
 
 import Tabs from "@theme/Tabs";
@@ -23,7 +25,7 @@ Agents can return structured data by defining the expected output with either [Z
 
 Define the `output` shape using [Zod](https://zod.dev/):
 
-```typescript showLineNumbers copy
+```typescript
 import { z } from "zod";
 
 const response = await testAgent.generate("Help me plan my day.", {
@@ -45,7 +47,7 @@ console.log(response.object);
 
 You can also use JSON Schema to define your output structure:
 
-```typescript showLineNumbers copy
+```typescript
 const response = await testAgent.generate("Help me plan my day.", {
   structuredOutput: {
     schema: {
@@ -72,7 +74,11 @@ console.log(response.object);
 </Tabs>
 
 
-> See [.generate()](/reference/v1/agents/generate#structuredoutput) for a full list of configuration options.
+:::info
+
+Visit [.generate()](/reference/v1/agents/generate) for a full list of configuration options.
+
+:::
 
 ### Example output
 
@@ -99,7 +105,7 @@ The `response.object` will contain the structured data as defined by the schema.
 
 Streaming also supports structured output. The final structured object is available on `stream.fullStream` and after the stream completes on `stream.object`. Text stream chunks are still emitted, but they contain natural language text rather than structured data.
 
-```typescript showLineNumbers copy
+```typescript
 import { z } from "zod";
 
 const stream = await testAgent.stream("Help me plan my day.", {
@@ -131,7 +137,7 @@ for await (const chunk of stream.textStream) {
 
 When your main agent isn't proficient at creating structured output you can provide a `model` to `structuredOutput`. In this case, Mastra uses a second agent under the hood to extract structured data from the main agent's natural language response. This makes two LLM calls, one to generate the response and another to turn that response into the structured object, which adds some latency and cost but can improve accuracy for complex structuring tasks.
 
-```typescript showLineNumbers copy
+```typescript
 import { z } from "zod";
 
 const response = await testAgent.generate("Analyze the TypeScript programming language.", {
@@ -156,13 +162,33 @@ const response = await testAgent.generate("Analyze the TypeScript programming la
 console.log(response.object);
 ```
 
-## Response format
+## Combining tools and structured output
+
+When an agent has both tools and structured output configured, some models may not support using both features together. This is a limitation of the underlying model APIs, not Mastra itself.
+
+If your tools aren't being called when structured output is enabled, or you receive an error when combining both features, try one of the workarounds below.
+
+### Workaround options
+
+When your model doesn't support tools and structured output together, you have three options:
+
+1. **Use `jsonPromptInjection: true`** - Injects the schema into the prompt instead of using the API's `response_format` parameter
+2. **Use a separate structuring model** - Pass a `model` to `structuredOutput` to use a second LLM for structuring
+3. **Use `prepareStep`** - Handle tools and structured output in separate steps
+
+Each approach is detailed in the sections below.
+
+## LLM structured output support
+
+Structured output support varies across LLMs due to differences in their APIs. The sections below cover workarounds for models that don't fully support structured output or combining it with tools.
+
+### `jsonPromptInjection`
 
 By default, Mastra passes the schema to the model provider using the `response_format` API parameter. Most model providers have built-in support for this, which reliably enforces the schema.
 
 If your model provider doesn't support `response_format`, you'll get an error from the API. When this happens, set `jsonPromptInjection: true`. This adds the schema to the system prompt instead, instructing the model to output JSON. This is less reliable than the API parameter approach.
 
-```typescript showLineNumbers copy
+```typescript
 import { z } from "zod";
 
 const response = await testAgent.generate("Help me plan my day.", {
@@ -194,11 +220,55 @@ const response = await agentWithTools.generate("Your prompt", {
 ```
 :::
 
+### Using a separate structuring model
+
+When `model` is provided to the `structuredOutput` property, Mastra uses a separate internal agent to handle the structured output. The main agent will handle all of the steps (including tool calling) and the structured output model will handle only the generation of structured output.
+
+```typescript
+const response = await testAgent.generate("Tell me about TypeScript.", {
+  structuredOutput: {
+    schema: yourSchema
+    model: 'openai/gpt-4o'
+  }
+});
+```
+
+### 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.
+
+```typescript
+const result = await agent.stream("weather in vancouver?", {
+  prepareStep: async ({ stepNumber }) => {
+    if (stepNumber === 0) {
+      return {
+        model: "anthropic/claude-sonnet-4-20250514",
+        tools: {
+          weatherTool,
+        },
+        toolChoice: "required",
+      };
+    }
+    return {
+      model: "anthropic/claude-sonnet-4-20250514",
+      tools: undefined,
+      structuredOutput: {
+        schema: z.object({
+          temperature: z.number(),
+          humidity: z.number(),
+          windSpeed: z.number(),
+        }),
+      },
+    };
+  },
+});
+```
+
 ## Error handling
 
 When schema validation fails, you can control how errors are handled using `errorStrategy`. The default `strict` strategy throws an error, while `warn` logs a warning and continues. The `fallback` strategy returns the values provided using `fallbackValue`.
 
-```typescript showLineNumbers copy
+```typescript
 import { z } from "zod";
 
 const response = await testAgent.generate("Tell me about TypeScript.", {

package/.docs/raw/agents/using-tools.mdx

@@ -1,6 +1,8 @@
 ---
 title: "Using Tools | Agents"
 description: Learn how to create tools and add them to agents to extend capabilities beyond text generation.
+packages:
+  - "@mastra/core"
 ---
 
 # Using Tools
@@ -17,7 +19,7 @@ When creating tools, keep descriptions simple and focused on what the tool does,
 
 This example shows how to create a tool that fetches weather data from an API. When the agent calls the tool, it provides the required input as defined by the tool's `inputSchema`. The tool accesses this data through its `inputData` parameter, which in this example includes the `location` used in the weather API query.
 
-```typescript {14} title="src/mastra/tools/weather-tool.ts" showLineNumbers copy
+```typescript title="src/mastra/tools/weather-tool.ts"
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 
@@ -47,7 +49,7 @@ To make a tool available to an agent, add it to `tools`. Mentioning available to
 
 An agent can use multiple tools to handle more complex tasks by delegating specific parts to individual tools. The agent decides which tools to use based on the user's message, the agent's instructions, and the tool descriptions and schemas.
 
-```typescript {8,10} title="src/mastra/agents/weather-agent.ts" showLineNumbers copy
+```typescript {11} title="src/mastra/agents/weather-agent.ts"
 import { Agent } from "@mastra/core/agent";
 import { weatherTool } from "../tools/weather-tool";
 
@@ -66,7 +68,7 @@ export const weatherAgent = new Agent({
 
 The agent uses the tool's `inputSchema` to infer what data the tool expects. In this case, it extracts `London` as the `location` from the message and passes it to the tool's inputData parameter.
 
-```typescript title="src/test-tool.ts" showLineNumbers copy
+```typescript title="src/test-tool.ts"
 import { mastra } from "./mastra";
 
 const agent = mastra.getAgent("weatherAgent");
@@ -78,20 +80,79 @@ const result = await agent.generate("What's the weather in London?");
 
 When multiple tools are available, the agent may choose to use one, several, or none, depending on what's needed to answer the query.
 
-```typescript {8} title="src/mastra/agents/weather-agent.ts" showLineNumbers copy
+```typescript {7} title="src/mastra/agents/weather-agent.ts"
 import { weatherTool } from "../tools/weather-tool";
 import { activitiesTool } from "../tools/activities-tool";
 
 export const weatherAgent = new Agent({
   id: "weather-agent",
   name: "Weather Agent",
-  // ..
   tools: { weatherTool, activitiesTool },
 });
 ```
 
+## Using workflows as tools
+
+Workflows can be added to agents through the `workflows` configuration. When you add a workflow, Mastra automatically converts it to a tool that the agent can call. The generated tool is named `workflow-<workflowName>` and uses the workflow's `inputSchema` and `outputSchema`.
+
+```typescript {14-16} title="src/mastra/agents/research-agent.ts"
+import { Agent } from "@mastra/core/agent";
+import { researchWorkflow } from "../workflows/research-workflow";
+
+export const researchAgent = new Agent({
+  id: "research-agent",
+  name: "Research Agent",
+  instructions: `
+      You are a research assistant.
+      Use the research workflow to gather and compile information on topics.`,
+  model: "openai/gpt-5.1",
+  tools: {
+    weatherTool,
+  },
+  workflows: {
+    researchWorkflow,
+  },
+});
+```
+
+The workflow should include a `description` to help the agent understand when to use it:
+
+```typescript title="src/mastra/workflows/research-workflow.ts"
+import { createWorkflow } from "@mastra/core/workflows";
+import { z } from "zod";
+
+export const researchWorkflow = createWorkflow({
+  id: "research-workflow",
+  description: "Gathers information on a topic and compiles a summary report.",
+  inputSchema: z.object({
+    topic: z.string(),
+  }),
+  outputSchema: z.object({
+    summary: z.string(),
+    sources: z.array(z.string()),
+  }),
+})
+  .then(gatherSourcesStep)
+  .then(compileReportStep)
+  .commit();
+```
+
+When the agent calls the workflow tool, it receives a response containing the workflow result and a `runId` that can be used to track the execution:
+
+```typescript
+{
+  result: { summary: "...", sources: ["..."] },
+  runId: "abc-123"
+}
+```
+
+## Tools with structured output
+
+When using tools with [structured output](/docs/v1/agents/structured-output), some models don't support combining both features in the same API call. If your tools aren't being called when structured output is enabled, or you receive errors about incompatible options, see [Combining tools and structured output](/docs/v1/agents/structured-output#combining-tools-and-structured-output) for model compatibility information and workarounds.
+
 ## Related
 
 - [MCP Overview](/docs/v1/mcp/overview)
+- [Structured Output](/docs/v1/agents/structured-output)
 - [Agent Memory](/docs/v1/agents/agent-memory)
-- [Request Context](/docs/v1/server-db/request-context)
+- [Request Context](/docs/v1/server/request-context)

package/.docs/raw/course/01-first-agent/07-creating-your-agent.md

@@ -8,7 +8,6 @@ Now add the necessary imports at the top of your file:
 
 ```typescript
 import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
 // We'll import our tool in a later step
 ```
 
@@ -43,7 +42,7 @@ SUCCESS CRITERIA
 - Deliver accurate and helpful analysis of transaction data.
 - Achieve high user satisfaction through clear and helpful responses.
 - Maintain user trust by ensuring data privacy and security.`,
-  model: openai("gpt-4o"), // You can use "gpt-3.5-turbo" if you prefer
+  model: "openai/gpt-4.1-mini",
   tools: {}, // We'll add tools in a later step
 });
 ```

package/.docs/raw/course/01-first-agent/12-connecting-tool-to-agent.md

@@ -19,7 +19,7 @@ export const financialAgent = new Agent({
   TOOLS
   - Use the getTransactions tool to fetch financial transaction data.
   - Analyze the transaction data to answer user questions about their spending.`,
-  model: openai("gpt-4o"),
+  model: "openai/gpt-4.1-mini",
   tools: { getTransactionsTool }, // Add our tool here
 });
 ```

package/.docs/raw/course/01-first-agent/16-adding-memory-to-agent.md

@@ -6,7 +6,6 @@ Now, let's update our agent to include memory. Open your `agents/index.ts` file
 
 ```typescript
 import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
 import { Memory } from "@mastra/memory";
 import { LibSQLStore } from "@mastra/libsql";
 import { getTransactionsTool } from "../tools";
@@ -20,7 +19,7 @@ export const financialAgent = new Agent({
   instructions: `ROLE DEFINITION
   // ... existing instructions ...
   `,
-  model: openai("gpt-4o"),
+  model: "openai/gpt-4.1-mini",
   tools: { getTransactionsTool },
   memory: new Memory({
     storage: new LibSQLStore({

package/.docs/raw/course/02-agent-tools-mcp/05-updating-your-agent.md

@@ -10,7 +10,7 @@ export const personalAssistantAgent = new Agent({
     
     Keep your responses concise and friendly.
   `,
-  model: openai("gpt-4o"),
+  model: "openai/gpt-4.1-mini",
   tools: { ...mcpTools }, // Add MCP tools to your agent
 });
 ```

package/.docs/raw/course/02-agent-tools-mcp/10-updating-agent-instructions-zapier.md

@@ -18,7 +18,7 @@ export const personalAssistantAgent = new Agent({
     
     Keep your responses concise and friendly.
   `,
-  model: openai("gpt-4o"),
+  model: "openai/gpt-4.1-mini",
   tools: { ...mcpTools },
   memory,
 });