temporalio 0.3.0-x86_64-linux → 0.4.0-x86_64-linux

data/lib/temporalio/worker.rb

@@ -6,6 +6,7 @@ require 'temporalio/client'
 require 'temporalio/error'
 require 'temporalio/internal/bridge'
 require 'temporalio/internal/bridge/worker'
+require 'temporalio/internal/proto_utils'
 require 'temporalio/internal/worker/activity_worker'
 require 'temporalio/internal/worker/multi_runner'
 require 'temporalio/internal/worker/workflow_instance'
@@ -51,10 +52,13 @@ module Temporalio
       :illegal_workflow_calls,
       :workflow_failure_exception_types,
       :workflow_payload_codec_thread_pool,
+      :unsafe_workflow_io_enabled,
       :debug_mode
     )
 
     # Options as returned from {options} for `**to_h` splat use in {initialize}. See {initialize} for details.
+    #
+    # Note, the `client` within can be replaced via client setter.
     class Options; end # rubocop:disable Lint/EmptyClass
 
     # @return [String] Memoized default build ID. This default value is built as a checksum of all of the loaded Ruby
@@ -137,7 +141,8 @@ module Temporalio
         case event
         when Internal::Worker::MultiRunner::Event::PollSuccess
           # Successful poll
-          event.worker._on_poll_bytes(runner, event.worker_type, event.bytes)
+          event.worker #: Worker
+               ._on_poll_bytes(runner, event.worker_type, event.bytes)
         when Internal::Worker::MultiRunner::Event::PollFailure
           # Poll failure, this causes shutdown of all workers
           logger.error('Poll failure (beginning worker shutdown if not already occurring)')
@@ -274,7 +279,7 @@ module Temporalio
       end
     end
 
-    # @return [Options] Frozen options for this client which has the same attributes as {initialize}.
+    # @return [Options] Options for this worker which has the same attributes as {initialize}.
     attr_reader :options
 
     # Create a new worker. At least one activity or workflow must be present.
@@ -343,6 +348,9 @@ module Temporalio
     # @param workflow_payload_codec_thread_pool [ThreadPool, nil] Thread pool to run payload codec encode/decode within.
     #   This is required if a payload codec exists and the worker is not fiber based. Codecs can potentially block
     #   execution which is why they need to be run in the background.
+    # @param unsafe_workflow_io_enabled [Boolean] If false, the default, workflow code that invokes io_wait on the fiber
+    #   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 debug_mode [Boolean] If true, deadlock detection is disabled. Deadlock detection will fail workflow tasks
     #   if they block the thread for too long. This defaults to true if the `TEMPORAL_DEBUG` environment variable is
     #   `true` or `1`.
@@ -374,10 +382,13 @@ module Temporalio
       illegal_workflow_calls: Worker.default_illegal_workflow_calls,
       workflow_failure_exception_types: [],
       workflow_payload_codec_thread_pool: nil,
+      unsafe_workflow_io_enabled: false,
       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(
         client:,
         task_queue:,
@@ -406,24 +417,16 @@ module Temporalio
         illegal_workflow_calls:,
         workflow_failure_exception_types:,
         workflow_payload_codec_thread_pool:,
+        unsafe_workflow_io_enabled:,
         debug_mode:
       ).freeze
 
       # Preload workflow definitions and some workflow settings for the bridge
       workflow_definitions = Internal::Worker::WorkflowWorker.workflow_definitions(workflows)
-      nondeterminism_as_workflow_fail = workflow_failure_exception_types.any? do |t|
-        t.is_a?(Class) && t >= Workflow::NondeterminismError
-      end
-      nondeterminism_as_workflow_fail_for_types = workflow_definitions.values.map do |defn|
-        next unless defn.failure_exception_types.any? { |t| t.is_a?(Class) && t >= Workflow::NondeterminismError }
-
-        # If they tried to do this on a dynamic workflow and haven't already set worker-level option, warn
-        unless defn.name || nondeterminism_as_workflow_fail
-          warn('Note, dynamic workflows cannot trap non-determinism errors, so worker-level ' \
-               'workflow_failure_exception_types should be set to capture that if that is the intention')
-        end
-        defn.name
-      end.compact
+      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:
+        )
 
       # Create the bridge worker
       @bridge_worker = Internal::Bridge::Worker.new(
@@ -433,11 +436,7 @@ module Temporalio
           workflow: !workflows.empty?,
           namespace: client.namespace,
           task_queue:,
-          tuner: Internal::Bridge::Worker::TunerOptions.new(
-            workflow_slot_supplier: to_bridge_slot_supplier_options(tuner.workflow_slot_supplier),
-            activity_slot_supplier: to_bridge_slot_supplier_options(tuner.activity_slot_supplier),
-            local_activity_slot_supplier: to_bridge_slot_supplier_options(tuner.local_activity_slot_supplier)
-          ),
+          tuner: tuner._to_bridge_options,
           build_id:,
           identity_override: identity,
           max_cached_workflows:,
@@ -476,13 +475,30 @@ module Temporalio
                                                                 bridge_worker: @bridge_worker)
       end
       unless workflows.empty?
-        @workflow_worker = Internal::Worker::WorkflowWorker.new(worker: self,
-                                                                bridge_worker: @bridge_worker,
-                                                                workflow_definitions:)
+        @workflow_worker = Internal::Worker::WorkflowWorker.new(
+          bridge_worker: @bridge_worker,
+          namespace: client.namespace,
+          task_queue:,
+          workflow_definitions:,
+          workflow_executor:,
+          logger:,
+          data_converter: client.data_converter,
+          metric_meter: 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:
+        )
       end
 
       # Validate worker
       @bridge_worker.validate
+
+      # Mutex needed for accessing and replacing a client
+      @client_mutex = Mutex.new
     end
 
     # @return [String] Task queue set on the worker options.
@@ -490,6 +506,25 @@ module Temporalio
       @options.task_queue
     end
 
+    # @return [Client] Client for this worker. This is the same as {Options.client} in {options}, but surrounded by a
+    #   mutex to be safe for client replacement in {client=}.
+    def client
+      @client_mutex.synchronize { @options.client }
+    end
+
+    # Replace the worker's client. When this is called, the client is replaced on the internal worker which means any
+    # new calls will be made on the new client (but existing calls will still complete on the previous one). This is
+    # commonly used for providing a new client with updated authentication credentials.
+    #
+    # @param new_client [Client] New client to use for new calls.
+    def client=(new_client)
+      @client_mutex.synchronize do
+        @bridge_worker.replace_client(new_client.connection._core_client)
+        @options = @options.with(client: new_client)
+        new_client
+      end
+    end
+
     # Run this worker until cancellation or optional block completes. When the cancellation or block is complete, the
     # worker is shut down. This will return the block result if everything successful or raise an error if not.
     #
@@ -543,11 +578,6 @@ module Temporalio
       @activity_interceptors
     end
 
-    # @!visibility private
-    def _workflow_interceptors
-      @workflow_interceptors
-    end
-
     # @!visibility private
     def _on_poll_bytes(runner, worker_type, bytes)
       case worker_type
@@ -569,29 +599,5 @@ module Temporalio
       @workflow_worker&.on_shutdown_complete
       @workflow_worker = nil
     end
-
-    private
-
-    def to_bridge_slot_supplier_options(slot_supplier)
-      if slot_supplier.is_a?(Tuner::SlotSupplier::Fixed)
-        Internal::Bridge::Worker::TunerSlotSupplierOptions.new(
-          fixed_size: slot_supplier.slots,
-          resource_based: nil
-        )
-      elsif slot_supplier.is_a?(Tuner::SlotSupplier::ResourceBased)
-        Internal::Bridge::Worker::TunerSlotSupplierOptions.new(
-          fixed_size: nil,
-          resource_based: Internal::Bridge::Worker::TunerResourceBasedSlotSupplierOptions.new(
-            target_mem_usage: slot_supplier.tuner_options.target_memory_usage,
-            target_cpu_usage: slot_supplier.tuner_options.target_cpu_usage,
-            min_slots: slot_supplier.slot_options.min_slots,
-            max_slots: slot_supplier.slot_options.max_slots,
-            ramp_throttle: slot_supplier.slot_options.ramp_throttle
-          )
-        )
-      else
-        raise ArgumentError, 'Tuner slot suppliers must be instances of Fixed or ResourceBased'
-      end
-    end
   end
 end

data/lib/temporalio/workflow/definition.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/proto_utils'
 require 'temporalio/workflow'
 require 'temporalio/workflow/handler_unfinished_policy'
 
@@ -71,7 +72,9 @@ module Temporalio
         # `attr_accessor`. If a writer is needed alongside this, use `attr_writer`.
         #
         # @param attr_names [Array<Symbol>] Attributes to expose.
-        def workflow_query_attr_reader(*attr_names)
+        # @param description [String, nil] Description that may appear in CLI/UI, applied to each query handler
+        #   implicitly created. This is currently experimental.
+        def workflow_query_attr_reader(*attr_names, description: nil)
           @workflow_queries ||= {}
           attr_names.each do |attr_name|
             raise 'Expected attr to be a symbol' unless attr_name.is_a?(Symbol)
@@ -83,7 +86,7 @@ module Temporalio
             end
 
             # Just run this as if done manually
-            workflow_query
+            workflow_query(description:)
             define_method(attr_name) { instance_variable_get("@#{attr_name}") }
           end
         end
@@ -100,6 +103,8 @@ module Temporalio
         # values.
         #
         # @param name [String, Symbol, nil] Override the default name.
+        # @param description [String, nil] Description for this handler that may appear in CLI/UI. This is currently
+        #   experimental.
         # @param dynamic [Boolean] If true, make the signal dynamic. This means it receives all other signals without
         #   handlers. This cannot have a name override since it is nameless. The first parameter will be the name. Often
         #   it is useful to have the second parameter be `*args` and `raw_args` be true.
@@ -109,19 +114,22 @@ module Temporalio
         #   when the workflow ends. The default warns, but this can be disabled.
         def workflow_signal(
           name: nil,
+          description: nil,
           dynamic: false,
           raw_args: false,
           unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON
         )
           raise 'Cannot provide name if dynamic is true' if name && dynamic
 
-          self.pending_handler_details = { type: :signal, name:, dynamic:, raw_args:, unfinished_policy: }
+          self.pending_handler_details = { type: :signal, name:, description:, dynamic:, raw_args:, unfinished_policy: }
         end
 
         # Mark the next method as a workflow query with a default name as the name of the method. Queries can not have
         # any side effects, meaning they should never mutate state or try to wait on anything.
         #
         # @param name [String, Symbol, nil] Override the default name.
+        # @param description [String, nil] Description for this handler that may appear in CLI/UI. This is currently
+        #   experimental.
         # @param dynamic [Boolean] If true, make the query dynamic. This means it receives all other queries without
         #   handlers. This cannot have a name override since it is nameless. The first parameter will be the name. Often
         #   it is useful to have the second parameter be `*args` and `raw_args` be true.
@@ -129,18 +137,21 @@ module Temporalio
         #   {Converters::RawValue} which is a raw payload wrapper, convertible with {Workflow.payload_converter}.
         def workflow_query(
           name: nil,
+          description: nil,
           dynamic: false,
           raw_args: false
         )
           raise 'Cannot provide name if dynamic is true' if name && dynamic
 
-          self.pending_handler_details = { type: :query, name:, dynamic:, raw_args: }
+          self.pending_handler_details = { type: :query, name:, description:, dynamic:, raw_args: }
         end
 
         # Mark the next method as a workflow update with a default name as the name of the method. Updates can return
         # values. Separate validation methods can be provided via {workflow_update_validator}.
         #
         # @param name [String, Symbol, nil] Override the default name.
+        # @param description [String, nil] Description for this handler that may appear in CLI/UI. This is currently
+        #   experimental.
         # @param dynamic [Boolean] If true, make the update dynamic. This means it receives all other updates without
         #   handlers. This cannot have a name override since it is nameless. The first parameter will be the name. Often
         #   it is useful to have the second parameter be `*args` and `raw_args` be true.
@@ -150,13 +161,14 @@ module Temporalio
         #   when the workflow ends. The default warns, but this can be disabled.
         def workflow_update(
           name: nil,
+          description: nil,
           dynamic: false,
           raw_args: false,
           unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON
         )
           raise 'Cannot provide name if dynamic is true' if name && dynamic
 
-          self.pending_handler_details = { type: :update, name:, dynamic:, raw_args:, unfinished_policy: }
+          self.pending_handler_details = { type: :update, name:, description:, dynamic:, raw_args:, unfinished_policy: }
         end
 
         # Mark the next method as a workflow update validator to the given update method. The validator is expected to
@@ -225,6 +237,7 @@ module Temporalio
             [Signal.new(
               name: handler[:dynamic] ? nil : (handler[:name] || method_name).to_s,
               to_invoke: method_name,
+              description: handler[:description],
               raw_args: handler[:raw_args],
               unfinished_policy: handler[:unfinished_policy]
             ), @workflow_signals, [@workflow_queries, @workflow_updates]]
@@ -232,12 +245,14 @@ module Temporalio
             [Query.new(
               name: handler[:dynamic] ? nil : (handler[:name] || method_name).to_s,
               to_invoke: method_name,
+              description: handler[:description],
               raw_args: handler[:raw_args]
             ), @workflow_queries, [@workflow_signals, @workflow_updates]]
           when :update
             [Update.new(
               name: handler[:dynamic] ? nil : (handler[:name] || method_name).to_s,
               to_invoke: method_name,
+              description: handler[:description],
               raw_args: handler[:raw_args],
               unfinished_policy: handler[:unfinished_policy]
             ), @workflow_updates, [@workflow_signals, @workflow_queries]]
@@ -430,6 +445,7 @@ module Temporalio
           @signals = signals.dup.freeze
           @queries = queries.dup.freeze
           @updates = updates.dup.freeze
+          Internal::ProtoUtils.assert_non_reserved_name(name)
         end
 
         # @return [String] Workflow name.
@@ -441,7 +457,7 @@ module Temporalio
       # A signal definition. This is usually built as a result of a {Definition.workflow_signal} method, but can be
       # manually created to set at runtime on {Workflow.signal_handlers}.
       class Signal
-        attr_reader :name, :to_invoke, :raw_args, :unfinished_policy
+        attr_reader :name, :to_invoke, :description, :raw_args, :unfinished_policy
 
         # @!visibility private
         def self._name_from_parameter(signal)
@@ -460,26 +476,31 @@ module Temporalio
         #
         # @param name [String, nil] Name or nil if dynamic.
         # @param to_invoke [Symbol, Proc] Method name or proc to invoke.
+        # @param description [String, nil] Description for this handler that may appear in CLI/UI. This is currently
+        #   experimental.
         # @param raw_args [Boolean] Whether the parameters should be raw values.
         # @param unfinished_policy [HandlerUnfinishedPolicy] How the workflow reacts when this handler is still running
         #   on workflow completion.
         def initialize(
           name:,
           to_invoke:,
+          description: nil,
           raw_args: false,
           unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON
         )
           @name = name
           @to_invoke = to_invoke
+          @description = description
           @raw_args = raw_args
           @unfinished_policy = unfinished_policy
+          Internal::ProtoUtils.assert_non_reserved_name(name)
         end
       end
 
       # A query definition. This is usually built as a result of a {Definition.workflow_query} method, but can be
       # manually created to set at runtime on {Workflow.query_handlers}.
       class Query
-        attr_reader :name, :to_invoke, :raw_args
+        attr_reader :name, :to_invoke, :description, :raw_args
 
         # @!visibility private
         def self._name_from_parameter(query)
@@ -498,22 +519,27 @@ module Temporalio
         #
         # @param name [String, nil] Name or nil if dynamic.
         # @param to_invoke [Symbol, Proc] Method name or proc to invoke.
+        # @param description [String, nil] Description for this handler that may appear in CLI/UI. This is currently
+        #   experimental.
         # @param raw_args [Boolean] Whether the parameters should be raw values.
         def initialize(
           name:,
           to_invoke:,
+          description: nil,
           raw_args: false
         )
           @name = name
           @to_invoke = to_invoke
+          @description = description
           @raw_args = raw_args
+          Internal::ProtoUtils.assert_non_reserved_name(name)
         end
       end
 
       # An update definition. This is usually built as a result of a {Definition.workflow_update} method, but can be
       # manually created to set at runtime on {Workflow.update_handlers}.
       class Update
-        attr_reader :name, :to_invoke, :raw_args, :unfinished_policy, :validator_to_invoke
+        attr_reader :name, :to_invoke, :description, :raw_args, :unfinished_policy, :validator_to_invoke
 
         # @!visibility private
         def self._name_from_parameter(update)
@@ -532,6 +558,8 @@ module Temporalio
         #
         # @param name [String, nil] Name or nil if dynamic.
         # @param to_invoke [Symbol, Proc] Method name or proc to invoke.
+        # @param description [String, nil] Description for this handler that may appear in CLI/UI. This is currently
+        #   experimental.
         # @param raw_args [Boolean] Whether the parameters should be raw values.
         # @param unfinished_policy [HandlerUnfinishedPolicy] How the workflow reacts when this handler is still running
         #   on workflow completion.
@@ -539,15 +567,18 @@ module Temporalio
         def initialize(
           name:,
           to_invoke:,
+          description: nil,
           raw_args: false,
           unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON,
           validator_to_invoke: nil
         )
           @name = name
           @to_invoke = to_invoke
+          @description = description
           @raw_args = raw_args
           @unfinished_policy = unfinished_policy
           @validator_to_invoke = validator_to_invoke
+          Internal::ProtoUtils.assert_non_reserved_name(name)
         end
 
         # @!visibility private
@@ -555,6 +586,7 @@ module Temporalio
           Update.new(
             name:,
             to_invoke:,
+            description:,
             raw_args:,
             unfinished_policy:,
             validator_to_invoke:

data/lib/temporalio/workflow/future.rb

@@ -8,7 +8,7 @@ module Temporalio
     # workflows.
     class Future
       # Return a future that completes when any of the given futures complete. The returned future will return the first
-      # completed futures value or raise the first completed futures exception. To not raise the exception, see
+      # completed future's value or raise the first completed future's exception. To not raise the exception, see
       # {try_any_of}.
       #
       # @param futures [Array<Future<Object>>] Futures to wait for the first to complete.
@@ -16,7 +16,7 @@ module Temporalio
       def self.any_of(*futures)
         Future.new do
           Workflow.wait_condition(cancellation: nil) { futures.any?(&:done?) }
-          # We know a future is always returned from find, the & just helps type checker
+          # We know a future is always returned from find, the || just helps type checker
           (futures.find(&:done?) || raise).wait
         end
       end

data/lib/temporalio/workflow/info.rb

@@ -7,11 +7,13 @@ module Temporalio
       :continued_run_id,
       :cron_schedule,
       :execution_timeout,
+      :headers,
       :last_failure,
       :last_result,
       :namespace,
       :parent,
       :retry_policy,
+      :root,
       :run_id,
       :run_timeout,
       :start_time,
@@ -32,6 +34,8 @@ module Temporalio
     #   @return [String, nil] Cron schedule if applicable.
     # @!attribute execution_timeout
     #   @return [Float, nil] Execution timeout for the workflow.
+    # @!attribute headers
+    #   @return [Hash<String, Api::Common::V1::Payload>] Headers.
     # @!attribute last_failure
     #   @return [Exception, nil] Failure if this workflow run is a continuation of a failure.
     # @!attribute last_result
@@ -42,6 +46,9 @@ module Temporalio
     #   @return [ParentInfo, nil] Parent information for the workflow if this is a child.
     # @!attribute retry_policy
     #   @return [RetryPolicy, nil] Retry policy for the workflow.
+    # @!attribute root
+    #   @return [RootInfo, nil] Root information for the workflow. This is nil in pre-1.27.0 server versions or if there
+    #     is no root (i.e. the root is itself).
     # @!attribute run_id
     #   @return [String] Run ID for the workflow.
     # @!attribute run_timeout
@@ -77,6 +84,21 @@ module Temporalio
         :workflow_id,
         keyword_init: true
       )
+
+      # Information about a root of a workflow.
+      #
+      # @!attribute run_id
+      #   @return [String] Run ID for the root.
+      # @!attribute workflow_id
+      #   @return [String] Workflow ID for the root.
+      #
+      # @note WARNING: This class may have required parameters added to its constructor. Users should not instantiate
+      #   this class or it may break in incompatible ways.
+      RootInfo = Struct.new(
+        :run_id,
+        :workflow_id,
+        keyword_init: true
+      )
     end
   end
 end

data/lib/temporalio/workflow.rb

@@ -38,6 +38,24 @@ module Temporalio
       _current.continue_as_new_suggested
     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.
+    #
+    # @return [String] Current details. Default is empty string.
+    def self.current_details
+      _current.current_details
+    end
+
+    # Set 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.
+    #
+    # @param details [String] Current details. Can use empty string to unset.
+    def self.current_details=(details)
+      _current.current_details = details
+    end
+
     # @return [Integer] Current number of events in history. This value is the current history event count up until the
     #   current task. Note, this value may not be up to date when accessed in a query.
     def self.current_history_length
@@ -77,6 +95,8 @@ module Temporalio
     # @param activity [Class<Activity::Definition>, Symbol, String] Activity definition class or activity name.
     # @param args [Array<Object>] Arguments to the activity.
     # @param task_queue [String] Task queue to run the activity on. Defaults to the current workflow's task queue.
+    # @param summary [String, nil] Single-line summary for this activity that may appear in CLI/UI. This can be in
+    #   single-line Temporal markdown format. This is currently experimental.
     # @param schedule_to_close_timeout [Float, nil] Max amount of time the activity can take from first being scheduled
     #   to being completed before it times out. This is inclusive of all retries.
     # @param schedule_to_start_timeout [Float, nil] Max amount of time the activity can take to be started from first
@@ -107,6 +127,7 @@ module Temporalio
       activity,
       *args,
       task_queue: info.task_queue,
+      summary: nil,
       schedule_to_close_timeout: nil,
       schedule_to_start_timeout: nil,
       start_to_close_timeout: nil,
@@ -119,7 +140,7 @@ module Temporalio
     )
       _current.execute_activity(
         activity, *args,
-        task_queue:, schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
+        task_queue:, summary:, schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
         heartbeat_timeout:, retry_policy:, cancellation:, cancellation_type:, activity_id:, disable_eager_execution:
       )
     end
@@ -130,6 +151,8 @@ module Temporalio
       *args,
       id: random.uuid,
       task_queue: info.task_queue,
+      static_summary: nil,
+      static_details: nil,
       cancellation: Workflow.cancellation,
       cancellation_type: ChildWorkflowCancellationType::WAIT_CANCELLATION_COMPLETED,
       parent_close_policy: ParentClosePolicy::TERMINATE,
@@ -144,8 +167,9 @@ module Temporalio
     )
       start_child_workflow(
         workflow, *args,
-        id:, task_queue:, cancellation:, cancellation_type:, parent_close_policy:, execution_timeout:, run_timeout:,
-        task_timeout:, id_reuse_policy:, retry_policy:, cron_schedule:, memo:, search_attributes:
+        id:, task_queue:, static_summary:, static_details:, cancellation:, cancellation_type:,
+        parent_close_policy:, execution_timeout:, run_timeout:, task_timeout:, id_reuse_policy:,
+        retry_policy:, cron_schedule:, memo:, search_attributes:
       ).result
     end
 
@@ -220,6 +244,12 @@ module Temporalio
       _current.info
     end
 
+    # @return [Definition, nil] Workflow class instance. This should always be present except in
+    #   {Worker::Interceptor::Workflow::Inbound.init} where it will be nil.
+    def self.instance
+      _current.instance
+    end
+
     # @return [Logger] Logger for the workflow. This is a scoped logger that automatically appends workflow details to
     #   every log and takes care not to log during replay.
     def self.logger
@@ -298,7 +328,7 @@ module Temporalio
     #   value cannot be negative. Since Temporal timers are server-side, timer resolution may not end up as precise as
     #   system timers.
     # @param summary [String, nil] A simple string identifying this timer that may be visible in UI/CLI. While it can be
-    #   normal text, it is best to treat as a timer ID.
+    #   normal text, it is best to treat as a timer ID. This is currently experimental.
     # @param cancellation [Cancellation] Cancellation for this timer.
     # @raise [Error::CanceledError] Sleep canceled.
     def self.sleep(duration, summary: nil, cancellation: Workflow.cancellation)
@@ -311,6 +341,12 @@ module Temporalio
     # @param args [Array<Object>] Arguments to the workflow.
     # @param id [String] Unique identifier for the workflow execution. Defaults to a new UUID from {random}.
     # @param task_queue [String] Task queue to run the workflow on. Defaults to the current workflow's task queue.
+    # @param static_summary [String, nil] Fixed single-line summary for this workflow execution that may appear in
+    #   CLI/UI. This can be in single-line Temporal markdown format. This is currently experimental.
+    # @param static_details [String, nil] Fixed details for this workflow execution that may appear in CLI/UI. This can
+    #   be in Temporal markdown format and can be multiple lines. This is a fixed value on the workflow that cannot be
+    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow. This is currently
+    #   experimental.
     # @param cancellation [Cancellation] Cancellation to apply to the child workflow. How cancellation is treated is
     #   based on `cancellation_type`. This defaults to the workflow's cancellation.
     # @param cancellation_type [ChildWorkflowCancellationType] How the child workflow will react to cancellation.
@@ -333,6 +369,8 @@ module Temporalio
       *args,
       id: random.uuid,
       task_queue: info.task_queue,
+      static_summary: nil,
+      static_details: nil,
       cancellation: Workflow.cancellation,
       cancellation_type: ChildWorkflowCancellationType::WAIT_CANCELLATION_COMPLETED,
       parent_close_policy: ParentClosePolicy::TERMINATE,
@@ -347,11 +385,18 @@ module Temporalio
     )
       _current.start_child_workflow(
         workflow, *args,
-        id:, task_queue:, cancellation:, cancellation_type:, parent_close_policy:, execution_timeout:, run_timeout:,
-        task_timeout:, id_reuse_policy:, retry_policy:, cron_schedule:, memo:, search_attributes:
+        id:, task_queue:, static_summary:, static_details:, cancellation:, cancellation_type:,
+        parent_close_policy:, execution_timeout:, run_timeout:, task_timeout:, id_reuse_policy:,
+        retry_policy:, cron_schedule:, memo:, search_attributes:
       )
     end
 
+    # @return [Hash<Object, Object>] General in-workflow storage. Most users will store state on the workflow class
+    #   instance instead, this is only for utilities without access to the class instance.
+    def self.storage
+      _current.storage
+    end
+
     # Run the block until the timeout is reached. This is backed by {sleep}. This does not accept cancellation because
     # it is expected the block within will properly handle/bubble cancellation.
     #
@@ -361,8 +406,8 @@ module Temporalio
     #   exception.
     # @param message [String] Message to use for timeout exception. Defaults to "execution expired" like
     #   {::Timeout.timeout}.
-    # @param summary [String] Timer summer for the timer created by this timeout. This is backed by {sleep} so see that
-    #   method for details.
+    # @param summary [String] Timer summary for the timer created by this timeout. This is backed by {sleep} so see that
+    #   method for details. This is currently experimental.
     #
     # @yield Block to run with a timeout.
     # @return [Object] The result of the block.
@@ -458,6 +503,13 @@ module Temporalio
       def self.illegal_call_tracing_disabled(&)
         Workflow._current.illegal_call_tracing_disabled(&)
       end
+
+      # Run a block of code with IO enabled. Specifically this allows the `io_wait` call of the fiber scheduler to work.
+      # Users should be cautious about using this as it can often signify unsafe code. Note, this is often only
+      # applicable to network code as file IO and most process-based IO does not go through scheduler `io_wait`.
+      def self.io_enabled(&)
+        Workflow._current.io_enabled(&)
+      end
     end
 
     # Error that is raised by a workflow out of the primary workflow method to issue a continue-as-new.