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

package/.docs/raw/server-db/server-adapters.mdx

@@ -0,0 +1,312 @@
+---
+title: "Server Adapters | Server & DB"
+description: "Manually configure a Mastra server using Hono or Express adapters."
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# Server Adapters
+
+Server adapters let you run Mastra with your own HTTP server instead of the Hono server generated by `mastra build`. They provide more control over the server setup, including custom middleware ordering, authentication, logging, and deployment configuration. You can still integrate Mastra into any Node.js application without changing how agents or workflows execute.
+
+## When to use server adapters
+
+- You want Mastra’s endpoints added automatically to an existing application
+- You need direct access to the server instance for custom configuration
+- Your team prefers using another server framework instead of the Hono server created by `mastra build`.
+
+:::tip
+
+For simple deployments without custom server requirements, use `mastra build` instead. It configures server setup, registers middleware, and applies deployment settings based on your project configuration. See [Server Configuration](/docs/v1/server-db/mastra-server).
+
+:::
+
+## Available adapters
+
+Mastra currently provides two official server adapters:
+
+- [@mastra/express](/reference/v1/server/express-adapter): Express framework adapter
+- [@mastra/hono](/reference/v1/server/hono-adapter): Hono framework adapter
+
+You can build your own adapter, read [Custom Adapters](/docs/v1/server-db/custom-adapters) for details.
+
+## Installation
+
+Install the adapter for the framework of your choice.
+
+<Tabs>
+  <TabItem value="express" label="Express">
+
+```bash
+npm install @mastra/express@beta
+```
+  </TabItem>
+  <TabItem value="hono" label="Hono">
+
+```bash
+npm install @mastra/hono@beta
+```
+  </TabItem>
+</Tabs>
+
+## Configuration
+
+Initialize your app as usual, then create a `MastraServer` by passing in the `app` and your main `mastra` instance from `src/mastra/index.ts`. Calling `init()` automatically registers Mastra middleware and all available endpoints. You can continue adding your own routes as normal, either before or after `init()`, and they’ll run alongside Mastra’s endpoints.
+
+<Tabs>
+  <TabItem value="express" label="Express">
+
+```typescript {8} title="src/express-server.ts"
+import express from "express";
+import { MastraServer } from "@mastra/express";
+import { mastra } from "./mastra";
+
+const app = express();
+app.use(express.json());
+
+const server = new MastraServer({ app, mastra });
+
+await server.init();
+
+app.listen(4111, () => {
+  console.log('Server running on port 4111');
+});
+```
+
+  </TabItem>
+  <TabItem value="hono" label="Hono">
+
+```typescript {8} title="src/hono-server.ts"
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { HonoBindings, HonoVariables, MastraServer } from "@mastra/hono";
+import { mastra } from "./mastra";
+
+const app = new Hono<{ Bindings: HonoBindings; Variables: HonoVariables }>();
+
+const server = new MastraServer({ app, mastra });
+
+await server.init();
+
+serve({ fetch: app.fetch, port: 4111 }, () => {
+  console.log('Server running on port 4111');
+});
+```
+
+  </TabItem>
+</Tabs>
+
+:::info
+
+See the [Express Adapter](/reference/v1/server/express-adapter) or [Hono Adapter](/reference/v1/server/hono-adapter) docs for full configuration options.
+
+:::
+
+## Initialization flow
+
+Calling `init()` runs three steps in order. Understanding this flow helps when you need to insert your own middleware at specific points.
+
+1. `registerContextMiddleware()`: Attaches the Mastra instance, request context, tools, and abort signal to every request. This makes Mastra available to all subsequent middleware and route handlers.
+2. `registerAuthMiddleware()`: Adds authentication and authorization middleware, but only if `server.auth` is configured in your Mastra instance. Skipped entirely if no auth is configured.
+3. `registerRoutes()`: Registers all Mastra API routes for agents, workflows, and other features. Also registers MCP routes if MCP servers are configured.
+
+### Manual initialization
+
+For custom middleware ordering, call each method separately instead of `init()`. This is useful when you need middleware that runs before Mastra's context is set up, or when you need to insert logic between the initialization steps.
+
+```typescript title="server.ts" copy
+const server = new MastraServer({ app, mastra });
+
+// Your middleware first
+app.use(loggingMiddleware);
+
+server.registerContextMiddleware();
+
+// Middleware that needs Mastra context
+app.use(customMiddleware);
+
+server.registerAuthMiddleware();
+await server.registerRoutes();
+
+// Routes after Mastra
+app.get('/health', ...);
+```
+
+:::tip
+
+Use manual initialization when you need middleware that runs before Mastra's context is available, or when you need to insert middleware between the context and auth steps.
+
+:::
+
+## Adding custom routes
+
+You can add your own routes to the app alongside Mastra's routes.
+
+- Routes added **before** `init()` won't have Mastra context available.
+- Routes added **after** `init()` have access to the Mastra context (the Mastra instance, request context, authenticated user, etc.).
+
+:::info
+
+Visit "Adding custom routes" for [Express](/reference/v1/server/express-adapter#adding-custom-routes) and [Hono](/reference/v1/server/hono-adapter#adding-custom-routes) for more information.
+
+:::
+
+## Route prefixes
+
+By default, Mastra routes are registered at `/api/agents`, `/api/workflows`, etc. Use the `prefix` option to change this. This is useful for API versioning or when integrating with an existing app that has its own `/api` routes.
+
+```typescript copy
+const server = new MastraServer({
+  app,
+  mastra,
+  prefix: '/api/v2',
+});
+```
+
+With this prefix, Mastra routes become `/api/v2/agents`, `/api/v2/workflows`, etc. Custom routes you add directly to the app are not affected by this prefix.
+
+## OpenAPI spec
+
+Mastra can generate an OpenAPI specification for all registered routes. This is useful for documentation, client generation, or integration with API tools. Enable it by setting the `openapiPath` option:
+
+```typescript copy
+const server = new MastraServer({
+  app,
+  mastra,
+  openapiPath: '/openapi.json',
+});
+```
+
+The spec is generated from the Zod schemas defined on each route and served at the specified path. It includes all Mastra routes as well as any custom routes created with `createRoute()`.
+
+## Stream data redaction
+
+When streaming agent responses over HTTP, the HTTP streaming layer redacts sensitive information from stream chunks before sending them to clients. This prevents accidental exposure of:
+
+- System prompts and agent instructions
+- Tool definitions and their parameters
+- API keys and other credentials in request bodies
+- Internal configuration data
+
+This redaction happens at the HTTP boundary, so internal callbacks like `onStepFinish` still have access to the full request data for debugging and observability purposes.
+
+By default, redaction is enabled. Configure this behavior via `streamOptions`. Set `redact: false` only for internal services or debugging scenarios where you need access to the full request data in stream responses.
+
+```typescript copy
+const server = new MastraServer({
+  app,
+  mastra,
+  streamOptions: {
+    redact: true, // Default
+  },
+});
+```
+
+:::info
+
+See [MastraServer](/reference/v1/server/mastra-server) for full configuration options.
+
+:::
+
+## Per-route auth overrides
+
+When authentication is configured on your Mastra instance, all routes require authentication by default. Sometimes you need exceptions: public health check endpoints, webhook receivers, or admin routes that need stricter controls.
+
+Use `customRouteAuthConfig` to override authentication behavior for specific routes. Keys follow the format `METHOD:PATH` where method is `GET`, `POST`, `PUT`, `DELETE`, or `ALL`. Paths support wildcards (`*`) for matching multiple routes. Setting a value to `false` makes the route public, while `true` requires authentication.
+
+```typescript copy
+const server = new MastraServer({
+  app,
+  mastra,
+  customRouteAuthConfig: new Map([
+    // Public health check
+    ['GET:/api/health', false],
+    // Public API spec
+    ['GET:/api/openapi.json', false],
+    // Public webhook endpoints
+    ['POST:/api/webhooks/*', false],
+    // Require auth even if globally disabled
+    ['POST:/api/admin/reset', true],
+    // Protect all methods on internal routes
+    ['ALL:/api/internal/*', true],
+  ]),
+});
+```
+
+:::info
+
+See [MastraServer](/reference/v1/server/mastra-server) for full configuration options.
+
+:::
+
+## Accessing the app
+
+After creating the adapter, you may still need access to the underlying framework app. This is useful when passing it to a platform’s `serve` function or when adding routes from another module.
+
+```typescript copy
+// Via the MastraServer instance
+const app = server.getApp();
+
+// Via the Mastra instance (available after adapter construction)
+const app = mastra.getServerApp();
+```
+
+Both methods return the same app instance. Use whichever is more convenient based on what's in scope.
+
+## Server config vs adapter options
+
+When using server adapters, configuration comes from two places: the Mastra `server` config (passed to the `Mastra` constructor) and the adapter constructor options. Understanding which options come from where helps avoid confusion when settings don't seem to take effect.
+
+### Used by adapters
+
+The adapter reads these settings from `mastra.getServer()`:
+
+| Option | Description |
+|--------|-------------|
+| `auth` | Authentication config, used by `registerAuthMiddleware()`. |
+| `bodySizeLimit` | Default body size limit in bytes. Can be overridden per-adapter via `bodyLimitOptions`. |
+
+### Adapter constructor only
+
+These options are passed directly to the adapter constructor and are not read from the Mastra config:
+
+| Option | Description |
+|--------|-------------|
+| `prefix` | Route path prefix |
+| `openapiPath` | OpenAPI spec endpoint |
+| `bodyLimitOptions` | Body size limit with custom error handler |
+| `streamOptions` | Stream redaction settings |
+| `customRouteAuthConfig` | Per-route auth overrides |
+
+### Not used by adapters
+
+These `server` config options are only used by `mastra build` and have no effect when using adapters directly:
+
+| Option | Used by |
+|--------|---------|
+| `port`, `host` | `mastra dev`, `mastra build` |
+| `cors` | `mastra build` adds CORS middleware |
+| `timeout` | `mastra build` |
+| `apiRoutes` | `registerApiRoute()` for `mastra build` |
+| `middleware` | Middleware config for `mastra build` |
+
+When using adapters, configure these features directly with your framework. For example, add CORS middleware using Hono's or Express's built-in CORS packages, and set the port when calling your framework's listen function.
+
+## MCP support
+
+Server adapters register MCP (Model Context Protocol) routes during `registerRoutes()` when MCP servers are configured in your Mastra instance. MCP allows external tools and services to connect to your Mastra server and interact with your agents.
+
+The adapter registers routes for both HTTP and SSE (Server-Sent Events) transports, enabling different client connection patterns.
+
+See [MCP](/docs/v1/mcp/overview) for configuration details and how to set up MCP servers.
+
+## Related
+
+- [Hono Adapter](/reference/v1/server/hono-adapter) - Hono-specific setup
+- [Express Adapter](/reference/v1/server/express-adapter) - Express-specific setup
+- [Custom Adapters](/docs/v1/server-db/custom-adapters) - Building adapters for other frameworks
+- [Server Configuration](/docs/v1/server-db/mastra-server) - Using `mastra build` instead
+- [Authentication](/docs/v1/auth) - Configuring auth for your server
+- [MastraServer Reference](/reference/v1/server/mastra-server) - Full API reference
+- [createRoute() Reference](/reference/v1/server/create-route) - Creating type-safe custom routes

package/.docs/raw/server-db/storage.mdx

@@ -1,5 +1,5 @@
 ---
-title: "MastraStorage | Server & DB | Mastra Docs"
+title: "MastraStorage | Server & DB"
 description: Overview of Mastra's storage system and data persistence capabilities.
 ---
 
@@ -489,12 +489,23 @@ console.log(result.messages); // MastraDBMessage[]
 console.log(result.total); // Total count
 console.log(result.hasMore); // Whether more pages exist
 
+// Get messages from multiple threads at once
+const multiThreadResult = await mastra
+  .getStorage()
+  .listMessages({
+    threadId: ["thread-1", "thread-2", "thread-3"],
+    page: 0,
+    perPage: 100
+  });
+
 // Get messages by their IDs
 const messages = await mastra
   .getStorage()
   .listMessagesById({ messageIds: messageIdArr });
 ```
 
+The `threadId` parameter accepts either a single thread ID string or an array of thread IDs to query messages from multiple threads in a single request.
+
 All message queries return `MastraDBMessage[]` format. If you need to convert messages to AI SDK formats for UI rendering, use the conversion utilities from `@mastra/ai-sdk/ui`:
 
 ```typescript copy

package/.docs/raw/streaming/events.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Streaming Events | Streaming | Mastra Docs"
+title: "Streaming Events | Streaming"
 description: "Learn about the different types of streaming events in Mastra, including text deltas, tool calls, step events, and how to handle them in your applications."
 ---
 

package/.docs/raw/streaming/overview.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Streaming Overview | Streaming | Mastra Docs"
+title: "Streaming Overview | Streaming"
 description: "Streaming in Mastra enables real-time, incremental responses from both agents and workflows, providing immediate feedback as AI-generated content is produced."
 ---
 
@@ -60,19 +60,30 @@ An agent stream provides access to various response properties:
 
 AI SDK v5 uses `LanguageModelV2` for the model providers. If you are getting an error that you are using an AI SDK v4 model you will need to upgrade your model package to the next major version.
 
-For integration with AI SDK v5, use `format` 'aisdk' to get an `AISDKV5OutputStream`:
+For integration with AI SDK v5, use the `toAISdkV5Stream()` utility from `@mastra/ai-sdk` to convert Mastra streams to AI SDK-compatible format:
+
+```typescript {2,9-12} showLineNumbers copy
+import { toAISdkV5Stream } from "@mastra/ai-sdk";
 
-```typescript {5} showLineNumbers copy
 const testAgent = mastra.getAgent("testAgent");
 
-const stream = await testAgent.stream(
-  [{ role: "user", content: "Help me organize my day" }],
-  { format: "aisdk" },
-);
+const stream = await testAgent.stream([
+  { role: "user", content: "Help me organize my day" },
+]);
 
-for await (const chunk of stream.textStream) {
-  process.stdout.write(chunk);
-}
+// Convert to AI SDK v5 compatible stream
+const aiSDKStream = toAISdkV5Stream(stream, { from: "agent" });
+
+// Use with AI SDK v5 methods
+```
+
+For converting messages to AI SDK v5 format, use the `toAISdkV5Messages()` utility from `@mastra/ai-sdk/ui`:
+
+```typescript {1,4} showLineNumbers copy
+import { toAISdkV5Messages } from "@mastra/ai-sdk/ui";
+
+const messages = [{ role: "user", content: "Hello" }];
+const aiSDKMessages = toAISdkV5Messages(messages);
 ```
 
 ### Using `Agent.network()`
@@ -121,14 +132,14 @@ console.log("Token usage:", await networkStream.usage);
 
 Streaming from a workflow returns a sequence of structured events describing the run lifecycle, rather than incremental text chunks. This event-based format makes it possible to track and respond to workflow progress in real time once a run is created using `.createRun()`.
 
-### Using `Run.streamVNext()`
+### Using `Run.stream()`
 
-This is the experimental API. It returns a `ReadableStream` of events directly.
+The `stream()` method returns a `ReadableStream` of events directly.
 
 ```typescript {3,9} showLineNumbers copy
 const run = await testWorkflow.createRun();
 
-const stream = await run.streamVNext({
+const stream = await run.stream({
   inputData: {
     value: "initial data",
   },
@@ -139,16 +150,16 @@ for await (const chunk of stream) {
 }
 ```
 
-> See Run.streamVNext() method documentation for more information.
+> See [Run.stream()](/reference/v1/streaming/workflows/stream) method documentation for more information.
 
 ### Output from `Run.stream()`
 
-The experimental API event structure includes `runId` and `from` at the top level, making it easier to identify and track workflow runs without digging into the payload.
+The event structure includes `runId` and `from` at the top level, making it easier to identify and track workflow runs without digging into the payload.
 
 ```typescript
 // ...
 {
-  type: 'step-start',
+  type: 'workflow-start',
   runId: '1eeaf01a-d2bf-4e3f-8d1b-027795ccd3df',
   from: 'WORKFLOW',
   payload: {

package/.docs/raw/streaming/tool-streaming.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Tool streaming | Streaming | Mastra Docs"
+title: "Tool streaming | Streaming"
 description: "Learn how to use tool streaming in Mastra, including handling tool calls, tool results, and tool execution events during streaming."
 ---
 
@@ -18,47 +18,44 @@ By combining writable tool streams with agent streaming, you gain fine grained c
 
 Agent streaming can be combined with tool calls, allowing tool outputs to be written directly into the agent’s streaming response. This makes it possible to surface tool activity as part of the overall interaction.
 
-```typescript {4,10} showLineNumbers copy
-import { openai } from "@ai-sdk/openai";
+```typescript {2,9} showLineNumbers copy
 import { Agent } from "@mastra/core/agent";
-
 import { testTool } from "../tools/test-tool";
 
 export const testAgent = new Agent({
   id: "test-agent",
   name: "Test Agent",
   instructions: "You are a weather agent.",
-  model: openai("gpt-4o-mini"),
+  model: "openai/gpt-5.1",
   tools: { testTool },
 });
 ```
 
 ### Using `context.writer`
 
-The `context.writer` object is available in a tool's `execute` function and can be used to emit custom events, data, or values into the active stream. This enables tools to provide intermediate results or status updates while execution is still in progress.
+The `context.writer` object is available in a tool's `execute()` function and can be used to emit custom events, data, or values into the active stream. This enables tools to provide intermediate results or status updates while execution is still in progress.
 
 :::warning
 
-You must `await` the call to `writer.write(...)` or else you will lock the stream and get a `WritableStream is locked` error.
+You must `await` the call to `writer.write()` or else you will lock the stream and get a `WritableStream is locked` error.
 
 :::
 
-```typescript {5,8,15} showLineNumbers copy
+```typescript {4,7,14} showLineNumbers copy
 import { createTool } from "@mastra/core/tools";
 
 export const testTool = createTool({
-  // ...
   execute: async (inputData, context) => {
     const { value } = inputData;
 
-   await context?.writer?.write({
+    await context?.writer?.write({
       type: "custom-event",
       status: "pending"
     });
 
     const response = await fetch(...);
 
-   await context?.writer?.write({
+    await context?.writer?.write({
       type: "custom-event",
       status: "success"
     });
@@ -70,14 +67,13 @@ export const testTool = createTool({
 });
 ```
 
-You can also use `writer.custom` if you want to emit top level stream chunks, This useful and relevant when
+You can also use `writer.custom()` if you want to emit top level stream chunks, This useful and relevant when
 integrating with UI Frameworks
 
-```typescript {5,8,15} showLineNumbers copy
+```typescript {4,7,14} showLineNumbers copy
 import { createTool } from "@mastra/core/tools";
 
 export const testTool = createTool({
-  // ...
   execute: async (inputData, context) => {
     const { value } = inputData;
 
@@ -117,23 +113,66 @@ for await (const chunk of stream) {
 }
 ```
 
+## Tool Lifecycle Hooks
+
+Tools support lifecycle hooks that allow you to monitor different stages of tool execution during streaming. These hooks are particularly useful for logging or analytics.
+
+### Example: Using onInputAvailable and onOutput
+
+```typescript showLineNumbers copy
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+export const weatherTool = createTool({
+  id: "weather-tool",
+  description: "Get weather information",
+  inputSchema: z.object({
+    city: z.string(),
+  }),
+  outputSchema: z.object({
+    temperature: z.number(),
+    conditions: z.string(),
+  }),
+  // Called when the complete input is available
+  onInputAvailable: ({ input, toolCallId }) => {
+    console.log(`Weather requested for: ${input.city}`);
+  },
+  execute: async (input) => {
+    const weather = await fetchWeather(input.city);
+    return weather;
+  },
+  // Called after successful execution
+  onOutput: ({ output, toolName }) => {
+    console.log(`${toolName} result: ${output.temperature}°F, ${output.conditions}`);
+  },
+});
+```
+
+### Available Hooks
+
+- **onInputStart**: Called when tool call input streaming begins
+- **onInputDelta**: Called for each chunk of input as it streams in
+- **onInputAvailable**: Called when complete input is parsed and validated
+- **onOutput**: Called after the tool successfully executes with the output
+
+For detailed documentation on all lifecycle hooks, see the [createTool() reference](/reference/v1/tools/create-tool#tool-lifecycle-hooks).
+
 ## Tool using an agent
 
-Pipe an agent’s `textStream` to the tool’s `writer`. This streams partial output, and Mastra automatically aggregates the agent’s usage into the tool run.
+Pipe an agent's `fullStream` to the tool's `writer`. This streams partial output, and Mastra automatically aggregates the agent's usage into the tool run.
 
 ```typescript showLineNumbers copy
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 
 export const testTool = createTool({
-  // ...
   execute: async (inputData, context) => {
     const { city } = inputData;
 
-    const testAgent = context?.mastra?.getAgent("testAgent");
-    const stream = await testAgent?.stream(`What is the weather in ${city}?`);
+    const agent = context?.mastra?.getAgent("testAgent");
+    const stream = await agent?.stream(`What is the weather in ${city}?`);
 
-    await stream!.textStream.pipeTo(context?.writer!);
+    await stream!.fullStream.pipeTo(context?.writer!);
 
     return {
       value: await stream!.text,

package/.docs/raw/streaming/workflow-streaming.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Workflow streaming | Streaming | Mastra Docs"
+title: "Workflow streaming | Streaming"
 description: "Learn how to use workflow streaming in Mastra, including handling workflow execution events, step streaming, and workflow integration with agents and tools."
 ---
 
@@ -16,12 +16,6 @@ By combining writable workflow streams with agent streaming, you gain fine-grain
 
 ### Using the `writer` argument
 
-:::warning
-
-The writer is only available when using `streamVNext`.
-
-:::
-
 The `writer` argument is passed to a workflow step's `execute` function and can be used to emit custom events, data, or values into the active stream. This enables workflow steps to provide intermediate results or status updates while execution is still in progress.
 
 :::warning
@@ -66,7 +60,7 @@ const testWorkflow = mastra.getWorkflow("testWorkflow");
 
 const run = await testWorkflow.createRun();
 
-const stream = await run.streamVNext({
+const stream = await run.stream({
   inputData: {
     value: "initial data",
   },
@@ -77,8 +71,8 @@ for await (const chunk of stream) {
 }
 
 if (result!.status === "suspended") {
-  // if the workflow is suspended, we can resume it with the resumeStreamVNext method
-  const resumedStream = await run.resumeStreamVNext({
+  // if the workflow is suspended, we can resume it with the resumeStream method
+  const resumedStream = await run.resumeStream({
     resumeData: { value: "resume data" },
   });
 
@@ -90,10 +84,10 @@ if (result!.status === "suspended") {
 
 ### Resuming an interrupted workflow stream
 
-If a workflow stream is closed or interrupted for any reason, you can resume it with the `resumeStreamVNext` method. This will return a new `ReadableStream` that you can use to observe the workflow events.
+If a workflow stream is closed or interrupted for any reason, you can resume it with the `resumeStream` method. This will return a new `ReadableStream` that you can use to observe the workflow events.
 
 ```typescript showLineNumbers copy
-const newStream = await run.resumeStreamVNext();
+const newStream = await run.resumeStream();
 
 for await (const chunk of newStream) {
   console.log(chunk);

package/.docs/raw/tools-mcp/advanced-usage.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Advanced Tool Usage | Tools & MCP | Mastra Docs"
+title: "Advanced Tool Usage | Tools & MCP"
 description: This page covers advanced features for Mastra tools, including abort signals and compatibility with the Vercel AI SDK tool format.
 ---
 
@@ -110,7 +110,6 @@ You can then add this tool to your Mastra agent just like any other tool:
 
 ```typescript title="src/mastra/agents/mixedToolsAgent.ts"
 import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
 import { vercelWeatherTool } from "../tools/vercelWeatherTool"; // Vercel AI SDK tool
 import { mastraTool } from "../tools/mastraTool"; // Mastra createTool tool
 
@@ -118,7 +117,7 @@ export const mixedToolsAgent = new Agent({
   id: "mixed-tools-agent",
   name: "Mixed Tools Agent",
   instructions: "You can use tools defined in different formats.",
-  model: openai("gpt-4o-mini"),
+  model: "openai/gpt-5.1",
   tools: {
     weatherVercel: vercelWeatherTool,
     someMastraTool: mastraTool,