workers-runtime-sdk 1.8.4__tar.gz → 1.8.6__tar.gz

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 <!-- version list -->
 
+## v1.8.6 (2026-09-18)
+
+### Bug Fixes
+
+- **runtime-sdk**: Convert workflow step results with python_to_rpc
+  ([`4220da8`](https://github.com/cloudflare/workers-py/commit/4220da80451073afd7140e091811a8dd4b879aa5))
+
+- **runtime-sdk**: Don't crash in _from_js_error on messages without a traceback
+  ([`a9159df`](https://github.com/cloudflare/workers-py/commit/a9159df2ede8f1a2ff420b8bac1d0e0199506e86))
+
+- **runtime-sdk**: Key workflow step memoisation by closure instead of step name
+  ([`610d18f`](https://github.com/cloudflare/workers-py/commit/610d18f7ce350bbd40cd20312bb26334f67923f5))
+
+- **runtime-sdk**: Raise a TypeError for invalid legacy `depends` entries
+  ([`10a2bcc`](https://github.com/cloudflare/workers-py/commit/10a2bccbe91d06e8c0fb187a661bb78a4d236342))
+
+- **runtime-sdk**: Recover Python exception types under enhanced error serialization
+  ([`53be6db`](https://github.com/cloudflare/workers-py/commit/53be6db4a8ff62e03b2eb4e4896d45d6dd5d748b))
+
+
+## v1.8.5 (2026-09-17)
+
+### Bug Fixes
+
+- **runtime-sdk**: Fix top-level import for opentelemetry package
+  ([#248](https://github.com/cloudflare/workers-py/pull/248),
+  [`338c12e`](https://github.com/cloudflare/workers-py/commit/338c12e5dc6aada9dd20968fdae6bb6e805ad33e))
+
+
 ## v1.8.4 (2026-09-08)
 
 ### Bug Fixes

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/PKG-INFO

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

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

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/src/_workers_sdk_entropy_import_context.py

@@ -4,6 +4,7 @@ Top level entropy patches for packages
 
 import sys
 from contextlib import contextmanager
+from importlib.metadata import PackageNotFoundError, version
 
 from _cloudflare.allow_entropy import (
     allow_bad_entropy_calls,
@@ -17,6 +18,29 @@ from _cloudflare.import_patch_manager import (
 )
 
 
+@contextmanager
+def allow_bad_entropy_calls_for_version(
+    package_name: str,
+    num_calls: int,
+    min_version: tuple[int, ...],
+    max_version: tuple[int, ...] | None = None,
+):
+    try:
+        package_version = tuple(map(int, version(package_name).split(".")))
+    except PackageNotFoundError:
+        yield
+        return
+
+    if package_version < min_version or (
+        max_version is not None and package_version > max_version
+    ):
+        yield
+        return
+
+    with allow_bad_entropy_calls(num_calls):
+        yield
+
+
 class STATE:
     imported_rust_package = False
     numpy_random = None
@@ -180,6 +204,30 @@ def langchain_openai_chat_models_base_context(module):
         yield
 
 
+@register_exec_patch("opentelemetry.context")
+@contextmanager
+def opentelemetry_context(module):
+    # OpenTelemetry creates three UUID-backed keys.
+    with allow_bad_entropy_calls_for_version("opentelemetry-api", 3, (1, 40, 0)):
+        yield
+
+
+@register_exec_patch("opentelemetry.trace.propagation")
+@contextmanager
+def opentelemetry_trace_propagation_context(module):
+    # OpenTelemetry creates a UUID-backed key.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("opentelemetry.baggage")
+@contextmanager
+def opentelemetry_baggage_context(module):
+    # OpenTelemetry creates a UUID-backed key.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
 @register_exec_patch("litestar.openapi.controller")
 @register_exec_patch("litestar.constants")
 @contextmanager

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/src/workers/entrypoints.py

@@ -116,7 +116,7 @@ class _WorkflowStepWrapper:
                     func, depends, implicit
                 )
                 results = await self._gather_results(results_future_list, concurrent)
-                return await _do_call(self, step_name, config, func, *results)
+                return await _do_call(self, step_name, wrapper, config, func, *results)
 
             wrapper._step_name = step_name
             self.step_closures[step_name] = wrapper
@@ -157,7 +157,13 @@ class _WorkflowStepWrapper:
                 if p.name == "ctx":
                     results_future_list.append(p)
                 else:
-                    results_future_list.append(depends[curr])
+                    dep = depends[curr]
+                    if not hasattr(dep, "_step_name"):
+                        raise TypeError(
+                            f"'depends' entry for parameter {p.name!r} is not a "
+                            "function decorated with step.do"
+                        )
+                    results_future_list.append(dep)
                     curr += 1
 
         return results_future_list
@@ -194,17 +200,17 @@ class _WorkflowStepWrapper:
         )
 
     async def _resolve_dependency(self, dep):
-        if hasattr(dep, "name") and dep.name == "ctx":
+        if isinstance(dep, inspect.Parameter) and dep.name == "ctx":
             return dep
-        elif dep._step_name in self._memoized_dependencies:
-            return self._memoized_dependencies[dep._step_name]
-        elif dep._step_name in self._in_flight:
-            return await self._in_flight[dep._step_name]
+        elif dep in self._memoized_dependencies:
+            return self._memoized_dependencies[dep]
+        elif dep in self._in_flight:
+            return await self._in_flight[dep]
 
         return await dep()
 
 
-async def _do_call(entrypoint, name, config, callback, *results):
+async def _do_call(entrypoint, name, key, config, callback, *results):
     async def _callback(ctx=None):
         # deconstruct the actual ctx object
         resolved_results = tuple(
@@ -217,7 +223,8 @@ async def _do_call(entrypoint, name, config, callback, *results):
 
         if inspect.iscoroutine(result):
             result = await result
-        return to_js(result, dict_converter=Object.fromEntries)
+        # The step result crosses the RPC boundary back to the Workflows engine
+        return python_to_rpc(result)
 
     async def _closure():
         try:
@@ -233,13 +240,13 @@ async def _do_call(entrypoint, name, config, callback, *results):
             raise _from_js_error(exc) from exc
 
     task = create_task(_closure())
-    entrypoint._in_flight[name] = task
+    entrypoint._in_flight[key] = task
 
     try:
         result = await task
-        entrypoint._memoized_dependencies[name] = result
+        entrypoint._memoized_dependencies[key] = result
     finally:
-        del entrypoint._in_flight[name]
+        entrypoint._in_flight.pop(key, None)
 
     return result
 

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/src/workers/utils.py

@@ -147,11 +147,24 @@ def _to_python_exception(exc: JsException) -> Exception:
 def _from_js_error(exc: JsException) -> Exception:
     # convert into Python exception after a full round trip
     # Python - JS - Python
-    if not exc.message or not exc.message.startswith("PythonError"):
+    message = exc.message or ""
+
+    # A Python exception that escaped to JS is a Pyodide `PythonError` whose
+    # message is the formatted traceback. Depending on how it was serialized
+    # over RPC it either keeps its name or arrives as a plain `Error` with
+    # "PythonError: " folded into the message.
+    if getattr(exc, "name", None) != "PythonError" and not message.startswith(
+        "PythonError"
+    ):
         return _to_python_exception(exc)
 
-    # extract the Python exception type from the traceback
-    error_message_last_line = exc.message.split("\n")[-2]
+    # extract the Python exception type from the last line of the traceback. The
+    # message may have been stripped down to just "PythonError" when crossing an RPC
+    # boundary, in which case there is no traceback to inspect.
+    lines = message.rstrip().split("\n")
+    if len(lines) < 2:
+        return _to_python_exception(exc)
+    error_message_last_line = lines[-1]
     if error_message_last_line.startswith("TypeError"):
         return TypeError(error_message_last_line)
     elif error_message_last_line.startswith("ValueError"):

workers_runtime_sdk-1.8.6/tests/bindings-test/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "bindings-test"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "pytest",
+    "pytest-asyncio<1.2.0",
+    # These are for hyperdrive tests
+    "pg8000",
+    "pymysql",
+    "aiomysql",
+    "psycopg[binary]; python_version >= '3.14'",
+    "asyncpg; python_version >= '3.14'",
+    "cryptography",
+    "testlib",
+]
+
+[tool.uv.sources]
+testlib = { path = "../testlib/dist/testlib-0.0.0-py3-none-any.whl" }

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/bindings-test/src/test_hyperdrive_mysql.py

@@ -24,6 +24,7 @@ uv run pytest tests/test_bindings.py -m hyperdrive -k mysql
 
 import sys
 
+import aiomysql
 import pymysql
 import pytest
 from conftest import unique_table_name
@@ -58,6 +59,26 @@ async def test_connect(env):
     conn.close()
 
 
+@pytest.mark.asyncio
+async def test_connect_aiomysql(env):
+    hd = env.HYPERDRIVE_MYSQL
+    conn = await aiomysql.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        db=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl=None,
+    )
+    try:
+        async with conn.cursor() as cur:
+            await cur.execute("SELECT %s", (1,))
+            assert await cur.fetchone() == (1,)
+    finally:
+        await conn.ensure_closed()
+
+
 @pytest.mark.asyncio
 async def test_create_insert_select(env):
     conn = _connect(env)

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/bindings-test/src/test_hyperdrive_postgresql.py

@@ -61,6 +61,71 @@ async def test_connect(env):
     conn.close()
 
 
+@pytest.mark.asyncio
+async def test_connect_psycopg(env):
+    import psycopg  # noqa: PLC0415
+
+    assert psycopg.pq.__impl__ == "binary"
+    hd = env.HYPERDRIVE_PG
+    with psycopg.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        dbname=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        sslmode="disable",
+    ) as conn:
+        with conn.cursor() as cur:
+            cur.execute("SELECT %s", (1,))
+            assert cur.fetchone() == (1,)
+
+
+@pytest.mark.asyncio
+async def test_asyncpg_crud(env):
+    import asyncpg  # noqa: PLC0415
+
+    hd = env.HYPERDRIVE_PG
+    conn = await asyncpg.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        database=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl=False,
+    )
+    table = unique_table_name()
+    try:
+        await conn.execute(
+            f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT, value INT)"
+        )
+        await conn.execute(
+            f"INSERT INTO {table} (name, value) VALUES ($1, $2)", "alpha", 1
+        )
+
+        row = await conn.fetchrow(
+            f"SELECT name, value FROM {table} WHERE name = $1", "alpha"
+        )
+        assert tuple(row) == ("alpha", 1)
+
+        await conn.execute(
+            f"UPDATE {table} SET value = $1 WHERE name = $2", 11, "alpha"
+        )
+        assert (
+            await conn.fetchval(f"SELECT value FROM {table} WHERE name = $1", "alpha")
+            == 11
+        )
+
+        await conn.execute(f"DELETE FROM {table} WHERE name = $1", "alpha")
+        assert await conn.fetchval(f"SELECT COUNT(*) FROM {table}") == 0
+    finally:
+        try:
+            await conn.execute(f"DROP TABLE IF EXISTS {table}")
+        finally:
+            await conn.close()
+
+
 @pytest.mark.asyncio
 async def test_create_insert_select(env):
     conn = _connect(env)

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/bindings-test/src/test_workflow.py

@@ -159,11 +159,36 @@ async def test_error_handling_catch(env):
     # Per the docs, a step error propagates to run() and is catchable with
     # `except Exception`. Neither the concrete type nor the original message is
     # guaranteed to survive the RPC layer, so we assert the reliable contract:
-    # the error was caught and a message was produced.
+    # the error was caught and a message was produced, and that the SDK's own
+    # error translation did not blow up (e.g. IndexError while parsing it).
     assert status["output"]["caught"] is not None
+    assert status["output"]["caught"] != "IndexError"
     assert status["output"]["message"]
 
 
+async def test_duplicate_step_names(env):
+    instance = await env.MY_WORKFLOW.create(
+        {"params": {"mode": "duplicate_step_names"}}
+    )
+    status = await _poll(instance)
+    assert status["status"] == "complete", f"unexpected status: {dict(status)!r}"
+    assert status["output"]["concurrent"] == [1, 2]
+    assert status["output"]["uses"] == 20
+
+
+async def test_step_output_conversion(env):
+    instance = await env.MY_WORKFLOW.create(
+        {"params": {"mode": "step_output_conversion"}}
+    )
+    status = await _poll(instance)
+    assert status["status"] == "complete", f"unexpected status: {dict(status)!r}"
+    out = status["output"]
+    assert out["when_is_datetime"] is True
+    assert out["year"] == 2026
+    assert out["nothing_is_none"] is True
+    assert out["nested_nothing_is_none"] is True
+
+
 # The tests below pass pre-converted (to_js) objects, the legacy pattern from the
 # Workflows docs, to ensure existing code keeps working now that the binding
 # auto-converts plain Python objects.

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/bindings-test/src/worker_workflow.py

@@ -1,3 +1,4 @@
+import asyncio
 import datetime
 
 from workers import WorkflowEntrypoint
@@ -19,6 +20,8 @@ class TestWorkflow(WorkflowEntrypoint):
             "retry": self._retry,
             "non_retryable": self._non_retryable,
             "catch_error": self._catch_error,
+            "duplicate_step_names": self._duplicate_step_names,
+            "step_output_conversion": self._step_output_conversion,
         }
         handler = handlers.get(mode)
         if handler is None:
@@ -115,6 +118,47 @@ class TestWorkflow(WorkflowEntrypoint):
 
         return await boom()
 
+    async def _duplicate_step_names(self, event, step):
+        # The engine disambiguates repeated step names with a counter, so two
+        # steps sharing a name must not share memoised results or in-flight tasks.
+        @step.do("dup")
+        async def first():
+            return 1
+
+        @step.do("dup")
+        async def second():
+            return 2
+
+        # Implicit dependencies resolve by step name, so `dup` refers to the most
+        # recently registered closure (`second`) and must return its result.
+        @step.do()
+        async def uses(dup):
+            return dup * 10
+
+        # Run both same-named steps concurrently so they are in flight together.
+        concurrent = list(await asyncio.gather(first(), second()))
+        return {"concurrent": concurrent, "uses": await uses()}
+
+    async def _step_output_conversion(self, event, step):
+        @step.do("produce")
+        async def produce():
+            return {
+                "when": datetime.datetime(2026, 1, 2, 3, 4, 5),
+                "nothing": None,
+                "nested": {"nothing": None},
+            }
+
+        @step.do()
+        async def consume(produce):
+            return {
+                "when_is_datetime": isinstance(produce["when"], datetime.datetime),
+                "year": produce["when"].year,
+                "nothing_is_none": produce["nothing"] is None,
+                "nested_nothing_is_none": produce["nested"]["nothing"] is None,
+            }
+
+        return await consume()
+
     async def _catch_error(self, event, step):
         @step.do(
             "failing-step",

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/test_in_workerd.py

@@ -29,6 +29,30 @@ def discover_workerd_tests():
     return cases
 
 
+def resolve_workerd(target: Path) -> str:
+    """Return the path to the workerd binary to use for tests.
+
+    If the ``WORKERD_PATH`` environment variable is set, it is used as-is (this
+    is useful for testing against a locally built workerd). Otherwise, workerd
+    is installed from npm into ``target`` and the installed binary is used.
+    """
+    workerd_path = os.environ.get("WORKERD_PATH")
+    if workerd_path:
+        workerd_bin = Path(workerd_path).expanduser().resolve()
+        if not workerd_bin.is_file():
+            raise FileNotFoundError(
+                f"WORKERD_PATH is set but does not point to a file: {workerd_bin}"
+            )
+        return str(workerd_bin)
+
+    subprocess.run(
+        ["npm", "i", "workerd"],
+        cwd=target,
+        check=True,
+    )
+    return "node_modules/workerd/bin/workerd"
+
+
 def embed(dir: Path, root: Path, level: int = 0):
     modules = []
     module_path_root = dir
@@ -79,10 +103,8 @@ def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
             "wsgi requires pyodide.ffi.run_sync (JSPI), unavailable before 2026-01-01"
         )
 
-    if test_dir.name == "entropy-patches" and python_version == "3.14":
-        pytest.skip(
-            "TODO: enable me after https://github.com/cloudflare/workerd/pull/7200 lands in wrangler"
-        )
+    if test_dir.name == "http-client" and python_version < "3.14":
+        pytest.skip("HTTP client compatibility tests require Python 3.14 or newer")
 
     color = pytestconfig.get_terminal_writer().hasmarkup
     target = tmp_path / test_dir.name
@@ -120,13 +142,9 @@ def test_in_workerd(  # noqa: PLR0913, PLR0917  (too-many-arguments)
     )
     configure_compatibility(wd_config, compat_config)
 
-    subprocess.run(
-        ["npm", "i", "workerd"],
-        cwd=target,
-        check=True,
-    )
+    workerd_bin = resolve_workerd(target)
     workerd_common = [
-        "node_modules/workerd/bin/workerd",
+        workerd_bin,
         "test",
         wd_test_file,
         "--experimental",

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/web-frameworks-test/fastapi-tests/src/worker.py

@@ -602,7 +602,7 @@ class FastAPIAppPlugin:
 
 @app.get("/run-tests/{suite_name:path}")
 async def run_suite(suite_name: str, request: Request):
-    runner = TestRunner(request.scope["env"])
+    runner = TestRunner(request.scope["env"], extra_plugins=[FastAPIAppPlugin()])
     result = runner.run_suite(suite_name)
     return JSONResponse(result.payload, status_code=result.status)
 

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/workerd-test/asgi-ws-disconnect/tests/test_ws_disconnect.py

@@ -1,5 +1,6 @@
 import asyncio
 import contextlib
+import json
 
 import pytest
 from pyodide.ffi import create_proxy, to_js
@@ -61,9 +62,6 @@ async def _ws_connect(path):
     )
 
 
-import json
-
-
 async def _events():
     response = await asyncio.wait_for(
         env.SELF.fetch("http://example.com/ws-events"), TIMEOUT_S

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/workerd-test/entropy-patches/pyproject.toml

@@ -18,4 +18,6 @@ dependencies = [
     # "langchain-openai",
     # "openai",
     "litestar",
+    "opentelemetry-api",
+    "mcp; python_version >= '3.14'",
 ]

workers_runtime_sdk-1.8.6/tests/workerd-test/entropy-patches/tests/test_mcp.py

@@ -0,0 +1,10 @@
+# ruff: noqa: F401
+import sys
+
+if sys.version_info >= (3, 14):
+    import mcp
+
+
+def test_import():
+    # make sure this file is collected by pytest
+    pass

workers_runtime_sdk-1.8.6/tests/workerd-test/entropy-patches/tests/test_opentelemetry.py

@@ -0,0 +1,8 @@
+# ruff: noqa: F401
+import opentelemetry.context
+import opentelemetry.trace
+
+
+def test_import():
+    # make sure this file is collected by pytest
+    pass

{workers_runtime_sdk-1.8.4 → workers_runtime_sdk-1.8.6}/tests/workerd-test/entropy-patches/worker.py

@@ -4,7 +4,9 @@ from tests import (  # noqa: F401
     test_aiohttp_websocket,
     test_langsmith,
     test_litestar,
+    test_mcp,
     test_numpy,
+    test_opentelemetry,
     test_pydantic,
     test_rust_packages,
     test_ssl_avoidance,

workers_runtime_sdk-1.8.6/tests/workerd-test/http-client/http-client.wd-test

@@ -0,0 +1,45 @@
+using Workerd = import "/workerd/workerd.capnp";
+
+const client :Workerd.Worker = (
+  modules = [
+    (name = "worker.py", pythonModule = embed "worker.py"),
+    %PYTHON_MODULES
+  ],
+  bindings = [
+    (name = "color", json = "%COLOR"),
+  ],
+  globalOutbound = "external",
+  compatibilityDate = "%COMPAT_DATE",
+  compatibilityFlags = ["python_workers", "service_binding_extra_handlers"],
+);
+
+const origin :Workerd.Worker = (
+  modules = [
+    (name = "origin.py", pythonModule = embed "origin.py"),
+    %PYTHON_MODULES
+  ],
+  compatibilityDate = "%COMPAT_DATE",
+  compatibilityFlags = ["python_workers"],
+);
+
+const unitTests :Workerd.Config = (
+  services = [
+    (
+      name = "external",
+      external = (
+        address = "loopback:raw-http-origin",
+        tcp = (),
+      ),
+    ),
+    (name = "http-client", worker = .client),
+    (name = "http-origin", worker = .origin),
+  ],
+  sockets = [
+    (
+      name = "raw-http-origin",
+      address = "loopback:raw-http-origin",
+      http = (),
+      service = "http-origin",
+    ),
+  ],
+);