temporalio 1.1.0 → 1.3.0

data/lib/temporalio/worker.rb

@@ -15,6 +15,7 @@ require 'temporalio/worker/activity_executor'
 require 'temporalio/worker/deployment_options'
 require 'temporalio/worker/illegal_workflow_call_validator'
 require 'temporalio/worker/interceptor'
+require 'temporalio/worker/plugin'
 require 'temporalio/worker/poller_behavior'
 require 'temporalio/worker/thread_pool'
 require 'temporalio/worker/tuner'
@@ -35,6 +36,7 @@ module Temporalio
       :tuner,
       :activity_executors,
       :workflow_executor,
+      :plugins,
       :interceptors,
       :identity,
       :logger,
@@ -122,6 +124,42 @@ module Temporalio
       raise_in_block_on_shutdown: Error::CanceledError.new('Workers finished'),
       wait_block_complete: true,
       &block
+    )
+      # We have to apply plugins. However, every plugin has a different worker. So we provide them the worker along with
+      # other options, but we disregard any mutation of the worker on the next call.
+      run_worker = proc do |options|
+        # @type var options: Plugin::RunWorkerOptions
+        _run_all_root(*workers,
+                      cancellation: options.cancellation,
+                      shutdown_signals: options.shutdown_signals,
+                      raise_in_block_on_shutdown: options.raise_in_block_on_shutdown,
+                      wait_block_complete:, &block)
+      end
+      plugins_with_workers = workers.flat_map { |w| w._plugins.map { |p| [p, w] } }
+      run_worker = plugins_with_workers.reverse_each.reduce(run_worker) do |next_call, plugin_with_worker|
+        plugin, worker = plugin_with_worker
+        proc do |options|
+          plugin.run_worker(options.with(worker:), next_call) # steep:ignore
+        end
+      end
+
+      run_worker.call(Plugin::RunWorkerOptions.new(
+        # Intentionally violating typing here because we set this on each call
+        worker: nil, # steep:ignore
+        cancellation:,
+        shutdown_signals:,
+        raise_in_block_on_shutdown:
+      ))
+    end
+
+    # @!visibility private
+    def self._run_all_root(
+      *workers,
+      cancellation:,
+      shutdown_signals:,
+      raise_in_block_on_shutdown:,
+      wait_block_complete:,
+      &block
     )
       # Confirm there is at least one and they are all workers
       raise ArgumentError, 'At least one worker required' if workers.empty?
@@ -301,6 +339,19 @@ module Temporalio
       end
     end
 
+    # @!visibility private
+    def self._validate_plugins!(plugins)
+      plugins.each do |plugin|
+        raise ArgumentError, "#{plugin.class} does not implement Worker::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 worker plugin method(s): #{missing.join(', ')}"
+        end
+      end
+    end
+
     # @return [Options] Options for this worker which has the same attributes as {initialize}.
     attr_reader :options
 
@@ -315,6 +366,9 @@ module Temporalio
     # @param activity_executors [Hash<Symbol, Worker::ActivityExecutor>] Executors that activities can run within.
     # @param workflow_executor [WorkflowExecutor] Workflow executor that workflow tasks run within. This must be a
     #   {WorkflowExecutor::ThreadPool} currently.
+    # @param plugins [Array<Plugin>] Plugins to use for configuring workers and intercepting the running of workers. Any
+    #   plugins that were set on the client that include {Plugin} will automatically be applied to the worker and
+    #   should not be configured explicitly via this option. WARNING: Plugins are experimental.
     # @param interceptors [Array<Interceptor::Activity, Interceptor::Workflow>] Interceptors specific to this worker.
     #   Note, interceptors set on the client that include the {Interceptor::Activity} or {Interceptor::Workflow} module
     #   are automatically included here, so no need to specify them again.
@@ -371,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
@@ -387,6 +440,7 @@ module Temporalio
       tuner: Tuner.create_fixed,
       activity_executors: ActivityExecutor.defaults,
       workflow_executor: WorkflowExecutor::ThreadPool.default,
+      plugins: [],
       interceptors: [],
       identity: nil,
       logger: client.options.logger,
@@ -411,8 +465,6 @@ module Temporalio
       activity_task_poller_behavior: PollerBehavior::SimpleMaximum.new(max_concurrent_activity_task_polls),
       debug_mode: %w[true 1].include?(ENV['TEMPORAL_DEBUG'].to_s.downcase)
     )
-      raise ArgumentError, 'Must have at least one activity or workflow' if activities.empty? && workflows.empty?
-
       Internal::ProtoUtils.assert_non_reserved_name(task_queue)
 
       @options = Options.new(
@@ -423,6 +475,7 @@ module Temporalio
         tuner:,
         activity_executors:,
         workflow_executor:,
+        plugins:,
         interceptors:,
         identity:,
         logger:,
@@ -447,53 +500,68 @@ module Temporalio
         activity_task_poller_behavior:,
         debug_mode:
       ).freeze
+      # Collect applicable client plugins and worker plugins, then validate and apply to options
+      @plugins = client.options.plugins.grep(Plugin) + plugins
+      Worker._validate_plugins!(@plugins)
+      @options = @plugins.reduce(@options) { |options, plugin| plugin.configure_worker(options) }
+      # Initialize the worker for the given options
+      _initialize_from_options
+    end
+
+    # @!visibility private
+    def _initialize_from_options
+      if @options.activities.empty? && @options.workflows.empty?
+        raise ArgumentError, 'Must have at least one activity or workflow'
+      end
 
       should_enforce_versioning_behavior =
-        deployment_options.use_worker_versioning &&
-        deployment_options.default_versioning_behavior == VersioningBehavior::UNSPECIFIED
+        @options.deployment_options.use_worker_versioning &&
+        @options.deployment_options.default_versioning_behavior == VersioningBehavior::UNSPECIFIED
       # Preload workflow definitions and some workflow settings for the bridge
       workflow_definitions = Internal::Worker::WorkflowWorker.workflow_definitions(
-        workflows,
-        should_enforce_versioning_behavior: should_enforce_versioning_behavior
+        @options.workflows,
+        should_enforce_versioning_behavior:
       )
       nondeterminism_as_workflow_fail, nondeterminism_as_workflow_fail_for_types =
         Internal::Worker::WorkflowWorker.bridge_workflow_failure_exception_type_options(
-          workflow_failure_exception_types:, workflow_definitions:
+          workflow_failure_exception_types: @options.workflow_failure_exception_types,
+          workflow_definitions:
         )
 
       # Create the bridge worker
       @bridge_worker = Internal::Bridge::Worker.new(
-        client.connection._core_client,
+        @options.client.connection._core_client,
         Internal::Bridge::Worker::Options.new(
-          namespace: client.namespace,
-          task_queue:,
-          tuner: tuner._to_bridge_options,
-          identity_override: identity,
-          max_cached_workflows:,
-          workflow_task_poller_behavior: workflow_task_poller_behavior._to_bridge_options,
-          nonsticky_to_sticky_poll_ratio:,
-          activity_task_poller_behavior: activity_task_poller_behavior._to_bridge_options,
-          enable_workflows: !workflows.empty?,
-          enable_local_activities: !workflows.empty? && !activities.empty?,
-          enable_remote_activities: !activities.empty? && !no_remote_activities,
+          namespace: @options.client.namespace,
+          task_queue: @options.task_queue,
+          tuner: @options.tuner._to_bridge_options,
+          identity_override: @options.identity,
+          max_cached_workflows: @options.max_cached_workflows,
+          workflow_task_poller_behavior: @options.workflow_task_poller_behavior._to_bridge_options,
+          nonsticky_to_sticky_poll_ratio: @options.nonsticky_to_sticky_poll_ratio,
+          activity_task_poller_behavior: @options.activity_task_poller_behavior._to_bridge_options,
+          enable_workflows: !@options.workflows.empty?,
+          enable_local_activities: !@options.workflows.empty? && !@options.activities.empty?,
+          enable_remote_activities: !@options.activities.empty? && !@options.no_remote_activities,
           enable_nexus: false,
-          sticky_queue_schedule_to_start_timeout:,
-          max_heartbeat_throttle_interval:,
-          default_heartbeat_throttle_interval:,
-          max_worker_activities_per_second: max_activities_per_second,
-          max_task_queue_activities_per_second:,
-          graceful_shutdown_period:,
+          sticky_queue_schedule_to_start_timeout: @options.sticky_queue_schedule_to_start_timeout,
+          max_heartbeat_throttle_interval: @options.max_heartbeat_throttle_interval,
+          default_heartbeat_throttle_interval: @options.default_heartbeat_throttle_interval,
+          max_worker_activities_per_second: @options.max_activities_per_second,
+          max_task_queue_activities_per_second: @options.max_task_queue_activities_per_second,
+          graceful_shutdown_period: @options.graceful_shutdown_period,
           nondeterminism_as_workflow_fail:,
           nondeterminism_as_workflow_fail_for_types:,
-          deployment_options: deployment_options._to_bridge_options
+          deployment_options: @options.deployment_options._to_bridge_options,
+          plugins: (@options.client.options.plugins + @options.plugins).map(&:name).uniq.sort
         )
       )
 
       # Collect interceptors from client and params
-      @activity_interceptors = (client.options.interceptors + interceptors).select do |i|
+      @activity_interceptors = (@options.client.options.interceptors + @options.interceptors).select do |i|
         i.is_a?(Interceptor::Activity)
       end
-      @workflow_interceptors = (client.options.interceptors + interceptors).select do |i|
+      @workflow_interceptors = (@options.client.options.interceptors + @options.interceptors).select do |i|
         i.is_a?(Interceptor::Workflow)
       end
 
@@ -501,27 +569,27 @@ module Temporalio
       @worker_shutdown_cancellation = Cancellation.new
 
       # Create workers
-      unless activities.empty?
+      unless @options.activities.empty?
         @activity_worker = Internal::Worker::ActivityWorker.new(worker: self,
                                                                 bridge_worker: @bridge_worker)
       end
-      unless workflows.empty?
+      unless @options.workflows.empty?
         @workflow_worker = Internal::Worker::WorkflowWorker.new(
           bridge_worker: @bridge_worker,
-          namespace: client.namespace,
-          task_queue:,
+          namespace: @options.client.namespace,
+          task_queue: @options.task_queue,
           workflow_definitions:,
-          workflow_executor:,
-          logger:,
-          data_converter: client.data_converter,
-          metric_meter: client.connection.options.runtime.metric_meter,
+          workflow_executor: @options.workflow_executor,
+          logger: @options.logger,
+          data_converter: @options.client.data_converter,
+          metric_meter: @options.client.connection.options.runtime.metric_meter,
           workflow_interceptors: @workflow_interceptors,
-          disable_eager_activity_execution:,
-          illegal_workflow_calls:,
-          workflow_failure_exception_types:,
-          workflow_payload_codec_thread_pool:,
-          unsafe_workflow_io_enabled:,
-          debug_mode:,
+          disable_eager_activity_execution: @options.disable_eager_activity_execution,
+          illegal_workflow_calls: @options.illegal_workflow_calls,
+          workflow_failure_exception_types: @options.workflow_failure_exception_types,
+          workflow_payload_codec_thread_pool: @options.workflow_payload_codec_thread_pool,
+          unsafe_workflow_io_enabled: @options.unsafe_workflow_io_enabled,
+          debug_mode: @options.debug_mode,
           assert_valid_local_activity: ->(activity) { _assert_valid_local_activity(activity) }
         )
       end
@@ -643,5 +711,10 @@ module Temporalio
             "Activity #{activity} " \
             'is not registered on this worker, no available activities.'
     end
+
+    # @!visibility private
+    def _plugins
+      @plugins
+    end
   end
 end

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.

data/lib/temporalio/workflow/definition.rb

@@ -102,14 +102,14 @@ module Temporalio
 
             # Just run this as if done manually
             workflow_query(description:)
-            define_method(attr_name) { instance_variable_get("@#{attr_name}") }
+            define_method(attr_name) do
+              instance_variable_get("@#{attr_name}") # steep:ignore NoMethod
+            end
           end
         end
 
         # Set the versioning behavior of this workflow.
         #
-        # WARNING: This method is experimental and may change in future versions.
-        #
         # @param behavior [VersioningBehavior] The versioning behavior.
         def workflow_versioning_behavior(behavior)
           @versioning_behavior = behavior
@@ -730,7 +730,6 @@ module Temporalio
     # @!attribute versioning_behavior
     #   Dynamic equivalent of {Definition.workflow_versioning_behavior}.
     #   Will override any behavior set there if set.
-    #   WARNING: Deployment-based versioning is experimental and APIs may change.
     #   @return [VersioningBehavior, nil] The versioning behavior
     #
     # @return [VersioningBehavior, nil] The versioning behavior

data/lib/temporalio/workflow/nexus_client.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Workflow
+    # Client for executing Nexus operations from workflows.
+    #
+    # This is created via {Workflow.create_nexus_client}, it is never instantiated directly.
+    #
+    # WARNING: Nexus support is experimental.
+    class NexusClient
+      # @!visibility private
+      def initialize
+        raise NotImplementedError, 'Cannot instantiate a Nexus client directly'
+      end
+
+      # @return [String] Endpoint name for this client.
+      def endpoint
+        raise NotImplementedError
+      end
+
+      # @return [String] Service name for this client.
+      def service
+        raise NotImplementedError
+      end
+
+      # Start a Nexus operation and return a handle.
+      #
+      # @param operation [Symbol, String] Operation name.
+      # @param arg [Object] Argument for the operation.
+      # @param schedule_to_close_timeout [Float, nil] Total timeout for the operation in seconds.
+      # @param cancellation_type [NexusOperationCancellationType] How the operation will react to cancellation.
+      # @param summary [String, nil] Optional summary for the operation (appears in UI/CLI).
+      # @param cancellation [Cancellation] Cancellation for the operation.
+      # @param arg_hint [Object, nil] Converter hint for the argument.
+      # @param result_hint [Object, nil] Converter hint for the result.
+      # @return [NexusOperationHandle] Handle to the started operation.
+      def start_operation(
+        operation,
+        arg,
+        schedule_to_close_timeout: nil,
+        cancellation_type: NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED,
+        summary: nil,
+        cancellation: Workflow.cancellation,
+        arg_hint: nil,
+        result_hint: nil
+      )
+        raise NotImplementedError
+      end
+
+      # Execute a Nexus operation and wait for the result.
+      #
+      # This is a convenience method that calls {#start_operation} and immediately waits for the result.
+      #
+      # @param operation [Symbol, String] Operation name.
+      # @param arg [Object] Argument for the operation.
+      # @param schedule_to_close_timeout [Float, nil] Total timeout for the operation in seconds.
+      # @param cancellation_type [NexusOperationCancellationType] How the operation will react to cancellation.
+      # @param summary [String, nil] Optional summary for the operation (appears in UI/CLI).
+      # @param cancellation [Cancellation] Cancellation for the operation.
+      # @param arg_hint [Object, nil] Converter hint for the argument.
+      # @param result_hint [Object, nil] Converter hint for the result.
+      # @return [Object] Result of the operation.
+      # @raise [Error::NexusOperationError] Operation failed.
+      def execute_operation(
+        operation,
+        arg,
+        schedule_to_close_timeout: nil,
+        cancellation_type: NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED,
+        summary: nil,
+        cancellation: Workflow.cancellation,
+        arg_hint: nil,
+        result_hint: nil
+      )
+        start_operation(
+          operation, arg, schedule_to_close_timeout:, cancellation_type:, summary:, cancellation:,
+                          arg_hint:, result_hint:
+        ).result
+      end
+    end
+  end
+end

data/lib/temporalio/workflow/nexus_operation_cancellation_type.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'temporalio/internal/bridge/api'
+
+module Temporalio
+  module Workflow
+    # How a Nexus operation should handle cancellation.
+    #
+    # WARNING: Nexus support is experimental.
+    module NexusOperationCancellationType
+      # Wait for cancellation to complete (default).
+      WAIT_CANCELLATION_COMPLETED = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED
+      # Abandon the operation without sending a cancellation request.
+      ABANDON = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::ABANDON
+      # Send a cancellation request but do not wait for confirmation.
+      TRY_CANCEL = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::TRY_CANCEL
+      # Wait for the server to confirm the cancellation request was delivered.
+      WAIT_CANCELLATION_REQUESTED = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_REQUESTED
+    end
+  end
+end

data/lib/temporalio/workflow/nexus_operation_handle.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Workflow
+    # Handle for interacting with a Nexus operation.
+    #
+    # This is created via {NexusClient#start_operation}, it is never instantiated directly.
+    #
+    # WARNING: Nexus support is experimental.
+    class NexusOperationHandle
+      # @!visibility private
+      def initialize
+        raise NotImplementedError, 'Cannot instantiate a Nexus operation handle directly'
+      end
+
+      # @return [String, nil] Operation token for async operations, nil for sync operations.
+      def operation_token
+        raise NotImplementedError
+      end
+
+      # @return [Object, nil] Hint for the result if any.
+      def result_hint
+        raise NotImplementedError
+      end
+
+      # Wait for the result.
+      #
+      # @param result_hint [Object, nil] Override the result hint, or if nil uses the one on the handle.
+      # @return [Object] Result of the Nexus operation.
+      #
+      # @raise [Error::NexusOperationError] Operation failed with +cause+ as the cause.
+      def result(result_hint: nil)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/workflow.rb

@@ -12,6 +12,9 @@ require 'temporalio/workflow/external_workflow_handle'
 require 'temporalio/workflow/future'
 require 'temporalio/workflow/handler_unfinished_policy'
 require 'temporalio/workflow/info'
+require 'temporalio/workflow/nexus_client'
+require 'temporalio/workflow/nexus_operation_cancellation_type'
+require 'temporalio/workflow/nexus_operation_handle'
 require 'temporalio/workflow/parent_close_policy'
 require 'temporalio/workflow/update_info'
 require 'timeout'
@@ -40,6 +43,17 @@ module Temporalio
       _current.continue_as_new_suggested
     end
 
+    # Create a Nexus client for executing operations.
+    #
+    # WARNING: Nexus support is experimental.
+    #
+    # @param endpoint [Symbol, String] Endpoint name.
+    # @param service [Symbol, String] Service name.
+    # @return [NexusClient] Client for executing Nexus operations.
+    def self.create_nexus_client(endpoint:, service:)
+      _current.create_nexus_client(endpoint:, service:)
+    end
+
     # Get current details for this workflow that may appear in UI/CLI. Unlike static details set at start, this value
     # can be updated throughout the life of the workflow. This can be in Temporal markdown format and can span multiple
     # lines. This is currently experimental.
@@ -533,11 +547,18 @@ module Temporalio
     # Unsafe module contains only-in-workflow methods that are considered unsafe. These should not be used unless the
     # consequences are understood.
     module Unsafe
-      # @return [Boolean] True if the workflow is replaying, false otherwise. Most code should not check this value.
+      # @return [Boolean] True if the workflow is replaying (including during queries and update validators), false
+      #   otherwise. Most code should not check this value.
       def self.replaying?
         Workflow._current.replaying?
       end
 
+      # @return [Boolean] True if the workflow is replaying history events (excluding queries and update validators),
+      #   false otherwise. Most code should not check this value.
+      def self.replaying_history_events?
+        Workflow._current.replaying_history_events?
+      end
+
       # Run a block of code with illegal call tracing disabled. Users should be cautious about using this as it can
       # often signify unsafe code.
       #

data/temporalio.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.extensions = ['ext/Cargo.toml']
   spec.metadata['rubygems_mfa_required'] = 'true'
-  spec.required_ruby_version = '>= 3.2.0'
+  spec.required_ruby_version = '>= 3.3.0'
 
   spec.add_dependency 'google-protobuf', '>= 3.25.0'
   spec.add_dependency 'logger'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: temporalio
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Temporal Technologies Inc
@@ -79,6 +79,7 @@ files:
 - lib/temporalio/api/common/v1/grpc_status.rb
 - lib/temporalio/api/common/v1/message.rb
 - lib/temporalio/api/deployment/v1/message.rb
+- lib/temporalio/api/enums/v1/activity.rb
 - lib/temporalio/api/enums/v1/batch_operation.rb
 - lib/temporalio/api/enums/v1/command_type.rb
 - lib/temporalio/api/enums/v1/common.rb
@@ -135,6 +136,7 @@ files:
 - lib/temporalio/client/connection/test_service.rb
 - lib/temporalio/client/connection/workflow_service.rb
 - lib/temporalio/client/interceptor.rb
+- lib/temporalio/client/plugin.rb
 - lib/temporalio/client/schedule.rb
 - lib/temporalio/client/schedule_handle.rb
 - lib/temporalio/client/with_start_workflow_operation.rb
@@ -195,6 +197,8 @@ files:
 - lib/temporalio/internal/worker/workflow_instance/handler_hash.rb
 - lib/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rb
 - lib/temporalio/internal/worker/workflow_instance/inbound_implementation.rb
+- lib/temporalio/internal/worker/workflow_instance/nexus_client.rb
+- lib/temporalio/internal/worker/workflow_instance/nexus_operation_handle.rb
 - lib/temporalio/internal/worker/workflow_instance/outbound_implementation.rb
 - lib/temporalio/internal/worker/workflow_instance/replay_safe_logger.rb
 - lib/temporalio/internal/worker/workflow_instance/replay_safe_metric.rb
@@ -207,6 +211,7 @@ files:
 - lib/temporalio/runtime/metric_buffer.rb
 - lib/temporalio/scoped_logger.rb
 - lib/temporalio/search_attributes.rb
+- lib/temporalio/simple_plugin.rb
 - lib/temporalio/testing.rb
 - lib/temporalio/testing/activity_environment.rb
 - lib/temporalio/testing/workflow_environment.rb
@@ -219,6 +224,7 @@ files:
 - lib/temporalio/worker/deployment_options.rb
 - lib/temporalio/worker/illegal_workflow_call_validator.rb
 - lib/temporalio/worker/interceptor.rb
+- lib/temporalio/worker/plugin.rb
 - lib/temporalio/worker/poller_behavior.rb
 - lib/temporalio/worker/thread_pool.rb
 - lib/temporalio/worker/tuner.rb
@@ -235,6 +241,9 @@ files:
 - lib/temporalio/workflow/future.rb
 - lib/temporalio/workflow/handler_unfinished_policy.rb
 - lib/temporalio/workflow/info.rb
+- lib/temporalio/workflow/nexus_client.rb
+- lib/temporalio/workflow/nexus_operation_cancellation_type.rb
+- lib/temporalio/workflow/nexus_operation_handle.rb
 - lib/temporalio/workflow/parent_close_policy.rb
 - lib/temporalio/workflow/update_info.rb
 - lib/temporalio/workflow_history.rb
@@ -253,14 +262,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Temporal.io Ruby SDK
 test_files: []