restate-sdk 0.5.1-aarch64-linux → 0.7.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a81d6c3c60667dd85535a4c6f668e7bff95ee2d52948640751458793f8389987
-  data.tar.gz: b9015e2e91776a61b23a636120aeef049857ef37f5bc17ba8c31b3a1988c2348
+  metadata.gz: 72ba1274d55d51d051485f01a9779d27b6d9935fdafc397f98d79a6471bd0314
+  data.tar.gz: a731a191f45085088e57fb54ca1210826ae2b8dfcf1a8789f187074b63685666
 SHA512:
-  metadata.gz: '059edf3c35921e494373a1960f65cdd6f6f33a7c1ad9308c7759be87e48b9e3e2246d831b02ef4e9d00305150c409a3bbae5a62290cb824e76b4f68f18b79fe4'
-  data.tar.gz: f772b40c32a8200b77f5dede3c4d10d5a92e226f58f52c32a769293e4d0ef14d8f5784c915945704dac3147764c204110fc2352a0d265288659dc96d095f03f6
+  metadata.gz: f6a72f1412e67244f4abe808aa4a9c3ab7bf411018351a4909e85242fd1516bd48141964866959b59d72f3570df037c48018927cb13383ba9c555768a77834fd
+  data.tar.gz: 467150dd5dba8e0adeb5dfddec4770c6a8976846c13b79b8865e954b9dc54c7f714bd3d89d95f267c4a9f6bcacd7de629eb5877693663757c9eac98d70909ca9

data/Cargo.lock

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

data/README.md

@@ -13,8 +13,20 @@
 require 'restate'
 
 class Greeter < Restate::Service
-  handler def greet(ctx, name)
-    ctx.run_sync('build-greeting') { "Hello, #{name}!" }
+  handler def greet(name)
+    Restate.run_sync('build-greeting') { "Hello, #{name}!" }
+  end
+end
+
+class Counter < Restate::VirtualObject
+  state :count, default: 0
+
+  handler def add(addend)
+    self.count += addend
+  end
+
+  shared def get
+    count
   end
 end
 ```
@@ -67,8 +79,8 @@ end
 
 class EventService < Restate::Service
   handler :register, input: RegistrationRequest, output: RegistrationResponse
-  def register(ctx, request)
-    registration_id = ctx.run_sync('create-registration') do
+  def register(request)
+    registration_id = Restate.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.5.1"
+version = "0.7.0"
 edition = "2021"
 publish = false
 

data/lib/restate/client.rb

@@ -0,0 +1,181 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Restate
+  # HTTP client for invoking Restate services and managing the Restate runtime
+  # from outside the Restate runtime.
+  #
+  # @example Via global config (recommended)
+  #   Restate.configure do |c|
+  #     c.ingress_url = "http://localhost:8080"
+  #     c.admin_url = "http://localhost:9070"
+  #   end
+  #   client = Restate.client
+  #   result = client.service(Greeter).greet("World")
+  #
+  # @example Standalone
+  #   client = Restate::Client.new(ingress_url: "http://localhost:8080",
+  #                                admin_url: "http://localhost:9070")
+  #
+  # @example Service invocation
+  #   client.service("Greeter").greet("World")
+  #   client.object("Counter", "my-key").add(5)
+  #   client.workflow("UserSignup", "user42").run("user@example.com")
+  #
+  # @example Admin operations
+  #   client.resolve_awakeable(awakeable_id, "result")
+  #   client.reject_awakeable(awakeable_id, "failed")
+  #   client.cancel_invocation(invocation_id)
+  #   client.create_deployment("http://localhost:9080")
+  class Client
+    extend T::Sig
+
+    sig do
+      params(ingress_url: String, admin_url: String,
+             ingress_headers: T::Hash[String, String],
+             admin_headers: T::Hash[String, String]).void
+    end
+    def initialize(ingress_url: 'http://localhost:8080', admin_url: 'http://localhost:9070',
+                   ingress_headers: {}, admin_headers: {})
+      @ingress_url = ingress_url.chomp('/')
+      @admin_url = admin_url.chomp('/')
+      @ingress_headers = ingress_headers
+      @admin_headers = admin_headers
+    end
+
+    # ── Service invocation proxies ──
+
+    # Returns a proxy for calling a stateless service.
+    sig { params(service: T.any(String, T::Class[T.anything])).returns(ClientServiceProxy) }
+    def service(service)
+      ClientServiceProxy.new(@ingress_url, resolve_name(service), nil, @ingress_headers)
+    end
+
+    # Returns a proxy for calling a keyed virtual object.
+    sig { params(service: T.any(String, T::Class[T.anything]), key: String).returns(ClientServiceProxy) }
+    def object(service, key)
+      ClientServiceProxy.new(@ingress_url, resolve_name(service), key, @ingress_headers)
+    end
+
+    # Returns a proxy for calling a workflow.
+    sig { params(service: T.any(String, T::Class[T.anything]), key: String).returns(ClientServiceProxy) }
+    def workflow(service, key)
+      ClientServiceProxy.new(@ingress_url, resolve_name(service), key, @ingress_headers)
+    end
+
+    # ── Awakeable operations ──
+
+    # Resolve an awakeable from outside the Restate runtime.
+    sig { params(awakeable_id: String, payload: T.untyped).void }
+    def resolve_awakeable(awakeable_id, payload)
+      post_ingress("/restate/awakeables/#{awakeable_id}/resolve", payload)
+    end
+
+    # Reject an awakeable from outside the Restate runtime.
+    sig { params(awakeable_id: String, message: String, code: Integer).void }
+    def reject_awakeable(awakeable_id, message, code: 500)
+      post_ingress("/restate/awakeables/#{awakeable_id}/reject",
+                   { 'message' => message, 'code' => code })
+    end
+
+    # ── Invocation management ──
+
+    # Cancel a running invocation.
+    sig { params(invocation_id: String).void }
+    def cancel_invocation(invocation_id)
+      post_admin("/restate/invocations/#{invocation_id}/cancel", nil)
+    end
+
+    # Kill a running invocation (immediate termination, no cleanup).
+    sig { params(invocation_id: String).void }
+    def kill_invocation(invocation_id)
+      post_admin("/restate/invocations/#{invocation_id}/kill", nil)
+    end
+
+    private
+
+    sig { params(service: T.any(String, T::Class[T.anything])).returns(String) }
+    def resolve_name(service)
+      if service.is_a?(Class) && service.respond_to?(:service_name)
+        T.unsafe(service).service_name
+      else
+        service.to_s
+      end
+    end
+
+    sig { params(path: String, body: T.untyped).returns(T.untyped) }
+    def post_ingress(path, body) # rubocop:disable Metrics/AbcSize
+      uri = URI("#{@ingress_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      @ingress_headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(body) if body
+      response = Net::HTTP.start(uri.hostname, uri.port,
+                                 use_ssl: uri.scheme == 'https',
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate ingress error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      parse_response(response)
+    end
+
+    sig { params(path: String, body: T.untyped).returns(T.untyped) }
+    def post_admin(path, body) # rubocop:disable Metrics/AbcSize
+      uri = URI("#{@admin_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      @admin_headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(body) if body
+      response = Net::HTTP.start(uri.hostname, uri.port,
+                                 use_ssl: uri.scheme == 'https',
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate admin error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      parse_response(response)
+    end
+
+    sig { params(response: Net::HTTPResponse).returns(T.untyped) }
+    def parse_response(response)
+      body = response.body
+      body && !body.empty? ? JSON.parse(body) : nil
+    end
+  end
+
+  # Proxy that sends HTTP requests to the Restate ingress for a specific service.
+  # Handler calls are forwarded via +method_missing+.
+  #
+  # @!visibility private
+  class ClientServiceProxy
+    extend T::Sig
+
+    sig do
+      params(base_url: String, service_name: String, key: T.nilable(String),
+             headers: T::Hash[String, String]).void
+    end
+    def initialize(base_url, service_name, key, headers)
+      @base_url = base_url
+      @service_name = service_name
+      @key = key
+      @headers = headers
+    end
+
+    def method_missing(handler_name, arg = nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      path = @key ? "/#{@service_name}/#{@key}/#{handler_name}" : "/#{@service_name}/#{handler_name}"
+      uri = URI("#{@base_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      @headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(arg)
+      response = Net::HTTP.start(uri.hostname, uri.port,
+                                 use_ssl: uri.scheme == 'https',
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate ingress error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      body = response.body
+      body && !body.empty? ? JSON.parse(body) : nil
+    end
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+  end
+end

data/lib/restate/config.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+module Restate
+  # Global SDK configuration. Set via +Restate.configure+.
+  #
+  # @example
+  #   Restate.configure do |c|
+  #     c.ingress_url = "http://localhost:8080"
+  #     c.admin_url   = "http://localhost:9070"
+  #   end
+  #
+  #   # Then use the pre-configured client:
+  #   Restate.client.service(Greeter).greet("World")
+  class Config
+    extend T::Sig
+
+    # Restate ingress URL (for invoking services).
+    sig { returns(String) }
+    attr_accessor :ingress_url
+
+    # Restate admin URL (for deployments, invocation management).
+    sig { returns(String) }
+    attr_accessor :admin_url
+
+    # Default headers sent with every ingress request.
+    sig { returns(T::Hash[String, String]) }
+    attr_accessor :ingress_headers
+
+    # Default headers sent with every admin request.
+    sig { returns(T::Hash[String, String]) }
+    attr_accessor :admin_headers
+
+    sig { void }
+    def initialize
+      @ingress_url = T.let('http://localhost:8080', String)
+      @admin_url = T.let('http://localhost:9070', String)
+      @ingress_headers = T.let({}, T::Hash[String, String])
+      @admin_headers = T.let({}, T::Hash[String, String])
+    end
+  end
+end

data/lib/restate/endpoint.rb

@@ -15,11 +15,15 @@ module Restate
     sig { returns(T.nilable(String)) }
     attr_accessor :protocol
 
+    sig { returns(T::Array[T.untyped]) }
+    attr_reader :middleware
+
     sig { void }
     def initialize
       @services = T.let({}, T::Hash[String, T.untyped])
       @protocol = T.let(nil, T.nilable(String))
       @identity_keys = T.let([], T::Array[String])
+      @middleware = T.let([], T::Array[T.untyped])
     end
 
     # Bind one or more services to this endpoint.
@@ -59,6 +63,70 @@ module Restate
       self
     end
 
+    # Add handler-level middleware.
+    #
+    # Middleware wraps every handler invocation with access to the handler metadata
+    # and context. Use it for tracing, metrics, logging, error reporting, etc.
+    #
+    # A middleware is a class whose instances respond to +call(handler, ctx)+.
+    # Use +yield+ inside +call+ to invoke the next middleware or the handler.
+    # The return value of +yield+ is the handler's return value.
+    #
+    # This follows the same pattern as {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq middleware}.
+    #
+    # @example OpenTelemetry tracing
+    #   class OpenTelemetryMiddleware
+    #     def call(handler, ctx)
+    #       tracer.in_span(handler.name, attributes: {
+    #         'restate.service' => handler.service_tag.name,
+    #         'restate.invocation_id' => ctx.request.id
+    #       }) do
+    #         yield
+    #       end
+    #     end
+    #   end
+    #   endpoint.use(OpenTelemetryMiddleware)
+    #
+    # @example Metrics
+    #   class MetricsMiddleware
+    #     def call(handler, ctx)
+    #       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    #       result = yield
+    #       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+    #       StatsD.timing("restate.handler.#{handler.name}", duration)
+    #       result
+    #     end
+    #   end
+    #   endpoint.use(MetricsMiddleware)
+    #
+    # @example Middleware with configuration
+    #   class AuthMiddleware
+    #     def initialize(api_key:)
+    #       @api_key = api_key
+    #     end
+    #
+    #     def call(handler, ctx)
+    #       raise Restate::TerminalError.new('unauthorized', status_code: 401) unless valid?(ctx)
+    #       yield
+    #     end
+    #   end
+    #   endpoint.use(AuthMiddleware, api_key: 'secret')
+    #
+    # @param klass [Class] middleware class (will be instantiated by the SDK)
+    # @param args [Array] positional arguments for the middleware constructor
+    # @param kwargs [Hash] keyword arguments for the middleware constructor
+    # @return [self]
+    sig { params(klass: T.untyped, args: T.untyped, kwargs: T.untyped).returns(T.self_type) }
+    def use(klass, *args, **kwargs)
+      instance = if kwargs.empty?
+                   klass.new(*args)
+                 else
+                   klass.new(*args, **kwargs)
+                 end
+      @middleware << instance
+      self
+    end
+
     # Build and return the Rack-compatible application.
     sig { returns(T.untyped) }
     def app

data/lib/restate/handler.rb

@@ -33,19 +33,33 @@ module Restate
 
   # Invoke a handler with the context and raw input bytes.
   # The context is passed as the first argument to every handler.
+  # Middleware (if any) wraps the handler call.
   # Returns raw output bytes.
-  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}"
+  sig do
+    params(handler: T.untyped, ctx: T.untyped, in_buffer: String,
+           middleware: T::Array[T.untyped]).returns(String)
+  end
+  def invoke_handler(handler:, ctx:, in_buffer:, middleware: []) # rubocop:disable Metrics/AbcSize
+    call_handler = Kernel.proc do
+      if handler.arity == 1
+        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
+        handler.callable.call(in_arg)
+      else
+        handler.callable.call
       end
-      out_arg = handler.callable.call(ctx, in_arg)
-    else
-      out_arg = handler.callable.call(ctx)
     end
+
+    # Build the middleware chain so each middleware can use `yield` to call the next.
+    # Middleware still receives (handler, ctx) for low-level access.
+    chain = middleware.reverse.reduce(call_handler) do |nxt, mw|
+      Kernel.proc { mw.call(handler, ctx, &nxt) }
+    end
+
+    out_arg = chain.call
     handler.handler_io.output_serde.serialize(out_arg)
   end
 end

data/lib/restate/server.rb

@@ -204,7 +204,8 @@ module Restate
         handler: handler,
         invocation: invocation,
         send_output: send_output,
-        input_queue: input_queue
+        input_queue: input_queue,
+        middleware: @endpoint.middleware
       )
 
       # Spawn the handler as an async task so the response body can stream

data/lib/restate/server_context.rb

@@ -28,8 +28,11 @@ module Restate
     sig { returns(T.untyped) }
     attr_reader :invocation
 
-    sig { params(vm: VMWrapper, handler: T.untyped, invocation: T.untyped, send_output: T.untyped, input_queue: Async::Queue).void }
-    def initialize(vm:, handler:, invocation:, send_output:, input_queue:)
+    sig do
+      params(vm: VMWrapper, handler: T.untyped, invocation: T.untyped, send_output: T.untyped,
+             input_queue: Async::Queue, middleware: T::Array[T.untyped]).void
+    end
+    def initialize(vm:, handler:, invocation:, send_output:, input_queue:, middleware: [])
       @vm = T.let(vm, VMWrapper)
       @handler = T.let(handler, T.untyped)
       @invocation = T.let(invocation, T.untyped)
@@ -37,6 +40,7 @@ module Restate
       @input_queue = T.let(input_queue, Async::Queue)
       @run_coros_to_execute = T.let({}, T::Hash[Integer, T.untyped])
       @attempt_finished_event = T.let(AttemptFinishedEvent.new, AttemptFinishedEvent)
+      @middleware = T.let(middleware, T::Array[T.untyped])
     end
 
     # ── Main entry point ──
@@ -48,7 +52,8 @@ 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, ctx: self, in_buffer: in_buffer)
+      out_buffer = Restate.invoke_handler(handler: @handler, ctx: self, in_buffer: in_buffer,
+                                          middleware: @middleware)
       @vm.sys_write_output_success(out_buffer.b)
       @vm.sys_end
     rescue TerminalError => e

data/lib/restate/service.rb

@@ -30,6 +30,28 @@ module Restate
       _register_handler(method_name, **T.unsafe({ kind: nil, **opts }))
     end
 
+    # Returns a call proxy for fluent durable calls to this service.
+    #
+    # @example
+    #   Greeter.call.greet("World").await
+    #
+    # @return [ServiceCallProxy]
+    def self.call
+      ServiceCallProxy.new(self, call_method: :service_call)
+    end
+
+    # Returns a send proxy for fluent fire-and-forget sends to this service.
+    #
+    # @example
+    #   Greeter.send!.greet("World")
+    #   Greeter.send!(delay: 60).greet("World")
+    #
+    # @param delay [Numeric, nil] optional delay in seconds
+    # @return [ServiceSendProxy]
+    def self.send!(delay: nil)
+      ServiceSendProxy.new(self, send_method: :service_send, delay: delay)
+    end
+
     def self._service_kind
       'service'
     end

data/lib/restate/service_dsl.rb

@@ -31,6 +31,70 @@ module Restate
       subclass.instance_variable_set(:@_idempotency_retention, nil)
       subclass.instance_variable_set(:@_ingress_private, nil)
       subclass.instance_variable_set(:@_invocation_retry_policy, nil)
+      subclass.instance_variable_set(:@_state_declarations, {})
+    end
+
+    # Declare a durable state entry with auto-generated getter, setter, and clear methods.
+    # Only available on VirtualObject and Workflow.
+    #
+    # The generated methods delegate to the current Restate context via +Thread.current+
+    # (fiber-scoped in Ruby 3.0+), so they work correctly across concurrent invocations.
+    #
+    # @param name [Symbol] state key name
+    # @param default [Object, nil] default value returned when state is not set
+    # @param serde [Object] serializer/deserializer (defaults to JsonSerde)
+    #
+    # @example
+    #   class Counter < Restate::VirtualObject
+    #     state :count, default: 0
+    #
+    #     handler def add(ctx, addend)
+    #       self.count += addend  # reads then writes via ctx.get/ctx.set
+    #     end
+    #
+    #     shared def get(ctx)
+    #       count  # reads via ctx.get, returns 0 if unset
+    #     end
+    #   end
+    def state(name, default: nil, serde: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      unless T.unsafe(self).respond_to?(:_service_kind) && %w[object workflow].include?(T.unsafe(self)._service_kind)
+        Kernel.raise ArgumentError, 'state declarations are only available on VirtualObject and Workflow'
+      end
+
+      name = name.to_sym
+      @_state_declarations[name] = { default: default, serde: serde }
+      state_key = name.to_s
+      state_serde = serde
+      state_default = default
+
+      # Getter: reads from durable state, returns default if unset
+      T.unsafe(self).define_method(name) do
+        ctx = Thread.current[:restate_context]
+        Kernel.raise 'Not inside a Restate handler' unless ctx
+
+        val = state_serde ? ctx.get(state_key, serde: state_serde) : ctx.get(state_key)
+        val.nil? ? state_default : val
+      end
+
+      # Setter: writes to durable state
+      T.unsafe(self).define_method(:"#{name}=") do |value|
+        ctx = Thread.current[:restate_context]
+        Kernel.raise 'Not inside a Restate handler' unless ctx
+
+        if state_serde
+          ctx.set(state_key, value, serde: state_serde)
+        else
+          ctx.set(state_key, value)
+        end
+      end
+
+      # Clear: removes the state entry
+      T.unsafe(self).define_method(:"clear_#{name}") do
+        ctx = Thread.current[:restate_context]
+        Kernel.raise 'Not inside a Restate handler' unless ctx
+
+        ctx.clear(state_key)
+      end
     end
 
     # Get or set the service name. Defaults to the unqualified class name.
@@ -210,8 +274,8 @@ module Restate
 
         um = T.unsafe(self).instance_method(name)
         arity = um.arity.abs
-        unless [1, 2].include?(arity)
-          Kernel.raise ArgumentError, "handler '#{name}' must accept 1 or 2 parameters (ctx[, input]), got #{arity}"
+        unless [0, 1].include?(arity)
+          Kernel.raise ArgumentError, "handler '#{name}' must accept 0 or 1 parameters ([input]), got #{arity}"
         end
 
         bound = um.bind(instance)

data/lib/restate/service_proxy.rb

@@ -0,0 +1,84 @@
+# typed: true
+# frozen_string_literal: true
+
+module Restate
+  # Proxy for fluent durable calls: +Service.call.handler(arg)+
+  #
+  # Returned by the +.call+ class method on service classes. Uses +method_missing+
+  # to forward handler invocations to the current Restate context.
+  #
+  # @example
+  #   # Instead of: ctx.service_call(Greeter, :greet, "World")
+  #   Greeter.call.greet("World")
+  #
+  #   # Instead of: ctx.object_call(Counter, :add, "key", 5)
+  #   Counter.call("key").add(5)
+  #
+  # @!visibility private
+  class ServiceCallProxy
+    extend T::Sig
+
+    sig { params(service_class: T.untyped, key: T.nilable(String), call_method: Symbol).void }
+    def initialize(service_class, key: nil, call_method: :service_call)
+      @service_class = service_class
+      @key = key
+      @call_method = call_method
+    end
+
+    def method_missing(handler_name, arg = nil, **opts)
+      ctx = Restate.fetch_context!
+      if @key
+        ctx.public_send(@call_method, @service_class, handler_name, @key, arg, **opts)
+      else
+        ctx.public_send(@call_method, @service_class, handler_name, arg, **opts)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      (@service_class.respond_to?(:handlers) && T.unsafe(@service_class).handlers.key?(method_name.to_s)) || super
+    end
+  end
+
+  # Proxy for fluent fire-and-forget sends: +Service.send!.handler(arg)+
+  #
+  # Returned by the +.send!+ class method on service classes.
+  #
+  # @example
+  #   # Instead of: ctx.service_send(Greeter, :greet, "World")
+  #   Greeter.send!.greet("World")
+  #
+  #   # Instead of: ctx.object_send(Counter, :add, "key", 5, delay: 60)
+  #   Counter.send!("key", delay: 60).add(5)
+  #
+  # @!visibility private
+  class ServiceSendProxy
+    extend T::Sig
+
+    sig do
+      params(
+        service_class: T.untyped, key: T.nilable(String),
+        send_method: Symbol, delay: T.nilable(Numeric)
+      ).void
+    end
+    def initialize(service_class, key: nil, send_method: :service_send, delay: nil)
+      @service_class = service_class
+      @key = key
+      @send_method = send_method
+      @delay = delay
+    end
+
+    def method_missing(handler_name, arg = nil, **opts)
+      ctx = Restate.fetch_context!
+      opts[:delay] = @delay if @delay
+      if @key
+        ctx.public_send(@send_method, @service_class, handler_name, @key, arg, **opts)
+      else
+        ctx.public_send(@send_method, @service_class, handler_name, arg, **opts)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      (@service_class.respond_to?(:handlers) && T.unsafe(@service_class).handlers.key?(method_name.to_s)) || super
+    end
+  end
+end