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)** These SDKs use separate, per-event data types (for example, `AssistantMessageDeltaData`), so only the relevant fields exist on each type.
>
> \[!TIP]
> **(.NET)** The .NET SDK uses separate, strongly-typed data classes per event (e.g., `AssistantMessageDeltaData`), so only the relevant fields exist on each type.
>
> \[!TIP]
> **(TypeScript)** The TypeScript SDK uses a discriminated union—when you match on `event.type`, the `data` payload is automatically narrowed to the correct shape.
## Render only the parent agent response
Sub-agent events share the parent session stream and include envelope-level `agentId`. Root/main agent events and session-level events omit `agentId`, so main-chat renderers can ignore assistant events where `agentId` is set and route those events to traces or progress UI instead.
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}");
}
}
}
}
```
## Assistant events
These events track the agent's response lifecycle—from turn start through streaming chunks to the final message.
### `assistant.turn_start`
Emitted when the agent begins processing a turn.
| Data Field | Type | Required | Description |
| --------------- | -------- | -------- | ----------------------------------------------------- |
| `turnId` | `string` | ✅ | Turn identifier (typically a stringified turn number) |
| `interactionId` | `string` | | CAPI interaction ID for telemetry correlation |
### `assistant.intent`
Ephemeral. Short description of what the agent is currently doing, updated as it works.
| Data Field | Type | Required | Description |
| ---------- | -------- | -------- | -------------------------------------------------- |
| `intent` | `string` | ✅ | Human-readable intent (e.g., "Exploring codebase") |
### `assistant.reasoning`
Complete extended thinking block from the model. Emitted after reasoning is finished.
| Data Field | Type | Required | Description |
| ------------- | -------- | -------- | ------------------------------------------ |
| `reasoningId` | `string` | ✅ | Unique identifier for this reasoning block |
| `content` | `string` | ✅ | The complete extended thinking text |
### `assistant.reasoning_delta`
Ephemeral. Incremental chunk of the model's extended thinking, streamed in real time.
| Data Field | Type | Required | Description |
| -------------- | -------- | -------- | ----------------------------------------------------- |
| `reasoningId` | `string` | ✅ | Matches the corresponding `assistant.reasoning` event |
| `deltaContent` | `string` | ✅ | Text chunk to append to reasoning content |
### `assistant.message`
The assistant's complete response for this LLM call. May include tool invocation requests.
| Data Field | Type | Required | Description |
| ------------------ | --------------- | -------- | ------------------------------------------------------------------ |
| `messageId` | `string` | ✅ | Unique identifier for this message |
| `content` | `string` | ✅ | The assistant's text response |
| `toolRequests` | `ToolRequest[]` | | Tool calls the assistant wants to make (see below) |
| `reasoningOpaque` | `string` | | Encrypted extended thinking (Anthropic models); session-bound |
| `reasoningText` | `string` | | Readable reasoning text from extended thinking |
| `encryptedContent` | `string` | | Encrypted reasoning content (OpenAI models); session-bound |
| `phase` | `string` | | Generation phase (e.g., `"thinking"` vs `"response"`) |
| `outputTokens` | `number` | | Actual output token count from the API response |
| `interactionId` | `string` | | CAPI interaction ID for telemetry |
| `parentToolCallId` | `string` | | Deprecated. Use envelope-level `agentId` for sub-agent attribution |
**`ToolRequest` fields:**
| Field | Type | Required | Description |
| ------------ | ------------------------ | -------- | ----------------------------------------------- |
| `toolCallId` | `string` | ✅ | Unique ID for this tool call |
| `name` | `string` | ✅ | Tool name (e.g., `"bash"`, `"edit"`, `"grep"`) |
| `arguments` | `object` | | Parsed arguments for the tool |
| `type` | `"function" \| "custom"` | | Call type; defaults to `"function"` when absent |
### `assistant.message_delta`
Ephemeral. Incremental chunk of the assistant's text response, streamed in real time.
| Data Field | Type | Required | Description |
| ------------------ | -------- | -------- | ------------------------------------------------------------------ |
| `messageId` | `string` | ✅ | Matches the corresponding `assistant.message` event |
| `deltaContent` | `string` | ✅ | Text chunk to append to the message |
| `parentToolCallId` | `string` | | Deprecated. Use envelope-level `agentId` for sub-agent attribution |
### `assistant.turn_end`
Emitted when the agent finishes a turn (all tool executions complete, final response delivered).
| Data Field | Type | Required | Description |
| ---------- | -------- | -------- | ------------------------------------------------------ |
| `turnId` | `string` | ✅ | Matches the corresponding `assistant.turn_start` event |
### `assistant.usage`
Ephemeral. Token usage and cost information for an individual API call.
| Data Field | Type | Required | Description |
| ------------------------ | -------------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model` | `string` | ✅ | Model identifier (e.g., `"gpt-5.4"`) |
| `inputTokens` | `number` | | Input tokens consumed |
| `outputTokens` | `number` | | Output tokens produced |
| `reasoningTokens` | `number` | | Output tokens used for reasoning/chain-of-thought (subset of `outputTokens`) |
| `cacheReadTokens` | `number` | | Tokens read from prompt cache |
| `cacheWriteTokens` | `number` | | Tokens written to prompt cache |
| `cacheExpiresAt` | `string` | | ISO 8601 timestamp when the prompt cache for this model call expires |
| `contentFilterTriggered` | `boolean` | | Whether the response was blocked or truncated by content filtering (`finish_reason === 'content_filter'`) |
| `finishReason` | `string` | | Model finish reason (e.g., `"stop"`, `"length"`, `"tool_calls"`, `"content_filter"`) |
| `cost` | `number` | | Model multiplier cost for billing |
| `duration` | `number` | | API call duration in milliseconds |
| `timeToFirstTokenMs` | `number` | | Time from request dispatch to first token received (streaming latency) |
| `interTokenLatencyMs` | `number` | | Average latency between consecutive tokens (streaming throughput) |
| `reasoningEffort` | `string` | | Reasoning effort level used for this call (e.g., `"low"`, `"medium"`, `"high"`) |
| `initiator` | `string` | | What triggered this call (e.g., `"sub-agent"`); absent for user-initiated |
| `apiCallId` | `string` | | Completion ID from the provider (e.g., `chatcmpl-abc123`) |
| `serviceRequestId` | `string` | | Copilot service request ID (`x-copilot-service-request-id`) for CAPI log correlation |
| `apiEndpoint` | `"/chat/completions" \| "/v1/messages" \| "/responses" \| "ws:/responses"` | | API endpoint used for the model call; useful for observability and cost attribution. `ws:/responses` is the websocket variant of the responses API |
| `providerCallId` | `string` | | GitHub request tracing ID (`x-github-request-id`) |
| `parentToolCallId` | `string` | | Deprecated. Use envelope-level `agentId` for sub-agent attribution |
| `quotaSnapshots` | `Record