workers-runtime-sdk 1.6.11__tar.gz → 1.6.13__tar.gz

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 <!-- version list -->
 
+## v1.6.13 (2026-08-12)
+
+### Bug Fixes
+
+- **runtime-sdk**: Preserve repeated response headers (multiple `Set-Cookie`)
+  ([#167](https://github.com/cloudflare/workers-py/pull/167),
+  [`f68bf6d`](https://github.com/cloudflare/workers-py/commit/f68bf6d622c896b6c61fe3c615d43d6e9b05d19b))
+
+
+## v1.6.12 (2026-08-11)
+
+### Bug Fixes
+
+- **runtime-sdk**: Send empty WebSocket frames instead of dropping them
+  ([#165](https://github.com/cloudflare/workers-py/pull/165),
+  [`a4128ce`](https://github.com/cloudflare/workers-py/commit/a4128cee402aa6f28f01e3e2268241d05d9fd393))
+
+
 ## v1.6.11 (2026-08-10)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: workers-runtime-sdk
-Version: 1.6.11
+Version: 1.6.13
 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.11 → workers_runtime_sdk-1.6.13}/pyproject.toml

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

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/src/asgi.py

@@ -8,6 +8,7 @@ from urllib.parse import unquote
 import js
 
 from workers import Context, Request
+from workers.utils import _to_js_headers
 
 ASGI = {"spec_version": "2.0", "version": "3.0"}
 NULL_BODY_STATUSES = frozenset({101, 103, 204, 205, 304})
@@ -179,7 +180,7 @@ async def process_request(
     # TODO(later): remove this parameter after unvendoring Python SDK from workerd
     ctx: Context | None,
 ) -> js.Response:
-    from js import Object, Response, TransformStream
+    from js import Response, TransformStream
     from pyodide.ffi import create_proxy
 
     status = None
@@ -221,6 +222,8 @@ async def process_request(
         if got["type"] == "http.response.start":
             status = got["status"]
             # Like above, we need to convert byte-pairs into string explicitly.
+            # A response header name may repeat (multiple Set-Cookie), so this
+            # must stay a sequence of pairs, not a name-keyed mapping.
             headers = [(k.decode(), v.decode()) for k, v in got.get("headers", [])]
 
         elif got["type"] == "http.response.body":
@@ -243,7 +246,7 @@ async def process_request(
                 readable = transform_stream.readable
                 writer = transform_stream.writable.getWriter()
                 resp = Response.new(
-                    readable, headers=Object.fromEntries(headers), status=status
+                    readable, headers=_to_js_headers(headers), status=status
                 )
                 result.set_result(resp)
                 with acquire_js_buffer(body) as jsbytes:
@@ -252,7 +255,7 @@ async def process_request(
                 # 101/103/204/205/304 must not carry a body per the Fetch spec.
                 # https://fetch.spec.whatwg.org/#null-body-status
                 resp = Response.new(
-                    None, headers=Object.fromEntries(headers), status=status
+                    None, headers=_to_js_headers(headers), status=status
                 )
                 result.set_result(resp)
                 finished_response.set()
@@ -262,7 +265,7 @@ async def process_request(
                 buf = px.getBuffer()
                 px.destroy()
                 resp = Response.new(
-                    buf.data, headers=Object.fromEntries(headers), status=status
+                    buf.data, headers=_to_js_headers(headers), status=status
                 )
                 result.set_result(resp)
                 finished_response.set()
@@ -352,12 +355,12 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
         if got["type"] == "websocket.send":
             b = got.get("bytes", None)
             s = got.get("text", None)
-            if b:
+            if b is not None:
                 with acquire_js_buffer(b) as jsbytes:
                     # Unlike the `Response` constructor,  server.send seems to
                     # eagerly copy the source buffer
                     server.send(jsbytes)
-            if s:
+            if s is not None:
                 server.send(s)
 
         else:

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/tests/web-frameworks-test/fastapi-tests/pyproject.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 requires-python = ">=3.12"
 dependencies = [
     "fastapi",
+    "python-multipart",
     "pytest",
     "pytest-asyncio<1.2.0",
 ]

workers_runtime_sdk-1.6.13/tests/web-frameworks-test/fastapi-tests/src/_client.py

@@ -0,0 +1,66 @@
+import json as _json
+
+import asgi
+from workers import Request
+
+BASE_URL = "http://testserver"
+
+
+def _with_content_length(headers, body):
+    """Ensure Content-Length is present when a body is provided."""
+    hdrs = dict(headers or {})
+    if body is not None and not any(k.lower() == "content-length" for k in hdrs):
+        length = len(body.encode() if isinstance(body, str) else body)
+        hdrs["Content-Length"] = str(length)
+    return hdrs
+
+
+async def fetch(app, path, env=None, method="GET", headers=None, body=None):
+    request = Request(
+        f"{BASE_URL}{path}",
+        method=method,
+        headers=_with_content_length(headers, body),
+        body=body,
+    )
+    return await asgi.fetch(app, request, env or {})
+
+
+async def read_json(response):
+    text = await response.text()
+    return _json.loads(text) if text else None
+
+
+async def get_json(app, path, **kwargs):
+    response = await fetch(app, path, **kwargs)
+    return response, await read_json(response)
+
+
+async def post_json(app, path, data, **kwargs):
+    return await fetch(
+        app,
+        path,
+        method="POST",
+        headers={"Content-Type": "application/json"},
+        body=_json.dumps(data),
+        **kwargs,
+    )
+
+
+def build_multipart(files, boundary="----WebTestBoundary"):
+    """Build a multipart/form-data body from a list of (name, filename, content) tuples."""
+    lines = []
+    for name, filename, content in files:
+        if isinstance(content, bytes):
+            content = content.decode()
+        lines.append(f"--{boundary}")
+        lines.append(
+            f'Content-Disposition: form-data; name="{name}"; filename="{filename}"'
+        )
+        lines.append("Content-Type: application/octet-stream")
+        lines.append("")
+        lines.append(content)
+    lines.append(f"--{boundary}--")
+    lines.append("")
+    body = "\r\n".join(lines)
+    content_type = f"multipart/form-data; boundary={boundary}"
+    return body, content_type

workers_runtime_sdk-1.6.13/tests/web-frameworks-test/fastapi-tests/src/test_sync_handlers.py

@@ -0,0 +1,128 @@
+"""Tests for FastAPI features that rely on anyio.to_thread.run_sync.
+
+The workers runtime is single-threaded, so ``anyio.to_thread.run_sync`` is
+patched to run the callable inline.  Without the patch every test in this file
+would fail with ``RuntimeError: can't start new thread``.
+
+Covered call-sites:
+- Sync ``def`` route handlers (``starlette.routing`` / ``fastapi.routing``)
+- Sync dependencies (``fastapi.dependencies.utils``)
+- Sync ``BackgroundTask`` (``starlette.background``)
+- Sync-iterator ``StreamingResponse`` (``starlette.concurrency.iterate_in_threadpool``)
+- ``UploadFile.read`` (``starlette.datastructures``)
+"""
+
+import pytest
+from _client import build_multipart, fetch, get_json, read_json
+
+# -- sync route handlers -----------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_sync_handler_returns_json(fastapi_app):
+    """A plain ``def`` route handler returns a JSON response."""
+    resp, data = await get_json(fastapi_app, "/sync/hello")
+    assert resp.status == 200
+    assert data["message"] == "sync hello"
+
+
+@pytest.mark.asyncio
+async def test_sync_post_handler(fastapi_app):
+    """A sync POST handler receives the request and responds."""
+    resp = await fetch(fastapi_app, "/sync/echo", method="POST", body="hi")
+    assert resp.status == 200
+    data = await read_json(resp)
+    assert data["method"] == "POST"
+
+
+# -- sync dependency ----------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_sync_dependency(fastapi_app):
+    """An async handler that depends on a sync ``def`` dependency."""
+    resp, data = await get_json(fastapi_app, "/sync/dep")
+    assert resp.status == 200
+    assert data["greeting"] == "hello from sync dep"
+
+
+# -- sync background task -----------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_sync_background_task(fastapi_app):
+    """A sync function passed to ``BackgroundTask`` runs to completion."""
+    resp, data = await get_json(fastapi_app, "/sync/background/run")
+    assert resp.status == 200
+    assert data["submitted"] is True
+
+    # The background task runs inline (patched), so by the time the response
+    # is fully sent the side-effect should already be visible.
+    resp2, data2 = await get_json(fastapi_app, "/sync/background/check")
+    assert resp2.status == 200
+    assert data2["bg_ran"] is True
+
+
+# -- sync-iterator streaming response ----------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_sync_streaming_response(fastapi_app):
+    """StreamingResponse backed by a sync generator delivers all chunks."""
+    resp = await fetch(fastapi_app, "/sync/stream")
+    assert resp.status == 200
+    body = await resp.text()
+    for i in range(5):
+        assert f"chunk-{i}" in body
+
+
+@pytest.mark.asyncio
+async def test_sync_streaming_content_type(fastapi_app):
+    """StreamingResponse preserves the declared media type."""
+    resp = await fetch(fastapi_app, "/sync/stream")
+    assert resp.status == 200
+    assert "text/plain" in resp.headers.get("content-type")
+
+
+# -- file upload (UploadFile) -------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_single_file_upload(fastapi_app):
+    """A single file upload is received and its content is echoed back."""
+    body, content_type = build_multipart([("file", "greet.txt", "hello world")])
+    resp = await fetch(
+        fastapi_app,
+        "/upload/single",
+        method="POST",
+        headers={"Content-Type": content_type},
+        body=body,
+    )
+    assert resp.status == 200
+    data = await read_json(resp)
+    assert data["filename"] == "greet.txt"
+    assert data["size"] > 0
+    assert "hello world" in data["text"]
+
+
+@pytest.mark.asyncio
+async def test_multiple_file_upload(fastapi_app):
+    """Multiple files are received and their metadata is echoed back."""
+    body, content_type = build_multipart(
+        [
+            ("files", "one.txt", "first"),
+            ("files", "two.txt", "second"),
+        ]
+    )
+    resp = await fetch(
+        fastapi_app,
+        "/upload/multiple",
+        method="POST",
+        headers={"Content-Type": content_type},
+        body=body,
+    )
+    assert resp.status == 200
+    data = await read_json(resp)
+    assert len(data) == 2
+    assert [f["filename"] for f in data] == ["one.txt", "two.txt"]
+    assert all(f["size"] > 0 for f in data)

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -3,11 +3,12 @@ import importlib.util
 from pathlib import Path
 
 import pytest
-from fastapi import FastAPI, Request
-from fastapi.responses import FileResponse
+from fastapi import Depends, FastAPI, File, Request, UploadFile
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from fastapi.responses import Response as FastAPIResponse
 from fastapi.staticfiles import StaticFiles
 from pyodide.webloop import WebLoop
+from starlette.background import BackgroundTask
 
 import asgi
 from workers import Response, WorkerEntrypoint
@@ -24,6 +25,16 @@ STATIC_DIR = Path(__file__).parent / "static"
 
 app = FastAPI()
 
+# --------------------------------------------------------------------------- #
+# Shared mutable state used to verify side-effects (e.g. background tasks).
+# --------------------------------------------------------------------------- #
+_side_effects: dict = {}
+
+
+# --------------------------------------------------------------------------- #
+# Routes exercising the anyio.to_thread.run_sync patch
+# --------------------------------------------------------------------------- #
+
 
 @app.get("/api/hello")
 async def api_hello():
@@ -35,6 +46,87 @@ async def health():
     return {"ok": True}
 
 
+# -- sync route handler (dispatched via run_in_threadpool) -------------------
+@app.get("/sync/hello")
+def sync_hello():
+    """A plain `def` (non-async) route handler."""
+    return {"message": "sync hello"}
+
+
+@app.post("/sync/echo")
+def sync_echo(request: Request):
+    """Sync POST handler that reads the body."""
+    # request.body() is async; the sync handler can still return a dict.
+    return {"method": request.method}
+
+
+# -- sync dependency ---------------------------------------------------------
+def _get_greeting():
+    """A plain `def` dependency (not async)."""
+    return "hello from sync dep"
+
+
+@app.get("/sync/dep")
+async def sync_dep_route(greeting: str = Depends(_get_greeting)):
+    """Async handler with a sync dependency."""
+    return {"greeting": greeting}
+
+
+# -- sync background task ----------------------------------------------------
+def _bg_task():
+    """Sync function executed as a BackgroundTask."""
+    _side_effects["bg_ran"] = True
+
+
+@app.get("/sync/background/run")
+async def sync_background_run():
+    """Fire a sync background task and return immediately."""
+    _side_effects.pop("bg_ran", None)
+    return JSONResponse({"submitted": True}, background=BackgroundTask(_bg_task))
+
+
+@app.get("/sync/background/check")
+async def sync_background_check():
+    """Return whether the background task has executed."""
+    return {"bg_ran": _side_effects.get("bg_ran", False)}
+
+
+# -- sync iterator streaming response ---------------------------------------
+def _sync_chunks():
+    """A plain generator (not async) yielding text chunks."""
+    for i in range(5):
+        yield f"chunk-{i}\n"
+
+
+@app.get("/sync/stream")
+async def sync_stream():
+    """StreamingResponse backed by a sync iterator."""
+    return StreamingResponse(_sync_chunks(), media_type="text/plain")
+
+
+# -- file upload (UploadFile.read/write/seek go through run_in_threadpool) ---
+@app.post("/upload/single")
+async def upload_single(file: UploadFile = File(...)):  # noqa: B008
+    """Accept a single file upload and echo its metadata + content."""
+    content = await file.read()
+    return {
+        "filename": file.filename,
+        "content_type": file.content_type,
+        "size": len(content),
+        "text": content.decode(errors="replace"),
+    }
+
+
+@app.post("/upload/multiple")
+async def upload_multiple(files: list[UploadFile] = File(...)):  # noqa: B008
+    """Accept multiple file uploads and echo their metadata."""
+    result = []
+    for f in files:
+        data = await f.read()
+        result.append({"filename": f.filename, "size": len(data)})
+    return result
+
+
 @app.get("/native-file")
 async def native_file():
     """Serve a single bundled file with FastAPI's native FileResponse."""

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/tests/workerd-test/asgi/tests/test_asgi.py

@@ -412,3 +412,12 @@ async def test_late_stream_failure_terminates_response():
     )
     body = await asyncio.wait_for(response.text(), timeout=5)
     assert body == "chunk-1"
+
+
+@pytest.mark.asyncio
+async def test_multiple_set_cookie_headers_survive():
+    response = await env.SELF.fetch("http://example.com/multi-cookie")
+    assert response.headers.get_all("set-cookie") == [
+        "first=1; Path=/",
+        "second=2; Path=/",
+    ]

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/tests/workerd-test/asgi/worker.py

@@ -233,11 +233,35 @@ class ScopeEchoApp:
         await send({"type": "http.response.body", "body": body})
 
 
+class MultiCookieApp:
+    """Sends two Set-Cookie headers; both must reach the client."""
+
+    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"set-cookie", b"first=1; Path=/"),
+                    (b"set-cookie", b"second=2; Path=/"),
+                ],
+            }
+        )
+        await send({"type": "http.response.body", "body": b"ok"})
+
+
 app = HeaderEchoApp()
 sse_app = SSEApp()
 streaming_app = StreamingApp()
 scope_echo_app = ScopeEchoApp()
 late_failure_stream_app = LateFailureStreamApp()
+multi_cookie_app = MultiCookieApp()
 
 example_hdr = {"Header1": "Value1", "Header2": "Value2"}
 
@@ -259,6 +283,8 @@ class Default(WorkerEntrypoint):
             return await asgi.fetch(
                 late_failure_stream_app, request, self.env, self.ctx
             )
+        elif path == "/multi-cookie":
+            return await asgi.fetch(multi_cookie_app, request, self.env, self.ctx)
 
         return await asgi.fetch(app, request, self.env, self.ctx)
 

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/tests/workerd-test/asgi-ws-disconnect/tests/test_ws_disconnect.py

@@ -26,6 +26,22 @@ def _listen(ws, event_type):
     return fut
 
 
+def _collect(ws, count):
+    """Future resolved with the payloads of the first `count` messages."""
+    fut = asyncio.get_event_loop().create_future()
+    messages = []
+
+    def callback(evt):
+        messages.append(evt.data)
+        if len(messages) == count and not fut.done():
+            fut.set_result(messages)
+
+    proxy = create_proxy(callback)
+    _proxies.append(proxy)
+    ws.addEventListener("message", proxy)
+    return fut
+
+
 async def _ws_connect(path):
     # Upgrade through the raw JS binding (as durable-object-websocket's
     # tester.js does): the SDK fetch wrapper routes through pyfetch, whose
@@ -113,3 +129,14 @@ async def test_binary_frame_arrives_as_asgi_bytes():
         data = evt.data
         assert not isinstance(data, str), f"delivered to the app as text: {data!r}"
         assert data.to_bytes() == b"bytes=" + payload
+
+
+@pytest.mark.asyncio
+async def test_empty_frames_reach_the_client():
+    async with _ws_session("/ws-empty") as ws:
+        received = _collect(ws, 3)
+        ws.send("go")
+        messages = await asyncio.wait_for(received, TIMEOUT_S)
+        assert messages[0] == ""
+        assert messages[1].to_bytes() == b""
+        assert messages[2] == "done"

{workers_runtime_sdk-1.6.11 → workers_runtime_sdk-1.6.13}/tests/workerd-test/asgi-ws-disconnect/worker.py

@@ -80,15 +80,37 @@ class WSEchoApp:
                 await send({"type": "websocket.send", "text": reply})
 
 
+class WSEmptyFrameApp:
+    """On each client frame, replies with an empty text frame, an empty binary
+    frame, and a sentinel, so a test can tell whether empty frames reach the
+    client at all."""
+
+    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
+            await send({"type": "websocket.send", "text": ""})
+            await send({"type": "websocket.send", "bytes": b""})
+            await send({"type": "websocket.send", "text": "done"})
+
+
 ws_app = WSWatchApp()
 echo_app = WSEchoApp()
+empty_frame_app = WSEmptyFrameApp()
 
 
 class Default(WorkerEntrypoint):
     async def fetch(self, request):
         if (request.headers.get("upgrade") or "").lower() == "websocket":
             path = urlsplit(request.url).path
-            app = echo_app if path == "/ws-echo" else ws_app
+            app = {"/ws-echo": echo_app, "/ws-empty": empty_frame_app}.get(path, ws_app)
             return await asgi.websocket(app, request)
         import json
 

workers_runtime_sdk-1.6.13/tests/workerd-test/wsgi/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "test"
+version = "0.0.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0"]