restate-sdk 0.4.4 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8e9a5eab5505c6585cad44e4d579238dfd87f637c480c8992ee182e1a5d7dc8
-  data.tar.gz: de1d60c560fcc48f55120820bdaf3de1d36c6a03664bdc0408c152ee11a160e7
+  metadata.gz: 1b23261e2b75927f25f70d83c93133191b894a2451c8a194e73a38e91b3f44d6
+  data.tar.gz: 269ac3b7c8a496da0db88b53d5dedbd54afe64a6507c712c9d71c828811bfb55
 SHA512:
-  metadata.gz: 9ffae9eb0811b513127a2369960a9aa8511cabd21c5e8b5d460e9b5e9131db8f45b3597c8f93aa1faea3d1cc3839b928ed4e216a20826de050668e09abd7617c
-  data.tar.gz: d9bfc8f6c4b86012aa00f236fe8b26abfff5966c833376259beb8b91cad1fc4a300d4ade6374e14865179f02485700428bb819c2ce455df2494f69126a1c03d3
+  metadata.gz: 3b66009141e9bfba8841a5f73c7a8bd4b808d36f1edd122f70e73b91f4718f5a0de1f8d653c55b1686839c66dbef802a1f71a13e7fba71fbb4d631b2c1721295
+  data.tar.gz: 9caa27f5058be3d18cf9a06295dc828c5053cbb3d4622c6944ec6f27466b8b80e41b67e11ac244c3fb1847297e24b03997aec7fe602347bdabfa9377213b77d9

data/Cargo.lock

@@ -569,7 +569,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.4.4"
+version = "0.5.1"
 dependencies = [
  "magnus",
  "rb-sys",

data/README.md

@@ -5,14 +5,15 @@
 
 # Restate Ruby SDK
 
+> **Note:** This SDK is currently under active development. APIs may change between releases.
+
 [Restate](https://restate.dev/) is a system for easily building resilient applications using *distributed durable async/await*. This repository contains the Restate SDK for writing services in **Ruby**.
 
 ```ruby
 require 'restate'
 
 class Greeter < Restate::Service
-  handler def greet(name)
-    ctx = Restate.current_context
+  handler def greet(ctx, name)
     ctx.run_sync('build-greeting') { "Hello, #{name}!" }
   end
 end
@@ -66,9 +67,7 @@ end
 
 class EventService < Restate::Service
   handler :register, input: RegistrationRequest, output: RegistrationResponse
-  def register(request)
-    ctx = Restate.current_context
-
+  def register(ctx, request)
     registration_id = ctx.run_sync('create-registration') do
       "reg_#{request.event_name}_#{rand(10_000)}"
     end

data/ext/restate_internal/Cargo.toml

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

data/lib/restate/handler.rb

@@ -31,20 +31,20 @@ module Restate
 
   module_function
 
-  # Invoke a handler with raw input bytes. The context is available via
-  # fiber-local Restate.current_context (set by ServerContext#enter).
+  # Invoke a handler with the context and raw input bytes.
+  # The context is passed as the first argument to every handler.
   # Returns raw output bytes.
-  sig { params(handler: T.untyped, in_buffer: String).returns(String) }
-  def invoke_handler(handler:, in_buffer:)
-    if handler.arity == 1
+  sig { params(handler: T.untyped, ctx: T.untyped, in_buffer: String).returns(String) }
+  def invoke_handler(handler:, ctx:, in_buffer:)
+    if handler.arity == 2
       begin
         in_arg = handler.handler_io.input_serde.deserialize(in_buffer)
       rescue StandardError => e
         Kernel.raise TerminalError, "Unable to parse input argument: #{e.message}"
       end
-      out_arg = handler.callable.call(in_arg)
+      out_arg = handler.callable.call(ctx, in_arg)
     else
-      out_arg = handler.callable.call
+      out_arg = handler.callable.call(ctx)
     end
     handler.handler_io.output_serde.serialize(out_arg)
   end

data/lib/restate/serde.rb

@@ -212,10 +212,13 @@ module Restate
   class TypeSerde
     extend T::Sig
 
+    sig { returns(T.untyped) }
+    attr_reader :type_class
+
     # Create a TypeSerde for the given type with a precomputed JSON Schema.
     sig { params(type: T.untyped, schema: T.nilable(T::Hash[String, T.untyped])).void }
     def initialize(type, schema)
-      @type = type
+      @type_class = type
       @schema = schema
     end
 
@@ -243,6 +246,9 @@ module Restate
   class DryStructSerde
     extend T::Sig
 
+    sig { returns(T.untyped) }
+    attr_reader :struct_class
+
     # Create a DryStructSerde for the given Dry::Struct class.
     sig { params(struct_class: T.untyped).void }
     def initialize(struct_class)
@@ -280,6 +286,9 @@ module Restate
   class TStructSerde
     extend T::Sig
 
+    sig { returns(T.class_of(T::Struct)) }
+    attr_reader :struct_class
+
     # Create a TStructSerde for the given T::Struct subclass.
     sig { params(struct_class: T.class_of(T::Struct)).void }
     def initialize(struct_class)

data/lib/restate/server_context.rb

@@ -48,7 +48,7 @@ module Restate
       Thread.current[:restate_service_kind] = @handler.service_tag.kind
       Thread.current[:restate_handler_kind] = @handler.kind
       in_buffer = @invocation.input_buffer
-      out_buffer = Restate.invoke_handler(handler: @handler, in_buffer: in_buffer)
+      out_buffer = Restate.invoke_handler(handler: @handler, ctx: self, in_buffer: in_buffer)
       @vm.sys_write_output_success(out_buffer.b)
       @vm.sys_end
     rescue TerminalError => e

data/lib/restate/service.rb

@@ -6,8 +6,8 @@ module Restate
   #
   # @example
   #   class Greeter < Restate::Service
-  #     handler def greet(name)
-  #       "Hello, #{name}!"
+  #     handler def greet(ctx, name)
+  #       ctx.run_sync('build-greeting') { "Hello, #{name}!" }
   #     end
   #   end
   class Service
@@ -15,7 +15,7 @@ module Restate
     extend ServiceDSL
 
     # Register a handler method on this service.
-    # Use as: +handler def my_method(arg)+ or +handler :my_method, input: String+
+    # Use as: +handler def my_method(ctx, arg)+ or +handler :my_method, input: String+
     #
     # @param method_name [Symbol] name of the method to register
     # @param opts [Hash] handler options (+input:+, +output:+, +accept:+, +content_type:+)

data/lib/restate/service_dsl.rb

@@ -9,8 +9,7 @@ module Restate
   #
   # @example
   #   class Counter < Restate::VirtualObject
-  #     handler def add(addend)
-  #       ctx = Restate.current_object_context
+  #     handler def add(ctx, addend)
   #       old = ctx.get('counter') || 0
   #       ctx.set('counter', old + addend)
   #       old + addend
@@ -211,8 +210,8 @@ module Restate
 
         um = T.unsafe(self).instance_method(name)
         arity = um.arity.abs
-        unless [0, 1].include?(arity)
-          Kernel.raise ArgumentError, "handler '#{name}' must accept 0 or 1 parameters ([input]), got #{arity}"
+        unless [1, 2].include?(arity)
+          Kernel.raise ArgumentError, "handler '#{name}' must accept 1 or 2 parameters (ctx[, input]), got #{arity}"
         end
 
         bound = um.bind(instance)

data/lib/restate/version.rb

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

data/lib/restate/virtual_object.rb

@@ -6,15 +6,13 @@ module Restate
   #
   # @example
   #   class Counter < Restate::VirtualObject
-  #     handler def add(addend)
-  #       ctx = Restate.current_object_context
+  #     handler def add(ctx, addend)
   #       old = ctx.get("count") || 0
   #       ctx.set("count", old + addend)
   #       old + addend
   #     end
   #
-  #     shared def get
-  #       ctx = Restate.current_object_context
+  #     shared def get(ctx)
   #       ctx.get("count") || 0
   #     end
   #   end
@@ -22,7 +20,7 @@ module Restate
     extend T::Sig
     extend ServiceDSL
 
-    # Register an exclusive handler. Use as: +handler def my_method(arg)+
+    # Register an exclusive handler. Use as: +handler def my_method(ctx, arg)+
     #
     # @param method_name [Symbol] name of the method to register
     # @param kind [Symbol] concurrency mode (+:exclusive+ or +:shared+)

data/lib/restate/workflow.rb

@@ -6,12 +6,11 @@ module Restate
   #
   # @example
   #   class Signup < Restate::Workflow
-  #     main def run(email)
+  #     main def run(ctx, email)
   #       # workflow logic
   #     end
   #
-  #     handler def status
-  #       ctx = Restate.current_workflow_context
+  #     handler def status(ctx)
   #       ctx.get("status")
   #     end
   #   end
@@ -20,7 +19,7 @@ module Restate
     extend ServiceDSL
 
     # Register the main workflow entry point.
-    # Use as: +main def run(arg)+ or +main :run, input: String+
+    # Use as: +main def run(ctx, arg)+ or +main :run, input: String+
     #
     # @param method_name [Symbol] name of the method to register
     # @param opts [Hash] handler options (+input:+, +output:+, +accept:+, +content_type:+)

data/lib/restate.rb

@@ -46,12 +46,12 @@ module Restate
 
   # ── Fiber-local context accessors ──
   #
-  # The SDK stores the current handler context in fiber-local storage
-  # (Thread.current[], which is fiber-scoped in Ruby). These methods
-  # retrieve it with the appropriate type for IDE completion.
+  # The SDK passes the context as the first argument to every handler.
+  # It is also stored in fiber-local storage (Thread.current[], which is
+  # fiber-scoped in Ruby). These methods retrieve it with the appropriate
+  # type for IDE completion.
   #
-  # Use these instead of the +ctx+ parameter when you need the context
-  # from a nested method that doesn't have +ctx+ in scope.
+  # Use these from nested helper methods that don't have +ctx+ in scope.
 
   # Returns the current context for a Service handler.
   # Raises if called outside a Restate handler.

data/lib/tapioca/dsl/compilers/restate.rb

@@ -3,14 +3,15 @@
 
 return unless defined?(Tapioca::Dsl::Compiler)
 
+require 'restate'
+
 module Tapioca
   module Dsl
     module Compilers
       # Generates Sorbet sigs for Restate handler methods.
       #
-      # Handlers no longer receive +ctx+ as a parameter — context is accessed
-      # via fiber-local +Restate.current_context+ (or typed variants). This
-      # compiler generates sigs reflecting the actual handler arity (0 or 1).
+      # Every handler receives +ctx+ as its first parameter. Handlers that
+      # accept input receive it as the second parameter (arity 2).
       #
       # Usage:
       #   bundle exec tapioca dsl
@@ -19,6 +20,10 @@ module Tapioca
 
         class << self
           def gather_constants
+            # Load service files so they're visible to all_classes.
+            # In non-Rails apps, Tapioca doesn't auto-load application code.
+            load_service_files
+
             all_classes.select do |klass|
               klass.is_a?(Class) && (
                 klass < ::Restate::Service ||
@@ -29,16 +34,82 @@ module Tapioca
               false
             end
           end
+
+          private
+
+          def load_service_files # rubocop:disable Metrics/MethodLength
+            root = Bundler.root.to_s
+            patterns = [
+              "#{root}/*.rb",
+              "#{root}/app/**/*.rb",
+              "#{root}/services/**/*.rb",
+              "#{root}/examples/**/*.rb"
+            ]
+            Dir.glob(patterns).each do |file|
+              next if file.end_with?('config.ru', 'Rakefile')
+
+              require file
+            rescue LoadError, StandardError
+              nil # skip files that can't be loaded
+            end
+          end
         end
 
-        def decorate
+        def decorate # rubocop:disable Metrics/MethodLength
           root.create_path(constant) do |klass|
             constant.handlers.each do |name, handler|
-              params = handler.arity == 1 ? [create_param('input', type: 'T.untyped')] : []
-              klass.create_method(name, parameters: params, return_type: 'T.untyped')
+              ctx_type = resolve_context_type(constant, handler)
+              params = [create_param('ctx', type: ctx_type)]
+              if handler.arity == 2
+                input_type = resolve_input_type(handler)
+                params << create_param('input', type: input_type)
+              end
+              output_type = resolve_output_type(handler)
+              klass.create_method(name, parameters: params, return_type: output_type)
             end
           end
         end
+
+        private
+
+        # Maps (service kind, handler kind) to the correct context module.
+        def resolve_context_type(klass, handler)
+          if klass < ::Restate::Workflow
+            handler.kind == 'workflow' ? 'Restate::WorkflowContext' : 'Restate::WorkflowSharedContext'
+          elsif klass < ::Restate::VirtualObject
+            handler.kind == 'shared' ? 'Restate::ObjectSharedContext' : 'Restate::ObjectContext'
+          else
+            'Restate::Context'
+          end
+        end
+
+        # Resolves the Sorbet type string for the handler's input serde.
+        def resolve_input_type(handler)
+          type_class = handler.handler_io&.input_serde
+          sorbet_type_name(type_class) || 'T.untyped'
+        end
+
+        # Resolves the Sorbet type string for the handler's output serde.
+        def resolve_output_type(handler)
+          type_class = handler.handler_io&.output_serde
+          sorbet_type_name(type_class) || 'T.untyped'
+        end
+
+        # Returns a Sorbet type string if the serde wraps a known type, nil otherwise.
+        def sorbet_type_name(serde)
+          return nil if serde.nil?
+
+          # TStructSerde exposes .struct_class (T::Struct subclasses are visible to Sorbet)
+          return serde.struct_class.name if serde.is_a?(::Restate::TStructSerde)
+
+          # TypeSerde wraps a primitive type in .type_class
+          if serde.respond_to?(:type_class)
+            name = serde.type_class.name
+            return name if %w[String Integer Float].include?(name)
+          end
+
+          nil
+        end
       end
     end
   end

data/rbi/restate-sdk.rbi

@@ -0,0 +1,307 @@
+# typed: true
+
+# RBI shipped with the restate-sdk gem.
+# Tapioca merges this automatically when users run `tapioca gems`.
+
+module Restate
+  # Create an endpoint, optionally binding services.
+  sig do
+    params(
+      services: T.untyped,
+      protocol: T.nilable(String),
+      identity_keys: T.nilable(T::Array[String])
+    ).returns(Restate::Endpoint)
+  end
+  def self.endpoint(*services, protocol: nil, identity_keys: nil); end
+
+  # Returns the current context (any handler).
+  sig { returns(Restate::Context) }
+  def self.current_context; end
+
+  # Returns the current context for a VirtualObject exclusive handler.
+  sig { returns(Restate::ObjectContext) }
+  def self.current_object_context; end
+
+  # Returns the current context for a VirtualObject shared handler.
+  sig { returns(Restate::ObjectSharedContext) }
+  def self.current_shared_context; end
+
+  # Returns the current context for a Workflow main handler.
+  sig { returns(Restate::WorkflowContext) }
+  def self.current_workflow_context; end
+
+  # Returns the current context for a Workflow shared handler.
+  sig { returns(Restate::WorkflowSharedContext) }
+  def self.current_shared_workflow_context; end
+
+  class TerminalError < StandardError
+    sig { returns(Integer) }
+    def status_code; end
+
+    sig { params(message: String, status_code: Integer).void }
+    def initialize(message = '', status_code: 500); end
+  end
+
+  class AttemptFinishedEvent
+    sig { returns(T::Boolean) }
+    def set?; end
+
+    sig { void }
+    def wait; end
+  end
+
+  Request = T.type_alias { T.untyped }
+
+  class RunRetryPolicy < T::Struct
+    const :initial_interval, T.nilable(Integer)
+    const :max_attempts, T.nilable(Integer)
+    const :max_duration, T.nilable(Integer)
+    const :max_interval, T.nilable(Integer)
+    const :interval_factor, T.nilable(Float)
+  end
+
+  class DurableFuture
+    sig { returns(T.untyped) }
+    def await; end
+
+    sig { returns(T::Boolean) }
+    def completed?; end
+
+    sig { returns(Integer) }
+    def handle; end
+  end
+
+  class DurableCallFuture < DurableFuture
+    sig { returns(String) }
+    def invocation_id; end
+
+    sig { void }
+    def cancel; end
+  end
+
+  class SendHandle
+    sig { returns(String) }
+    def invocation_id; end
+
+    sig { void }
+    def cancel; end
+  end
+
+  # Base context interface for all Restate handlers.
+  module Context
+    sig do
+      params(
+        name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
+        background: T::Boolean, action: T.proc.returns(T.untyped)
+      ).returns(DurableFuture)
+    end
+    def run(name, serde: Restate::JsonSerde, retry_policy: nil, background: false, &action); end
+
+    sig do
+      params(
+        name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
+        background: T::Boolean, action: T.proc.returns(T.untyped)
+      ).returns(T.untyped)
+    end
+    def run_sync(name, serde: Restate::JsonSerde, retry_policy: nil, background: false, &action); end
+
+    sig { params(seconds: Numeric).returns(DurableFuture) }
+    def sleep(seconds); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        arg: T.untyped, key: T.nilable(String), idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def service_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil,
+                     input_serde: T.unsafe(nil), output_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        arg: T.untyped, key: T.nilable(String), delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def service_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil,
+                     headers: nil, input_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def object_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
+                    input_serde: T.unsafe(nil), output_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def object_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
+                    headers: nil, input_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def workflow_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
+                      input_serde: T.unsafe(nil), output_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def workflow_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
+                      headers: nil, input_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: String, handler: String, arg: String,
+        key: T.nilable(String), idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String])
+      ).returns(DurableCallFuture)
+    end
+    def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil); end
+
+    sig do
+      params(
+        service: String, handler: String, arg: String,
+        key: T.nilable(String), delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String])
+      ).returns(SendHandle)
+    end
+    def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil); end
+
+    sig { params(serde: T.untyped).returns([String, DurableFuture]) }
+    def awakeable(serde: Restate::JsonSerde); end
+
+    sig { params(awakeable_id: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_awakeable(awakeable_id, payload, serde: Restate::JsonSerde); end
+
+    sig { params(awakeable_id: String, message: String, code: Integer).void }
+    def reject_awakeable(awakeable_id, message, code: 500); end
+
+    sig { params(invocation_id: String).void }
+    def cancel_invocation(invocation_id); end
+
+    sig { params(futures: DurableFuture).returns([T::Array[DurableFuture], T::Array[DurableFuture]]) }
+    def wait_any(*futures); end
+
+    sig { returns(T.untyped) }
+    def request; end
+
+    sig { returns(String) }
+    def key; end
+  end
+
+  # VirtualObject shared handler context (read-only state).
+  module ObjectSharedContext
+    include Context
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def get(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, serde: T.untyped).returns(DurableFuture) }
+    def get_async(name, serde: Restate::JsonSerde); end
+
+    sig { returns(T.untyped) }
+    def state_keys; end
+
+    sig { returns(DurableFuture) }
+    def state_keys_async; end
+  end
+
+  # VirtualObject exclusive handler context (full state access).
+  module ObjectContext
+    include ObjectSharedContext
+
+    sig { params(name: String, value: T.untyped, serde: T.untyped).void }
+    def set(name, value, serde: Restate::JsonSerde); end
+
+    sig { params(name: String).void }
+    def clear(name); end
+
+    sig { void }
+    def clear_all; end
+  end
+
+  # Workflow shared handler context (read-only state + promises).
+  module WorkflowSharedContext
+    include ObjectSharedContext
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def peek_promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_promise(name, payload, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, message: String, code: Integer).void }
+    def reject_promise(name, message, code: 500); end
+  end
+
+  # Workflow main handler context (full state + promises).
+  module WorkflowContext
+    include ObjectContext
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def peek_promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_promise(name, payload, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, message: String, code: Integer).void }
+    def reject_promise(name, message, code: 500); end
+  end
+
+  # Stateless service base class.
+  class Service; end
+
+  # Keyed virtual object base class.
+  class VirtualObject; end
+
+  # Durable workflow base class.
+  class Workflow; end
+
+  class Endpoint
+    sig { params(services: T.untyped).void }
+    def bind(*services); end
+
+    sig { void }
+    def streaming_protocol; end
+
+    sig { void }
+    def request_response_protocol; end
+
+    sig { params(key: String).void }
+    def identity_key(key); end
+
+    sig { returns(T.untyped) }
+    def app; end
+  end
+
+  module JsonSerde; end
+  module BytesSerde; end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.1
 platform: ruby
 authors:
 - Restate Developers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-17 00:00:00.000000000 Z
+date: 2026-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -86,6 +86,7 @@ files:
 - lib/restate/vm.rb
 - lib/restate/workflow.rb
 - lib/tapioca/dsl/compilers/restate.rb
+- rbi/restate-sdk.rbi
 homepage: https://github.com/restatedev/sdk-ruby
 licenses:
 - MIT