> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# SessionEvent

> Manipulez SessionEvent de Laravel Copilot SDK avec des helpers à la Laravel, des tests de type et la diffusion (broadcast).

## SessionEvent

Tous les messages provenant de Copilot sont des instances de `Revolution\Copilot\Types\SessionEvent`.
Comme cette classe est très utilisée, des commodités à la Laravel lui ont été ajoutées.

## `content()`

Récupère le message de réponse le plus important renvoyé par l'IA.

```php theme={null}
$response = Copilot::run('1 + 1');
echo $response->content(); // '2'
// content() peut être null
```

Une conversion implicite via `__toString()` renvoie également le contenu du message.

```php theme={null}
echo (string) $response; // '2'
// Ce cas n'est pas null
```

## Test du type d'événement

`isAssistantMessage()`, `isUserMessage()`, `isIdle()`, `isAssistantMessageDelta()` sont disponibles.
Pour les types d'événements couramment utilisés, d'autres helpers peuvent être ajoutés.

`is()` permet de tester un `EventType` arbitraire.

```php theme={null}
use Revolution\Copilot\Enums\SessionEventType;

if ($response->is(SessionEventType::HOOK_START)) {
    // Traitement d'événement de démarrage d'un hook
}
```

`type()` renvoie la valeur chaîne de l'enum `SessionEventType`.

```php theme={null}
echo $response->type(); // 'assistant.message'
```

## `failed()` / `successful()`

Si le type d'événement est `SESSION_ERROR`, `failed()` renvoie true.
`successful()` est l'inverse.

Pour s'aligner sur la nomenclature Laravel, `isError()` a été renommé.

## `throw()`

Comme pour les APIs HTTP et Process de Laravel, l'erreur est conservée et peut être relancée via `throw()`.
Si aucune erreur, la méthode ne fait rien ; vous pouvez donc écrire :

```php theme={null}
$content = $response->throw()->content();
```

Si le type d'événement est `SESSION_ERROR`, `Revolution\Copilot\Exceptions\SessionErrorException` est levée.
En cas de timeout, `Revolution\Copilot\Exceptions\SessionTimeoutException` est levée.

Pour les erreurs JSON-RPC, `Revolution\Copilot\Exceptions\JsonRpcException` est levée.

## Conditionable

`when()` et `unless()` sont disponibles.

```php theme={null}
$response->when($response->isAssistantMessage(), function (SessionEvent $event) {
    // Traitement pour un message d'assistant
});
```

## Dumpable

`dump()` et `dd()` sont disponibles.

```php theme={null}
$response->dump();
```

## Tappable

`tap()` est disponible.

```php theme={null}
return $response->tap(function (SessionEvent $event) {
    // Effectuer un traitement
    info($event->content());
});
```

## InteractsWithData

Cette fonctionnalité ne s'applique qu'à la propriété `$data` de SessionEvent.

Vous disposez d'helpers familiers : `all()`, `has()`, `only()`, `collect()`, etc.
Pour plus de détails, voir [InteractsWithData](/fr/advanced/interacts-with-data).

Comme la structure de `$data` diffère selon l'`EventType`, ces accès sont pratiques.

`content()` s'appuie également sur InteractsWithData en interne.

```php theme={null}
return $this->data('content', $default);

// Avec une valeur par défaut, content() n'est pas null
echo $response->content('');
```

## `toArray()` / `toJson()`

Vous pouvez convertir l'ensemble du SessionEvent en tableau ou en JSON.

```php theme={null}
$array = $response->toArray();
$json = $response->toJson();
```

Il n'existe pas de méthode `collect()` sur l'événement entier.
En effet, `$data` possède déjà `collect()` via InteractsWithData.
Pour manipuler l'événement en tant que collection, utilisez le helper `collect()` de Laravel.

```php theme={null}
$collect = collect($response->toArray());
```

## `broadcast()` / `broadcastNow()`

La diffusion utilise la même interface que `StreamEvent` de Laravel AI SDK.
Là où l'AI SDK l'utilise en streaming, ici vous pouvez l'utiliser pour n'importe quel `EventType`.

```php theme={null}
use Illuminate\Broadcasting\Channel;

$event->broadcast(new Channel('channel-name'));
```

`broadcastNow()` diffuse immédiatement sans passer par la file d'attente.

```php theme={null}
$event->broadcastNow(new Channel('channel-name'));
```

Exemple en streaming :

```php theme={null}
use Illuminate\Broadcasting\Channel;
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\SessionEvent;

Copilot::start(function (CopilotSession $session) {
    $session->on(function (SessionEvent $event): void {
        if ($event->isAssistantMessageDelta()) {
            $event->broadcastNow(new Channel('copilot'));
        }
    });

    $session->sendAndWait(prompt: 'Tell me something about Laravel.');
}, config: new SessionConfig(streaming: true));
```

<Info>
  Pour les dernières informations, consultez le [dépôt GitHub](https://github.com/invokable/laravel-copilot-sdk).
</Info>


## Related topics

- [Événements de cycle de vie de session](/fr/packages/laravel-copilot-sdk/session-lifecycle-event.md)
- [Événements de streaming](/fr/packages/laravel-copilot-sdk/streaming-events.md)
- [Agents personnalisés](/fr/packages/laravel-copilot-sdk/custom-agents.md)
- [Démarrer - GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/getting-started.md)
- [Concurrence](/fr/packages/laravel-copilot-sdk/concurrency.md)