temporalio 1.7.0 → 1.9.0

data/lib/temporalio/client/interceptor.rb

@@ -260,8 +260,6 @@ module Temporalio
       )
 
       # Input for {Outbound.start_activity}.
-      #
-      # WARNING: Standalone Activities are experimental.
       StartActivityInput = Data.define(
         :activity,
         :args,
@@ -275,7 +273,7 @@ module Temporalio
         :id_conflict_policy,
         :retry_policy,
         :search_attributes,
-        :static_summary,
+        :summary,
         :static_details,
         :headers,
         :priority,
@@ -286,17 +284,17 @@ module Temporalio
       )
 
       # Input for {Outbound.describe_activity}.
-      #
-      # WARNING: Standalone Activities are experimental.
       DescribeActivityInput = Data.define(
         :activity_id,
         :activity_run_id,
+        :include_input,
+        :include_outcome,
+        :include_heartbeat_details,
+        :include_last_failure,
         :rpc_options
       )
 
       # Input for {Outbound.cancel_activity}.
-      #
-      # WARNING: Standalone Activities are experimental.
       CancelActivityInput = Data.define(
         :activity_id,
         :activity_run_id,
@@ -305,26 +303,53 @@ module Temporalio
       )
 
       # Input for {Outbound.terminate_activity}.
+      TerminateActivityInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :reason,
+        :rpc_options
+      )
+
+      # Input for {Outbound.pause_activity}.
       #
       # WARNING: Standalone Activities are experimental.
-      TerminateActivityInput = Data.define(
+      PauseActivityInput = Data.define(
         :activity_id,
         :activity_run_id,
         :reason,
         :rpc_options
       )
 
-      # Input for {Outbound.list_activities}.
+      # Input for {Outbound.unpause_activity}.
       #
       # WARNING: Standalone Activities are experimental.
+      UnpauseActivityInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :reason,
+        :jitter,
+        :rpc_options
+      )
+
+      # Input for {Outbound.update_activity_options}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      UpdateActivityOptionsInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :activity_options,
+        :update_mask,
+        :restore_original,
+        :rpc_options
+      )
+
+      # Input for {Outbound.list_activities}.
       ListActivitiesInput = Data.define(
         :query,
         :rpc_options
       )
 
       # Input for {Outbound.count_activities}.
-      #
-      # WARNING: Standalone Activities are experimental.
       CountActivitiesInput = Data.define(
         :query,
         :rpc_options
@@ -332,8 +357,6 @@ module Temporalio
 
       # Input for {Outbound.fetch_activity_outcome}. Used by `ActivityHandle#result` for long-polling
       # the activity outcome via `PollActivityExecution`.
-      #
-      # WARNING: Standalone Activities are experimental.
       FetchActivityOutcomeInput = Data.define(
         :activity_id,
         :activity_run_id,
@@ -551,8 +574,6 @@ module Temporalio
 
         # Called for every {Client.start_activity} and {Client.execute_activity} call.
         #
-        # WARNING: Standalone Activities are experimental.
-        #
         # @param input [StartActivityInput] Input.
         # @return [ActivityHandle] Activity handle.
         def start_activity(input)
@@ -561,8 +582,6 @@ module Temporalio
 
         # Called for every {ActivityHandle.describe} call.
         #
-        # WARNING: Standalone Activities are experimental.
-        #
         # @param input [DescribeActivityInput] Input.
         # @return [ActivityExecution::Description] Activity description.
         def describe_activity(input)
@@ -571,8 +590,6 @@ module Temporalio
 
         # Called for every {ActivityHandle.cancel} call.
         #
-        # WARNING: Standalone Activities are experimental.
-        #
         # @param input [CancelActivityInput] Input.
         def cancel_activity(input)
           next_interceptor.cancel_activity(input)
@@ -580,17 +597,41 @@ module Temporalio
 
         # Called for every {ActivityHandle.terminate} call.
         #
-        # WARNING: Standalone Activities are experimental.
-        #
         # @param input [TerminateActivityInput] Input.
         def terminate_activity(input)
           next_interceptor.terminate_activity(input)
         end
 
-        # Called for every {Client.list_activities} call.
+        # Called for every {ActivityHandle.pause} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [PauseActivityInput] Input.
+        def pause_activity(input)
+          next_interceptor.pause_activity(input)
+        end
+
+        # Called for every {ActivityHandle.unpause} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [UnpauseActivityInput] Input.
+        def unpause_activity(input)
+          next_interceptor.unpause_activity(input)
+        end
+
+        # Called for every {ActivityHandle.update_options} call.
         #
         # WARNING: Standalone Activities are experimental.
         #
+        # @param input [UpdateActivityOptionsInput] Input.
+        # @return [Api::Activity::V1::ActivityOptions] Activity options after the update.
+        def update_activity_options(input)
+          next_interceptor.update_activity_options(input)
+        end
+
+        # Called for every {Client.list_activities} call.
+        #
         # @param input [ListActivitiesInput] Input.
         # @return [Enumerator<ActivityExecution>] Activity executions.
         def list_activities(input)
@@ -599,8 +640,6 @@ module Temporalio
 
         # Called for every {Client.count_activities} call.
         #
-        # WARNING: Standalone Activities are experimental.
-        #
         # @param input [CountActivitiesInput] Input.
         # @return [ActivityExecutionCount] Activity count.
         def count_activities(input)
@@ -609,8 +648,6 @@ module Temporalio
 
         # Called by {ActivityHandle.result} to long-poll the activity outcome.
         #
-        # WARNING: Standalone Activities are experimental.
-        #
         # @param input [FetchActivityOutcomeInput] Input.
         # @return [Api::Activity::V1::ActivityExecutionOutcome] Activity outcome.
         def fetch_activity_outcome(input)

data/lib/temporalio/client/pending_activity_state.rb

@@ -5,8 +5,6 @@ require 'temporalio/api'
 module Temporalio
   class Client
     # More detailed breakdown of a running activity's state.
-    #
-    # WARNING: Standalone Activities are experimental.
     module PendingActivityState
       SCHEDULED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_SCHEDULED
       STARTED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_STARTED

data/lib/temporalio/client.rb

@@ -485,8 +485,6 @@ module Temporalio
     # Get a handle for an existing standalone activity. Useful when the activity was started elsewhere
     # (a different process, or by another client) and you have only its ID.
     #
-    # WARNING: Standalone Activities are experimental.
-    #
     # @param activity_id [String] ID for the activity.
     # @param activity_run_id [String, nil] Run ID for the activity execution. If nil, operations target the
     #   latest run of the given activity ID.
@@ -500,8 +498,6 @@ module Temporalio
 
     # Start a standalone activity execution and return its handle.
     #
-    # WARNING: Standalone Activities are experimental.
-    #
     # @param activity [Class<Activity::Definition>, Activity::Definition, Activity::Definition::Info, Symbol, String]
     #   Activity definition, definition class or activity name.
     # @param args [Array<Object>] Arguments to the activity.
@@ -519,7 +515,7 @@ module Temporalio
     #   is currently running. Defaults to `FAIL` (reject the start attempt).
     # @param retry_policy [RetryPolicy, nil] Retry policy for the activity.
     # @param search_attributes [SearchAttributes, nil] Search attributes for the activity.
-    # @param static_summary [String, nil] Fixed single-line summary for this activity execution.
+    # @param summary [String, nil] Fixed single-line summary for this activity execution.
     # @param static_details [String, nil] Fixed details for this activity execution. May be in markdown format.
     # @param priority [Priority] Priority for the activity. This is currently experimental.
     # @param start_delay [Float, nil] Time (in seconds) to wait before dispatching the first activity task. This delay
@@ -545,7 +541,7 @@ module Temporalio
       id_conflict_policy: ActivityIDConflictPolicy::FAIL,
       retry_policy: nil,
       search_attributes: nil,
-      static_summary: nil,
+      summary: nil,
       static_details: nil,
       priority: Priority.default,
       start_delay: nil,
@@ -568,7 +564,7 @@ module Temporalio
                              id_conflict_policy:,
                              retry_policy:,
                              search_attributes:,
-                             static_summary:,
+                             summary:,
                              static_details:,
                              headers: {},
                              priority:,
@@ -582,8 +578,6 @@ module Temporalio
     # Start a standalone activity execution and wait for its result. Shortcut for
     # {start_activity} + {ActivityHandle#result}.
     #
-    # WARNING: Standalone Activities are experimental.
-    #
     # @param activity [Class<Activity::Definition>, Activity::Definition, Activity::Definition::Info, Symbol, String]
     #   Activity definition, definition class or activity name.
     # @param args [Array<Object>] Arguments to the activity.
@@ -601,7 +595,7 @@ module Temporalio
     #   is currently running. Defaults to `FAIL` (reject the start attempt).
     # @param retry_policy [RetryPolicy, nil] Retry policy for the activity.
     # @param search_attributes [SearchAttributes, nil] Search attributes for the activity.
-    # @param static_summary [String, nil] Fixed single-line summary for this activity execution.
+    # @param summary [String, nil] Fixed single-line summary for this activity execution.
     # @param static_details [String, nil] Fixed details for this activity execution. May be in markdown format.
     # @param priority [Priority] Priority for the activity. This is currently experimental.
     # @param start_delay [Float, nil] Time (in seconds) to wait before dispatching the first activity task. This delay
@@ -628,7 +622,7 @@ module Temporalio
       id_conflict_policy: ActivityIDConflictPolicy::FAIL,
       retry_policy: nil,
       search_attributes: nil,
-      static_summary: nil,
+      summary: nil,
       static_details: nil,
       priority: Priority.default,
       start_delay: nil,
@@ -649,7 +643,7 @@ module Temporalio
         id_conflict_policy:,
         retry_policy:,
         search_attributes:,
-        static_summary:,
+        summary:,
         static_details:,
         priority:,
         start_delay:,
@@ -661,8 +655,6 @@ module Temporalio
 
     # List standalone activities matching a visibility query.
     #
-    # WARNING: Standalone Activities are experimental.
-    #
     # @param query [String] Visibility list filter.
     # @param rpc_options [RPCOptions, nil] Advanced RPC options.
     #
@@ -674,8 +666,6 @@ module Temporalio
 
     # Count standalone activities matching a visibility query.
     #
-    # WARNING: Standalone Activities are experimental.
-    #
     # @param query [String] Visibility list filter.
     # @param rpc_options [RPCOptions, nil] Advanced RPC options.
     #

data/lib/temporalio/common_enums.rb

@@ -86,8 +86,6 @@ module Temporalio
 
   # Controls behavior when an activity with the same ID was previously run and is now closed.
   #
-  # WARNING: Standalone Activities are experimental.
-  #
   # @see https://docs.temporal.io/activities
   module ActivityIDReusePolicy
     # Always allow starting an activity using the same activity ID.
@@ -102,8 +100,6 @@ module Temporalio
 
   # Controls behavior when an activity with the same ID is currently running.
   #
-  # WARNING: Standalone Activities are experimental.
-  #
   # @see https://docs.temporal.io/activities
   module ActivityIDConflictPolicy
     # Don't start a new activity; instead fail with already-started error.

data/lib/temporalio/error/failure.rb

@@ -30,8 +30,6 @@ module Temporalio
     end
 
     # Error raised by a client when a standalone activity execution has already started.
-    #
-    # WARNING: Standalone Activities are experimental.
     class ActivityAlreadyStartedError < Failure
       # @return [String] ID of the already-started activity.
       attr_reader :activity_id

data/lib/temporalio/error.rb

@@ -42,8 +42,6 @@ module Temporalio
 
     # Error returned from {Client::ActivityHandle#result} when the activity did not complete successfully.
     # The specific activity failure can be accessed via `cause`.
-    #
-    # WARNING: Standalone Activities are experimental.
     class ActivityFailedError < Error
       # @!visibility private
       def initialize(message = 'Activity execution failed')

data/lib/temporalio/internal/client/implementation.rb

@@ -29,7 +29,7 @@ require 'temporalio/workflow/definition'
 module Temporalio
   module Internal
     module Client
-      class Implementation < Temporalio::Client::Interceptor::Outbound
+      class Implementation < Temporalio::Client::Interceptor::Outbound # rubocop:disable Metrics/ClassLength
         # Proto routing convention for standalone activity completion: `*_by_id` requests carry
         # `resource_id = "activity:<activity_id>"`. See the resource_id field comment on
         # `RecordActivityTaskHeartbeatByIdRequest` (and the analogous Completed/Failed/Canceled
@@ -984,7 +984,7 @@ module Temporalio
             retry_policy: input.retry_policy&._to_proto,
             search_attributes: input.search_attributes&._to_proto,
             user_metadata: ProtoUtils.to_user_metadata(
-              input.static_summary, input.static_details, @client.data_converter
+              input.summary, input.static_details, @client.data_converter
             ),
             header: ProtoUtils.headers_to_proto(input.headers, @client.data_converter),
             priority: input.priority._to_proto,
@@ -1025,7 +1025,11 @@ module Temporalio
             Api::WorkflowService::V1::DescribeActivityExecutionRequest.new(
               namespace: @client.namespace,
               activity_id: input.activity_id,
-              run_id: input.activity_run_id || ''
+              run_id: input.activity_run_id || '',
+              include_input: input.include_input,
+              include_outcome: input.include_outcome,
+              include_heartbeat_details: input.include_heartbeat_details,
+              include_last_failure: input.include_last_failure
             ),
             rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
           )
@@ -1062,6 +1066,59 @@ module Temporalio
           nil
         end
 
+        def pause_activity(input)
+          @client.workflow_service.pause_activity_execution(
+            Api::WorkflowService::V1::PauseActivityExecutionRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || '',
+              identity: @client.connection.identity,
+              request_id: SecureRandom.uuid,
+              reason: input.reason || ''
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          nil
+        end
+
+        def unpause_activity(input)
+          @client.workflow_service.unpause_activity_execution(
+            Api::WorkflowService::V1::UnpauseActivityExecutionRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || '',
+              identity: @client.connection.identity,
+              request_id: SecureRandom.uuid,
+              reason: input.reason || '',
+              jitter: ProtoUtils.seconds_to_duration(input.jitter)
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          nil
+        end
+
+        def update_activity_options(input)
+          # The handle rejects a repeated option, but an interceptor could still add one.
+          paths = input.update_mask&.paths || []
+          dupe = paths.tally.find { |_, count| count > 1 }&.first
+          raise ArgumentError, "More than one update given for option #{dupe}" if dupe
+
+          resp = @client.workflow_service.update_activity_execution_options(
+            Api::WorkflowService::V1::UpdateActivityExecutionOptionsRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || '',
+              identity: @client.connection.identity,
+              request_id: SecureRandom.uuid,
+              activity_options: input.activity_options,
+              update_mask: input.update_mask,
+              restore_original: input.restore_original
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          Temporalio::Client::ActivityExecutionOptions._from_proto(resp.activity_options)
+        end
+
         def list_activities(input)
           Enumerator.new do |yielder|
             req = Api::WorkflowService::V1::ListActivityExecutionsRequest.new(

data/lib/temporalio/scoped_logger.rb

@@ -106,6 +106,9 @@ module Temporalio
         message_str = message.is_a?(String) ? message : message.inspect
         "#{message_str} #{scoped_values}"
       end
+
+      # @return [String] The log message.
+      alias to_s message
     end
   end
 end

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '1.7.0'
+  VERSION = '1.9.0'
 end

data/lib/temporalio/worker/activity_executor/fiber.rb

@@ -39,8 +39,18 @@ module Temporalio
           return unless defn.cancel_raise
 
           fiber = ::Fiber.current
+          scheduler = ::Fiber.scheduler
+          scheduler = nil unless scheduler.respond_to?(:fiber_interrupt)
           context&.cancellation&.add_cancel_callback do
-            fiber.raise(Error::CanceledError.new('Activity canceled'))
+            error = Error::CanceledError.new('Activity canceled')
+            # Directly raising from another fiber can strand a `Fiber#transfer`
+            # based scheduler's current fiber, so we defer to the scheduler to interrupt.
+            # If on the same fiber, we can just raise directly.
+            if scheduler.nil? || ::Fiber.current.equal?(fiber)
+              fiber.raise(error)
+            else
+              scheduler.fiber_interrupt(fiber, error)
+            end
           end
         end
       end

data/rbi/temporalio/client/activity_execution.rbi

@@ -33,6 +33,9 @@ class Temporalio::Client::ActivityExecution
   sig { returns(T.nilable(Time)) }
   def schedule_time; end
 
+  sig { returns(T.nilable(Time)) }
+  def execution_time; end
+
   sig { returns(T.nilable(Time)) }
   def close_time; end
 
@@ -76,9 +79,30 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   sig { returns(T.nilable(Float)) }
   def heartbeat_timeout; end
 
+  sig { returns(T.nilable(Float)) }
+  def start_delay; end
+
   sig { returns(T::Boolean) }
   def has_heartbeat_details?; end
 
+  sig { returns(T::Boolean) }
+  def has_last_failure?; end
+
+  sig { returns(T::Boolean) }
+  def has_input?; end
+
+  sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
+  def input(hints: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def has_result?; end
+
+  sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def result(result_hint: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(Temporalio::Error::Failure)) }
+  def failure; end
+
   sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
   def heartbeat_details(hints: T.unsafe(nil)); end
 
@@ -94,6 +118,9 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   sig { returns(Integer) }
   def attempt; end
 
+  sig { returns(Integer) }
+  def total_heartbeat_count; end
+
   sig { returns(T.nilable(Temporalio::Error::Failure)) }
   def last_failure; end
 
@@ -122,7 +149,7 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   def canceled_reason; end
 
   sig { returns(T.nilable(String)) }
-  def static_summary; end
+  def summary; end
 
   sig { returns(T.nilable(String)) }
   def static_details; end

data/rbi/temporalio/client/activity_execution_options.rbi

@@ -0,0 +1,58 @@
+# typed: true
+
+class Temporalio::Client::ActivityExecutionOptions
+  class << self
+    sig do
+      params(options: Temporalio::Api::Activity::V1::ActivityOptions)
+        .returns(Temporalio::Client::ActivityExecutionOptions)
+    end
+    def _from_proto(options); end
+  end
+
+  sig do
+    params(
+      task_queue: T.nilable(String),
+      schedule_to_close_timeout: T.nilable(Float),
+      schedule_to_start_timeout: T.nilable(Float),
+      start_to_close_timeout: T.nilable(Float),
+      heartbeat_timeout: T.nilable(Float),
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      priority: Temporalio::Priority,
+      start_delay: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    task_queue:,
+    schedule_to_close_timeout:,
+    schedule_to_start_timeout:,
+    start_to_close_timeout:,
+    heartbeat_timeout:,
+    retry_policy:,
+    priority:,
+    start_delay:
+  ); end
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :task_queue
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :schedule_to_close_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :schedule_to_start_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :start_to_close_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :heartbeat_timeout
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  attr_reader :retry_policy
+
+  sig { returns(Temporalio::Priority) }
+  attr_reader :priority
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :start_delay
+end

data/rbi/temporalio/client/activity_execution_status.rbi

@@ -8,4 +8,5 @@ module Temporalio::Client::ActivityExecutionStatus
   CANCELED = T.let(T.unsafe(nil), Integer)
   TERMINATED = T.let(T.unsafe(nil), Integer)
   TIMED_OUT = T.let(T.unsafe(nil), Integer)
+  PAUSED = T.let(T.unsafe(nil), Integer)
 end

data/rbi/temporalio/client/activity_handle.rbi

@@ -1,6 +1,8 @@
 # typed: true
 
 class Temporalio::Client::ActivityHandle
+  UPDATABLE_OPTION_PATHS = T.let(T.unsafe(nil), T::Hash[Symbol, String])
+
   sig do
     params(
       client: Temporalio::Client,
@@ -28,8 +30,22 @@ class Temporalio::Client::ActivityHandle
   end
   def result(result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
 
-  sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Client::ActivityExecution::Description) }
-  def describe(rpc_options: T.unsafe(nil)); end
+  sig do
+    params(
+      include_input: T::Boolean,
+      include_outcome: T::Boolean,
+      include_heartbeat_details: T::Boolean,
+      include_last_failure: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::ActivityExecution::Description)
+  end
+  def describe(
+    include_input: T.unsafe(nil),
+    include_outcome: T.unsafe(nil),
+    include_heartbeat_details: T.unsafe(nil),
+    include_last_failure: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
 
   sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
   def cancel(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
@@ -37,6 +53,31 @@ class Temporalio::Client::ActivityHandle
   sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
   def terminate(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
 
+  sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def pause(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      reason: T.nilable(String),
+      jitter: T.nilable(Float),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).void
+  end
+  def unpause(reason: T.unsafe(nil), jitter: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      updates: Temporalio::Client::ActivityOptions::Update,
+      restore_original: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::ActivityExecutionOptions)
+  end
+  def update_options(
+    *updates,
+    restore_original: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
+
   private
 
   sig do