temporalio 0.2.0 → 0.4.0

data/lib/temporalio/internal/metric.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'temporalio/internal/bridge'
+require 'temporalio/metric'
+
+module Temporalio
+  module Internal
+    class Metric < Temporalio::Metric
+      attr_reader :metric_type, :name, :description, :unit, :value_type
+
+      def initialize(metric_type:, name:, description:, unit:, value_type:, bridge:, bridge_attrs:) # rubocop:disable Lint/MissingSuper
+        @metric_type = metric_type
+        @name = name
+        @description = description
+        @unit = unit
+        @value_type = value_type
+        @bridge = bridge
+        @bridge_attrs = bridge_attrs
+      end
+
+      def record(value, additional_attributes: nil)
+        bridge_attrs = @bridge_attrs
+        bridge_attrs = @bridge_attrs.with_additional(additional_attributes) if additional_attributes
+        @bridge.record_value(value, bridge_attrs)
+      end
+
+      def with_additional_attributes(additional_attributes)
+        Metric.new(
+          metric_type:,
+          name:,
+          description:,
+          unit:,
+          value_type:,
+          bridge: @bridge,
+          bridge_attrs: @bridge_attrs.with_additional(additional_attributes)
+        )
+      end
+
+      class Meter < Temporalio::Metric::Meter
+        def self.create_from_runtime(runtime)
+          bridge = Bridge::Metric::Meter.new(runtime._core_runtime)
+          return nil unless bridge
+
+          Meter.new(bridge, bridge.default_attributes)
+        end
+
+        def initialize(bridge, bridge_attrs) # rubocop:disable Lint/MissingSuper
+          @bridge = bridge
+          @bridge_attrs = bridge_attrs
+        end
+
+        def create_metric(
+          metric_type,
+          name,
+          description: nil,
+          unit: nil,
+          value_type: :integer
+        )
+          Metric.new(
+            metric_type:,
+            name:,
+            description:,
+            unit:,
+            value_type:,
+            bridge: Bridge::Metric.new(@bridge, metric_type, name, description, unit, value_type),
+            bridge_attrs: @bridge_attrs
+          )
+        end
+
+        def with_additional_attributes(additional_attributes)
+          Meter.new(@bridge, @bridge_attrs.with_additional(additional_attributes))
+        end
+      end
+
+      class NullMeter < Temporalio::Metric::Meter
+        include Singleton
+
+        def initialize # rubocop:disable Style/RedundantInitialize,Lint/MissingSuper
+        end
+
+        def create_metric(
+          metric_type,
+          name,
+          description: nil,
+          unit: nil,
+          value_type: :integer
+        )
+          NullMetric.new(
+            metric_type:,
+            name:,
+            description:,
+            unit:,
+            value_type:
+          )
+        end
+
+        def with_additional_attributes(_additional_attributes)
+          self
+        end
+      end
+
+      class NullMetric < Temporalio::Metric
+        attr_reader :metric_type, :name, :description, :unit, :value_type
+
+        def initialize(metric_type:, name:, description:, unit:, value_type:) # rubocop:disable Lint/MissingSuper
+          @metric_type = metric_type
+          @name = name
+          @description = description
+          @unit = unit
+          @value_type = value_type
+        end
+
+        def record(value, additional_attributes: nil); end
+
+        def with_additional_attributes(_additional_attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/proto_utils.rb

@@ -5,26 +5,82 @@ require 'temporalio/api'
 module Temporalio
   module Internal
     module ProtoUtils
-      def self.seconds_to_duration(seconds_float)
-        return nil if seconds_float.nil?
+      def self.seconds_to_duration(seconds_numeric)
+        return nil if seconds_numeric.nil?
 
-        seconds = seconds_float.to_i
-        nanos = ((seconds_float - seconds) * 1_000_000_000).round
+        seconds = seconds_numeric.to_i
+        nanos = ((seconds_numeric - seconds) * 1_000_000_000).round
         Google::Protobuf::Duration.new(seconds:, nanos:)
       end
 
+      def self.duration_to_seconds(duration)
+        return nil if duration.nil?
+
+        # This logic was corrected for timestamp at
+        # https://github.com/protocolbuffers/protobuf/pull/2482 but not for
+        # duration, so 4.56 is not properly represented in to_f, it becomes
+        # 4.5600000000000005.
+        (duration.seconds + duration.nanos.quo(1_000_000_000)).to_f
+      end
+
+      def self.time_to_timestamp(time)
+        return nil if time.nil?
+
+        Google::Protobuf::Timestamp.from_time(time)
+      end
+
+      def self.timestamp_to_time(timestamp)
+        return nil if timestamp.nil?
+
+        # The regular to_time on the timestamp converts to local timezone,
+        # and we prefer not to make a separate .utc call (converts to local
+        # then back to UTC unnecessarily)
+        Time.at(timestamp.seconds, timestamp.nanos, :nanosecond, in: 'UTC')
+      end
+
       def self.memo_to_proto(hash, converter)
-        return nil if hash.nil?
+        return nil if hash.nil? || hash.empty?
+
+        Api::Common::V1::Memo.new(fields: memo_to_proto_hash(hash, converter))
+      end
+
+      def self.memo_to_proto_hash(hash, converter)
+        return nil if hash.nil? || hash.empty?
 
-        Api::Common::V1::Memo.new(fields: hash.transform_values { |val| converter.to_payload(val) })
+        hash.transform_keys(&:to_s).transform_values { |val| converter.to_payload(val) }
       end
 
       def self.memo_from_proto(memo, converter)
-        return nil if memo.nil?
+        return nil if memo.nil? || memo.fields.size.zero? # rubocop:disable Style/ZeroLengthPredicate -- Google Maps don't have empty
 
         memo.fields.each_with_object({}) { |(key, val), h| h[key] = converter.from_payload(val) } # rubocop:disable Style/HashTransformValues
       end
 
+      def self.headers_to_proto(headers, converter)
+        return nil if headers.nil? || headers.empty?
+
+        Api::Common::V1::Header.new(fields: headers_to_proto_hash(headers, converter))
+      end
+
+      def self.headers_to_proto_hash(headers, converter)
+        return nil if headers.nil? || headers.empty?
+
+        headers.transform_values { |val| converter.to_payload(val) }
+      end
+
+      def self.headers_from_proto(headers, converter)
+        headers_from_proto_map(headers&.fields, converter)
+      end
+
+      def self.headers_from_proto_map(headers, converter)
+        return nil if headers.nil? || headers.size.zero? # rubocop:disable Style/ZeroLengthPredicate -- Google Maps don't have empty
+
+        headers.each_with_object({}) do |(key, val), h| # rubocop:disable Style/HashTransformValues
+          # @type var h: Hash[String, Object?]
+          h[key] = converter.from_payload(val)
+        end
+      end
+
       def self.string_or(str, default = nil)
         str && !str.empty? ? str : default
       end
@@ -49,6 +105,61 @@ module Temporalio
 
         converter.to_payloads(values).payloads.to_ary
       end
+
+      def self.assert_non_reserved_name(name)
+        name = name&.to_s # In case it's a symbol or not present
+        return unless name
+        raise "'#{name}' cannot start with '__temporal_'" if name.start_with?('__temporal_')
+        # Might as well disable __stack_trace and __enhanced_stack_trace everywhere even though technically it's only
+        # reserved for queries
+        raise "'#{name}' name invalid" if name == '__stack_trace' || name == '__enhanced_stack_trace'
+      end
+
+      def self.reserved_name?(name)
+        name = name&.to_s # In case it's a symbol or not present
+        return false unless name
+
+        name.start_with?('__temporal_') || name == '__stack_trace' || name == '__enhanced_stack_trace'
+      end
+
+      def self.to_user_metadata(summary, details, converter)
+        return nil if (!summary || summary.empty?) && (!details || details.empty?)
+
+        metadata = Temporalio::Api::Sdk::V1::UserMetadata.new
+        metadata.summary = converter.to_payload(summary) if summary && !summary.empty?
+        metadata.details = converter.to_payload(details) if details && !details.empty?
+        metadata
+      end
+
+      def self.from_user_metadata(metadata, converter)
+        [
+          (converter.from_payload(metadata.summary) if metadata&.summary), #: String?
+          (converter.from_payload(metadata.details) if metadata&.details) #: String?
+        ]
+      end
+
+      class LazyMemo
+        def initialize(raw_memo, converter)
+          @raw_memo = raw_memo
+          @converter = converter
+        end
+
+        def get
+          @memo = ProtoUtils.memo_from_proto(@raw_memo, @converter) unless defined?(@memo)
+          @memo
+        end
+      end
+
+      class LazySearchAttributes
+        def initialize(raw_search_attributes)
+          @raw_search_attributes = raw_search_attributes
+        end
+
+        def get
+          @search_attributes = SearchAttributes._from_proto(@raw_search_attributes) unless defined?(@search_attributes)
+          @search_attributes
+        end
+      end
     end
   end
 end

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

@@ -3,6 +3,7 @@
 require 'temporalio/activity'
 require 'temporalio/activity/definition'
 require 'temporalio/cancellation'
+require 'temporalio/converters/raw_value'
 require 'temporalio/internal/bridge/api'
 require 'temporalio/internal/proto_utils'
 require 'temporalio/scoped_logger'
@@ -11,14 +12,17 @@ require 'temporalio/worker/interceptor'
 module Temporalio
   module Internal
     module Worker
+      # Worker for handling activity tasks. Upon overarching worker shutdown, {wait_all_complete} should be used to wait
+      # for the activities to complete.
       class ActivityWorker
         LOG_TASKS = false
 
         attr_reader :worker, :bridge_worker
 
-        def initialize(worker, bridge_worker)
+        def initialize(worker:, bridge_worker:)
           @worker = worker
           @bridge_worker = bridge_worker
+          @runtime_metric_meter = worker.options.client.connection.options.runtime.metric_meter
 
           # Create shared logger that gives scoped activity details
           @scoped_logger = ScopedLogger.new(@worker.options.logger)
@@ -26,12 +30,13 @@ module Temporalio
             Activity::Context.current_or_nil&._scoped_logger_info
           }
 
-          # Build up activity hash by name, failing if any fail validation
+          # Build up activity hash by name (can be nil for dynamic), failing if any fail validation
           @activities = worker.options.activities.each_with_object({}) do |act, hash|
             # Class means create each time, instance means just call, definition
             # does nothing special
-            defn = Activity::Definition.from_activity(act)
+            defn = Activity::Definition::Info.from_activity(act)
             # Confirm name not in use
+            raise ArgumentError, 'Only one dynamic activity allowed' if !defn.name && hash.key?(defn.name)
             raise ArgumentError, "Multiple activities named #{defn.name}" if hash.key?(defn.name)
 
             # Confirm executor is a known executor and let it initialize
@@ -88,8 +93,10 @@ module Temporalio
         def handle_start_task(task_token, start)
           set_running_activity(task_token, nil)
 
-          # Find activity definition
+          # Find activity definition, falling back to dynamic if not found and not reserved name
           defn = @activities[start.activity_type]
+          defn = @activities[nil] if !defn && !Internal::ProtoUtils.reserved_name?(start.activity_type)
+
           if defn.nil?
             raise Error::ApplicationError.new(
               "Activity #{start.activity_type} for workflow #{start.workflow_execution.workflow_id} " \
@@ -109,7 +116,7 @@ module Temporalio
             # Unset at the end
             Activity::Context._current_executor = nil
           end
-        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+        rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
           remove_running_activity(task_token)
           @scoped_logger.warn("Failed starting activity #{start.activity_type}")
           @scoped_logger.warn(e)
@@ -158,17 +165,19 @@ module Temporalio
             activity_id: start.activity_id,
             activity_type: start.activity_type,
             attempt: start.attempt,
-            current_attempt_scheduled_time: start.current_attempt_scheduled_time.to_time,
+            current_attempt_scheduled_time: Internal::ProtoUtils.timestamp_to_time(
+              start.current_attempt_scheduled_time
+            ) || raise, # Never nil
             heartbeat_details: ProtoUtils.convert_from_payload_array(
               @worker.options.client.data_converter,
               start.heartbeat_details.to_ary
             ),
-            heartbeat_timeout: start.heartbeat_timeout&.to_f,
+            heartbeat_timeout: Internal::ProtoUtils.duration_to_seconds(start.heartbeat_timeout),
             local?: start.is_local,
-            schedule_to_close_timeout: start.schedule_to_close_timeout&.to_f,
-            scheduled_time: start.scheduled_time.to_time,
-            start_to_close_timeout: start.start_to_close_timeout&.to_f,
-            started_time: start.started_time.to_time,
+            schedule_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(start.schedule_to_close_timeout),
+            scheduled_time: Internal::ProtoUtils.timestamp_to_time(start.scheduled_time) || raise, # Never nil
+            start_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(start.start_to_close_timeout),
+            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,
@@ -178,27 +187,34 @@ module Temporalio
           ).freeze
 
           # Build input
-          input = Temporalio::Worker::Interceptor::ExecuteActivityInput.new(
+          input = Temporalio::Worker::Interceptor::Activity::ExecuteInput.new(
             proc: defn.proc,
-            args: ProtoUtils.convert_from_payload_array(
-              @worker.options.client.data_converter,
-              start.input.to_ary
-            ),
-            headers: start.header_fields
+            # If the activity wants raw_args, we only decode we don't convert
+            args: if defn.raw_args
+                    payloads = start.input.to_ary
+                    codec = @worker.options.client.data_converter.payload_codec
+                    payloads = codec.decode(payloads) if codec
+                    payloads.map { |p| Temporalio::Converters::RawValue.new(p) }
+                  else
+                    ProtoUtils.convert_from_payload_array(@worker.options.client.data_converter, start.input.to_ary)
+                  end,
+            headers: ProtoUtils.headers_from_proto_map(start.header_fields, @worker.options.client.data_converter) || {}
           )
 
           # Run
           activity = RunningActivity.new(
+            worker: @worker,
             info:,
             cancellation: Cancellation.new,
             worker_shutdown_cancellation: @worker._worker_shutdown_cancellation,
             payload_converter: @worker.options.client.data_converter.payload_converter,
-            logger: @scoped_logger
+            logger: @scoped_logger,
+            runtime_metric_meter: @runtime_metric_meter
           )
           Activity::Context._current_executor&.set_activity_context(defn, activity)
           set_running_activity(task_token, activity)
-          run_activity(activity, input)
-        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          run_activity(defn, activity, input)
+        rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
           @scoped_logger.warn("Failed starting or sending completion for activity #{start.activity_type}")
           @scoped_logger.warn(e)
           # This means that the activity couldn't start or send completion (run
@@ -223,12 +239,15 @@ module Temporalio
           remove_running_activity(task_token)
         end
 
-        def run_activity(activity, input)
+        def run_activity(defn, activity, input)
           result = begin
+            # Create the instance. We choose to do this before interceptors so that it is available in the interceptor.
+            activity.instance = defn.instance.is_a?(Proc) ? defn.instance.call : defn.instance # steep:ignore
+
             # Build impl with interceptors
-            # @type var impl: Temporalio::Worker::Interceptor::ActivityInbound
+            # @type var impl: Temporalio::Worker::Interceptor::Activity::Inbound
             impl = InboundImplementation.new(self)
-            impl = @worker._all_interceptors.reverse_each.reduce(impl) do |acc, int|
+            impl = @worker._activity_interceptors.reverse_each.reduce(impl) do |acc, int|
               int.intercept_activity(acc)
             end
             impl.init(OutboundImplementation.new(self))
@@ -242,7 +261,7 @@ module Temporalio
                 result: @worker.options.client.data_converter.to_payload(result)
               )
             )
-          rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
             if e.is_a?(Activity::CompleteAsyncError)
               # Wanting to complete async
               @scoped_logger.debug('Completing activity asynchronously')
@@ -280,20 +299,24 @@ module Temporalio
 
         class RunningActivity < Activity::Context
           attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
-          attr_accessor :_outbound_impl, :_server_requested_cancel
+          attr_accessor :instance, :_outbound_impl, :_server_requested_cancel
 
           def initialize( # rubocop:disable Lint/MissingSuper
+            worker:,
             info:,
             cancellation:,
             worker_shutdown_cancellation:,
             payload_converter:,
-            logger:
+            logger:,
+            runtime_metric_meter:
           )
+            @worker = worker
             @info = info
             @cancellation = cancellation
             @worker_shutdown_cancellation = worker_shutdown_cancellation
             @payload_converter = payload_converter
             @logger = logger
+            @runtime_metric_meter = runtime_metric_meter
             @_outbound_impl = nil
             @_server_requested_cancel = false
           end
@@ -301,11 +324,28 @@ module Temporalio
           def heartbeat(*details)
             raise 'Implementation not set yet' if _outbound_impl.nil?
 
-            _outbound_impl.heartbeat(Temporalio::Worker::Interceptor::HeartbeatActivityInput.new(details:))
+            # No-op if local
+            return if info.local?
+
+            _outbound_impl.heartbeat(Temporalio::Worker::Interceptor::Activity::HeartbeatInput.new(details:))
+          end
+
+          def metric_meter
+            @metric_meter ||= @runtime_metric_meter.with_additional_attributes(
+              {
+                namespace: info.workflow_namespace,
+                task_queue: info.task_queue,
+                activity_type: info.activity_type
+              }
+            )
+          end
+
+          def client
+            @worker.client
           end
         end
 
-        class InboundImplementation < Temporalio::Worker::Interceptor::ActivityInbound
+        class InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound
           def initialize(worker)
             super(nil) # steep:ignore
             @worker = worker
@@ -323,7 +363,7 @@ module Temporalio
           end
         end
 
-        class OutboundImplementation < Temporalio::Worker::Interceptor::ActivityOutbound
+        class OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound
           def initialize(worker)
             super(nil) # steep:ignore
             @worker = worker

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

@@ -6,6 +6,8 @@ require 'temporalio/internal/bridge/worker'
 module Temporalio
   module Internal
     module Worker
+      # Primary worker (re)actor-style event handler. This handles multiple workers, receiving events from the bridge,
+      # and handling a user block.
       class MultiRunner
         def initialize(workers:, shutdown_signals:)
           @workers = workers
@@ -32,7 +34,7 @@ module Temporalio
                                rescue InjectEventForTesting => e
                                  @queue.push(e.event)
                                  @queue.push(Event::BlockSuccess.new(result: e))
-                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                               rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally catch all
                                  @queue.push(Event::BlockFailure.new(error: e))
                                end
                              else
@@ -41,12 +43,22 @@ module Temporalio
                                rescue InjectEventForTesting => e
                                  @queue.push(e.event)
                                  @queue.push(Event::BlockSuccess.new(result: e))
-                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                               rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally catch all
                                  @queue.push(Event::BlockFailure.new(error: e))
                                end
                              end
         end
 
+        def apply_workflow_activation_decoded(workflow_worker:, activation:)
+          @queue.push(Event::WorkflowActivationDecoded.new(workflow_worker:, activation:))
+        end
+
+        def apply_workflow_activation_complete(workflow_worker:, activation_completion:, encoded:)
+          @queue.push(Event::WorkflowActivationComplete.new(
+                        workflow_worker:, activation_completion:, encoded:, completion_complete_queue: @queue
+                      ))
+        end
+
         def raise_in_thread_or_fiber_block(error)
           @thread_or_fiber&.raise(error)
         end
@@ -80,22 +92,25 @@ module Temporalio
           # * [worker index, :activity/:workflow, error] - poll fail
           # * [worker index, :activity/:workflow, nil] - worker shutdown
           # * [nil, nil, nil] - all pollers done
+          # * [-1, run_id_string, error_or_nil] - workflow activation completion complete
           result = @queue.pop
           if result.is_a?(Event)
             result
           else
-            worker_index, worker_type, poll_result = result
-            if worker_index.nil? || worker_type.nil?
+            first, second, third = result
+            if first.nil? || second.nil?
               Event::AllPollersShutDown.instance
+            elsif first == -1
+              Event::WorkflowActivationCompletionComplete.new(run_id: second, error: third)
             else
-              worker = @workers[worker_index]
-              case poll_result
+              worker = @workers[first]
+              case third
               when nil
-                Event::PollerShutDown.new(worker:, worker_type:)
+                Event::PollerShutDown.new(worker:, worker_type: second)
               when Exception
-                Event::PollFailure.new(worker:, worker_type:, error: poll_result)
+                Event::PollFailure.new(worker:, worker_type: second, error: third)
               else
-                Event::PollSuccess.new(worker:, worker_type:, bytes: poll_result)
+                Event::PollSuccess.new(worker:, worker_type: second, bytes: third)
               end
             end
           end
@@ -122,6 +137,35 @@ module Temporalio
             end
           end
 
+          class WorkflowActivationDecoded < Event
+            attr_reader :workflow_worker, :activation
+
+            def initialize(workflow_worker:, activation:) # rubocop:disable Lint/MissingSuper
+              @workflow_worker = workflow_worker
+              @activation = activation
+            end
+          end
+
+          class WorkflowActivationComplete < Event
+            attr_reader :workflow_worker, :activation_completion, :encoded, :completion_complete_queue
+
+            def initialize(workflow_worker:, activation_completion:, encoded:, completion_complete_queue:) # rubocop:disable Lint/MissingSuper
+              @workflow_worker = workflow_worker
+              @activation_completion = activation_completion
+              @encoded = encoded
+              @completion_complete_queue = completion_complete_queue
+            end
+          end
+
+          class WorkflowActivationCompletionComplete < Event
+            attr_reader :run_id, :error
+
+            def initialize(run_id:, error:) # rubocop:disable Lint/MissingSuper
+              @run_id = run_id
+              @error = error
+            end
+          end
+
           class PollerShutDown < Event
             attr_reader :worker, :worker_type
 

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'temporalio/cancellation'
+require 'temporalio/workflow'
+require 'temporalio/workflow/child_workflow_handle'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Implementation of the child workflow handle.
+        class ChildWorkflowHandle < Workflow::ChildWorkflowHandle
+          attr_reader :id, :first_execution_run_id
+
+          def initialize(id:, first_execution_run_id:, instance:, cancellation:, cancel_callback_key:) # rubocop:disable Lint/MissingSuper
+            @id = id
+            @first_execution_run_id = first_execution_run_id
+            @instance = instance
+            @cancellation = cancellation
+            @cancel_callback_key = cancel_callback_key
+            @resolution = nil
+          end
+
+          def result
+            # Notice that we actually provide a detached cancellation here instead of defaulting to workflow
+            # cancellation because we don't want workflow cancellation (or a user-provided cancellation to this result
+            # call) to be able to interrupt waiting on a child that may be processing the cancellation.
+            Workflow.wait_condition(cancellation: Cancellation.new) { @resolution }
+
+            case @resolution.status
+            when :completed
+              @instance.payload_converter.from_payload(@resolution.completed.result)
+            when :failed
+              raise @instance.failure_converter.from_failure(@resolution.failed.failure, @instance.payload_converter)
+            when :cancelled
+              raise @instance.failure_converter.from_failure(@resolution.cancelled.failure, @instance.payload_converter)
+            else
+              raise "Unrecognized resolution status: #{@resolution.status}"
+            end
+          end
+
+          def _resolve(resolution)
+            @cancellation.remove_cancel_callback(@cancel_callback_key)
+            @resolution = resolution
+          end
+
+          def signal(signal, *args, cancellation: Workflow.cancellation)
+            @instance.context._signal_child_workflow(id:, signal:, args:, cancellation:)
+          end
+        end
+      end
+    end
+  end
+end