celerity-runtime-sdk 0.1.0__tar.gz → 0.2.1__tar.gz

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/Cargo.lock

@@ -971,7 +971,7 @@ dependencies = [
 
 [[package]]
 name = "celerity-python-runtime-sdk"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "async-trait",
  "axum 0.8.8",

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celerity-runtime-sdk
-Version: 0.1.0
+Version: 0.2.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/core/src/consts.rs

@@ -70,6 +70,15 @@ pub const CELERITY_WS_UNAUTHORISED_ERROR_CODE: u16 = 4001;
 // via the `Forbidden` error variant.
 pub const CELERITY_WS_FORBIDDEN_ERROR_CODE: u16 = 4002;
 
+// Binary prefix for the server capabilities signal.
+// Sent immediately after a WebSocket connection is established to indicate
+// that the server supports full protocol capabilities (binary messages,
+// custom close codes, and binary control frames).
+// In environments where binary frames are not supported (e.g., managed
+// WebSocket gateways), this frame will not reach the client, causing the
+// client to fall back to constrained capabilities (text-only).
+pub const CELERITY_WS_CAPABILITIES_SIGNAL: [u8; 4] = [0x1, 0x5, 0x0, 0x0];
+
 // The route key for the connect handler for a WebSocket API.
 // A handler registered with this route key will be called when a client
 // connects to the WebSocket API server after authentication has been performed

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/core/src/websocket.rs

@@ -41,9 +41,9 @@ use crate::{
     },
     auth_jwt::{validate_jwt_on_ws_connect, ValidateJwtError},
     consts::{
-        CELERITY_WS_CONNECT_HANDLER_ROUTE, CELERITY_WS_DEFAULT_MESSAGE_HANDLER_ROUTE,
-        CELERITY_WS_DISCONNECT_HANDLER_ROUTE, CELERITY_WS_FORBIDDEN_ERROR_CODE,
-        CELERITY_WS_UNAUTHORISED_ERROR_CODE,
+        CELERITY_WS_CAPABILITIES_SIGNAL, CELERITY_WS_CONNECT_HANDLER_ROUTE,
+        CELERITY_WS_DEFAULT_MESSAGE_HANDLER_ROUTE, CELERITY_WS_DISCONNECT_HANDLER_ROUTE,
+        CELERITY_WS_FORBIDDEN_ERROR_CODE, CELERITY_WS_UNAUTHORISED_ERROR_CODE,
     },
     errors::WebSocketsMessageError,
     request::{HttpProtocolVersion, RequestId},
@@ -296,6 +296,21 @@ async fn handle_socket(
             .add_connection(connection_id.clone(), socket_ref.clone());
         ws_connections_counter().add(1, &[]);
 
+        // Send the capabilities signal — a binary frame that indicates the server
+        // supports full protocol capabilities (binary messages, custom close codes,
+        // binary control frames). In environments where binary frames are not
+        // supported (e.g., managed WebSocket gateways that proxy via text-only APIs),
+        // this frame will not reach the client, causing it to fall back to constrained
+        // capabilities (text-only, JSON-format control frames).
+        {
+            let mut sock = socket_ref.lock().await;
+            let _ = sock
+                .send(Message::Binary(
+                    CELERITY_WS_CAPABILITIES_SIGNAL.to_vec().into(),
+                ))
+                .await;
+        }
+
         // For Connect strategy, only reached after successful auth (with auth data).
         // For AuthMessage / no auth, fires immediately with null auth data.
         if let ControlFlow::Break(_) = on_connect(

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/pyproject.toml

@@ -44,6 +44,6 @@ check_untyped_defs = true
 [tool.maturin]
 module-name = "celerity_runtime_sdk._celerity_runtime_sdk"
 bindings = "pyo3"
-features = ["pyo3/extension-module"]
+features = ["pyo3/extension-module", "celerity_local_consumers", "aws_consumers", "gcloud_consumers", "azure_consumers"]
 manifest-path = "sdk/python/Cargo.toml"
 python-source = "python"

celerity_runtime_sdk-0.2.1/sdk/python/.core-version

@@ -0,0 +1 @@
+runtime-core/v0.6.0

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/sdk/python/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.1](https://github.com/newstack-cloud/celerity/compare/runtime-sdk-python/v0.2.0...runtime-sdk-python/v0.2.1) (2026-03-23)
+
+
+### Bug Fixes
+
+* **lib-rt-sdk-python:** add fixes to websocket types and include all features in build ([39cee06](https://github.com/newstack-cloud/celerity/commit/39cee06918f6bbdd1f020d1a33908db32205ca0a))
+
+
+### Dependencies
+
+* **runtime-sdk-python:** update core dependencies ([d2be0ed](https://github.com/newstack-cloud/celerity/commit/d2be0edddef9e16d6ec348eb41df5ab8d328501e))
+
 ## [0.2.0](https://github.com/newstack-cloud/celerity/compare/runtime-sdk-python/v0.1.0...runtime-sdk-python/v0.2.0) (2026-03-17)
 
 

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/sdk/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "celerity-python-runtime-sdk"
-version = "0.1.0"
+version = "0.2.1"
 edition = "2021"
 license.workspace = true
 readme = "README.md"

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/sdk/python/src/websockets.rs

@@ -144,6 +144,17 @@ pub enum WSBindingEventType {
   Disconnect,
 }
 
+#[pymethods]
+impl WSBindingEventType {
+  fn __str__(&self) -> &str {
+    match self {
+      Self::Connect => "connect",
+      Self::Message => "message",
+      Self::Disconnect => "disconnect",
+    }
+  }
+}
+
 impl From<WebSocketEventType> for WSBindingEventType {
   fn from(event_type: WebSocketEventType) -> Self {
     match event_type {
@@ -176,6 +187,8 @@ pub struct WSBindingMessageRequestContext {
   #[pyo3(get)]
   pub cookies: HashMap<String, String>,
   #[pyo3(get)]
+  pub auth: Option<Py<PyAny>>,
+  #[pyo3(get)]
   pub trace_context: Option<HashMap<String, String>>,
 }
 
@@ -185,6 +198,12 @@ impl WSBindingMessageRequestContext {
     trace_context: Option<HashMap<String, String>>,
     py: Python,
   ) -> PyResult<Py<Self>> {
+    let auth = message_request_context
+      .auth
+      .as_ref()
+      .map(|v| json_value_to_python(v, py).map(|b| b.unbind()))
+      .transpose()?;
+
     Py::new(
       py,
       Self {
@@ -205,6 +224,7 @@ impl WSBindingMessageRequestContext {
         client_ip: message_request_context.client_ip,
         query: message_request_context.query,
         cookies: message_request_context.cookies,
+        auth,
         trace_context,
       },
     )
@@ -236,6 +256,7 @@ impl WSBindingMessageRequestContextBuilder {
         client_ip: String::new(),
         query: HashMap::new(),
         cookies: HashMap::new(),
+        auth: None,
         trace_context: None,
       }),
     }
@@ -483,6 +504,16 @@ pub enum WSBindingMessageType {
   Binary,
 }
 
+#[pymethods]
+impl WSBindingMessageType {
+  fn __str__(&self) -> &str {
+    match self {
+      Self::Json => "json",
+      Self::Binary => "binary",
+    }
+  }
+}
+
 impl From<WSBindingMessageType> for MessageType {
   fn from(message_type: WSBindingMessageType) -> Self {
     match message_type {

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/sdk/python/tests/test_runtime_application.py

@@ -17,10 +17,19 @@ def test_http_endpoint(runtime_server):
     assert response.json() == {"message": "Order received"}
 
 
+def _recv_text(ws):
+    """Receive the next text frame, skipping binary frames
+    (e.g. the capabilities signal sent on connect)."""
+    while True:
+        opcode, data = ws.recv_data()
+        if opcode == 1:
+            return data.decode("utf-8") if isinstance(data, bytes) else data
+
+
 def test_websockets(runtime_server):
     ws = create_connection("ws://localhost:22346/ws", origin="https://example.com")
     ws.send(json.dumps({"action": "processOrderUpdate", "data": {"orderId": "1234"}}))
-    msg = ws.recv()
+    msg = _recv_text(ws)
     assert msg == '{"action": "processedOrderUpdate", "message": "Order received"}'
     ws.close()
 

{celerity_runtime_sdk-0.1.0 → celerity_runtime_sdk-0.2.1}/sdk/python/tests/test_websocket.py

@@ -61,6 +61,17 @@ def _ws_connect(query: str = ""):
     return create_connection(url, origin="https://example.com")
 
 
+def _recv_text(ws):
+    """Receive the next text frame, skipping any binary frames
+    (e.g. the capabilities signal sent on connect)."""
+    while True:
+        opcode, data = ws.recv_data()
+        # opcode 1 = text, 2 = binary
+        if opcode == 1:
+            return data.decode("utf-8") if isinstance(data, bytes) else data
+        # skip binary frames
+
+
 def _wait_for_file(path: str, timeout: float = 10.0):
     start = time.time()
     while time.time() - start < timeout:
@@ -102,10 +113,10 @@ def test_setup_returns_websocket_config():
 def test_ws_connect_triggers_handler(ws_server):
     ws = _ws_connect()
     try:
-        msg = json.loads(ws.recv())
+        msg = json.loads(_recv_text(ws))
         assert msg["event"] == "connected"
         assert msg["connectionId"]
-        assert "CONNECT" in msg["eventType"]
+        assert "connect" in msg["eventType"].lower()
     finally:
         ws.close()
 
@@ -119,10 +130,10 @@ def test_ws_json_message_routes_to_echo(ws_server):
     ws = _ws_connect()
     try:
         # Consume the connect message first.
-        ws.recv()
+        _recv_text(ws)
 
         ws.send(json.dumps({"action": "echo", "data": "hello"}))
-        msg = json.loads(ws.recv())
+        msg = json.loads(_recv_text(ws))
         assert msg["event"] == "echo"
         assert msg["body"]["data"] == "hello"
         assert msg["connectionId"]
@@ -139,10 +150,10 @@ def test_ws_default_route(ws_server):
     ws = _ws_connect()
     try:
         # Consume the connect message.
-        ws.recv()
+        _recv_text(ws)
 
         ws.send(json.dumps({"action": "unknownAction", "data": "test"}))
-        msg = json.loads(ws.recv())
+        msg = json.loads(_recv_text(ws))
         assert msg["event"] == "default"
         assert msg["connectionId"]
     finally:
@@ -164,7 +175,7 @@ def test_ws_disconnect_triggers_handler(ws_server):
 
     ws = _ws_connect()
     # Consume the connect message.
-    ws.recv()
+    _recv_text(ws)
     ws.close()
 
     result = _wait_for_file(disconnect_file)
@@ -181,10 +192,10 @@ def test_ws_registry_send_message(ws_server):
     ws = _ws_connect()
     try:
         # Consume the connect message.
-        ws.recv()
+        _recv_text(ws)
 
         ws.send(json.dumps({"action": "echo", "payload": {"key": "value"}}))
-        msg = json.loads(ws.recv())
+        msg = json.loads(_recv_text(ws))
         # The echo handler uses ws_registry.send_message to send back.
         assert msg["event"] == "echo"
         assert msg["body"]["payload"] == {"key": "value"}
@@ -201,10 +212,10 @@ def test_ws_request_context(ws_server):
     ws = _ws_connect(query="token=abc")
     try:
         # Consume the connect message.
-        ws.recv()
+        _recv_text(ws)
 
         ws.send(json.dumps({"action": "echo", "data": "ctx-test"}))
-        msg = json.loads(ws.recv())
+        msg = json.loads(_recv_text(ws))
         assert msg["requestContext"] is not None
         assert msg["requestContext"]["requestId"]
         assert msg["requestContext"]["clientIp"]

celerity_runtime_sdk-0.1.0/sdk/python/.core-version

@@ -1 +0,0 @@
-runtime-consumers/v0.3.0