app_bridge 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00d50e19cf07ec17b1726b49439094e14edcd7735c69ac8ac4c949a5debe963c
-  data.tar.gz: 4741cee1c95978801525dbf639890188d824a44f055d24939d43e8fcb8ce796a
+  metadata.gz: 26bd5103440c1de1bd93ea671635a87e8f25d39fc56fef5025752799e6731edd
+  data.tar.gz: 92157e6b2962fadcca66aa24b9baf234bf04e093f0c016cd51d8e7542a8da0b1
 SHA512:
-  metadata.gz: a7690b6f2e084ac20fda5f9307a9dd0d4fc3a2760e6f8aa19c62998e57367b795d32cb4743fdb2adcd70732bebe79e9099953208ccd28a11fdbf1fc7aeb3bdb3
-  data.tar.gz: 6692c79285a2f86cbeb87445082e28d3f415ea909c37115f0d29b5ac0cf5e079d284d1085108cb222c22093eac272bcdfb9739b5feb54f8668532c0ef0ceda8e
+  metadata.gz: f7f8c267d373d1e0f5ffa730956fc5e2d0bdc43f9143c61e3866596efae583d6e9403c2cf4ead9972af4cd16ee6d6097c5fa01d8974017de6f4a8c571316b7a9
+  data.tar.gz: 2bebe7b17a804216f59846866d374b4d2b2439ad77aee6ab1e4d51766dbeba6053b896f2906c0feda378d9cbbaa64b695897351113aa3ee3e157cdec20586d4a

data/Cargo.lock

@@ -55,7 +55,7 @@ checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "app_bridge"
-version = "4.0.0"
+version = "4.1.0"
 dependencies = [
  "base64",
  "httpmock",

data/README.md

@@ -103,6 +103,67 @@ AppBridge.file_uploader = ->(file_data) {
 
 The gem automatically replaces file data with the return value (in this example blob IDs) before returning the action response.
 
+### Multipart Form Data
+
+For `multipart/form-data`, you must build the body manually and set the `Content-Type` header with a boundary. In `standout:app@4.1.0` you can send raw bytes via `body-bytes`; earlier versions only support a string body.
+
+#### In your WASM connector (Rust):
+
+```rust
+let boundary = "----app-bridge-boundary";
+
+let mut body = Vec::new();
+body.extend_from_slice(format!(
+    "--{b}\r\n\
+Content-Disposition: form-data; name=\"metadata\"\r\n\r\n\
+{metadata}\r\n\
+--{b}\r\n\
+Content-Disposition: form-data; name=\"file\"; filename=\"invoice.pdf\"\r\n\
+Content-Type: application/pdf\r\n\r\n",
+    b = boundary,
+    metadata = metadata_json,
+).as_bytes());
+body.extend_from_slice(&file_bytes);
+body.extend_from_slice(format!("\r\n--{b}--\r\n", b = boundary).as_bytes());
+
+let response = RequestBuilder::new()
+    .method(Method::Post)
+    .url(upload_url)
+    .header("Content-Type", format!("multipart/form-data; boundary={}", boundary))
+    .body_bytes(body)
+    .send()?;
+```
+
+If you are targeting `standout:app@4.0.0` or earlier, you can only send a string body. That means multipart uploads must be base64-encoded and the receiving API must support `Content-Transfer-Encoding: base64`.
+
+## Retry With Reference
+
+`standout:app@4.1.0` introduces a structured retry error for actions. Connectors can return a retry error with a reference and status, and the platform can pass that back on subsequent retries via `action-context.reference-object`.
+
+### In your WASM connector (Rust)
+
+```rust
+return Err(AppError {
+    code: ErrorCode::RetryWithReference(ReferenceObject {
+        reference: request_id.to_string(),
+        status: status.to_string(),
+    }),
+    message: "Background request still processing".to_string(),
+});
+```
+
+### In the Ruby platform
+
+When the connector returns `retry-with-reference`, the bridge raises `AppBridge::RetryWithReferenceError`. You can access the structured fields:
+
+```ruby
+rescue AppBridge::RetryWithReferenceError => e
+  e.reference # => "ref-123"
+  e.status    # => "queued"
+  e.message   # => "Background request still processing after 1 attempts."
+end
+```
+
 ## Backward Compatibility
 
 The gem supports **multi-version WIT interfaces**, allowing connectors built against older WIT versions to continue working when the gem is updated.

data/ext/app_bridge/Cargo.toml

@@ -2,7 +2,7 @@
 name = "app_bridge"
 # When updating the version, please also update the version in the
 # lib/app_bridge/version.rb file to keep them in sync.
-version = "4.0.0"
+version = "4.1.0"
 edition = "2021"
 authors = ["Alexander Ross <ross@standout.se>"]
 publish = false

data/ext/app_bridge/src/app_state.rs

@@ -1,4 +1,4 @@
-use crate::component::{v3, v4};
+use crate::component::{v3, v4, v4_1};
 use crate::component::v4::standout::app::http::Request;
 use reqwest::blocking::Client;
 use std::collections::HashMap;
@@ -11,6 +11,7 @@ pub struct AppState {
     table: ResourceTable,
     pub client: Arc<Mutex<Client>>,
     pub request_list: HashMap<u32, Request>,
+    pub request_body_bytes: HashMap<u32, Vec<u8>>,
     pub next_request_id: u32,
     pub environment_variables: HashMap<String, String>,
 }
@@ -22,6 +23,7 @@ impl AppState {
             table: ResourceTable::new(),
             client: Arc::new(Mutex::new(Client::new())),
             request_list: HashMap::new(),
+            request_body_bytes: HashMap::new(),
             next_request_id: 0,
             environment_variables: env_vars.unwrap_or_default(),
         }
@@ -53,6 +55,7 @@ macro_rules! impl_host_for_version {
 // Apply to both versions
 impl_host_for_version!(v3);
 impl_host_for_version!(v4);
+impl_host_for_version!(v4_1);
 
 // ============================================================================
 // WASI implementations

data/ext/app_bridge/src/component.rs

@@ -7,7 +7,7 @@ use wasmtime_wasi::p2::WasiCtxBuilder;
 use crate::app_state::AppState;
 use crate::types::{
     ActionContext, ActionResponse, AppError, Connection, ErrorCode, TriggerContext,
-    TriggerEvent, TriggerResponse,
+    ReferenceObject, TriggerEvent, TriggerResponse,
 };
 
 // ============================================================================
@@ -35,13 +35,19 @@ pub mod v4 {
     });
 }
 
+pub mod v4_1 {
+    wasmtime::component::bindgen!({
+        path: "./wit/v4_1",
+        world: "bridge",
+    });
+}
+
 // ============================================================================
 // Version conversion macro - generates From impls for a version module
 // ============================================================================
 
-macro_rules! impl_conversions {
-    ($v:ident) => {
-        // ErrorCode: version → canonical
+macro_rules! impl_error_code_conversion {
+    ($v:ident, $($extra_arms:tt)*) => {
         impl From<$v::standout::app::types::ErrorCode> for ErrorCode {
             fn from(c: $v::standout::app::types::ErrorCode) -> Self {
                 use $v::standout::app::types::ErrorCode as V;
@@ -56,19 +62,17 @@ macro_rules! impl_conversions {
                     V::InternalError => Self::InternalError,
                     V::MalformedResponse => Self::MalformedResponse,
                     V::Other => Self::Other,
+                    $($extra_arms)*
                     V::CompleteWorkflow => Self::CompleteWorkflow,
                     V::CompleteParent => Self::CompleteParent,
                 }
             }
         }
+    };
+}
 
-        // AppError: version → canonical
-        impl From<$v::standout::app::types::AppError> for AppError {
-            fn from(e: $v::standout::app::types::AppError) -> Self {
-                Self { code: e.code.into(), message: e.message }
-            }
-        }
-
+macro_rules! impl_conversions {
+    ($v:ident) => {
         // TriggerEvent: version → canonical
         impl From<$v::standout::app::types::TriggerEvent> for TriggerEvent {
             fn from(e: $v::standout::app::types::TriggerEvent) -> Self {
@@ -116,7 +120,24 @@ macro_rules! impl_conversions {
             }
         }
 
-        // ActionContext: canonical → version
+    };
+}
+
+macro_rules! impl_app_error_conversion {
+    ($v:ident) => {
+        impl From<$v::standout::app::types::AppError> for AppError {
+            fn from(e: $v::standout::app::types::AppError) -> Self {
+                Self {
+                    code: e.code.into(),
+                    message: e.message,
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_action_context_conversion_basic {
+    ($v:ident) => {
         impl From<&ActionContext> for $v::standout::app::types::ActionContext {
             fn from(c: &ActionContext) -> Self {
                 Self {
@@ -129,9 +150,55 @@ macro_rules! impl_conversions {
     };
 }
 
+macro_rules! impl_action_context_conversion_retry {
+    ($v:ident) => {
+        impl From<&ActionContext> for $v::standout::app::types::ActionContext {
+            fn from(c: &ActionContext) -> Self {
+                Self {
+                    action_id: c.action_id.clone(),
+                    connection: (&c.connection).into(),
+                    serialized_input: c.serialized_input.clone(),
+                    reference_object: c.reference_object.as_ref().map(Into::into),
+                }
+            }
+        }
+    };
+}
+
+impl From<v4_1::standout::app::types::ReferenceObject> for ReferenceObject {
+    fn from(r: v4_1::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 {
+            reference: r.reference.clone(),
+            status: r.status.clone(),
+        }
+    }
+}
+
 // Generate conversions for all supported versions
+impl_error_code_conversion!(v3,);
 impl_conversions!(v3);
+impl_app_error_conversion!(v3);
+impl_action_context_conversion_basic!(v3);
+impl_error_code_conversion!(v4,);
 impl_conversions!(v4);
+impl_app_error_conversion!(v4);
+impl_action_context_conversion_basic!(v4);
+impl_error_code_conversion!(
+    v4_1,
+    V::RetryWithReference(r) => Self::RetryWithReference(r.into()),
+);
+impl_conversions!(v4_1);
+impl_app_error_conversion!(v4_1);
+impl_action_context_conversion_retry!(v4_1);
 
 // ============================================================================
 // BridgeWrapper - unified interface for all component versions
@@ -142,6 +209,7 @@ impl_conversions!(v4);
 pub enum BridgeWrapper {
     V3(v3::Bridge),
     V4(v4::Bridge),
+    V4_1(v4_1::Bridge),
 }
 
 impl BridgeWrapper {
@@ -150,6 +218,7 @@ impl BridgeWrapper {
         match self {
             BridgeWrapper::V3(_) => "3.0.0",
             BridgeWrapper::V4(_) => "4.0.0",
+            BridgeWrapper::V4_1(_) => "4.1.0",
         }
     }
 }
@@ -169,6 +238,10 @@ macro_rules! bridge_method {
                     let r = b.$interface().$method(store)?;
                     Ok(r.map_err(Into::into))
                 }
+                BridgeWrapper::V4_1(b) => {
+                    let r = b.$interface().$method(store)?;
+                    Ok(r.map_err(Into::into))
+                }
             }
         }
     };
@@ -184,6 +257,10 @@ macro_rules! bridge_method {
                     let r = b.$interface().$method(store, &ctx.into())?;
                     Ok(r.map(Into::into).map_err(Into::into))
                 }
+                BridgeWrapper::V4_1(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
             }
         }
     };
@@ -199,6 +276,10 @@ macro_rules! bridge_method {
                     let r = b.$interface().$method(store, &ctx.into())?;
                     Ok(r.map(Into::into).map_err(Into::into))
                 }
+                BridgeWrapper::V4_1(b) => {
+                    let r = b.$interface().$method(store, &ctx.into())?;
+                    Ok(r.map(Into::into).map_err(Into::into))
+                }
             }
         }
     };
@@ -242,6 +323,11 @@ pub fn build_linker(engine: &Engine) -> Result<Linker<AppState>> {
     v4::standout::app::environment::add_to_linker(&mut linker, |s| s)?;
     v4::standout::app::file::add_to_linker(&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)?;
+
     // 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)?;
@@ -274,7 +360,12 @@ pub fn app(
     let component = Component::from_file(&engine, &file_path)?;
 
     // Try versions newest-first. When adding vN, insert at the top.
-    // v4 (current - has file interface)
+    // v4.1 (current - has file interface)
+    if let Ok(instance) = v4_1::Bridge::instantiate(&mut *store, &component, &linker) {
+        return Ok(BridgeWrapper::V4_1(instance));
+    }
+
+    // v4
     if let Ok(instance) = v4::Bridge::instantiate(&mut *store, &component, &linker) {
         return Ok(BridgeWrapper::V4(instance));
     }
@@ -285,6 +376,6 @@ pub fn app(
     }
 
     Err(wasmtime::Error::msg(
-        "Failed to instantiate component: no compatible WIT version found (tried v4, v3)",
+        "Failed to instantiate component: no compatible WIT version found (tried v4.1, v4, v3)",
     ))
 }

data/ext/app_bridge/src/error_mapping.rs

@@ -1,5 +1,6 @@
 use crate::types::{AppError, ErrorCode};
-use magnus::{Error, ExceptionClass, Ruby};
+use magnus::prelude::*;
+use magnus::{Error, ExceptionClass, RObject, Ruby};
 
 impl From<ErrorCode> for ExceptionClass {
     fn from(value: ErrorCode) -> Self {
@@ -19,6 +20,7 @@ impl From<ErrorCode> for ExceptionClass {
             ErrorCode::InternalError => get_class("AppBridge::InternalError"),
             ErrorCode::MalformedResponse => get_class("AppBridge::MalformedResponseError"),
             ErrorCode::Other => get_class("AppBridge::OtherError"),
+            ErrorCode::RetryWithReference(_) => get_class("AppBridge::RetryWithReferenceError"),
             ErrorCode::CompleteWorkflow => get_class("AppBridge::CompleteWorkflowException"),
             ErrorCode::CompleteParent => get_class("AppBridge::CompleteParentException"),
         }
@@ -27,6 +29,20 @@ impl From<ErrorCode> for ExceptionClass {
 
 impl From<AppError> for Error {
     fn from(value: AppError) -> Self {
+        if let ErrorCode::RetryWithReference(retry) = value.code.clone() {
+            let class: ExceptionClass = value.code.into();
+            let message = value.message;
+            if let Ok(exception) = class.new_instance((message.as_str(),)) {
+                if let Ok(exception_value) = RObject::try_convert(exception.as_value()) {
+                    let _ = exception_value.ivar_set("@reference", retry.reference);
+                    let _ = exception_value.ivar_set("@status", retry.status);
+                }
+                return Error::from(exception);
+            }
+
+            return Error::new(class, message);
+        }
+
         Error::new(value.code.into(), value.message)
     }
 }

data/ext/app_bridge/src/file_ops.rs

@@ -1,5 +1,5 @@
 use crate::app_state::AppState;
-use crate::component::v4;
+use crate::component::{v4, v4_1};
 use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
 
 /// Detects the type of input string
@@ -256,6 +256,7 @@ macro_rules! impl_file_host {
 // Note: v3 doesn't have the file interface, so no impl needed
 // When adding v5, add: impl_file_host!(v5);
 impl_file_host!(v4);
+impl_file_host!(v4_1);
 
 #[cfg(test)]
 mod tests {

data/ext/app_bridge/src/lib.rs

@@ -1,4 +1,4 @@
-use magnus::{function, method, prelude::*, Error, Ruby};
+use magnus::{function, method, prelude::*, Error, RObject, Ruby, Value};
 mod app_state;
 mod component;
 mod error_mapping;
@@ -15,6 +15,16 @@ use wrappers::action_context::RActionContext;
 use wrappers::action_response::RActionResponse;
 use wrappers::app::MutRApp;
 
+fn retry_reference(exception: Value) -> Result<Value, Error> {
+    let exception = RObject::try_convert(exception)?;
+    exception.ivar_get("@reference")
+}
+
+fn retry_status(exception: Value) -> Result<Value, Error> {
+    let exception = RObject::try_convert(exception)?;
+    exception.ivar_get("@status")
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("AppBridge")?;
@@ -30,6 +40,9 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_error("InternalError", error)?;
     module.define_error("MalformedResponseError", error)?;
     module.define_error("OtherError", error)?;
+    let retry_error = module.define_error("RetryWithReferenceError", error)?;
+    retry_error.define_method("reference", method!(retry_reference, 0))?;
+    retry_error.define_method("status", method!(retry_status, 0))?;
     module.define_error("CompleteWorkflowException", error)?;
     module.define_error("CompleteParentException", error)?;
 
@@ -62,10 +75,11 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 
     // Define the Action classes
     let action_context_class = module.define_class("ActionContext", ruby.class_object())?;
-    action_context_class.define_singleton_method("new", function!(RActionContext::new, 3))?;
+    action_context_class.define_singleton_method("new", function!(RActionContext::new, -1))?;
     action_context_class.define_method("action_id", method!(RActionContext::action_id, 0))?;
     action_context_class.define_method("connection", method!(RActionContext::connection, 0))?;
     action_context_class.define_method("serialized_input", method!(RActionContext::serialized_input, 0))?;
+    action_context_class.define_method("reference_object", method!(RActionContext::reference_object, 0))?;
 
     let action_response_class = module.define_class("ActionResponse", ruby.class_object())?;
     action_response_class.define_singleton_method("new", function!(RActionResponse::new, 1))?;

data/ext/app_bridge/src/request_builder.rs

@@ -1,5 +1,5 @@
 use crate::app_state::AppState;
-use crate::component::{v3, v4};
+use crate::component::{v3, v4, v4_1};
 use crate::component::v4::standout::app::http::{Method, Request, RequestError, Response};
 use reqwest::Method as ReqwestMethod;
 use std::result::Result::Ok;
@@ -14,7 +14,7 @@ use wasmtime::component::Resource;
 // ============================================================================
 
 macro_rules! impl_host_request_builder {
-    ($v:ident) => {
+    ($v:ident, $has_body_bytes:ident) => {
         impl $v::standout::app::http::HostRequestBuilder for AppState {
             fn new(&mut self) -> Resource<$v::standout::app::http::RequestBuilder> {
                 let id = self.next_request_id;
@@ -34,6 +34,9 @@ macro_rules! impl_host_request_builder {
                     let new_id = self.next_request_id;
                     self.next_request_id += 1;
                     self.request_list.insert(new_id, request);
+                    if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                        self.request_body_bytes.insert(new_id, bytes);
+                    }
                     Resource::new_own(new_id)
                 } else {
                     Resource::new_own(id)
@@ -51,6 +54,9 @@ macro_rules! impl_host_request_builder {
                     let new_id = self.next_request_id;
                     self.next_request_id += 1;
                     self.request_list.insert(new_id, request);
+                    if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                        self.request_body_bytes.insert(new_id, bytes);
+                    }
                     Resource::new_own(new_id)
                 } else {
                     Resource::new_own(id)
@@ -69,6 +75,9 @@ macro_rules! impl_host_request_builder {
                 let new_id = self.next_request_id;
                 self.next_request_id += 1;
                 self.request_list.insert(new_id, request);
+                if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                    self.request_body_bytes.insert(new_id, bytes);
+                }
                 Resource::new_own(new_id)
             }
 
@@ -83,6 +92,9 @@ macro_rules! impl_host_request_builder {
                 let new_id = self.next_request_id;
                 self.next_request_id += 1;
                 self.request_list.insert(new_id, request);
+                if let Some(bytes) = self.request_body_bytes.get(&id).cloned() {
+                    self.request_body_bytes.insert(new_id, bytes);
+                }
                 Resource::new_own(new_id)
             }
 
@@ -97,6 +109,7 @@ macro_rules! impl_host_request_builder {
                 let new_id = self.next_request_id;
                 self.next_request_id += 1;
                 self.request_list.insert(new_id, request);
+                self.request_body_bytes.remove(&new_id);
                 Resource::new_own(new_id)
             }
 
@@ -106,9 +119,12 @@ macro_rules! impl_host_request_builder {
             ) -> Result<$v::standout::app::http::Response, $v::standout::app::http::RequestError> {
                 let id = self_.rep();
                 match self.request_list.get(&id).cloned() {
-                    Some(request) => send_request(&self.client, &request)
-                        .map(Into::into)
-                        .map_err(Into::into),
+                    Some(request) => {
+                        let body_bytes = self.request_body_bytes.get(&id).map(|b| b.as_slice());
+                        send_request(&self.client, &request, body_bytes)
+                            .map(Into::into)
+                            .map_err(Into::into)
+                    }
                     None => Err($v::standout::app::http::RequestError::Other(
                         "Request not found".to_string(),
                     )),
@@ -120,6 +136,7 @@ macro_rules! impl_host_request_builder {
                 rep: Resource<$v::standout::app::http::RequestBuilder>,
             ) -> wasmtime::Result<()> {
                 self.request_list.remove(&rep.rep());
+                self.request_body_bytes.remove(&rep.rep());
                 Ok(())
             }
 
@@ -133,10 +150,33 @@ macro_rules! impl_host_request_builder {
                     .unwrap_or_default()
                     .into()
             }
+
+            impl_host_request_builder_body_bytes!($v, $has_body_bytes);
+        }
+    };
+}
+
+macro_rules! impl_host_request_builder_body_bytes {
+    ($v:ident, yes) => {
+        fn body_bytes(
+            &mut self,
+            self_: Resource<$v::standout::app::http::RequestBuilder>,
+            body: Vec<u8>,
+        ) -> Resource<$v::standout::app::http::RequestBuilder> {
+            let id = self_.rep();
+            let mut request = self.request_list.get(&id).cloned().unwrap_or_default();
+            request.body.clear();
+            let new_id = self.next_request_id;
+            self.next_request_id += 1;
+            self.request_list.insert(new_id, request);
+            self.request_body_bytes.insert(new_id, body);
+            Resource::new_own(new_id)
         }
     };
+    ($v:ident, no) => {};
 }
 
+
 // ============================================================================
 // Macro to implement HTTP type conversions for a version
 // ============================================================================
@@ -210,11 +250,13 @@ macro_rules! impl_http_type_conversions {
 //   impl_http_type_conversions!(v5);
 // ============================================================================
 
-impl_host_request_builder!(v3);
-impl_host_request_builder!(v4);
+impl_host_request_builder!(v3, no);
+impl_host_request_builder!(v4, no);
+impl_host_request_builder!(v4_1, 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);
 
 // ============================================================================
 // Shared request sending logic
@@ -223,6 +265,7 @@ impl_http_type_conversions!(v3);
 fn send_request(
     client: &std::sync::Arc<std::sync::Mutex<reqwest::blocking::Client>>,
     request: &Request,
+    body_bytes: Option<&[u8]>,
 ) -> Result<Response, RequestError> {
     let client = client.lock().unwrap();
     let mut builder = client.request(request.method.clone().into(), &request.url);
@@ -230,7 +273,11 @@ fn send_request(
     for (key, value) in &request.headers {
         builder = builder.header(key, value);
     }
-    builder = builder.body(request.body.clone());
+    builder = if let Some(bytes) = body_bytes {
+        builder.body(bytes.to_vec())
+    } else {
+        builder.body(request.body.clone())
+    };
 
     match builder.send() {
         Ok(resp) => {
@@ -321,7 +368,7 @@ impl std::fmt::Display for Method {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use httpmock::{Method::GET, MockServer};
+    use httpmock::{Method::GET, Method::POST, MockServer};
 
     #[test]
     fn sends_request_with_default_user_agent() {
@@ -349,4 +396,30 @@ mod tests {
         assert_eq!(response.status, 200);
         mock.assert();
     }
+
+    #[test]
+    fn sends_binary_body_when_bytes_present() {
+        use v4_1::standout::app::http::HostRequestBuilder;
+
+        let server = MockServer::start();
+        let mock = server.mock(|when, then| {
+            when.method(POST)
+                .path("/upload")
+                .body("raw-bytes");
+            then.status(200);
+        });
+        let url = format!("{}/upload", 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 builder = app_state.body(builder, "string-body".to_string());
+        let builder = app_state.body_bytes(builder, b"raw-bytes".to_vec());
+
+        let response = app_state.send(builder).expect("Request failed");
+
+        assert_eq!(response.status, 200);
+        mock.assert();
+    }
 }

data/ext/app_bridge/src/types.rs

@@ -14,6 +14,15 @@ pub struct AppError {
     pub message: String,
 }
 
+impl AppError {
+    pub fn new(code: ErrorCode, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+        }
+    }
+}
+
 impl fmt::Display for AppError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}: {}", self.code, self.message)
@@ -22,7 +31,7 @@ impl fmt::Display for AppError {
 
 impl std::error::Error for AppError {}
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub enum ErrorCode {
     Unauthenticated,
     Forbidden,
@@ -34,10 +43,17 @@ pub enum ErrorCode {
     InternalError,
     MalformedResponse,
     Other,
+    RetryWithReference(ReferenceObject),
     CompleteWorkflow,
     CompleteParent,
 }
 
+#[derive(Debug, Clone)]
+pub struct ReferenceObject {
+    pub reference: String,
+    pub status: String,
+}
+
 #[derive(Debug, Clone)]
 pub struct Connection {
     pub id: String,
@@ -58,6 +74,7 @@ pub struct ActionContext {
     pub action_id: String,
     pub connection: Connection,
     pub serialized_input: String,
+    pub reference_object: Option<ReferenceObject>,
 }
 
 #[derive(Debug, Clone)]

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

@@ -1,5 +1,5 @@
-use magnus::{prelude::*, Error, TryConvert, Value};
-use crate::types::ActionContext;
+use magnus::{prelude::*, scan_args::scan_args, Error, RHash, Ruby, Symbol, TryConvert, Value};
+use crate::types::{ActionContext, ReferenceObject};
 use super::connection::RConnection;
 
 #[magnus::wrap(class = "AppBridge::ActionContext")]
@@ -9,7 +9,29 @@ pub struct RActionContext {
 }
 
 impl RActionContext {
-    pub fn new(action_id: String, connection: Value, serialized_input: String) -> Result<Self, Error> {
+    fn parse_reference_object(value: Value) -> Result<ReferenceObject, Error> {
+        let reference: String = fetch_hash_string(value, "reference")?;
+        let status: String = fetch_hash_string(value, "status")?;
+        Ok(ReferenceObject {
+            reference,
+            status,
+        })
+    }
+
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::<(String, Value, String), (Option<Value>,), (), (), (), ()>(args)?;
+        let (action_id, connection, serialized_input) = args.required;
+        let (retry,) = args.optional;
+
+        Self::build(action_id, connection, serialized_input, retry)
+    }
+
+    fn build(
+        action_id: String,
+        connection: Value,
+        serialized_input: String,
+        retry: Option<Value>,
+    ) -> Result<Self, Error> {
         if connection.is_nil() {
             return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
         }
@@ -19,14 +41,18 @@ impl RActionContext {
             Err(_) => return Err(Error::new(magnus::exception::runtime_error(), "Connection is required")),
         };
 
-        let inner = ActionContext {
-            action_id,
-            connection: wrapped_connection.clone().into(),
-            serialized_input,
+        let reference_object = match retry {
+            Some(value) if !value.is_nil() => Some(Self::parse_reference_object(value)?),
+            _ => None,
         };
 
         Ok(Self {
-            inner,
+            inner: ActionContext {
+                action_id,
+                connection: wrapped_connection.clone().into(),
+                serialized_input,
+                reference_object,
+            },
             wrapped_connection: Some(wrapped_connection),
         })
     }
@@ -42,6 +68,18 @@ impl RActionContext {
     pub fn serialized_input(&self) -> String {
         self.inner.serialized_input.clone()
     }
+
+    pub fn reference_object(&self) -> Result<Value, Error> {
+        let ruby = Ruby::get().unwrap();
+        if let Some(reference_object) = &self.inner.reference_object {
+            let hash: RHash = ruby.hash_new();
+            hash.aset("reference", reference_object.reference.clone())?;
+            hash.aset("status", reference_object.status.clone())?;
+            Ok(hash.as_value())
+        } else {
+            Ok(ruby.qnil().as_value())
+        }
+    }
 }
 
 impl TryConvert for RActionContext {
@@ -49,6 +87,16 @@ impl TryConvert for RActionContext {
         let connection_val: Value = val.funcall("connection", ())?;
         let serialized_input: String = val.funcall("serialized_input", ())?;
         let action_id: String = val.funcall("action_id", ())?;
+        let reference_object = if val.funcall("respond_to?", ("reference_object",))? {
+            let reference_object_val: Value = val.funcall("reference_object", ())?;
+            if reference_object_val.is_nil() {
+                None
+            } else {
+                Some(Self::parse_reference_object(reference_object_val)?)
+            }
+        } else {
+            None
+        };
 
         if connection_val.is_nil() {
             return Err(Error::new(magnus::exception::runtime_error(), "Connection is required"));
@@ -63,6 +111,7 @@ impl TryConvert for RActionContext {
             action_id,
             connection: wrapped_connection.clone().inner,
             serialized_input,
+            reference_object,
         };
 
         Ok(Self {
@@ -72,6 +121,18 @@ 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,))?
+    } else {
+        value
+    };
+    TryConvert::try_convert(value)
+}
+
+
 impl From<RActionContext> for ActionContext {
     fn from(raction_context: RActionContext) -> Self {
         raction_context.inner

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

@@ -0,0 +1,343 @@
+package standout:app@4.1.0;
+
+interface types {
+  // The trigger-store is a string that is used to store data between trigger
+  // invocations. It is unique per trigger instance and is persisted between
+  // invocations.
+  //
+  // You can store any string here. We suggest that you use a serialized
+  // JSON object or similar since that will give you some flexibility if you
+  // need to add more data to the store.
+  type trigger-store = string;
+
+  record connection {
+    id: string,
+    name: string,
+    // The connection data is a JSON object serialized into a string. The JSON root
+    // will always be an object.
+    serialized-data: string,
+  }
+
+  record trigger-context {
+    // Trigger ID is a unique identifier for the trigger that is requested to be
+    // invoked.
+    trigger-id: string,
+
+    // The connection that the trigger is invoked for.
+    // Connection is required for all trigger operations.
+    connection: connection,
+
+    // The store will contain the data that was stored in the trigger store the
+    // last time the trigger was invoked.
+    store: trigger-store,
+
+    // The input data for the trigger, serialized as a JSON object string.
+    // This contains the input data from the trigger configuration form.
+    serialized-input: string,
+  }
+
+  record action-context {
+    // Action ID is a unique identifier for the action that is requested to be
+    // invoked.
+    action-id: string,
+
+    // The connection that the action is invoked for.
+    // Connection is required for all action operations.
+    connection: connection,
+
+    // The input data for the action, serialized as a JSON object string.
+    // This contains the data passed from the previous step in the workflow.
+    serialized-input: string,
+
+    // Optional reference information when the platform retries an action.
+    reference-object: option<reference-object>,
+  }
+
+  record trigger-response {
+    // The trigger events, each event will be used to spawn a new workflow
+    // execution in Standouts integration platform.
+    events: list<trigger-event>,
+
+    // The updated store will be stored and used the next time the trigger is
+    // invoked.
+    store: trigger-store,
+  }
+
+  record action-response {
+    // The output data from the action, serialized as a JSON object string.
+    // This contains the data that will be passed to the next step in the workflow.
+    // The data must be a valid JSON object (not an array or primitive).
+    serialized-output: string
+  }
+
+  record trigger-event {
+    // The ID of the trigger event
+    //
+    // If the connection used for the given instance of the trigger is the same,
+    // as seen before. Then the event will be ignored.
+    //
+    // A scheduler could therefore use a timestamp as the ID, to ensure that
+    // the event is only triggered once per given time.
+    //
+    // A trigger that acts on created orders in a e-commerce system could use
+    // the order ID as the ID, to ensure that the event is only triggered once
+    // per order.
+    //
+    // A trigger that acts on updated orders in a e-commerce system could use
+    // the order ID in combination with an updated at timestamp as the ID, to
+    // ensure that the event is only triggered once per order update.
+    id: string,
+
+    // Serialized data must be a JSON object serialized into a string
+    // Note that it is important that the root is an object, not an array,
+    // or another primitive type.
+    serialized-data: string,
+  }
+
+  /// Retry reference payload returned with error-code.retry-with-reference.
+  record reference-object {
+    /// Reference ID provided for retrying this request later.
+    reference: string,
+
+    /// Status describing the retry state.
+    status: string,
+  }
+
+  record app-error {
+    /// The error code identifying the type of failure.
+    code: error-code,
+
+    /// A human-readable message describing the error in more detail.
+    message: string,
+  }
+
+  /// An enumeration of error codes that can be returned by a trigger implementation.
+  /// These codes help the platform and plugin developers distinguish between different types of failures.
+  variant error-code {
+    /// Authentication failed. Typically due to an invalid or expired API key or token.
+    unauthenticated,
+
+    /// Authorization failed. The connection is valid but does not have the necessary permissions.
+    forbidden,
+
+    /// The trigger is misconfigured. For example, a required setting is missing or invalid.
+    misconfigured,
+
+    /// The target system does not support a required feature or endpoint.
+    unsupported,
+
+    /// The target system is rate-limiting requests. Try again later.
+    rate-limit,
+
+    /// The request timed out. The target system did not respond in time.
+    timeout,
+
+    /// The target system is currently unavailable or unreachable.
+    unavailable,
+
+    /// An unexpected internal error occurred in the plugin.
+    internal-error,
+
+    /// The response from the external system could not be parsed or was in an invalid format.
+    malformed-response,
+
+    /// A catch-all for all other types of errors. Should include a descriptive message.
+    other,
+
+    /// Retry the request using a reference identifier.
+    retry-with-reference(reference-object),
+
+    /// Complete the current workflow execution.
+    complete-workflow,
+
+    /// Complete the parent step execution.
+    complete-parent,
+  }
+}
+
+
+interface triggers {
+  use types.{trigger-context, trigger-event, trigger-response, app-error};
+
+  trigger-ids: func() -> result<list<string>, app-error>;
+
+  // Get the input schema for a specific trigger
+  // Returns a JSON Schema Draft 2020-12 schema as a string
+  // The schema may vary based on the connection in the context
+  // The trigger-id is extracted from the context
+  input-schema: func(context: trigger-context) -> result<string, app-error>;
+
+  // Get the output schema for a specific trigger
+  // Returns a JSON Schema Draft 2020-12 schema as a string
+  // The schema may vary based on the connection in the context
+  // The trigger-id is extracted from the context
+  output-schema: func(context: trigger-context) -> result<string, app-error>;
+
+  // Fetch events
+  //
+  // There are some limitations to the function:
+  // - It must return a `trigger-response` within 30 seconds
+  // - It must return less than or equal to 100 `trigger-response.events`
+  // - It must not return more than 64 kB of data in the `trigger-response.store`
+  //
+  // If you need to fetch more events, you can return up to 100 events and then
+  // store the data needed for you to remember where you left off in the store.
+  // The next time the trigger is invoked, you can use the store to continue
+  // where you left off.
+  //
+  // If you do not pass the limitations the return value will be ignored. We
+  // will not handle any events and we persist the store that was returned in
+  // the response.
+  //
+  // That also means that you should implement your fetch event function in a
+  // way that it can be called multiple times using the same context and return
+  // the same events. That will ensure that the user that is building an
+  // integration with your trigger will not miss any events if your system is
+  // down for a short period of time.
+  fetch-events: func(context: trigger-context) -> result<trigger-response, app-error>;
+}
+
+interface actions {
+  use types.{action-context, action-response, app-error};
+
+  action-ids: func() -> result<list<string>, app-error>;
+
+  // Get the input schema for a specific action
+  // Returns a JSON Schema Draft 2020-12 schema as a string
+  // The schema may vary based on the connection in the context
+  // The action-id is extracted from the context
+  input-schema: func(context: action-context) -> result<string, app-error>;
+
+  // Get the output schema for a specific action
+  // Returns a JSON Schema Draft 2020-12 schema as a string
+  // The schema may vary based on the connection in the context
+  // The action-id is extracted from the context
+  output-schema: func(context: action-context) -> result<string, app-error>;
+
+  // Execute an action
+  //
+  // There are some limitations to the function:
+  // - It must return an `action-response` within 30 seconds
+  // - The serialized-output must be a valid JSON object serialized as a string
+  //
+  // Actions can perform various operations such as:
+  // - Making HTTP requests to external APIs
+  // - Processing and transforming data
+  // - Storing data for future use
+  // - Triggering other systems or workflows
+  //
+  // The action receives input data from the previous step and can return
+  // serialized output data to be passed to the next step in the workflow.
+  execute: func(context: action-context) -> result<action-response, app-error>;
+}
+
+interface environment {
+  // Get all environment variables
+  env-vars: func() -> list<tuple<string, string>>;
+  // Get a specific environment variable by name
+  env-var: func(name: string) -> option<string>;
+}
+
+interface http {
+  record response {
+    status: u16,
+    headers: headers,
+    body: string,
+  }
+
+  record request {
+    method: method,
+    url: string,
+    headers: headers,
+    body: string,
+  }
+
+  variant request-error {
+    other(string)
+  }
+
+  type headers = list<tuple<string, string>>;
+
+  resource request-builder {
+    constructor();
+
+    method: func(method: method) -> request-builder;
+    url: func(url: string) -> request-builder;
+
+    // Add a header to the request
+    header: func(key: string, value: string) -> request-builder;
+    headers: func(headers: list<tuple<string, string>>) -> request-builder;
+
+    // Add a body to the request
+    body: func(body: string) -> request-builder;
+    // Add a binary body to the request
+    body-bytes: func(body: list<u8>) -> request-builder;
+
+    object: func() -> request;
+
+    // Send the request
+    send: func() -> result<response, request-error>;
+  }
+
+  variant method {
+    get,
+    post,
+    put,
+    delete,
+    patch,
+    options,
+    head,
+  }
+}
+
+interface file {
+  // HTTP headers for file requests (same as http interface)
+  type headers = list<tuple<string, string>>;
+
+  // Normalized file data
+  record file-data {
+    // Base64-encoded file content
+    base64: string,
+    // MIME type (e.g., "application/pdf")
+    content-type: string,
+    // Filename
+    filename: string,
+  }
+
+  variant file-error {
+    // Failed to fetch file from URL
+    fetch-failed(string),
+    // Invalid input format (not a valid URL, data URI, or base64)
+    invalid-input(string),
+    // Request timed out
+    timeout(string),
+    // Any other error
+    other(string),
+  }
+
+  // Normalize any file source to FileData
+  //
+  // The source is automatically detected:
+  // - URL: "https://example.com/file.pdf" - fetched with optional headers
+  // - Data URI: "data:application/pdf;base64,JVBERi0..." - parsed and extracted
+  // - Base64: Any other string is treated as raw base64 - decoded to detect type
+  //
+  // Parameters:
+  // - source: URL, data URI, or base64-encoded content
+  // - headers: Optional HTTP headers for URL requests (e.g., Authorization)
+  // - filename: Optional filename override (auto-detected if not provided)
+  //
+  // Returns file-data which will be processed by the platform:
+  // 1. Fields with format: "file-output" in the output schema are identified
+  // 2. File data is uploaded using the configured file_uploader
+  // 3. The file-data is replaced with the blob ID in the response
+  normalize: func(source: string, headers: option<headers>, filename: option<string>) -> result<file-data, file-error>;
+}
+
+world bridge {
+  import http;
+  import environment;
+  import file;
+  export triggers;
+  export actions;
+}

data/lib/app_bridge/version.rb

@@ -4,5 +4,5 @@
 # ext/app_bridge/Cargo.toml file to keep them in sync.
 
 module AppBridge
-  VERSION = "4.0.0"
+  VERSION = "4.1.0"
 end

data/lib/app_bridge.rb

@@ -11,7 +11,6 @@ module AppBridge
   class TooManyEventsError < Error; end
   class StoreTooLargeError < Error; end
   class ActionResponseTooLargeError < Error; end
-  class FileUploadError < Error; end
   class InternalError < Error; end
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: app_bridge
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Alexander Ross
@@ -61,6 +61,7 @@ files:
 - ext/app_bridge/src/wrappers/trigger_response.rs
 - ext/app_bridge/wit/v3/world.wit
 - ext/app_bridge/wit/v4/world.wit
+- ext/app_bridge/wit/v4_1/world.wit
 - lib/app_bridge.rb
 - lib/app_bridge/app.rb
 - lib/app_bridge/file_processor.rb