temporalio 0.4.0 → 0.5.0

data/lib/temporalio/client/connection/cloud_service.rb

@@ -241,6 +241,21 @@ module Temporalio
           )
         end
 
+        # Calls CloudService.DeleteNamespaceRegion API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionResponse] API response.
+        def delete_namespace_region(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'delete_namespace_region',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
         # Calls CloudService.GetRegions API call.
         #
         # @param request [Temporalio::Api::Cloud::CloudService::V1::GetRegionsRequest] API request.
@@ -511,6 +526,51 @@ module Temporalio
           )
         end
 
+        # Calls CloudService.AddUserGroupMember API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberResponse] API response.
+        def add_user_group_member(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'add_user_group_member',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.RemoveUserGroupMember API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberResponse] API response.
+        def remove_user_group_member(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'remove_user_group_member',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.GetUserGroupMembers API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersResponse] API response.
+        def get_user_group_members(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'get_user_group_members',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
         # Calls CloudService.CreateServiceAccount API call.
         #
         # @param request [Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountRequest] API request.

data/lib/temporalio/client/connection/workflow_service.rb

@@ -1245,6 +1245,111 @@ module Temporalio
             rpc_options:
           )
         end
+
+        # Calls WorkflowService.CreateWorkflowRule API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleResponse] API response.
+        def create_workflow_rule(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'create_workflow_rule',
+            request_class: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.DescribeWorkflowRule API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleResponse] API response.
+        def describe_workflow_rule(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'describe_workflow_rule',
+            request_class: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.DeleteWorkflowRule API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleResponse] API response.
+        def delete_workflow_rule(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'delete_workflow_rule',
+            request_class: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.ListWorkflowRules API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::ListWorkflowRulesRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::ListWorkflowRulesResponse] API response.
+        def list_workflow_rules(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'list_workflow_rules',
+            request_class: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.TriggerWorkflowRule API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleResponse] API response.
+        def trigger_workflow_rule(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'trigger_workflow_rule',
+            request_class: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.RecordWorkerHeartbeat API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatResponse] API response.
+        def record_worker_heartbeat(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'record_worker_heartbeat',
+            request_class: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.ListWorkers API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::ListWorkersRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::ListWorkersResponse] API response.
+        def list_workers(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'list_workers',
+            request_class: Temporalio::Api::WorkflowService::V1::ListWorkersRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::ListWorkersResponse,
+            request:,
+            rpc_options:
+          )
+        end
       end
     end
   end

data/lib/temporalio/client/interceptor.rb

@@ -36,6 +36,10 @@ module Temporalio
         :search_attributes,
         :start_delay,
         :request_eager_start,
+        :versioning_override,
+        :priority,
+        :arg_hints,
+        :result_hint,
         :headers,
         :rpc_options
       )
@@ -47,6 +51,8 @@ module Temporalio
         :args,
         :wait_for_stage,
         :start_workflow_operation,
+        :arg_hints,
+        :result_hint,
         :headers,
         :rpc_options
       )
@@ -56,13 +62,16 @@ module Temporalio
         :signal,
         :args,
         :start_workflow_operation,
+        :arg_hints,
         # Headers intentionally not defined here, because they are not separate from start_workflow_operation
         :rpc_options
       )
 
-      # Input for {Outbound.list_workflows}.
-      ListWorkflowsInput = Data.define(
+      # Input for {Outbound.list_workflow_page}.
+      ListWorkflowPageInput = Data.define(
         :query,
+        :next_page_token,
+        :page_size,
         :rpc_options
       )
 
@@ -95,6 +104,7 @@ module Temporalio
         :run_id,
         :signal,
         :args,
+        :arg_hints,
         :headers,
         :rpc_options
       )
@@ -106,6 +116,8 @@ module Temporalio
         :query,
         :args,
         :reject_condition,
+        :arg_hints,
+        :result_hint,
         :headers,
         :rpc_options
       )
@@ -118,6 +130,8 @@ module Temporalio
         :update,
         :args,
         :wait_for_stage,
+        :arg_hints,
+        :result_hint,
         :headers,
         :rpc_options
       )
@@ -216,6 +230,7 @@ module Temporalio
       HeartbeatAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :details,
+        :detail_hints,
         :rpc_options
       )
 
@@ -223,6 +238,7 @@ module Temporalio
       CompleteAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :result,
+        :result_hint,
         :rpc_options
       )
 
@@ -231,6 +247,7 @@ module Temporalio
         :task_token_or_id_reference,
         :error,
         :last_heartbeat_details,
+        :last_heartbeat_detail_hints,
         :rpc_options
       )
 
@@ -238,6 +255,7 @@ module Temporalio
       ReportCancellationAsyncActivityInput = Data.define(
         :task_token_or_id_reference,
         :details,
+        :detail_hints,
         :rpc_options
       )
 
@@ -279,12 +297,12 @@ module Temporalio
           next_interceptor.signal_with_start_workflow(input)
         end
 
-        # Called for every {Client.list_workflows} call.
+        # Called for every {Client.list_workflow_page} call.
         #
-        # @param input [ListWorkflowsInput] Input.
-        # @return [Enumerator<WorkflowExecution>] Enumerable workflow executions.
-        def list_workflows(input)
-          next_interceptor.list_workflows(input)
+        # @param input [ListWorkflowPageInput] Input.
+        # @return [Client::ListWorkflowPage] Enumerable workflow executions, with a #next_page_token method.
+        def list_workflow_page(input)
+          next_interceptor.list_workflow_page(input)
         end
 
         # Called for every {Client.count_workflows} call.

data/lib/temporalio/client/schedule.rb

@@ -175,6 +175,7 @@ module Temporalio
           :retry_policy,
           :memo,
           :search_attributes,
+          :arg_hints,
           :headers
         )
 
@@ -208,6 +209,9 @@ module Temporalio
         #   @return [Hash<String, Object>, nil] Memo for the workflow.
         # @!attribute search_attributes
         #   @return [SearchAttributes, nil] Search attributes for the workflow.
+        # @!attribute arg_hints
+        #   @return [Array<Object>, nil] Converter hints for workflow arguments. This is only user-set (e.g. on create)
+        #     and is not persisted and therefore will not be set when describing a workflow.
         # @!attribute headers
         #   @return [Hash<String, Object>, nil] Headers for the workflow.
         class StartWorkflow
@@ -249,10 +253,13 @@ module Temporalio
               retry_policy: nil,
               memo: nil,
               search_attributes: nil,
+              arg_hints: nil,
               headers: nil
             )
+              workflow, defn_arg_hints, =
+                Workflow::Definition._workflow_type_and_hints_from_workflow_parameter(workflow)
               _original_new( # steep:ignore
-                workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
+                workflow:,
                 args:,
                 id:,
                 task_queue:,
@@ -264,6 +271,7 @@ module Temporalio
                 retry_policy:,
                 memo:,
                 search_attributes:,
+                arg_hints: arg_hints || defn_arg_hints,
                 headers:
               )
             end
@@ -296,7 +304,7 @@ module Temporalio
                 workflow_id: id,
                 workflow_type: Api::Common::V1::WorkflowType.new(name: workflow),
                 task_queue: Api::TaskQueue::V1::TaskQueue.new(name: task_queue),
-                input: data_converter.to_payloads(args),
+                input: data_converter.to_payloads(args, hints: arg_hints),
                 workflow_execution_timeout: Internal::ProtoUtils.seconds_to_duration(execution_timeout),
                 workflow_run_timeout: Internal::ProtoUtils.seconds_to_duration(run_timeout),
                 workflow_task_timeout: Internal::ProtoUtils.seconds_to_duration(task_timeout),

data/lib/temporalio/client/with_start_workflow_operation.rb

@@ -24,6 +24,8 @@ module Temporalio
         :memo,
         :search_attributes,
         :start_delay,
+        :arg_hints,
+        :result_hint,
         :headers
       )
 
@@ -55,10 +57,14 @@ module Temporalio
         memo: nil,
         search_attributes: nil,
         start_delay: nil,
+        arg_hints: nil,
+        result_hint: nil,
         headers: {}
       )
+        workflow, defn_arg_hints, defn_result_hint =
+          Workflow::Definition._workflow_type_and_hints_from_workflow_parameter(workflow)
         @options = Options.new(
-          workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
+          workflow:,
           args:,
           id:,
           task_queue:,
@@ -74,6 +80,8 @@ module Temporalio
           memo:,
           search_attributes:,
           start_delay:,
+          arg_hints: arg_hints || defn_arg_hints,
+          result_hint: result_hint || defn_result_hint,
           headers:
         )
         @workflow_handle_mutex = Mutex.new

data/lib/temporalio/client/workflow_handle.rb

@@ -48,13 +48,21 @@ module Temporalio
       # @return [String, nil] First execution run ID.
       attr_reader :first_execution_run_id
 
+      # Result hint for the result of this workflow. If this handle was created via {Client.start_workflow}, this is set
+      # from there (either via result hint on that call or workflow definition's result hint). Otherwise, the result
+      # hint is set by the creator of the handle.
+      #
+      # @return [Object, nil] Result hint.
+      attr_reader :result_hint
+
       # @!visibility private
-      def initialize(client:, id:, run_id:, result_run_id:, first_execution_run_id:)
+      def initialize(client:, id:, run_id:, result_run_id:, first_execution_run_id:, result_hint:)
         @client = client
         @id = id
         @run_id = run_id
         @result_run_id = result_run_id
         @first_execution_run_id = first_execution_run_id
+        @result_hint = result_hint
       end
 
       # Wait for the result of the workflow.
@@ -64,6 +72,8 @@ module Temporalio
       #
       # @param follow_runs [Boolean] If +true+, workflow runs will be continually fetched across retries and continue as
       #   new until the latest one is found. If +false+, the first result is used.
+      # @param result_hint [Object, nil] Override the result hint for the result. If unset/nil, uses one on the handle
+      #   itself.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @return [Object] Result of the workflow after being converted by the data converter.
@@ -71,7 +81,7 @@ module Temporalio
       # @raise [Error::WorkflowFailedError] Workflow failed with +cause+ as the cause.
       # @raise [Error::WorkflowContinuedAsNewError] Workflow continued as new and +follow_runs+ is +false+.
       # @raise [Error::RPCError] RPC error from call.
-      def result(follow_runs: true, rpc_options: nil)
+      def result(follow_runs: true, result_hint: nil, rpc_options: nil)
         # Wait on the close event, following as needed
         hist_run_id = result_run_id
         loop do
@@ -91,7 +101,7 @@ module Temporalio
             hist_run_id = attrs.new_execution_run_id
             next if follow_runs && hist_run_id && !hist_run_id.empty?
 
-            return @client.data_converter.from_payloads(attrs.result).first
+            return @client.data_converter.from_payloads(attrs.result, hints: Array(@result_hint || result_hint)).first
           when :EVENT_TYPE_WORKFLOW_EXECUTION_FAILED
             attrs = event.workflow_execution_failed_event_attributes
             hist_run_id = attrs.new_execution_run_id
@@ -212,18 +222,22 @@ module Temporalio
       #
       # @param signal [Workflow::Definition::Signal, Symbol, String] Signal definition or name.
       # @param args [Array<Object>] Signal arguments.
+      # @param arg_hints [Array<Object>, nil] Signal argument hints. If unset/nil and a signal definition is passed,
+      #   uses the ones on the signal definition if present.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @raise [Error::RPCError] RPC error from call.
       #
       # @note Handles created as a result of {Client.start_workflow} will signal the latest workflow with the same
       #   workflow ID even if it is unrelated to the started workflow.
-      def signal(signal, *args, rpc_options: nil)
+      def signal(signal, *args, arg_hints: nil, rpc_options: nil)
+        signal, defn_arg_hints = Workflow::Definition::Signal._name_and_hints_from_parameter(signal)
         @client._impl.signal_workflow(Interceptor::SignalWorkflowInput.new(
                                         workflow_id: id,
                                         run_id:,
-                                        signal: Workflow::Definition::Signal._name_from_parameter(signal),
+                                        signal:,
                                         args:,
+                                        arg_hints: arg_hints || defn_arg_hints,
                                         headers: {},
                                         rpc_options:
                                       ))
@@ -235,6 +249,10 @@ module Temporalio
       # @param query [Workflow::Definition::Query, Symbol, String] Query definition or name.
       # @param args [Array<Object>] Query arguments.
       # @param reject_condition [WorkflowQueryRejectCondition, nil] Condition for rejecting the query.
+      # @param arg_hints [Array<Object>, nil] Query argument hints. If unset/nil and a query definition is passed,
+      #   uses the ones on the query definition if present.
+      # @param result_hint [Object, nil] Query result hints. If unset/nil and a query definition is passed, uses the
+      #   one on the query definition if present.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @return [Object, nil] Query result.
@@ -249,14 +267,19 @@ module Temporalio
         query,
         *args,
         reject_condition: @client.options.default_workflow_query_reject_condition,
+        arg_hints: nil,
+        result_hint: nil,
         rpc_options: nil
       )
+        query, defn_arg_hints, defn_result_hint = Workflow::Definition::Query._name_and_hints_from_parameter(query)
         @client._impl.query_workflow(Interceptor::QueryWorkflowInput.new(
                                        workflow_id: id,
                                        run_id:,
-                                       query: Workflow::Definition::Query._name_from_parameter(query),
+                                       query:,
                                        args:,
                                        reject_condition:,
+                                       arg_hints: arg_hints || defn_arg_hints,
+                                       result_hint: result_hint || defn_result_hint,
                                        headers: {},
                                        rpc_options:
                                      ))
@@ -270,6 +293,10 @@ module Temporalio
       # @param wait_for_stage [WorkflowUpdateWaitStage] Required stage to wait until returning. ADMITTED is not
       #   currently supported. See https://docs.temporal.io/workflows#update for more details.
       # @param id [String] ID of the update.
+      # @param arg_hints [Array<Object>, nil] Update argument hints. If unset/nil and am update definition is passed,
+      #   uses the ones on the update definition if present.
+      # @param result_hint [Object, nil] Update result hints. If unset/nil and an update definition is passed, uses the
+      #   one on the update definition if present.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @return [WorkflowUpdateHandle] The update handle.
@@ -285,15 +312,20 @@ module Temporalio
         *args,
         wait_for_stage:,
         id: SecureRandom.uuid,
+        arg_hints: nil,
+        result_hint: nil,
         rpc_options: nil
       )
+        update, defn_arg_hints, defn_result_hint = Workflow::Definition::Update._name_and_hints_from_parameter(update)
         @client._impl.start_workflow_update(Interceptor::StartWorkflowUpdateInput.new(
                                               workflow_id: self.id,
                                               run_id:,
                                               update_id: id,
-                                              update: Workflow::Definition::Update._name_from_parameter(update),
+                                              update:,
                                               args:,
                                               wait_for_stage:,
+                                              arg_hints: arg_hints || defn_arg_hints,
+                                              result_hint: result_hint || defn_result_hint,
                                               headers: {},
                                               rpc_options:
                                             ))
@@ -305,6 +337,10 @@ module Temporalio
       # @param update [Workflow::Definition::Update, Symbol, String] Update definition or name.
       # @param args [Array<Object>] Update arguments.
       # @param id [String] ID of the update.
+      # @param arg_hints [Array<Object>, nil] Update argument hints. If unset/nil and am update definition is passed,
+      #   uses the ones on the update definition if present.
+      # @param result_hint [Object, nil] Update result hints. If unset/nil and an update definition is passed, uses the
+      #   one on the update definition if present.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @return [Object, nil] Update result.
@@ -316,12 +352,14 @@ module Temporalio
       #
       # @note Handles created as a result of {Client.start_workflow} will send updates the latest workflow with the same
       #   workflow ID even if it is unrelated to the started workflow.
-      def execute_update(update, *args, id: SecureRandom.uuid, rpc_options: nil)
+      def execute_update(update, *args, id: SecureRandom.uuid, arg_hints: nil, result_hint: nil, rpc_options: nil)
         start_update(
           update,
           *args,
           wait_for_stage: WorkflowUpdateWaitStage::COMPLETED,
           id:,
+          arg_hints:,
+          result_hint:,
           rpc_options:
         ).result
       end
@@ -331,15 +369,17 @@ module Temporalio
       # @param id [String] ID of the update.
       # @param specific_run_id [String, nil] Workflow run ID to get update handle for. Default is the {run_id}. Most
       #   users will not need to set this and instead use the one on the class.
+      # @param result_hint [Object, nil] Result hint for the update result to set on the handle.
       #
       # @return [WorkflowUpdateHandle] The update handle.
-      def update_handle(id, specific_run_id: run_id)
+      def update_handle(id, specific_run_id: run_id, result_hint: nil)
         WorkflowUpdateHandle.new(
           client: @client,
           id:,
           workflow_id: self.id,
           workflow_run_id: specific_run_id,
-          known_outcome: nil
+          known_outcome: nil,
+          result_hint:
         )
       end
 

data/lib/temporalio/client/workflow_update_handle.rb

@@ -18,13 +18,17 @@ module Temporalio
       # @return [String, nil] Run ID for the workflow.
       attr_reader :workflow_run_id
 
+      # @return [Object, nil] Result hint if one set when the handle was created.
+      attr_reader :result_hint
+
       # @!visibility private
-      def initialize(client:, id:, workflow_id:, workflow_run_id:, known_outcome:)
+      def initialize(client:, id:, workflow_id:, workflow_run_id:, known_outcome:, result_hint:)
         @client = client
         @id = id
         @workflow_id = workflow_id
         @workflow_run_id = workflow_run_id
         @known_outcome = known_outcome
+        @result_hint = result_hint
       end
 
       # @return [Boolean] True if the result is already known and {result} will not make a blocking call, false if
@@ -36,6 +40,7 @@ module Temporalio
       # Wait for and return the result of the update. The result may already be known in which case no network call is
       # made. Otherwise the result will be polled for until it is returned.
       #
+      # @param result_hint [Object, nil] If not nil, overrides handle-level result hint for getting the result.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
       #
       # @return [Object, nil] Update result.
@@ -44,7 +49,7 @@ module Temporalio
       # @raise [Error::WorkflowUpdateRPCTimeoutOrCanceledError] This update call timed out or was canceled. This doesn't
       #   mean the update itself was timed out or canceled.
       # @raise [Error::RPCError] RPC error from call.
-      def result(rpc_options: nil)
+      def result(result_hint: nil, rpc_options: nil)
         @known_outcome ||= @client._impl.poll_workflow_update(Interceptor::PollWorkflowUpdateInput.new(
                                                                 workflow_id:,
                                                                 run_id: workflow_run_id,
@@ -56,7 +61,8 @@ module Temporalio
           raise Error::WorkflowUpdateFailedError.new, cause: @client.data_converter.from_failure(@known_outcome.failure)
         end
 
-        results = @client.data_converter.from_payloads(@known_outcome.success)
+        results = @client.data_converter.from_payloads(@known_outcome.success,
+                                                       hints: Array(result_hint || @result_hint))
         warn("Expected 0 or 1 update result, got #{results.size}") if results.size > 1
         results.first
       end