temporalio 0.4.0-x86_64-linux → 0.5.0-x86_64-linux

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

@@ -53,7 +53,7 @@ module Temporalio
             workflow_type: Api::Common::V1::WorkflowType.new(name: input.workflow),
             workflow_id: input.workflow_id,
             task_queue: Api::TaskQueue::V1::TaskQueue.new(name: input.task_queue.to_s),
-            input: @client.data_converter.to_payloads(input.args),
+            input: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
             workflow_execution_timeout: ProtoUtils.seconds_to_duration(input.execution_timeout),
             workflow_run_timeout: ProtoUtils.seconds_to_duration(input.run_timeout),
             workflow_task_timeout: ProtoUtils.seconds_to_duration(input.task_timeout),
@@ -69,7 +69,9 @@ module Temporalio
             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)
+            header: ProtoUtils.headers_to_proto(input.headers, @client.data_converter),
+            priority: input.priority._to_proto,
+            versioning_override: input.versioning_override&._to_proto
           )
 
           # Send request
@@ -101,7 +103,8 @@ module Temporalio
             id: input.workflow_id,
             run_id: nil,
             result_run_id: resp.run_id,
-            first_execution_run_id: resp.run_id
+            first_execution_run_id: resp.run_id,
+            result_hint: input.result_hint
           )
         end
 
@@ -137,7 +140,7 @@ module Temporalio
                     ),
                     input: Api::Update::V1::Input.new(
                       name: input.update,
-                      args: @client.data_converter.to_payloads(input.args),
+                      args: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
                       header: Internal::ProtoUtils.headers_to_proto(input.headers, @client.data_converter)
                     )
                   ),
@@ -167,7 +170,8 @@ module Temporalio
                   id: start_options.id,
                   run_id: nil,
                   result_run_id: run_id,
-                  first_execution_run_id: run_id
+                  first_execution_run_id: run_id,
+                  result_hint: start_options.result_hint
                 )
               )
               update_resp = resp.responses.last.update_workflow
@@ -243,7 +247,8 @@ module Temporalio
             id: input.update_id,
             workflow_id: start_options.id,
             workflow_run_id: run_id,
-            known_outcome: update_resp.outcome
+            known_outcome: update_resp.outcome,
+            result_hint: input.result_hint
           )
         end
 
@@ -259,7 +264,7 @@ module Temporalio
             Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest, start_options
           )
           req.signal_name = input.signal
-          req.signal_input = @client.data_converter.to_payloads(input.args)
+          req.signal_input = @client.data_converter.to_payloads(input.args, hints: input.arg_hints)
 
           # Send request
           begin
@@ -292,7 +297,8 @@ module Temporalio
             id: start_options.id,
             run_id: nil,
             result_run_id: resp.run_id,
-            first_execution_run_id: resp.run_id
+            first_execution_run_id: resp.run_id,
+            result_hint: start_options.result_hint
           )
           input.start_workflow_operation._set_workflow_handle(handle)
           handle
@@ -305,7 +311,7 @@ module Temporalio
             workflow_type: Api::Common::V1::WorkflowType.new(name: start_options.workflow),
             workflow_id: start_options.id,
             task_queue: Api::TaskQueue::V1::TaskQueue.new(name: start_options.task_queue.to_s),
-            input: @client.data_converter.to_payloads(start_options.args),
+            input: @client.data_converter.to_payloads(start_options.args, hints: start_options.arg_hints),
             workflow_execution_timeout: ProtoUtils.seconds_to_duration(start_options.execution_timeout),
             workflow_run_timeout: ProtoUtils.seconds_to_duration(start_options.run_timeout),
             workflow_task_timeout: ProtoUtils.seconds_to_duration(start_options.task_timeout),
@@ -324,25 +330,24 @@ module Temporalio
           )
         end
 
-        def list_workflows(input)
-          Enumerator.new do |yielder|
-            req = Api::WorkflowService::V1::ListWorkflowExecutionsRequest.new(
-              namespace: @client.namespace,
-              query: input.query || ''
-            )
-            loop do
-              resp = @client.workflow_service.list_workflow_executions(
-                req,
-                rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
-              )
-              resp.executions.each do |raw_info|
-                yielder << Temporalio::Client::WorkflowExecution.new(raw_info, @client.data_converter)
-              end
-              break if resp.next_page_token.empty?
-
-              req.next_page_token = resp.next_page_token
-            end
+        def list_workflow_page(input)
+          req = Api::WorkflowService::V1::ListWorkflowExecutionsRequest.new(
+            namespace: @client.namespace,
+            query: input.query || '',
+            next_page_token: input.next_page_token,
+            page_size: input.page_size
+          )
+          resp = @client.workflow_service.list_workflow_executions(
+            req,
+            rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
+          )
+          executions = resp.executions.map do |raw_info|
+            Temporalio::Client::WorkflowExecution.new(raw_info, @client.data_converter)
           end
+          Temporalio::Client::ListWorkflowPage.new(
+            executions: executions,
+            next_page_token: resp.next_page_token
+          )
         end
 
         def count_workflows(input)
@@ -412,7 +417,7 @@ module Temporalio
                 run_id: input.run_id || ''
               ),
               signal_name: input.signal,
-              input: @client.data_converter.to_payloads(input.args),
+              input: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
               header: Internal::ProtoUtils.headers_to_proto(input.headers, @client.data_converter),
               identity: @client.connection.identity,
               request_id: SecureRandom.uuid
@@ -433,7 +438,7 @@ module Temporalio
                 ),
                 query: Api::Query::V1::WorkflowQuery.new(
                   query_type: input.query,
-                  query_args: @client.data_converter.to_payloads(input.args),
+                  query_args: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
                   header: Internal::ProtoUtils.headers_to_proto(input.headers, @client.data_converter)
                 ),
                 query_reject_condition: input.reject_condition || 0
@@ -453,7 +458,7 @@ module Temporalio
             ))
           end
 
-          results = @client.data_converter.from_payloads(resp.query_result)
+          results = @client.data_converter.from_payloads(resp.query_result, hints: Array(input.result_hint))
           warn("Expected 0 or 1 query result, got #{results.size}") if results.size > 1
           results&.first
         end
@@ -476,7 +481,7 @@ module Temporalio
               ),
               input: Api::Update::V1::Input.new(
                 name: input.update,
-                args: @client.data_converter.to_payloads(input.args),
+                args: @client.data_converter.to_payloads(input.args, hints: input.arg_hints),
                 header: Internal::ProtoUtils.headers_to_proto(input.headers, @client.data_converter)
               )
             ),
@@ -490,6 +495,10 @@ module Temporalio
           # the user cannot specify sooner than ACCEPTED)
           # @type var resp: untyped
           resp = nil
+          expected_stage = ProtoUtils.enum_to_int(Api::Enums::V1::UpdateWorkflowExecutionLifecycleStage,
+                                                  req.wait_policy.lifecycle_stage)
+          accepted_stage = ProtoUtils.enum_to_int(Api::Enums::V1::UpdateWorkflowExecutionLifecycleStage,
+                                                  Temporalio::Client::WorkflowUpdateWaitStage::ACCEPTED)
           loop do
             resp = @client.workflow_service.update_workflow_execution(
               req,
@@ -498,10 +507,8 @@ module Temporalio
 
             # We're only done if the response stage is after the requested stage
             # or the response stage is accepted
-            if resp.stage >= req.wait_policy.lifecycle_stage ||
-               resp.stage >= Temporalio::Client::WorkflowUpdateWaitStage::ACCEPTED
-              break
-            end
+            actual_stage = ProtoUtils.enum_to_int(Api::Enums::V1::UpdateWorkflowExecutionLifecycleStage, resp.stage)
+            break if actual_stage >= expected_stage || actual_stage >= accepted_stage
           rescue Error::RPCError => e
             # Deadline exceeded or cancel is a special error type
             if e.code == Error::RPCError::Code::DEADLINE_EXCEEDED || e.code == Error::RPCError::Code::CANCELED
@@ -531,7 +538,8 @@ module Temporalio
             id: input.update_id,
             workflow_id: input.workflow_id,
             workflow_run_id: input.run_id,
-            known_outcome: resp.outcome
+            known_outcome: resp.outcome,
+            result_hint: input.result_hint
           )
         end
 
@@ -806,7 +814,7 @@ module Temporalio
                        activity_id: input.task_token_or_id_reference.activity_id,
                        namespace: @client.namespace,
                        identity: @client.connection.identity,
-                       details: @client.data_converter.to_payloads(input.details)
+                       details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
                      ),
                      rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
                    )
@@ -816,7 +824,7 @@ module Temporalio
                        task_token: input.task_token_or_id_reference,
                        namespace: @client.namespace,
                        identity: @client.connection.identity,
-                       details: @client.data_converter.to_payloads(input.details)
+                       details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
                      ),
                      rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
                    )
@@ -835,7 +843,7 @@ module Temporalio
                 activity_id: input.task_token_or_id_reference.activity_id,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
-                result: @client.data_converter.to_payloads([input.result])
+                result: @client.data_converter.to_payloads([input.result], hints: Array(input.result_hint))
               ),
               rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
             )
@@ -845,7 +853,7 @@ module Temporalio
                 task_token: input.task_token_or_id_reference,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
-                result: @client.data_converter.to_payloads([input.result])
+                result: @client.data_converter.to_payloads([input.result], hints: Array(input.result_hint))
               ),
               rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
             )
@@ -854,6 +862,14 @@ module Temporalio
         end
 
         def fail_async_activity(input)
+          last_heartbeat_details = if input.last_heartbeat_details.empty?
+                                     nil
+                                   else
+                                     @client.data_converter.to_payloads(
+                                       input.last_heartbeat_details,
+                                       hints: input.last_heartbeat_detail_hints
+                                     )
+                                   end
           if input.task_token_or_id_reference.is_a?(Temporalio::Client::ActivityIDReference)
             @client.workflow_service.respond_activity_task_failed_by_id(
               Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest.new(
@@ -863,11 +879,7 @@ module Temporalio
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 failure: @client.data_converter.to_failure(input.error),
-                last_heartbeat_details: if input.last_heartbeat_details.empty?
-                                          nil
-                                        else
-                                          @client.data_converter.to_payloads(input.last_heartbeat_details)
-                                        end
+                last_heartbeat_details:
               ),
               rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
             )
@@ -878,11 +890,7 @@ module Temporalio
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
                 failure: @client.data_converter.to_failure(input.error),
-                last_heartbeat_details: if input.last_heartbeat_details.empty?
-                                          nil
-                                        else
-                                          @client.data_converter.to_payloads(input.last_heartbeat_details)
-                                        end
+                last_heartbeat_details:
               ),
               rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
             )
@@ -899,7 +907,7 @@ module Temporalio
                 activity_id: input.task_token_or_id_reference.activity_id,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
-                details: @client.data_converter.to_payloads(input.details)
+                details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
               ),
               rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
             )
@@ -909,7 +917,7 @@ module Temporalio
                 task_token: input.task_token_or_id_reference,
                 namespace: @client.namespace,
                 identity: @client.connection.identity,
-                details: @client.data_converter.to_payloads(input.details)
+                details: @client.data_converter.to_payloads(input.details, hints: input.detail_hints)
               ),
               rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
             )

data/lib/temporalio/internal/proto_utils.rb

@@ -94,16 +94,16 @@ module Temporalio
         enum_val
       end
 
-      def self.convert_from_payload_array(converter, payloads)
+      def self.convert_from_payload_array(converter, payloads, hints:)
         return [] if payloads.empty?
 
-        converter.from_payloads(Api::Common::V1::Payloads.new(payloads:))
+        converter.from_payloads(Api::Common::V1::Payloads.new(payloads:), hints:)
       end
 
-      def self.convert_to_payload_array(converter, values)
+      def self.convert_to_payload_array(converter, values, hints:)
         return [] if values.empty?
 
-        converter.to_payloads(values).payloads.to_ary
+        converter.to_payloads(values, hints:).payloads.to_ary
       end
 
       def self.assert_non_reserved_name(name)

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

@@ -148,10 +148,18 @@ module Temporalio
             @scoped_logger.warn("Cannot find activity to cancel for token #{task_token}")
             return
           end
-          activity._server_requested_cancel = true
-          _, cancel_proc = activity.cancellation
           begin
-            cancel_proc.call(reason: cancel.reason.to_s)
+            activity._cancel(
+              reason: cancel.reason.to_s,
+              details: Activity::CancellationDetails.new(
+                gone_from_server: cancel.details.is_not_found,
+                cancel_requested: cancel.details.is_cancelled,
+                timed_out: cancel.details.is_timed_out,
+                worker_shutdown: cancel.details.is_worker_shutdown,
+                paused: cancel.details.is_paused,
+                reset: cancel.details.is_reset
+              )
+            )
           rescue StandardError => e
             @scoped_logger.warn("Failed cancelling activity #{activity.info.activity_type} \
               with ID #{activity.info.activity_id}")
@@ -168,12 +176,15 @@ module Temporalio
             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: Internal::ProtoUtils.duration_to_seconds(start.heartbeat_timeout),
             local?: start.is_local,
+            priority: Priority._from_proto(start.priority),
+            raw_heartbeat_details: begin
+              payloads = start.heartbeat_details.to_ary
+              codec = @worker.options.client.data_converter.payload_codec
+              payloads = codec.decode(payloads) if codec
+              payloads.map { |p| Temporalio::Converters::RawValue.new(p) }
+            end,
             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),
@@ -184,7 +195,7 @@ module Temporalio
             workflow_namespace: start.workflow_namespace,
             workflow_run_id: start.workflow_execution.run_id,
             workflow_type: start.workflow_type
-          ).freeze
+          )
 
           # Build input
           input = Temporalio::Worker::Interceptor::Activity::ExecuteInput.new(
@@ -196,8 +207,13 @@ module Temporalio
                     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)
+                    ProtoUtils.convert_from_payload_array(
+                      @worker.options.client.data_converter,
+                      start.input.to_ary,
+                      hints: defn.arg_hints
+                    )
                   end,
+            result_hint: defn.result_hint,
             headers: ProtoUtils.headers_from_proto_map(start.header_fields, @worker.options.client.data_converter) || {}
           )
 
@@ -250,7 +266,7 @@ module Temporalio
             impl = @worker._activity_interceptors.reverse_each.reduce(impl) do |acc, int|
               int.intercept_activity(acc)
             end
-            impl.init(OutboundImplementation.new(self))
+            impl.init(OutboundImplementation.new(self, activity.info.task_token))
 
             # Execute
             result = impl.execute(input)
@@ -258,7 +274,7 @@ module Temporalio
             # Success
             Bridge::Api::ActivityResult::ActivityExecutionResult.new(
               completed: Bridge::Api::ActivityResult::Success.new(
-                result: @worker.options.client.data_converter.to_payload(result)
+                result: @worker.options.client.data_converter.to_payload(result, hint: input.result_hint)
               )
             )
           rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
@@ -268,6 +284,30 @@ module Temporalio
               Bridge::Api::ActivityResult::ActivityExecutionResult.new(
                 will_complete_async: Bridge::Api::ActivityResult::WillCompleteAsync.new
               )
+            elsif e.is_a?(Error::CanceledError) && activity.cancellation_details&.paused?
+              # Server requested pause
+              @scoped_logger.debug('Completing activity as failed due to exception caused by pause')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                failed: Bridge::Api::ActivityResult::Failure.new(
+                  failure: @worker.options.client.data_converter.to_failure(
+                    Error._with_backtrace_and_cause(
+                      Error::ApplicationError.new('Activity paused', type: 'ActivityPause'), backtrace: nil, cause: e
+                    )
+                  )
+                )
+              )
+            elsif e.is_a?(Error::CanceledError) && activity.cancellation_details&.reset?
+              # Server requested reset
+              @scoped_logger.debug('Completing activity as failed due to exception caused by reset')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                failed: Bridge::Api::ActivityResult::Failure.new(
+                  failure: @worker.options.client.data_converter.to_failure(
+                    Error._with_backtrace_and_cause(
+                      Error::ApplicationError.new('Activity reset', type: 'ActivityReset'), backtrace: nil, cause: e
+                    )
+                  )
+                )
+              )
             elsif e.is_a?(Error::CanceledError) && activity._server_requested_cancel
               # Server requested cancel
               @scoped_logger.debug('Completing activity as canceled')
@@ -278,8 +318,13 @@ module Temporalio
               )
             else
               # General failure
-              @scoped_logger.warn('Completing activity as failed')
-              @scoped_logger.warn(e)
+              log_level = if e.is_a?(Error::ApplicationError) && e.category == Error::ApplicationError::Category::BENIGN
+                            Logger::DEBUG
+                          else
+                            Logger::WARN
+                          end
+              @scoped_logger.add(log_level, 'Completing activity as failed')
+              @scoped_logger.add(log_level, e)
               Bridge::Api::ActivityResult::ActivityExecutionResult.new(
                 failed: Bridge::Api::ActivityResult::Failure.new(
                   failure: @worker.options.client.data_converter.to_failure(e)
@@ -297,9 +342,21 @@ module Temporalio
           )
         end
 
+        def assert_valid_activity(activity)
+          defn = @activities[activity]
+          defn = @activities[nil] if !defn && !Internal::ProtoUtils.reserved_name?(activity)
+
+          return unless defn.nil?
+
+          raise ArgumentError,
+                "Activity #{activity} " \
+                "is not registered on this worker, available activities: #{@activities.keys.sort.join(', ')}"
+        end
+
         class RunningActivity < Activity::Context
-          attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
-          attr_accessor :instance, :_outbound_impl, :_server_requested_cancel
+          attr_reader :info, :cancellation, :cancellation_details, :worker_shutdown_cancellation,
+                      :payload_converter, :logger, :_server_requested_cancel
+          attr_accessor :instance, :_outbound_impl
 
           def initialize( # rubocop:disable Lint/MissingSuper
             worker:,
@@ -313,6 +370,7 @@ module Temporalio
             @worker = worker
             @info = info
             @cancellation = cancellation
+            @cancellation_details = nil
             @worker_shutdown_cancellation = worker_shutdown_cancellation
             @payload_converter = payload_converter
             @logger = logger
@@ -321,13 +379,15 @@ module Temporalio
             @_server_requested_cancel = false
           end
 
-          def heartbeat(*details)
+          def heartbeat(*details, detail_hints: nil)
             raise 'Implementation not set yet' if _outbound_impl.nil?
 
             # No-op if local
             return if info.local?
 
-            _outbound_impl.heartbeat(Temporalio::Worker::Interceptor::Activity::HeartbeatInput.new(details:))
+            _outbound_impl.heartbeat(
+              Temporalio::Worker::Interceptor::Activity::HeartbeatInput.new(details:, detail_hints:)
+            )
           end
 
           def metric_meter
@@ -343,6 +403,17 @@ module Temporalio
           def client
             @worker.client
           end
+
+          def _cancel(reason:, details:)
+            # Do not issue cancel if already canceled
+            return if @cancellation_details
+
+            @_server_requested_cancel = true
+            # Set the cancellation details _before_ issuing the cancel itself
+            @cancellation_details = details
+            _, cancel_proc = cancellation
+            cancel_proc.call(reason:)
+          end
         end
 
         class InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound
@@ -364,17 +435,19 @@ module Temporalio
         end
 
         class OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound
-          def initialize(worker)
+          def initialize(worker, task_token)
             super(nil) # steep:ignore
             @worker = worker
+            @task_token = task_token
           end
 
           def heartbeat(input)
             @worker.bridge_worker.record_activity_heartbeat(
               Bridge::Api::CoreInterface::ActivityHeartbeat.new(
-                task_token: Activity::Context.current.info.task_token,
+                task_token: @task_token,
                 details: ProtoUtils.convert_to_payload_array(@worker.worker.options.client.data_converter,
-                                                             input.details)
+                                                             input.details,
+                                                             hints: input.detail_hints)
               ).to_proto
             )
           end

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

@@ -10,18 +10,20 @@ module Temporalio
       class WorkflowInstance
         # Implementation of the child workflow handle.
         class ChildWorkflowHandle < Workflow::ChildWorkflowHandle
-          attr_reader :id, :first_execution_run_id
+          attr_reader :id, :first_execution_run_id, :result_hint
 
-          def initialize(id:, first_execution_run_id:, instance:, cancellation:, cancel_callback_key:) # rubocop:disable Lint/MissingSuper
+          def initialize(id:, first_execution_run_id:, instance:, # rubocop:disable Lint/MissingSuper
+                         cancellation:, cancel_callback_key:, result_hint:)
             @id = id
             @first_execution_run_id = first_execution_run_id
             @instance = instance
             @cancellation = cancellation
             @cancel_callback_key = cancel_callback_key
+            @result_hint = result_hint
             @resolution = nil
           end
 
-          def result
+          def result(result_hint: nil)
             # 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.
@@ -29,7 +31,7 @@ module Temporalio
 
             case @resolution.status
             when :completed
-              @instance.payload_converter.from_payload(@resolution.completed.result)
+              @instance.payload_converter.from_payload(@resolution.completed.result, hint: result_hint || @result_hint)
             when :failed
               raise @instance.failure_converter.from_failure(@resolution.failed.failure, @instance.payload_converter)
             when :cancelled
@@ -44,8 +46,8 @@ module Temporalio
             @resolution = resolution
           end
 
-          def signal(signal, *args, cancellation: Workflow.cancellation)
-            @instance.context._signal_child_workflow(id:, signal:, args:, cancellation:)
+          def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil)
+            @instance.context._signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:)
           end
         end
       end