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

# TaskSignalProvider

Regroupe les Tools de tâches intégrés (`task_write`, `task_update`, `task_complete`, `task_check`) et le `TaskStateProcessor` derrière un unique enregistrement d’Agent. Utilisez-le pour ajouter une liste de tâches structurée et durable à un Agent sans connecter séparément les Tools et le processeur.

Étend [`SignalProvider`](https://mastra.zisheng.pro/fr/reference/signals/signal-provider). La liste de tâches est stockée dans le domaine de stockage `tasks` limité au thread (la source de vérité), puis projetée par le processeur sur la voie de signal d’état de l’Agent ; elle survit ainsi à la troncature de la mémoire d’observation sans invalider le cache du prompt.

## Exemple d’utilisation

Enregistrez le fournisseur sur un Agent disposant de `Memory` et d’un `storage` Mastra :

```typescript
import { Agent } from '@mastra/core/agent'
import { TaskSignalProvider } from '@mastra/core/signals'

const agent = new Agent({
  id: 'coder',
  name: 'coder',
  instructions: '...',
  model,
  memory,
  signals: [new TaskSignalProvider()],
})
```

L’Agent fusionne automatiquement les quatre Tools de tâches dans son ensemble de Tools et enregistre le processeur dans sa chaîne de Processors d’entrée. Aucun autre câblage n’est nécessaire.

Le suivi des tâches exige un thread adossé à une mémoire (`threadId` + `resourceId`). Sans mémoire, les Tools de tâches ne font rien et renvoient un résultat expliquant que le suivi des tâches exige la mémoire de l’Agent. Le domaine de stockage `tasks` est connecté en mémoire par défaut ; le suivi des tâches fonctionne donc sans configurer de backend de stockage.

## Paramètres du constructeur

`TaskSignalProvider` ne prend aucun argument de constructeur.

## Propriétés

**id** (`'task-signals'`): Identifiant stable de l’instance de fournisseur.

## Méthodes

### Intégration à l’Agent

Ces méthodes sont appelées automatiquement par l’Agent lorsque le fournisseur est transmis à `signals`. Vous ne les appelez généralement pas directement.

#### `getTools()`

Renvoie les quatre Tools de tâches, indexés par leurs id de Tool (`task_write`, `task_update`, `task_complete`, `task_check`). L’Agent les fusionne dans son ensemble de Tools.

```typescript
const tools = new TaskSignalProvider().getTools()
// { task_write, task_update, task_complete, task_check }
```

Renvoie : `Record<string, Tool>`

#### `getInputProcessors()`

Renvoie l’instance `TaskStateProcessor` du fournisseur. L’Agent l’enregistre dans la chaîne de Processors d’entrée, qui propage l’instance Mastra afin que le processeur puisse résoudre le stockage `tasks`.

```typescript
const [processor] = new TaskSignalProvider().getInputProcessors()
// processor instanceof TaskStateProcessor
```

Renvoie : `InputProcessorOrWorkflow[]`