temporalio 0.4.0 → 0.5.0

data/lib/temporalio/workflow/definition.rb

@@ -47,6 +47,21 @@ module Temporalio
           @workflow_raw_args = value
         end
 
+        # Add workflow hints to be passed to converter for workflow args.
+        #
+        # @param hints [Array<Object>] Hints to add.
+        def workflow_arg_hint(*hints)
+          @workflow_arg_hints ||= []
+          @workflow_arg_hints.concat(hints)
+        end
+
+        # Set workflow result hint to be passed to converter for workflow result.
+        #
+        # @param hint [Object] Hint to set.
+        def workflow_result_hint(hint)
+          @workflow_result_hint = hint
+        end
+
         # Configure workflow failure exception types. This sets the types of exceptions that, if a
         # workflow-thrown exception extends, will cause the workflow/update to fail instead of suspending the workflow
         # via task failure. These are applied in addition to the worker option. If {::Exception} is set, it effectively
@@ -55,7 +70,7 @@ module Temporalio
         # @param types [Array<Class<Exception>>] Exception types to turn into workflow failures.
         def workflow_failure_exception_type(*types)
           types.each do |t|
-            raise ArgumentError, 'All types must classes inheriting Exception' unless t.is_a?(Class) && t < Exception
+            raise ArgumentError, 'All types must classes inheriting Exception' unless t.is_a?(Class) && t <= Exception
           end
           @workflow_failure_exception_types ||= []
           @workflow_failure_exception_types.concat(types)
@@ -91,6 +106,15 @@ module Temporalio
           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
+        end
+
         # Mark an `initialize` as needing the workflow start arguments. Otherwise, `initialize` must accept no required
         # arguments. This must be placed above the `initialize` method or it will fail.
         #
@@ -112,16 +136,20 @@ module Temporalio
         #   {Converters::RawValue} which is a raw payload wrapper, convertible with {Workflow.payload_converter}.
         # @param unfinished_policy [HandlerUnfinishedPolicy] How to treat unfinished handlers if they are still running
         #   when the workflow ends. The default warns, but this can be disabled.
+        # @param arg_hints [Array<Object>, nil] Argument hint(s) for the signal.
         def workflow_signal(
           name: nil,
           description: nil,
           dynamic: false,
           raw_args: false,
-          unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON
+          unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON,
+          arg_hints: nil
         )
           raise 'Cannot provide name if dynamic is true' if name && dynamic
 
-          self.pending_handler_details = { type: :signal, name:, description:, dynamic:, raw_args:, unfinished_policy: }
+          self.pending_handler_details =
+            { type: :signal, name:, description:, dynamic:, raw_args:, unfinished_policy:,
+              arg_hints: Array(arg_hints) }
         end
 
         # Mark the next method as a workflow query with a default name as the name of the method. Queries can not have
@@ -135,15 +163,20 @@ module Temporalio
         #   it is useful to have the second parameter be `*args` and `raw_args` be true.
         # @param raw_args [Boolean] If true, does not convert arguments, but instead provides each argument as
         #   {Converters::RawValue} which is a raw payload wrapper, convertible with {Workflow.payload_converter}.
+        # @param arg_hints [Object, Array<Object>, nil] Argument hint(s) for the query.
+        # @param result_hint [Object, nil] Result hint for the query.
         def workflow_query(
           name: nil,
           description: nil,
           dynamic: false,
-          raw_args: false
+          raw_args: false,
+          arg_hints: nil,
+          result_hint: nil
         )
           raise 'Cannot provide name if dynamic is true' if name && dynamic
 
-          self.pending_handler_details = { type: :query, name:, description:, dynamic:, raw_args: }
+          self.pending_handler_details = { type: :query, name:, description:, dynamic:, raw_args:,
+                                           arg_hints: Array(arg_hints), result_hint: }
         end
 
         # Mark the next method as a workflow update with a default name as the name of the method. Updates can return
@@ -159,16 +192,21 @@ module Temporalio
         #   {Converters::RawValue} which is a raw payload wrapper, convertible with {Workflow.payload_converter}.
         # @param unfinished_policy [HandlerUnfinishedPolicy] How to treat unfinished handlers if they are still running
         #   when the workflow ends. The default warns, but this can be disabled.
+        # @param arg_hints [Object, Array<Object>, nil] Argument hint(s) for the update.
+        # @param result_hint [Object, nil] Result hint for the update.
         def workflow_update(
           name: nil,
           description: nil,
           dynamic: false,
           raw_args: false,
-          unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON
+          unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON,
+          arg_hints: nil,
+          result_hint: nil
         )
           raise 'Cannot provide name if dynamic is true' if name && dynamic
 
-          self.pending_handler_details = { type: :update, name:, description:, dynamic:, raw_args:, unfinished_policy: }
+          self.pending_handler_details = { type: :update, name:, description:, dynamic:, raw_args:, unfinished_policy:,
+                                           arg_hints: Array(arg_hints), result_hint: }
         end
 
         # Mark the next method as a workflow update validator to the given update method. The validator is expected to
@@ -181,6 +219,24 @@ module Temporalio
           self.pending_handler_details = { type: :update_validator, update_method: }
         end
 
+        # Mark the next method as returning some dynamic configuraion.
+        #
+        # Because dynamic workflows may conceptually represent more than one workflow type, it may
+        # be desirable to have different settings for fields that would normally be passed to
+        # `workflow_xxx` setters, but vary based on the workflow type name or other information
+        # available in the workflow's context. This function will be called after the workflow's
+        # `initialize`, if it has one, but before the workflow's `execute` method.
+        #
+        # The method must only take self as a parameter, and any values set in the class it returns
+        # will override those provided to other `workflow_xxx` setters.
+        #
+        # Cannot be specified on non-dynamic workflows.
+        def workflow_dynamic_options
+          raise 'Dynamic options method can only be set on workflows using `workflow_dynamic`' unless @workflow_dynamic
+
+          self.pending_handler_details = { type: :dynamic_options }
+        end
+
         private
 
         attr_reader :pending_handler_details
@@ -208,6 +264,15 @@ module Temporalio
         # Reset details
         self.pending_handler_details = nil
 
+        # Disallow kwargs in parameters
+        begin
+          if instance_method(method_name).parameters.any? { |t, _| t == :key || t == :keyreq }
+            raise "Workflow #{handler[:type]} cannot have keyword arguments"
+          end
+        rescue NameError
+          # Ignore name error
+        end
+
         # Initialize class variables if not done already
         @workflow_signals ||= {}
         @workflow_queries ||= {}
@@ -239,14 +304,17 @@ module Temporalio
               to_invoke: method_name,
               description: handler[:description],
               raw_args: handler[:raw_args],
-              unfinished_policy: handler[:unfinished_policy]
+              unfinished_policy: handler[:unfinished_policy],
+              arg_hints: handler[:arg_hints]
             ), @workflow_signals, [@workflow_queries, @workflow_updates]]
           when :query
             [Query.new(
               name: handler[:dynamic] ? nil : (handler[:name] || method_name).to_s,
               to_invoke: method_name,
               description: handler[:description],
-              raw_args: handler[:raw_args]
+              raw_args: handler[:raw_args],
+              arg_hints: handler[:arg_hints],
+              result_hint: handler[:result_hint]
             ), @workflow_queries, [@workflow_signals, @workflow_updates]]
           when :update
             [Update.new(
@@ -254,8 +322,15 @@ module Temporalio
               to_invoke: method_name,
               description: handler[:description],
               raw_args: handler[:raw_args],
-              unfinished_policy: handler[:unfinished_policy]
+              unfinished_policy: handler[:unfinished_policy],
+              arg_hints: handler[:arg_hints],
+              result_hint: handler[:result_hint]
             ), @workflow_updates, [@workflow_signals, @workflow_queries]]
+          when :dynamic_options
+            raise 'Dynamic options method already set' if @dynamic_options_method
+
+            @dynamic_options_method = method_name
+            return
           else
             raise "Unrecognized handler type #{handler[:type]}"
           end
@@ -293,7 +368,7 @@ module Temporalio
       end
 
       # @!visibility private
-      def self._workflow_type_from_workflow_parameter(workflow)
+      def self._workflow_type_and_hints_from_workflow_parameter(workflow)
         case workflow
         when Class
           unless workflow < Definition
@@ -301,11 +376,15 @@ module Temporalio
           end
 
           info = Info.from_class(workflow)
-          info.name || raise(ArgumentError, 'Cannot pass dynamic workflow to start')
+          raise(ArgumentError, 'Cannot pass dynamic workflow to start') unless info.name
+
+          [info.name.to_s, info.arg_hints, info.result_hint]
         when Info
-          workflow.name || raise(ArgumentError, 'Cannot pass dynamic workflow to start')
+          raise(ArgumentError, 'Cannot pass dynamic workflow to start') unless workflow.name
+
+          [workflow.name.to_s, nil, nil]
         when String, Symbol
-          workflow.to_s
+          [workflow.to_s, nil, nil]
         else
           raise ArgumentError, 'Workflow is not a workflow class or string/symbol'
         end
@@ -318,6 +397,11 @@ module Temporalio
           raise "Leftover #{pending_handler_details&.[](:type)} handler not applied to a method"
         end
 
+        # Disallow kwargs in execute parameters
+        if instance_method(:execute).parameters.any? { |t, _| t == :key || t == :keyreq }
+          raise 'Workflow execute cannot have keyword arguments'
+        end
+
         # Apply all update validators before merging with super
         updates = @workflow_updates&.dup || {}
         @workflow_update_validators&.each_value do |validator|
@@ -387,6 +471,10 @@ module Temporalio
 
         raise 'Workflow cannot be given a name and be dynamic' if dynamic && override_name
 
+        if !dynamic && !@dynamic_options_method.nil?
+          raise 'Workflow cannot have a dynamic_options_method unless it is dynamic'
+        end
+
         Info.new(
           workflow_class: self,
           override_name:,
@@ -396,7 +484,11 @@ module Temporalio
           failure_exception_types: @workflow_failure_exception_types || [],
           signals:,
           queries:,
-          updates:
+          updates:,
+          versioning_behavior: @versioning_behavior || VersioningBehavior::UNSPECIFIED,
+          dynamic_options_method: @dynamic_options_method,
+          arg_hints: @workflow_arg_hints,
+          result_hint: @workflow_result_hint
         )
       end
 
@@ -409,7 +501,8 @@ module Temporalio
       # Information about the workflow definition. This is usually not used directly.
       class Info
         attr_reader :workflow_class, :override_name, :dynamic, :init, :raw_args,
-                    :failure_exception_types, :signals, :queries, :updates
+                    :failure_exception_types, :signals, :queries, :updates, :versioning_behavior,
+                    :dynamic_options_method, :arg_hints, :result_hint
 
         # Derive the workflow definition info from the class.
         #
@@ -434,7 +527,11 @@ module Temporalio
           failure_exception_types: [],
           signals: {},
           queries: {},
-          updates: {}
+          updates: {},
+          versioning_behavior: VersioningBehavior::UNSPECIFIED,
+          dynamic_options_method: nil,
+          arg_hints: nil,
+          result_hint: nil
         )
           @workflow_class = workflow_class
           @override_name = override_name
@@ -445,6 +542,10 @@ module Temporalio
           @signals = signals.dup.freeze
           @queries = queries.dup.freeze
           @updates = updates.dup.freeze
+          @versioning_behavior = versioning_behavior
+          @dynamic_options_method = dynamic_options_method
+          @arg_hints = arg_hints
+          @result_hint = result_hint
           Internal::ProtoUtils.assert_non_reserved_name(name)
         end
 
@@ -457,15 +558,17 @@ 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, :description, :raw_args, :unfinished_policy
+        attr_reader :name, :to_invoke, :description, :raw_args, :unfinished_policy, :arg_hints
 
         # @!visibility private
-        def self._name_from_parameter(signal)
+        def self._name_and_hints_from_parameter(signal)
           case signal
           when Workflow::Definition::Signal
-            signal.name || raise(ArgumentError, 'Cannot call dynamic signal directly')
+            raise(ArgumentError, 'Cannot call dynamic signal directly') unless signal.name
+
+            [signal.name, signal.arg_hints]
           when String, Symbol
-            signal.to_s
+            [signal.to_s, nil]
           else
             raise ArgumentError, 'Signal is not a definition or string/symbol'
           end
@@ -481,18 +584,21 @@ module Temporalio
         # @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.
+        # @param arg_hints [Array<Object>, nil] Argument hints for the signal.
         def initialize(
           name:,
           to_invoke:,
           description: nil,
           raw_args: false,
-          unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON
+          unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON,
+          arg_hints: nil
         )
           @name = name
           @to_invoke = to_invoke
           @description = description
           @raw_args = raw_args
           @unfinished_policy = unfinished_policy
+          @arg_hints = arg_hints
           Internal::ProtoUtils.assert_non_reserved_name(name)
         end
       end
@@ -500,15 +606,17 @@ module Temporalio
       # 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, :description, :raw_args
+        attr_reader :name, :to_invoke, :description, :raw_args, :arg_hints, :result_hint
 
         # @!visibility private
-        def self._name_from_parameter(query)
+        def self._name_and_hints_from_parameter(query)
           case query
           when Workflow::Definition::Query
-            query.name || raise(ArgumentError, 'Cannot call dynamic query directly')
+            raise(ArgumentError, 'Cannot call dynamic query directly') unless query.name
+
+            [query.name, query.arg_hints, query.result_hint]
           when String, Symbol
-            query.to_s
+            [query.to_s, nil, nil]
           else
             raise ArgumentError, 'Query is not a definition or string/symbol'
           end
@@ -522,16 +630,22 @@ module Temporalio
         # @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 arg_hints [Array<Object>, nil] Argument hints for the query.
+        # @param result_hint [Object, nil] Result hints for the query.
         def initialize(
           name:,
           to_invoke:,
           description: nil,
-          raw_args: false
+          raw_args: false,
+          arg_hints: nil,
+          result_hint: nil
         )
           @name = name
           @to_invoke = to_invoke
           @description = description
           @raw_args = raw_args
+          @arg_hints = arg_hints
+          @result_hint = result_hint
           Internal::ProtoUtils.assert_non_reserved_name(name)
         end
       end
@@ -539,15 +653,18 @@ module Temporalio
       # 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, :description, :raw_args, :unfinished_policy, :validator_to_invoke
+        attr_reader :name, :to_invoke, :description, :raw_args, :unfinished_policy, :validator_to_invoke,
+                    :arg_hints, :result_hint
 
         # @!visibility private
-        def self._name_from_parameter(update)
+        def self._name_and_hints_from_parameter(update)
           case update
           when Workflow::Definition::Update
-            update.name || raise(ArgumentError, 'Cannot call dynamic update directly')
+            raise(ArgumentError, 'Cannot call dynamic update directly') unless update.name
+
+            [update.name, update.arg_hints, update.result_hint]
           when String, Symbol
-            update.to_s
+            [update.to_s, nil, nil]
           else
             raise ArgumentError, 'Update is not a definition or string/symbol'
           end
@@ -564,13 +681,17 @@ module Temporalio
         # @param unfinished_policy [HandlerUnfinishedPolicy] How the workflow reacts when this handler is still running
         #   on workflow completion.
         # @param validator_to_invoke [Symbol, Proc, nil] Method name or proc validator to invoke.
+        # @param arg_hints [Array<Object>, nil] Argument hints for the update.
+        # @param result_hint [Object, nil] Result hints for the update.
         def initialize(
           name:,
           to_invoke:,
           description: nil,
           raw_args: false,
           unfinished_policy: HandlerUnfinishedPolicy::WARN_AND_ABANDON,
-          validator_to_invoke: nil
+          validator_to_invoke: nil,
+          arg_hints: nil,
+          result_hint: nil
         )
           @name = name
           @to_invoke = to_invoke
@@ -578,6 +699,8 @@ module Temporalio
           @raw_args = raw_args
           @unfinished_policy = unfinished_policy
           @validator_to_invoke = validator_to_invoke
+          @arg_hints = arg_hints
+          @result_hint = result_hint
           Internal::ProtoUtils.assert_non_reserved_name(name)
         end
 
@@ -589,10 +712,37 @@ module Temporalio
             description:,
             raw_args:,
             unfinished_policy:,
-            validator_to_invoke:
+            validator_to_invoke:,
+            arg_hints:,
+            result_hint:
           )
         end
       end
     end
+
+    DefinitionOptions = Struct.new(
+      :failure_exception_types,
+      :versioning_behavior
+    )
+    # @!attribute failure_exception_types
+    #   Dynamic equivalent of {Definition.workflow_failure_exception_type}.
+    #   Will override any types set there if set, including if set to an empty array.
+    #   @return [Array<Class<Exception>>, nil] The failure exception types
+    #
+    # @!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
+    class DefinitionOptions
+      def initialize(
+        failure_exception_types: nil,
+        versioning_behavior: nil
+      )
+        super
+      end
+    end
   end
 end

data/lib/temporalio/workflow/external_workflow_handle.rb

@@ -28,7 +28,9 @@ module Temporalio
       # @param signal [Workflow::Definition::Signal, Symbol, String] Signal definition or name.
       # @param args [Array<Object>] Signal args.
       # @param cancellation [Cancellation] Cancellation for canceling the signalling.
-      def signal(signal, *args, cancellation: Workflow.cancellation)
+      # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
+      #   signal definition has arg hints, those are used by default.
+      def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil)
         raise NotImplementedError
       end
 

data/lib/temporalio/workflow/info.rb

@@ -12,6 +12,7 @@ module Temporalio
       :last_result,
       :namespace,
       :parent,
+      :priority,
       :retry_policy,
       :root,
       :run_id,
@@ -44,6 +45,8 @@ module Temporalio
     #   @return [String] Namespace for the workflow.
     # @!attribute parent
     #   @return [ParentInfo, nil] Parent information for the workflow if this is a child.
+    # @!attribute priority
+    #   @return [Priority] The priority of this workflow.
     # @!attribute retry_policy
     #   @return [RetryPolicy, nil] Retry policy for the workflow.
     # @!attribute root
@@ -54,7 +57,7 @@ module Temporalio
     # @!attribute run_timeout
     #   @return [Float, nil] Run timeout for the workflow.
     # @!attribute start_time
-    #   @return [Time] Time when the workflow started.
+    #   @return [Time] Time when the workflow started on the server.
     # @!attribute task_queue
     #   @return [String] Task queue for the workflow.
     # @!attribute task_timeout

data/lib/temporalio/workflow.rb

@@ -2,6 +2,7 @@
 
 require 'random/formatter'
 require 'temporalio/error'
+require 'temporalio/priority'
 require 'temporalio/workflow/activity_cancellation_type'
 require 'temporalio/workflow/child_workflow_cancellation_type'
 require 'temporalio/workflow/child_workflow_handle'
@@ -56,6 +57,18 @@ module Temporalio
       _current.current_details = details
     end
 
+    # Get the deployment version of the worker which executed the current Workflow Task.
+    #
+    # May be nil if the task was completed by a worker without a deployment version or build id. If
+    # this worker is the one executing this task for the first time and has a deployment version
+    # set, then its ID will be used. This value may change over the lifetime of the workflow run,
+    # but is deterministic and safe to use for branching. This is currently experimental.
+    #
+    # @return [WorkerDeploymentVersion, nil] the current deployment version if any.
+    def self.current_deployment_version
+      _current.current_deployment_version
+    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
@@ -118,6 +131,11 @@ module Temporalio
     #   optimization on some servers that sends activities back to the same worker as the calling workflow if they can
     #   run there. If `false` (the default), eager execution may still be disabled at the worker level or may not be
     #   requested due to lack of available slots.
+    # @param priority [Priority] Priority of the activity. This is currently experimental.
+    # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
+    #   activity definition has arg hints, those are used by default.
+    # @param result_hint [Object, nil] Overrides converter hint for result if any. If unset/nil and the activity
+    #   definition has result hint, it is used by default.
     #
     # @return [Object] Result of the activity.
     # @raise [Error::ActivityError] Activity failed (and retry was disabled or exhausted).
@@ -136,12 +154,16 @@ module Temporalio
       cancellation: Workflow.cancellation,
       cancellation_type: ActivityCancellationType::TRY_CANCEL,
       activity_id: nil,
-      disable_eager_execution: false
+      disable_eager_execution: false,
+      priority: Priority.default,
+      arg_hints: nil,
+      result_hint: nil
     )
       _current.execute_activity(
         activity, *args,
         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:
+        heartbeat_timeout:, retry_policy:, cancellation:, cancellation_type:, activity_id:, disable_eager_execution:,
+        priority:, arg_hints:, result_hint:
       )
     end
 
@@ -163,13 +185,16 @@ module Temporalio
       retry_policy: nil,
       cron_schedule: nil,
       memo: nil,
-      search_attributes: nil
+      search_attributes: nil,
+      priority: Priority.default,
+      arg_hints: nil,
+      result_hint: nil
     )
       start_child_workflow(
         workflow, *args,
         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:
+        retry_policy:, cron_schedule:, memo:, search_attributes:, priority:, arg_hints:, result_hint:
       ).result
     end
 
@@ -200,6 +225,10 @@ module Temporalio
     #   workflow.
     # @param activity_id [String, nil] Optional unique identifier for the activity. This is an advanced setting that
     #   should not be set unless users are sure they need to. Contact Temporal before setting this value.
+    # @param arg_hints [Array<Object>, nil] Overrides converter hints for arguments if any. If unset/nil and the
+    #   activity definition has arg hints, those are used by default.
+    # @param result_hint [Object, nil] Overrides converter hint for result if any. If unset/nil and the activity
+    #   definition has result hint, it is used by default.
     #
     # @return [Object] Result of the activity.
     # @raise [Error::ActivityError] Activity failed (and retry was disabled or exhausted).
@@ -215,12 +244,15 @@ module Temporalio
       local_retry_threshold: nil,
       cancellation: Workflow.cancellation,
       cancellation_type: ActivityCancellationType::TRY_CANCEL,
-      activity_id: nil
+      activity_id: nil,
+      arg_hints: nil,
+      result_hint: nil
     )
       _current.execute_local_activity(
         activity, *args,
         schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
-        retry_policy:, local_retry_threshold:, cancellation:, cancellation_type:, activity_id:
+        retry_policy:, local_retry_threshold:, cancellation:, cancellation_type:,
+        activity_id:, arg_hints:, result_hint:
       )
     end
 
@@ -360,6 +392,11 @@ module Temporalio
     # @param cron_schedule [String, nil] Cron schedule. Users should use schedules instead of this.
     # @param memo [Hash{String, Symbol => Object}, nil] Memo for the workflow.
     # @param search_attributes [SearchAttributes, nil] Search attributes for the workflow.
+    # @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.
+    # @param result_hint [Object, nil] Overrides converter hint for result if any. If unset/nil and the workflow
+    #   definition has result hint, it is used by default.
     #
     # @return [ChildWorkflowHandle] Workflow handle to the started workflow.
     # @raise [Error::WorkflowAlreadyStartedError] Workflow already exists for the ID.
@@ -381,13 +418,16 @@ module Temporalio
       retry_policy: nil,
       cron_schedule: nil,
       memo: nil,
-      search_attributes: nil
+      search_attributes: nil,
+      priority: Priority.default,
+      arg_hints: nil,
+      result_hint: nil
     )
       _current.start_child_workflow(
         workflow, *args,
         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:
+        retry_policy:, cron_schedule:, memo:, search_attributes:, priority:, arg_hints:, result_hint:
       )
     end
 
@@ -510,12 +550,20 @@ module Temporalio
       def self.io_enabled(&)
         Workflow._current.io_enabled(&)
       end
+
+      # Run a block of code with the durable/deterministic workflow Fiber scheduler off. This means fallback to default
+      # fiber scheduler and no workflow helpers will be available in the block. This is usually only needed in advanced
+      # situations where a third party library does something like use "Timeout" in a way that shouldn't be made
+      # durable.
+      def self.durable_scheduler_disabled(&)
+        Workflow._current.durable_scheduler_disabled(&)
+      end
     end
 
     # Error that is raised by a workflow out of the primary workflow method to issue a continue-as-new.
     class ContinueAsNewError < Error
       attr_accessor :args, :workflow, :task_queue, :run_timeout, :task_timeout,
-                    :retry_policy, :memo, :search_attributes, :headers
+                    :retry_policy, :memo, :search_attributes, :arg_hints, :headers
 
       # Create a continue as new error.
       #
@@ -534,6 +582,8 @@ module Temporalio
       #   is used.
       # @param search_attributes [SearchAttributes, nil] Search attributes for the workflow. If unset/nil, the current
       #   workflow search attributes are used.
+      # @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.
       # @param headers [Hash<String, Object>] Headers for the workflow. The default is _not_ carried over from the
       #   current workflow.
       def initialize(
@@ -545,6 +595,7 @@ module Temporalio
         retry_policy: nil,
         memo: nil,
         search_attributes: nil,
+        arg_hints: nil,
         headers: {}
       )
         super('Continue as new')
@@ -556,6 +607,7 @@ module Temporalio
         @retry_policy = retry_policy
         @memo = memo
         @search_attributes = search_attributes
+        @arg_hints = arg_hints
         @headers = headers
         Workflow._current.initialize_continue_as_new_error(self)
       end