temporalio 1.2.0-aarch64-linux → 1.4.0-aarch64-linux

data/lib/temporalio/internal/bridge/testing.rb

@@ -22,8 +22,7 @@ module Temporalio
             :log_format,
             :log_level,
             :extra_args,
-            :download_ttl, # Optional
-            keyword_init: true
+            :download_ttl # Optional
           )
 
           StartTestServerOptions = Struct.new(
@@ -34,8 +33,7 @@ module Temporalio
             :download_dest_dir, # Optional
             :port, # Optional
             :extra_args,
-            :download_ttl, # Optional
-            keyword_init: true
+            :download_ttl # Optional
           )
 
           def self.start_dev_server(runtime, options)

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

@@ -28,22 +28,19 @@ module Temporalio
           :nondeterminism_as_workflow_fail,
           :nondeterminism_as_workflow_fail_for_types,
           :deployment_options,
-          :plugins,
-          keyword_init: true
+          :plugins
         )
 
         TunerOptions = Struct.new(
           :workflow_slot_supplier,
           :activity_slot_supplier,
-          :local_activity_slot_supplier,
-          keyword_init: true
+          :local_activity_slot_supplier
         )
 
         TunerSlotSupplierOptions = Struct.new(
           :fixed_size,
           :resource_based,
-          :custom,
-          keyword_init: true
+          :custom
         )
 
         TunerResourceBasedSlotSupplierOptions = Struct.new(
@@ -51,33 +48,28 @@ module Temporalio
           :target_cpu_usage,
           :min_slots,
           :max_slots,
-          :ramp_throttle,
-          keyword_init: true
+          :ramp_throttle
         )
 
         WorkerDeploymentVersion = Struct.new(
           :deployment_name,
-          :build_id,
-          keyword_init: true
+          :build_id
         )
 
         DeploymentOptions = Struct.new(
           :version,
           :use_worker_versioning,
-          :default_versioning_behavior,
-          keyword_init: true
+          :default_versioning_behavior
         )
 
         PollerBehaviorSimpleMaximum = Struct.new(
-          :simple_maximum,
-          keyword_init: true
+          :simple_maximum
         )
 
         PollerBehaviorAutoscaling = Struct.new(
           :minimum,
           :maximum,
-          :initial,
-          keyword_init: true
+          :initial
         )
 
         def self.finalize_shutdown_all(workers)

data/lib/temporalio/internal/bridge.rb

@@ -25,11 +25,11 @@ module Temporalio
               'see https://github.com/temporalio/sdk-ruby/issues/162'
       end
 
-      def self.fibers_supported # rubocop:disable Naming/PredicateMethod
+      def self.fibers_supported
         # We do not allow fibers on < 3.3 due to a bug we still need to dig
         # into: https://github.com/temporalio/sdk-ruby/issues/162
         major, minor = RUBY_VERSION.split('.').take(2).map(&:to_i)
-        !major.nil? && major >= 3 && !minor.nil? && minor >= 3
+        !major.nil? && !minor.nil? && (major > 3 || (major == 3 && minor >= 3))
       end
     end
   end

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

@@ -228,7 +228,7 @@ module Temporalio
                 if details
                   e = Error::WorkflowAlreadyStartedError.new(
                     workflow_id: start_options.id,
-                    workflow_type: start_req.workflow_type,
+                    workflow_type: start_req.workflow_type.name,
                     run_id: details.run_id
                   )
                 end

data/lib/temporalio/internal/proto_utils.rb

@@ -53,7 +53,9 @@ module Temporalio
       def self.memo_from_proto(memo, converter)
         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
+        h = {}
+        memo.fields.each { |key, val| h[key] = converter.from_payload(val) }
+        h
       end
 
       def self.headers_to_proto(headers, converter)
@@ -75,10 +77,10 @@ module Temporalio
       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
+        # @type var h: Hash[String, Object?]
+        h = {}
+        headers.each { |key, val| h[key] = converter.from_payload(val) }
+        h
       end
 
       def self.string_or(str, default = nil)

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

@@ -6,6 +6,7 @@ require 'temporalio/internal/bridge/api'
 require 'temporalio/internal/proto_utils'
 require 'temporalio/internal/worker/workflow_instance'
 require 'temporalio/internal/worker/workflow_instance/external_workflow_handle'
+require 'temporalio/internal/worker/workflow_instance/nexus_client'
 require 'temporalio/worker/interceptor'
 require 'temporalio/workflow'
 
@@ -32,6 +33,18 @@ module Temporalio
             @instance.continue_as_new_suggested
           end
 
+          def create_nexus_client(endpoint:, service:)
+            NexusClient.new(endpoint:, service:, outbound: @outbound)
+          end
+
+          def suggest_continue_as_new_reasons
+            @instance.suggest_continue_as_new_reasons
+          end
+
+          def target_worker_deployment_version_changed?
+            @instance.target_worker_deployment_version_changed
+          end
+
           def current_details
             @instance.current_details || ''
           end
@@ -374,7 +387,9 @@ module Temporalio
             @instance.add_command(
               Bridge::Api::WorkflowCommands::WorkflowCommand.new(
                 upsert_workflow_search_attributes: Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes.new(
-                  search_attributes: updates.to_h(&:_to_proto_pair)
+                  search_attributes: Api::Common::V1::SearchAttributes.new(
+                    indexed_fields: updates.to_h(&:_to_proto_pair)
+                  )
                 )
               )
             )

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'temporalio/workflow'
+require 'temporalio/workflow/nexus_client'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Implementation of the Nexus client.
+        class NexusClient < Workflow::NexusClient
+          attr_reader :endpoint, :service
+
+          def initialize(endpoint:, service:, outbound:) # rubocop:disable Lint/MissingSuper
+            @endpoint = endpoint.to_s
+            @service = service.to_s
+            @outbound = outbound
+          end
+
+          def start_operation(operation, arg, schedule_to_close_timeout: nil, schedule_to_start_timeout: nil,
+                              start_to_close_timeout: nil, cancellation_type: nil, summary: nil,
+                              cancellation: Workflow.cancellation, arg_hint: nil, result_hint: nil)
+            @outbound.start_nexus_operation(
+              Temporalio::Worker::Interceptor::Workflow::StartNexusOperationInput.new(
+                endpoint: @endpoint,
+                service: @service,
+                operation: operation.to_s,
+                arg:,
+                schedule_to_close_timeout:,
+                schedule_to_start_timeout:,
+                start_to_close_timeout:,
+                cancellation_type:,
+                summary:,
+                cancellation:,
+                arg_hint:,
+                result_hint:,
+                headers: {}
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'temporalio/cancellation'
+require 'temporalio/workflow'
+require 'temporalio/workflow/nexus_operation_handle'
+
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        # Implementation of the Nexus operation handle.
+        class NexusOperationHandle < Workflow::NexusOperationHandle
+          attr_reader :operation_token, :result_hint
+
+          def initialize(operation_token:, instance:, cancellation:, cancel_callback_key:, # rubocop:disable Lint/MissingSuper
+                         result_hint:)
+            @operation_token = operation_token
+            @instance = instance
+            @cancellation = cancellation
+            @cancel_callback_key = cancel_callback_key
+            @result_hint = result_hint
+            @resolution = nil
+          end
+
+          def result(result_hint: nil)
+            # Use detached cancellation like child workflow to avoid interrupting result wait
+            Workflow.wait_condition(cancellation: Cancellation.new) { @resolution }
+
+            case @resolution.status
+            when :completed
+              @instance.payload_converter.from_payload(@resolution.completed, hint: result_hint || @result_hint)
+            when :failed
+              raise @instance.failure_converter.from_failure(@resolution.failed, @instance.payload_converter)
+            when :cancelled
+              raise @instance.failure_converter.from_failure(@resolution.cancelled, @instance.payload_converter)
+            when :timed_out
+              raise @instance.failure_converter.from_failure(@resolution.timed_out, @instance.payload_converter)
+            else
+              raise "Unrecognized Nexus operation result status: #{@resolution.status}"
+            end
+          end
+
+          def _resolve(resolution)
+            @cancellation.remove_cancel_callback(@cancel_callback_key)
+            @resolution = resolution
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ require 'temporalio/error'
 require 'temporalio/internal/bridge/api'
 require 'temporalio/internal/proto_utils'
 require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/internal/worker/workflow_instance/nexus_operation_handle'
 require 'temporalio/worker/interceptor'
 require 'temporalio/workflow'
 require 'temporalio/workflow/child_workflow_handle'
@@ -22,6 +23,7 @@ module Temporalio
             @activity_counter = 0
             @timer_counter = 0
             @child_counter = 0
+            @nexus_operation_counter = 0
             @external_signal_counter = 0
             @external_cancel_counter = 0
           end
@@ -363,7 +365,7 @@ module Temporalio
                   cron_schedule: input.cron_schedule,
                   headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
                   memo: ProtoUtils.memo_to_proto_hash(input.memo, @instance.payload_converter),
-                  search_attributes: input.search_attributes&._to_proto_hash,
+                  search_attributes: input.search_attributes&._to_proto,
                   cancellation_type: input.cancellation_type,
                   priority: input.priority._to_proto
                 ),
@@ -429,6 +431,74 @@ module Temporalio
               raise "Unknown resolution status: #{resolution.status}"
             end
           end
+
+          def start_nexus_operation(input)
+            raise Error::CanceledError, 'Nexus operation canceled before scheduled' if input.cancellation.canceled?
+
+            # Add the command
+            seq = (@nexus_operation_counter += 1)
+            @instance.add_command(
+              Bridge::Api::WorkflowCommands::WorkflowCommand.new(
+                schedule_nexus_operation: Bridge::Api::WorkflowCommands::ScheduleNexusOperation.new(
+                  seq:,
+                  endpoint: input.endpoint,
+                  service: input.service,
+                  operation: input.operation,
+                  input: @instance.payload_converter.to_payload(input.arg, hint: input.arg_hint),
+                  schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
+                  schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
+                  start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
+                  nexus_header: input.headers,
+                  cancellation_type: input.cancellation_type
+                ),
+                user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
+              )
+            )
+
+            # Set as pending start
+            @instance.pending_nexus_operation_starts[seq] = Fiber.current
+
+            # Register cancel callback
+            cancel_callback_key = input.cancellation.add_cancel_callback do
+              # Send cancel if in start or pending
+              if @instance.pending_nexus_operation_starts.include?(seq) ||
+                 @instance.pending_nexus_operations.include?(seq)
+                @instance.add_command(
+                  Bridge::Api::WorkflowCommands::WorkflowCommand.new(
+                    request_cancel_nexus_operation: Bridge::Api::WorkflowCommands::RequestCancelNexusOperation.new(
+                      seq:
+                    )
+                  )
+                )
+              end
+            end
+
+            # Wait for start resolution
+            resolution = begin
+              Fiber.yield
+            ensure
+              # Remove pending start
+              @instance.pending_nexus_operation_starts.delete(seq)
+            end
+
+            # Handle start failure
+            if resolution.failed
+              input.cancellation.remove_cancel_callback(cancel_callback_key)
+              raise @instance.failure_converter.from_failure(resolution.failed, @instance.payload_converter)
+            end
+
+            # Create handle and add to pending operations (result will come via resolve_nexus_operation)
+            handle = NexusOperationHandle.new(
+              operation_token: resolution.operation_token,
+              instance: @instance,
+              cancellation: input.cancellation,
+              cancel_callback_key:,
+              result_hint: input.result_hint
+            )
+            @instance.pending_nexus_operations[seq] = handle
+
+            handle
+          end
         end
       end
     end

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

@@ -54,8 +54,11 @@ module Temporalio
 
         attr_reader :context, :logger, :info, :scheduler, :disable_eager_activity_execution, :pending_activities,
                     :pending_timers, :pending_child_workflow_starts, :pending_child_workflows,
+                    :pending_nexus_operation_starts, :pending_nexus_operations,
                     :pending_external_signals, :pending_external_cancels, :in_progress_handlers, :payload_converter,
-                    :failure_converter, :cancellation, :continue_as_new_suggested, :current_deployment_version,
+                    :failure_converter, :cancellation, :continue_as_new_suggested,
+                    :suggest_continue_as_new_reasons, :target_worker_deployment_version_changed,
+                    :current_deployment_version,
                     :current_history_length, :current_history_size, :replaying, :random,
                     :signal_handlers, :query_handlers, :update_handlers, :context_frozen, :assert_valid_local_activity,
                     :in_query_or_validator
@@ -79,6 +82,8 @@ module Temporalio
           @pending_timers = {} # Keyed by sequence, value is fiber to resume with proto result
           @pending_child_workflow_starts = {} # Keyed by sequence, value is fiber to resume with proto result
           @pending_child_workflows = {} # Keyed by sequence, value is ChildWorkflowHandle to resolve with proto result
+          @pending_nexus_operation_starts = {} # Keyed by sequence, value is fiber to resume with proto result
+          @pending_nexus_operations = {} # Keyed by sequence, value is NexusOperationHandle to resolve with proto result
           @pending_external_signals = {} # Keyed by sequence, value is fiber to resume with proto result
           @pending_external_cancels = {} # Keyed by sequence, value is fiber to resume with proto result
           @buffered_signals = {} # Keyed by signal name, value is array of signal jobs
@@ -89,6 +94,8 @@ module Temporalio
           @interceptors = details.interceptors
           @cancellation, @cancellation_proc = Cancellation.new
           @continue_as_new_suggested = false
+          @suggest_continue_as_new_reasons = []
+          @target_worker_deployment_version_changed = false
           @current_history_length = 0
           @current_history_size = 0
           @replaying = false
@@ -173,6 +180,8 @@ module Temporalio
           @commands = []
           @current_activation_error = nil
           @continue_as_new_suggested = activation.continue_as_new_suggested
+          @suggest_continue_as_new_reasons = activation.suggest_continue_as_new_reasons.map(&:to_i)
+          @target_worker_deployment_version_changed = activation.target_worker_deployment_version_changed
           @current_deployment_version = WorkerDeploymentVersion._from_bridge(
             activation.deployment_version_for_current_task
           )
@@ -369,6 +378,14 @@ module Temporalio
             pending_child_workflows[job.resolve_child_workflow_execution.seq]&._resolve(
               job.resolve_child_workflow_execution.result
             )
+          when :resolve_nexus_operation_start
+            pending_nexus_operation_starts[job.resolve_nexus_operation_start.seq]&.resume(
+              job.resolve_nexus_operation_start
+            )
+          when :resolve_nexus_operation
+            pending_nexus_operations[job.resolve_nexus_operation.seq]&._resolve(
+              job.resolve_nexus_operation.result
+            )
           when :resolve_signal_external_workflow
             pending_external_signals[job.resolve_signal_external_workflow.seq]&.resume(
               job.resolve_signal_external_workflow
@@ -628,7 +645,8 @@ module Temporalio
                   memo: ProtoUtils.memo_to_proto_hash(err.memo, payload_converter),
                   headers: ProtoUtils.headers_to_proto_hash(err.headers, payload_converter),
                   search_attributes: err.search_attributes&._to_proto,
-                  retry_policy: err.retry_policy&._to_proto
+                  retry_policy: err.retry_policy&._to_proto,
+                  initial_versioning_behavior: err.initial_versioning_behavior || 0
                 )
               )
             )

data/lib/temporalio/search_attributes.rb

@@ -58,7 +58,7 @@ module Temporalio
         when IndexedValueType::TIME
           raise TypeError, 'Value of TIME key must be a Time' unless value.is_a?(Time)
         when IndexedValueType::KEYWORD_LIST
-          unless value.is_a?(Array) && value.all? { |v| v.is_a?(String) }
+          unless value.is_a?(Array) && value.all?(String)
             raise TypeError, 'Value of KEYWORD_LIST key must be an Array of String'
           end
         else
@@ -350,7 +350,17 @@ module Temporalio
       }.freeze
 
       # @!visibility private
-      PROTO_VALUES = PROTO_NAMES.invert.freeze
+      # The type metadata is usually in PascalCase (e.g. "KeywordList") but in
+      # rare cases may be in SCREAMING_SNAKE_CASE (e.g. "INDEXED_VALUE_TYPE_KEYWORD_LIST").
+      PROTO_VALUES = PROTO_NAMES.invert.merge(
+        'INDEXED_VALUE_TYPE_TEXT' => TEXT,
+        'INDEXED_VALUE_TYPE_KEYWORD' => KEYWORD,
+        'INDEXED_VALUE_TYPE_INT' => INTEGER,
+        'INDEXED_VALUE_TYPE_DOUBLE' => FLOAT,
+        'INDEXED_VALUE_TYPE_BOOL' => BOOLEAN,
+        'INDEXED_VALUE_TYPE_DATETIME' => TIME,
+        'INDEXED_VALUE_TYPE_KEYWORD_LIST' => KEYWORD_LIST
+      ).freeze
     end
   end
 end

data/lib/temporalio/testing/workflow_environment.rb

@@ -2,6 +2,7 @@
 
 require 'delegate'
 require 'temporalio/api'
+require 'temporalio/api/operatorservice/v1/request_response'
 require 'temporalio/api/testservice/v1/request_response'
 require 'temporalio/client'
 require 'temporalio/client/connection/test_service'
@@ -264,6 +265,45 @@ module Temporalio
         Time.now
       end
 
+      # Create Nexus endpoint on this test environment.
+      #
+      # WARNING: Nexus support is experimental.
+      #
+      # @param name [String] Endpoint name.
+      # @param task_queue [String] Task queue for the endpoint.
+      # @return [Temporalio::Api::Nexus::V1::Endpoint] Created endpoint.
+      def create_nexus_endpoint(name:, task_queue:)
+        resp = client.connection.operator_service.create_nexus_endpoint(
+          Temporalio::Api::OperatorService::V1::CreateNexusEndpointRequest.new(
+            spec: Temporalio::Api::Nexus::V1::EndpointSpec.new(
+              name:,
+              target: Temporalio::Api::Nexus::V1::EndpointTarget.new(
+                worker: Temporalio::Api::Nexus::V1::EndpointTarget::Worker.new(
+                  namespace: client.namespace,
+                  task_queue:
+                )
+              )
+            )
+          )
+        )
+        resp.endpoint
+      end
+
+      # Delete Nexus endpoint on this test environment.
+      #
+      # WARNING: Nexus support is experimental.
+      #
+      # @param endpoint [Temporalio::Api::Nexus::V1::Endpoint] Endpoint to delete.
+      def delete_nexus_endpoint(endpoint)
+        client.connection.operator_service.delete_nexus_endpoint(
+          Temporalio::Api::OperatorService::V1::DeleteNexusEndpointRequest.new(
+            id: endpoint.id,
+            version: endpoint.version
+          )
+        )
+        nil
+      end
+
       # Run a block with automatic time skipping disabled. This just runs the block for environments that don't support
       # time skipping.
       #

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '1.2.0'
+  VERSION = '1.4.0'
 end

data/lib/temporalio/versioning_override.rb

@@ -5,8 +5,6 @@ require 'temporalio/worker_deployment_version'
 module Temporalio
   # Base class for version overrides that can be provided in start workflow options.
   # Used to control the versioning behavior of workflows started with this override.
-  #
-  # WARNING: Experimental API.
   class VersioningOverride
     # @!visibility private
     def _to_proto

data/lib/temporalio/worker/deployment_options.rb

@@ -13,8 +13,6 @@ module Temporalio
 
     # Options for configuring the Worker Versioning feature.
     #
-    # WARNING: Deployment-based versioning is experimental and APIs may change.
-    #
     # @!attribute version
     #   @return [WorkerDeploymentVersion] The worker deployment version.
     # @!attribute use_worker_versioning

data/lib/temporalio/worker/interceptor.rb

@@ -300,6 +300,25 @@ module Temporalio
           :headers
         )
 
+        # Input for {Outbound.start_nexus_operation}.
+        #
+        # WARNING: Nexus support is experimental.
+        StartNexusOperationInput = Data.define(
+          :endpoint,
+          :service,
+          :operation,
+          :arg,
+          :schedule_to_close_timeout,
+          :schedule_to_start_timeout,
+          :start_to_close_timeout,
+          :cancellation_type,
+          :summary,
+          :cancellation,
+          :arg_hint,
+          :result_hint,
+          :headers
+        )
+
         # Outbound interceptor for intercepting outbound workflow calls. This should be extended by users needing to
         # intercept workflow calls.
         class Outbound
@@ -371,6 +390,16 @@ module Temporalio
           def start_child_workflow(input)
             @next_interceptor.start_child_workflow(input)
           end
+
+          # Start Nexus operation.
+          #
+          # WARNING: Nexus support is experimental.
+          #
+          # @param input [StartNexusOperationInput] Input.
+          # @return [Workflow::NexusOperationHandle] Nexus operation handle.
+          def start_nexus_operation(input)
+            @next_interceptor.start_nexus_operation(input)
+          end
         end
       end
     end

data/lib/temporalio/worker/workflow_executor/thread_pool.rb

@@ -49,7 +49,7 @@ module Temporalio
               # If not found, get a new one either by creating if not enough or find the one with the fewest.
               new_worker = if @workers.size < @max_threads
                              created_worker = Worker.new(self)
-                             @workers << Worker.new(self)
+                             @workers << created_worker
                              created_worker
                            else
                              @workers.min_by(&:workflow_count)

data/lib/temporalio/worker/workflow_replayer.rb

@@ -258,9 +258,7 @@ module Temporalio
             logger: options.logger,
             data_converter: options.data_converter,
             metric_meter: options.runtime.metric_meter,
-            workflow_interceptors: options.interceptors.select do |i|
-              i.is_a?(Interceptor::Workflow)
-            end,
+            workflow_interceptors: options.interceptors.grep(Interceptor::Workflow),
             disable_eager_activity_execution: false,
             illegal_workflow_calls: options.illegal_workflow_calls,
             workflow_failure_exception_types: options.workflow_failure_exception_types,

data/lib/temporalio/worker.rb

@@ -163,7 +163,7 @@ module Temporalio
     )
       # Confirm there is at least one and they are all workers
       raise ArgumentError, 'At least one worker required' if workers.empty?
-      raise ArgumentError, 'Not all parameters are workers' unless workers.all? { |w| w.is_a?(Worker) }
+      raise ArgumentError, 'Not all parameters are workers' unless workers.all?(Worker)
 
       Internal::Bridge.assert_fiber_compatibility!
 
@@ -425,7 +425,6 @@ module Temporalio
     #   scheduler will fail. Instead of setting this to true, users are encouraged to use {Workflow::Unsafe.io_enabled}
     #   with a block for narrower enabling of IO.
     # @param deployment_options [DeploymentOptions, nil] Deployment options for the worker.
-    #   WARNING: This is an experimental feature and may change in the future.
     # @param workflow_task_poller_behavior [PollerBehavior] Specify the behavior of workflow task
     #   polling. Defaults to a 5-poller maximum.
     # @param activity_task_poller_behavior [PollerBehavior] Specify the behavior of activity task
@@ -515,6 +514,12 @@ module Temporalio
         raise ArgumentError, 'Must have at least one activity or workflow'
       end
 
+      if !@options.deployment_options.use_worker_versioning &&
+         @options.deployment_options.default_versioning_behavior != VersioningBehavior::UNSPECIFIED
+        raise ArgumentError,
+              'default_versioning_behavior must be UNSPECIFIED when use_worker_versioning is false'
+      end
+
       should_enforce_versioning_behavior =
         @options.deployment_options.use_worker_versioning &&
         @options.deployment_options.default_versioning_behavior == VersioningBehavior::UNSPECIFIED
@@ -559,12 +564,8 @@ module Temporalio
       )
 
       # Collect interceptors from client and params
-      @activity_interceptors = (@options.client.options.interceptors + @options.interceptors).select do |i|
-        i.is_a?(Interceptor::Activity)
-      end
-      @workflow_interceptors = (@options.client.options.interceptors + @options.interceptors).select do |i|
-        i.is_a?(Interceptor::Workflow)
-      end
+      @activity_interceptors = (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Activity)
+      @workflow_interceptors = (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Workflow)
 
       # Cancellation for the whole worker
       @worker_shutdown_cancellation = Cancellation.new

data/lib/temporalio/worker_deployment_version.rb

@@ -9,8 +9,6 @@ module Temporalio
   )
 
   # Represents the version of a specific worker deployment.
-  #
-  # WARNING: Experimental API.
   class WorkerDeploymentVersion
     # Parse a version from a canonical string, which must be in the format
     # `<deployment_name>.<build_id>`. Deployment name must not have a `.` in it.