langgraph-api 0.4.22__tar.gz → 0.4.24__tar.gz

{langgraph_api-0.4.22 → langgraph_api-0.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.22
+Version: 0.4.24
 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.14.0,>=0.13.0
+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.24/healthcheck.py

@@ -0,0 +1,48 @@
+import json
+import os
+import urllib.request
+from ipaddress import IPv6Address, ip_address
+
+
+def get_healthcheck_host() -> str:
+    server_host = os.environ.get("LANGGRAPH_SERVER_HOST", "0.0.0.0")
+    if server_host in (
+        "0.0.0.0",  # IPv4 wildcard
+        "",  # IPv4/IPv6 dual-stack
+    ):
+        return "localhost"
+
+    try:
+        server_host_ip = ip_address(server_host)
+    except ValueError:
+        return server_host
+
+    return (
+        f"[{server_host_ip.compressed}]"
+        if isinstance(server_host_ip, IPv6Address)
+        else server_host_ip.compressed
+    )
+
+
+def healthcheck():
+    host = get_healthcheck_host()
+
+    prefix = ""
+    mount_prefix = None
+    # Override prefix if it's set in the http config
+    if (http := os.environ.get("LANGGRAPH_HTTP")) and (
+        mount_prefix := json.loads(http).get("mount_prefix")
+    ):
+        prefix = mount_prefix
+    # Override that
+    if os.environ.get("MOUNT_PREFIX"):
+        prefix = os.environ["MOUNT_PREFIX"]
+
+    with urllib.request.urlopen(
+        f"http://{host}:{os.environ['PORT']}{prefix}/ok"
+    ) as response:
+        assert response.status == 200
+
+
+if __name__ == "__main__":
+    healthcheck()

langgraph_api-0.4.24/langgraph_api/__init__.py

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

{langgraph_api-0.4.22 → langgraph_api-0.4.24}/langgraph_api/api/a2a.py

@@ -33,6 +33,9 @@ logger = structlog.stdlib.get_logger(__name__)
 # Cache for assistant schemas (assistant_id -> schemas dict)
 _assistant_schemas_cache = LRUCache[dict[str, Any]](max_size=1000, ttl=60)
 
+MAX_HISTORY_LENGTH_REQUESTED = 10
+LANGGRAPH_HISTORY_QUERY_LIMIT = 500
+
 
 # ============================================================================
 # JSON-RPC 2.0 Base Types (shared with MCP)
@@ -99,12 +102,11 @@ def _client() -> LangGraphClient:
 
 
 async def _get_assistant(
-    client: LangGraphClient, assistant_id: str, headers: Headers | dict[str, Any] | None
+    assistant_id: str, headers: Headers | dict[str, Any] | None
 ) -> dict[str, Any]:
     """Get assistant with proper 404 error handling.
 
     Args:
-        client: LangGraph client
         assistant_id: The assistant ID to get
         headers: Request headers
 
@@ -115,7 +117,7 @@ async def _get_assistant(
         ValueError: If assistant not found or other errors
     """
     try:
-        return await client.assistants.get(assistant_id, headers=headers)
+        return await get_client().assistants.get(assistant_id, headers=headers)
     except Exception as e:
         if (
             hasattr(e, "response")
@@ -127,7 +129,6 @@ async def _get_assistant(
 
 
 async def _validate_supports_messages(
-    client: LangGraphClient,
     assistant: dict[str, Any],
     headers: Headers | dict[str, Any] | None,
     parts: list[dict[str, Any]],
@@ -138,7 +139,6 @@ async def _validate_supports_messages(
     If the parts only contain data parts, no validation is performed.
 
     Args:
-        client: LangGraph client
         assistant: The assistant dictionary
         headers: Request headers
         parts: The original A2A message parts
@@ -156,7 +156,9 @@ async def _validate_supports_messages(
         schemas = cached_schemas
     else:
         try:
-            schemas = await client.assistants.get_schemas(assistant_id, headers=headers)
+            schemas = await get_client().assistants.get_schemas(
+                assistant_id, headers=headers
+            )
             _assistant_schemas_cache.set(assistant_id, schemas)
         except Exception as e:
             raise ValueError(
@@ -505,10 +507,50 @@ def _map_runs_get_error_to_rpc(
     }
 
 
-def _create_task_response(
+def _convert_messages_to_a2a_format(
+    messages: list[dict[str, Any]],
+    task_id: str,
+    context_id: str,
+) -> list[dict[str, Any]]:
+    """Convert LangChain messages to A2A message format.
+
+    Args:
+        messages: List of LangChain messages
+        task_id: The task ID to assign to all messages
+        context_id: The context ID to assign to all messages
+
+    Returns:
+        List of A2A messages
+    """
+
+    # Convert each LangChain message to A2A format
+    a2a_messages = []
+    for msg in messages:
+        if isinstance(msg, dict):
+            msg_type = msg.get("type", "ai")
+            msg_role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            # Support both LangChain style (type: "human"/"ai") and OpenAI style (role: "user"/"assistant")
+            # Map to A2A roles: "human"/"user" -> "user", everything else -> "agent"
+            a2a_role = "user" if msg_type == "human" or msg_role == "user" else "agent"
+
+            a2a_message = {
+                "role": a2a_role,
+                "parts": [{"kind": "text", "text": str(content)}],
+                "messageId": str(uuid.uuid4()),
+                "taskId": task_id,
+                "contextId": context_id,
+                "kind": "message",
+            }
+            a2a_messages.append(a2a_message)
+
+    return a2a_messages
+
+
+async def _create_task_response(
     task_id: str,
     context_id: str,
-    message: dict[str, Any],
     result: dict[str, Any],
     assistant_id: str,
 ) -> dict[str, Any]:
@@ -520,16 +562,19 @@ def _create_task_response(
         message: Original A2A message from request
         result: LangGraph execution result
         assistant_id: The assistant ID used
+        headers: Request headers
 
     Returns:
         A2A Task response dictionary
     """
+    # Convert result messages to A2A message format
+    messages = result.get("messages", []) or []
+    thread_history = _convert_messages_to_a2a_format(messages, task_id, context_id)
+
     base_task = {
         "id": task_id,
         "contextId": context_id,
-        "history": [
-            {**message, "taskId": task_id, "contextId": context_id, "kind": "message"}
-        ],
+        "history": thread_history,
         "kind": "task",
     }
 
@@ -796,8 +841,8 @@ async def handle_message_send(
             }
 
         try:
-            assistant = await _get_assistant(client, assistant_id, request.headers)
-            await _validate_supports_messages(client, assistant, request.headers, parts)
+            assistant = await _get_assistant(assistant_id, request.headers)
+            await _validate_supports_messages(assistant, request.headers, parts)
         except ValueError as e:
             return {
                 "error": {
@@ -822,6 +867,10 @@ async def handle_message_send(
 
         context_id = message.get("contextId")
 
+        # If no contextId provided, generate a UUID so we don't pass None to runs.create
+        if context_id is None:
+            context_id = str(uuid.uuid4())
+
         try:
             run = await client.runs.create(
                 thread_id=context_id,
@@ -845,10 +894,9 @@ async def handle_message_send(
         task_id = run["run_id"]
         context_id = run["thread_id"]
 
-        return _create_task_response(
+        return await _create_task_response(
             task_id=task_id,
             context_id=context_id,
-            message=message,
             result=result,
             assistant_id=assistant_id,
         )
@@ -863,6 +911,37 @@ async def handle_message_send(
         }
 
 
+async def _get_historical_messages_for_task(
+    context_id: str,
+    task_run_id: str,
+    request_headers: Headers,
+    history_length: int | None = None,
+) -> list[Any]:
+    """Get historical messages for a specific task by matching run_id."""
+    history = await get_client().threads.get_history(
+        context_id,
+        limit=LANGGRAPH_HISTORY_QUERY_LIMIT,
+        metadata={"run_id": task_run_id},
+        headers=request_headers,
+    )
+
+    if history:
+        # Find the checkpoint with the highest step number (final state for this task)
+        target_checkpoint = max(
+            history, key=lambda c: c.get("metadata", {}).get("step", 0)
+        )
+        values = target_checkpoint["values"]
+        messages = values.get("messages", [])
+
+        # Apply client-requested history length limit per A2A spec
+        if history_length is not None and len(messages) > history_length:
+            # Return the most recent messages up to the limit
+            messages = messages[-history_length:]
+        return messages
+    else:
+        return []
+
+
 async def handle_tasks_get(
     request: ApiRequest, params: dict[str, Any]
 ) -> dict[str, Any]:
@@ -885,6 +964,7 @@ async def handle_tasks_get(
     try:
         task_id = params.get("id")
         context_id = params.get("contextId")
+        history_length = params.get("historyLength")
 
         if not task_id:
             return {
@@ -902,6 +982,23 @@ async def handle_tasks_get(
                 }
             }
 
+        # Validate history_length parameter per A2A spec
+        if history_length is not None:
+            if not isinstance(history_length, int) or history_length < 0:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_INVALID_PARAMS,
+                        "message": "historyLength must be a non-negative integer",
+                    }
+                }
+            if history_length > MAX_HISTORY_LENGTH_REQUESTED:
+                return {
+                    "error": {
+                        "code": ERROR_CODE_INVALID_PARAMS,
+                        "message": f"historyLength cannot exceed {MAX_HISTORY_LENGTH_REQUESTED}",
+                    }
+                }
+
         try:
             run_info = await client.runs.get(
                 thread_id=context_id,
@@ -919,7 +1016,7 @@ async def handle_tasks_get(
         if assistant_id:
             try:
                 # Verify that the assistant exists
-                await _get_assistant(client, assistant_id, request.headers)
+                await _get_assistant(assistant_id, request.headers)
             except ValueError as e:
                 return {
                     "error": {
@@ -941,10 +1038,24 @@ async def handle_tasks_get(
         else:
             a2a_state = "submitted"
 
+        try:
+            task_run_id = run_info.get("run_id")
+            messages = await _get_historical_messages_for_task(
+                context_id, task_run_id, request.headers, history_length
+            )
+            thread_history = _convert_messages_to_a2a_format(
+                messages, task_id, context_id
+            )
+        except Exception as e:
+            await logger.aexception(f"Failed to get thread state for tasks/get: {e}")
+            thread_history = []
+
         # Build the A2A Task response
         task_response = {
             "id": task_id,
             "contextId": context_id,
+            "history": thread_history,
+            "kind": "task",
             "status": {
                 "state": a2a_state,
             },
@@ -1033,7 +1144,7 @@ async def generate_agent_card(request: ApiRequest, assistant_id: str) -> dict[st
     """
     client = _client()
 
-    assistant = await _get_assistant(client, assistant_id, request.headers)
+    assistant = await _get_assistant(assistant_id, request.headers)
     schemas = await client.assistants.get_schemas(assistant_id, headers=request.headers)
 
     # Extract schema information for metadata
@@ -1212,10 +1323,8 @@ async def handle_message_stream(
                 return
 
             try:
-                assistant = await _get_assistant(client, assistant_id, request.headers)
-                await _validate_supports_messages(
-                    client, assistant, request.headers, parts
-                )
+                assistant = await _get_assistant(assistant_id, request.headers)
+                await _validate_supports_messages(assistant, request.headers, parts)
             except ValueError as e:
                 yield (
                     b"message",

{langgraph_api-0.4.22 → langgraph_api-0.4.24}/langgraph_api/queue_entrypoint.py

@@ -81,7 +81,7 @@ async def health_and_metrics_server():
 
     config = uvicorn.Config(
         app,
-        host="0.0.0.0",
+        host=os.getenv("LANGGRAPH_SERVER_HOST", "0.0.0.0"),
         port=port,
         log_level="error",
         access_log=False,

{langgraph_api-0.4.22 → langgraph_api-0.4.24}/langgraph_api/stream.py

@@ -317,9 +317,11 @@ async def astream_state(
                                     else "messages/complete"
                                 ),
                                 [
-                                    message_chunk_to_message(messages[msg.id])
-                                    if not is_chunk
-                                    else messages[msg.id]
+                                    (
+                                        message_chunk_to_message(messages[msg.id])
+                                        if not is_chunk
+                                        else messages[msg.id]
+                                    )
                                 ],
                             )
                     elif mode in stream_mode:
@@ -379,6 +381,7 @@ async def astream_state(
                     elif chunk["type"] == "task_result":
                         on_task_result(chunk["payload"])
                 if mode == "messages":
+                    logger.warning("EVENT BRO", stream_event=event)
                     if "messages-tuple" in stream_mode:
                         if subgraphs and ns:
                             yield f"messages|{'|'.join(ns)}", chunk
@@ -410,6 +413,14 @@ async def astream_state(
                         else:
                             messages[msg.id] = msg
                             yield "messages/metadata", {msg.id: {"metadata": meta}}
+                        print(
+                            "YIELDING",
+                            msg.id,
+                            type(msg),
+                            is_chunk,
+                            isinstance(msg, BaseMessageChunk),
+                            msg,
+                        )
                         yield (
                             (
                                 "messages/partial"
@@ -417,9 +428,11 @@ async def astream_state(
                                 else "messages/complete"
                             ),
                             [
-                                message_chunk_to_message(messages[msg.id])
-                                if not is_chunk
-                                else messages[msg.id]
+                                (
+                                    message_chunk_to_message(messages[msg.id])
+                                    if not is_chunk
+                                    else messages[msg.id]
+                                )
                             ],
                         )
                 elif mode in stream_mode:

langgraph_api-0.4.24/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.22 → langgraph_api-0.4.24}/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.13.0,<0.14.0",
+    "langgraph-runtime-inmem>=0.14.0,<0.15.0",
     "truststore>=0.1",
 ]
 

langgraph_api-0.4.22/healthcheck.py

@@ -1,19 +0,0 @@
-import json
-import os
-import urllib.request
-
-prefix = ""
-mount_prefix = None
-# Override prefix if it's set in the http config
-if (http := os.environ.get("LANGGRAPH_HTTP")) and (
-    mount_prefix := json.loads(http).get("mount_prefix")
-):
-    prefix = mount_prefix
-# Override that
-if os.environ.get("MOUNT_PREFIX"):
-    prefix = os.environ["MOUNT_PREFIX"]
-
-with urllib.request.urlopen(
-    f"http://localhost:{os.environ['PORT']}{prefix}/ok"
-) as response:
-    assert response.status == 200

langgraph_api-0.4.22/langgraph_api/__init__.py

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