@lovrozagar/honey 0.6.5 → 0.7.0

package/src/client-python/_sse.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import re
-from typing import AsyncIterator, TypedDict
+import codecs
+from typing import AsyncIterator, Iterable, Iterator, TypedDict
 
 import httpx
 
@@ -13,87 +13,143 @@ class SSEEvent(TypedDict, total=False):
     retry: int
 
 
-def _parse_sse_block(block: str) -> SSEEvent | None:
-    lines = block.splitlines()
-    is_comment = True
-    data: str | None = None
-    event: str | None = None
-    id_val: str | None = None
-    retry: int | None = None
-
-    for line in lines:
+DEFAULT_MAX_BUFFER = 1024 * 1024
+MAX_EVENT_DATA = 8 * 1024 * 1024
+
+
+class SSEParser:
+    """WHATWG event-stream parser.
+
+    Lines end in CRLF, LF or CR only (never U+2028 and friends, which
+    ``str.splitlines`` would also split on). A blank line dispatches the event;
+    a final event without its blank line is discarded; the id is sticky across
+    events; ``retry`` needs ASCII digits. Each chunk is scanned once.
+    """
+
+    def __init__(self, max_line: int = DEFAULT_MAX_BUFFER) -> None:
+        self._max_line = max_line
+        self._decoder = codecs.getincrementaldecoder("utf-8")("replace")
+        self._line: list[str] = []
+        self._line_len = 0
+        self._pending_cr = False
+        self._first = True
+        self._data: list[str] = []
+        self._data_len = 0
+        self._has_data = False
+        self._event: str | None = None
+        self._last_id: str | None = None
+        self._retry: int | None = None
+
+    def feed(self, chunk: bytes) -> Iterator[SSEEvent]:
+        yield from self._feed_text(self._decoder.decode(chunk))
+
+    def feed_text(self, text: str) -> Iterator[SSEEvent]:
+        yield from self._feed_text(text)
+
+    def _feed_text(self, text: str) -> Iterator[SSEEvent]:
+        start = 0
+        for i, ch in enumerate(text):
+            if i < start or (ch != "\r" and ch != "\n"):
+                continue
+            if ch == "\n" and self._pending_cr and i == start:
+                # LF completing a CRLF split across chunks
+                self._pending_cr = False
+                start = i + 1
+                continue
+            self._pending_cr = False
+            self._append(text[start:i])
+            line = "".join(self._line)
+            self._line = []
+            self._line_len = 0
+            if ch == "\r":
+                if i + 1 < len(text):
+                    if text[i + 1] == "\n":
+                        start = i + 2
+                        event = self._process(line)
+                        if event is not None:
+                            yield event
+                        continue
+                else:
+                    self._pending_cr = True
+            start = i + 1
+            event = self._process(line)
+            if event is not None:
+                yield event
+        if start < len(text):
+            self._pending_cr = False
+            self._append(text[start:])
+
+    def _append(self, part: str) -> None:
+        if not part:
+            return
+        self._line_len += len(part)
+        if self._line_len > self._max_line:
+            raise RuntimeError(f"SSE line exceeded {self._max_line} characters")
+        self._line.append(part)
+
+    def _process(self, line: str) -> SSEEvent | None:
+        if self._first:
+            self._first = False
+            if line.startswith("\ufeff"):
+                line = line[1:]
+        if line == "":
+            return self._dispatch()
         if line.startswith(":"):
-            continue
-        is_comment = False
-        colon_idx = line.find(":")
-        if colon_idx == -1:
-            field_name = line
-            val = ""
-        else:
-            field_name = line[:colon_idx]
-            val = line[colon_idx + 1:]
-            if val.startswith(" "):
-                val = val[1:]
-
-        if field_name == "data":
-            data = val if data is None else f"{data}\n{val}"
-        elif field_name == "event":
-            event = val
-        elif field_name == "id":
-            # per SSE spec: id containing null byte must be ignored
-            if "\0" not in val:
-                id_val = val
-        elif field_name == "retry":
-            try:
-                n = int(val)
-                if n >= 0:
-                    retry = n
-            except ValueError:
-                pass
-
-    if is_comment or data is None:
+            return None
+        name, sep, value = line.partition(":")
+        if sep and value.startswith(" "):
+            value = value[1:]
+        if name == "data":
+            self._data_len += len(value) + 1
+            if self._data_len > MAX_EVENT_DATA:
+                raise RuntimeError(f"SSE event exceeded {MAX_EVENT_DATA} characters")
+            self._data.append(value)
+            self._has_data = True
+        elif name == "event":
+            self._event = value
+        elif name == "id":
+            if "\0" not in value:
+                self._last_id = value
+        elif name == "retry":
+            if value and value.isascii() and value.isdigit():
+                self._retry = int(value)
         return None
 
-    result: SSEEvent = {"data": data}
-    if event is not None:
-        result["event"] = event
-    if id_val is not None:
-        result["id"] = id_val
-    if retry is not None:
-        result["retry"] = retry
-    return result
-
-
-DEFAULT_MAX_BUFFER = 1024 * 1024
-
-_SSE_BLOCK_RE = re.compile(r"\r\n\r\n|\r\n\r|\r\n\n|\r\r\n|\n\r\n|\n\r|\r\r|\n\n")
+    def _dispatch(self) -> SSEEvent | None:
+        event: SSEEvent | None = None
+        if self._has_data:
+            event = {"data": "\n".join(self._data)}
+            if self._event is not None:
+                event["event"] = self._event
+            if self._last_id is not None:
+                event["id"] = self._last_id
+            if self._retry is not None:
+                event["retry"] = self._retry
+        self._data = []
+        self._data_len = 0
+        self._has_data = False
+        self._event = None
+        self._retry = None
+        return event
+
+
+def parse_sse_text(chunks: Iterable[str]) -> list[SSEEvent]:
+    """Parse already-decoded text chunks; used by the conformance vectors."""
+    parser = SSEParser()
+    out: list[SSEEvent] = []
+    for chunk in chunks:
+        out.extend(parser.feed_text(chunk))
+    return out
 
 
 async def parse_sse_stream(
     response: httpx.Response,
     max_buffer_size: int = DEFAULT_MAX_BUFFER,
 ) -> AsyncIterator[SSEEvent]:
-    buffer = ""
-    async for chunk in response.aiter_text():
-        buffer += chunk
-        if len(buffer) > max_buffer_size:
-            raise RuntimeError(f"SSE buffer exceeded {max_buffer_size} characters")
-
-        # split on double-newline (any combo of \r\n, \r, \n)
-        blocks = _SSE_BLOCK_RE.split(buffer)
-        buffer = blocks.pop()
-
-        for block in blocks:
-            if not block.strip():
-                continue
-            event = _parse_sse_block(block)
-            if event is not None:
-                yield event
-
-    if buffer.strip():
-        event = _parse_sse_block(buffer)
-        if event is not None:
+    parser = SSEParser(max_buffer_size)
+    async for chunk in response.aiter_bytes():
+        for event in parser.feed(chunk):
             yield event
 
 
-__all__ = ["SSEEvent", "parse_sse_stream"]
+__all__ = ["SSEEvent", "SSEParser", "parse_sse_stream", "parse_sse_text"]

package/src/client-python/_transport.py

@@ -4,7 +4,7 @@ import json
 import uuid
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Protocol, runtime_checkable
+from typing import Any, Protocol, cast, runtime_checkable
 from urllib.parse import urlencode
 
 try:
@@ -28,12 +28,21 @@ class TransportKind(str, Enum):
 
 @dataclass
 class TransportOpts:
+    """Options for each transport connect.
+
+    ``max_reconnect_attempts`` caps consecutive failed reconnects (0 or less:
+    unlimited); ``reconnect_delay_ms`` is the first backoff delay. ``headers``
+    are sent on every transport (the generated SDK fills in config headers and
+    auth). ``max_message_bytes`` caps one WebSocket message.
+    """
+
     reconnect_token: str | None = None
     last_event_id: str | None = None
     headers: dict[str, str] | None = None
     max_reconnect_attempts: int = 5
     reconnect_delay_ms: int = 1000
     protocols: list[str] | None = None
+    max_message_bytes: int = 16 * 1024 * 1024
 
 
 @runtime_checkable
@@ -81,9 +90,9 @@ class _StubConn:
 
 def _to_ws_url(url: str) -> str:
     if url.startswith("https://"):
-        return "wss://" + url[len("https://"):]
+        return "wss://" + url[len("https://") :]
     if url.startswith("http://"):
-        return "ws://" + url[len("http://"):]
+        return "ws://" + url[len("http://") :]
     return url
 
 
@@ -148,8 +157,9 @@ class WsAdapter:
         headers = opts.headers or None
         conn = await websockets.connect(
             ws_url,
-            subprotocols=subprotocols,
+            subprotocols=cast(Any, subprotocols),
             additional_headers=headers,
+            max_size=opts.max_message_bytes,
         )
         return _WsConn(conn)
 
@@ -224,14 +234,32 @@ class SseAdapter:
             headers["x-request-id"] = str(uuid.uuid4())
         client = self.http_client or httpx.AsyncClient()
         owns_client = self.http_client is None
+        # a stream may idle between events: no read timeout
         ctx = client.stream(
-            "GET", url, params=params or None, headers=headers,
+            "GET",
+            url,
+            params=params or None,
+            headers=headers,
+            timeout=httpx.Timeout(30.0, read=None),
         )
-        response = await ctx.__aenter__()
-        response.raise_for_status()
+        try:
+            response = await ctx.__aenter__()
+        except BaseException:
+            if owns_client:
+                await client.aclose()
+            raise
+        try:
+            response.raise_for_status()
+        except BaseException:
+            await ctx.__aexit__(None, None, None)
+            if owns_client:
+                await client.aclose()
+            raise
         return _SseConn(
-            client=client, owns_client=owns_client,
-            ctx=ctx, response=response,
+            client=client,
+            owns_client=owns_client,
+            ctx=ctx,
+            response=response,
         )
 
 

package/src/client-python/_ws.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any, AsyncIterator, Callable
+from typing import Any, AsyncIterator, Callable, cast
 
 try:
     import websockets
@@ -43,15 +43,12 @@ class _TypedWebSocket:
         }
         self.close_code: int | None = None
         self.close_reason: str | None = None
+        self._close_fired = False
 
     async def __aenter__(self) -> _TypedWebSocket:
         if websockets is None:
             raise ImportError("pip install honey-sdk[ws] to use WebSocket methods")
-        self._conn = await websockets.connect(
-            self._url,
-            subprotocols=self._protocols or None,
-            additional_headers=self._extra_headers or None,
-        )
+        self._conn = await _connect(self._url, self._protocols, self._extra_headers)
         for handler in self._handlers["open"]:
             try:
                 handler()
@@ -66,13 +63,10 @@ class _TypedWebSocket:
             except Exception:
                 pass
             self._capture_close()
-            code = self.close_code if self.close_code is not None else 1000
-            reason = self.close_reason if self.close_reason is not None else ""
-            for handler in self._handlers["close"]:
-                try:
-                    handler(code, reason)
-                except Exception:
-                    pass
+            self._fire_close(
+                self.close_code if self.close_code is not None else 1000,
+                self.close_reason if self.close_reason is not None else "",
+            )
 
     def __aiter__(self) -> AsyncIterator[str | bytes]:
         return self._iter_messages()
@@ -86,16 +80,31 @@ class _TypedWebSocket:
                     except Exception:
                         pass
                 yield msg
-        finally:
-            self._capture_close()
-            code = self.close_code
-            reason = self.close_reason
-            if code is not None:
-                for handler in self._handlers["close"]:
+        except Exception as exc:
+            closed_ok = websockets is not None and isinstance(
+                exc, getattr(websockets.exceptions, "ConnectionClosedOK", ())
+            )
+            if not closed_ok:
+                for handler in self._handlers["error"]:
                     try:
-                        handler(code, reason or "")
+                        handler(exc)
                     except Exception:
                         pass
+                raise
+        finally:
+            self._capture_close()
+            if self.close_code is not None:
+                self._fire_close(self.close_code, self.close_reason or "")
+
+    def _fire_close(self, code: int, reason: str) -> None:
+        if self._close_fired:
+            return
+        self._close_fired = True
+        for handler in self._handlers["close"]:
+            try:
+                handler(code, reason)
+            except Exception:
+                pass
 
     def _capture_close(self) -> None:
         """Read close code/reason from the underlying websockets.Connection once
@@ -118,8 +127,9 @@ class _TypedWebSocket:
             )
         self._handlers[event].append(callback)
 
-    async def send(self, data: str | bytes | dict[str, Any]) -> None:
-        if isinstance(data, dict):
+    async def send(self, data: Any) -> None:
+        """Send str/bytes as-is; anything else (dict, list, numbers) as JSON text."""
+        if not isinstance(data, (str, bytes, bytearray)):
             data = json.dumps(data)
         await self._conn.send(data)
 
@@ -128,4 +138,22 @@ class _TypedWebSocket:
             await self._conn.close(code, reason)
 
 
+async def _connect(url: str, protocols: list[str], headers: dict[str, str]) -> Any:
+    """websockets >= 14 takes ``additional_headers``; older releases take
+    ``extra_headers``."""
+    assert websockets is not None
+    try:
+        return await websockets.connect(
+            url,
+            subprotocols=cast(Any, protocols or None),
+            additional_headers=headers or None,
+        )
+    except TypeError:
+        return await websockets.connect(
+            url,
+            subprotocols=cast(Any, protocols or None),
+            extra_headers=headers or None,
+        )
+
+
 __all__ = ["_TypedWebSocket"]

package/src/client-rust/errors.rs

@@ -181,7 +181,7 @@ pub(crate) fn raise_for_status(status: u16, body: Vec<u8>) -> Option<Error> {
     } else {
         serde_json::from_slice(&body).ok()
     };
-    let message = String::from_utf8_lossy(&body).to_string();
+    let message = error_message(&body, data.as_ref());
     let api_err: Box<dyn ApiError + Send + Sync> = match status {
         400 => Box::new(BadRequestError { message, body, status_code: 400, data }),
         401 => Box::new(UnauthorizedError { message, body, status_code: 401, data }),
@@ -198,3 +198,23 @@ pub(crate) fn raise_for_status(status: u16, body: Vec<u8>) -> Option<Error> {
     };
     Some(Error::Api(api_err))
 }
+
+/// error_message is the server's `message` field when the body is a JSON object
+/// carrying one, else the body text, with control characters dropped and capped
+/// at 512 characters.
+pub(crate) fn error_message(body: &[u8], data: Option<&serde_json::Value>) -> String {
+    let text = data
+        .and_then(|d| d.get("message"))
+        .and_then(|m| m.as_str())
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| String::from_utf8_lossy(body).into_owned());
+    let mut out = String::new();
+    for (n, ch) in text.chars().filter(|c| !c.is_control()).enumerate() {
+        if n >= 512 {
+            out.push('…');
+            break;
+        }
+        out.push(ch);
+    }
+    out
+}