For AI agents: a documentation index is available at the root level at /llms.txt and /llms-full.txt. Append /llms.txt to any URL for a page-level index, or .md for the markdown version of any page.
  • About NVIDIA NeMo Relay
    • Overview
    • Architecture
    • Ecosystem
    • Concepts
    • Release Notes
  • Getting Started
    • Agent Runtime Primer
    • Prerequisites
    • Installation
    • Configuration / Setup
    • Quick Start
  • NVIDIA NeMo Relay CLI
    • About
    • Basic Usage
    • Claude Code
    • Codex
    • Cursor
    • Hermes Agent
  • Supported Integrations
    • About
    • OpenClaw Plugin Guide
    • LangChain Integration Guide
    • LangGraph Integration Guide
    • Deep Agents Integration Guide
  • Instrument Applications
    • About
    • Adding Scopes and Marks
    • Instrument a Tool Call
    • Instrument an LLM Call
    • Add Middleware
    • Code Examples
  • Observability Plugin
    • About
    • Configuration
    • Agent Trajectory Interchange Format (ATIF)
    • Agent Trajectory Observability Format (ATOF)
    • OpenTelemetry
    • OpenInference
  • Adaptive Plugin
    • About
    • Configuration
    • Adaptive Cache Governor (ACG)
    • Adaptive Hints
  • NeMo Guardrails Plugin
    • About
    • Configuration
  • Integrate into Frameworks
    • About
    • Adding Scopes
    • Wrap Tool Calls
    • Wrap LLM Calls
    • Handle Non-Serializable Data
    • Using Codecs
    • Provider Codecs
    • Provider Response Codecs
    • Code Examples
  • Build Plugins
    • About
    • Define a Plugin
    • Validate Plugin Configuration
    • Plugin Configuration Files
    • Register Plugin Behavior
    • Design Plugin Configuration
    • NeMo Guardrails Example Plugin
    • Code Examples
  • Contribute
    • About
    • Development Setup
    • Workflow and Reviews
    • Testing and Documentation
  • Reference
    • APIs
      • Python Library Reference
      • Node.js Library Reference
      • Rust Library Reference
        • nemo-relay
          • api
          • codec
            • anthropic
            • openai_chat
            • openai_responses
            • request
            • response
            • streaming
              • SseEvent
              • SseEventDecoder
              • StreamingCodec
            • traits
          • config_editor
          • error
          • json
          • observability
          • plugin
          • plugins
          • stream
          • editor_config
        • nemo-relay-adaptive
        • nemo-relay-ffi
    • Performance
  • Resources
    • Support and FAQs
    • Glossary
    • Troubleshooting Guide
    • Community
    • Legal
NVIDIANVIDIA
Developer-friendly docs for your API
Privacy Policy | Your Privacy Choices | Terms of Service | Accessibility | Corporate Policies | Product Security | Contact

Copyright © 2026, NVIDIA Corporation.

LogoLogo
On this page
  • Implementations
  • impl SseEventDecoder
  • new
  • push_bytes
  • finish
  • Trait Implementations
  • impl Default for SseEventDecoder
  • default
ReferenceAPIsRust Library Referencenemo-relaycodecstreaming

Struct SseEvent Decoder

||View as Markdown|
Previous

Struct SseEvent

Next

Trait Streaming Codec

Generated from cargo doc --no-deps -p nemo-relay -p nemo-relay-adaptive -p nemo-relay-ffi.

1pub struct SseEventDecoder { /* private fields */ }

Incremental decoder for text/event-stream byte streams that yields one JSON object per complete data: payload.

SSE frames are separated by blank lines (\n\n); each frame may contain event: and data: lines. Anthropic Messages, OpenAI Responses, and OpenAI Chat Completions all emit one JSON object per data: line, so the decoder buffers received bytes, splits on frame boundaries, parses the JSON payload, and tags it with the frame’s event name when present.

The decoder is byte-stream-friendly: it accumulates partial frames across chunks and emits completed frames only when their terminating blank line arrives. Bytes after the last terminator are retained for the next call.

Implementations

impl SseEventDecoder

impl SseEventDecoder

new

pub fn new() -> Self

Creates a new decoder with an empty buffer.

push_bytes

pub fn push_bytes(&mut self, bytes: &[u8]) -> Result<Vec<SseEvent>>

Appends bytes to the internal buffer and returns every now-complete SSE event.

Bytes are interpreted as UTF-8 with replacement characters for invalid sequences; provider SSE streams are well-formed UTF-8 in practice, but lossy decoding keeps the decoder honest rather than failing on a single corrupt chunk.

Returns Ok(events) containing zero or more events whose data: payloads parsed successfully. Frames whose data: line is non-empty but does not parse as JSON are surfaced as FlowError::Internal so the caller can decide whether to abort the stream or skip the frame; frames with no data: line at all (e.g. SSE heartbeats) are silently dropped.

finish

pub fn finish(self) -> Result<Option<SseEvent>>

Drains any remaining buffered frame at end of stream.

Most well-formed SSE streams end with a terminating blank line, in which case this returns Ok(None). Stops with no terminator are surfaced as a final partial frame so observability captures the last bytes the upstream sent before disconnect.

Trait Implementations

impl Default for SseEventDecoder

impl Default for SseEventDecoder

default

fn default() -> SseEventDecoder