temporalio 1.4.1 → 1.6.0

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

@@ -4,6 +4,9 @@ require 'google/protobuf/well_known_types'
 require 'securerandom'
 require 'temporalio/activity'
 require 'temporalio/api'
+require 'temporalio/client/activity_execution'
+require 'temporalio/client/activity_execution_count'
+require 'temporalio/client/activity_handle'
 require 'temporalio/client/activity_id_reference'
 require 'temporalio/client/async_activity_handle'
 require 'temporalio/client/connection'
@@ -27,6 +30,35 @@ module Temporalio
   module Internal
     module Client
       class Implementation < Temporalio::Client::Interceptor::Outbound
+        # 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
+        # requests) in `workflowservice/v1/request_response.proto`. Workflow-scheduled activities
+        # leave resource_id empty.
+        STANDALONE_ACTIVITY_RESOURCE_ID_PREFIX = 'activity:'
+
+        # Returns the activity_id / workflow_id / run_id / resource_id fields for a `*_by_id`
+        # async-completion request, depending on whether the reference is the standalone or
+        # workflow-bound form. Splat into the request constructor's kwargs alongside the
+        # request-specific fields.
+        def self._activity_id_reference_request_fields(ref)
+          if ref.standalone?
+            {
+              workflow_id: nil,
+              run_id: ref.activity_run_id,
+              activity_id: ref.activity_id,
+              resource_id: "#{STANDALONE_ACTIVITY_RESOURCE_ID_PREFIX}#{ref.activity_id}"
+            }
+          else
+            {
+              workflow_id: ref.workflow_id,
+              run_id: ref.run_id,
+              activity_id: ref.activity_id,
+              resource_id: nil
+            }
+          end
+        end
+
         def self.with_default_rpc_options(user_rpc_options)
           # If the user did not provide an override_retry, we need to make sure
           # we use an option set that has it as "true"
@@ -185,7 +217,7 @@ module Temporalio
             end
 
             # If the user wants to wait until completed, we must poll until outcome if not already there
-            if input.wait_for_stage == Temporalio::Client::WorkflowUpdateWaitStage::COMPLETED && update_resp.outcome
+            if input.wait_for_stage == Temporalio::Client::WorkflowUpdateWaitStage::COMPLETED && !update_resp.outcome
               update_resp.outcome = @client._impl.poll_workflow_update(
                 Temporalio::Client::Interceptor::PollWorkflowUpdateInput.new(
                   workflow_id: start_options.id,
@@ -327,7 +359,8 @@ module Temporalio
             user_metadata: ProtoUtils.to_user_metadata(
               start_options.static_summary, start_options.static_details, @client.data_converter
             ),
-            header: ProtoUtils.headers_to_proto(start_options.headers, @client.data_converter)
+            header: ProtoUtils.headers_to_proto(start_options.headers, @client.data_converter),
+            priority: start_options.priority._to_proto
           )
         end
 
@@ -807,12 +840,11 @@ module Temporalio
         end
 
         def heartbeat_async_activity(input)
-          resp = if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          resp = if ref.is_a?(Temporalio::Client::ActivityIDReference)
                    @client.workflow_service.record_activity_task_heartbeat_by_id(
                      Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest.new(
-                       workflow_id: input.task_token_or_id_reference.workflow_id,
-                       run_id: input.task_token_or_id_reference.run_id,
-                       activity_id: input.task_token_or_id_reference.activity_id,
+                       **Implementation._activity_id_reference_request_fields(ref),
                        namespace: @client.namespace,
                        identity: @client.connection.identity,
                        details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -822,7 +854,7 @@ module Temporalio
                  else
                    @client.workflow_service.record_activity_task_heartbeat(
                      Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest.new(
-                       task_token: input.task_token_or_id_reference,
+                       task_token: ref,
                        namespace: @client.namespace,
                        identity: @client.connection.identity,
                        details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -840,12 +872,11 @@ module Temporalio
         end
 
         def complete_async_activity(input)
-          if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          if ref.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_completed_by_id(
               Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest.new(
-                workflow_id: input.task_token_or_id_reference.workflow_id,
-                run_id: input.task_token_or_id_reference.run_id,
-                activity_id: input.task_token_or_id_reference.activity_id,
+                **Implementation._activity_id_reference_request_fields(ref),
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 result: @client.data_converter.to_payloads([input.result], hints: Array(input.result_hint))
@@ -855,7 +886,7 @@ module Temporalio
           else
             @client.workflow_service.respond_activity_task_completed(
               Api::WorkflowService::V1::RespondActivityTaskCompletedRequest.new(
-                task_token: input.task_token_or_id_reference,
+                task_token: ref,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 result: @client.data_converter.to_payloads([input.result], hints: Array(input.result_hint))
@@ -875,12 +906,11 @@ module Temporalio
                                        hints: input.last_heartbeat_detail_hints
                                      )
                                    end
-          if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          if ref.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_failed_by_id(
               Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest.new(
-                workflow_id: input.task_token_or_id_reference.workflow_id,
-                run_id: input.task_token_or_id_reference.run_id,
-                activity_id: input.task_token_or_id_reference.activity_id,
+                **Implementation._activity_id_reference_request_fields(ref),
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 failure: @client.data_converter.to_failure(input.error),
@@ -891,7 +921,7 @@ module Temporalio
           else
             @client.workflow_service.respond_activity_task_failed(
               Api::WorkflowService::V1::RespondActivityTaskFailedRequest.new(
-                task_token: input.task_token_or_id_reference,
+                task_token: ref,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 failure: @client.data_converter.to_failure(input.error),
@@ -904,12 +934,11 @@ module Temporalio
         end
 
         def report_cancellation_async_activity(input)
-          if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
+          ref = input.task_token_or_id_reference
+          if ref.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_canceled_by_id(
               Api::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest.new(
-                workflow_id: input.task_token_or_id_reference.workflow_id,
-                run_id: input.task_token_or_id_reference.run_id,
-                activity_id: input.task_token_or_id_reference.activity_id,
+                **Implementation._activity_id_reference_request_fields(ref),
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -919,7 +948,7 @@ module Temporalio
           else
             @client.workflow_service.respond_activity_task_canceled(
               Api::WorkflowService::V1::RespondActivityTaskCanceledRequest.new(
-                task_token: input.task_token_or_id_reference,
+                task_token: ref,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
@@ -929,6 +958,168 @@ module Temporalio
           end
           nil
         end
+
+        def start_activity(input)
+          raise ArgumentError, 'activity_id is required' if input.activity_id.nil? || input.activity_id.empty?
+          raise ArgumentError, 'task_queue is required' if input.task_queue.nil? || input.task_queue.to_s.empty?
+          if input.schedule_to_close_timeout.nil? && input.start_to_close_timeout.nil?
+            raise ArgumentError, 'either schedule_to_close_timeout or start_to_close_timeout is required'
+          end
+          raise ArgumentError, 'start_delay must be non-negative' if input.start_delay&.negative?
+
+          req = Api::WorkflowService::V1::StartActivityExecutionRequest.new(
+            namespace: @client.namespace,
+            identity: @client.connection.identity,
+            request_id: SecureRandom.uuid,
+            activity_id: input.activity_id,
+            activity_type: Api::Common::V1::ActivityType.new(name: input.activity),
+            task_queue: Api::TaskQueue::V1::TaskQueue.new(name: input.task_queue.to_s),
+            input: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
+            schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
+            schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
+            start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
+            heartbeat_timeout: ProtoUtils.seconds_to_duration(input.heartbeat_timeout),
+            id_reuse_policy: input.id_reuse_policy,
+            id_conflict_policy: input.id_conflict_policy,
+            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
+            ),
+            header: ProtoUtils.headers_to_proto(input.headers, @client.data_converter),
+            priority: input.priority._to_proto,
+            start_delay: ProtoUtils.seconds_to_duration(input.start_delay)
+          )
+
+          begin
+            resp = @client.workflow_service.start_activity_execution(
+              req,
+              rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+            )
+          rescue Error::RPCError => e
+            if e.code == Error::RPCError::Code::ALREADY_EXISTS && e.grpc_status.details.first
+              details = e.grpc_status.details.first.unpack(
+                Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure
+              )
+              if details
+                raise Error::ActivityAlreadyStartedError.new(
+                  activity_id: input.activity_id,
+                  activity_type: input.activity,
+                  activity_run_id: details.run_id
+                )
+              end
+            end
+            raise
+          end
+
+          Temporalio::Client::ActivityHandle.new(
+            client: @client,
+            id: input.activity_id,
+            run_id: resp.run_id,
+            result_hint: input.result_hint
+          )
+        end
+
+        def describe_activity(input)
+          resp = @client.workflow_service.describe_activity_execution(
+            Api::WorkflowService::V1::DescribeActivityExecutionRequest.new(
+              namespace: @client.namespace,
+              activity_id: input.activity_id,
+              run_id: input.activity_run_id || ''
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          Temporalio::Client::ActivityExecution::Description.new(resp, @client.data_converter)
+        end
+
+        def cancel_activity(input)
+          @client.workflow_service.request_cancel_activity_execution(
+            Api::WorkflowService::V1::RequestCancelActivityExecutionRequest.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 terminate_activity(input)
+          @client.workflow_service.terminate_activity_execution(
+            Api::WorkflowService::V1::TerminateActivityExecutionRequest.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 list_activities(input)
+          Enumerator.new do |yielder|
+            req = Api::WorkflowService::V1::ListActivityExecutionsRequest.new(
+              namespace: @client.namespace,
+              query: input.query || ''
+            )
+            loop do
+              resp = @client.workflow_service.list_activity_executions(
+                req,
+                rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+              )
+              resp.executions.each do |raw_info|
+                yielder << Temporalio::Client::ActivityExecution.new(raw_info)
+              end
+              break if resp.next_page_token.empty?
+
+              req.next_page_token = resp.next_page_token
+            end
+          end
+        end
+
+        def count_activities(input)
+          resp = @client.workflow_service.count_activity_executions(
+            Api::WorkflowService::V1::CountActivityExecutionsRequest.new(
+              namespace: @client.namespace,
+              query: input.query || ''
+            ),
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          Temporalio::Client::ActivityExecutionCount.new(
+            resp.count,
+            resp.groups.map do |group|
+              Temporalio::Client::ActivityExecutionCount::AggregationGroup.new(
+                group.count,
+                group.group_values.map { |payload| SearchAttributes._value_from_payload(payload) }
+              )
+            end
+          )
+        end
+
+        # Long-polls PollActivityExecution until the activity reaches a terminal state. Returns the
+        # ActivityExecutionOutcome. The server's long-poll deadline may expire before the activity
+        # completes; in that case PollActivityExecutionResponse comes back with an unpopulated
+        # `outcome` field and the call must be reissued.
+        def fetch_activity_outcome(input)
+          req = Api::WorkflowService::V1::PollActivityExecutionRequest.new(
+            namespace: @client.namespace,
+            activity_id: input.activity_id,
+            run_id: input.activity_run_id || ''
+          )
+          loop do
+            resp = @client.workflow_service.poll_activity_execution(
+              req,
+              rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+            )
+            return resp.outcome if resp.outcome
+          end
+        end
       end
     end
   end

data/lib/temporalio/internal/google_protobuf.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    module GoogleProtobuf
+      def self.in_call_stack?(locations)
+        locations&.any? { |loc| loc.path&.include?('google/protobuf/') } || false
+      end
+    end
+  end
+end

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

@@ -168,9 +168,18 @@ module Temporalio
         end
 
         def execute_activity(task_token, defn, start)
-          # Build info
+          # Build info. Standalone activities have some empty fields on the wire; translate
+          # empty strings to nil for the user-facing Info fields.
+          workflow_id = Internal::ProtoUtils.string_or(start.workflow_execution&.workflow_id, nil)
+          workflow_run_id = Internal::ProtoUtils.string_or(start.workflow_execution&.run_id, nil)
+          workflow_type = Internal::ProtoUtils.string_or(start.workflow_type, nil)
+          activity_run_id = Internal::ProtoUtils.string_or(start.run_id, nil)
+          # `namespace` is always set. `workflow_namespace` is the deprecated accessor, nil for standalone activities.
+          namespace = Internal::ProtoUtils.string_or(start.workflow_namespace, @worker.options.client.namespace)
+          workflow_namespace = workflow_id.nil? ? nil : namespace
           info = Activity::Info.new(
             activity_id: start.activity_id,
+            activity_run_id: activity_run_id,
             activity_type: start.activity_type,
             attempt: start.attempt,
             current_attempt_scheduled_time: Internal::ProtoUtils.timestamp_to_time(
@@ -178,6 +187,7 @@ module Temporalio
             ) || raise, # Never nil
             heartbeat_timeout: Internal::ProtoUtils.duration_to_seconds(start.heartbeat_timeout),
             local?: start.is_local,
+            namespace: namespace,
             priority: Priority._from_proto(start.priority),
             raw_heartbeat_details: begin
               payloads = start.heartbeat_details.to_ary
@@ -192,10 +202,10 @@ module Temporalio
             started_time: Internal::ProtoUtils.timestamp_to_time(start.started_time) || raise, # Never nil
             task_queue: @worker.options.task_queue,
             task_token:,
-            workflow_id: start.workflow_execution.workflow_id,
-            workflow_namespace: start.workflow_namespace,
-            workflow_run_id: start.workflow_execution.run_id,
-            workflow_type: start.workflow_type
+            workflow_id: workflow_id,
+            workflow_namespace: workflow_namespace,
+            workflow_run_id: workflow_run_id,
+            workflow_type: workflow_type
           )
 
           # Build input

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

@@ -248,6 +248,8 @@ module Temporalio
           end
 
           def random
+            raise Workflow::InvalidWorkflowStateError, 'Cannot use random in this context' if @instance.random_disabled
+
             @instance.random
           end
 

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

@@ -9,7 +9,7 @@ module Temporalio
           attr_reader :namespace, :task_queue, :definition, :initial_activation, :logger, :metric_meter,
                       :payload_converter, :failure_converter, :interceptors, :disable_eager_activity_execution,
                       :illegal_calls, :workflow_failure_exception_types, :unsafe_workflow_io_enabled,
-                      :assert_valid_local_activity
+                      :patch_activation_callback, :assert_valid_local_activity
 
           def initialize(
             namespace:,
@@ -25,6 +25,7 @@ module Temporalio
             illegal_calls:,
             workflow_failure_exception_types:,
             unsafe_workflow_io_enabled:,
+            patch_activation_callback:,
             assert_valid_local_activity:
           )
             @namespace = namespace
@@ -40,6 +41,7 @@ module Temporalio
             @illegal_calls = illegal_calls
             @workflow_failure_exception_types = workflow_failure_exception_types
             @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
+            @patch_activation_callback = patch_activation_callback
             @assert_valid_local_activity = assert_valid_local_activity
           end
         end

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

@@ -481,15 +481,25 @@ module Temporalio
               @instance.pending_nexus_operation_starts.delete(seq)
             end
 
-            # Handle start failure
-            if resolution.failed
+            # Handle start resolution
+            case resolution.status
+            when :operation_token
+              operation_token = resolution.operation_token
+            when :started_sync
+              operation_token = nil
+            when :failed
+              input.cancellation.remove_cancel_callback(cancel_callback_key)
+              raise @instance.failure_converter.from_failure(
+                resolution.failed, @instance.payload_converter
+              )
+            else
               input.cancellation.remove_cancel_callback(cancel_callback_key)
-              raise @instance.failure_converter.from_failure(resolution.failed, @instance.payload_converter)
+              raise "Unknown Nexus operation start status: #{resolution.status.inspect}"
             end
 
             # Create handle and add to pending operations (result will come via resolve_nexus_operation)
             handle = NexusOperationHandle.new(
-              operation_token: resolution.operation_token,
+              operation_token:,
               instance: @instance,
               cancellation: input.cancellation,
               cancel_callback_key:,

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

@@ -3,6 +3,7 @@
 require 'temporalio'
 require 'temporalio/cancellation'
 require 'temporalio/error'
+require 'temporalio/internal/google_protobuf'
 require 'temporalio/internal/worker/workflow_instance'
 require 'temporalio/workflow'
 require 'timeout'
@@ -19,6 +20,10 @@ module Temporalio
             @ready = []
             @wait_conditions = {}
             @wait_condition_counter = 0
+            @thread_blocking_fibers = {}
+            @thread_blocking_mutex = Mutex.new
+            @thread_blocking_condition = ConditionVariable.new
+            @workflow_thread = nil
           end
 
           def context
@@ -26,12 +31,17 @@ module Temporalio
           end
 
           def run_until_all_yielded
+            @workflow_thread = Thread.current
             loop do
               # Run all fibers until all yielded
               while (fiber = @ready.shift)
                 fiber.resume
               end
 
+              # Thread-blocking fibers are not durable workflow yields. Wait for them to unblock before satisfying any
+              # wait condition so the condition sees the workflow after all runnable work has settled.
+              next if wait_for_thread_blocking_fiber
+
               # Find the _first_ resolvable wait condition and if there, resolve it, and loop again, otherwise return.
               # It is important that we both let fibers get all settled _before_ this and only allow a _single_ wait
               # condition to be satisfied before looping. This allows wait condition users to trust that the line of
@@ -55,6 +65,8 @@ module Temporalio
 
               cond_fiber.resume(cond_result)
             end
+          ensure
+            @workflow_thread = nil
           end
 
           def wait_condition(cancellation:, &block)
@@ -110,9 +122,26 @@ module Temporalio
           # work inside of workflows. So we only implement the bare minimum.
           ###
 
-          def block(_blocker, timeout = nil)
+          def block(blocker, timeout = nil)
             # TODO(cretz): Make the blocker visible in the stack trace?
 
+            # Protobuf's object cache uses a process-local Mutex. We allowlist that Mutex use, but it is not a durable
+            # workflow yield: if it blocks the only runnable workflow fiber, the workflow task must remain blocked so
+            # deadlock detection can fail it instead of completing a partial command set.
+            if timeout.nil? && thread_blocking_protobuf_mutex_wait?(blocker)
+              fiber = Fiber.current
+              synchronize_thread_blocking_fibers { @thread_blocking_fibers[fiber] = true }
+              begin
+                Fiber.yield
+                return true
+              ensure
+                synchronize_thread_blocking_fibers do
+                  @thread_blocking_fibers.delete(fiber)
+                  @thread_blocking_condition.broadcast
+                end
+              end
+            end
+
             # We just yield because unblock will resume this. We will just wrap in timeout if needed.
             if timeout
               begin
@@ -189,7 +218,49 @@ module Temporalio
           end
 
           def unblock(_blocker, fiber)
-            @ready << fiber
+            synchronize_thread_blocking_fibers do
+              @thread_blocking_fibers.delete(fiber)
+              @ready << fiber
+              @thread_blocking_condition.broadcast
+            end
+          end
+
+          private
+
+          def thread_blocking_protobuf_mutex_wait?(blocker)
+            blocker.is_a?(::Mutex) &&
+              ::Temporalio::Internal::GoogleProtobuf.in_call_stack?(caller_locations)
+          end
+
+          def wait_for_thread_blocking_fiber
+            synchronize_thread_blocking_fibers do
+              return true unless @ready.empty?
+              return false if @thread_blocking_fibers.empty?
+
+              @thread_blocking_condition.wait(@thread_blocking_mutex) while @ready.empty? &&
+                                                                            !@thread_blocking_fibers.empty?
+              true
+            end
+          end
+
+          def synchronize_thread_blocking_fibers(&)
+            if Thread.current == @workflow_thread
+              with_workflow_scheduler_disabled do
+                @thread_blocking_mutex.synchronize(&)
+              end
+            else
+              @thread_blocking_mutex.synchronize(&)
+            end
+          end
+
+          def with_workflow_scheduler_disabled
+            previous_scheduler = Fiber.scheduler
+            @instance.illegal_call_tracing_disabled do
+              Fiber.set_scheduler(nil)
+              yield
+            ensure
+              Fiber.set_scheduler(previous_scheduler)
+            end
           end
         end
       end

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

@@ -61,7 +61,7 @@ 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
+                    :in_query_or_validator, :random_disabled, :patch_activation_callback
         attr_accessor :io_enabled, :current_details
 
         def initialize(details)
@@ -77,6 +77,7 @@ module Temporalio
           @scheduler = Scheduler.new(self)
           @payload_converter = details.payload_converter
           @failure_converter = details.failure_converter
+          @patch_activation_callback = details.patch_activation_callback
           @disable_eager_activity_execution = details.disable_eager_activity_execution
           @pending_activities = {} # Keyed by sequence, value is fiber to resume with proto result
           @pending_timers = {} # Keyed by sequence, value is fiber to resume with proto result
@@ -99,7 +100,9 @@ module Temporalio
           @current_history_length = 0
           @current_history_size = 0
           @replaying = false
+          @context_frozen = false
           @in_query_or_validator = false
+          @random_disabled = false
           @workflow_failure_exception_types = details.workflow_failure_exception_types
           @signal_handlers = HandlerHash.new(
             details.definition.signals,
@@ -180,7 +183,9 @@ module Temporalio
           @commands = []
           @current_activation_error = nil
           @continue_as_new_suggested = activation.continue_as_new_suggested
-          @suggest_continue_as_new_reasons = activation.suggest_continue_as_new_reasons.map(&:to_i)
+          @suggest_continue_as_new_reasons = activation.suggest_continue_as_new_reasons.map do |reason|
+            ProtoUtils.enum_to_int(Api::Enums::V1::SuggestContinueAsNewReason, reason)
+          end
           @target_worker_deployment_version_changed = activation.target_worker_deployment_version_changed
           @current_deployment_version = WorkerDeploymentVersion._from_bridge(
             activation.deployment_version_for_current_task
@@ -290,7 +295,12 @@ module Temporalio
           patch_id = patch_id.to_s
           @patches_memoized ||= {}
           @patches_memoized.fetch(patch_id) do
-            patched = !replaying || @patches_notified.include?(patch_id)
+            # Only fresh, non-replay patches can consult rollout policy; replay and deprecation must follow history.
+            patched = if deprecated || replaying || @patches_notified.include?(patch_id)
+                        !replaying || @patches_notified.include?(patch_id)
+                      else
+                        patch_activated?(patch_id)
+                      end
             @patches_memoized[patch_id] = patched
             if patched
               add_command(
@@ -303,6 +313,20 @@ module Temporalio
           end
         end
 
+        def patch_activated?(patch_id)
+          return true unless patch_activation_callback
+
+          patched = with_context_frozen(in_query_or_validator: false, random_disabled: true) do
+            patch_activation_callback.call(Temporalio::Worker::PatchActivationInput.new(
+                                             workflow_info: info,
+                                             patch_id:
+                                           ))
+          end
+          return patched if patched == true || patched == false
+
+          raise TypeError, 'Patch activation callback must return true or false'
+        end
+
         def metric_meter
           @metric_meter ||= ReplaySafeMetric::Meter.new(
             @runtime_metric_meter.with_additional_attributes(
@@ -642,6 +666,7 @@ module Temporalio
                                                                  hints: err.arg_hints || defn_arg_hints),
                   workflow_run_timeout: ProtoUtils.seconds_to_duration(err.run_timeout),
                   workflow_task_timeout: ProtoUtils.seconds_to_duration(err.task_timeout),
+                  backoff_start_interval: ProtoUtils.seconds_to_duration(err.backoff_start_interval),
                   memo: ProtoUtils.memo_to_proto_hash(err.memo, payload_converter),
                   headers: ProtoUtils.headers_to_proto_hash(err.headers, payload_converter),
                   search_attributes: err.search_attributes&._to_proto,
@@ -683,13 +708,18 @@ module Temporalio
             @definition_options.failure_exception_types&.any? { |cls| err.is_a?(cls) }
         end
 
-        def with_context_frozen(in_query_or_validator:, &)
+        def with_context_frozen(in_query_or_validator:, random_disabled: false, &)
+          previous_context_frozen = @context_frozen
+          previous_in_query_or_validator = @in_query_or_validator
+          previous_random_disabled = @random_disabled
           @context_frozen = true
           @in_query_or_validator = in_query_or_validator
+          @random_disabled = random_disabled
           yield
         ensure
-          @context_frozen = false
-          @in_query_or_validator = false
+          @context_frozen = previous_context_frozen
+          @in_query_or_validator = previous_in_query_or_validator
+          @random_disabled = previous_random_disabled
         end
 
         def convert_handler_args(payload_array:, defn:)