# How to Implement Streaming Responses with the GitHub Copilot SDK

> Learn to implement streaming responses with the GitHub Copilot SDK using Server-Sent Events. Enable real-time content delivery by setting stream to true for incremental assistant events.

- Repository: [GitHub/copilot-sdk](https://github.com/github/copilot-sdk)
- Tags: how-to-guide
- Published: 2026-07-18

---

**The GitHub Copilot SDK enables real-time streaming of model-generated content via Server-Sent Events (SSE) by setting the `streaming` option to `true`, which emits incremental `assistant.streaming_delta` events as tokens arrive from the model.**

Real-time streaming reduces perceived latency in AI applications by delivering tokens as they are generated rather than waiting for complete responses. To implement streaming responses with the GitHub Copilot SDK, you configure the client with a boolean flag and listen for specific event types emitted by the session layer. The SDK handles the underlying Server-Sent Events (SSE) transport, parsing, and type-safe event distribution according to the source code in `github/copilot-sdk`.

## Architecture of Streaming in the Copilot SDK

The streaming implementation spans multiple layers of the SDK, from client initialization to low-level transport handling.

### Client Configuration Layer

In [`nodejs/src/client.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/client.ts) (approximately lines 1560 and 1780), the `CopilotClient` constructor accepts a `streaming` option that propagates to all subsequent requests. When enabled, this flag signals the SDK to request SSE transport from the model endpoint.

### Request Payload Structure

The request adapter in [`test/harness/responsesApiAdapter.ts`](https://github.com/github/copilot-sdk/blob/main/test/harness/responsesApiAdapter.ts) (line 57) demonstrates how the SDK injects the `stream: true` field into the JSON payload sent to the model layer. This parameter instructs the upstream API to return a streaming response rather than a complete JSON object.

### CAPI Proxy and SSE Transport

The [`test/harness/replayingCapiProxy.ts`](https://github.com/github/copilot-sdk/blob/main/test/harness/replayingCapiProxy.ts) file (lines 517-587) contains the proxy logic that detects the `stream: true` flag and sets the response header `Content-Type: text/event-stream`. This component either streams cached responses slowly or forwards live responses instantly, maintaining the SSE format required by the client.

### Session Event Management

At [`nodejs/src/session.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/session.ts) (approximately line 230), the `Session` object listens for raw SSE chunks from the transport layer. It parses these chunks and emits high-level SDK events including `assistant.streaming_delta` and `assistant.reasoning_delta`, allowing applications to process incremental content without handling raw HTTP streams.

### Type Definitions for Streaming Events

The generated types in [`nodejs/src/generated/session-events.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/session-events.ts) (lines 3340-3385) define concrete interfaces for streaming events. These TypeScript definitions provide autocompletion and type safety for properties like `delta` (the text fragment) and `cumulative_bytes` (total bytes received).

## Implementing Streaming Responses

The following patterns demonstrate how to enable and consume streaming responses in production code.

### Global Streaming Configuration

Enable streaming for all requests by setting the `streaming` option when instantiating `CopilotClient`:

```typescript
import { CopilotClient } from '@github/copilot-sdk';

const client = new CopilotClient({
  // ... other configuration
  streaming: true,  // Enables SSE for all sessions
});

```

### Consuming Token Deltas

After creating a chat session, register listeners for the `assistant.streaming_delta` event to receive tokens as they arrive:

```typescript
const session = await client.createChatSession();

session.on('assistant.streaming_delta', (event) => {
  // event.delta contains the newest text fragment
  // event.cumulative_bytes tracks total bytes received
  process.stdout.write(event.delta);
});

```

### Per-Request Streaming Control

Override the client default for individual requests by passing the `streaming` flag directly to the send method:

```typescript
await session.send({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Explain async/await.' }],
  streaming: true,  // Overrides client default for this call only
});

```

### Detecting Stream Completion

Listen for the `assistant.message_stop` event to handle the final aggregated message after streaming concludes:

```typescript
session.on('assistant.message_stop', (msg) => {
  console.log('\nFull response:', msg.content);
});

```

## End-to-End Streaming Test Implementation

The SDK's test suite in [`nodejs/test/e2e/streaming_fidelity.e2e.test.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/test/e2e/streaming_fidelity.e2e.test.ts) validates the streaming pipeline. This pattern demonstrates how to verify that delta events fire correctly:

```typescript
it('should produce delta events when streaming is enabled', async () => {
  const client = await createTestClient({ streaming: true });
  const session = await client.createChatSession();
  
  const deltas: string[] = [];
  session.on('assistant.streaming_delta', (e) => deltas.push(e.delta));
  
  await session.send({ 
    model: 'gpt-4', 
    messages: [{ role: 'user', content: 'Hi' }] 
  });
  
  expect(deltas.length).toBeGreaterThan(0);
});

```

## Summary

- Enable streaming globally via the `streaming: true` option in `CopilotClient` configuration
- The SDK uses **Server-Sent Events (SSE)** with `Content-Type: text/event-stream` as implemented in the CAPI proxy layer
- Listen for `assistant.streaming_delta` events on the session object to process incremental tokens
- Per-request streaming overrides are supported via the `streaming` parameter in `session.send()`
- Type definitions in [`nodejs/src/generated/session-events.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/session-events.ts) ensure TypeScript safety for streaming payloads

## Frequently Asked Questions

### What transport protocol does the GitHub Copilot SDK use for streaming?

The SDK uses **Server-Sent Events (SSE)** via HTTP when streaming is enabled, as indicated by the `Content-Type: text/event-stream` header set in [`test/harness/replayingCapiProxy.ts`](https://github.com/github/copilot-sdk/blob/main/test/harness/replayingCapiProxy.ts). The low-level RPC layer in [`nodejs/src/generated/rpc.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/rpc.ts) (lines 1150-1400) also supports WebSocket transport where available, though SSE remains the primary method for streaming model responses.

### How do I access the cumulative byte count during streaming?

The `assistant.streaming_delta` event includes a `cumulative_bytes` property that tracks the total bytes received so far. According to the type definitions in [`nodejs/src/generated/session-events.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/session-events.ts), this field allows you to monitor download progress or implement custom buffering logic as tokens arrive from the model.

### Can I enable streaming for only specific requests?

Yes. While you can set `streaming: true` in the `CopilotClient` constructor to enable it globally, you can also pass `streaming: true` to individual `session.send()` calls to override the default behavior for specific requests, as shown in the request payload handling at [`test/harness/responsesApiAdapter.ts`](https://github.com/github/copilot-sdk/blob/main/test/harness/responsesApiAdapter.ts).

### What is the difference between assistant.streaming_delta and assistant.reasoning_delta?

Both events emit incremental content, but they target different model outputs. The `assistant.streaming_delta` event carries the primary response text tokens, while `assistant.reasoning_delta` provides intermediate reasoning steps when supported by the model. Both are defined in [`nodejs/src/generated/session-events.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/generated/session-events.ts) and emitted by the session layer in [`nodejs/src/session.ts`](https://github.com/github/copilot-sdk/blob/main/nodejs/src/session.ts).