TypeScript
```typescript
// All events
session.on((event) => {
console.log(event.type, event.data);
});
// Specific event type — data is narrowed automatically
session.on("assistant.message_delta", (event) => {
process.stdout.write(event.data.deltaContent);
});
```
Python
```python
from copilot import CopilotClient
from copilot.session_events import SessionEventType
client = CopilotClient()
session = None # assume session is created elsewhere
def handle(event):
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
print(event.data.delta_content, end="", flush=True)
# session.on(handle)
```
```python
from copilot.session_events import SessionEventType
def handle(event):
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
print(event.data.delta_content, end="", flush=True)
session.on(handle)
```
Go
```golang
package main
import (
"context"
"fmt"
copilot "github.com/github/copilot-sdk/go"
"github.com/github/copilot-sdk/go/rpc"
)
func main() {
ctx := context.Background()
client := copilot.NewClient(nil)
session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5.4",
Streaming: copilot.Bool(true),
OnPermissionRequest: func(req copilot.PermissionRequest, inv copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
return &rpc.PermissionDecisionApproveOnce{}, nil
},
})
session.On(func(event copilot.SessionEvent) {
if d, ok := event.Data.(*copilot.AssistantMessageDeltaData); ok {
fmt.Print(d.DeltaContent)
}
})
_ = session
}
```
```golang
session.On(func(event copilot.SessionEvent) {
if d, ok := event.Data.(*copilot.AssistantMessageDeltaData); ok {
fmt.Print(d.DeltaContent)
}
})
```
.NET
```csharp
using GitHub.Copilot;
public static class StreamingEventsExample
{
public static async Task Example(CopilotSession session)
{
session.On
(evt =>
{
if (evt is AssistantMessageDeltaEvent delta)
{
Console.Write(delta.Data.DeltaContent);
}
});
}
}
```
```csharp
session.On(evt =>
{
if (evt is AssistantMessageDeltaEvent delta)
{
Console.Write(delta.Data.DeltaContent);
}
});
```
Java
```java
// All events
session.on(event -> System.out.println(event.getType()));
// Specific event type — data is narrowed to the matching class
session.on(AssistantMessageDeltaEvent.class, event ->
System.out.print(event.getData().deltaContent())
);
```
> \[!TIP]
> **(Python/Go)** Ces kits SDK utilisent des types de données distincts par événement (par exemple), `AssistantMessageDeltaData`de sorte que seuls les champs pertinents existent sur chaque type.
>
> \[!TIP]
> **(.NET)** Le sdk .NET utilise des classes de données distinctes et fortement typées par événement (par exemple, `AssistantMessageDeltaData`), de sorte que seuls les champs pertinents existent sur chaque type.
>
> \[!TIP]
> **(TypeScript)** Le Kit de développement logiciel (SDK) TypeScript utilise une union discriminée : lorsque vous faites correspondre `event.type`, la charge utile `data` est automatiquement réduite à la forme correcte.
## Afficher uniquement la réponse de l’agent parent
Les événements des sous-agents partagent le flux de la session parente et incluent la balise `agentId` au niveau de l’enveloppe. Les événements de l’agent racine/principal et les événements au niveau de la session omettent `agentId`, de sorte que les renderers main-chat peuvent ignorer les événements d’assistant où `agentId` est défini et acheminer ces événements vers des traces ou une interface utilisateur de progression à la place.
TypeScript
```typescript
import type { CopilotSession } from "@github/copilot-sdk";
export function subscribeParentResponse(session: CopilotSession): void {
session.on("assistant.message_delta", (event) => {
if (!event.agentId) {
process.stdout.write(event.data.deltaContent);
}
});
}
```
Python
```python
from copilot import CopilotSession, SessionEvent, SessionEventType
from copilot.session_events import AssistantMessageDeltaData
def subscribe_parent_response(session: CopilotSession) -> None:
def handle(event: SessionEvent) -> None:
if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA and event.agent_id is None:
data = event.data
if isinstance(data, AssistantMessageDeltaData):
print(data.delta_content, end="", flush=True)
session.on(handle)
```
Go
```golang
package example
import (
"fmt"
copilot "github.com/github/copilot-sdk/go"
)
func subscribeParentResponse(session *copilot.Session) {
session.On(func(event copilot.SessionEvent) {
if event.AgentID != nil {
return
}
if d, ok := event.Data.(*copilot.AssistantMessageDeltaData); ok {
fmt.Print(d.DeltaContent)
}
})
}
```
.NET
```csharp
using System;
using GitHub.Copilot;
static class ParentAgentResponseExample
{
public static void SubscribeParentResponse(CopilotSession session)
{
session.On
(evt =>
{
if (evt.AgentId is null)
{
Console.Write(evt.Data.DeltaContent);
}
});
}
}
```
Java
```java
import com.github.copilot.CopilotSession;
import com.github.copilot.generated.AssistantMessageDeltaEvent;
final class ParentAgentResponseExample {
static void subscribeParentResponse(CopilotSession session) {
session.on(AssistantMessageDeltaEvent.class, event -> {
if (event.getAgentId() == null) {
System.out.print(event.getData().deltaContent());
}
});
}
}
```
Rust
```rust
use github_copilot_sdk::session::Session;
async fn subscribe_parent_response(session: &Session) {
let mut events = session.subscribe();
while let Ok(event) = events.recv().await {
if event.event_type == "assistant.message_delta" && event.agent_id.is_none() {
if let Some(delta) = event.data.get("deltaContent").and_then(|v| v.as_str()) {
print!("{delta}");
}
}
}
}
```
## Événements de l'Assistant
Ces événements effectuent le suivi du cycle de vie de réponse de l’agent, du début en passant par les flux en continu jusqu’au message final.
### `assistant.turn_start`
Émis lorsque l'agent commence à traiter une itération.
| Champ de données | Catégorie | Obligatoire | Description |
| ------------------------------------------------------- | --------- | ----------- | ------------------------------------------------------------------------------------- |
| `turnId` | `string` | ✅ | Identifiant de tour (généralement un numéro de tour converti en chaîne de caractères) |
| `interactionId` | `string` | | |
| ID d’interaction CAPI pour la corrélation de télémétrie | | | |
### `assistant.intent`
Éphémère. Brève description de ce que fait actuellement l’agent, et mise à jour à mesure qu’il travaille.
| Champ de données | Catégorie | Obligatoire | Description |
| ---------------- | --------- | ----------- | ------------------------------------------------------------------------ |
| `intent` | `string` | ✅ | Intention lisible par l’homme (par exemple, « Exploration de codebase ») |
### `assistant.reasoning`
Bloc de pensée étendu complet du modèle. Émis après la fin du raisonnement.
| Champ de données | Catégorie | Obligatoire | Description |
| ---------------- | --------- | ----------- | -------------------------------------------------- |
| `reasoningId` | `string` | ✅ | Identificateur unique pour ce bloc de raisonnement |
| `content` | `string` | ✅ | Texte complet de réflexion approfondie |
### `assistant.reasoning_delta`
Éphémère. Partie incrémentielle de la pensée étendue du modèle, diffusée en temps réel.
| Champ de données | Catégorie | Obligatoire | Description |
| ---------------- | --------- | ----------- | ------------------------------------------------------------ |
| `reasoningId` | `string` | ✅ | Correspond à l’événement correspondant `assistant.reasoning` |
| `deltaContent` | `string` | ✅ | Bloc de texte à ajouter au contenu de raisonnement |
### `assistant.message`
Réponse complète de l’Assistant pour cet appel LLM. Peut inclure des demandes d’appel d’outil.
| Champ de données | Catégorie | Obligatoire | Description |
| ---------------------------------------------------------------------------------------- | --------------- | ----------- | ------------------------------------- |
| `messageId` | `string` | ✅ | Identificateur unique pour ce message |
| `content` | `string` | ✅ | Réponse textuelle de l’Assistant |
| `toolRequests` | `ToolRequest[]` | | |
| Les appels que l'assistant souhaite faire avec l'outil (voir ci-dessous) | | | |
| `reasoningOpaque` | `string` | | |
| Pensée étendue chiffrée (modèles anthropiques) ; liée à la session | | | |
| `reasoningText` | `string` | | |
| Texte de raisonnement lisible résultant d'une réflexion approfondie | | | |
| `encryptedContent` | `string` | | |
| Contenu de raisonnement chiffré (modèles OpenAI) ; liées à la session | | | |
| `phase` | `string` | | |
| Phase de génération (par exemple, `"thinking"` vs `"response"`) | | | |
| `outputTokens` | `number` | | |
| Nombre exact de jetons de sortie dans la réponse de l’API | | | |
| `interactionId` | `string` | | |
| ID d’interaction CAPI pour la télémétrie | | | |
| `parentToolCallId` | `string` | | |
| Deprecated. Utiliser `agentId` au niveau de l’enveloppe pour l’attribution du sous-agent | | | |
\*\*
`ToolRequest` Champs:\*\*
| Champ | Catégorie | Obligatoire | Description |
| --------------------------------------------------------------------------- | ------------------------ | ----------- | ---------------------------------------------------------- |
| `toolCallId` | `string` | ✅ | ID unique pour cet appel d’outil |
| `name` | `string` | ✅ | Nom de l’outil (par exemple, `"bash"`, `"edit"`, `"grep"`) |
| `arguments` | `object` | | |
| Arguments analysés pour l’outil | | | |
| `type` | `"function" \| "custom"` | | |
| Type d’appel ; prend la valeur par défaut `"function"` lorsqu’il est absent | | | |
### `assistant.message_delta`
Éphémère. Segment incrémentiel de la réponse de texte de l’assistant, diffusé en temps réel.
| Champ de données | Catégorie | Obligatoire | Description |
| ---------------------------------------------------------------------------------------- | --------- | ----------- | ---------------------------------------------------------- |
| `messageId` | `string` | ✅ | Correspond à l’événement correspondant `assistant.message` |
| `deltaContent` | `string` | ✅ | Bloc de texte à ajouter au message |
| `parentToolCallId` | `string` | | |
| Deprecated. Utiliser `agentId` au niveau de l’enveloppe pour l’attribution du sous-agent | | | |
### `assistant.turn_end`
Émis lorsque l’agent termine un tour (toutes les exécutions d’outils sont terminées, réponse finale remise).
| Champ de données | Catégorie | Obligatoire | Description |
| ---------------- | --------- | ----------- | ------------------------------------------------------------- |
| `turnId` | `string` | ✅ | Correspond à l’événement correspondant `assistant.turn_start` |
### `assistant.usage`
Éphémère. Informations d’utilisation et de coût des jetons pour un appel d’API individuel.
| Champ de données | Catégorie | Obligatoire | Description |
| ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------- | ----------- | --------------------------------------------------- |
| `model` | `string` | ✅ | Identificateur de modèle (par exemple, `"gpt-5.4"`) |
| `inputTokens` | `number` | | |
| Jetons d’entrée consommés | | | |
| `outputTokens` | `number` | | |
| Jetons de sortie produits | | | |
| `reasoningTokens` | `number` | | |
| Jetons de sortie utilisés pour le raisonnement/la chaîne de pensée (sous-ensemble de `outputTokens`) | | | |
| `cacheReadTokens` | `number` | | |
| Jetons lus à partir du cache d’invite | | | |
| `cacheWriteTokens` | `number` | | |
| Jetons écrits dans le cache d’invite | | | |
| `cacheExpiresAt` | `string` | | |
| Horodatage ISO 8601 lorsque le cache d’invite de cet appel de modèle expire | | | |
| `contentFilterTriggered` | `boolean` | | |
| Indique si la réponse a été bloquée ou tronquée par le filtrage de contenu (`finish_reason === 'content_filter'`) | | | |
| `finishReason` | `string` | | |
| Motif de fin du modèle (par exemple, `"stop"`, `"tool_calls"`, `"length"`, `"content_filter"`) | | | |
| `cost` | `number` | | |
| Coût du multiplicateur de modèle pour la facturation | | | |
| `duration` | `number` | | |
| Durée des appels d’API en millisecondes | | | |
| `timeToFirstTokenMs` | `number` | | |
| Temps écoulé entre l’envoi de la requête et la réception du premier token (latence de streaming) | | | |
| `interTokenLatencyMs` | `number` | | |
| Latence moyenne entre les jetons consécutifs (débit de streaming) | | | |
| `reasoningEffort` | `string` | | |
| Niveau d’effort de raisonnement utilisé pour cet appel (par exemple, `"low"`, `"medium"`, `"high"`) | | | |
| `initiator` | `string` | | |
| Ce qui a déclenché cet appel (par exemple, `"sub-agent"`) ; absent si l’appel est initié par l’utilisateur | | | |
| `apiCallId` | `string` | | |
| ID d’achèvement du fournisseur (par exemple, `chatcmpl-abc123`) | | | |
| `serviceRequestId` | `string` | | |
| ID de requête de service Copilot (`x-copilot-service-request-id`) pour la corrélation des journaux CAPI | | | |
| `apiEndpoint` | `"/chat/completions" \| "/v1/messages" \| "/responses" \| "ws:/responses"` | | |
| Point de terminaison d’API utilisé pour l’appel de modèle ; utile pour l’observabilité et l’attribution des coûts. | | | |
| `ws:/responses` est la variante websocket de l’API réponses | | | |
| `providerCallId` | `string` | | |
| ID de suivi de requête GitHub (`x-github-request-id`) | | | |
| `parentToolCallId` | `string` | | |
| Deprecated. Utiliser `agentId` au niveau de l’enveloppe pour l’attribution du sous-agent | | | |
| `quotaSnapshots` | `Record