workers-runtime-sdk 1.6.8__tar.gz → 1.6.10__tar.gz

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 <!-- version list -->
 
+## v1.6.10 (2026-08-10)
+
+### Bug Fixes
+
+- **runtime-sdk**: Terminate the response stream when the app fails mid-stream
+  ([#168](https://github.com/cloudflare/workers-py/pull/168),
+  [`fd4dde9`](https://github.com/cloudflare/workers-py/commit/fd4dde98fcc39f405a7cf320a6db49a83426f46b))
+
+
+## v1.6.9 (2026-08-10)
+
+### Bug Fixes
+
+- **runtime-sdk**: Deliver binary WebSocket frames as ASGI `bytes`
+  ([#164](https://github.com/cloudflare/workers-py/pull/164),
+  [`44ca368`](https://github.com/cloudflare/workers-py/commit/44ca36818367af23ffd0c76f5d2dc7588219b340))
+
+
 ## v1.6.8 (2026-08-05)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workers-runtime-sdk
-Version: 1.6.8
+Version: 1.6.10
 Summary: Python SDK for Cloudflare Workers
 Project-URL: Homepage, https://github.com/cloudflare/workers-py
 Project-URL: Bug Tracker, https://github.com/cloudflare/workers-py/issues

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.6.8"
+version = "1.6.10"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/src/asgi.py

@@ -28,6 +28,13 @@ def run_in_background(coro: Awaitable[Any]) -> None:
     fut.add_done_callback(_on_done)
 
 
+async def close_stream_quietly(writer):
+    try:
+        await writer.close()
+    except Exception:
+        logger.debug("Closing the response stream failed", exc_info=True)
+
+
 @contextmanager
 def acquire_js_buffer(pybuffer):
     from pyodide.ffi import create_proxy
@@ -182,6 +189,7 @@ async def process_request(
 
     # Streaming state — initialized lazily on first body chunk with more_body=True.
     writer = None
+    writer_closed = False
 
     receive_queue = Queue()
     if req.body:
@@ -208,6 +216,7 @@ async def process_request(
         nonlocal status
         nonlocal headers
         nonlocal writer
+        nonlocal writer_closed
 
         if got["type"] == "http.response.start":
             status = got["status"]
@@ -224,6 +233,7 @@ async def process_request(
                     await writer.write(jsbytes.slice())
                 if not more_body:
                     await writer.close()
+                    writer_closed = True
                     finished_response.set()
             elif more_body:
                 # First body chunk with more data coming — switch to streaming.
@@ -275,6 +285,15 @@ async def process_request(
                 # Response already sent — exception can't be propagated to the
                 # client, so log it to avoid silently swallowing errors.
                 logger.exception("Exception in ASGI application after response started")
+                finished_response.set()
+                if writer is not None and not writer_closed:
+                    # End the body so a client reading it sees the stream stop
+                    # instead of waiting forever for chunks that will never
+                    # come. Deliberately not awaited: close() settles only once
+                    # the queued chunks reach a consumer, so a response body
+                    # that nobody reads would block this task, which the
+                    # runtime is waiting on through wait_until.
+                    run_in_background(close_stream_quietly(writer))
 
     # Create task to run the application in the background
     app_task = create_proxy(create_task(run_app()))
@@ -294,6 +313,9 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
 
     client, server = WebSocketPair.new().object_values()
     server.accept()
+    # Binary frames otherwise arrive as Blob (observed under wrangler dev),
+    # which cannot be read synchronously in the message callback.
+    server.binaryType = "arraybuffer"
     queue = Queue()
 
     def onopen(evt):
@@ -312,7 +334,14 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
         queue.put_nowait(msg)
 
     def onmessage(evt):
-        msg = {"type": "websocket.receive", "text": evt.data}
+        data = evt.data
+        if isinstance(data, str):
+            msg = {"type": "websocket.receive", "text": data}
+        else:
+            # Binary frames arrive as an ArrayBuffer; the ASGI spec requires
+            # them under "bytes" (frameworks like Starlette dispatch on which
+            # key is present, so labeling them "text" breaks receive_bytes()).
+            msg = {"type": "websocket.receive", "bytes": data.to_bytes()}
         queue.put_nowait(msg)
 
     server.onopen = onopen

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/tests/web-frameworks-test/django-async/pyproject.toml

@@ -3,7 +3,9 @@ name = "django-async-test"
 version = "0.1.0"
 requires-python = ">=3.12"
 dependencies = [
-    "django",
+    # https://github.com/django/django/pull/21438/changes#r3399119797
+    # Remove this constraint when drf releases a version that supports Django 6.1
+    "django<6.1",
     "djangorestframework",
     "django-cors-headers",
     "pytest",

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/tests/workerd-test/asgi/tests/test_asgi.py

@@ -399,3 +399,16 @@ async def test_scope_path_is_percent_decoded():
 async def test_scope_exposes_raw_path():
     scope = await _scope("/scope/hello%20world")
     assert scope["raw_path"] == "/scope/hello%20world"
+
+
+@pytest.mark.asyncio
+async def test_late_stream_failure_terminates_response():
+    # An app that raises after the streaming response started must terminate
+    # the stream (truncated EOF) instead of leaving the client hanging; a
+    # regression here surfaces as a timeout or workerd's hung-request
+    # cancellation instead of a clean read.
+    response = await asyncio.wait_for(
+        env.SELF.fetch("http://example.com/stream-late-failure"), timeout=5
+    )
+    body = await asyncio.wait_for(response.text(), timeout=5)
+    assert body == "chunk-1"

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/tests/workerd-test/asgi/worker.py

@@ -182,6 +182,29 @@ class StreamingApp:
 # ---------------------------------------------------------------------------
 
 
+class LateFailureStreamApp:
+    """Starts a streaming response, then raises: the stream must terminate."""
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "lifespan":
+            message = await receive()
+            if message["type"] == "lifespan.startup":
+                await send({"type": "lifespan.startup.complete"})
+            return
+        await receive()
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": [(b"content-type", b"application/octet-stream")],
+            }
+        )
+        await send(
+            {"type": "http.response.body", "body": b"chunk-1", "more_body": True}
+        )
+        raise RuntimeError("app failed mid-stream")
+
+
 class ScopeEchoApp:
     """Echoes selected scope fields as JSON so tests can inspect them."""
 
@@ -214,6 +237,7 @@ app = HeaderEchoApp()
 sse_app = SSEApp()
 streaming_app = StreamingApp()
 scope_echo_app = ScopeEchoApp()
+late_failure_stream_app = LateFailureStreamApp()
 
 example_hdr = {"Header1": "Value1", "Header2": "Value2"}
 
@@ -231,6 +255,10 @@ class Default(WorkerEntrypoint):
             return await asgi.fetch(streaming_app, request, self.env, self.ctx)
         elif path.startswith("/scope"):
             return await asgi.fetch(scope_echo_app, request, self.env, self.ctx)
+        elif path == "/stream-late-failure":
+            return await asgi.fetch(
+                late_failure_stream_app, request, self.env, self.ctx
+            )
 
         return await asgi.fetch(app, request, self.env, self.ctx)
 

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/tests/workerd-test/asgi-ws-disconnect/tests/test_ws_disconnect.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 
 import pytest
 from pyodide.ffi import create_proxy, to_js
@@ -70,3 +71,45 @@ async def test_client_close_reaches_app_as_disconnect():
             return
         await asyncio.sleep(0.2)
     pytest.fail("the app never observed the client's disconnect")
+
+
+@contextlib.asynccontextmanager
+async def _ws_session(path):
+    """Accepted client socket, always closed again.
+
+    A test that raises before closing leaves the app awaiting receive(), and
+    the runtime keeps the request alive for that task, so the whole worker
+    invocation hangs instead of reporting the failure.
+    """
+    response = await _ws_connect(path)
+    ws = response.webSocket
+    assert ws is not None
+    ws.accept()
+    # Without this the payload arrives as a Blob, which cannot be read
+    # synchronously in the message callback.
+    ws.binaryType = "arraybuffer"
+    try:
+        yield ws
+    finally:
+        ws.close()
+
+
+@pytest.mark.asyncio
+async def test_text_frame_arrives_as_asgi_text():
+    async with _ws_session("/ws-echo") as ws:
+        message = _listen(ws, "message")
+        ws.send("hello")
+        evt = await asyncio.wait_for(message, TIMEOUT_S)
+        assert evt.data == "text=hello"
+
+
+@pytest.mark.asyncio
+async def test_binary_frame_arrives_as_asgi_bytes():
+    async with _ws_session("/ws-echo") as ws:
+        message = _listen(ws, "message")
+        payload = b"\x00\x01binary"
+        ws.send(to_js(payload))
+        evt = await asyncio.wait_for(message, TIMEOUT_S)
+        data = evt.data
+        assert not isinstance(data, str), f"delivered to the app as text: {data!r}"
+        assert data.to_bytes() == b"bytes=" + payload

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/tests/workerd-test/asgi-ws-disconnect/worker.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 import sys
+from urllib.parse import urlsplit
 
 import pytest
 from pyodide.webloop import WebLoop
@@ -49,13 +50,46 @@ class WSWatchApp:
                 return
 
 
+class WSEchoApp:
+    """Accepts and echoes each frame back tagged with the ASGI key it arrived
+    under ("bytes=" / "text=" prefix), so tests can detect frames delivered
+    under the wrong key (an untagged echo would bounce a mislabeled frame
+    opaquely and pass anyway)."""
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "lifespan":
+            await _drain_lifespan(receive, send)
+            return
+        message = await receive()
+        assert message["type"] == "websocket.connect"
+        await send({"type": "websocket.accept"})
+        while True:
+            message = await receive()
+            if message["type"] == "websocket.disconnect":
+                return
+            if message.get("bytes") is not None:
+                await send(
+                    {"type": "websocket.send", "bytes": b"bytes=" + message["bytes"]}
+                )
+            else:
+                text = message.get("text")
+                # text is always str once frames are labeled correctly; repr()
+                # keeps a regression readable instead of timing out on a
+                # TypeError inside the app.
+                reply = "text=" + (text if isinstance(text, str) else repr(text))
+                await send({"type": "websocket.send", "text": reply})
+
+
 ws_app = WSWatchApp()
+echo_app = WSEchoApp()
 
 
 class Default(WorkerEntrypoint):
     async def fetch(self, request):
         if (request.headers.get("upgrade") or "").lower() == "websocket":
-            return await asgi.websocket(ws_app, request)
+            path = urlsplit(request.url).path
+            app = echo_app if path == "/ws-echo" else ws_app
+            return await asgi.websocket(app, request)
         import json
 
         from workers import Response

{workers_runtime_sdk-1.6.8 → workers_runtime_sdk-1.6.10}/uv.lock

@@ -345,7 +345,7 @@ wheels = [
 
 [[package]]
 name = "workers-runtime-sdk"
-version = "1.6.8"
+version = "1.6.10"
 source = { editable = "." }
 
 [package.dev-dependencies]