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.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
session.On(func(event copilot.SessionEvent) {
if d, ok := event.Data.(*copilot.AssistantMessageDeltaData); ok {
fmt.Print(d.DeltaContent)
}
})
```
.NET
```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)** Esses SDKs usam tipos de dados separados por evento (por exemplo, ), portanto, `AssistantMessageDeltaData`somente os campos relevantes existem em cada tipo.
>
> \[!TIP]
> **(.NET)** O SDK do .NET usa classes de dados separadas e fortemente tipados por evento (por exemplo, `AssistantMessageDeltaData`), portanto, somente os campos relevantes existem em cada tipo.
>
> \[!TIP]
> **(TypeScript)** O SDK do TypeScript usa uma união discriminada — quando você faz a correspondência com `event.type`, o payload `data` é automaticamente refinado para o formato correto.
## Renderize somente a resposta do agente principal
Os eventos do subagente compartilham o fluxo da sessão principal e incluem o nível de envelope `agentId`. Os eventos do agente raiz/principal e os eventos de nível de sessão omitem `agentId`, portanto, os renderizadores do chat principal podem ignorar os eventos do assistente onde `agentId` está definido e encaminhar esses eventos para rastreamentos ou para a interface de progresso.
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}");
}
}
}
}
```
## Eventos do assistente
Esses eventos acompanham o ciclo de vida de resposta do agente, desde o início da vez, passando pelos fragmentos de streaming até a mensagem final.
### `assistant.turn_start`
Emitido quando o agente começa a processar uma rodada.
| Campo de dados | Tipo | Obrigatório | Description |
| -------------------------------------------------- | -------- | ----------- | ------------------------------------------------------------------------------- |
| `turnId` | `string` | ✅ | Identificador de turno (normalmente um número de turno em cadeia de caracteres) |
| `interactionId` | `string` | | |
| ID de interação CAPI para correlação de telemetria | | | |
### `assistant.intent`
Efêmero. Breve descrição do que o agente está fazendo no momento, atualizada conforme funciona.
| Campo de dados | Tipo | Obrigatório | Description |
| -------------- | -------- | ----------- | ------------------------------------------------------------------------- |
| `intent` | `string` | ✅ | Intenção legível por humanos (por exemplo, "Explorando a base de código") |
### `assistant.reasoning`
Conclua o bloco de pensamento estendido do modelo. Emitido após a conclusão do raciocínio.
| Campo de dados | Tipo | Obrigatório | Description |
| -------------- | -------- | ----------- | ----------------------------------------------------- |
| `reasoningId` | `string` | ✅ | Identificador exclusivo para esse bloco de raciocínio |
| `content` | `string` | ✅ | O texto de pensamento estendido completo |
### `assistant.reasoning_delta`
Efêmero. Bloco incremental do pensamento estendido do modelo, transmitido em tempo real.
| Campo de dados | Tipo | Obrigatório | Description |
| -------------- | -------- | ----------- | ----------------------------------------------------------- |
| `reasoningId` | `string` | ✅ | Corresponde ao evento correspondente `assistant.reasoning` |
| `deltaContent` | `string` | ✅ | Parte de texto a ser acrescentada ao conteúdo de raciocínio |
### `assistant.message`
Resposta completa do assistente para esta chamada LLM. Pode incluir solicitações de invocação de ferramentas.
| Campo de dados | Tipo | Obrigatório | Description |
| --------------------------------------------------------------------------- | --------------- | ----------- | ------------------------------------------ |
| `messageId` | `string` | ✅ | Identificador exclusivo para esta mensagem |
| `content` | `string` | ✅ | Resposta de texto do assistente |
| `toolRequests` | `ToolRequest[]` | | |
| Chamadas de ferramenta que o assistente deseja fazer (veja abaixo) | | | |
| `reasoningOpaque` | `string` | | |
| Pensamento estendido criptografado (modelos antrópicos); associado à sessão | | | |
| `reasoningText` | `string` | | |
| Texto claro de raciocínio a partir de pensamento aprofundado | | | |
| `encryptedContent` | `string` | | |
| Conteúdo de raciocínio criptografado (modelos OpenAI); associado à sessão | | | |
| `phase` | `string` | | |
| Fase de geração (por exemplo, `"thinking"` vs `"response"`) | | | |
| `outputTokens` | `number` | | |
| Contagem real de tokens de saída na resposta da API | | | |
| `interactionId` | `string` | | |
| ID de interação CAPI para telemetria | | | |
| `parentToolCallId` | `string` | | |
| Preterido. Usar o nível `agentId` do envelope para atribuição de subagente | | | |
\*\*
`ToolRequest` Campos:\*\*
| Campo | Tipo | Obrigatório | Description |
| ----------------------------------------------------------------- | ------------------------ | ----------- | --------------------------------------------------------------- |
| `toolCallId` | `string` | ✅ | Identificação única para esta chamada de método |
| `name` | `string` | ✅ | Nome da ferramenta (por exemplo, , `"bash"`, `"edit"`) `"grep"` |
| `arguments` | `object` | | |
| Argumentos analisados para a ferramenta | | | |
| `type` | `"function" \| "custom"` | | |
| Tipo de chamada; é definido como `"function"` caso esteja ausente | | | |
### `assistant.message_delta`
Efêmero. Porção incremental da resposta de texto do assistente, transmitida em tempo real.
| Campo de dados | Tipo | Obrigatório | Description |
| -------------------------------------------------------------------------- | -------- | ----------- | -------------------------------------------------------- |
| `messageId` | `string` | ✅ | Corresponde ao evento correspondente `assistant.message` |
| `deltaContent` | `string` | ✅ | Parte de texto a ser acrescentada à mensagem |
| `parentToolCallId` | `string` | | |
| Preterido. Usar o nível `agentId` do envelope para atribuição de subagente | | | |
### `assistant.turn_end`
Emitido quando o agente conclui um turno (todas as execuções de ferramentas são concluídas, resposta final fornecida).
| Campo de dados | Tipo | Obrigatório | Description |
| -------------- | -------- | ----------- | ----------------------------------------------------------- |
| `turnId` | `string` | ✅ | Corresponde ao evento correspondente `assistant.turn_start` |
### `assistant.usage`
Efêmero. Informações de uso e custo de token para uma chamada de API individual.
| Campo de dados | Tipo | Obrigatório | Description |
| --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ----------- | -------------------------------------------------- |
| `model` | `string` | ✅ | Identificador de modelo (por exemplo, `"gpt-5.4"`) |
| `inputTokens` | `number` | | |
| Tokens de entrada consumidos | | | |
| `outputTokens` | `number` | | |
| Tokens de saída produzidos | | | |
| `reasoningTokens` | `number` | | |
| Tokens de saída usados para raciocínio/cadeia de pensamento (subconjunto de `outputTokens`) | | | |
| `cacheReadTokens` | `number` | | |
| Tokens lidos do cache de prompt | | | |
| `cacheWriteTokens` | `number` | | |
| Tokens gravados no cache de prompt | | | |
| `cacheExpiresAt` | `string` | | |
| Carimbo de data e hora ISO 8601 em que o cache de prompts para esta chamada de modelo expira | | | |
| `contentFilterTriggered` | `boolean` | | |
| Se a resposta foi bloqueada ou truncada pela filtragem de conteúdo (`finish_reason === 'content_filter'`) | | | |
| `finishReason` | `string` | | |
| Motivo de término do modelo (por exemplo, , `"stop"`, `"length"`, `"tool_calls"`, `"content_filter"`) | | | |
| `cost` | `number` | | |
| Custo do multiplicador de modelo para cobrança | | | |
| `duration` | `number` | | |
| Duração da chamada à API em milissegundos | | | |
| `timeToFirstTokenMs` | `number` | | |
| Hora da expedição de solicitação para o primeiro token recebido (latência de streaming) | | | |
| `interTokenLatencyMs` | `number` | | |
| Latência média entre tokens consecutivos (taxa de transferência de streaming) | | | |
| `reasoningEffort` | `string` | | |
| Nível de esforço de raciocínio usado para essa chamada (por exemplo, , `"low"`, `"medium"`) `"high"` | | | |
| `initiator` | `string` | | |
| O que acionou esta chamada (por exemplo, `"sub-agent"`); ausente para chamadas iniciadas pelo usuário | | | |
| `apiCallId` | `string` | | |
| ID de conclusão do provedor (por exemplo, `chatcmpl-abc123`) | | | |
| `serviceRequestId` | `string` | | |
| ID da solicitação de serviço do Copilot (`x-copilot-service-request-id`) para correlação de logs do CAPI | | | |
| `apiEndpoint` | `"/chat/completions" \| "/v1/messages" \| "/responses" \| "ws:/responses"` | | |
| Endpoint da API usado para a chamada ao modelo; útil para observabilidade e atribuição de custos. | | | |
| `ws:/responses` é a variante websocket da API de respostas | | | |
| `providerCallId` | `string` | | |
| ID de rastreamento da solicitação do GitHub (`x-github-request-id`) | | | |
| `parentToolCallId` | `string` | | |
| Preterido. Usar o nível `agentId` do envelope para atribuição de subagente | | | |
| `quotaSnapshots` | `Record