langgraph-api 0.4.21__tar.gz → 0.4.23__tar.gz

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.21
+Version: 0.4.23
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
-Requires-Dist: langgraph-runtime-inmem<0.13.0,>=0.12.1
+Requires-Dist: langgraph-runtime-inmem<0.15.0,>=0.14.0
 Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45

langgraph_api-0.4.23/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.23"

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/api/runs.py

@@ -1,7 +1,7 @@
 import asyncio
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Awaitable, Callable
 from typing import Literal, cast
-from uuid import uuid4
+from uuid import UUID, uuid4
 
 import orjson
 import structlog
@@ -32,12 +32,116 @@ from langgraph_api.validation import (
 )
 from langgraph_license.validation import plus_features_enabled
 from langgraph_runtime.database import connect
-from langgraph_runtime.ops import Crons, Runs, Threads
+from langgraph_runtime.ops import Crons, Runs, StreamHandler, Threads
 from langgraph_runtime.retry import retry_db
 
 logger = structlog.stdlib.get_logger(__name__)
 
 
+_RunResultFallback = Callable[[], Awaitable[bytes]]
+
+
+def _thread_values_fallback(thread_id: UUID) -> _RunResultFallback:
+    async def fetch_thread_values() -> bytes:
+        async with connect() as conn:
+            thread_iter = await Threads.get(conn, thread_id)
+            try:
+                thread = await anext(thread_iter)
+                if thread["status"] == "error":
+                    return orjson.dumps({"__error__": orjson.Fragment(thread["error"])})
+                if thread["status"] == "interrupted":
+                    # Get an interrupt for the thread. There is the case where there are multiple interrupts for the same run and we may not show the same
+                    # interrupt, but we'll always show one. Long term we should show all of them.
+                    try:
+                        if isinstance(thread["interrupts"], dict):
+                            # Handle in memory format
+                            interrupt_map = thread["interrupts"]
+                        else:
+                            interrupt_map = orjson.loads(thread["interrupts"].buf)
+                        interrupt = [next(iter(interrupt_map.values()))[0]]
+                        return orjson.dumps({"__interrupt__": interrupt})
+                    except Exception:
+                        # No interrupt, but status is interrupted from a before/after block. Default back to values.
+                        pass
+                return cast(bytes, thread["values"])
+            except StopAsyncIteration:
+                await logger.awarning(
+                    f"No checkpoint found for thread {thread_id}",
+                    thread_id=thread_id,
+                )
+                return b"{}"
+
+    return fetch_thread_values
+
+
+def _run_result_body(
+    *,
+    run_id: UUID,
+    thread_id: UUID,
+    sub: StreamHandler,
+    cancel_on_disconnect: bool = False,
+    ignore_404: bool = False,
+    fallback: _RunResultFallback | None = None,
+    cancel_message: str | None = None,
+) -> Callable[[], AsyncIterator[bytes]]:
+    last_chunk = ValueEvent()
+
+    async def consume() -> None:
+        vchunk: bytes | None = None
+        try:
+            async for mode, chunk, _ in Runs.Stream.join(
+                run_id,
+                stream_channel=sub,
+                cancel_on_disconnect=cancel_on_disconnect,
+                thread_id=thread_id,
+                ignore_404=ignore_404,
+            ):
+                if (
+                    mode == b"values"
+                    or mode == b"updates"
+                    and b"__interrupt__" in chunk
+                ):
+                    vchunk = chunk
+                elif mode == b"error":
+                    vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
+            if vchunk is not None:
+                last_chunk.set(vchunk)
+            elif fallback is not None:
+                last_chunk.set(await fallback())
+            else:
+                last_chunk.set(b"{}")
+        finally:
+            # Make sure to always clean up the pubsub
+            await sub.__aexit__(None, None, None)
+
+    # keep the connection open by sending whitespace every 5 seconds
+    # leading whitespace will be ignored by json parsers
+    async def body() -> AsyncIterator[bytes]:
+        try:
+            stream = asyncio.create_task(consume())
+            while True:
+                try:
+                    if stream.done():
+                        # raise stream exception if any
+                        stream.result()
+                    yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
+                    break
+                except TimeoutError:
+                    yield b"\n"
+                except asyncio.CancelledError:
+                    if cancel_message is not None:
+                        stream.cancel(cancel_message)
+                    else:
+                        stream.cancel()
+                    await stream
+                    raise
+        finally:
+            # Make sure to always clean up the pubsub
+            await sub.__aexit__(None, None, None)
+
+    return body
+
+
 @retry_db
 async def create_run(request: ApiRequest):
     """Create a run."""
@@ -218,56 +322,13 @@ async def wait_run(request: ApiRequest):
         await sub.__aexit__(None, None, None)
         raise
 
-    last_chunk = ValueEvent()
-
-    async def consume():
-        vchunk: bytes | None = None
-        async for mode, chunk, _ in Runs.Stream.join(
-            run["run_id"],
-            thread_id=run["thread_id"],
-            stream_channel=sub,
-            cancel_on_disconnect=on_disconnect == "cancel",
-        ):
-            if mode == b"values" or mode == b"updates" and b"__interrupt__" in chunk:
-                vchunk = chunk
-            elif mode == b"error":
-                vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
-        if vchunk is not None:
-            last_chunk.set(vchunk)
-        else:
-            async with connect() as conn:
-                thread_iter = await Threads.get(conn, thread_id)
-                try:
-                    thread = await anext(thread_iter)
-                    last_chunk.set(thread["values"])
-                except StopAsyncIteration:
-                    await logger.awarning(
-                        f"No checkpoint found for thread {thread_id}",
-                        thread_id=thread_id,
-                    )
-                    last_chunk.set(b"{}")
-
-    # keep the connection open by sending whitespace every 5 seconds
-    # leading whitespace will be ignored by json parsers
-    async def body() -> AsyncIterator[bytes]:
-        try:
-            stream = asyncio.create_task(consume())
-            while True:
-                try:
-                    if stream.done():
-                        # raise stream exception if any
-                        stream.result()
-                    yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
-                    break
-                except TimeoutError:
-                    yield b"\n"
-                except asyncio.CancelledError:
-                    stream.cancel()
-                    await stream
-                    raise
-        finally:
-            # Make sure to always clean up the pubsub
-            await sub.__aexit__(None, None, None)
+    body = _run_result_body(
+        run_id=run["run_id"],
+        thread_id=run["thread_id"],
+        sub=sub,
+        cancel_on_disconnect=on_disconnect == "cancel",
+        fallback=_thread_values_fallback(thread_id),
+    )
 
     return StreamingResponse(
         body(),
@@ -305,53 +366,23 @@ async def wait_run_stateless(request: ApiRequest):
         await sub.__aexit__(None, None, None)
         raise
 
-    last_chunk = ValueEvent()
-
-    async def consume():
-        vchunk: bytes | None = None
-        async for mode, chunk, _ in Runs.Stream.join(
-            run["run_id"],
+    async def stateless_fallback() -> bytes:
+        await logger.awarning(
+            "No checkpoint emitted for stateless run",
+            run_id=run["run_id"],
             thread_id=run["thread_id"],
-            stream_channel=sub,
-            ignore_404=True,
-            cancel_on_disconnect=on_disconnect == "cancel",
-        ):
-            if mode == b"values" or mode == b"updates" and b"__interrupt__" in chunk:
-                vchunk = chunk
-            elif mode == b"error":
-                vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
-        if vchunk is not None:
-            last_chunk.set(vchunk)
-        else:
-            # we can't fetch the thread (it was deleted), so just return empty values
-            await logger.awarning(
-                "No checkpoint emitted for stateless run",
-                run_id=run["run_id"],
-                thread_id=run["thread_id"],
-            )
-            last_chunk.set(b"{}")
-
-    # keep the connection open by sending whitespace every 5 seconds
-    # leading whitespace will be ignored by json parsers
-    async def body() -> AsyncIterator[bytes]:
-        try:
-            stream = asyncio.create_task(consume())
-            while True:
-                try:
-                    if stream.done():
-                        # raise stream exception if any
-                        stream.result()
-                    yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
-                    break
-                except TimeoutError:
-                    yield b"\n"
-                except asyncio.CancelledError:
-                    stream.cancel("Run stream cancelled")
-                    await stream
-                    raise
-        finally:
-            # Make sure to always clean up the pubsub
-            await sub.__aexit__(None, None, None)
+        )
+        return b"{}"
+
+    body = _run_result_body(
+        run_id=run["run_id"],
+        thread_id=run["thread_id"],
+        sub=sub,
+        cancel_on_disconnect=on_disconnect == "cancel",
+        ignore_404=True,
+        fallback=stateless_fallback,
+        cancel_message="Run stream cancelled",
+    )
 
     return StreamingResponse(
         body(),
@@ -422,11 +453,23 @@ async def join_run(request: ApiRequest):
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
 
-    return ApiResponse(
-        await Runs.join(
-            run_id,
-            thread_id=thread_id,
-        )
+    # A touch redundant, but to meet the existing signature of join, we need to throw any 404s before we enter the streaming body
+    await Runs.Stream.check_run_stream_auth(run_id, thread_id)
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
+    body = _run_result_body(
+        run_id=run_id,
+        thread_id=thread_id,
+        sub=sub,
+        fallback=_thread_values_fallback(thread_id),
+    )
+
+    return StreamingResponse(
+        body(),
+        media_type="application/json",
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run_id}/join",
+            "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
+        },
     )
 
 
@@ -456,6 +499,10 @@ async def join_run_stream(request: ApiRequest):
 
     return EventSourceResponse(
         body(),
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run_id}/stream",
+            "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
+        },
     )
 
 
@@ -476,19 +523,36 @@ async def cancel_run(
         action_str if action_str in {"interrupt", "rollback"} else "interrupt",
     )
 
-    async with connect() as conn:
-        await Runs.cancel(
-            conn,
-            [run_id],
-            action=action,
-            thread_id=thread_id,
-        )
-    if wait:
-        await Runs.join(
-            run_id,
-            thread_id=thread_id,
-        )
-    return Response(status_code=204 if wait else 202)
+    sub = await Runs.Stream.subscribe(run_id, thread_id) if wait else None
+    try:
+        async with connect() as conn:
+            await Runs.cancel(
+                conn,
+                [run_id],
+                action=action,
+                thread_id=thread_id,
+            )
+    except Exception:
+        if sub is not None:
+            await sub.__aexit__(None, None, None)
+        raise
+    if not wait:
+        return Response(status_code=202)
+
+    body = _run_result_body(
+        run_id=run_id,
+        thread_id=thread_id,
+        sub=sub,
+    )
+
+    return StreamingResponse(
+        body(),
+        media_type="application/json",
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run_id}/join",
+            "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
+        },
+    )
 
 
 @retry_db

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/cli.py

@@ -256,7 +256,7 @@ def run_server(
             if k in to_patch:
                 logger.debug(f"Skipping loaded env var {k}={v}")
                 continue
-            to_patch[k] = v
+            to_patch[k] = v  # type: ignore[invalid-assignment]
     with patch_environment(
         **to_patch,
     ):

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/command.py

@@ -21,7 +21,7 @@ def map_cmd(cmd: RunCommand) -> Command:
         update=update,
         goto=(
             [
-                it if isinstance(it, str) else Send(it["node"], it["input"])
+                it if isinstance(it, str) else Send(it["node"], it["input"])  # type: ignore[non-subscriptable]
                 for it in goto
             ]
             if goto

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/js/remote.py

@@ -239,7 +239,7 @@ class RemotePregel(BaseRemotePregel):
                         tuple(task["path"]) if task.get("path") else tuple(),
                         # TODO: figure out how to properly deserialise errors
                         task.get("error"),
-                        tuple(interrupts),
+                        tuple(interrupts),  # type: ignore[arg-type]
                         state,
                         task.get("result"),
                     )

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/models/run.py

@@ -147,7 +147,7 @@ def ensure_ids(
             ) from None
     else:
         results.append(None)
-    return tuple(results)
+    return tuple(results)  # type: ignore[invalid-return-type]
 
 
 def assign_defaults(

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/patch.py

@@ -3,7 +3,7 @@ from typing import Any
 from starlette.responses import Response, StreamingResponse
 from starlette.types import Send
 
-from langgraph_api.serde import Fragment
+from langgraph_api.serde import Fragment, json_dumpb
 
 """
 Patch Response.render and StreamingResponse.stream_response
@@ -32,6 +32,8 @@ async def StreamingResponse_stream_response(self, send: Send) -> None:
             continue
         if isinstance(chunk, Fragment):
             chunk = chunk.buf
+        if isinstance(chunk, dict):
+            chunk = json_dumpb(chunk)
         if not isinstance(chunk, (bytes, bytearray, memoryview)):  # noqa: UP038
             chunk = chunk.encode(self.charset)
         await send({"type": "http.response.body", "body": chunk, "more_body": True})

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/serde.py

@@ -149,7 +149,7 @@ def json_loads(content: bytes | Fragment | dict) -> Any:
         content = content.buf
     if isinstance(content, dict):
         return content
-    return orjson.loads(cast(bytes, content))
+    return orjson.loads(content)
 
 
 # Do not use. orjson holds the GIL the entire time it's running anyway.

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/langgraph_api/stream.py

@@ -304,7 +304,7 @@ async def astream_state(
                                 else:
                                     msg = convert_to_messages([msg_])[0]
                             else:
-                                msg = cast(BaseMessage, msg_)
+                                msg = msg_
                             if msg.id in messages:
                                 messages[msg.id] += msg
                             else:
@@ -404,7 +404,7 @@ async def astream_state(
                             else:
                                 msg = convert_to_messages([msg_])[0]
                         else:
-                            msg = cast(BaseMessage, msg_)
+                            msg = msg_
                         if msg.id in messages:
                             messages[msg.id] += msg
                         else:

langgraph_api-0.4.23/langgraph_api/utils/stream_codec.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+
+import orjson
+import structlog
+
+PROTOCOL_VERSION = 1
+"""
+---
+Version 1:
+Byte Offsets
+0        1                  3                5                    5+N                5+N+M
++--------+------------------+----------------+------------------+------------------+--------------------+
+| version| stream_id_len    | event_len      | stream_id        | event            | message            |
++--------+------------------+----------------+------------------+------------------+--------------------+
+   1 B         2 B                2 B              N B                 M B               variable
+
+---- Old (to be dropped soon / multiple formats)
+Version 0 (old):
+1) b"$:" + <stream_id> + b"$:" + <event> + b"$:" + <raw_json>
+2) b"$:" + <stream_id> + b"$:" + <raw_json>
+"""
+
+BYTE_MASK = 0xFF
+HEADER_LEN = 5
+logger = structlog.stdlib.get_logger(__name__)
+
+
+class StreamFormatError(ValueError):
+    """Raised when a stream frame fails validation."""
+
+
+@dataclass(slots=True)
+class StreamPacket:
+    version: int
+    event: memoryview | bytes
+    message: memoryview | bytes
+    stream_id: memoryview | bytes | None
+
+    @property
+    def event_bytes(self) -> bytes:
+        return (
+            self.event.tobytes() if isinstance(self.event, memoryview) else self.event
+        )
+
+    @property
+    def message_bytes(self) -> bytes:
+        return (
+            self.message.tobytes()
+            if isinstance(self.message, memoryview)
+            else self.message
+        )
+
+    @property
+    def resumable(self) -> bool:
+        return self.stream_id is not None
+
+    @property
+    def stream_id_bytes(self) -> bytes | None:
+        if self.stream_id is None:
+            return None
+        if isinstance(self.stream_id, bytes):
+            return self.stream_id
+        return self.stream_id.tobytes()
+
+
+class StreamCodec:
+    """Codec for encoding and decoding stream packets."""
+
+    __slots__ = ("_version",)
+
+    def __init__(self, *, protocol_version: int = PROTOCOL_VERSION) -> None:
+        self._version = protocol_version & BYTE_MASK
+
+    def encode(
+        self,
+        event: str,
+        message: bytes,
+        *,
+        stream_id: str | None = None,
+    ) -> bytes:
+        if not event:
+            raise StreamFormatError("event cannot be empty")
+        event_bytes = event.encode("utf-8")
+        if len(event_bytes) > 0xFFFF:
+            raise StreamFormatError("event exceeds 65535 bytes; cannot encode")
+        if not event_bytes:
+            raise StreamFormatError("event cannot be empty")
+
+        if stream_id:
+            # It's a resumable stream
+            stream_id_bytes = stream_id.encode("utf-8")
+            if len(stream_id_bytes) > 0xFFFF:
+                raise StreamFormatError("stream_id exceeds 65535 bytes; cannot encode")
+        else:
+            stream_id_bytes = None
+        stream_id_len = len(stream_id_bytes) if stream_id_bytes else 0
+        event_len = len(event_bytes)
+        frame = bytearray(HEADER_LEN + stream_id_len + event_len + len(message))
+        frame[0] = self._version
+        frame[1:3] = stream_id_len.to_bytes(2, "big")
+        frame[3:5] = event_len.to_bytes(2, "big")
+
+        cursor = HEADER_LEN
+        if stream_id_bytes is not None:
+            frame[cursor : cursor + stream_id_len] = stream_id_bytes
+            cursor += stream_id_len
+
+        frame[cursor : cursor + event_len] = event_bytes
+        cursor += event_len
+        frame[cursor:] = message
+        return bytes(frame)
+
+    def decode(self, data: bytes | bytearray | memoryview) -> StreamPacket:
+        view = data if isinstance(data, memoryview) else memoryview(data)
+        if len(view) < HEADER_LEN:
+            raise StreamFormatError("frame too short")
+
+        version = view[0]
+        if version != self._version:
+            raise StreamFormatError(f"unsupported protocol version: {version}")
+
+        stream_id_len = int.from_bytes(view[1:3], "big")
+        event_len = int.from_bytes(view[3:5], "big")
+        if event_len == 0:
+            raise StreamFormatError("event cannot be empty")
+        offset = HEADER_LEN
+        if stream_id_len > 0:
+            stream_id_view = view[offset : offset + stream_id_len]
+            offset += stream_id_len
+        else:
+            # Not resumable
+            stream_id_view = None
+        if len(view) < offset + event_len:
+            raise StreamFormatError("truncated event payload")
+        event_view = view[offset : offset + event_len]
+        offset += event_len
+        message_view = view[offset:]
+        return StreamPacket(
+            version=version,
+            event=event_view,
+            message=message_view,
+            stream_id=stream_id_view,
+        )
+
+    def decode_safe(self, data: bytes | bytearray | memoryview) -> StreamPacket | None:
+        try:
+            return self.decode(data)
+        except StreamFormatError as e:
+            logger.warning(f"Failed to decode as version {self._version}", error=e)
+            return None
+
+
+STREAM_CODEC = StreamCodec()
+
+
+def decode_stream_message(
+    data: bytes | bytearray | memoryview,
+    *,
+    channel: bytes | str | None = None,
+) -> StreamPacket:
+    if isinstance(data, memoryview):
+        view = data
+    elif isinstance(data, (bytes, bytearray)):
+        view = memoryview(data)
+    else:
+        logger.warning("Unknown type for stream message", type=type(data))
+        view = memoryview(bytes(data))
+
+    # Current protocol version
+    if packet := STREAM_CODEC.decode_safe(view):
+        return packet
+    logger.debug("Attempting to decode a v0 formatted stream message")
+    # Legacy codecs. Yuck. Won't be hit unless you have stale pods running (or for a brief period during upgrade).
+    # Schedule for removal in next major release.
+    if packet := _decode_v0_resumable_format(view, channel):
+        return packet
+
+    # Non-resumable format.
+    if packet := _decode_v0_live_format(view, channel):
+        return packet
+    raise StreamFormatError("failed to decode stream message")
+
+
+_STREAMING_DELIMITER = b"$:"
+_STREAMING_DELIMITER_LEN = len(_STREAMING_DELIMITER)
+
+
+def _decode_v0_resumable_format(
+    view: memoryview,
+    channel: bytes | str | None = None,
+) -> StreamPacket | None:
+    """
+    Legacy v0 resumable format:
+      1) b"$:" + <stream_id> + b"$:" + <event> + b"$:" + <raw_json>
+      2) b"$:" + <stream_id> + b"$:" + <raw_json>
+    """
+
+    # must start with "$:"
+    if (
+        len(view) < _STREAMING_DELIMITER_LEN
+        or view[:_STREAMING_DELIMITER_LEN] != _STREAMING_DELIMITER
+    ):
+        return None
+
+    # "$:<stream_id>$:"
+    first = _find_delim(view, _STREAMING_DELIMITER_LEN, _STREAMING_DELIMITER)
+    if first == -1:
+        return None
+    stream_view = view[_STREAMING_DELIMITER_LEN:first]
+
+    # try "$:<event>$:"
+    second = _find_delim(view, first + _STREAMING_DELIMITER_LEN, _STREAMING_DELIMITER)
+    if second != -1:
+        event_view = view[first + _STREAMING_DELIMITER_LEN : second]
+        msg_view = view[second + _STREAMING_DELIMITER_LEN :]
+        return StreamPacket(
+            version=0,
+            event=event_view,
+            message=msg_view,
+            stream_id=stream_view,
+        )
+
+    chan_bytes = channel.encode("utf-8") if isinstance(channel, str) else channel
+
+    if chan_bytes:
+        marker = b":stream:"
+        idx = chan_bytes.rfind(marker)
+        event_bytes = chan_bytes[idx + len(marker) :] if idx != -1 else chan_bytes
+    else:
+        event_bytes = b""
+
+    msg_view = view[first + _STREAMING_DELIMITER_LEN :]
+    return StreamPacket(
+        version=0,
+        event=memoryview(event_bytes),
+        message=msg_view,
+        stream_id=stream_view,
+    )
+
+
+def _decode_v0_live_format(
+    view: memoryview, channel: bytes | str | None = None
+) -> StreamPacket | None:
+    try:
+        package = orjson.loads(view)
+    except orjson.JSONDecodeError:
+        return _decode_v0_flat_format(view, channel)
+    if (
+        not isinstance(package, dict)
+        or "event" not in package
+        or "message" not in package
+    ):
+        return _decode_v0_flat_format(view, channel)
+    event_obj = package.get("event")
+    message_obj = package.get("message")
+    if event_obj is None:
+        event_bytes = b""
+    elif isinstance(event_obj, str):
+        event_bytes = event_obj.encode()
+    elif isinstance(event_obj, (bytes, bytearray, memoryview)):
+        event_bytes = bytes(event_obj)
+    else:
+        event_bytes = orjson.dumps(event_obj)
+
+    if isinstance(message_obj, (bytes, bytearray, memoryview)):
+        message_view = memoryview(bytes(message_obj))
+    elif isinstance(message_obj, str):
+        try:
+            message_view = memoryview(base64.b64decode(message_obj))
+        except Exception:
+            message_view = memoryview(message_obj.encode())
+    elif message_obj is None:
+        message_view = memoryview(b"")
+    else:
+        message_view = memoryview(orjson.dumps(message_obj))
+
+    return StreamPacket(
+        event=event_bytes,
+        message=message_view,
+        stream_id=None,
+        version=0,
+    )
+
+
+def _decode_v0_flat_format(
+    view: memoryview, channel: bytes | str | None = None
+) -> StreamPacket | None:
+    packet = bytes(view)
+    stream_id = None
+    if channel is None:
+        return
+    if packet.startswith(b"$:"):
+        _, stream_id, packet = packet.split(b":", 2)
+    channel = channel.encode("utf-8") if isinstance(channel, str) else channel
+    channel = channel.split(b":")[-1]
+    return StreamPacket(
+        version=0,
+        event=memoryview(channel),
+        message=memoryview(packet),
+        stream_id=stream_id,
+    )
+
+
+def _find_delim(view: memoryview, start: int, delimiter: bytes) -> int:
+    delim_len = len(delimiter)
+    end = len(view) - delim_len
+    i = start
+    while i <= end:
+        if view[i : i + delim_len] == delimiter:
+            return i
+        i += 1
+    return -1

{langgraph_api-0.4.21 → langgraph_api-0.4.23}/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
     "cryptography>=42.0.0,<45.0",
     "langgraph-sdk>=0.2.0",
     "cloudpickle>=3.0.0",
-    "langgraph-runtime-inmem>=0.12.1,<0.13.0",
+    "langgraph-runtime-inmem>=0.14.0,<0.15.0",
     "truststore>=0.1",
 ]
 

langgraph_api-0.4.21/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.21"