temporalio 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 268dababab1b3104d90484a92d2b31cf2716c0ccf8e174b86f957d7e78a7dc34
-  data.tar.gz: 4ac90452d338cda2967b8ab88f9fac481dc92a6ec8aa740be539067c9a5e07da
+  metadata.gz: eab42914a8505489221304731b5e794855699374913e2ceda6b37dc446d175b7
+  data.tar.gz: ec78f3ae4a518ba34d8086d372684b9f71f2de89b380e639a7f4e83a44e8b6f5
 SHA512:
-  metadata.gz: 1cbb397fdb411c2d869e2deb6cc641e1840d272071e425b58da2d6bca9b39bea69428d6a20da60688325094cf4c8ddc0568033ec57e8772b42ca3594b6477a07
-  data.tar.gz: b1b91bb6f524008cf4b1c40d29c6e92c8e3bc22addf949c6b12aedd631e0314ea65770853f9a0076016a9540f10bb2e22a4170e606defd934187a1fcc9783774
+  metadata.gz: aafa0d2a6640601bf031ce18029c5135a53c5127056e0c423c1ade397069e746f4d96278cc282286f28213b32aa5248c7fcc2a9f3c71579caa68d1a8cf59774b
+  data.tar.gz: 7a4054f79dbcb27a9f27a9d6d16e9275d7cfd4663f04775c9525a9b63a234df70986fc9c9db40fcacac58ec272e401c59f552fadb4d782d21a277f1d5fe1e154

data/README.md

@@ -1491,6 +1491,14 @@ E.g. show all test names while executing:
 
     bundle exec rake test TESTOPTS="--verbose"
 
+To list source tests excluded from Cloud, grouped by reason and note:
+
+    bundle exec rake test:cloud_inventory
+
+To run the Cloud-eligible suite against an envconfig-defined server:
+
+    bundle exec rake test:cloud
+
 ### Code Formatting and Type Checking
 
 This project uses `rubocop`:

data/Rakefile

@@ -27,6 +27,25 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb', 'extra/release/test/**/*_test.rb']
 end
 
+namespace :test do
+  desc 'List tests excluded from Temporal Cloud by reason'
+  task :cloud_inventory do
+    ENV['TESTOPTS'] = [
+      ENV.fetch('TESTOPTS', nil),
+      '--cloud-inventory',
+      '--name=/CloudTestInventoryTest#test_report/'
+    ].compact.join(' ')
+    Rake::Task[:test].invoke
+  end
+
+  desc 'Run tests eligible for Temporal Cloud using envconfig'
+  task :cloud do
+    ENV['TEMPORAL_TEST_ENV_CONFIG_SERVER'] = '1'
+    ENV['TESTOPTS'] = [ENV.fetch('TESTOPTS', nil), '--cloud'].compact.join(' ')
+    Rake::Task[:test].invoke
+  end
+end
+
 require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new

data/lib/temporalio/client/activity_execution.rb

@@ -46,6 +46,12 @@ module Temporalio
         Internal::ProtoUtils.timestamp_to_time(@raw_info.schedule_time)
       end
 
+      # @return [Time, nil] When the first activity task was made available for dispatch. Equals
+      #   schedule_time + start_delay; equal to schedule_time when no start delay is set.
+      def execution_time
+        Internal::ProtoUtils.timestamp_to_time(@raw_info.execution_time)
+      end
+
       # @return [Time, nil] When the activity reached a terminal state.
       def close_time
         Internal::ProtoUtils.timestamp_to_time(@raw_info.close_time)
@@ -112,7 +118,17 @@ module Temporalio
           Internal::ProtoUtils.duration_to_seconds(@raw_info.heartbeat_timeout)
         end
 
-        # @return [Boolean] Whether the activity has recorded any heartbeat details.
+        # @return [Float, nil] Delay in seconds before the first activity task is made available for
+        #   dispatch. Not applied to retry attempts.
+        def start_delay
+          Internal::ProtoUtils.duration_to_seconds(@raw_info.start_delay)
+        end
+
+        # Whether heartbeat details are present on this description. False when the activity
+        # recorded none, and also when {ActivityHandle#describe} was called without
+        # `include_heartbeat_details:`.
+        #
+        # @return [Boolean] Whether heartbeat details are present.
         def has_heartbeat_details? # rubocop:disable Naming/PredicatePrefix
           !@raw_info.heartbeat_details&.payloads.nil? && !@raw_info.heartbeat_details.payloads.empty?
         end
@@ -125,6 +141,57 @@ module Temporalio
           @data_converter.from_payloads(@raw_info.heartbeat_details, hints:)
         end
 
+        # Whether the activity's input is present. False unless {ActivityHandle#describe} was
+        # called with `include_input:`.
+        #
+        # @return [Boolean] Whether input is present.
+        def has_input? # rubocop:disable Naming/PredicatePrefix
+          !@raw_description.input.nil?
+        end
+
+        # Deserialized activity input, one element per argument. Empty when no input is present.
+        #
+        # @param hints [Array<Object>, nil] Hints, if any, to assist conversion.
+        # @return [Array<Object>] Converted arguments.
+        def input(hints: nil)
+          @data_converter.from_payloads(@raw_description.input, hints:)
+        end
+
+        # Whether the activity closed with a successful result. False while the activity is still
+        # running, when it closed with a failure, and when {ActivityHandle#describe} was called
+        # without `include_outcome:`.
+        #
+        # @return [Boolean] Whether a result is present.
+        def has_result? # rubocop:disable Naming/PredicatePrefix
+          @raw_description.outcome&.value == :result
+        end
+
+        # Deserialized result the activity closed with. Nil when no result is present (still
+        # running, closed with a failure, or `include_outcome:` was not requested).
+        #
+        # @param result_hint [Object, nil] Hint, if any, to assist conversion.
+        # @return [Object, nil] Converted result.
+        def result(result_hint: nil)
+          return nil unless has_result?
+
+          @data_converter.from_payloads(
+            @raw_description.outcome.result, hints: Array(result_hint)
+          ).first
+        end
+
+        # Failure the activity closed with. Nil when the activity did not close with a failure or
+        # when {ActivityHandle#describe} was called without `include_outcome:`.
+        #
+        # This is the terminal outcome; {#last_failure} is the failure of the most recent attempt,
+        # which may be set while the activity is still retrying.
+        #
+        # @return [Error::Failure, nil] Converted failure.
+        def failure
+          return nil unless @raw_description.outcome&.value == :failure
+
+          @data_converter.from_failure(@raw_description.outcome.failure)
+        end
+
         # @return [RetryPolicy] Retry policy in effect for this activity.
         def retry_policy
           RetryPolicy._from_proto(@raw_info.retry_policy)
@@ -145,6 +212,20 @@ module Temporalio
           @raw_info.attempt
         end
 
+        # @return [Integer] Total number of heartbeats recorded across all attempts.
+        def total_heartbeat_count
+          @raw_info.total_heartbeat_count
+        end
+
+        # Whether a last failure is present on this description. False when the activity has no
+        # failed attempt, and also when {ActivityHandle#describe} was called without
+        # `include_last_failure:`.
+        #
+        # @return [Boolean] Whether a last failure is present.
+        def has_last_failure? # rubocop:disable Naming/PredicatePrefix
+          !@raw_info.last_failure.nil?
+        end
+
         # @return [Error::Failure, nil] Failure of the last failed attempt if any.
         def last_failure
           return nil unless @raw_info.last_failure

data/lib/temporalio/client/activity_execution_options.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/proto_utils'
+require 'temporalio/priority'
+require 'temporalio/retry_policy'
+
+module Temporalio
+  class Client
+    # The resolved options of a standalone activity execution, as returned by
+    # {ActivityHandle#update_options}. Reflects the activity's options as the server resolved them
+    # after the update was applied.
+    #
+    # WARNING: Standalone Activities are experimental.
+    ActivityExecutionOptions = Data.define(
+      :task_queue,
+      :schedule_to_close_timeout,
+      :schedule_to_start_timeout,
+      :start_to_close_timeout,
+      :heartbeat_timeout,
+      :retry_policy,
+      :priority,
+      :start_delay
+    ) do
+      # @!visibility private
+      def self._from_proto(options)
+        new(
+          task_queue: Internal::ProtoUtils.string_or(options.task_queue&.name, nil),
+          schedule_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(options.schedule_to_close_timeout),
+          schedule_to_start_timeout: Internal::ProtoUtils.duration_to_seconds(options.schedule_to_start_timeout),
+          start_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(options.start_to_close_timeout),
+          heartbeat_timeout: Internal::ProtoUtils.duration_to_seconds(options.heartbeat_timeout),
+          retry_policy: options.retry_policy ? RetryPolicy._from_proto(options.retry_policy) : nil,
+          priority: Priority._from_proto(options.priority),
+          start_delay: Internal::ProtoUtils.duration_to_seconds(options.start_delay)
+        )
+      end
+    end
+  end
+end

data/lib/temporalio/client/activity_execution_status.rb

@@ -15,6 +15,7 @@ module Temporalio
       CANCELED = Api::Enums::V1::ActivityExecutionStatus::ACTIVITY_EXECUTION_STATUS_CANCELED
       TERMINATED = Api::Enums::V1::ActivityExecutionStatus::ACTIVITY_EXECUTION_STATUS_TERMINATED
       TIMED_OUT = Api::Enums::V1::ActivityExecutionStatus::ACTIVITY_EXECUTION_STATUS_TIMED_OUT
+      PAUSED = Api::Enums::V1::ActivityExecutionStatus::ACTIVITY_EXECUTION_STATUS_PAUSED
     end
   end
 end

data/lib/temporalio/client/activity_handle.rb

@@ -2,8 +2,13 @@
 
 require 'temporalio/api'
 require 'temporalio/client/activity_execution'
+require 'temporalio/client/activity_execution_options'
+require 'temporalio/client/activity_options'
 require 'temporalio/client/interceptor'
 require 'temporalio/error'
+require 'temporalio/internal/proto_utils'
+require 'temporalio/priority'
+require 'temporalio/retry_policy'
 
 module Temporalio
   class Client
@@ -55,15 +60,35 @@ module Temporalio
 
       # Describe the activity.
       #
+      # The payload-bearing fields are opt-in because they can be arbitrarily large; request them
+      # only when needed. Each has a corresponding predicate on the returned description that
+      # reports whether the server supplied it.
+      #
+      # @param include_input [Boolean] If true and the activity received input, include the input.
+      # @param include_outcome [Boolean] If true and the activity is closed, include the outcome.
+      # @param include_heartbeat_details [Boolean] If true and the activity recorded heartbeat
+      #   details, include them.
+      # @param include_last_failure [Boolean] If true and the activity has a failed attempt, include
+      #   the last failure.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @return [ActivityExecution::Description] Activity description.
       # @raise [Error::RPCError] RPC error from call.
-      def describe(rpc_options: nil)
+      def describe(
+        include_input: false,
+        include_outcome: false,
+        include_heartbeat_details: false,
+        include_last_failure: false,
+        rpc_options: nil
+      )
         @client._impl.describe_activity(
           Interceptor::DescribeActivityInput.new(
             activity_id: id,
             activity_run_id: run_id,
+            include_input:,
+            include_outcome:,
+            include_heartbeat_details:,
+            include_last_failure:,
             rpc_options:
           )
         )
@@ -103,6 +128,102 @@ module Temporalio
         nil
       end
 
+      # Pause the activity. A paused activity is not scheduled or retried until it is unpaused via
+      # {#unpause}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      #
+      # @param reason [String, nil] Optional reason recorded on the server.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      # @raise [Error::RPCError] RPC error from call.
+      def pause(reason = nil, rpc_options: nil)
+        @client._impl.pause_activity(
+          Interceptor::PauseActivityInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            reason:,
+            rpc_options:
+          )
+        )
+        nil
+      end
+
+      # Unpause the activity, allowing it to be scheduled or retried again.
+      #
+      # WARNING: Standalone Activities are experimental.
+      #
+      # @param reason [String, nil] Optional reason recorded on the server.
+      # @param jitter [Float, nil] If set, the activity will start at a random time within this
+      #   duration (in seconds).
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      # @raise [Error::RPCError] RPC error from call.
+      def unpause(reason: nil, jitter: nil, rpc_options: nil)
+        @client._impl.unpause_activity(
+          Interceptor::UnpauseActivityInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            reason:,
+            jitter:,
+            rpc_options:
+          )
+        )
+        nil
+      end
+
+      # Update the activity's options. Only the options named by `updates` are changed; anything
+      # not named is left as-is.
+      #
+      # Updates are created from the keys on {ActivityOptions}, via {ActivityOptions::Key#value_set}
+      # to set an option or {ActivityOptions::Key#value_unset} to clear it.
+      #
+      # WARNING: Standalone Activities are experimental.
+      #
+      # @param updates [Array<ActivityOptions::Update>] The option updates to apply. At least one is
+      #   required unless `restore_original` is true.
+      # @param restore_original [Boolean] If true, restore the options to the originals the activity
+      #   was created with. Mutually exclusive with any update.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @return [ActivityExecutionOptions] The activity options after the update.
+      #
+      # @raise [ArgumentError] If a non-update is given, if `restore_original` is combined with any
+      #   update, or if no update is provided and `restore_original` is false.
+      # @raise [Error::RPCError] RPC error from call.
+      def update_options(*updates, restore_original: false, rpc_options: nil)
+        unless updates.all?(ActivityOptions::Update)
+          raise ArgumentError,
+                'Updates must be created via ActivityOptions::Key#value_set or #value_unset'
+        end
+
+        if restore_original && !updates.empty?
+          raise ArgumentError, 'restore_original cannot be combined with any option update'
+        elsif !restore_original && updates.empty?
+          raise ArgumentError,
+                'At least one option update must be given, or restore_original must be used'
+        end
+
+        # For repeated keys, later values override previous ones.
+        by_path = updates.to_h { |update| [update.key.name, update] }
+
+        proto = Api::Activity::V1::ActivityOptions.new
+        by_path.each_value do |update|
+          # An unset update names its path but leaves the field absent, which is how the server is
+          # told to clear the option rather than set it to a value.
+          update.key._apply(proto, update.value) unless update.value.nil?
+        end
+
+        @client._impl.update_activity_options(
+          Interceptor::UpdateActivityOptionsInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            activity_options: proto,
+            update_mask: Google::Protobuf::FieldMask.new(paths: by_path.keys),
+            restore_original:,
+            rpc_options:
+          )
+        )
+      end
+
       private
 
       def _process_outcome(outcome, hint)

data/lib/temporalio/client/activity_options.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+require 'temporalio/internal/proto_utils'
+
+module Temporalio
+  class Client
+    # The activity options that {ActivityHandle#update_options} can change.
+    #
+    # Updates are created from the keys below, via {Key#value_set} to set an option or
+    # {Key#value_unset} to clear it. An option with no update is left untouched.
+    #
+    # WARNING: Standalone Activities are experimental.
+    module ActivityOptions
+      # Typed key for one updatable activity option. Use the keys on {ActivityOptions} rather than
+      # constructing these directly.
+      class Key
+        # @return [String] Field-mask path this key updates.
+        attr_reader :name
+
+        # @!visibility private
+        def initialize(name, &to_proto)
+          @name = name
+          @to_proto = to_proto
+          freeze
+        end
+
+        # Create an update that sets this option to the given value.
+        #
+        # @param value [Object] Value to set. Cannot be nil.
+        # @return [Update] Created update.
+        def value_set(value)
+          raise ArgumentError, 'Value cannot be nil, use value_unset' if value.nil?
+
+          Update.new(self, value)
+        end
+
+        # Create an update that clears this option server-side.
+        #
+        # @return [Update] Created update.
+        def value_unset
+          Update.new(self, nil)
+        end
+
+        # @!visibility private
+        def _apply(proto, value)
+          @to_proto.call(proto, value)
+        end
+      end
+
+      # A single change to an activity's options that can be separately applied.
+      class Update
+        # @return [Key] Key this update applies to.
+        attr_reader :key
+
+        # @return [Object, nil] Value to set, or `nil` to clear the option.
+        attr_reader :value
+
+        # Create an update. Users may find it easier to use {Key#value_set} and {Key#value_unset}.
+        #
+        # @param key [Key] Key to update.
+        # @param value [Object, nil] Value to set, or nil to clear the option.
+        def initialize(key, value)
+          raise ArgumentError, 'Key must be a key' unless key.is_a?(Key)
+
+          @key = key
+          @value = value
+          freeze
+        end
+      end
+
+      # @return [Key] New task queue.
+      TASK_QUEUE = Key.new('task_queue.name') do |proto, value|
+        proto.task_queue = Api::TaskQueue::V1::TaskQueue.new(name: value.to_s)
+      end
+
+      # @return [Key] New schedule-to-close timeout in seconds.
+      SCHEDULE_TO_CLOSE_TIMEOUT = Key.new('schedule_to_close_timeout') do |proto, value|
+        proto.schedule_to_close_timeout = Internal::ProtoUtils.seconds_to_duration(value)
+      end
+
+      # @return [Key] New schedule-to-start timeout in seconds.
+      SCHEDULE_TO_START_TIMEOUT = Key.new('schedule_to_start_timeout') do |proto, value|
+        proto.schedule_to_start_timeout = Internal::ProtoUtils.seconds_to_duration(value)
+      end
+
+      # @return [Key] New start-to-close timeout in seconds.
+      START_TO_CLOSE_TIMEOUT = Key.new('start_to_close_timeout') do |proto, value|
+        proto.start_to_close_timeout = Internal::ProtoUtils.seconds_to_duration(value)
+      end
+
+      # @return [Key] New heartbeat timeout in seconds.
+      HEARTBEAT_TIMEOUT = Key.new('heartbeat_timeout') do |proto, value|
+        proto.heartbeat_timeout = Internal::ProtoUtils.seconds_to_duration(value)
+      end
+
+      # @return [Key] New start delay in seconds.
+      START_DELAY = Key.new('start_delay') do |proto, value|
+        proto.start_delay = Internal::ProtoUtils.seconds_to_duration(value)
+      end
+
+      # @return [Key] New retry policy.
+      RETRY_POLICY = Key.new('retry_policy') do |proto, value|
+        proto.retry_policy = value._to_proto
+      end
+
+      # @return [Key] New priority.
+      PRIORITY = Key.new('priority') do |proto, value|
+        proto.priority = value._to_proto
+      end
+    end
+  end
+end

data/lib/temporalio/client/interceptor.rb

@@ -291,6 +291,10 @@ module Temporalio
       DescribeActivityInput = Data.define(
         :activity_id,
         :activity_run_id,
+        :include_input,
+        :include_outcome,
+        :include_heartbeat_details,
+        :include_last_failure,
         :rpc_options
       )
 
@@ -314,6 +318,39 @@ module Temporalio
         :rpc_options
       )
 
+      # Input for {Outbound.pause_activity}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      PauseActivityInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :reason,
+        :rpc_options
+      )
+
+      # 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}.
       #
       # WARNING: Standalone Activities are experimental.
@@ -587,6 +624,34 @@ module Temporalio
           next_interceptor.terminate_activity(input)
         end
 
+        # 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.
         #
         # WARNING: Standalone Activities are experimental.

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
@@ -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,54 @@ 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)
+          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.8.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
 

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

data/rbi/temporalio/client/activity_options.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Temporalio
+  class Client
+    module ActivityOptions
+      class Key
+        sig { returns(String) }
+        def name; end
+
+        sig do
+          params(
+            name: String,
+            to_proto: T.proc.params(proto: Temporalio::Api::Activity::V1::ActivityOptions, value: Object).void
+          ).void
+        end
+        def initialize(name, &to_proto); end
+
+        sig { params(value: Object).returns(Temporalio::Client::ActivityOptions::Update) }
+        def value_set(value); end
+
+        sig { returns(Temporalio::Client::ActivityOptions::Update) }
+        def value_unset; end
+
+        sig { params(proto: Temporalio::Api::Activity::V1::ActivityOptions, value: Object).void }
+        def _apply(proto, value); end
+      end
+
+      class Update
+        sig { returns(Temporalio::Client::ActivityOptions::Key) }
+        def key; end
+
+        sig { returns(T.nilable(Object)) }
+        def value; end
+
+        sig { params(key: Temporalio::Client::ActivityOptions::Key, value: T.nilable(Object)).void }
+        def initialize(key, value); end
+      end
+
+      TASK_QUEUE = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      SCHEDULE_TO_CLOSE_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      SCHEDULE_TO_START_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      START_TO_CLOSE_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      HEARTBEAT_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      START_DELAY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      RETRY_POLICY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      PRIORITY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+    end
+  end
+end

data/rbi/temporalio/client/interceptor.rbi

@@ -834,6 +834,18 @@ class Temporalio::Client::Interceptor::DescribeActivityInput < ::Data
   sig { returns(T.nilable(String)) }
   def activity_run_id; end
 
+  sig { returns(T::Boolean) }
+  def include_input; end
+
+  sig { returns(T::Boolean) }
+  def include_outcome; end
+
+  sig { returns(T::Boolean) }
+  def include_heartbeat_details; end
+
+  sig { returns(T::Boolean) }
+  def include_last_failure; end
+
   sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
   def rpc_options; end
 
@@ -849,6 +861,88 @@ class Temporalio::Client::Interceptor::DescribeActivityInput < ::Data
   end
 end
 
+class Temporalio::Client::Interceptor::PauseActivityInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def reason; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseActivityInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseActivityInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+class Temporalio::Client::Interceptor::UnpauseActivityInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def reason; end
+
+  sig { returns(T.nilable(Float)) }
+  def jitter; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseActivityInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseActivityInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+class Temporalio::Client::Interceptor::UpdateActivityOptionsInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(Temporalio::Api::Activity::V1::ActivityOptions) }
+  def activity_options; end
+
+  sig { returns(Google::Protobuf::FieldMask) }
+  def update_mask; end
+
+  sig { returns(T::Boolean) }
+  def restore_original; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateActivityOptionsInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateActivityOptionsInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+
 class Temporalio::Client::Interceptor::CancelActivityInput < ::Data
   sig { returns(String) }
   def activity_id; end
@@ -1056,6 +1150,19 @@ class Temporalio::Client::Interceptor::Outbound
   sig { params(input: Temporalio::Client::Interceptor::TerminateActivityInput).void }
   def terminate_activity(input); end
 
+  sig { params(input: Temporalio::Client::Interceptor::PauseActivityInput).void }
+  def pause_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::UnpauseActivityInput).void }
+  def unpause_activity(input); end
+
+
+  sig do
+    params(input: Temporalio::Client::Interceptor::UpdateActivityOptionsInput)
+      .returns(Temporalio::Client::ActivityExecutionOptions)
+  end
+  def update_activity_options(input); end
+
   sig { params(input: Temporalio::Client::Interceptor::ListActivitiesInput).returns(T::Enumerator[Temporalio::Client::ActivityExecution]) }
   def list_activities(input); end
 

data/sig/temporalio/client/activity_execution.rbs

@@ -9,6 +9,7 @@ module Temporalio
       def activity_run_id: -> String?
       def activity_type: -> String
       def schedule_time: -> Time?
+      def execution_time: -> Time?
       def close_time: -> Time?
       def status: -> ActivityExecutionStatus::enum
       def search_attributes: -> SearchAttributes?
@@ -25,12 +26,21 @@ module Temporalio
         def schedule_to_start_timeout: -> Float?
         def start_to_close_timeout: -> Float?
         def heartbeat_timeout: -> Float?
+        def start_delay: -> Float?
         def has_heartbeat_details?: -> bool
+        def has_last_failure?: -> bool
+        def has_input?: -> bool
+        def input: (?hints: Array[Object]?) -> Array[Object?]
+        def has_result?: -> bool
+        def result: (?result_hint: Object?) -> Object?
+        def failure: -> Error::Failure?
         def heartbeat_details: (?hints: Array[Object]?) -> Array[Object?]
         def retry_policy: -> RetryPolicy
         def last_heartbeat_time: -> Time?
         def last_started_time: -> Time?
         def attempt: -> Integer
+
+        def total_heartbeat_count: -> Integer
         def last_failure: -> Error::Failure?
         def expiration_time: -> Time?
         def last_worker_identity: -> String?

data/sig/temporalio/client/activity_execution_options.rbs

@@ -0,0 +1,27 @@
+module Temporalio
+  class Client
+    class ActivityExecutionOptions
+      attr_reader task_queue: String?
+      attr_reader schedule_to_close_timeout: Float?
+      attr_reader schedule_to_start_timeout: Float?
+      attr_reader start_to_close_timeout: Float?
+      attr_reader heartbeat_timeout: Float?
+      attr_reader retry_policy: RetryPolicy?
+      attr_reader priority: Priority
+      attr_reader start_delay: Float?
+
+      def self._from_proto: (untyped options) -> ActivityExecutionOptions
+
+      def initialize: (
+        task_queue: String?,
+        schedule_to_close_timeout: Float?,
+        schedule_to_start_timeout: Float?,
+        start_to_close_timeout: Float?,
+        heartbeat_timeout: Float?,
+        retry_policy: RetryPolicy?,
+        priority: Priority,
+        start_delay: Float?
+      ) -> void
+    end
+  end
+end

data/sig/temporalio/client/activity_execution_status.rbs

@@ -10,6 +10,7 @@ module Temporalio
       CANCELED: enum
       TERMINATED: enum
       TIMED_OUT: enum
+      PAUSED: enum
     end
   end
 end

data/sig/temporalio/client/activity_handle.rbs

@@ -1,6 +1,8 @@
 module Temporalio
   class Client
     class ActivityHandle
+      UPDATABLE_OPTION_PATHS: Hash[Symbol, String]
+
       attr_reader id: String
       attr_reader run_id: String?
       attr_reader result_hint: Object?
@@ -14,12 +16,32 @@ module Temporalio
 
       def result: (?result_hint: Object?, ?rpc_options: RPCOptions?) -> Object?
 
-      def describe: (?rpc_options: RPCOptions?) -> ActivityExecution::Description
+      def describe: (
+        ?include_input: bool,
+        ?include_outcome: bool,
+        ?include_heartbeat_details: bool,
+        ?include_last_failure: bool,
+        ?rpc_options: RPCOptions?
+      ) -> ActivityExecution::Description
 
       def cancel: (?String? reason, ?rpc_options: RPCOptions?) -> void
 
       def terminate: (?String? reason, ?rpc_options: RPCOptions?) -> void
 
+      def pause: (?String? reason, ?rpc_options: RPCOptions?) -> void
+
+      def unpause: (
+        ?reason: String?,
+        ?jitter: Float?,
+        ?rpc_options: RPCOptions?
+      ) -> void
+
+      def update_options: (
+        *ActivityOptions::Update updates,
+        ?restore_original: bool,
+        ?rpc_options: RPCOptions?
+      ) -> ActivityExecutionOptions
+
       private def _process_outcome: (Api::Activity::V1::ActivityExecutionOutcome? outcome, Object? hint) -> Object?
     end
   end

data/sig/temporalio/client/activity_options.rbs

@@ -0,0 +1,30 @@
+module Temporalio
+  class Client
+    module ActivityOptions
+      class Key
+        attr_reader name: String
+
+        def initialize: (String name) { (untyped proto, untyped value) -> void } -> void
+        def value_set: (untyped value) -> Update
+        def value_unset: () -> Update
+        def _apply: (untyped proto, untyped value) -> void
+      end
+
+      class Update
+        attr_reader key: Key
+        attr_reader value: untyped?
+
+        def initialize: (Key key, untyped? value) -> void
+      end
+
+      TASK_QUEUE: Key
+      SCHEDULE_TO_CLOSE_TIMEOUT: Key
+      SCHEDULE_TO_START_TIMEOUT: Key
+      START_TO_CLOSE_TIMEOUT: Key
+      HEARTBEAT_TIMEOUT: Key
+      START_DELAY: Key
+      RETRY_POLICY: Key
+      PRIORITY: Key
+    end
+  end
+end

data/sig/temporalio/client/interceptor.rbs

@@ -481,11 +481,19 @@ module Temporalio
       class DescribeActivityInput
         attr_reader activity_id: String
         attr_reader activity_run_id: String?
+        attr_reader include_input: bool
+        attr_reader include_outcome: bool
+        attr_reader include_heartbeat_details: bool
+        attr_reader include_last_failure: bool
         attr_reader rpc_options: RPCOptions?
 
         def initialize: (
           activity_id: String,
           activity_run_id: String?,
+          include_input: bool,
+          include_outcome: bool,
+          include_heartbeat_details: bool,
+          include_last_failure: bool,
           rpc_options: RPCOptions?
         ) -> void
       end
@@ -518,6 +526,54 @@ module Temporalio
         ) -> void
       end
 
+      class PauseActivityInput
+        attr_reader activity_id: String
+        attr_reader activity_run_id: String?
+        attr_reader reason: String?
+        attr_reader rpc_options: RPCOptions?
+
+        def initialize: (
+          activity_id: String,
+          activity_run_id: String?,
+          reason: String?,
+          rpc_options: RPCOptions?
+        ) -> void
+      end
+
+      class UnpauseActivityInput
+        attr_reader activity_id: String
+        attr_reader activity_run_id: String?
+        attr_reader reason: String?
+        attr_reader jitter: Float?
+        attr_reader rpc_options: RPCOptions?
+
+        def initialize: (
+          activity_id: String,
+          activity_run_id: String?,
+          reason: String?,
+          jitter: Float?,
+          rpc_options: RPCOptions?
+        ) -> void
+      end
+
+      class UpdateActivityOptionsInput
+        attr_reader activity_id: String
+        attr_reader activity_run_id: String?
+        attr_reader activity_options: untyped
+        attr_reader update_mask: untyped
+        attr_reader restore_original: bool
+        attr_reader rpc_options: RPCOptions?
+
+        def initialize: (
+          activity_id: String,
+          activity_run_id: String?,
+          activity_options: untyped,
+          update_mask: untyped,
+          restore_original: bool,
+          rpc_options: RPCOptions?
+        ) -> void
+      end
+
       class ListActivitiesInput
         attr_reader query: String
         attr_reader rpc_options: RPCOptions?
@@ -611,6 +667,12 @@ module Temporalio
 
         def terminate_activity: (TerminateActivityInput input) -> void
 
+        def pause_activity: (PauseActivityInput input) -> void
+
+        def unpause_activity: (UnpauseActivityInput input) -> void
+
+        def update_activity_options: (UpdateActivityOptionsInput input) -> untyped
+
         def list_activities: (ListActivitiesInput input) -> Enumerator[ActivityExecution, ActivityExecution]
 
         def count_activities: (CountActivitiesInput input) -> ActivityExecutionCount

data/sig/temporalio/internal/client/implementation.rbs

@@ -22,6 +22,13 @@ module Temporalio
 
         def terminate_activity: (Temporalio::Client::Interceptor::TerminateActivityInput input) -> void
 
+        def pause_activity: (Temporalio::Client::Interceptor::PauseActivityInput input) -> void
+
+        def unpause_activity: (Temporalio::Client::Interceptor::UnpauseActivityInput input) -> void
+
+
+        def update_activity_options: (Temporalio::Client::Interceptor::UpdateActivityOptionsInput input) -> untyped
+
         def list_activities: (Temporalio::Client::Interceptor::ListActivitiesInput input) -> Enumerator[Temporalio::Client::ActivityExecution, Temporalio::Client::ActivityExecution]
 
         def count_activities: (Temporalio::Client::Interceptor::CountActivitiesInput input) -> Temporalio::Client::ActivityExecutionCount

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: temporalio
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Temporal Technologies Inc
@@ -143,9 +143,11 @@ files:
 - lib/temporalio/client.rb
 - lib/temporalio/client/activity_execution.rb
 - lib/temporalio/client/activity_execution_count.rb
+- lib/temporalio/client/activity_execution_options.rb
 - lib/temporalio/client/activity_execution_status.rb
 - lib/temporalio/client/activity_handle.rb
 - lib/temporalio/client/activity_id_reference.rb
+- lib/temporalio/client/activity_options.rb
 - lib/temporalio/client/async_activity_handle.rb
 - lib/temporalio/client/connection.rb
 - lib/temporalio/client/connection/cloud_service.rb
@@ -364,9 +366,11 @@ files:
 - rbi/temporalio/client.rbi
 - rbi/temporalio/client/activity_execution.rbi
 - rbi/temporalio/client/activity_execution_count.rbi
+- rbi/temporalio/client/activity_execution_options.rbi
 - rbi/temporalio/client/activity_execution_status.rbi
 - rbi/temporalio/client/activity_handle.rbi
 - rbi/temporalio/client/activity_id_reference.rbi
+- rbi/temporalio/client/activity_options.rbi
 - rbi/temporalio/client/async_activity_handle.rbi
 - rbi/temporalio/client/connection.rbi
 - rbi/temporalio/client/connection/cloud_service.rbi
@@ -583,9 +587,11 @@ files:
 - sig/temporalio/client.rbs
 - sig/temporalio/client/activity_execution.rbs
 - sig/temporalio/client/activity_execution_count.rbs
+- sig/temporalio/client/activity_execution_options.rbs
 - sig/temporalio/client/activity_execution_status.rbs
 - sig/temporalio/client/activity_handle.rbs
 - sig/temporalio/client/activity_id_reference.rbs
+- sig/temporalio/client/activity_options.rbs
 - sig/temporalio/client/async_activity_handle.rbs
 - sig/temporalio/client/connection.rbs
 - sig/temporalio/client/connection/cloud_service.rbs