temporalio 1.10.1 → 1.11.0

data/lib/temporalio/internal/worker/workflow_instance.rb

@@ -61,7 +61,8 @@ module Temporalio
                     :current_deployment_version,
                     :current_history_length, :current_history_size, :replaying, :random,
                     :signal_handlers, :query_handlers, :update_handlers, :context_frozen, :assert_valid_local_activity,
-                    :in_query_or_validator, :random_disabled, :patch_activation_callback
+                    :in_query_or_validator, :random_disabled, :patch_activation_callback,
+                    :check_conditions
         attr_accessor :io_enabled, :current_details
 
         def initialize(details)
@@ -102,6 +103,7 @@ module Temporalio
           @replaying = false
           @context_frozen = false
           @in_query_or_validator = false
+          @check_conditions = false
           @random_disabled = false
           @workflow_failure_exception_types = details.workflow_failure_exception_types
           @signal_handlers = HandlerHash.new(
@@ -147,6 +149,8 @@ module Temporalio
                            end,
               has_last_result?: !@init_job.last_completion_result.nil?,
               namespace: details.namespace,
+              original_execution_run_id: ProtoUtils.string_or(@init_job.original_execution_run_id) ||
+                details.initial_activation.run_id,
               parent: if @init_job.parent_workflow_info
                         Workflow::Info::ParentInfo.new(
                           namespace: @init_job.parent_workflow_info.namespace,
@@ -194,6 +198,10 @@ module Temporalio
           @current_history_size = activation.history_size_bytes
           @replaying = activation.is_replaying
           @now_timestamp = activation.timestamp
+          # Updates can only change state once accepted, which is recorded when that happens
+          @check_conditions = activation.jobs.any? do |job|
+            !%i[do_update query_workflow].include?(job.variant)
+          end
 
           # Apply jobs and run event loop
           begin
@@ -289,7 +297,7 @@ module Temporalio
           end
         end
 
-        def patch(patch_id:, deprecated:)
+        def patch(patch_id:, deprecated:, event_groups: nil)
           # Use memoized result if present. If this is being deprecated, we can still use memoized result and skip the
           # command.
           patch_id = patch_id.to_s
@@ -305,7 +313,8 @@ module Temporalio
             if patched
               add_command(
                 Bridge::Api::WorkflowCommands::WorkflowCommand.new(
-                  set_patch_marker: Bridge::Api::WorkflowCommands::SetPatchMarker.new(patch_id:, deprecated:)
+                  set_patch_marker: Bridge::Api::WorkflowCommands::SetPatchMarker.new(patch_id:, deprecated:),
+                  event_group_markers: Workflow::EventGroup._markers_for_command(event_groups)
                 )
               )
             end
@@ -426,6 +435,10 @@ module Temporalio
         end
 
         def apply_signal(job)
+          if job.originating_event_id.nil? || job.originating_event_id <= 0
+            raise "Signal #{job.signal_name} has invalid originating event ID #{job.originating_event_id}"
+          end
+
           # Get signal definition, falling back to dynamic if not present and not reserved
           defn = signal_handlers[job.signal_name]
           defn = signal_handlers[nil] if !defn && !Internal::ProtoUtils.reserved_name?(job.signal_name)
@@ -436,27 +449,29 @@ module Temporalio
             end
           # Process as a top level handler so that errors are treated as if in primary workflow method
           schedule(top_level: true, handler_exec:) do
-            # Send to interceptor if there is a definition, buffer otherwise
-            if defn
-              @inbound.handle_signal(
-                Temporalio::Worker::Interceptor::Workflow::HandleSignalInput.new(
-                  signal: job.signal_name,
-                  args: begin
-                    convert_handler_args(payload_array: job.input, defn:)
-                  rescue StandardError => e
-                    # Signals argument conversion failure must not fail task
-                    @logger.error("Failed converting signal input arguments for #{job.signal_name}, dropping signal")
-                    @logger.error(e)
-                    next
-                  end,
-                  definition: defn,
-                  headers: ProtoUtils.headers_from_proto_map(job.headers, @payload_converter) || {}
+            Workflow::EventGroup._with_inbound_event(job.originating_event_id) do
+              # Send to interceptor if there is a definition, buffer otherwise
+              if defn
+                @inbound.handle_signal(
+                  Temporalio::Worker::Interceptor::Workflow::HandleSignalInput.new(
+                    signal: job.signal_name,
+                    args: begin
+                      convert_handler_args(payload_array: job.input, defn:)
+                    rescue StandardError => e
+                      # Signals argument conversion failure must not fail task
+                      @logger.error("Failed converting signal input arguments for #{job.signal_name}, dropping signal")
+                      @logger.error(e)
+                      next
+                    end,
+                    definition: defn,
+                    headers: ProtoUtils.headers_from_proto_map(job.headers, @payload_converter) || {}
+                  )
                 )
-              )
-            else
-              buffered = @buffered_signals[job.signal_name]
-              buffered = @buffered_signals[job.signal_name] = [] if buffered.nil?
-              buffered << job
+              else
+                buffered = @buffered_signals[job.signal_name]
+                buffered = @buffered_signals[job.signal_name] = [] if buffered.nil?
+                buffered << job
+              end
             end
           end
         end
@@ -522,6 +537,8 @@ module Temporalio
         end
 
         def apply_update(job)
+          raise "Update #{job.name} has invalid update ID #{job.id.inspect}" if job.id.nil? || job.id.empty?
+
           # Get update definition, falling back to dynamic if not present and not reserved
           defn = update_handlers[job.name]
           defn = update_handlers[nil] if !defn && !Internal::ProtoUtils.reserved_name?(job.name)
@@ -585,9 +602,12 @@ module Temporalio
               )
             )
             accepted = true
+            @check_conditions = true
 
-            # Issue update
-            result = @inbound.handle_update(input)
+            # Issue update. Validators are intentionally not wrapped in the EG scope
+            result = Workflow::EventGroup._with_inbound_update(job.id) do
+              @inbound.handle_update(input)
+            end
 
             add_command(
               Bridge::Api::WorkflowCommands::WorkflowCommand.new(
@@ -672,7 +692,8 @@ module Temporalio
                   search_attributes: err.search_attributes&._to_proto,
                   retry_policy: err.retry_policy&._to_proto,
                   initial_versioning_behavior: err.initial_versioning_behavior || 0
-                )
+                ),
+                event_group_markers: err.send(:_event_group_markers) || []
               )
             )
           elsif @cancellation.canceled? && Error.canceled?(err)

data/lib/temporalio/internal/worker/workflow_worker.rb

@@ -148,7 +148,7 @@ module Temporalio
         end
 
         # Returns whether completion was submitted to the bridge
-        # rubocop:disable Naming/PredicateMethod
+        # rubocop:disable-next Naming/PredicateMethod
         def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:)
           if @payload_encoding_visitor && !encoded
             if Fiber.current_scheduler
@@ -166,7 +166,6 @@ module Temporalio
             true
           end
         end
-        # rubocop:enable Naming/PredicateMethod
 
         def on_shutdown_complete
           @state.evict_all

data/lib/temporalio/search_attributes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'temporalio/api'
+require 'time'
 
 module Temporalio
   # Collection of typed search attributes.
@@ -142,8 +143,9 @@ module Temporalio
 
     # @!visibility private
     def self._to_proto_pair(key, value)
-      # We use a default converter, but if type is a time, we need ISO format
-      value = value.iso8601 if key.type == IndexedValueType::TIME && value.is_a?(Time)
+      # We use a default converter, but if type is a time, we need ISO format with nanoseconds since the server keeps
+      # sub-second precision
+      value = value.iso8601(9) if key.type == IndexedValueType::TIME && value.is_a?(Time)
 
       # Convert to payload
       payload = Converters::PayloadConverter.default.to_payload(value)

data/lib/temporalio/testing/workflow_environment.rb

@@ -52,6 +52,8 @@ module Temporalio
       # @param dev_server_extra_args [Array<String>] Any extra arguments for the CLI dev server.
       # @param dev_server_download_ttl [Float, nil] How long the automatic download should be cached for. If nil, cached
       #   indefinitely.
+      # @param dev_server_startup_timeout [Float, nil] Seconds to wait for startup, excluding download time.
+      #   Defaults to 5.
       #
       # @yield [environment] If a block is given, it is called with the environment and upon complete the environment is
       #   shutdown.
@@ -79,6 +81,7 @@ module Temporalio
         dev_server_download_dest_dir: nil,
         dev_server_extra_args: [],
         dev_server_download_ttl: nil,
+        dev_server_startup_timeout: nil,
         &
       )
         # Add search attribute args
@@ -105,7 +108,8 @@ module Temporalio
           log_format: dev_server_log_format,
           log_level: dev_server_log_level,
           extra_args: dev_server_extra_args,
-          download_ttl: dev_server_download_ttl
+          download_ttl: dev_server_download_ttl,
+          startup_timeout: dev_server_startup_timeout
         )
         _with_core_server(
           core_server: Internal::Bridge::Testing::EphemeralServer.start_dev_server(
@@ -144,6 +148,8 @@ module Temporalio
       # @param test_server_extra_args [Array<String>] Any extra arguments for the test server.
       # @param test_server_download_ttl [Float, nil] How long the automatic download should be cached for. If nil,
       #   cached indefinitely.
+      # @param test_server_startup_timeout [Float, nil] Seconds to wait for startup, excluding download time.
+      #   Defaults to 5.
       #
       # @yield [environment] If a block is given, it is called with the environment and upon complete the environment is
       #   shutdown.
@@ -163,6 +169,7 @@ module Temporalio
         test_server_download_dest_dir: nil,
         test_server_extra_args: [],
         test_server_download_ttl: nil,
+        test_server_startup_timeout: nil,
         &
       )
         server_options = Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions.new(
@@ -173,7 +180,8 @@ module Temporalio
           download_dest_dir: test_server_download_dest_dir,
           port:,
           extra_args: test_server_extra_args,
-          download_ttl: test_server_download_ttl
+          download_ttl: test_server_download_ttl,
+          startup_timeout: test_server_startup_timeout
         )
         _with_core_server(
           core_server: Internal::Bridge::Testing::EphemeralServer.start_test_server(

data/lib/temporalio/version.rb

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

data/lib/temporalio/worker/interceptor.rb

@@ -200,7 +200,8 @@ module Temporalio
         # Input for {Outbound.cancel_external_workflow}.
         CancelExternalWorkflowInput = Data.define(
           :id,
-          :run_id
+          :run_id,
+          :event_groups
         )
 
         # Input for {Outbound.execute_activity}.
@@ -221,7 +222,8 @@ module Temporalio
           :priority,
           :arg_hints,
           :result_hint,
-          :headers
+          :headers,
+          :event_groups
         )
 
         # Input for {Outbound.execute_local_activity}.
@@ -239,7 +241,8 @@ module Temporalio
           :activity_id,
           :arg_hints,
           :result_hint,
-          :headers
+          :headers,
+          :event_groups
         )
 
         # Input for {Outbound.initialize_continue_as_new_error}.
@@ -254,7 +257,8 @@ module Temporalio
           :args,
           :cancellation,
           :arg_hints,
-          :headers
+          :headers,
+          :event_groups
         )
 
         # Input for {Outbound.signal_external_workflow}.
@@ -265,14 +269,16 @@ module Temporalio
           :args,
           :cancellation,
           :arg_hints,
-          :headers
+          :headers,
+          :event_groups
         )
 
         # Input for {Outbound.sleep}.
         SleepInput = Data.define(
           :duration,
           :summary,
-          :cancellation
+          :cancellation,
+          :event_groups
         )
 
         # Input for {Outbound.start_child_workflow}.
@@ -298,7 +304,8 @@ module Temporalio
           :versioning_override,
           :arg_hints,
           :result_hint,
-          :headers
+          :headers,
+          :event_groups
         )
 
         # Input for {Outbound.start_nexus_operation}.
@@ -317,7 +324,8 @@ module Temporalio
           :cancellation,
           :arg_hint,
           :result_hint,
-          :headers
+          :headers,
+          :event_groups
         )
 
         # Outbound interceptor for intercepting outbound workflow calls. This should be extended by users needing to

data/lib/temporalio/worker/workflow_replayer.rb

@@ -130,7 +130,7 @@ module Temporalio
             workflow_definitions: @workflow_definitions
           )
         # If there is a block, we'll go ahead and assume it's for with_replay_worker
-        with_replay_worker(&) if block_given? # steep:ignore
+        with_replay_worker(&) if block_given?
       end
 
       # Replay a workflow history.

data/lib/temporalio/worker.rb

@@ -395,15 +395,15 @@ module Temporalio
     # @param logger [Logger] Logger to override client logger with. Default is the client logger.
     # @param max_cached_workflows [Integer] Number of workflows held in cache for use by sticky task queue. If set to 0,
     #   workflow caching and sticky queuing are disabled.
-    # @param max_concurrent_workflow_task_polls [Integer] Maximum number of concurrent poll workflow task requests we
-    #   will perform at a time on this worker's task queue.
+    # @param max_concurrent_workflow_task_polls [Integer, nil] Maximum number of concurrent poll workflow task requests
+    #   we will perform at a time on this worker's task queue.
     # @param nonsticky_to_sticky_poll_ratio [Float] `max_concurrent_workflow_task_polls` * this number = the number of
     #   max pollers that will be allowed for the nonsticky queue when sticky tasks are enabled. If both defaults are
     #   used, the sticky queue will allow 4 max pollers while the nonsticky queue will allow one. The minimum for either
     #   poller is 1, so if `max_concurrent_workflow_task_polls` is 1 and sticky queues are enabled, there will be 2
     #   concurrent polls.
-    # @param max_concurrent_activity_task_polls [Integer] Maximum number of concurrent poll activity task requests we
-    #   will perform at a time on this worker's task queue.
+    # @param max_concurrent_activity_task_polls [Integer, nil] Maximum number of concurrent poll activity task requests
+    #   we will perform at a time on this worker's task queue.
     # @param no_remote_activities [Boolean] If true, this worker will only handle workflow tasks and local activities,
     #   it will not poll for activity tasks.
     # @param sticky_queue_schedule_to_start_timeout [Float] How long a workflow task is allowed to sit on the sticky
@@ -450,9 +450,9 @@ module Temporalio
     # @param patch_activation_callback [Proc, nil] Experimental callback to decide whether the first non-replay call to
     #   {Workflow.patched} for a patch ID should activate that patch. The callback receives a {PatchActivationInput} and
     #   must return `true` to activate the patch or `false` to leave it inactive.
-    # @param workflow_task_poller_behavior [PollerBehavior] Specify the behavior of workflow task
+    # @param workflow_task_poller_behavior [PollerBehavior, nil] Specify the behavior of workflow task
     #   polling. Defaults to a 5-poller maximum.
-    # @param activity_task_poller_behavior [PollerBehavior] Specify the behavior of activity task
+    # @param activity_task_poller_behavior [PollerBehavior, nil] Specify the behavior of activity task
     #   polling. Defaults to a 5-poller maximum.
     # @param debug_mode [Boolean] If true, deadlock detection is disabled. Deadlock detection will fail workflow tasks
     #   if they block the thread for too long. This defaults to true if the `TEMPORAL_DEBUG` environment variable is
@@ -473,9 +473,9 @@ module Temporalio
       identity: nil,
       logger: client.options.logger,
       max_cached_workflows: 1000,
-      max_concurrent_workflow_task_polls: 5,
+      max_concurrent_workflow_task_polls: nil,
       nonsticky_to_sticky_poll_ratio: 0.2,
-      max_concurrent_activity_task_polls: 5,
+      max_concurrent_activity_task_polls: nil,
       no_remote_activities: false,
       sticky_queue_schedule_to_start_timeout: 10,
       max_heartbeat_throttle_interval: 60,
@@ -491,13 +491,20 @@ module Temporalio
       unsafe_workflow_io_enabled: false,
       deployment_options: Worker.default_deployment_options,
       patch_activation_callback: nil,
-      workflow_task_poller_behavior: PollerBehavior::SimpleMaximum.new(max_concurrent_workflow_task_polls),
-      activity_task_poller_behavior: PollerBehavior::SimpleMaximum.new(max_concurrent_activity_task_polls),
+      workflow_task_poller_behavior: nil,
+      activity_task_poller_behavior: nil,
       debug_mode: %w[true 1].include?(ENV['TEMPORAL_DEBUG'].to_s.downcase),
       disable_payload_error_limit: false
     )
       Internal::ProtoUtils.assert_non_reserved_name(task_queue)
 
+      if max_concurrent_workflow_task_polls
+        workflow_task_poller_behavior ||= PollerBehavior::SimpleMaximum.new(max_concurrent_workflow_task_polls)
+      end
+      if max_concurrent_activity_task_polls
+        activity_task_poller_behavior ||= PollerBehavior::SimpleMaximum.new(max_concurrent_activity_task_polls)
+      end
+
       @options = Options.new(
         client:,
         task_queue:,
@@ -582,9 +589,9 @@ module Temporalio
           tuner: @options.tuner._to_bridge_options,
           identity_override: @options.identity,
           max_cached_workflows: @options.max_cached_workflows,
-          workflow_task_poller_behavior: @options.workflow_task_poller_behavior._to_bridge_options,
+          workflow_task_poller_behavior: @options.workflow_task_poller_behavior&._to_bridge_options,
           nonsticky_to_sticky_poll_ratio: @options.nonsticky_to_sticky_poll_ratio,
-          activity_task_poller_behavior: @options.activity_task_poller_behavior._to_bridge_options,
+          activity_task_poller_behavior: @options.activity_task_poller_behavior&._to_bridge_options,
           enable_workflows: !@options.workflows.empty?,
           enable_local_activities: !@options.workflows.empty? && !@options.activities.empty?,
           enable_remote_activities: !@options.activities.empty? && !@options.no_remote_activities,

data/lib/temporalio/workflow/child_workflow_handle.rb

@@ -43,7 +43,10 @@ module Temporalio
       # @param cancellation [Cancellation] Cancellation for canceling the signalling.
       # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
       #   signal definition has arg hints, those are used by default.
-      def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil)
+      # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the signal command, in
+      #   addition to any groups from enclosing {Workflow.with_event_groups} scopes.
+      #   WARNING: This option is experimental.
+      def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil, event_groups: nil)
         raise NotImplementedError
       end
     end

data/lib/temporalio/workflow/event_group.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'temporalio/api/sdk/v1/event_group_marker'
+require 'temporalio/converters/payload_converter'
+
+module Temporalio
+  module Workflow
+    # A discrete token associating workflow commands, and the history events they produce, with a logical group for UI
+    # and observability purposes.
+    #
+    # Multiple Event Groups may be attached to a single command, and a single Event Group may be attached to multiple
+    # commands. Instances are created with {Workflow.create_event_group}. Attach them to specific commands via the
+    # `event_groups:` option, or to every command produced within a block via {Workflow.with_event_groups}.
+    #
+    # WARNING: Event Groups support is experimental.
+    class EventGroup
+      # @!visibility private
+      Active = Struct.new(:implicit, :explicit, keyword_init: true)
+
+      # @!visibility private
+      EMPTY_ACTIVE = Active.new(implicit: nil, explicit: {}.freeze).freeze
+
+      # @!visibility private
+      STORAGE_KEY = :__temporal_event_groups
+
+      class << self
+        # @!visibility private
+        def _active
+          Fiber[STORAGE_KEY] || EMPTY_ACTIVE
+        end
+
+        # @!visibility private
+        def _with_active(active)
+          prev = Fiber[STORAGE_KEY]
+          Fiber[STORAGE_KEY] = active
+          yield
+        ensure
+          Fiber[STORAGE_KEY] = prev
+        end
+
+        # @!visibility private
+        def _with_event_groups(*groups, &)
+          active = _active
+          explicit = active.explicit.dup
+          groups.each do |group|
+            unless group.is_a?(Label)
+              raise TypeError, 'Event groups must be created with Temporalio::Workflow.create_event_group'
+            end
+
+            explicit[group.id] = group
+          end
+          _with_active(Active.new(implicit: active.implicit, explicit:), &)
+        end
+
+        # @!visibility private
+        def _with_inbound_event(event_id, &)
+          group = Implicit.new(
+            Api::Sdk::V1::EventGroupMarker.new(
+              inbound_event: Api::Sdk::V1::EventGroupMarker::InboundEvent.new(inbound_event_id: event_id)
+            )
+          )
+          _with_active(group._applied_over(_active), &)
+        end
+
+        # @!visibility private
+        def _with_inbound_update(update_id, &)
+          group = Implicit.new(
+            Api::Sdk::V1::EventGroupMarker.new(
+              inbound_update: Api::Sdk::V1::EventGroupMarker::InboundUpdate.new(inbound_update_id: update_id)
+            )
+          )
+          _with_active(group._applied_over(_active), &)
+        end
+
+        # @!visibility private
+        def _markers_for_command(directs)
+          active = _active
+          explicit = active.explicit
+          if directs
+            explicit = explicit.dup
+            directs.each do |group|
+              unless group.is_a?(Label)
+                raise TypeError, 'Event groups must be created with Temporalio::Workflow.create_event_group'
+              end
+
+              explicit[group.id] = group
+            end
+          end
+          groups = explicit.values
+          groups.unshift(active.implicit) if active.implicit
+          groups.map(&:_to_proto)
+        end
+      end
+
+      # @!visibility private
+      def initialize
+        raise NotImplementedError, 'Cannot instantiate EventGroup directly, use Temporalio::Workflow.create_event_group'
+      end
+
+      # @!visibility private
+      def _applied_over(_active)
+        raise NotImplementedError
+      end
+
+      # @!visibility private
+      def _to_proto
+        raise NotImplementedError
+      end
+
+      # An Event Group explicitly created by workflow code.
+      #
+      # @!visibility private
+      class Label < EventGroup
+        attr_reader :id, :label
+
+        def initialize(id, label) # rubocop:disable Lint/MissingSuper
+          @id = id
+          @label = label
+        end
+
+        # @!visibility private
+        def _applied_over(active)
+          Active.new(implicit: active.implicit, explicit: active.explicit.merge(id => self))
+        end
+
+        # @!visibility private
+        def _to_proto
+          marker_label = Api::Sdk::V1::EventGroupMarker::Label.new(id:)
+          # Deliberately the SDK's default converter, not the user-provided one.
+          marker_label.label = Converters::PayloadConverter.default.to_payload(label) if label
+          Api::Sdk::V1::EventGroupMarker.new(label: marker_label)
+        end
+      end
+
+      # An Event Group created by the SDK around an inbound signal or update.
+      #
+      # @!visibility private
+      class Implicit < EventGroup
+        def initialize(marker) # rubocop:disable Lint/MissingSuper
+          @marker = marker
+        end
+
+        # @!visibility private
+        def _applied_over(_active)
+          # Implicit groups do not inherit enclosing explicit scopes: a handler registered
+          # inside an explicit scope must not attribute its commands to that scope.
+          Active.new(implicit: self, explicit: {})
+        end
+
+        # @!visibility private
+        def _to_proto
+          @marker
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/workflow/external_workflow_handle.rb

@@ -30,12 +30,19 @@ module Temporalio
       # @param cancellation [Cancellation] Cancellation for canceling the signalling.
       # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
       #   signal definition has arg hints, those are used by default.
-      def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil)
+      # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the signal command, in
+      #   addition to any groups from enclosing {Workflow.with_event_groups} scopes.
+      #   WARNING: This option is experimental.
+      def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil, event_groups: nil)
         raise NotImplementedError
       end
 
       # Cancel the external workflow.
-      def cancel
+      #
+      # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the cancel command, in
+      #   addition to any groups from enclosing {Workflow.with_event_groups} scopes.
+      #   WARNING: This option is experimental.
+      def cancel(event_groups: nil)
         raise NotImplementedError
       end
     end

data/lib/temporalio/workflow/future.rb

@@ -80,7 +80,7 @@ module Temporalio
         return unless block_given?
 
         @fiber = Fiber.schedule do
-          @result = block.call # steep:ignore
+          @result = block.call
         rescue Exception => e # rubocop:disable Lint/RescueException
           # These errors invalidate the whole workflow task. If stored and only raised on wait, the activation may
           # complete successfully with commands that were emitted before the error.

data/lib/temporalio/workflow/info.rb

@@ -13,6 +13,7 @@ module Temporalio
       :last_result,
       :has_last_result?,
       :namespace,
+      :original_execution_run_id,
       :parent,
       :priority,
       :retry_policy,
@@ -49,6 +50,9 @@ module Temporalio
 
     # @!attribute namespace
     #   @return [String] Namespace for the workflow.
+    # @!attribute original_execution_run_id
+    #   @return [String] Run ID recorded on the workflow execution started event. Unlike {#run_id},
+    #     this value is preserved across workflow resets.
     # @!attribute parent
     #   @return [ParentInfo, nil] Parent information for the workflow if this is a child.
     # @!attribute priority