restate-sdk 0.12.0-x86_64-linux → 0.13.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 756de29f4acfd7f01095a61f9349c1bbdc2dc03dbdde601d5dd0572a653d7f92
-  data.tar.gz: 19e29f31128f08e9316b1924f5aa5a5990c6ce021d0ac1730366c4605d042b91
+  metadata.gz: 3886f200d09df85267ac44d61ee031dcf7b3c67c19ec36d4588d6ade808dbe6f
+  data.tar.gz: f7580ea8952fb87fa37cad385c85bd39491f8ac169b66c3d9338061e7c47d60b
 SHA512:
-  metadata.gz: 6e7504964adc027e511810774e3e1ffd6226a466d433a31befceef3992481876059f7501bb700057999aafb84b596f5e0b0facebdb3ea88cf3eb1dfd3706a7ca
-  data.tar.gz: 49264acece8439b11ea20e0188e6f978b9b54db7b8b9e04288d8957cb36d33d8e1ea34df4df15d2c0798e2b9411bd99369182e88a914deca6bef17234c0e8c0c
+  metadata.gz: 5db2971d531c39c8f93619cc09a9b2c46ca81b7c4f78ad2931c2c3da95c942252bc6c6d7b36b0836afa7abde502492e745e468d470736b6204d88b42fa4ac239
+  data.tar.gz: 4af1720520b8fe5107e275a7cea05026c657aa6ae1be26fb0ed17e740e328f6b4bca430e0664b4b012ded7b6ebf1edca43637531a06fb83d19b0026154b85229

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: x86_64-linux
 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