langgraph-sdk 0.2.7__tar.gz → 0.2.9__tar.gz

{langgraph_sdk-0.2.7 → langgraph_sdk-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-sdk
-Version: 0.2.7
+Version: 0.2.9
 Summary: SDK for interacting with LangGraph API
 Project-URL: Repository, https://www.github.com/langchain-ai/langgraph
 License-Expression: MIT

{langgraph_sdk-0.2.7 → langgraph_sdk-0.2.9}/langgraph_sdk/__init__.py

@@ -1,6 +1,6 @@
 from langgraph_sdk.auth import Auth
 from langgraph_sdk.client import get_client, get_sync_client
 
-__version__ = "0.2.7"
+__version__ = "0.2.9"
 
 __all__ = ["Auth", "get_client", "get_sync_client"]

{langgraph_sdk-0.2.7 → langgraph_sdk-0.2.9}/langgraph_sdk/auth/__init__.py

@@ -728,7 +728,7 @@ def is_studio_user(
     return (
         isinstance(user, types.StudioUser)
         or isinstance(user, dict)
-        and user.get("kind") == "StudioUser"
+        and user.get("kind") == "StudioUser"  # ty: ignore[invalid-argument-type]
     )
 
 

{langgraph_sdk-0.2.7 → langgraph_sdk-0.2.9}/langgraph_sdk/client.py

@@ -437,7 +437,7 @@ class HttpClient:
                 logger.error(f"Error from langgraph-api: {body}", exc_info=e)
             raise e
 
-    async def stream(
+    async def request_reconnect(
         self,
         path: str,
         method: str,
@@ -446,45 +446,151 @@ class HttpClient:
         params: QueryParamTypes | None = None,
         headers: Mapping[str, str] | None = None,
         on_response: Callable[[httpx.Response], None] | None = None,
-    ) -> AsyncIterator[StreamPart]:
-        """Stream results using SSE."""
+        reconnect_limit: int = 5,
+    ) -> Any:
+        """Send a request that automatically reconnects to Location header."""
         request_headers, content = await _aencode_json(json)
-        request_headers["Accept"] = "text/event-stream"
-        request_headers["Cache-Control"] = "no-store"
-        # Add runtime headers with precedence
         if headers:
             request_headers.update(headers)
-
         async with self.client.stream(
             method, path, headers=request_headers, content=content, params=params
-        ) as res:
+        ) as r:
             if on_response:
-                on_response(res)
-            # check status
+                on_response(r)
             try:
-                res.raise_for_status()
+                r.raise_for_status()
             except httpx.HTTPStatusError as e:
-                body = (await res.aread()).decode()
+                body = (await r.aread()).decode()
                 if sys.version_info >= (3, 11):
                     e.add_note(body)
                 else:
                     logger.error(f"Error from langgraph-api: {body}", exc_info=e)
                 raise e
-            # check content type
-            content_type = res.headers.get("content-type", "").partition(";")[0]
-            if "text/event-stream" not in content_type:
-                raise httpx.TransportError(
-                    "Expected response header Content-Type to contain 'text/event-stream', "
-                    f"got {content_type!r}"
+            loc = r.headers.get("location")
+            if reconnect_limit <= 0 or not loc:
+                return await _adecode_json(r)
+            try:
+                return await _adecode_json(r)
+            except httpx.HTTPError:
+                warnings.warn(
+                    f"Request failed, attempting reconnect to Location: {loc}",
+                    stacklevel=2,
+                )
+                await r.aclose()
+                return await self.request_reconnect(
+                    loc,
+                    "GET",
+                    headers=request_headers,
+                    # don't pass on_response so it's only called once
+                    reconnect_limit=reconnect_limit - 1,
                 )
-            # parse SSE
-            decoder = SSEDecoder()
-            async for line in aiter_lines_raw(res):
-                sse = decoder.decode(line=line.rstrip(b"\n"))
-                if sse is not None:
-                    yield sse
-            if sse := decoder.decode(b""):
-                yield sse
+
+    async def stream(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> AsyncIterator[StreamPart]:
+        """Stream results using SSE."""
+        request_headers, content = await _aencode_json(json)
+        request_headers["Accept"] = "text/event-stream"
+        request_headers["Cache-Control"] = "no-store"
+        # Add runtime headers with precedence
+        if headers:
+            request_headers.update(headers)
+
+        reconnect_headers = {
+            key: value
+            for key, value in request_headers.items()
+            if key.lower() not in {"content-length", "content-type"}
+        }
+
+        last_event_id: str | None = None
+        reconnect_path: str | None = None
+        reconnect_attempts = 0
+        max_reconnect_attempts = 5
+
+        while True:
+            current_headers = dict(
+                request_headers if reconnect_path is None else reconnect_headers
+            )
+            if last_event_id is not None:
+                current_headers["Last-Event-ID"] = last_event_id
+
+            current_method = method if reconnect_path is None else "GET"
+            current_content = content if reconnect_path is None else None
+            current_params = params if reconnect_path is None else None
+
+            retry = False
+            async with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                try:
+                    res.raise_for_status()
+                except httpx.HTTPStatusError as e:
+                    body = (await res.aread()).decode()
+                    if sys.version_info >= (3, 11):
+                        e.add_note(body)
+                    else:
+                        logger.error(f"Error from langgraph-api: {body}", exc_info=e)
+                    raise e
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
+
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    reconnect_path = reconnect_location
+
+                # parse SSE
+                decoder = SSEDecoder()
+                try:
+                    async for line in aiter_lines_raw(res):
+                        sse = decoder.decode(line=line.rstrip(b"\n"))
+                        if sse is not None:
+                            if decoder.last_event_id is not None:
+                                last_event_id = decoder.last_event_id
+                            if sse.event or sse.data is not None:
+                                yield sse
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # decoder.decode(b"") flushes the in-flight event and may
+                            # return an empty placeholder when there is no pending
+                            # message. Skip these no-op events so the stream doesn't
+                            # emit a trailing blank item after reconnects.
+                            yield sse
+            if retry:
+                reconnect_attempts += 1
+                if reconnect_attempts > max_reconnect_attempts:
+                    raise httpx.TransportError(
+                        "Exceeded maximum SSE reconnection attempts"
+                    )
+                continue
+            break
 
 
 async def _aencode_json(json: Any) -> tuple[dict[str, str], bytes | None]:
@@ -2475,8 +2581,9 @@ class RunsClient:
             if on_run_created and (metadata := _get_run_metadata_from_response(res)):
                 on_run_created(metadata)
 
-        response = await self.http.post(
+        response = await self.http.request_reconnect(
             endpoint,
+            "POST",
             json={k: v for k, v in payload.items() if v is not None},
             params=params,
             headers=headers,
@@ -2621,12 +2728,20 @@ class RunsClient:
         }
         if params:
             query_params.update(params)
-        return await self.http.post(
-            f"/threads/{thread_id}/runs/{run_id}/cancel",
-            json=None,
-            params=query_params,
-            headers=headers,
-        )
+        if wait:
+            return await self.http.request_reconnect(
+                f"/threads/{thread_id}/runs/{run_id}/cancel",
+                "POST",
+                params=query_params,
+                headers=headers,
+            )
+        else:
+            return await self.http.post(
+                f"/threads/{thread_id}/runs/{run_id}/cancel",
+                json=None,
+                params=query_params,
+                headers=headers,
+            )
 
     async def join(
         self,
@@ -2658,8 +2773,11 @@ class RunsClient:
             ```
 
         """  # noqa: E501
-        return await self.http.get(
-            f"/threads/{thread_id}/runs/{run_id}/join", headers=headers, params=params
+        return await self.http.request_reconnect(
+            f"/threads/{thread_id}/runs/{run_id}/join",
+            "GET",
+            headers=headers,
+            params=params,
         )
 
     def join_stream(
@@ -3631,7 +3749,7 @@ class SyncHttpClient:
                 logger.error(f"Error from langgraph-api: {body}", exc_info=e)
             raise e
 
-    def stream(
+    def request_reconnect(
         self,
         path: str,
         method: str,
@@ -3640,43 +3758,150 @@ class SyncHttpClient:
         params: QueryParamTypes | None = None,
         headers: Mapping[str, str] | None = None,
         on_response: Callable[[httpx.Response], None] | None = None,
-    ) -> Iterator[StreamPart]:
-        """Stream the results of a request using SSE."""
+        reconnect_limit: int = 5,
+    ) -> Any:
+        """Send a request that automatically reconnects to Location header."""
         request_headers, content = _encode_json(json)
-        request_headers["Accept"] = "text/event-stream"
-        request_headers["Cache-Control"] = "no-store"
         if headers:
             request_headers.update(headers)
         with self.client.stream(
             method, path, headers=request_headers, content=content, params=params
-        ) as res:
+        ) as r:
             if on_response:
-                on_response(res)
-            # check status
+                on_response(r)
             try:
-                res.raise_for_status()
+                r.raise_for_status()
             except httpx.HTTPStatusError as e:
-                body = (res.read()).decode()
+                body = r.read().decode()
                 if sys.version_info >= (3, 11):
                     e.add_note(body)
                 else:
                     logger.error(f"Error from langgraph-api: {body}", exc_info=e)
                 raise e
-            # check content type
-            content_type = res.headers.get("content-type", "").partition(";")[0]
-            if "text/event-stream" not in content_type:
-                raise httpx.TransportError(
-                    "Expected response header Content-Type to contain 'text/event-stream', "
-                    f"got {content_type!r}"
+            loc = r.headers.get("location")
+            if reconnect_limit <= 0 or not loc:
+                return _decode_json(r)
+            try:
+                return _decode_json(r)
+            except httpx.HTTPError:
+                warnings.warn(
+                    f"Request failed, attempting reconnect to Location: {loc}",
+                    stacklevel=2,
                 )
-            # parse SSE
-            decoder = SSEDecoder()
-            for line in iter_lines_raw(res):
-                sse = decoder.decode(line.rstrip(b"\n"))
-                if sse is not None:
-                    yield sse
-            if sse := decoder.decode(b""):
-                yield sse
+                r.close()
+                return self.request_reconnect(
+                    loc,
+                    "GET",
+                    headers=request_headers,
+                    # don't pass on_response so it's only called once
+                    reconnect_limit=reconnect_limit - 1,
+                )
+
+    def stream(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Iterator[StreamPart]:
+        """Stream the results of a request using SSE."""
+        if json is not None:
+            request_headers, content = _encode_json(json)
+        else:
+            request_headers, content = {}, None
+        request_headers["Accept"] = "text/event-stream"
+        request_headers["Cache-Control"] = "no-store"
+        if headers:
+            request_headers.update(headers)
+
+        reconnect_headers = {
+            key: value
+            for key, value in request_headers.items()
+            if key.lower() not in {"content-length", "content-type"}
+        }
+
+        last_event_id: str | None = None
+        reconnect_path: str | None = None
+        reconnect_attempts = 0
+        max_reconnect_attempts = 5
+
+        while True:
+            current_headers = dict(
+                request_headers if reconnect_path is None else reconnect_headers
+            )
+            if last_event_id is not None:
+                current_headers["Last-Event-ID"] = last_event_id
+
+            current_method = method if reconnect_path is None else "GET"
+            current_content = content if reconnect_path is None else None
+            current_params = params if reconnect_path is None else None
+
+            retry = False
+            with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                try:
+                    res.raise_for_status()
+                except httpx.HTTPStatusError as e:
+                    body = (res.read()).decode()
+                    if sys.version_info >= (3, 11):
+                        e.add_note(body)
+                    else:
+                        logger.error(f"Error from langgraph-api: {body}", exc_info=e)
+                    raise e
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
+
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    reconnect_path = reconnect_location
+
+                decoder = SSEDecoder()
+                try:
+                    for line in iter_lines_raw(res):
+                        sse = decoder.decode(line.rstrip(b"\n"))
+                        if sse is not None:
+                            if decoder.last_event_id is not None:
+                                last_event_id = decoder.last_event_id
+                            if sse.event or sse.data is not None:
+                                yield sse
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # See async stream implementation for rationale on
+                            # skipping empty flush events.
+                            yield sse
+            if retry:
+                reconnect_attempts += 1
+                if reconnect_attempts > max_reconnect_attempts:
+                    raise httpx.TransportError(
+                        "Exceeded maximum SSE reconnection attempts"
+                    )
+                continue
+            break
 
 
 def _encode_json(json: Any) -> tuple[dict[str, str], bytes]:
@@ -5637,8 +5862,9 @@ class SyncRunsClient:
         endpoint = (
             f"/threads/{thread_id}/runs/wait" if thread_id is not None else "/runs/wait"
         )
-        return self.http.post(
+        return self.http.request_reconnect(
             endpoint,
+            "POST",
             json={k: v for k, v in payload.items() if v is not None},
             params=params,
             headers=headers,
@@ -5761,11 +5987,25 @@ class SyncRunsClient:
             ```
 
         """  # noqa: E501
+        query_params = {
+            "wait": 1 if wait else 0,
+            "action": action,
+        }
+        if params:
+            query_params.update(params)
+        if wait:
+            return self.http.request_reconnect(
+                f"/threads/{thread_id}/runs/{run_id}/cancel",
+                "POST",
+                json=None,
+                params=query_params,
+                headers=headers,
+            )
         return self.http.post(
-            f"/threads/{thread_id}/runs/{run_id}/cancel?wait={1 if wait else 0}&action={action}",
+            f"/threads/{thread_id}/runs/{run_id}/cancel",
             json=None,
+            params=query_params,
             headers=headers,
-            params=params,
         )
 
     def join(
@@ -5798,8 +6038,11 @@ class SyncRunsClient:
             ```
 
         """  # noqa: E501
-        return self.http.get(
-            f"/threads/{thread_id}/runs/{run_id}/join", headers=headers, params=params
+        return self.http.request_reconnect(
+            f"/threads/{thread_id}/runs/{run_id}/join",
+            "GET",
+            headers=headers,
+            params=params,
         )
 
     def join_stream(

{langgraph_sdk-0.2.7 → langgraph_sdk-0.2.9}/langgraph_sdk/sse.py

@@ -81,6 +81,12 @@ class SSEDecoder:
         self._last_event_id = ""
         self._retry: int | None = None
 
+    @property
+    def last_event_id(self) -> str | None:
+        """Return the last event identifier that was seen."""
+
+        return self._last_event_id or None
+
     def decode(self, line: bytes) -> StreamPart | None:
         # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation  # noqa: E501
 

langgraph_sdk-0.2.9/tests/test_client_stream.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from pathlib import Path
+
+import httpx
+import pytest
+
+from langgraph_sdk.client import HttpClient, SyncHttpClient
+from langgraph_sdk.schema import StreamPart
+from langgraph_sdk.sse import BytesLike, BytesLineDecoder, SSEDecoder
+
+with open(Path(__file__).parent / "fixtures" / "response.txt", "rb") as f:
+    RESPONSE_PAYLOAD = f.read()
+
+
+class AsyncListByteStream(httpx.AsyncByteStream):
+    def __init__(self, chunks: Sequence[bytes], exc: Exception | None = None) -> None:
+        self._chunks = list(chunks)
+        self._exc = exc
+
+    async def __aiter__(self):  # type: ignore[override]
+        for chunk in self._chunks:
+            yield chunk
+        if self._exc is not None:
+            raise self._exc
+
+    async def aclose(self) -> None:
+        return None
+
+
+class ListByteStream(httpx.ByteStream):
+    def __init__(self, chunks: Sequence[bytes], exc: Exception | None = None) -> None:
+        self._chunks = list(chunks)
+        self._exc = exc
+
+    def __iter__(self):  # type: ignore[override]
+        yield from self._chunks
+        if self._exc is not None:
+            raise self._exc
+
+    def close(self) -> None:
+        return None
+
+
+def iter_lines_raw(payload: list[bytes]) -> Iterator[BytesLike]:
+    decoder = BytesLineDecoder()
+    for part in payload:
+        yield from decoder.decode(part)
+    yield from decoder.flush()
+
+
+def test_stream_see():
+    for groups in (
+        [RESPONSE_PAYLOAD],
+        RESPONSE_PAYLOAD.splitlines(keepends=True),
+    ):
+        parts: list[StreamPart] = []
+
+        decoder = SSEDecoder()
+        for line in iter_lines_raw(groups):
+            sse = decoder.decode(line=line.rstrip(b"\n"))
+            if sse is not None:
+                parts.append(sse)
+        if sse := decoder.decode(b""):
+            parts.append(sse)
+
+        assert decoder.decode(b"") is None
+        assert len(parts) == 79
+
+
+@pytest.mark.asyncio
+async def test_http_client_stream_flushes_trailing_event():
+    payload = b'event: foo\ndata: {"bar": 1}\n'
+
+    async def handler(request: httpx.Request) -> httpx.Response:
+        assert request.headers["accept"] == "text/event-stream"
+        assert request.headers["cache-control"] == "no-store"
+        return httpx.Response(
+            200,
+            headers={"Content-Type": "text/event-stream"},
+            content=payload,
+        )
+
+    transport = httpx.MockTransport(handler)
+    async with httpx.AsyncClient(
+        transport=transport, base_url="https://example.com"
+    ) as client:
+        http_client = HttpClient(client)
+        parts = [part async for part in http_client.stream("/stream", "GET")]
+
+    assert parts == [StreamPart(event="foo", data={"bar": 1})]
+
+
+def test_sync_http_client_stream_recovers_after_disconnect():
+    reconnect_path = "/reconnect"
+    first_chunks = [
+        b"id: 1\n",
+        b"event: values\n",
+        b'data: {"step": 1}\n\n',
+    ]
+    second_chunks = [
+        b"id: 2\n",
+        b"event: values\n",
+        b'data: {"step": 2}\n\n',
+        b"event: end\n",
+        b"data: null\n\n",
+    ]
+    call_count = 0
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            assert request.method == "POST"
+            assert request.url.path == "/stream"
+            assert request.headers["accept"] == "text/event-stream"
+            assert request.headers["cache-control"] == "no-store"
+            assert "last-event-id" not in {
+                k.lower(): v for k, v in request.headers.items()
+            }
+            assert request.read()
+            return httpx.Response(
+                200,
+                headers={
+                    "Content-Type": "text/event-stream",
+                    "Location": reconnect_path,
+                },
+                stream=ListByteStream(
+                    first_chunks,
+                    httpx.RemoteProtocolError("incomplete chunked read"),
+                ),
+            )
+        if call_count == 2:
+            assert request.method == "GET"
+            assert request.url.path == reconnect_path
+            assert request.headers["Last-Event-ID"] == "1"
+            assert request.read() == b""
+            return httpx.Response(
+                200,
+                headers={"Content-Type": "text/event-stream"},
+                stream=ListByteStream(second_chunks),
+            )
+        raise AssertionError("unexpected request")
+
+    transport = httpx.MockTransport(handler)
+    with httpx.Client(transport=transport, base_url="https://example.com") as client:
+        http_client = SyncHttpClient(client)
+        parts = list(http_client.stream("/stream", "POST", json={"payload": "value"}))
+
+    assert call_count == 2
+    assert parts == [
+        StreamPart(event="values", data={"step": 1}),
+        StreamPart(event="values", data={"step": 2}),
+        StreamPart(event="end", data=None),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_http_client_stream_recovers_after_disconnect():
+    reconnect_path = "/reconnect"
+    first_chunks = [
+        b"id: 1\n",
+        b"event: values\n",
+        b'data: {"step": 1}\n\n',
+    ]
+    second_chunks = [
+        b"id: 2\n",
+        b"event: values\n",
+        b'data: {"step": 2}\n\n',
+        b"event: end\n",
+        b"data: null\n\n",
+    ]
+    call_count = 0
+
+    async def handler(request: httpx.Request) -> httpx.Response:
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            assert request.method == "POST"
+            assert request.url.path == "/stream"
+            assert request.headers["accept"] == "text/event-stream"
+            assert request.headers["cache-control"] == "no-store"
+            assert "last-event-id" not in {
+                k.lower(): v for k, v in request.headers.items()
+            }
+            assert await request.aread()
+            return httpx.Response(
+                200,
+                headers={
+                    "Content-Type": "text/event-stream",
+                    "Location": reconnect_path,
+                },
+                stream=AsyncListByteStream(
+                    first_chunks,
+                    httpx.RemoteProtocolError("incomplete chunked read"),
+                ),
+            )
+        if call_count == 2:
+            assert request.method == "GET"
+            assert request.url.path == reconnect_path
+            assert request.headers["Last-Event-ID"] == "1"
+            assert await request.aread() == b""
+            return httpx.Response(
+                200,
+                headers={"Content-Type": "text/event-stream"},
+                stream=AsyncListByteStream(second_chunks),
+            )
+        raise AssertionError("unexpected request")
+
+    transport = httpx.MockTransport(handler)
+    async with httpx.AsyncClient(
+        transport=transport, base_url="https://example.com"
+    ) as client:
+        http_client = HttpClient(client)
+        parts = [
+            part
+            async for part in http_client.stream(
+                "/stream", "POST", json={"payload": "value"}
+            )
+        ]
+
+    assert call_count == 2
+    assert parts == [
+        StreamPart(event="values", data={"step": 1}),
+        StreamPart(event="values", data={"step": 2}),
+        StreamPart(event="end", data=None),
+    ]
+
+
+def test_sync_http_client_stream_flushes_trailing_event():
+    payload = b'event: foo\ndata: {"bar": 1}\n'
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.headers["accept"] == "text/event-stream"
+        assert request.headers["cache-control"] == "no-store"
+        return httpx.Response(
+            200,
+            headers={"Content-Type": "text/event-stream"},
+            content=payload,
+        )
+
+    transport = httpx.MockTransport(handler)
+    with httpx.Client(transport=transport, base_url="https://example.com") as client:
+        http_client = SyncHttpClient(client)
+        parts = list(http_client.stream("/stream", "GET"))
+
+    assert parts == [StreamPart(event="foo", data={"bar": 1})]

langgraph_sdk-0.2.7/tests/test_client_stream.py

@@ -1,81 +0,0 @@
-from collections.abc import Iterator
-from pathlib import Path
-
-import httpx
-import pytest
-
-from langgraph_sdk.client import HttpClient, SyncHttpClient
-from langgraph_sdk.schema import StreamPart
-from langgraph_sdk.sse import BytesLike, BytesLineDecoder, SSEDecoder
-
-with open(Path(__file__).parent / "fixtures" / "response.txt", "rb") as f:
-    RESPONSE_PAYLOAD = f.read()
-
-
-def iter_lines_raw(payload: list[bytes]) -> Iterator[BytesLike]:
-    decoder = BytesLineDecoder()
-    for part in payload:
-        yield from decoder.decode(part)
-    yield from decoder.flush()
-
-
-def test_stream_see():
-    for groups in (
-        [RESPONSE_PAYLOAD],
-        RESPONSE_PAYLOAD.splitlines(keepends=True),
-    ):
-        parts: list[StreamPart] = []
-
-        decoder = SSEDecoder()
-        for line in iter_lines_raw(groups):
-            sse = decoder.decode(line=line.rstrip(b"\n"))
-            if sse is not None:
-                parts.append(sse)
-        if sse := decoder.decode(b""):
-            parts.append(sse)
-
-        assert decoder.decode(b"") is None
-        assert len(parts) == 79
-
-
-@pytest.mark.asyncio
-async def test_http_client_stream_flushes_trailing_event():
-    payload = b'event: foo\ndata: {"bar": 1}\n'
-
-    async def handler(request: httpx.Request) -> httpx.Response:
-        assert request.headers["accept"] == "text/event-stream"
-        assert request.headers["cache-control"] == "no-store"
-        return httpx.Response(
-            200,
-            headers={"Content-Type": "text/event-stream"},
-            content=payload,
-        )
-
-    transport = httpx.MockTransport(handler)
-    async with httpx.AsyncClient(
-        transport=transport, base_url="https://example.com"
-    ) as client:
-        http_client = HttpClient(client)
-        parts = [part async for part in http_client.stream("/stream", "GET")]
-
-    assert parts == [StreamPart(event="foo", data={"bar": 1})]
-
-
-def test_sync_http_client_stream_flushes_trailing_event():
-    payload = b'event: foo\ndata: {"bar": 1}\n'
-
-    def handler(request: httpx.Request) -> httpx.Response:
-        assert request.headers["accept"] == "text/event-stream"
-        assert request.headers["cache-control"] == "no-store"
-        return httpx.Response(
-            200,
-            headers={"Content-Type": "text/event-stream"},
-            content=payload,
-        )
-
-    transport = httpx.MockTransport(handler)
-    with httpx.Client(transport=transport, base_url="https://example.com") as client:
-        http_client = SyncHttpClient(client)
-        parts = list(http_client.stream("/stream", "GET"))
-
-    assert parts == [StreamPart(event="foo", data={"bar": 1})]