@mastra/mcp-docs-server 1.1.17-alpha.1 → 1.1.17-alpha.3

package/.docs/docs/memory/observational-memory.md

@@ -150,17 +150,19 @@ const memory = new Memory({
       observation: {
         model: new ModelByInputTokens({
           upTo: {
-            10_000: 'google/gemini-2.5-flash', // Fast and cheap for small inputs
-            40_000: 'openai/gpt-4o', // Stronger for medium inputs
-            1_000_000: 'openai/gpt-4.5', // Most capable for very large inputs
+            // Faster, cheaper models for smaller inputs; stronger models for larger contexts
+            5_000: 'openrouter/mistralai/ministral-8b-2512',
+            20_000: 'openrouter/mistralai/mistral-small-2603',
+            40_000: 'openai/gpt-5.4-mini',
+            1_000_000: 'google/gemini-3.1-flash-lite-preview',
           },
         }),
       },
       reflection: {
         model: new ModelByInputTokens({
           upTo: {
-            20_000: 'google/gemini-2.5-flash',
-            80_000: 'openai/gpt-4o',
+            20_000: 'openai/gpt-5.4-mini',
+            100_000: 'google/gemini-2.5-flash',
           },
         }),
       },

package/.docs/docs/observability/tracing/bridges/otel.md

@@ -151,10 +151,10 @@ With the OtelBridge, your traces maintain proper hierarchy across OTEL and Mastr
 ```text
 HTTP POST /api/chat (from Hono middleware)
 └── agent.assistant (from Mastra via OtelBridge)
-    ├── chat gpt-4o (LLM call)
+    ├── chat gpt-5.4 (LLM call)
     ├── tool.execute search (tool execution)
     │   └── HTTP GET api.example.com (from OTEL auto-instrumentation)
-    └── chat gpt-4o (follow-up LLM call)
+    └── chat gpt-5.4 (follow-up LLM call)
 ```
 
 ## Multi-service distributed tracing
@@ -167,7 +167,7 @@ Service A: HTTP POST /api/process
 
 Service B: HTTP POST /api/analyze (incoming call - same trace!)
 └── agent.analyzer (Mastra agent inherits trace context)
-    └── chat gpt-4o
+    └── chat gpt-5.4
 ```
 
 Both services must have:

package/.docs/docs/observability/tracing/exporters/sentry.md

@@ -162,7 +162,7 @@ The exporter uses standard GenAI semantic conventions with Sentry-specific attri
 **For MODEL\_GENERATION spans:**
 
 - `gen_ai.system`: Model provider (e.g., `openai`, `anthropic`)
-- `gen_ai.request.model`: Model identifier (e.g., `gpt-4`)
+- `gen_ai.request.model`: Model identifier (e.g., `gpt-5.4`)
 - `gen_ai.response.model`: Response model
 - `gen_ai.response.text`: Output text response
 - `gen_ai.response.tool_calls`: Tool calls made during generation (JSON array)

package/.docs/docs/server/auth/okta.md

@@ -0,0 +1,225 @@
+# Okta
+
+The `@mastra/auth-okta` package provides authentication and role-based access control for Mastra using Okta. It supports an OAuth 2.0 / OIDC login flow with encrypted session cookies and maps Okta groups to Mastra permissions.
+
+## Prerequisites
+
+This guide uses Okta authentication. Make sure to:
+
+1. Create an Okta account at [okta.com](https://www.okta.com/)
+2. Set up an OAuth application in the Okta Admin Console (Web app, Authorization Code grant)
+3. Add your redirect URI to the application's sign-in redirect URIs
+4. Create an API token (required for RBAC)
+
+Make sure your environment variables are set.
+
+```env
+OKTA_DOMAIN=dev-123456.okta.com
+OKTA_CLIENT_ID=your-client-id
+OKTA_CLIENT_SECRET=your-client-secret
+OKTA_REDIRECT_URI=http://localhost:4111/api/auth/callback
+OKTA_COOKIE_PASSWORD=a-random-string-at-least-32-characters-long
+OKTA_API_TOKEN=your-api-token
+```
+
+> **Note:** `OKTA_COOKIE_PASSWORD` encrypts session cookies. If omitted, an auto-generated value is used that does not survive server restarts. Set it explicitly for production.
+>
+> `OKTA_API_TOKEN` is only required when using `MastraRBACOkta` to map Okta groups to permissions.
+
+## Installation
+
+**npm**:
+
+```bash
+npm install @mastra/auth-okta
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/auth-okta
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/auth-okta
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/auth-okta
+```
+
+## Usage examples
+
+### Basic usage with environment variables
+
+With the environment variables above set, all constructor parameters are optional:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { MastraAuthOkta } from '@mastra/auth-okta'
+
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthOkta(),
+  },
+})
+```
+
+### Auth with RBAC
+
+Add `MastraRBACOkta` to map Okta groups to Mastra permissions:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { MastraAuthOkta, MastraRBACOkta } from '@mastra/auth-okta'
+
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthOkta(),
+    rbac: new MastraRBACOkta({
+      roleMapping: {
+        Admin: ['*'],
+        Engineering: ['agents:*', 'workflows:*', 'tools:*'],
+        Viewer: ['agents:read', 'workflows:read'],
+        _default: [], // users with unmapped groups get no permissions
+      },
+    }),
+  },
+})
+```
+
+### Cross-provider usage
+
+Use a different auth provider (Auth0, Clerk, etc.) for login and Okta for RBAC. Pass a `getUserId` function to resolve the Okta user ID from the other provider's user object:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { MastraAuthAuth0 } from '@mastra/auth-auth0'
+import { MastraRBACOkta } from '@mastra/auth-okta'
+
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthAuth0(),
+    rbac: new MastraRBACOkta({
+      getUserId: user => user.metadata?.oktaUserId || user.email,
+      roleMapping: {
+        Engineering: ['agents:*', 'workflows:*'],
+        Admin: ['*'],
+        _default: [],
+      },
+    }),
+  },
+})
+```
+
+> **Note:** To link users between providers, store the Okta user ID in the other provider's user metadata. Mastra uses this ID to fetch groups from Okta.
+
+> **Info:** Visit [MastraAuthOkta](https://mastra.ai/reference/auth/okta) for all available configuration options.
+
+## Role mapping
+
+The `roleMapping` option maps Okta group names to arrays of Mastra permission strings. Permissions follow a `resource:action` pattern and support wildcards:
+
+```typescript
+const rbac = new MastraRBACOkta({
+  roleMapping: {
+    // full access to everything
+    Admin: ['*'],
+
+    // full access to agents and workflows
+    Engineering: ['agents:*', 'workflows:*'],
+
+    // read-only access
+    Viewer: ['agents:read', 'workflows:read'],
+
+    // users whose groups don't match any key above
+    _default: [],
+  },
+})
+```
+
+The `_default` key assigns permissions to users whose Okta groups do not match any other key.
+
+## Client-side setup
+
+When auth is enabled, requests to Mastra routes require authentication. `MastraAuthOkta` uses SSO, so users authenticate through Okta's hosted login page. After login, an encrypted session cookie is set automatically.
+
+### Cookie session (recommended)
+
+For cross-origin requests (e.g. a frontend on `:3000` calling Mastra on `:4111`), enable CORS credentials on the Mastra server:
+
+```typescript
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthOkta(),
+    cors: {
+      origin: 'http://localhost:3000',
+      credentials: true,
+    },
+  },
+})
+```
+
+Configure the client to include credentials:
+
+```typescript
+import { MastraClient } from '@mastra/client-js'
+
+export const mastraClient = new MastraClient({
+  baseUrl: 'http://localhost:4111',
+  credentials: 'include',
+})
+```
+
+### Bearer token
+
+You can also pass an Okta access token as a Bearer token. The token is verified against Okta's JWKS endpoint:
+
+```typescript
+import { MastraClient } from '@mastra/client-js'
+
+export const createMastraClient = (accessToken: string) => {
+  return new MastraClient({
+    baseUrl: 'http://localhost:4111',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  })
+}
+```
+
+> **Info:** Visit [Mastra Client SDK](https://mastra.ai/docs/server/mastra-client) for more configuration options.
+
+### Making authenticated requests
+
+**MastraClient**:
+
+```typescript
+import { mastraClient } from '../lib/mastra-client'
+
+const agent = mastraClient.getAgent('weatherAgent')
+const response = await agent.generate('Weather in London')
+console.log(response)
+```
+
+**cURL**:
+
+```bash
+curl -X POST http://localhost:4111/api/agents/weatherAgent/generate \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer <your-okta-access-token>" \
+  -d '{
+    "messages": "Weather in London"
+  }'
+```
+
+## Troubleshooting
+
+- **401 on every request**: Verify your Okta domain, client ID, and client secret are correct. Check that the redirect URI in your Okta application matches `OKTA_REDIRECT_URI`.
+- **Cookies not sent cross-origin**: Set `credentials: "include"` in `MastraClient` and configure `server.cors` with your frontend origin and `credentials: true`.
+- **Session lost on restart**: Set `OKTA_COOKIE_PASSWORD` to a stable value (at least 32 characters). Without it, an auto-generated key is used that changes on each restart.
+- **RBAC returns empty permissions**: Verify `OKTA_API_TOKEN` is set and the token has permission to list user groups. Check that group names in `roleMapping` match your Okta group names exactly.

package/.docs/docs/server/auth.md

@@ -30,6 +30,7 @@ See [Custom API Routes](https://mastra.ai/docs/server/custom-api-routes) for con
 - [Better Auth](https://mastra.ai/docs/server/auth/better-auth)
 - [Clerk](https://mastra.ai/docs/server/auth/clerk)
 - [Firebase](https://mastra.ai/docs/server/auth/firebase)
+- [Okta](https://mastra.ai/docs/server/auth/okta)
 - [Supabase](https://mastra.ai/docs/server/auth/supabase)
 - [WorkOS](https://mastra.ai/docs/server/auth/workos)
 

package/.docs/guides/agent-frameworks/ai-sdk.md

@@ -56,7 +56,7 @@ const loggingProcessor: Processor<'logger'> = {
   },
 }
 
-const model = withMastra(openai('gpt-4o'), {
+const model = withMastra(openai('gpt-5.4'), {
   inputProcessors: [loggingProcessor],
   outputProcessors: [loggingProcessor],
 })
@@ -85,7 +85,7 @@ await storage.init()
 
 const memoryStorage = await storage.getStore('memory')
 
-const model = withMastra(openai('gpt-4o'), {
+const model = withMastra(openai('gpt-5.4'), {
   memory: {
     storage: memoryStorage!,
     threadId: 'user-thread-123',
@@ -115,7 +115,7 @@ await storage.init()
 
 const memoryStorage = await storage.getStore('memory')
 
-const model = withMastra(openai('gpt-4o'), {
+const model = withMastra(openai('gpt-5.4'), {
   inputProcessors: [myGuardProcessor],
   outputProcessors: [myLoggingProcessor],
   memory: {

package/.docs/reference/ai-sdk/with-mastra.md

@@ -18,7 +18,7 @@ const loggingProcessor: Processor<'logger'> = {
   },
 }
 
-const model = withMastra(openai('gpt-4o'), {
+const model = withMastra(openai('gpt-5.4'), {
   inputProcessors: [loggingProcessor],
 })
 
@@ -30,7 +30,7 @@ const { text } = await generateText({
 
 ## Parameters
 
-**model** (`LanguageModelV2 | LanguageModelV3`): Any AI SDK v5 or v6 language model (e.g., \`openai('gpt-4o')\`, \`anthropic('claude-3-opus')\`).
+**model** (`LanguageModelV2 | LanguageModelV3`): Any AI SDK v5 or v6 language model (e.g., \`openai('gpt-5.4')\`, \`anthropic('claude-opus-4-6')\`).
 
 **options** (`WithMastraOptions`): Configuration object for processors and memory.
 

package/.docs/reference/auth/okta.md

@@ -0,0 +1,162 @@
+# MastraAuthOkta & MastraRBACOkta class
+
+## MastraAuthOkta class
+
+The `MastraAuthOkta` class provides authentication for Mastra using Okta. It implements an OAuth 2.0 / OIDC login flow with encrypted session cookies and integrates with the Mastra server using the `auth` option.
+
+### Usage example
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { MastraAuthOkta } from '@mastra/auth-okta'
+
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthOkta({
+      domain: process.env.OKTA_DOMAIN,
+      clientId: process.env.OKTA_CLIENT_ID,
+      clientSecret: process.env.OKTA_CLIENT_SECRET,
+      redirectUri: process.env.OKTA_REDIRECT_URI,
+    }),
+  },
+})
+```
+
+> **Note:** You can omit the constructor parameters if you have the appropriately named environment variables set. In that case, use `new MastraAuthOkta()` without any arguments.
+
+### Constructor parameters
+
+**domain** (`string`): Your Okta domain (e.g., \`dev-123456.okta.com\`). Used to construct the issuer URL and API endpoints. (Default: `process.env.OKTA_DOMAIN`)
+
+**clientId** (`string`): The OAuth client ID from your Okta application. (Default: `process.env.OKTA_CLIENT_ID`)
+
+**clientSecret** (`string`): The OAuth client secret. Required for the SSO authorization code flow. (Default: `process.env.OKTA_CLIENT_SECRET`)
+
+**issuer** (`string`): The token issuer URL. Override this if you use a custom authorization server. (Default: `` `https://{domain}/oauth2/default` ``)
+
+**redirectUri** (`string`): The OAuth redirect URI for the SSO callback. Must match the redirect URI configured in your Okta application. (Default: `process.env.OKTA_REDIRECT_URI`)
+
+**scopes** (`string[]`): OAuth scopes to request during the login flow. (Default: `['openid', 'profile', 'email', 'groups']`)
+
+**apiToken** (`string`): Okta API token for user lookups via the Users API. Required for \`getUser()\` to return user data by ID. (Default: `process.env.OKTA_API_TOKEN`)
+
+**session** (`OktaSessionOptions`): Session cookie configuration.
+
+**session.cookieName** (`string`): Name of the session cookie.
+
+**session.cookieMaxAge** (`number`): Cookie max age in seconds.
+
+**session.cookiePassword** (`string`): Password for encrypting session cookies. Must be at least 32 characters. If not set, an auto-generated value is used that does not survive restarts.
+
+**session.secureCookies** (`boolean`): Set the \`Secure\` flag on session cookies.
+
+**name** (`string`): Custom name for the auth provider instance. (Default: `'okta'`)
+
+### Environment variables
+
+The following environment variables are automatically used when constructor options are not provided:
+
+**OKTA\_DOMAIN** (`string`): Your Okta domain (e.g., \`dev-123456.okta.com\`). Found in your Okta admin console.
+
+**OKTA\_CLIENT\_ID** (`string`): The OAuth client ID from your Okta application.
+
+**OKTA\_CLIENT\_SECRET** (`string`): The OAuth client secret from your Okta application.
+
+**OKTA\_ISSUER** (`string`): Token issuer URL. Defaults to \`https\://{domain}/oauth2/default\` if not set.
+
+**OKTA\_REDIRECT\_URI** (`string`): OAuth redirect URI for the SSO callback.
+
+**OKTA\_COOKIE\_PASSWORD** (`string`): Password for encrypting session cookies. Must be at least 32 characters.
+
+**OKTA\_API\_TOKEN** (`string`): Okta API token for user lookups and RBAC group resolution.
+
+### Authentication flow
+
+`MastraAuthOkta` authenticates requests in the following order:
+
+1. **Session cookie**: Reads the encrypted session cookie and decrypts it. If the session is valid and not expired, the user is authenticated.
+2. **JWT fallback**: If no session cookie is present, verifies the `Authorization` header token against Okta's JWKS endpoint.
+
+After authentication, `authorizeUser` checks that the user has a valid `oktaId`. Provide a custom `authorizeUser` function to implement additional logic.
+
+### `OktaUser` type
+
+The `OktaUser` type extends the base `EEUser` interface with Okta-specific fields:
+
+**id** (`string`): User identifier (maps to the \`sub\` claim).
+
+**oktaId** (`string`): Okta user ID (same as \`id\`).
+
+**email** (`string`): User email address.
+
+**name** (`string`): User display name, constructed from token claims.
+
+**avatarUrl** (`string`): URL to the user's profile picture.
+
+**groups** (`string[]`): Okta groups the user belongs to, populated from the \`groups\` claim.
+
+## MastraRBACOkta class
+
+The `MastraRBACOkta` class maps Okta groups to Mastra permissions. It fetches user groups from the Okta API and resolves them against a configurable role mapping. Use it with `MastraAuthOkta` or any other auth provider.
+
+> **Note:** RBAC requires a valid Enterprise Edition license. It works without a license in development so you can try it locally, but you’ll need a license for production. [Contact sales](https://mastra.ai/contact) for more information.
+
+### Usage example
+
+Use `MastraRBACOkta` alongside an auth provider by passing it to the `rbac` option:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { MastraAuthOkta, MastraRBACOkta } from '@mastra/auth-okta'
+
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthOkta(),
+    rbac: new MastraRBACOkta({
+      roleMapping: {
+        Admin: ['*'],
+        Engineering: ['agents:*', 'workflows:*', 'tools:*'],
+        Viewer: ['agents:read', 'workflows:read'],
+        _default: [],
+      },
+    }),
+  },
+})
+```
+
+To use Okta RBAC with a different auth provider, pass a `getUserId` function to resolve the Okta user ID from the other provider's user object:
+
+```typescript
+import { MastraAuthAuth0 } from '@mastra/auth-auth0'
+import { MastraRBACOkta } from '@mastra/auth-okta'
+
+export const mastra = new Mastra({
+  server: {
+    auth: new MastraAuthAuth0(),
+    rbac: new MastraRBACOkta({
+      getUserId: user => user.metadata?.oktaUserId || user.email,
+      roleMapping: {
+        Engineering: ['agents:*', 'workflows:*'],
+        Admin: ['*'],
+        _default: [],
+      },
+    }),
+  },
+})
+```
+
+### Constructor parameters
+
+**roleMapping** (`RoleMapping`): Maps Okta group names to arrays of Mastra permission strings. Use \`'\_default'\` to assign permissions to users who do not match any group. Supports wildcards like \`'\*'\` (full access) and \`'agents:\*'\` (all agent actions).
+
+**domain** (`string`): Your Okta domain. Used to initialize the Okta management SDK. (Default: `process.env.OKTA_DOMAIN`)
+
+**apiToken** (`string`): Okta API token for the management SDK. Required to fetch user groups from the Okta API. (Default: `process.env.OKTA_API_TOKEN`)
+
+**getUserId** (`(user: unknown) => string | undefined`): Extract the Okta user ID from a user object. Use this when combining Okta RBAC with a different auth provider. If not provided, falls back to \`oktaId\` or \`id\` on the user object.
+
+**cache** (`PermissionCacheOptions`): Configure the LRU cache for group lookups.
+
+**cache.maxSize** (`number`): Maximum number of users to cache.
+
+**cache.ttlMs** (`number`): Time-to-live in milliseconds.

package/.docs/reference/client-js/agents.md

@@ -344,7 +344,7 @@ const agent = await mastraClient.createStoredAgent({
   instructions: 'You are a helpful assistant.',
   model: {
     provider: 'openai',
-    name: 'gpt-4',
+    name: 'gpt-5.4',
   },
 })
 ```
@@ -359,7 +359,7 @@ const agent = await mastraClient.createStoredAgent({
   instructions: 'You are a helpful assistant.',
   model: {
     provider: 'openai',
-    name: 'gpt-4',
+    name: 'gpt-5.4',
   },
   tools: ['calculator', 'weather'],
   workflows: ['data-processing'],

package/.docs/reference/evals/noise-sensitivity.md

@@ -546,9 +546,9 @@ import { createNoiseSensitivityScorerLLM } from '@mastra/evals'
 
 async function compareModelRobustness() {
   const models = [
-    { name: 'GPT-5.1', model: 'openai/gpt-5.4' },
-    { name: 'GPT-4.1', model: 'openai/gpt-4.1' },
-    { name: 'Claude', model: 'anthropic/claude-sonnet-4-6' },
+    { name: 'GPT-5.4', model: 'openai/gpt-5.4' },
+    { name: 'GPT-5.4-mini', model: 'openai/gpt-5.4-mini' },
+    { name: 'Claude', model: 'anthropic/claude-opus-4-6' },
   ]
 
   const testScenario = {

package/.docs/reference/index.md

@@ -35,6 +35,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [Clerk](https://mastra.ai/reference/auth/clerk)
 - [Firebase](https://mastra.ai/reference/auth/firebase)
 - [JSON Web Token](https://mastra.ai/reference/auth/jwt)
+- [Okta](https://mastra.ai/reference/auth/okta)
 - [Supabase](https://mastra.ai/reference/auth/supabase)
 - [WorkOS](https://mastra.ai/reference/auth/workos)
 - [create-mastra](https://mastra.ai/reference/cli/create-mastra)

package/.docs/reference/memory/observational-memory.md

@@ -632,8 +632,8 @@ import { ModelByInputTokens } from '@mastra/memory'
 const selector = new ModelByInputTokens({
   upTo: {
     10_000: 'google/gemini-2.5-flash', // Fast for small inputs
-    40_000: 'openai/gpt-4o', // Stronger for medium inputs
-    1_000_000: 'openai/gpt-4.5', // Most capable for large inputs
+    40_000: 'openai/gpt-5.4-mini', // Stronger for medium inputs
+    1_000_000: 'openai/gpt-5.4', // Most capable for large inputs
   },
 })
 ```

package/.docs/reference/observability/tracing/interfaces.md

@@ -268,7 +268,7 @@ Model Generation attributes.
 
 ```typescript
 interface ModelGenerationAttributes {
-  /** Model name (e.g., 'gpt-4', 'claude-3') */
+  /** Model name (e.g., 'gpt-5.4', 'claude-opus-4-6') */
   model?: string
 
   /** Model provider (e.g., 'openai', 'anthropic') */

package/.docs/reference/processors/message-history-processor.md

@@ -45,7 +45,7 @@ const storage = new PostgresStorage({
 export const agent = new Agent({
   name: 'memory-agent',
   instructions: 'You are a helpful assistant with conversation memory',
-  model: 'openai:gpt-4o',
+  model: 'openai/gpt-5.4',
   inputProcessors: [
     new MessageHistory({
       storage,

package/.docs/reference/processors/processor-interface.md

@@ -202,9 +202,9 @@ The method can return any combination of these properties:
 When multiple processors implement `processInputStep`, they run in order and changes chain through:
 
 ```text
-Processor 1: receives { model: 'gpt-4o' } → returns { model: 'gpt-4o-mini' }
-Processor 2: receives { model: 'gpt-4o-mini' } → returns { toolChoice: 'none' }
-Final: model = 'gpt-4o-mini', toolChoice = 'none'
+Processor 1: receives { model: 'gpt-5.4' } → returns { model: 'gpt-5.4-mini' }
+Processor 2: receives { model: 'gpt-5.4-mini' } → returns { toolChoice: 'none' }
+Final: model = 'gpt-5.4-mini', toolChoice = 'none'
 ```
 
 #### System message isolation

package/.docs/reference/processors/semantic-recall-processor.md

@@ -82,7 +82,7 @@ const semanticRecall = new SemanticRecall({
 export const agent = new Agent({
   name: 'semantic-memory-agent',
   instructions: 'You are a helpful assistant with semantic memory recall',
-  model: 'openai:gpt-4o',
+  model: 'openai/gpt-5.4',
   inputProcessors: [semanticRecall, new MessageHistory({ storage, lastMessages: 50 })],
   outputProcessors: [semanticRecall, new MessageHistory({ storage })],
 })

package/.docs/reference/processors/tool-call-filter.md

@@ -39,7 +39,7 @@ import { ToolCallFilter } from '@mastra/core/processors'
 export const agent = new Agent({
   name: 'filtered-agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai:gpt-4o',
+  model: 'openai/gpt-5.4',
   tools: {
     searchDatabase,
     sendEmail,
@@ -64,7 +64,7 @@ import { ToolCallFilter } from '@mastra/core/processors'
 export const agent = new Agent({
   name: 'no-tools-context-agent',
   instructions: 'You are a helpful assistant',
-  model: 'openai:gpt-4o',
+  model: 'openai/gpt-5.4',
   tools: {
     searchDatabase,
     sendEmail,

package/.docs/reference/processors/working-memory-processor.md

@@ -67,7 +67,7 @@ const storage = new PostgresStorage({
 export const agent = new Agent({
   name: 'personalized-agent',
   instructions: 'You are a helpful assistant that remembers user preferences',
-  model: 'openai:gpt-4o',
+  model: 'openai/gpt-5.4',
   inputProcessors: [
     new WorkingMemory({
       storage,

package/.docs/reference/streaming/agents/stream.md

@@ -327,7 +327,7 @@ await agent.stream('message for agent', {
 
 ## OpenAI WebSocket transport
 
-Opt into OpenAI Responses WebSocket streaming via `providerOptions.openai.transport`. This only applies to streaming calls and is currently supported for direct OpenAI models (for example, `openai/gpt-4o`). If WebSocket streaming is unavailable, Mastra falls back to HTTP streaming. By default, Mastra closes the WebSocket when the stream finishes.
+Opt into OpenAI Responses WebSocket streaming via `providerOptions.openai.transport`. This only applies to streaming calls and is currently supported for direct OpenAI models (for example, `openai/gpt-5.4`). If WebSocket streaming is unavailable, Mastra falls back to HTTP streaming. By default, Mastra closes the WebSocket when the stream finishes.
 
 ```ts
 const stream = await agent.stream('Hello', {

package/.docs/reference/tools/mcp-client.md

@@ -901,7 +901,7 @@ const mcpClient = new MCPClient({
 const agent = new Agent({
   name: 'My Agent',
   instructions: 'You are a helpful assistant.',
-  model: openai('gpt-4o'),
+  model: openai('gpt-5.4'),
   tools: await mcpClient.listTools(),
 })
 

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @mastra/mcp-docs-server
 
+## 1.1.17-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [[`7302e5c`](https://github.com/mastra-ai/mastra/commit/7302e5ce0f52d769d3d63fb0faa8a7d4089cda6d)]:
+  - @mastra/core@1.16.1-alpha.1
+
 ## 1.1.17-alpha.0
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "1.1.17-alpha.1",
+  "version": "1.1.17-alpha.3",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -29,8 +29,8 @@
     "jsdom": "^26.1.0",
     "local-pkg": "^1.1.2",
     "zod": "^4.3.6",
-    "@mastra/core": "1.16.1-alpha.0",
-    "@mastra/mcp": "^1.3.1"
+    "@mastra/mcp": "^1.3.1",
+    "@mastra/core": "1.16.1-alpha.1"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.11",
@@ -46,9 +46,9 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "4.0.18",
-    "@mastra/core": "1.16.1-alpha.0",
     "@internal/lint": "0.0.74",
-    "@internal/types-builder": "0.0.49"
+    "@internal/types-builder": "0.0.49",
+    "@mastra/core": "1.16.1-alpha.1"
   },
   "homepage": "https://mastra.ai",
   "repository": {