langgraph-sdk 0.2.6__tar.gz → 0.2.8__tar.gz

{langgraph_sdk-0.2.6 → langgraph_sdk-0.2.8}/PKG-INFO

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

{langgraph_sdk-0.2.6 → langgraph_sdk-0.2.8}/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.6"
+__version__ = "0.2.8"
 
 __all__ = ["Auth", "get_client", "get_sync_client"]

{langgraph_sdk-0.2.6 → langgraph_sdk-0.2.8}/langgraph_sdk/client.py

@@ -157,27 +157,38 @@ def get_client(
     headers: Mapping[str, str] | None = None,
     timeout: TimeoutTypes | None = None,
 ) -> LangGraphClient:
-    """Get a LangGraphClient instance.
+    """Create and configure a LangGraphClient.
+
+    The client provides programmatic access to a LangGraph Platform deployment. It supports
+    both remote servers and local in-process connections (when running inside a LangGraph server).
 
     Args:
-        url: The URL of the LangGraph API.
-        api_key: The API key. If not provided, it will be read from the environment.
-            Precedence:
-                1. explicit argument
-                2. LANGGRAPH_API_KEY
-                3. LANGSMITH_API_KEY
-                4. LANGCHAIN_API_KEY
-        headers: Optional custom headers
-        timeout: Optional timeout configuration for the HTTP client.
-            Accepts an httpx.Timeout instance, a float (seconds), or a tuple of timeouts.
-            Tuple format is (connect, read, write, pool)
-            If not provided, defaults to connect=5s, read=300s, write=300s, and pool=5s.
+        url:
+            Base URL of the LangGraph API.
+            – If `None`, the client first attempts an in-process connection via ASGI transport.
+              If that fails, it falls back to `http://localhost:8123`.
+        api_key:
+            API key for authentication. If omitted, the client reads from environment
+            variables in the following order:
+              1. Function argument
+              2. `LANGGRAPH_API_KEY`
+              3. `LANGSMITH_API_KEY`
+              4. `LANGCHAIN_API_KEY`
+        headers:
+            Additional HTTP headers to include in requests. Merged with authentication headers.
+        timeout:
+            HTTP timeout configuration. May be:
+              – `httpx.Timeout` instance
+              – float (total seconds)
+              – tuple `(connect, read, write, pool)` in seconds
+            Defaults: connect=5, read=300, write=300, pool=5.
 
     Returns:
-        LangGraphClient: The top-level client for accessing AssistantsClient,
-        ThreadsClient, RunsClient, and CronClient.
+        LangGraphClient:
+            A top-level client exposing sub-clients for assistants, threads,
+            runs, and cron operations.
 
-    ???+ example "Example"
+    ???+ example "Connect to a remote server:"
 
         ```python
         from langgraph_sdk import get_client
@@ -188,6 +199,21 @@ def get_client(
         # example usage: client.<model>.<method_name>()
         assistants = await client.assistants.get(assistant_id="some_uuid")
         ```
+
+    ???+ example "Connect in-process to a running LangGraph server:"
+
+        ```python
+        from langgraph_sdk import get_client
+
+        client = get_client(url=None)
+
+        async def my_node(...):
+            subagent_result = await client.runs.wait(
+                thread_id=None,
+                assistant_id="agent",
+                input={"messages": [{"role": "user", "content": "Foo"}]},
+            )
+        ```
     """
 
     transport: httpx.AsyncBaseTransport | None = None
@@ -429,34 +455,94 @@ class HttpClient:
         if headers:
             request_headers.update(headers)
 
-        async with self.client.stream(
-            method, path, headers=request_headers, content=content, params=params
-        ) as res:
-            if 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)
+        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:
-                    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}"
-                )
-            # 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""):
+                        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]:
@@ -3614,39 +3700,100 @@ class SyncHttpClient:
         on_response: Callable[[httpx.Response], None] | None = None,
     ) -> Iterator[StreamPart]:
         """Stream the results of a request using SSE."""
-        request_headers, content = _encode_json(json)
+        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)
-        with self.client.stream(
-            method, path, headers=request_headers, content=content, params=params
-        ) as res:
-            if 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)
+
+        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:
-                    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}"
-                )
-            # 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""):
+                        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]:

{langgraph_sdk-0.2.6 → langgraph_sdk-0.2.8}/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