temporalio 1.1.0-aarch64-linux → 1.3.0-aarch64-linux

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

@@ -1425,6 +1425,156 @@ module Temporalio
             rpc_options:
           )
         end
+
+        # Calls WorkflowService.PauseWorkflowExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse] API response.
+        def pause_workflow_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'pause_workflow_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.UnpauseWorkflowExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse] API response.
+        def unpause_workflow_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'unpause_workflow_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.StartActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::StartActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::StartActivityExecutionResponse] API response.
+        def start_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'start_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::StartActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::StartActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.DescribeActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionResponse] API response.
+        def describe_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'describe_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.PollActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::PollActivityExecutionResponse] API response.
+        def poll_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'poll_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::PollActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.ListActivityExecutions API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::ListActivityExecutionsRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::ListActivityExecutionsResponse] API response.
+        def list_activity_executions(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'list_activity_executions',
+            request_class: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.CountActivityExecutions API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::CountActivityExecutionsRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse] API response.
+        def count_activity_executions(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'count_activity_executions',
+            request_class: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.RequestCancelActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionResponse] API response.
+        def request_cancel_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'request_cancel_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.TerminateActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionResponse] API response.
+        def terminate_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'terminate_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.DeleteActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionResponse] API response.
+        def delete_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'delete_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
       end
     end
   end

data/lib/temporalio/client/connection.rb

@@ -169,6 +169,9 @@ module Temporalio
       # @param lazy_connect [Boolean] If true, there is no connection until the first call is attempted or a worker
       #   is created with it. Clients from lazy connections cannot be used for workers if they have not performed a
       #   connection.
+      # @param around_connect [Proc, nil] If present, this proc accepts two values: options and a block. The block must
+      #   be yielded to only once with the options. The block does not return a meaningful value, nor should
+      #   around_connect.
       #
       # @see Client.connect
       def initialize(
@@ -181,7 +184,8 @@ module Temporalio
         keep_alive: KeepAliveOptions.new,
         http_connect_proxy: nil,
         runtime: Runtime.default,
-        lazy_connect: false
+        lazy_connect: false,
+        around_connect: nil
       )
         @options = Options.new(
           target_host:,
@@ -195,9 +199,19 @@ module Temporalio
           runtime:,
           lazy_connect:
         ).freeze
-        # Create core client now if not lazy
         @core_client_mutex = Mutex.new
-        _core_client unless lazy_connect
+        # Create core client now if not lazy, applying around_connect if present
+        if around_connect
+          # Technically around_connect can never run the block for whatever reason (i.e. plugin returning a mock
+          # connection), so we don't enforce it
+          around_connect.call(@options) do |options|
+            @options = options
+            _core_client unless lazy_connect
+            nil
+          end
+        else
+          _core_client unless lazy_connect
+        end
         # Create service instances
         @workflow_service = WorkflowService.new(self)
         @operator_service = OperatorService.new(self)

data/lib/temporalio/client/plugin.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Client
+    # Plugin mixin to include for configuring clients and/or intercepting connect calls.
+    #
+    # This is a low-level implementation that requires abstract methods herein to be implemented. Many implementers may
+    # prefer {SimplePlugin} which includes this.
+    #
+    # WARNING: Plugins are experimental.
+    module Plugin
+      # @abstract
+      # @return [String] Name of the plugin.
+      def name
+        raise NotImplementedError
+      end
+
+      # Configure a client.
+      #
+      # @abstract
+      # @param options [Options] Current immutable options set.
+      # @return [Options] Options to use, possibly updated from original.
+      def configure_client(options)
+        raise NotImplementedError
+      end
+
+      # Connect a client.
+      #
+      # Implementers are expected to delegate to next_call to perform the connection. Note, this does not apply to users
+      # explicitly creating connections via {Connection} constructor.
+      #
+      # @abstract
+      # @param options [Connection::Options] Current immutable options set.
+      # @param next_call [Proc] Proc for the next plugin in the chain to call. It accepts the options and returns a
+      #   {Connection}.
+      # @return [Connection] Connected connection.
+      def connect_client(options, next_call)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/client.rb

@@ -6,6 +6,7 @@ require 'temporalio/api'
 require 'temporalio/client/async_activity_handle'
 require 'temporalio/client/connection'
 require 'temporalio/client/interceptor'
+require 'temporalio/client/plugin'
 require 'temporalio/client/schedule'
 require 'temporalio/client/schedule_handle'
 require 'temporalio/client/with_start_workflow_operation'
@@ -42,6 +43,7 @@ module Temporalio
       :connection,
       :namespace,
       :data_converter,
+      :plugins,
       :interceptors,
       :logger,
       :default_workflow_query_reject_condition
@@ -70,6 +72,9 @@ module Temporalio
     # @param tls [Boolean, Connection::TLSOptions] If false, do not use TLS. If true, use system default TLS options. If
     #   TLS options are present, those TLS options will be used.
     # @param data_converter [Converters::DataConverter] Data converter to use for all data conversions to/from payloads.
+    # @param plugins [Array<Plugin>] Plugins to use for configuring clients and intercepting connection. Any plugins
+    #   that also include {Worker::Plugin} will automatically be applied to the worker and should not be configured
+    #   explicitly on the worker. WARNING: Plugins are experimental.
     # @param interceptors [Array<Interceptor>] Set of interceptors that are chained together to allow intercepting of
     #   client calls. The earlier interceptors wrap the later ones. Any interceptors that also implement worker
     #   interceptor will be used as worker interceptors too so they should not be given separately when creating a
@@ -101,6 +106,7 @@ module Temporalio
       api_key: nil,
       tls: nil,
       data_converter: Converters::DataConverter.default,
+      plugins: [],
       interceptors: [],
       logger: Logger.new($stdout, level: Logger::WARN),
       default_workflow_query_reject_condition: nil,
@@ -112,27 +118,78 @@ module Temporalio
       runtime: Runtime.default,
       lazy_connect: false
     )
+      # Prepare connection. The connection var is needed here so it can be used in callback for plugin.
+      base_connection = nil
+      final_connection = nil
+      around_connect = if plugins.any?
+                         _validate_plugins!(plugins)
+                         # For plugins, we have to do an around_connect approach with Connection where we provide a
+                         # no-return-value proc that is invoked with the built options and yields newly built options.
+                         # The connection will have been created before, but we allow plugins to return a
+                         # different/extended connection, possibly avoiding actual connection altogether.
+                         proc do |options, &block|
+                           # Steep simply can't comprehend these advanced inline procs
+                           # steep:ignore:start
+
+                           # Root next call
+                           next_call_called = false
+                           next_call = proc do |options|
+                             raise 'next_call called more than once' if next_call_called
+
+                             next_call_called = true
+                             block&.call(options)
+                             base_connection
+                           end
+                           # Go backwards, building up new next_call invocations on plugins
+                           next_call = plugins.reverse_each.reduce(next_call) do |next_call, plugin|
+                             proc { |options| plugin.connect_client(options, next_call) }
+                           end
+                           # Do call
+                           final_connection = next_call.call(options)
+
+                           # steep:ignore:end
+                         end
+                       end
+      # Now create connection
+      base_connection = Connection.new(
+        target_host:,
+        api_key:,
+        tls:,
+        rpc_metadata:,
+        rpc_retry:,
+        identity:,
+        keep_alive:,
+        http_connect_proxy:,
+        runtime:,
+        lazy_connect:,
+        around_connect: # steep:ignore
+      )
+
+      # Create client
       Client.new(
-        connection: Connection.new(
-          target_host:,
-          api_key:,
-          tls:,
-          rpc_metadata:,
-          rpc_retry:,
-          identity:,
-          keep_alive:,
-          http_connect_proxy:,
-          runtime:,
-          lazy_connect:
-        ),
+        connection: final_connection || base_connection,
         namespace:,
         data_converter:,
+        plugins:,
         interceptors:,
         logger:,
         default_workflow_query_reject_condition:
       )
     end
 
+    # @!visibility private
+    def self._validate_plugins!(plugins)
+      plugins.each do |plugin|
+        raise ArgumentError, "#{plugin.class} does not implement Client::Plugin" unless plugin.is_a?(Plugin)
+
+        # Validate plugin has implemented expected methods
+        missing = Plugin.instance_methods(false).select { |m| plugin.method(m).owner == Plugin }
+        unless missing.empty?
+          raise ArgumentError, "#{plugin.class} missing the following client plugin method(s): #{missing.join(', ')}"
+        end
+      end
+    end
+
     # @return [Options] Frozen options for this client which has the same attributes as {initialize}.
     attr_reader :options
 
@@ -143,6 +200,9 @@ module Temporalio
     # @param connection [Connection] Existing connection to create a client from.
     # @param namespace [String] Namespace to use for client calls.
     # @param data_converter [Converters::DataConverter] Data converter to use for all data conversions to/from payloads.
+    # @param plugins [Array<Plugin>] Plugins to use for configuring clients. Any plugins that also include
+    #   {Worker::Plugin} will automatically be applied to the worker and should not be configured explicitly on the
+    #   worker. WARNING: Plugins are experimental.
     # @param interceptors [Array<Interceptor>] Set of interceptors that are chained together to allow intercepting of
     #   client calls. The earlier interceptors wrap the later ones. Any interceptors that also implement worker
     #   interceptor will be used as worker interceptors too so they should not be given separately when creating a
@@ -157,6 +217,7 @@ module Temporalio
       connection:,
       namespace:,
       data_converter: DataConverter.default,
+      plugins: [],
       interceptors: [],
       logger: Logger.new($stdout, level: Logger::WARN),
       default_workflow_query_reject_condition: nil
@@ -165,12 +226,20 @@ module Temporalio
         connection:,
         namespace:,
         data_converter:,
+        plugins:,
         interceptors:,
         logger:,
         default_workflow_query_reject_condition:
       ).freeze
+
+      # Apply plugins
+      Client._validate_plugins!(plugins)
+      @options = plugins.reduce(@options) { |options, plugin| plugin.configure_client(options) }
+
       # Initialize interceptors
-      @impl = interceptors.reverse_each.reduce(Internal::Client::Implementation.new(self)) do |acc, int| # steep:ignore
+      @impl = @options.interceptors.reverse_each.reduce(
+        Internal::Client::Implementation.new(self)
+      ) do |acc, int| # steep:ignore
         int.intercept_client(acc)
       end
     end
@@ -229,7 +298,6 @@ module Temporalio
     # @param request_eager_start [Boolean] Potentially reduce the latency to start this workflow by encouraging the
     #   server to start it on a local worker running with this same client. This is currently experimental.
     # @param versioning_override [VersioningOverride, nil] Override the version of the workflow.
-    #   This is currently experimental.
     # @param priority [Priority] Priority of the workflow. This is currently experimental.
     # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
     #   workflow definition has arg hints, those are used by default.
@@ -323,7 +391,6 @@ module Temporalio
     # @param request_eager_start [Boolean] Potentially reduce the latency to start this workflow by encouraging the
     #   server to start it on a local worker running with this same client. This is currently experimental.
     # @param versioning_override [VersioningOverride, nil] Override the version of the workflow.
-    #   This is currently experimental.
     # @param priority [Priority] Priority for the workflow. This is currently experimental.
     # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
     #   workflow definition has arg hints, those are used by default.

data/lib/temporalio/common_enums.rb

@@ -40,8 +40,6 @@ module Temporalio
   end
 
   # Specifies when a workflow might move from a worker of one Build Id to another.
-  #
-  # WARNING: Experimental API.
   module VersioningBehavior
     # Unspecified versioning behavior. By default, workers opting into worker versioning will
     # be required to specify a behavior.

data/lib/temporalio/contrib/open_telemetry.rb

@@ -67,6 +67,11 @@ module Temporalio
           headers[@header_key] = carrier unless carrier.empty?
         end
 
+        # @!visibility private
+        def _propagator
+          @propagator
+        end
+
         # @!visibility private
         def _attach_context(headers)
           context = _context_from_headers(headers)
@@ -402,6 +407,22 @@ module Temporalio
             super
           end
 
+          # @!visibility private
+          def start_nexus_operation(input)
+            # Nexus headers are string-to-string maps (not payload-based like activity/workflow headers)
+            # so we inject the tracing context directly into the headers instead of nesting under a key
+            span = Workflow.completed_span("StartNexusOperation:#{input.service}/#{input.operation}", kind: :client)
+            Temporalio::Workflow::Unsafe.durable_scheduler_disabled do
+              if span
+                @root._propagator.inject(
+                  input.headers,
+                  context: ::OpenTelemetry::Trace.context_with_span(span)
+                )
+              end
+            end
+            super
+          end
+
           # @!visibility private
           def _apply_span_to_headers(headers, span)
             # See WorkflowInbound#_attach_context comments for why we have to disable scheduler even for these simple

data/lib/temporalio/converters/failure_converter.rb

@@ -84,6 +84,18 @@ module Temporalio
             started_event_id: error.started_event_id,
             retry_state: error.retry_state
           )
+        when Error::NexusOperationError
+          failure.nexus_operation_execution_failure_info = Api::Failure::V1::NexusOperationFailureInfo.new(
+            endpoint: error.endpoint,
+            service: error.service,
+            operation: error.operation,
+            operation_token: error.operation_token || ''
+          )
+        when Error::NexusHandlerError
+          failure.nexus_handler_failure_info = Api::Failure::V1::NexusHandlerFailureInfo.new(
+            type: error.error_type.to_s,
+            retry_behavior: error.retry_behavior
+          )
         else
           failure.application_failure_info = Api::Failure::V1::ApplicationFailureInfo.new(
             type: error.class.name.to_s.split('::').last
@@ -190,6 +202,24 @@ module Temporalio
                       zero_means_nil: true
                     )
                   )
+                elsif failure.nexus_operation_execution_failure_info
+                  token = failure.nexus_operation_execution_failure_info.operation_token
+                  Error::NexusOperationError.new(
+                    Internal::ProtoUtils.string_or(failure.message, 'Nexus operation error'),
+                    endpoint: failure.nexus_operation_execution_failure_info.endpoint,
+                    service: failure.nexus_operation_execution_failure_info.service,
+                    operation: failure.nexus_operation_execution_failure_info.operation,
+                    operation_token: token.empty? ? nil : token
+                  )
+                elsif failure.nexus_handler_failure_info
+                  Error::NexusHandlerError.new(
+                    Internal::ProtoUtils.string_or(failure.message, 'Nexus handler error'),
+                    error_type: failure.nexus_handler_failure_info.type,
+                    retry_behavior: Internal::ProtoUtils.enum_to_int(
+                      Api::Enums::V1::NexusHandlerErrorRetryBehavior,
+                      failure.nexus_handler_failure_info.retry_behavior
+                    )
+                  )
                 else
                   Error::Failure.new(Internal::ProtoUtils.string_or(failure.message, 'Failure error'))
                 end

data/lib/temporalio/converters/payload_converter/binary_protobuf.rb

@@ -22,7 +22,10 @@ module Temporalio
 
           # @type var value: Google::Protobuf::MessageExts
           Api::Common::V1::Payload.new(
-            metadata: { 'encoding' => ENCODING, 'messageType' => value.class.descriptor.name },
+            metadata: {
+              'encoding' => ENCODING,
+              'messageType' => value.class.descriptor.name # steep:ignore NoMethod
+            },
             data: value.to_proto
           )
         end

data/lib/temporalio/converters/payload_converter/json_protobuf.rb

@@ -21,7 +21,10 @@ module Temporalio
           return nil unless value.is_a?(Google::Protobuf::MessageExts)
 
           Api::Common::V1::Payload.new(
-            metadata: { 'encoding' => ENCODING, 'messageType' => value.class.descriptor.name },
+            metadata: {
+              'encoding' => ENCODING,
+              'messageType' => value.class.descriptor.name # steep:ignore NoMethod
+            },
             data: value.to_json.b
           )
         end

data/lib/temporalio/env_config.rb

@@ -4,9 +4,7 @@ require 'pathname'
 require 'temporalio/internal/bridge'
 
 module Temporalio
-  # Environment and file-based configuration for Temporal clients
-  #
-  # WARNING: Experimental API.
+  # Environment and file-based configuration for Temporal clients.
   module EnvConfig
     # This module provides utilities to load Temporal client configuration from TOML files
     # and environment variables.
@@ -180,13 +178,7 @@ module Temporalio
         path, data = EnvConfig._source_to_path_and_data(config_source)
 
         raw_profile = Internal::Bridge::EnvConfig.load_client_connect_config(
-          profile,
-          path,
-          data,
-          disable_file,
-          disable_env,
-          config_file_strict,
-          override_env_vars || {}
+          profile, path, data, disable_file, disable_env, config_file_strict, override_env_vars
         )
 
         from_h(raw_profile)
@@ -272,10 +264,7 @@ module Temporalio
         path, data = EnvConfig._source_to_path_and_data(config_source)
 
         loaded_profiles = Internal::Bridge::EnvConfig.load_client_config(
-          path,
-          data,
-          config_file_strict,
-          override_env_vars || {}
+          path, data, config_file_strict, override_env_vars
         )
 
         from_h(loaded_profiles)

data/lib/temporalio/error/failure.rb

@@ -233,5 +233,71 @@ module Temporalio
         @retry_state = retry_state
       end
     end
+
+    # Error raised on Nexus operation failure.
+    #
+    # WARNING: Nexus support is experimental.
+    class NexusOperationError < Failure
+      # @return [String] Nexus endpoint.
+      attr_reader :endpoint
+      # @return [String] Nexus service.
+      attr_reader :service
+      # @return [String] Nexus operation.
+      attr_reader :operation
+      # @return [String, nil] Operation token for async operations.
+      attr_reader :operation_token
+
+      # @!visibility private
+      def initialize(
+        message,
+        endpoint:,
+        service:,
+        operation:,
+        operation_token:
+      )
+        super(message)
+        @endpoint = endpoint
+        @service = service
+        @operation = operation
+        @operation_token = operation_token
+      end
+    end
+
+    # Error raised from a Nexus handler.
+    #
+    # WARNING: Nexus support is experimental.
+    class NexusHandlerError < Failure
+      # @return [Symbol] Error type from the handler.
+      attr_reader :error_type
+
+      # @return [RetryBehavior] Retry behavior for the error.
+      attr_reader :retry_behavior
+
+      # @!visibility private
+      def initialize(
+        message,
+        error_type:,
+        retry_behavior:
+      )
+        super(message)
+        @error_type = error_type.to_sym
+        @retry_behavior = retry_behavior
+      end
+
+      # Nexus handler error retry behavior.
+      module RetryBehavior
+        # Unspecified retry behavior.
+        UNSPECIFIED =
+          Api::Enums::V1::NexusHandlerErrorRetryBehavior::NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_UNSPECIFIED
+
+        # Retryable error.
+        RETRYABLE =
+          Api::Enums::V1::NexusHandlerErrorRetryBehavior::NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_RETRYABLE
+
+        # Non-retryable error.
+        NON_RETRYABLE =
+          Api::Enums::V1::NexusHandlerErrorRetryBehavior::NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_NON_RETRYABLE
+      end
+    end
   end
 end