Streaming Agent Responses

Introduction & Context

Welcome back! In the previous lesson, you learned how to structure your agent's output using Zod schemas and the outputType parameter. This made your agent's responses more predictable and type-safe, allowing you to confidently access specific fields in the agent's output — an essential skill for building robust JavaScript applications. Now, let's take the next step: making your agent-powered applications more responsive and interactive. In many real-world scenarios — such as chatbots, web apps, or interactive tools — waiting for an agent to complete its entire response before showing anything to the user can make your application feel slow or unresponsive. This is where streaming execution comes in. While the standard async execution waits for the complete response, streaming allows you to process and display the agent's output as it's being generated, creating a smoother and more engaging user experience. In this lesson, you'll learn the differences between non-streaming and streaming execution modes, and how to implement streaming in your JavaScript applications. By the end, you'll be able to build applications that feel fast and interactive, even when working with complex AI agents.

Understanding Non-Streaming vs Streaming Execution

The OpenAI Agents SDK for JavaScript provides two ways to handle agent responses: non-streaming (default) and streaming execution. Both are asynchronous operations (using async/await), but they differ in how and when you receive the agent's output. Non-streaming execution is what you've been using so far. When you call await run(agent, input), your code waits for the agent to completely finish generating its response before returning the result. This is simple and works well for many use cases, but it means users have to wait for the entire response before seeing anything. Streaming execution allows you to receive and process the agent's output as it's being generated, token by token or chunk by chunk. This creates a more interactive experience, similar to how ChatGPT displays text as it "types" out responses. To enable streaming, you simply add { stream: true } to your run call. Here's a quick comparison: Aspect Non-Streaming Streaming Method await run(...) await run(..., { stream: true }) Response timing All at once when complete Incrementally as generated Result type RunResult StreamedRunResult User experience Wait, then see full response See response appearing live Use cases APIs, batch processing, simple apps Chat UIs, live demos, interactive apps Think of streaming like watching a video that loads progressively versus downloading the entire file before you can watch it — streaming provides immediate feedback and keeps users engaged throughout the process.

Aspect	Non-Streaming	Streaming
Method	`await run(...)`	`await run(..., { stream: true })`
Response timing	All at once when complete	Incrementally as generated
Result type	`RunResult`	`StreamedRunResult`
User experience	Wait, then see full response	See response appearing live
Use cases	APIs, batch processing, simple apps	Chat UIs, live demos, interactive apps

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Streaming Execution for Real-Time Output

Streamed execution is designed for situations where you want to process the agent’s output as soon as it is available, rather than waiting for the entire response. This is especially useful for real-time applications, such as chatbots or live dashboards, where you want to display information to the user as quickly as possible.

With the OpenAI Agents SDK, you can use the run function with the { stream: true } option to start the agent and then process the streaming events as they arrive. Each event can represent a new chunk of text or another type of update from the agent.

Here’s an example that prints the agent’s response as it is generated:

JavaScript

// ... (agent definition as before)

// Run the agent in streaming mode
const streamResult = await run(
    agent,
    'What are the best travel tips for solo travelers in Japan?',
    { stream: true }
);

// Stream the text output to console as it arrives
streamResult.toTextStream({ compatibleWithNodeStreams: true }).pipe(process.stdout);

// Wait for streaming to complete
await streamResult.completed;

// Access the final output after streaming is complete
console.log('Final Output:', streamResult.finalOutput);

// ... (agent definition as before)

// Run the agent in streaming mode
const streamResult = await run(
    agent,
    'What are the best travel tips for solo travelers in Japan?',
    { stream: true }
);

// Stream the text output to console as it arrives
streamResult.toTextStream({ compatibleWithNodeStreams: true }).pipe(process.stdout);

// Wait for streaming to complete
await streamResult.completed;

// Access the final output after streaming is complete
console.log('Final Output:', streamResult.finalOutput);

Here’s what’s happening in this example:

Start the agent in streaming mode by passing { stream: true } to the run function. This lets you receive the agent’s response bit by bit, instead of waiting for the whole answer.
Stream the output to the console using toTextStream(), which pipes the streamed text directly to process.stdout as it arrives.
Wait for the stream to complete with await streamResult.completed.
Access the final output as before, using streamResult.finalOutput.

With this approach, users see the agent's response appearing in real-time, creating a much more engaging and responsive experience compared to waiting for the entire response to complete.

Introduction & Context

Understanding Non-Streaming vs Streaming Execution

Join the 1M+ learners on CodeSignal

Non-Streaming Execution (Standard Approach)

Streaming Execution for Real-Time Output

Using the Runner Class for Streaming

Processing Streaming Events Manually

When to Use Streaming vs Non-Streaming

Summary & Next Steps