restate-sdk 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e91954de78530040b4ef55bed9b2edda82440f8a376b779fb8d99d6dfc2cc80
-  data.tar.gz: dbb6d5edbbfdbe5d4ed339546a9c28be5c46d771d8e859931bb63791b4eaf55e
+  metadata.gz: 3ce15bde18d1b56824de0e89d3b01a2a8df327c0adf454c922d72bef60a9afae
+  data.tar.gz: 9ceb40425d0be8ffb705e8639a7dc911791c5e77de56965f8b9214b640c7a6e6
 SHA512:
-  metadata.gz: 9092d9e1f3bd1efed1331090c88e2bbe1cb556dcdf99d26a64112583a318eaea8002f44c8e23b86ae9f155cba31917de6a942822e8f7df2441d2b5fae99f7529
-  data.tar.gz: 769a28444a0cbad0bc9aeaac73aa590823a998d939c804e58be68e2fecfb64cd2f6fef45efcb24ef8026d85fb9de73406e5f440174d3f71a05f2a6d85ed7c5f4
+  metadata.gz: edd0c0a9a4dd9df432ca4ee736f96f96daaee2e5485437968b43c9f10de6f1acc7dea1510d2e96436d49a25045f4ef83819fbac09388a1f80dba317d86f157dd
+  data.tar.gz: d94297953c904448104d9b033d9eafabdc63e75f605235aedb31501070ce3b528a590ac1ab7186e4044d6f385039404c6bfbaf8d6c34a0af2d718d5a9efe0029

data/Cargo.lock

@@ -561,7 +561,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "magnus",
  "rb-sys",

data/ext/restate_internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restate_internal"
-version = "0.12.0"
+version = "0.13.0"
 edition = "2021"
 publish = false
 

data/ext/restate_internal/src/lib.rs

@@ -129,6 +129,7 @@ struct RbFailure {
     code: u16,
     message: String,
     stacktrace: Option<String>,
+    metadata: Vec<(String, String)>,
 }
 
 impl RbFailure {
@@ -141,6 +142,17 @@ impl RbFailure {
     fn stacktrace(&self) -> Option<&str> {
         self.stacktrace.as_deref()
     }
+    fn metadata_array(&self) -> Result<RArray, Error> {
+        let ruby = Ruby::get().map_err(|_| Error::new(vm_error_class(), "Ruby not available"))?;
+        let ary = ruby.ary_new_capa(self.metadata.len());
+        for (k, v) in &self.metadata {
+            let pair = ruby.ary_new_capa(2);
+            pair.push(ruby.str_new(k))?;
+            pair.push(ruby.str_new(v))?;
+            ary.push(pair)?;
+        }
+        Ok(ary)
+    }
 }
 
 impl From<TerminalFailure> for RbFailure {
@@ -149,6 +161,7 @@ impl From<TerminalFailure> for RbFailure {
             code: f.code,
             message: f.message,
             stacktrace: None,
+            metadata: f.metadata,
         }
     }
 }
@@ -158,7 +171,7 @@ impl From<RbFailure> for TerminalFailure {
         TerminalFailure {
             code: f.code,
             message: f.message,
-            metadata: vec![],
+            metadata: f.metadata,
         }
     }
 }
@@ -929,17 +942,36 @@ fn parse_headers_array(ary: RArray) -> Result<Vec<Header>, Error> {
 
 // Constructor functions (free functions for use with function! macro)
 
-fn rb_failure_new(code: u16, message: String, stacktrace: Value) -> RbFailure {
+fn rb_failure_new(
+    code: u16,
+    message: String,
+    stacktrace: Value,
+    metadata: Value,
+) -> Result<RbFailure, Error> {
     let st = if stacktrace.is_nil() {
         None
     } else {
         Some(String::try_convert(stacktrace).unwrap_or_default())
     };
-    RbFailure {
+    let md = if metadata.is_nil() {
+        Vec::new()
+    } else {
+        let ary = RArray::try_convert(metadata)?;
+        let mut out = Vec::with_capacity(ary.len());
+        for item in ary.into_iter() {
+            let pair = RArray::try_convert(item)?;
+            let k: String = pair.entry(0)?;
+            let v: String = pair.entry(1)?;
+            out.push((k, v));
+        }
+        out
+    };
+    Ok(RbFailure {
         code,
         message,
         stacktrace: st,
-    }
+        metadata: md,
+    })
 }
 
 fn rb_exponential_retry_config_new(
@@ -1002,12 +1034,13 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     rh_class.define_method("status_code", method!(RbResponseHead::status_code, 0))?;
     rh_class.define_method("headers", method!(RbResponseHead::headers_array, 0))?;
 
-    // Failure - constructor takes (code, message, stacktrace_or_nil)
+    // Failure - constructor takes (code, message, stacktrace_or_nil, metadata_or_nil)
     let failure_class = internal.define_class("Failure", ruby.class_object())?;
-    failure_class.define_singleton_method("new", function!(rb_failure_new, 3))?;
+    failure_class.define_singleton_method("new", function!(rb_failure_new, 4))?;
     failure_class.define_method("code", method!(RbFailure::code, 0))?;
     failure_class.define_method("message", method!(RbFailure::message, 0))?;
     failure_class.define_method("stacktrace", method!(RbFailure::stacktrace, 0))?;
+    failure_class.define_method("metadata", method!(RbFailure::metadata_array, 0))?;
 
     // Void, Suspended, StateKeys
     internal.define_class("Void", ruby.class_object())?;

data/lib/restate/config.rb

@@ -20,9 +20,20 @@ module Restate
     attr_accessor :admin_url
 
     # Default headers sent with every ingress request.
+    # Can be a Hash or a callable (Proc/Lambda) returning a Hash.
+    # A callable is evaluated each time +Restate.client+ is called,
+    # which lets frameworks like Rails inject per-request context
+    # (e.g., team ID, shard routing, auth tokens).
+    #
+    # @example Static headers
+    #   config.ingress_headers = { "Authorization" => "Bearer tok" }
+    #
+    # @example Dynamic headers
+    #   config.ingress_headers = -> { { "X-Team-Id" => Current.team_id } }
     attr_accessor :ingress_headers
 
     # Default headers sent with every admin request.
+    # Accepts the same static Hash or callable forms as +ingress_headers+.
     attr_accessor :admin_headers
 
     def initialize

data/lib/restate/discovery.rb

@@ -41,7 +41,7 @@ module Restate
       compact(
         protocolMode: protocol_mode,
         minProtocolVersion: 5,
-        maxProtocolVersion: 5,
+        maxProtocolVersion: 6,
         services: services
       )
     end

data/lib/restate/errors.rb

@@ -6,12 +6,14 @@ module Restate
   #
   # @example
   #   raise Restate::TerminalError.new('not found', status_code: 404)
+  #   raise Restate::TerminalError.new('bad input', metadata: { 'field' => 'name' })
   class TerminalError < StandardError
-    attr_reader :status_code
+    attr_reader :status_code, :metadata
 
-    def initialize(message = 'Internal Server Error', status_code: 500)
+    def initialize(message = 'Internal Server Error', status_code: 500, metadata: nil)
       super(message)
       @status_code = status_code
+      @metadata = metadata
     end
   end
 

data/lib/restate/server/context.rb

@@ -50,7 +50,7 @@ module Restate
         @vm.sys_write_output_success(out_buffer)
         @vm.sys_end
       rescue TerminalError => e
-        failure = Failure.new(code: e.status_code, message: e.message)
+        failure = Failure.new(code: e.status_code, message: e.message, metadata: e.metadata)
         @vm.sys_write_output_failure(failure)
         @vm.sys_end
       rescue SuspendedError, InternalError
@@ -63,7 +63,7 @@ module Restate
         handled = false
         while cause
           if cause.is_a?(TerminalError)
-            f = Failure.new(code: cause.status_code, message: cause.message)
+            f = Failure.new(code: cause.status_code, message: cause.message, metadata: cause.metadata)
             @vm.sys_write_output_failure(f)
             @vm.sys_end
             handled = true
@@ -472,7 +472,7 @@ module Restate
         when NotReady
           raise "Unexpected NotReady for handle #{handle}"
         when Failure
-          raise TerminalError.new(result.message, status_code: result.code)
+          raise TerminalError.new(result.message, status_code: result.code, metadata: result.metadata)
         else
           block ? yield(result) : result
         end
@@ -561,7 +561,7 @@ module Restate
           buffer = serde.serialize(result)
           @vm.propose_run_completion_success(handle, buffer)
         rescue TerminalError => e
-          failure = Failure.new(code: e.status_code, message: e.message)
+          failure = Failure.new(code: e.status_code, message: e.message, metadata: e.metadata)
           @vm.propose_run_completion_failure(handle, failure)
         rescue SuspendedError, InternalError
           raise

data/lib/restate/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Restate
-  VERSION = '0.12.0'
+  VERSION = '0.13.0'
 end

data/lib/restate/vm.rb

@@ -7,14 +7,19 @@ begin
   RUBY_VERSION =~ /(\d+\.\d+)/
   require_relative "#{Regexp.last_match(1)}/restate_internal"
 rescue LoadError
-  # Fall back to the default location (development builds, source gem installs)
-  require_relative 'restate_internal'
+  begin
+    # rake compile output (ext.lib_dir = 'lib/restate' in Rakefile)
+    require_relative 'restate_internal'
+  rescue LoadError
+    # gem install from source: extconf.rb builds to lib/restate_internal
+    require_relative '../restate_internal'
+  end
 end
 
 module Restate
   # Ruby-side data types for VM results
   Invocation = Struct.new(:invocation_id, :random_seed, :headers, :input_buffer, :key, keyword_init: true)
-  Failure = Struct.new(:code, :message, :stacktrace, keyword_init: true)
+  Failure = Struct.new(:code, :message, :stacktrace, :metadata, keyword_init: true)
 
   class NotReady; end
   class Suspended; end
@@ -157,12 +162,12 @@ module Restate
     end
 
     def propose_run_completion_failure(handle, failure)
-      native_failure = Internal::Failure.new(failure.code, failure.message, nil)
+      native_failure = Internal::Failure.new(failure.code, failure.message, nil, native_metadata(failure))
       @vm.propose_run_completion_failure(handle, native_failure)
     end
 
     def propose_run_completion_transient(handle, failure:, attempt_duration_ms:, config:)
-      native_failure = Internal::Failure.new(failure.code, failure.message, failure.stacktrace)
+      native_failure = Internal::Failure.new(failure.code, failure.message, failure.stacktrace, nil)
       native_config = Internal::ExponentialRetryConfig.new(
         config.initial_interval, config.max_attempts,
         config.max_duration, config.max_interval,
@@ -176,7 +181,7 @@ module Restate
     end
 
     def sys_write_output_failure(failure)
-      native_failure = Internal::Failure.new(failure.code, failure.message, nil)
+      native_failure = Internal::Failure.new(failure.code, failure.message, nil, native_metadata(failure))
       @vm.sys_write_output_failure(native_failure)
     end
 
@@ -198,7 +203,7 @@ module Restate
     end
 
     def sys_complete_awakeable_failure(awakeable_id, failure)
-      native_failure = Internal::Failure.new(failure.code, failure.message, nil)
+      native_failure = Internal::Failure.new(failure.code, failure.message, nil, native_metadata(failure))
       @vm.sys_complete_awakeable_failure(awakeable_id, native_failure)
     end
 
@@ -215,7 +220,7 @@ module Restate
     end
 
     def sys_complete_promise_failure(key, failure)
-      native_failure = Internal::Failure.new(failure.code, failure.message, nil)
+      native_failure = Internal::Failure.new(failure.code, failure.message, nil, native_metadata(failure))
       @vm.sys_complete_promise_failure(key, native_failure)
     end
 
@@ -232,12 +237,19 @@ module Restate
     end
 
     def sys_complete_signal_failure(invocation_id, name, failure)
-      native_failure = Internal::Failure.new(failure.code, failure.message, nil)
+      native_failure = Internal::Failure.new(failure.code, failure.message, nil, native_metadata(failure))
       @vm.sys_complete_signal_failure(invocation_id, name, native_failure)
     end
 
     private
 
+    def native_metadata(failure)
+      md = failure.metadata
+      return nil if md.nil? || md.empty?
+
+      md.map { |k, v| [k.to_s, v.to_s] }
+    end
+
     def map_do_progress(result)
       case result
       when Internal::Suspended
@@ -270,7 +282,7 @@ module Restate
         # The native layer returns RString for both.
         result
       when Internal::Failure
-        Failure.new(code: result.code, message: result.message)
+        Failure.new(code: result.code, message: result.message, metadata: result.metadata.to_h)
       when Internal::StateKeys
         result.keys
       else

data/lib/restate.rb

@@ -76,7 +76,13 @@ module Restate # rubocop:disable Metrics/ModuleLength
   def client
     cfg = config
     Client.new(ingress_url: cfg.ingress_url, admin_url: cfg.admin_url,
-               ingress_headers: cfg.ingress_headers, admin_headers: cfg.admin_headers)
+               ingress_headers: resolve_headers(cfg.ingress_headers),
+               admin_headers: resolve_headers(cfg.admin_headers))
+  end
+
+  # @!visibility private
+  def resolve_headers(headers)
+    headers.respond_to?(:call) ? headers.call : headers
   end
 
   # ── Context accessor (internal) ──

data/sig/restate.rbs

@@ -69,7 +69,8 @@ module Restate
 
   class TerminalError < StandardError
     attr_reader status_code: Integer
-    def initialize: (?String message, ?status_code: Integer) -> void
+    attr_reader metadata: Hash[String, String]?
+    def initialize: (?String message, ?status_code: Integer, ?metadata: Hash[String, String]?) -> void
   end
 
   class SuspendedError < StandardError

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Restate Developers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async