Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""Incremental Server-Sent Events parsing.
The parser follows the event-stream grammar from the W3C/WHATWG SSE
specification. It deliberately accepts bytes because an HTTP transport may
split a UTF-8 code point, a CRLF pair, or a ``data:`` field at any boundary.
"""
from __future__ import annotations
import codecs
import re
from dataclasses import dataclass
from typing import Iterable
DEFAULT_MAX_PENDING_LINE_SIZE = 8 * 1024 * 1024
DEFAULT_MAX_PENDING_EVENT_SIZE = 32 * 1024 * 1024
_LINE_END_RE = re.compile(r"[\r\n]")
class SSEParseError(ValueError):
"""A provider sent an event-stream frame larger than the safety budget."""
@dataclass(frozen=True)
class SSEEvent:
"""One dispatched SSE event."""
data: str
event: str | None = None
event_id: str | None = None
retry: int | None = None
class SSEParser:
"""Parse an SSE byte or text stream incrementally."""
def __init__(
self,
*,
max_line_size: int | None = None,
max_event_size: int | None = None,
) -> None:
self.max_line_size = (
DEFAULT_MAX_PENDING_LINE_SIZE if max_line_size is None else max_line_size
)
self.max_event_size = (
DEFAULT_MAX_PENDING_EVENT_SIZE if max_event_size is None else max_event_size
)
if self.max_line_size <= 0 or self.max_event_size <= 0:
raise ValueError("SSE parser limits must be positive")
self._buffer = ""
self._decoder = codecs.getincrementaldecoder("utf-8")("replace")
self._data: list[str] = []
self._data_size = 0
self._event: str | None = None
self._event_id: str | None = None
self._retry: int | None = None
self._at_stream_start = True
self._line_start = 0
self._scan_position = 0
def feed(self, chunk: bytes | bytearray | memoryview | str) -> list[SSEEvent]:
"""Consume an arbitrary chunk and return complete events."""
text = self._decode(chunk)
if not text:
return []
self._buffer += text
events: list[SSEEvent] = []
while True:
line = self._take_line()
if line is None:
break
if line == "":
event = self._dispatch()
if event is not None:
events.append(event)
continue
self._check_line_size(line)
self._parse_line(line)
self._compact_buffer()
self._check_pending_line_size()
return events
def finish(self) -> list[SSEEvent]:
"""Flush a final unterminated line and pending event."""
events: list[SSEEvent] = []
decoded_tail = self._decoder.decode(b"", final=True)
if decoded_tail:
self._buffer += decoded_tail
while True:
line = self._take_line()
if line is None:
break
if line == "":
event = self._dispatch()
if event is not None:
events.append(event)
continue
self._check_line_size(line)
self._parse_line(line)
self._compact_buffer()
if self._buffer:
self._check_pending_line_size()
line = self._buffer[:-1] if self._buffer.endswith("\r") else self._buffer
self._parse_line(line)
self._buffer = ""
self._line_start = 0
self._scan_position = 0
event = self._dispatch()
if event is not None:
events.append(event)
return events
def _decode(self, chunk: bytes | bytearray | memoryview | str) -> str:
if isinstance(chunk, (bytes, bytearray, memoryview)):
text = self._decoder.decode(bytes(chunk), final=False)
else:
pending, _ = self._decoder.getstate()
text = self._decoder.decode(b"", final=True) + chunk if pending else chunk
if self._at_stream_start and text:
self._at_stream_start = False
if text.startswith("\ufeff"):
text = text[1:]
return text
def _check_line_size(self, line: str) -> None:
if len(line) > self.max_line_size:
raise SSEParseError(
f"SSE pending line exceeds {self.max_line_size} characters"
)
def _check_pending_line_size(self) -> None:
if len(self._buffer) - self._line_start > self.max_line_size:
raise SSEParseError(
f"SSE pending line exceeds {self.max_line_size} characters"
)
def _take_line(self) -> str | None:
match = _LINE_END_RE.search(self._buffer, self._scan_position)
if match is None:
self._scan_position = len(self._buffer)
return None
index = match.start()
character = self._buffer[index]
# A CR may be the first half of a CRLF pair split across HTTP chunks.
# Wait for the next chunk so that the blank-line dispatch cannot happen
# one byte too early.
if character == "\r" and index + 1 == len(self._buffer):
self._scan_position = index
return None
line = self._buffer[self._line_start : index]
if character == "\r" and index + 1 < len(self._buffer) and self._buffer[index + 1] == "\n":
self._line_start = index + 2
else:
self._line_start = index + 1
self._scan_position = self._line_start
return line
def _compact_buffer(self) -> None:
if self._line_start:
self._buffer = self._buffer[self._line_start :]
self._line_start = 0
self._scan_position = 0
def _parse_line(self, line: str) -> None:
if line.startswith(":"):
return
if ":" in line:
field, value = line.split(":", 1)
if value.startswith(" "):
value = value[1:]
else:
field, value = line, ""
if field == "data":
new_size = self._data_size + len(value) + (1 if self._data else 0)
if new_size > self.max_event_size:
raise SSEParseError(
f"SSE pending event exceeds {self.max_event_size} characters"
)
self._data.append(value)
self._data_size = new_size
elif field == "event":
self._event = value
elif field == "id" and "\x00" not in value:
self._event_id = value
elif field == "retry" and value.isdigit():
self._retry = int(value)
def _dispatch(self) -> SSEEvent | None:
if not self._data:
self._event = None
self._retry = None
return None
event = SSEEvent(
data="\n".join(self._data),
event=self._event,
event_id=self._event_id,
retry=self._retry,
)
self._data.clear()
self._data_size = 0
self._event = None
self._retry = None
return event
def parse_sse(chunks: Iterable[bytes | str]) -> list[SSEEvent]:
"""Parse a finite iterable of chunks."""
parser = SSEParser()
events: list[SSEEvent] = []
for chunk in chunks:
events.extend(parser.feed(chunk))
events.extend(parser.finish())
return events
IncrementalSSEParser = SSEParser
SSEDecoder = SSEParser