app_bridge 4.1.0 → 5.0.0

data/ext/app_bridge/src/component.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use std::result::Result::Ok;
-use wasmtime::component::{Component, Linker};
+use wasmtime::component::{Component, HasSelf, Linker};
 use wasmtime::{Engine, Result, Store};
-use wasmtime_wasi::p2::WasiCtxBuilder;
+use wasmtime_wasi::WasiCtxBuilder;
 
 use crate::app_state::AppState;
 use crate::types::{
@@ -42,6 +42,13 @@ pub mod v4_1 {
     });
 }
 
+pub mod v5 {
+    wasmtime::component::bindgen!({
+        path: "./wit/v5",
+        world: "bridge",
+    });
+}
+
 // ============================================================================
 // Version conversion macro - generates From impls for a version module
 // ============================================================================
@@ -174,6 +181,15 @@ impl From<v4_1::standout::app::types::ReferenceObject> for ReferenceObject {
     }
 }
 
+impl From<v5::standout::app::types::ReferenceObject> for ReferenceObject {
+    fn from(r: v5::standout::app::types::ReferenceObject) -> Self {
+        Self {
+            reference: r.reference,
+            status: r.status,
+        }
+    }
+}
+
 impl From<&ReferenceObject> for v4_1::standout::app::types::ReferenceObject {
     fn from(r: &ReferenceObject) -> Self {
         Self {
@@ -183,6 +199,15 @@ impl From<&ReferenceObject> for v4_1::standout::app::types::ReferenceObject {
     }
 }
 
+impl From<&ReferenceObject> for v5::standout::app::types::ReferenceObject {
+    fn from(r: &ReferenceObject) -> Self {
+        Self {
+            reference: r.reference.clone(),
+            status: r.status.clone(),
+        }
+    }
+}
+
 // Generate conversions for all supported versions
 impl_error_code_conversion!(v3,);
 impl_conversions!(v3);
@@ -199,6 +224,13 @@ impl_error_code_conversion!(
 impl_conversions!(v4_1);
 impl_app_error_conversion!(v4_1);
 impl_action_context_conversion_retry!(v4_1);
+impl_error_code_conversion!(
+    v5,
+    V::RetryWithReference(r) => Self::RetryWithReference(r.into()),
+);
+impl_conversions!(v5);
+impl_app_error_conversion!(v5);
+impl_action_context_conversion_retry!(v5);
 
 // ============================================================================
 // BridgeWrapper - unified interface for all component versions
@@ -210,6 +242,7 @@ pub enum BridgeWrapper {
     V3(v3::Bridge),
     V4(v4::Bridge),
     V4_1(v4_1::Bridge),
+    V5(v5::Bridge),
 }
 
 impl BridgeWrapper {
@@ -219,8 +252,13 @@ impl BridgeWrapper {
             BridgeWrapper::V3(_) => "3.0.0",
             BridgeWrapper::V4(_) => "4.0.0",
             BridgeWrapper::V4_1(_) => "4.1.0",
+            BridgeWrapper::V5(_) => "5.0.0",
         }
     }
+
+    pub fn connections_supported(&self) -> bool {
+        matches!(self, BridgeWrapper::V5(_))
+    }
 }
 
 /// Macro to implement a bridge method that works across all versions.
@@ -242,6 +280,10 @@ macro_rules! bridge_method {
                     let r = b.$interface().$method(store)?;
                     Ok(r.map_err(Into::into))
                 }
+                BridgeWrapper::V5(b) => {
+                    let r = b.$interface().$method(store)?;
+                    Ok(r.map_err(Into::into))
+                }
             }
         }
     };
@@ -261,6 +303,10 @@ macro_rules! bridge_method {
                     let r = b.$interface().$method(store, &ctx.into())?;
                     Ok(r.map(Into::into).map_err(Into::into))
                 }
+                BridgeWrapper::V5(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
             }
         }
     };
@@ -280,6 +326,10 @@ macro_rules! bridge_method {
                     let r = b.$interface().$method(store, &ctx.into())?;
                     Ok(r.map(Into::into).map_err(Into::into))
                 }
+                BridgeWrapper::V5(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
             }
         }
     };
@@ -297,6 +347,18 @@ impl BridgeWrapper {
     bridge_method!(fn call_action_input_schema(&ActionContext) -> Result<String> via standout_app_actions . call_input_schema);
     bridge_method!(fn call_action_output_schema(&ActionContext) -> Result<String> via standout_app_actions . call_output_schema);
     bridge_method!(fn call_execute(&ActionContext) -> Result<ActionResponse> via standout_app_actions . call_execute);
+
+    pub fn call_connection_config(
+        &self,
+        store: &mut Store<AppState>,
+    ) -> Result<String> {
+        match self {
+            BridgeWrapper::V5(b) => {
+                b.standout_app_connections().call_connection_config(store)
+            }
+            _ => unreachable!("call_connection_config requires connections_supported"),
+        }
+    }
 }
 
 // ============================================================================
@@ -315,24 +377,23 @@ pub fn build_linker(engine: &Engine) -> Result<Linker<AppState>> {
 
     // ---- Version-specific interfaces ----
     // v3: http + environment
-    v3::standout::app::http::add_to_linker(&mut linker, |s| s)?;
-    v3::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
+    v3::standout::app::http::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v3::standout::app::environment::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
 
     // v4: http + environment + file
-    v4::standout::app::http::add_to_linker(&mut linker, |s| s)?;
-    v4::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
-    v4::standout::app::file::add_to_linker(&mut linker, |s| s)?;
+    v4::standout::app::http::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v4::standout::app::environment::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v4::standout::app::file::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
 
     // v4.1: http + environment + file
-    v4_1::standout::app::http::add_to_linker(&mut linker, |s| s)?;
-    v4_1::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
-    v4_1::standout::app::file::add_to_linker(&mut linker, |s| s)?;
+    v4_1::standout::app::http::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v4_1::standout::app::environment::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v4_1::standout::app::file::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
 
-    // Add new versions here:
-    // v5::standout::app::http::add_to_linker(&mut linker, |s| s)?;
-    // v5::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
-    // v5::standout::app::file::add_to_linker(&mut linker, |s| s)?;
-    // v5::standout::app::new_feature::add_to_linker(&mut linker, |s| s)?;
+    // v5: http + environment + file
+    v5::standout::app::http::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v5::standout::app::environment::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
+    v5::standout::app::file::add_to_linker::<AppState, HasSelf<AppState>>(&mut linker, |s| s)?;
 
     Ok(linker)
 }
@@ -360,7 +421,12 @@ pub fn app(
     let component = Component::from_file(&engine, &file_path)?;
 
     // Try versions newest-first. When adding vN, insert at the top.
-    // v4.1 (current - has file interface)
+    // v5 (current - has connections interface)
+    if let Ok(instance) = v5::Bridge::instantiate(&mut *store, &component, &linker) {
+        return Ok(BridgeWrapper::V5(instance));
+    }
+
+    // v4.1 (has file interface + retry-with-reference)
     if let Ok(instance) = v4_1::Bridge::instantiate(&mut *store, &component, &linker) {
         return Ok(BridgeWrapper::V4_1(instance));
     }
@@ -376,6 +442,6 @@ pub fn app(
     }
 
     Err(wasmtime::Error::msg(
-        "Failed to instantiate component: no compatible WIT version found (tried v4.1, v4, v3)",
+        "Failed to instantiate component: no compatible WIT version found (tried v5, v4.1, v4, v3)",
     ))
 }

data/ext/app_bridge/src/error_mapping.rs

@@ -2,6 +2,11 @@ use crate::types::{AppError, ErrorCode};
 use magnus::prelude::*;
 use magnus::{Error, ExceptionClass, RObject, Ruby};
 
+pub fn runtime_error(message: impl Into<String>) -> Error {
+    let ruby = Ruby::get().unwrap();
+    Error::new(ruby.exception_runtime_error(), message.into())
+}
+
 impl From<ErrorCode> for ExceptionClass {
     fn from(value: ErrorCode) -> Self {
         fn get_class(name: &str) -> ExceptionClass {

data/ext/app_bridge/src/file_ops.rs

@@ -1,5 +1,5 @@
 use crate::app_state::AppState;
-use crate::component::{v4, v4_1};
+use crate::component::{v4, v4_1, v5};
 use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
 
 /// Detects the type of input string
@@ -257,6 +257,7 @@ macro_rules! impl_file_host {
 // When adding v5, add: impl_file_host!(v5);
 impl_file_host!(v4);
 impl_file_host!(v4_1);
+impl_file_host!(v5);
 
 #[cfg(test)]
 mod tests {

data/ext/app_bridge/src/lib.rs

@@ -90,6 +90,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     let app_class = module.define_class("App", ruby.class_object())?;
     app_class.define_alloc_func::<MutRApp>();
     app_class.define_method("wit_version", method!(MutRApp::wit_version, 0))?;
+    app_class.define_method("connections_supported?", method!(MutRApp::connections_supported, 0))?;
     app_class.define_method("trigger_ids", method!(MutRApp::trigger_ids, 0))?;
     app_class.define_method("action_ids", method!(MutRApp::action_ids, 0))?;
     app_class.define_method("action_input_schema", method!(MutRApp::action_input_schema, 1))?;
@@ -97,6 +98,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     app_class.define_method("trigger_input_schema", method!(MutRApp::trigger_input_schema, 1))?;
     app_class.define_method("trigger_output_schema", method!(MutRApp::trigger_output_schema, 1))?;
     app_class.define_private_method("_rust_initialize", method!(MutRApp::initialize, 2))?;
+    app_class.define_private_method("_rust_connections_supported?", method!(MutRApp::connections_supported, 0))?;
+    app_class.define_private_method("_rust_connection_config", method!(MutRApp::connection_config, 0))?;
     app_class.define_private_method("_rust_fetch_events", method!(MutRApp::rb_fetch_events, 1))?;
     app_class.define_private_method("_rust_execute_action", method!(MutRApp::rb_execute_action, 1))?;
 

data/ext/app_bridge/src/request_builder.rs

@@ -1,6 +1,6 @@
 use crate::app_state::AppState;
-use crate::component::{v3, v4, v4_1};
-use crate::component::v4::standout::app::http::{Method, Request, RequestError, Response};
+use crate::component::{v3, v4, v4_1, v5};
+use crate::component::v4::standout::app::http::{Method, Request, RequestError};
 use reqwest::Method as ReqwestMethod;
 use std::result::Result::Ok;
 use wasmtime::component::Resource;
@@ -212,16 +212,6 @@ macro_rules! impl_http_type_conversions {
             }
         }
 
-        impl From<Response> for $v::standout::app::http::Response {
-            fn from(r: Response) -> Self {
-                Self {
-                    status: r.status,
-                    headers: r.headers,
-                    body: r.body,
-                }
-            }
-        }
-
         impl From<Request> for $v::standout::app::http::Request {
             fn from(r: Request) -> Self {
                 Self {
@@ -243,6 +233,32 @@ macro_rules! impl_http_type_conversions {
     };
 }
 
+macro_rules! impl_http_response_conversion {
+    ($v:ident, with_bytes) => {
+        impl From<Response> for $v::standout::app::http::Response {
+            fn from(r: Response) -> Self {
+                Self {
+                    status: r.status,
+                    headers: r.headers,
+                    body: r.body,
+                    body_bytes: r.body_bytes,
+                }
+            }
+        }
+    };
+    ($v:ident, no_bytes) => {
+        impl From<Response> for $v::standout::app::http::Response {
+            fn from(r: Response) -> Self {
+                Self {
+                    status: r.status,
+                    headers: r.headers,
+                    body: r.body,
+                }
+            }
+        }
+    };
+}
+
 // ============================================================================
 // Generate implementations for all supported versions
 // When adding v5, just add:
@@ -253,15 +269,28 @@ macro_rules! impl_http_type_conversions {
 impl_host_request_builder!(v3, no);
 impl_host_request_builder!(v4, no);
 impl_host_request_builder!(v4_1, yes);
+impl_host_request_builder!(v5, yes);
 
 impl_http_type_conversions!(v3);
-// Note: v4 doesn't need conversions since we use v4 types as the canonical internal types
 impl_http_type_conversions!(v4_1);
+impl_http_type_conversions!(v5);
+impl_http_response_conversion!(v3, no_bytes);
+impl_http_response_conversion!(v4, no_bytes);
+impl_http_response_conversion!(v4_1, with_bytes);
+impl_http_response_conversion!(v5, with_bytes);
 
 // ============================================================================
 // Shared request sending logic
 // ============================================================================
 
+#[derive(Debug, Clone)]
+struct Response {
+    status: u16,
+    headers: Vec<(String, String)>,
+    body: String,
+    body_bytes: Option<Vec<u8>>,
+}
+
 fn send_request(
     client: &std::sync::Arc<std::sync::Mutex<reqwest::blocking::Client>>,
     request: &Request,
@@ -281,6 +310,7 @@ fn send_request(
 
     match builder.send() {
         Ok(resp) => {
+            let status = resp.status().as_u16();
             let headers = resp
                 .headers()
                 .iter()
@@ -292,10 +322,14 @@ fn send_request(
                 })
                 .collect();
 
+            let bytes = resp.bytes().unwrap_or_default().to_vec();
+            let body = String::from_utf8(bytes.clone()).unwrap_or_default();
+
             Ok(Response {
-                status: resp.status().as_u16(),
+                status,
                 headers,
-                body: resp.text().unwrap_or_default(),
+                body,
+                body_bytes: Some(bytes),
             })
         }
         Err(error) => Err(RequestError::Other(format!(
@@ -343,6 +377,7 @@ impl Default for Response {
             status: 0,
             headers: Vec::new(),
             body: String::new(),
+            body_bytes: None,
         }
     }
 }
@@ -422,4 +457,30 @@ mod tests {
         assert_eq!(response.status, 200);
         mock.assert();
     }
+
+    #[test]
+    fn returns_binary_response_body_bytes() {
+        use v4_1::standout::app::http::HostRequestBuilder;
+
+        let server = MockServer::start();
+        let body = b"%PDF-1.3".to_vec();
+        let mock = server.mock(|when, then| {
+            when.method(POST).path("/download");
+            then.status(200)
+                .header("Content-Type", "application/pdf")
+                .body(body.clone());
+        });
+        let url = format!("{}/download", server.base_url());
+
+        let mut app_state = AppState::default();
+        let builder = app_state.new();
+        let builder = app_state.method(builder, v4_1::standout::app::http::Method::Post);
+        let builder = app_state.url(builder, url);
+
+        let response = app_state.send(builder).expect("Request failed");
+
+        assert_eq!(response.status, 200);
+        assert_eq!(response.body_bytes, Some(body));
+        mock.assert();
+    }
 }

data/ext/app_bridge/src/wrappers/action_context.rs

@@ -1,4 +1,5 @@
-use magnus::{prelude::*, scan_args::scan_args, Error, RHash, Ruby, Symbol, TryConvert, Value};
+use magnus::{prelude::*, scan_args::scan_args, Error, RHash, Ruby, TryConvert, Value};
+use crate::error_mapping::runtime_error;
 use crate::types::{ActionContext, ReferenceObject};
 use super::connection::RConnection;
 
@@ -33,12 +34,12 @@ impl RActionContext {
         retry: Option<Value>,
     ) -> Result<Self, Error> {
         if connection.is_nil() {
-            return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
+            return Err(runtime_error("Connection is required"));
         }
 
         let wrapped_connection: RConnection = match TryConvert::try_convert(connection) {
             Ok(conn) => conn,
-            Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
+            Err(_) => return Err(runtime_error("Connection is required")),
         };
 
         let reference_object = match retry {
@@ -99,12 +100,12 @@ impl TryConvert for RActionContext {
         };
 
         if connection_val.is_nil() {
-            return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
+            return Err(runtime_error("Connection is required"));
         }
 
         let wrapped_connection: RConnection = match TryConvert::try_convert(connection_val) {
             Ok(conn) => conn,
-            Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
+            Err(_) => return Err(runtime_error("Connection is required")),
         };
 
         let inner = ActionContext {
@@ -124,8 +125,8 @@ impl TryConvert for RActionContext {
 fn fetch_hash_string(hash: Value, key: &str) -> Result<String, Error> {
     let value: Value = hash.funcall("[]", (key,))?;
     let value = if value.is_nil() {
-        let symbol = Symbol::new(key);
-        hash.funcall("[]", (symbol,))?
+        let ruby = Ruby::get().unwrap();
+        hash.funcall("[]", (ruby.to_symbol(key),))?
     } else {
         value
     };

data/ext/app_bridge/src/wrappers/app.rs

@@ -5,6 +5,7 @@ use wasmtime::Store;
 
 use crate::app_state::AppState;
 use crate::component::{app, build_engine, build_linker, build_store, BridgeWrapper};
+use crate::error_mapping::runtime_error;
 use crate::types::{ActionContext, ActionResponse, AppError, ErrorCode, TriggerContext, TriggerResponse};
 use super::{
     action_context::RActionContext,
@@ -33,10 +34,45 @@ impl MutRApp {
         if let Some(instance) = &*instance {
             Ok(instance.wit_version().to_string())
         } else {
-            Err(Error::new(
-                magnus::exception::runtime_error(),
-                "App not initialized",
-            ))
+            Err(runtime_error("App not initialized"))
+        }
+    }
+
+    pub fn connections_supported(&self) -> Result<bool, Error> {
+        let binding = self.0.borrow();
+        let instance = binding.instance.borrow();
+
+        if let Some(instance) = &*instance {
+            Ok(instance.connections_supported())
+        } else {
+            Err(runtime_error("App not initialized"))
+        }
+    }
+
+    pub fn connection_config(&self) -> Result<String, Error> {
+        let binding = self.0.borrow();
+        let mut instance = binding.instance.borrow_mut();
+        let mut store = binding.store.borrow_mut();
+
+        if let (Some(instance), Some(store)) = (&mut *instance, &mut *store) {
+            if !instance.connections_supported() {
+                return Err(AppError {
+                    code: ErrorCode::Unsupported,
+                    message: "connections interface not supported by this component version"
+                        .to_string(),
+                }
+                .into());
+            }
+
+            instance.call_connection_config(store).map_err(|err| {
+                runtime_error(format!("Failed to read connection-config: {err}"))
+            })
+        } else {
+            Err(AppError {
+                code: ErrorCode::InternalError,
+                message: "App instance couldn't be initialized".to_string(),
+            }
+            .into())
         }
     }
 
@@ -44,10 +80,7 @@ impl MutRApp {
         let mut this = self.0.borrow_mut();
         let engine = build_engine();
         let linker = build_linker(&engine).map_err(|e| {
-            Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to build linker: {}", e),
-            )
+            runtime_error(format!("Failed to build linker: {}", e))
         })?;
         let mut store = if env_vars.is_empty() {
             build_store(&engine, None)
@@ -57,12 +90,9 @@ impl MutRApp {
 
         let app = app(component_path.clone(), engine, &mut store, linker).map_err(|e| {
             if e.to_string().contains("Incompatible WASM file version") {
-                Error::new(magnus::exception::runtime_error(), e.to_string())
+                runtime_error(e.to_string())
             } else {
-                Error::new(
-                    magnus::exception::runtime_error(),
-                    format!("Failed to initialize app: {}", e),
-                )
+                runtime_error(format!("Failed to initialize app: {}", e))
             }
         })?;
 
@@ -85,10 +115,7 @@ impl MutRApp {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
                         Err(wit_err.clone().into())
                     } else {
-                        Err(Error::new(
-                            magnus::exception::runtime_error(),
-                            format!("Unexpected error: {:?}", err),
-                        ))
+                        Err(runtime_error(format!("Unexpected error: {:?}", err)))
                     }
                 }
             }
@@ -114,10 +141,7 @@ impl MutRApp {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
                         Err(wit_err.clone().into())
                     } else {
-                        Err(Error::new(
-                            magnus::exception::runtime_error(),
-                            format!("Unexpected error: {:?}", err),
-                        ))
+                        Err(runtime_error(format!("Unexpected error: {:?}", err)))
                     }
                 }
             }
@@ -143,10 +167,7 @@ impl MutRApp {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
                         Err(wit_err.clone().into())
                     } else {
-                        Err(Error::new(
-                            magnus::exception::runtime_error(),
-                            format!("Unexpected error: {:?}", err),
-                        ))
+                        Err(runtime_error(format!("Unexpected error: {:?}", err)))
                     }
                 }
             }
@@ -208,10 +229,7 @@ impl MutRApp {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
                         Err(wit_err.clone().into())
                     } else {
-                        Err(Error::new(
-                            magnus::exception::runtime_error(),
-                            format!("Unexpected error: {:?}", err),
-                        ))
+                        Err(runtime_error(format!("Unexpected error: {:?}", err)))
                     }
                 }
             }
@@ -237,10 +255,7 @@ impl MutRApp {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
                         Err(wit_err.clone().into())
                     } else {
-                        Err(Error::new(
-                            magnus::exception::runtime_error(),
-                            format!("Unexpected error: {:?}", err),
-                        ))
+                        Err(runtime_error(format!("Unexpected error: {:?}", err)))
                     }
                 }
             }
@@ -266,10 +281,7 @@ impl MutRApp {
                     if let Some(wit_err) = err.downcast_ref::<AppError>() {
                         Err(wit_err.clone().into())
                     } else {
-                        Err(Error::new(
-                            magnus::exception::runtime_error(),
-                            format!("Unexpected error: {:?}", err),
-                        ))
+                        Err(runtime_error(format!("Unexpected error: {:?}", err)))
                     }
                 }
             }

data/ext/app_bridge/src/wrappers/trigger_context.rs

@@ -1,4 +1,5 @@
 use magnus::{prelude::*, Error, TryConvert, Value};
+use crate::error_mapping::runtime_error;
 use crate::types::TriggerContext;
 use super::connection::RConnection;
 
@@ -11,12 +12,12 @@ pub struct RTriggerContext {
 impl RTriggerContext {
     pub fn new(trigger_id: String, connection: Value, store: String, serialized_input: String) -> Result<Self, Error> {
         if connection.is_nil() {
-            return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
+            return Err(runtime_error("Connection is required"));
         }
 
         let wrapped_connection: RConnection = match TryConvert::try_convert(connection) {
             Ok(conn) => conn,
-            Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
+            Err(_) => return Err(runtime_error("Connection is required")),
         };
 
         let inner = TriggerContext {
@@ -56,12 +57,12 @@ impl TryConvert for RTriggerContext {
         let serialized_input: String = val.funcall("serialized_input", ())?;
 
         if connection_val.is_nil() {
-            return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
+            return Err(runtime_error("Connection is required"));
         }
 
         let wrapped_connection: RConnection = match TryConvert::try_convert(connection_val) {
             Ok(conn) => conn,
-            Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
+            Err(_) => return Err(runtime_error("Connection is required")),
         };
 
         let inner = TriggerContext {

data/ext/app_bridge/wit/v4_1/world.wit

@@ -243,6 +243,8 @@ interface http {
     status: u16,
     headers: headers,
     body: string,
+    /// Raw response payload for binary responses.
+    body-bytes: option<list<u8>>,
   }
 
   record request {