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

JavaScript

import { Agent, run } from '@openai/agents';

// Define the agent
const agent = new Agent({
  name: 'Travel Genie',
  instructions:
    'You are Travel Genie, a friendly and knowledgeable travel assistant. ' +
    'Recommend exciting destinations and offer helpful travel tips. ' +
    'Be enthusiastic and tailor suggestions to the user\'s interests.',
  model: 'gpt-5.6-terra',
  modelSettings: { reasoning: { effort: 'none' } }
});
  
// Run the agent and wait for the complete response
const result = await run(
    agent,
    'What are the best travel tips for solo travelers in Japan?'
);

// The agent's response is only available after it's fully generated
console.log('Agent response:', result.finalOutput);

import { Agent, run } from '@openai/agents';

// Define the agent
const agent = new Agent({
  name: 'Travel Genie',
  instructions:
    'You are Travel Genie, a friendly and knowledgeable travel assistant. ' +
    'Recommend exciting destinations and offer helpful travel tips. ' +
    'Be enthusiastic and tailor suggestions to the user\'s interests.',
  model: 'gpt-5.6-terra',
  modelSettings: { reasoning: { effort: 'none' } }
});
  
// Run the agent and wait for the complete response
const result = await run(
    agent,
    'What are the best travel tips for solo travelers in Japan?'
);

// The agent's response is only available after it's fully generated
console.log('Agent response:', result.finalOutput);

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);

JavaScript

import { Agent, Runner } from '@openai/agents';

// ... (agent definition as before)

// Create a runner instance
const runner = new Runner();

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

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

// Wait for completion
await streamResult.completed;

console.log('Final Output:', streamResult.finalOutput);

import { Agent, Runner } from '@openai/agents';

// ... (agent definition as before)

// Create a runner instance
const runner = new Runner();

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

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

// Wait for completion
await streamResult.completed;

console.log('Final Output:', streamResult.finalOutput);

JavaScript

// ... (agent definition and execution)

// Process streaming events manually
for await (const event of streamResult) {
    // Check if this is a raw streaming event from the model
    if (event.type === 'raw_model_stream_event') {
        // Look specifically for text output chunks
        if (event.data.type === 'output_text_delta') {
            // Write each text chunk to stdout as it arrives (The delta contains the new text fragment)
            process.stdout.write(event.data.delta || '');
        }
    }
}

// ... (agent definition and execution)

// Process streaming events manually
for await (const event of streamResult) {
    // Check if this is a raw streaming event from the model
    if (event.type === 'raw_model_stream_event') {
        // Look specifically for text output chunks
        if (event.data.type === 'output_text_delta') {
            // Write each text chunk to stdout as it arrives (The delta contains the new text fragment)
            process.stdout.write(event.data.delta || '');
        }
    }
}

JavaScript

import { Agent, run } from '@openai/agents';

// Define the agent
const agent = new Agent({
  name: 'Travel Genie',
  instructions:
    'You are Travel Genie, a friendly and knowledgeable travel assistant. ' +
    'Recommend exciting destinations and offer helpful travel tips. ' +
    'Be enthusiastic and tailor suggestions to the user\'s interests.',
  model: 'gpt-5.6-terra',
  modelSettings: { reasoning: { effort: 'none' } }
});
  
// Run the agent and wait for the complete response
const result = await run(
    agent,
    'What are the best travel tips for solo travelers in Japan?'
);

// The agent's response is only available after it's fully generated
console.log('Agent response:', result.finalOutput);

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);

JavaScript

import { Agent, Runner } from '@openai/agents';

// ... (agent definition as before)

// Create a runner instance
const runner = new Runner();

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

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

// Wait for completion
await streamResult.completed;

console.log('Final Output:', streamResult.finalOutput);

JavaScript

// ... (agent definition and execution)

// Process streaming events manually
for await (const event of streamResult) {
    // Check if this is a raw streaming event from the model
    if (event.type === 'raw_model_stream_event') {
        // Look specifically for text output chunks
        if (event.data.type === 'output_text_delta') {
            // Write each text chunk to stdout as it arrives (The delta contains the new text fragment)
            process.stdout.write(event.data.delta || '');
        }
    }
}

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