restate-sdk 1.0.0 → 1.2.0

data/lib/restate/vm.rb

@@ -18,7 +18,8 @@ end
 
 module Restate
   # Ruby-side data types for VM results
-  Invocation = Struct.new(:invocation_id, :random_seed, :headers, :input_buffer, :key, keyword_init: true)
+  Invocation = Struct.new(:invocation_id, :random_seed, :headers, :input_buffer, :key,
+                          :scope, :limit_key, :idempotency_key, keyword_init: true)
   Failure = Struct.new(:code, :message, :stacktrace, :metadata, keyword_init: true)
 
   class NotReady; end
@@ -116,7 +117,10 @@ module Restate
         random_seed: inp.random_seed,
         headers: headers,
         input_buffer: inp.input.b,
-        key: inp.key
+        key: inp.key,
+        scope: inp.scope,
+        limit_key: inp.limit_key,
+        idempotency_key: inp.idempotency_key
       )
     end
 
@@ -145,16 +149,19 @@ module Restate
       @vm.sys_sleep(millis, name)
     end
 
-    def sys_call(service:, handler:, parameter:, key: nil, idempotency_key: nil, headers: nil)
-      # Rust side expects 6 args: (service, handler, buffer, key_or_nil, idem_key_or_nil, headers_or_nil)
+    def sys_call(service:, handler:, parameter:, key: nil, idempotency_key: nil, headers: nil,
+                 scope: nil, limit_key: nil)
+      # Rust side expects 8 args:
+      # (service, handler, buffer, key_or_nil, idem_key_or_nil, headers_or_nil, scope_or_nil, limit_key_or_nil)
       hdr_array = headers&.map { |k, v| [k, v] }
-      @vm.sys_call(service, handler, parameter, key, idempotency_key, hdr_array)
+      @vm.sys_call(service, handler, parameter, key, idempotency_key, hdr_array, scope, limit_key)
     end
 
-    def sys_send(service:, handler:, parameter:, key: nil, delay: nil, idempotency_key: nil, headers: nil)
-      # Rust side expects 7 args
+    def sys_send(service:, handler:, parameter:, key: nil, delay: nil, idempotency_key: nil, headers: nil,
+                 scope: nil, limit_key: nil)
+      # Rust side expects 9 args
       hdr_array = headers&.map { |k, v| [k, v] }
-      @vm.sys_send(service, handler, parameter, key, delay, idempotency_key, hdr_array)
+      @vm.sys_send(service, handler, parameter, key, delay, idempotency_key, hdr_array, scope, limit_key)
     end
 
     def sys_run(name)

data/lib/restate/workflow.rb

@@ -52,11 +52,14 @@ module Restate
     #
     # @example
     #   UserSignup.call("user42").run("user@example.com").await
+    #   UserSignup.call("user42", scope: "tenant1", limit_key: "tenant1/user42").run(email).await
     #
     # @param key [String] the workflow key
+    # @param scope [String, nil] optional scope to route the call within (see {Restate.scope})
+    # @param limit_key [String, nil] optional concurrency limit key within the scope
     # @return [ServiceCallProxy]
-    def self.call(key)
-      ServiceCallProxy.new(self, key: key, call_method: :workflow_call)
+    def self.call(key, scope: nil, limit_key: nil)
+      ServiceCallProxy.new(self, key: key, call_method: :workflow_call, scope: scope, limit_key: limit_key)
     end
 
     # Returns a send proxy for fluent fire-and-forget sends to this workflow.
@@ -64,12 +67,19 @@ module Restate
     # @example
     #   UserSignup.send!("user42").run("user@example.com")
     #   UserSignup.send!("user42", delay: 60).run("user@example.com")
+    #   UserSignup.send!("user42", scope: "tenant1", limit_key: "tenant1/user42").run(email)
     #
     # @param key [String] the workflow key
     # @param delay [Numeric, nil] optional delay in seconds
+    # @param scope [String, nil] optional scope to route the send within (see {Restate.scope})
+    # @param limit_key [String, nil] optional concurrency limit key within the scope
     # @return [ServiceSendProxy]
-    def self.send!(key, delay: nil)
-      ServiceSendProxy.new(self, key: key, send_method: :workflow_send, delay: delay)
+    def self.send!(key, delay: nil, scope: nil, limit_key: nil)
+      ServiceSendProxy.new(
+        self,
+        key: key, send_method: :workflow_send,
+        delay: delay, scope: scope, limit_key: limit_key
+      )
     end
 
     def self._service_kind

data/lib/restate.rb

@@ -219,15 +219,27 @@ module Restate # rubocop:disable Metrics/ModuleLength
   end
 
   # Durably call a handler using raw bytes (no serialization).
-  def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil)
-    fetch_context!.generic_call(service, handler, arg, key: key,
-                                                       idempotency_key: idempotency_key, headers: headers)
+  def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil,
+                   scope: nil, limit_key: nil)
+    fetch_context!.generic_call(service, handler, arg, key: key, idempotency_key: idempotency_key,
+                                                       headers: headers, scope: scope, limit_key: limit_key)
   end
 
   # Fire-and-forget send using raw bytes (no serialization).
-  def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil)
+  def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil,
+                   scope: nil, limit_key: nil)
     fetch_context!.generic_send(service, handler, arg, key: key, delay: delay,
-                                                       idempotency_key: idempotency_key, headers: headers)
+                                                       idempotency_key: idempotency_key, headers: headers,
+                                                       scope: scope, limit_key: limit_key)
+  end
+
+  # Returns a +ScopedContext+ that routes all outgoing calls within the given scope.
+  # See {Restate::Context#scope} for the full semantics and constraints.
+  #
+  # @example
+  #   Restate.scope("tenant1").service_call(Greeter, :greet, "World", limit_key: "tenant1/user42")
+  def scope(scope)
+    fetch_context!.scope(scope)
   end
 
   # ── Awakeables ──

data/sig/restate.rbs

@@ -35,8 +35,9 @@ module Restate
   def self.object_send: (untyped service, (String | Symbol) handler, String key, untyped arg, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
   def self.workflow_call: (untyped service, (String | Symbol) handler, String key, untyped arg, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
   def self.workflow_send: (untyped service, (String | Symbol) handler, String key, untyped arg, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
-  def self.generic_call: (String service, String handler, String arg, ?key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?) -> DurableCallFuture
-  def self.generic_send: (String service, String handler, String arg, ?key: String?, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?) -> SendHandle
+  def self.generic_call: (String service, String handler, String arg, ?key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?scope: String?, ?limit_key: String?) -> DurableCallFuture
+  def self.generic_send: (String service, String handler, String arg, ?key: String?, ?delay: Numeric?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?scope: String?, ?limit_key: String?) -> SendHandle
+  def self.scope: (String scope) -> Server::ScopedContext
 
   # ── Awakeables ──
 
@@ -197,11 +198,11 @@ module Restate
   # ── Service proxies ──
 
   class ServiceCallProxy
-    def initialize: (untyped service_class, ?key: String?, ?call_method: Symbol) -> void
+    def initialize: (untyped service_class, ?key: String?, ?call_method: Symbol, ?scope: String?, ?limit_key: String?) -> void
   end
 
   class ServiceSendProxy
-    def initialize: (untyped service_class, ?key: String?, ?send_method: Symbol, ?delay: Numeric?) -> void
+    def initialize: (untyped service_class, ?key: String?, ?send_method: Symbol, ?delay: Numeric?, ?scope: String?, ?limit_key: String?) -> void
   end
 
   # ── Service classes (declared but not checked — heavy metaprogramming) ──
@@ -225,6 +226,16 @@ module Restate
 
     class Context
     end
+
+    class ScopedContext
+      def initialize: (untyped ctx, String scope) -> void
+      def service_call: (untyped service, (String | Symbol) handler, untyped arg, ?key: String?, ?limit_key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
+      def service_send: (untyped service, (String | Symbol) handler, untyped arg, ?key: String?, ?delay: Numeric?, ?limit_key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
+      def object_call: (untyped service, (String | Symbol) handler, String key, untyped arg, ?limit_key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
+      def object_send: (untyped service, (String | Symbol) handler, String key, untyped arg, ?delay: Numeric?, ?limit_key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
+      def workflow_call: (untyped service, (String | Symbol) handler, String key, untyped arg, ?limit_key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped, ?output_serde: untyped) -> DurableCallFuture
+      def workflow_send: (untyped service, (String | Symbol) handler, String key, untyped arg, ?delay: Numeric?, ?limit_key: String?, ?idempotency_key: String?, ?headers: Hash[String, String]?, ?input_serde: untyped) -> SendHandle
+    end
   end
 
   module JsonSerde

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Restate Developers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-26 00:00:00.000000000 Z
+date: 2026-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async