restate-sdk 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c57bd9821f10bb65901d7da4ad7f6a38f9e64f81f36bd6eece1f2a9efcb7d57
-  data.tar.gz: c924c4d0f17f82012edaafba7d9867b2f78f2aecdd6fecc0a8f17cbd84c5f89a
+  metadata.gz: cc64f400fa1b48565474c9cc26c8bde6742e58b0c02f5090c0f633e16fd2b354
+  data.tar.gz: 7d72ad638b4dd6742c149d5314e8c67de919d198362d4a29e65d78da24146898
 SHA512:
-  metadata.gz: 0153b6c412588938d243b1d806af7a4e38d9467a21296fd299b9a6c1da77296a208009a82ce264f7d2e6e722a03fcd7b33fa1e77525c736dde7f0286512ece83
-  data.tar.gz: 4218cc6a283aa5ddf29eaed2ffd9935769a098e58fa98d476687509da45c9ddf4e4bfc871b873cfe234c1239b44f4d4ad6810975e89b61e90017463b0a0bf3d7
+  metadata.gz: 6180be88c64766e8537a59ce16c22ff591d9a0b6620301668b0c7759b981f2344a9d04f9e6d896b08a569168cd517e29e9202c69947f1311410911c1c2190f85
+  data.tar.gz: bfaa1a28cbfdbeafa95a10a428e7e0b7f17ebc033e0c28659ffeec059c980c4f1635827f40a799e517ccf31c6d143bd342fb6fdfa4b70f6f8dd9709d383af7a9

data/Cargo.lock

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

data/README.md

@@ -58,23 +58,28 @@ Or add the gem to an existing project:
 gem install restate-sdk
 ```
 
-### Typed handlers with T::Struct
+### Typed handlers with Dry::Struct
 
-Use Sorbet's `T::Struct` for typed input/output with automatic JSON Schema generation:
+Use [dry-struct](https://dry-rb.org/gems/dry-struct/) for typed input/output with automatic JSON Schema generation:
 
 ```ruby
 require 'restate'
+require 'dry-struct'
 
-class RegistrationRequest < T::Struct
-  const :event_name, String
-  const :attendee, String
-  const :num_guests, Integer
-  const :note, T.nilable(String)
+module Types
+  include Dry.Types()
 end
 
-class RegistrationResponse < T::Struct
-  const :registration_id, String
-  const :status, String
+class RegistrationRequest < Dry::Struct
+  attribute :event_name, Types::String
+  attribute :attendee, Types::String
+  attribute :num_guests, Types::Integer
+  attribute? :note, Types::String       # optional attribute
+end
+
+class RegistrationResponse < Dry::Struct
+  attribute :registration_id, Types::String
+  attribute :status, Types::String
 end
 
 class EventService < Restate::Service

data/ext/restate_internal/Cargo.toml

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

data/lib/restate/client.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 require 'net/http'
@@ -31,13 +31,6 @@ module Restate
   #   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('/')
@@ -49,19 +42,16 @@ module Restate
     # ── 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
@@ -69,13 +59,11 @@ module Restate
     # ── 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 })
@@ -84,57 +72,51 @@ module Restate
     # ── 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
+        service.service_name # steep:ignore NoMethod
       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,
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
                                  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,
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
                                  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
@@ -146,12 +128,6 @@ module Restate
   #
   # @!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
@@ -166,7 +142,7 @@ module Restate
       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,
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
                                  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)

data/lib/restate/config.rb

@@ -13,30 +13,23 @@ module Restate
   #   # 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])
+      @ingress_url = 'http://localhost:8080'
+      @admin_url = 'http://localhost:9070'
+      @ingress_headers = {}
+      @admin_headers = {}
     end
   end
 end

data/lib/restate/context.rb

@@ -1,7 +1,7 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength,Metrics/ParameterLists,Style/EmptyMethod
+# rubocop:disable Style/EmptyMethod
 module Restate
   # Signals when the current invocation attempt has finished — either the handler
   # completed, the connection was lost, or a transient error occurred.
@@ -17,27 +17,22 @@ module Restate
   #     # poll event.set? periodically, or pass it to your HTTP client
   #   end
   class AttemptFinishedEvent
-    extend T::Sig
-
-    sig { void }
     def initialize
-      @mutex = T.let(Mutex.new, Mutex)
-      @set = T.let(false, T::Boolean)
-      @waiters = T.let([], T::Array[Thread::Queue])
+      @mutex = Mutex.new
+      @set = false
+      @waiters = []
     end
 
     # Returns true if the attempt has finished.
-    sig { returns(T::Boolean) }
     def set?
       @set
     end
 
     # Blocks the current fiber/thread until the attempt finishes.
-    sig { void }
     def wait
       return if @set
 
-      waiter = T.let(nil, T.nilable(Thread::Queue))
+      waiter = nil
       @mutex.synchronize do
         unless @set
           waiter = Thread::Queue.new
@@ -49,7 +44,6 @@ module Restate
 
     # Marks the event as set and wakes all waiters.
     # Called internally by the SDK when the attempt ends.
-    sig { void }
     def set!
       @mutex.synchronize do
         @set = true
@@ -79,258 +73,149 @@ module Restate
   # @see ObjectContext for VirtualObject handlers (adds state operations)
   # @see WorkflowContext for Workflow handlers (adds promise operations)
   module Context
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     # Execute a durable side effect. The block runs at most once; the result
     # is journaled and replayed on retries.
     #
     # Pass +background: true+ to offload the block to a real OS Thread,
     # keeping the fiber event loop responsive for CPU-intensive work.
-    sig do
-      abstract.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: JsonSerde, retry_policy: nil, background: false, &action); end
 
     # Convenience shortcut for +run(...).await+. Returns the result directly.
     # Accepts all the same options as +run+, including +background: true+.
-    sig do
-      abstract.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: JsonSerde, retry_policy: nil, background: false, &action); end
 
     # Durable timer that survives handler restarts.
-    sig { params(seconds: Numeric).returns(DurableFuture) }
     def sleep(seconds) # rubocop:disable Lint/UnusedMethodArgument
       Kernel.raise NotImplementedError
     end
 
     # Durably call a handler on a Restate service.
-    sig do
-      abstract.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: NOT_SET, output_serde: NOT_SET)
     end
+
     # Fire-and-forget send to a Restate service handler.
-    sig do
-      abstract.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: NOT_SET)
     end
+
     # Durably call a handler on a Restate virtual object.
-    sig do
-      abstract.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: NOT_SET, output_serde: NOT_SET)
     end
+
     # Fire-and-forget send to a Restate virtual object handler.
-    sig do
-      abstract.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: NOT_SET)
     end
+
     # Durably call a handler on a Restate workflow.
-    sig do
-      abstract.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: NOT_SET, output_serde: NOT_SET)
     end
+
     # Fire-and-forget send to a Restate workflow handler.
-    sig do
-      abstract.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: NOT_SET)
     end
+
     # Durably call a handler using raw bytes (no serialization).
-    sig do
-      abstract.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
 
     # Fire-and-forget send using raw bytes (no serialization).
-    sig do
-      abstract.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
 
     # Create an awakeable for external callbacks.
     # Returns [awakeable_id, DurableFuture].
-    sig { abstract.params(serde: T.untyped).returns([String, DurableFuture]) }
     def awakeable(serde: JsonSerde); end
 
     # Resolve an awakeable with a success value.
-    sig { abstract.params(awakeable_id: String, payload: T.untyped, serde: T.untyped).void }
     def resolve_awakeable(awakeable_id, payload, serde: JsonSerde); end
 
     # Reject an awakeable with a terminal failure.
-    sig { abstract.params(awakeable_id: String, message: String, code: Integer).void }
     def reject_awakeable(awakeable_id, message, code: 500); end
 
     # Request cancellation of another invocation.
-    sig { abstract.params(invocation_id: String).void }
     def cancel_invocation(invocation_id); end
 
     # Wait until any of the given futures completes.
     # Returns [completed, remaining].
-    sig { abstract.params(futures: DurableFuture).returns([T::Array[DurableFuture], T::Array[DurableFuture]]) }
     def wait_any(*futures); end
 
     # Returns metadata about the current invocation.
-    sig { abstract.returns(Request) }
     def request; end
 
     # Returns the key for this virtual object or workflow invocation.
-    sig { abstract.returns(String) }
     def key; end
   end
 
   # Context interface for VirtualObject shared handlers (read-only state).
   # Extends {Context} with +get+, +state_keys+, and +key+ — but no mutations.
   module ObjectSharedContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include Context
 
     # Durably retrieve a state entry. Returns nil if unset.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def get(name, serde: JsonSerde); end
 
     # Durably retrieve a state entry, returning a DurableFuture instead of blocking.
-    sig { abstract.params(name: String, serde: T.untyped).returns(DurableFuture) }
     def get_async(name, serde: JsonSerde); end
 
     # List all state entry names.
-    sig { abstract.returns(T.untyped) }
     def state_keys; end
 
     # List all state entry names, returning a DurableFuture instead of blocking.
-    sig { abstract.returns(DurableFuture) }
     def state_keys_async; end
   end
 
   # Context interface for VirtualObject exclusive handlers (full state access).
   # Extends {ObjectSharedContext} with mutating state operations.
   module ObjectContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include ObjectSharedContext
 
     # Durably set a state entry.
-    sig { abstract.params(name: String, value: T.untyped, serde: T.untyped).void }
     def set(name, value, serde: JsonSerde); end
 
     # Durably remove a single state entry.
-    sig { abstract.params(name: String).void }
     def clear(name); end
 
     # Durably remove all state entries.
-    sig { abstract.void }
     def clear_all; end
   end
 
   # Context interface for Workflow shared handlers (read-only state + promises).
   # Extends {ObjectSharedContext} with durable promise operations.
   module WorkflowSharedContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include ObjectSharedContext
 
     # Get a durable promise value, blocking until resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def promise(name, serde: JsonSerde); end
 
     # Peek at a durable promise without blocking. Returns nil if not yet resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def peek_promise(name, serde: JsonSerde); end
 
     # Resolve a durable promise with a value.
-    sig { abstract.params(name: String, payload: T.untyped, serde: T.untyped).void }
     def resolve_promise(name, payload, serde: JsonSerde); end
 
     # Reject a durable promise with a terminal failure.
-    sig { abstract.params(name: String, message: String, code: Integer).void }
     def reject_promise(name, message, code: 500); end
   end
 
   # Context interface for Workflow main handler (full state + promises).
   # Extends {ObjectContext} with durable promise operations.
   module WorkflowContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include ObjectContext
 
     # Get a durable promise value, blocking until resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def promise(name, serde: JsonSerde); end
 
     # Peek at a durable promise without blocking. Returns nil if not yet resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def peek_promise(name, serde: JsonSerde); end
 
     # Resolve a durable promise with a value.
-    sig { abstract.params(name: String, payload: T.untyped, serde: T.untyped).void }
     def resolve_promise(name, payload, serde: JsonSerde); end
 
     # Reject a durable promise with a terminal failure.
-    sig { abstract.params(name: String, message: String, code: Integer).void }
     def reject_promise(name, message, code: 500); end
   end
 end
-# rubocop:enable Metrics/ModuleLength,Metrics/ParameterLists,Style/EmptyMethod
+# rubocop:enable Style/EmptyMethod

data/lib/restate/discovery.rb

@@ -5,36 +5,32 @@ require 'json'
 
 module Restate
   module Discovery # rubocop:disable Metrics/ModuleLength
-    extend T::Sig
-
-    PROTOCOL_MODES = T.let({
+    PROTOCOL_MODES = {
       'bidi' => 'BIDI_STREAM',
       'request_response' => 'REQUEST_RESPONSE'
-    }.freeze, T::Hash[String, String])
+    }.freeze
 
-    SERVICE_TYPES = T.let({
+    SERVICE_TYPES = {
       'service' => 'SERVICE',
       'object' => 'VIRTUAL_OBJECT',
       'workflow' => 'WORKFLOW'
-    }.freeze, T::Hash[String, String])
+    }.freeze
 
-    HANDLER_TYPES = T.let({
+    HANDLER_TYPES = {
       'exclusive' => 'EXCLUSIVE',
       'shared' => 'SHARED',
       'workflow' => 'WORKFLOW'
-    }.freeze, T::Hash[String, String])
+    }.freeze
 
     module_function
 
     # Generate the discovery JSON for the given endpoint.
-    sig { params(endpoint: Endpoint, _version: Integer, discovered_as: String).returns(String) }
     def compute_discovery_json(endpoint, _version, discovered_as)
       ep = compute_discovery(endpoint, discovered_as)
       JSON.generate(ep, allow_nan: false)
     end
 
     # Build the discovery hash for the endpoint.
-    sig { params(endpoint: Endpoint, discovered_as: String).returns(T::Hash[Symbol, T.untyped]) }
     def compute_discovery(endpoint, discovered_as)
       services = endpoint.services.values.map do |service|
         build_service(service)
@@ -50,7 +46,6 @@ module Restate
       )
     end
 
-    sig { params(service: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
     def build_service(service) # rubocop:disable Metrics/AbcSize
       service_type = SERVICE_TYPES.fetch(service.service_tag.kind)
 
@@ -80,7 +75,6 @@ module Restate
       result
     end
 
-    sig { params(handler: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
     def build_handler(handler) # rubocop:disable Metrics/AbcSize
       ty = handler.kind ? HANDLER_TYPES.fetch(handler.kind) : nil
 
@@ -118,7 +112,6 @@ module Restate
     end
 
     # Convert seconds to milliseconds (integer). Returns nil if input is nil.
-    sig { params(seconds: T.nilable(Numeric)).returns(T.nilable(Integer)) }
     def seconds_to_ms(seconds)
       return nil if seconds.nil?
 
@@ -126,7 +119,6 @@ module Restate
     end
 
     # Merge retry policy fields (flattened) into the target hash.
-    sig { params(target: T::Hash[Symbol, T.untyped], policy: T.nilable(T::Hash[Symbol, T.untyped])).void }
     def merge_retry_policy!(target, policy) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
       return if policy.nil? || policy.empty?
 
@@ -138,7 +130,6 @@ module Restate
     end
 
     # Remove nil values from a hash (non-recursive for top level, recursive for nested).
-    sig { params(kwargs: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
     def compact(**kwargs)
       kwargs.each_with_object({}) do |(k, v), result|
         next if v.nil?