> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# MastraServer

La classe abstraite `MastraServer` est la base de tous les adaptateurs de serveur. Étendez cette classe pour créer des adaptateurs pour des frameworks autres que Hono ou Express.

## Importation

```typescript
import { MastraServer } from '@mastra/server/server-adapter'
```

## Paramètres de type

```typescript
MastraServer<TApp, TRequest, TResponse>
```

| Paramètre   | Description                                                          |
| ----------- | -------------------------------------------------------------------- |
| `TApp`      | Type d'application du framework (par exemple, `Hono`, `Application`) |
| `TRequest`  | Type de requête du framework                                         |
| `TResponse` | Type de réponse/contexte du framework                                |

## Constructeur

```typescript
constructor(options: MastraServerOptions<TApp>)
```

### Options

**app** (`TApp`): Instance d'application du framework

**mastra** (`Mastra`): Instance Mastra

**prefix** (`string`): Préfixe du chemin de route (par exemple, /api/v2) (Default: `''`)

**openapiPath** (`string`): Chemin servant la spécification OpenAPI (Default: `''`)

**bodyLimitOptions** (`BodyLimitOptions`): Limites de taille du corps de la requête

**streamOptions** (`StreamOptions`): Configuration de masquage du flux (Default: `{ redact: true }`)

**customRouteAuthConfig** (`Map<string, boolean>`): Remplacements d'authentification par route

**tools** (`Record<string, Tool>`): Outils disponibles pour le serveur

**taskStore** (`InMemoryTaskStore`): Magasin de tâches pour les opérations A2A (Agent-to-Agent)

**mcpOptions** (`MCPOptions`): Options de transport MCP pour les environnements serverless

## Méthodes abstraites

Ces méthodes doivent être implémentées par les adaptateurs :

### `registerContextMiddleware()`

Attache le contexte Mastra à chaque requête.

```typescript
abstract registerContextMiddleware(): void
```

**Contexte à attacher :**

- `mastra` - instance Mastra
- `requestContext` - contexte limité à la requête
- `tools` - outils disponibles
- `abortSignal` - signal d'annulation de la requête

### `registerAuthMiddleware()`

Exécute le hook d'authentification de l'adaptateur pendant l'initialisation. Les adaptateurs officiels peuvent l'implémenter comme une opération vide lorsque l'authentification est appliquée par route.

```typescript
abstract registerAuthMiddleware(): void
```

### `registerRoute()`

Enregistre une seule route auprès du framework.

```typescript
abstract registerRoute(
  app: TApp,
  route: ServerRoute,
  options: { prefix?: string }
): Promise<void>
```

### `getParams()`

Extrait les paramètres de la requête.

```typescript
abstract getParams(
  route: ServerRoute,
  request: TRequest
): Promise<{
  urlParams: Record<string, string>;
  queryParams: Record<string, string>;
  body: unknown;
}>
```

### `sendResponse()`

Envoie une réponse en fonction du type de route.

```typescript
abstract sendResponse(
  route: ServerRoute,
  response: TResponse,
  result: unknown
): Promise<unknown>
```

### `stream()`

Gère les réponses en flux continu.

```typescript
abstract stream(
  route: ServerRoute,
  response: TResponse,
  result: unknown
): Promise<unknown>
```

## Méthodes d'instance

### `init()`

Initialise le serveur en enregistrant tous les middlewares et toutes les routes.

```typescript
async init(): Promise<void>
```

Appelle, dans l'ordre :

1. `registerContextMiddleware()`
2. `registerAuthMiddleware()`
3. `registerRoutes()`

### `registerRoutes()`

Enregistre toutes les routes Mastra.

```typescript
async registerRoutes(): Promise<void>
```

### `getApp()`

Obtient l'instance d'application du framework.

```typescript
getApp<T = TApp>(): T
```

### `parsePathParams()`

Valide les paramètres de chemin avec le schéma Zod de la route.

```typescript
async parsePathParams(
  route: ServerRoute,
  params: Record<string, string>
): Promise<Record<string, unknown>>
```

### `parseQueryParams()`

Valide les paramètres de requête avec le schéma Zod de la route.

```typescript
async parseQueryParams(
  route: ServerRoute,
  params: Record<string, string>
): Promise<Record<string, unknown>>
```

### `parseBody()`

Valide le corps de la requête avec le schéma Zod de la route.

```typescript
async parseBody(
  route: ServerRoute,
  body: unknown
): Promise<unknown>
```

### `registerOpenAPIRoute()`

Enregistre un endpoint qui sert la spécification OpenAPI.

```typescript
async registerOpenAPIRoute(
  app: TApp,
  config: OpenAPIConfig,
  options: { prefix?: string }
): Promise<void>
```

## Méthodes protégées

### `mergeRequestContext()`

Fusionne le contexte de la requête à partir de plusieurs sources (paramètres de requête et corps).

```typescript
protected mergeRequestContext(options: {
  paramsRequestContext?: Record<string, any>;
  bodyRequestContext?: Record<string, any>;
}): RequestContext
```

## Types

### `BodyLimitOptions`

```typescript
interface BodyLimitOptions {
  maxSize: number
  onError: (error: unknown) => unknown
}
```

### `StreamOptions`

```typescript
interface StreamOptions {
  redact?: boolean
}
```

### MCPOptions

```typescript
interface MCPOptions {
  serverless?: boolean
  sessionIdGenerator?: () => string
}
```

| Propriété            | Description                                                                                                                                                                       |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `serverless`         | Lorsque la valeur est `true`, exécute MCP en mode sans état, sans gestion des sessions. À utiliser pour des environnements serverless tels que Cloudflare Workers ou Vercel Edge. |
| `sessionIdGenerator` | Fonction personnalisée qui génère des ID de session.                                                                                                                              |

## Exemple

```typescript
import { MastraServer, ServerRoute } from '@mastra/server/server-adapter'
import type { Mastra } from '@mastra/core'

export class MyServer extends MastraServer<MyApp, MyRequest, MyResponse> {
  registerContextMiddleware(): void {
    this.app.use('*', (req, res, next) => {
      res.locals.mastra = this.mastra
      next()
    })
  }

  registerAuthMiddleware(): void {
    const auth = this.mastra.getServer()?.auth
    if (!auth) return
    // Register global auth middleware, or leave this empty and
    // enforce auth when routes are registered.
  }

  async registerRoute(app, route, { prefix }) {
    // Implement route registration
  }

  async getParams(route, request) {
    return {
      urlParams: request.params,
      queryParams: request.query,
      body: request.body,
    }
  }

  async sendResponse(route, response, result) {
    return response.json(result)
  }

  async stream(route, response, result) {
    // Implement streaming
  }
}
```

## Ressources associées

- [Adaptateurs de serveur](https://mastra.zisheng.pro/fr/docs/server/server-adapters) : utiliser des adaptateurs
- [Adaptateurs personnalisés](https://mastra.zisheng.pro/fr/docs/server/custom-adapters) : créer des adaptateurs personnalisés
- [createRoute()](https://mastra.zisheng.pro/fr/reference/server/create-route) : créer des routes personnalisées