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

# toAISdkStream()

Convertit les flux Mastra (Agent, Network ou Workflow) en flux compatibles avec AI SDK. Utilisez cette fonction lorsque vous devez transformer manuellement des flux Mastra afin de les utiliser avec les fonctions `createUIMessageStream()` et `createUIMessageStreamResponse()` d'AI SDK.

Cette fonction est utile pour créer des endpoints de streaming personnalisés sans employer les fonctions utilitaires de route fournies par Mastra, telles que [`chatRoute()`](https://mastra.zisheng.pro/fr/reference/ai-sdk/chat-route) ou [`workflowRoute()`](https://mastra.zisheng.pro/fr/reference/ai-sdk/workflow-route).

`toAISdkStream()` conserve le comportement existant et par défaut d'AI SDK v5. Si votre application est typée pour AI SDK v6, transmettez `version: 'v6'` dans l'objet d'options.

## Sortie structurée dans les flux UI

Lorsque le flux de l'Agent source comprend un objet de sortie structurée final, `toAISdkStream()` l'émet sous la forme d'une partie de données UI AI SDK personnalisée :

```json
{
  "type": "data-structured-output",
  "data": {
    "object": {}
  }
}
```

Le champ `object` contient la valeur complète de votre sortie structurée. Cela associe le chunk final de sortie structurée de Mastra au flux UI AI SDK. Les chunks de sortie structurée partiels ne sont pas émis.

## Exemple d'utilisation

Exemple avec App Router de Next.js :

```typescript
import { mastra } from '../../mastra'
import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'

export async function POST(req: Request) {
  const { messages } = await req.json()
  const myAgent = mastra.getAgent('weatherAgent')
  const stream = await myAgent.stream(messages)

  const uiMessageStream = createUIMessageStream({
    originalMessages: messages,
    execute: async ({ writer }) => {
      for await (const part of toAISdkStream(stream, { from: 'agent' })) {
        await writer.write(part)
      }
    },
  })

  return createUIMessageStreamResponse({
    stream: uiMessageStream,
  })
}
```

> **Astuce:** Transmettez `messages` à `originalMessages` dans `createUIMessageStream()` afin d'éviter la duplication des messages de l'Assistant dans l'interface utilisateur. Consultez [Résolution des problèmes : messages répétés de l'Assistant](https://ai-sdk.dev/docs/troubleshooting/repeated-assistant-messages) pour plus de détails.

## Paramètres

Le premier paramètre est le flux Mastra à convertir. Il peut s'agir de l'un des éléments suivants :

- `MastraModelOutput` - Flux d'Agent provenant de `agent.stream()`
- `MastraAgentNetworkStream` - Flux Network provenant de `agent.network()`
- `MastraWorkflowStream` ou `WorkflowRunOutput` - Flux de Workflow

Le deuxième paramètre est un objet d'options :

**version** (`'v5' | 'v6'`): Sélectionne le contrat de flux AI SDK à émettre. Omettez cette option ou transmettez 'v5' pour conserver le comportement existant par défaut. Transmettez 'v6' lorsque votre application est typée pour les fonctions utilitaires de réponse d'AI SDK v6. (Default: `'v5'`)

**from** (`'agent' | 'network' | 'workflow'`): Type du flux Mastra en cours de conversion. (Default: `'agent'`)

**lastMessageId** (`string`): (Agent uniquement) Identifiant du dernier message de la conversation.

**sendStart** (`boolean`): (Agent uniquement) Indique si les événements de démarrage doivent être envoyés dans le flux. (Default: `true`)

**sendFinish** (`boolean`): (Agent uniquement) Indique si les événements de fin doivent être envoyés dans le flux. (Default: `true`)

**sendReasoning** (`boolean`): (Agent uniquement) Indique si les chunks reasoning-delta doivent être inclus dans le flux. Définissez cette option sur true pour diffuser le contenu de raisonnement des modèles prenant en charge le raisonnement étendu. (Default: `false`)

**sendSources** (`boolean`): (Agent uniquement) Indique si les citations des sources doivent être incluses dans la sortie. (Default: `false`)

**includeTextStreamParts** (`boolean`): (Workflow uniquement) Indique si les parties du flux de texte doivent être incluses dans la sortie. (Default: `true`)

**messageMetadata** (`(options: { part: UIMessageStreamPart }) => Record<string, unknown> | undefined`): (Agent uniquement) Fonction qui reçoit la partie actuelle du flux et renvoie les métadonnées à associer aux chunks de démarrage et de fin.

**onError** (`(error: unknown) => string`): (Agent uniquement) Fonction qui gère les erreurs pendant la conversion du flux. Elle reçoit l'erreur et doit en renvoyer une représentation sous forme de chaîne.

## Exemples

### Conversion d'un flux de Workflow

```typescript
import { mastra } from '../../mastra'
import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'

export async function POST(req: Request) {
  const { input } = await req.json()
  const workflow = mastra.getWorkflow('myWorkflow')
  const run = workflow.createRun()
  const stream = await run.stream({ inputData: input })

  const uiMessageStream = createUIMessageStream({
    execute: async ({ writer }) => {
      for await (const part of toAISdkStream(stream, { from: 'workflow' })) {
        await writer.write(part)
      }
    },
  })

  return createUIMessageStreamResponse({
    stream: uiMessageStream,
  })
}
```

### Conversion d'un flux Network

```typescript
import { mastra } from '../../mastra'
import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'

export async function POST(req: Request) {
  const { messages } = await req.json()
  const routingAgent = mastra.getAgent('routingAgent')
  const stream = await routingAgent.network(messages)

  const uiMessageStream = createUIMessageStream({
    execute: async ({ writer }) => {
      for await (const part of toAISdkStream(stream, { from: 'network' })) {
        await writer.write(part)
      }
    },
  })

  return createUIMessageStreamResponse({
    stream: uiMessageStream,
  })
}
```

### Conversion d'un flux d'Agent avec le raisonnement activé

```typescript
import { mastra } from '../../mastra'
import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'

export async function POST(req: Request) {
  const { messages } = await req.json()
  const reasoningAgent = mastra.getAgent('reasoningAgent')
  const stream = await reasoningAgent.stream(messages, {
    providerOptions: {
      openai: { reasoningEffort: 'high' },
    },
  })

  const uiMessageStream = createUIMessageStream({
    originalMessages: messages,
    execute: async ({ writer }) => {
      for await (const part of toAISdkStream(stream, {
        from: 'agent',
        sendReasoning: true,
      })) {
        await writer.write(part)
      }
    },
  })

  return createUIMessageStreamResponse({
    stream: uiMessageStream,
  })
}
```

### Conversion d'un flux d'Agent pour AI SDK v6

```typescript
import { mastra } from '../../mastra'
import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'

export async function POST(req: Request) {
  const { messages } = await req.json()
  const myAgent = mastra.getAgent('weatherAgent')
  const stream = await myAgent.stream(messages)

  const uiMessageStream = createUIMessageStream({
    originalMessages: messages,
    execute: async ({ writer }) => {
      for await (const part of toAISdkStream(stream, {
        from: 'agent',
        version: 'v6',
      })) {
        await writer.write(part)
      }
    },
  })

  return createUIMessageStreamResponse({
    stream: uiMessageStream,
  })
}
```

### Utilisation de `messageMetadata`

```typescript
import { mastra } from '../../mastra'
import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'

export async function POST(req: Request) {
  const { messages } = await req.json()
  const myAgent = mastra.getAgent('weatherAgent')
  const stream = await myAgent.stream(messages)

  const uiMessageStream = createUIMessageStream({
    originalMessages: messages,
    execute: async ({ writer }) => {
      for await (const part of toAISdkStream(stream, {
        from: 'agent',
        messageMetadata: ({ part }) => ({
          timestamp: Date.now(),
          partType: part.type,
        }),
      })) {
        await writer.write(part)
      }
    },
  })

  return createUIMessageStreamResponse({
    stream: uiMessageStream,
  })
}
```

### Transformation du flux côté client

Si vous utilisez le SDK client Mastra (`@mastra/client-js`) côté client et souhaitez convertir les flux au format AI SDK :

```typescript
import { MastraClient } from '@mastra/client-js'
import { createUIMessageStream } from 'ai'
import { toAISdkStream } from '@mastra/ai-sdk'
import type { ChunkType, MastraModelOutput } from '@mastra/core/stream'

const client = new MastraClient({
  baseUrl: 'http://localhost:4111',
})

const agent = client.getAgent('weatherAgent')
const response = await agent.stream('What is the weather in Tokyo?')

// Convert the client SDK stream to a ReadableStream<ChunkType>
const chunkStream = new ReadableStream<ChunkType>({
  async start(controller) {
    await response.processDataStream({
      onChunk: async chunk => {
        controller.enqueue(chunk)
      },
    })
    controller.close()
  },
})

// Transform to AI SDK format
const uiMessageStream = createUIMessageStream({
  execute: async ({ writer }) => {
    for await (const part of toAISdkStream(chunkStream as unknown as MastraModelOutput, {
      from: 'agent',
    })) {
      await writer.write(part)
    }
  },
})

for await (const part of uiMessageStream) {
  console.log(part)
}
```