temporalio 1.10.0 → 1.11.0

data/rbi/temporalio/internal/bridge/api/activity_task/activity_task.rbi

@@ -127,7 +127,9 @@ class Temporalio::Internal::Bridge::Api::ActivityTask::Start
       retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy),
       priority: T.nilable(Temporalio::Api::Common::V1::Priority),
       is_local: T.nilable(T::Boolean),
-      run_id: T.nilable(String)
+      run_id: T.nilable(String),
+      propagated_nexus_serialization_context: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext),
+      workflow_task: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt)
     ).void
   end
   def initialize(
@@ -149,7 +151,9 @@ class Temporalio::Internal::Bridge::Api::ActivityTask::Start
     retry_policy: nil,
     priority: nil,
     is_local: false,
-    run_id: ""
+    run_id: "",
+    propagated_nexus_serialization_context: nil,
+    workflow_task: nil
   )
   end
 
@@ -441,6 +445,45 @@ class Temporalio::Internal::Bridge::Api::ActivityTask::Start
   def clear_run_id
   end
 
+  # Serialization context of the Nexus operation handler that started this activity, if any.
+# Only set for standalone activities. Lang should use it to serialize the activity's result and
+# failure, which are returned to the Nexus caller.
+  sig { returns(T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)) }
+  def propagated_nexus_serialization_context
+  end
+
+  # Serialization context of the Nexus operation handler that started this activity, if any.
+# Only set for standalone activities. Lang should use it to serialize the activity's result and
+# failure, which are returned to the Nexus caller.
+  sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)).void }
+  def propagated_nexus_serialization_context=(value)
+  end
+
+  # Serialization context of the Nexus operation handler that started this activity, if any.
+# Only set for standalone activities. Lang should use it to serialize the activity's result and
+# failure, which are returned to the Nexus caller.
+  sig { void }
+  def clear_propagated_nexus_serialization_context
+  end
+
+  # For a local activity, the workflow task in which Core dispatched this execution. Retries that
+# Core runs locally keep the value. Unset for other activities.
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt)) }
+  def workflow_task
+  end
+
+  # For a local activity, the workflow task in which Core dispatched this execution. Retries that
+# Core runs locally keep the value. Unset for other activities.
+  sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt)).void }
+  def workflow_task=(value)
+  end
+
+  # For a local activity, the workflow task in which Core dispatched this execution. Retries that
+# Core runs locally keep the value. Unset for other activities.
+  sig { void }
+  def clear_workflow_task
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -474,6 +517,174 @@ class Temporalio::Internal::Bridge::Api::ActivityTask::Start
   end
 end
 
+# One attempt of a workflow task, from the poll response and the history of that attempt.
+class Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      started_event_id: T.nilable(Integer),
+      attempt: T.nilable(Integer),
+      started_time: T.nilable(Google::Protobuf::Timestamp),
+      previous_started_event_id: T.nilable(Integer),
+      failed_tasks: T.nilable(T::Array[Integer]),
+      previous_attempt: T.nilable(Integer),
+      previous_started_time: T.nilable(Google::Protobuf::Timestamp)
+    ).void
+  end
+  def initialize(
+    started_event_id: 0,
+    attempt: 0,
+    started_time: nil,
+    previous_started_event_id: 0,
+    failed_tasks: [],
+    previous_attempt: 0,
+    previous_started_time: nil
+  )
+  end
+
+  # The event id of the task's WorkflowTaskStarted event.
+  sig { returns(Integer) }
+  def started_event_id
+  end
+
+  # The event id of the task's WorkflowTaskStarted event.
+  sig { params(value: Integer).void }
+  def started_event_id=(value)
+  end
+
+  # The event id of the task's WorkflowTaskStarted event.
+  sig { void }
+  def clear_started_event_id
+  end
+
+  sig { returns(Integer) }
+  def attempt
+  end
+
+  sig { params(value: Integer).void }
+  def attempt=(value)
+  end
+
+  sig { void }
+  def clear_attempt
+  end
+
+  # When the server started the task.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def started_time
+  end
+
+  # When the server started the task.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def started_time=(value)
+  end
+
+  # When the server started the task.
+  sig { void }
+  def clear_started_time
+  end
+
+  # The started event id of the run's last completed workflow task, from the poll response.
+# 0 when no task of the run has completed.
+  sig { returns(Integer) }
+  def previous_started_event_id
+  end
+
+  # The started event id of the run's last completed workflow task, from the poll response.
+# 0 when no task of the run has completed.
+  sig { params(value: Integer).void }
+  def previous_started_event_id=(value)
+  end
+
+  # The started event id of the run's last completed workflow task, from the poll response.
+# 0 when no task of the run has completed.
+  sig { void }
+  def clear_previous_started_event_id
+  end
+
+  # The started event ids of the run's last 100 failed and timed out workflow tasks in history,
+# in event order. The cap keeps each start small. A transient attempt has no such event.
+  sig { returns(T::Array[Integer]) }
+  def failed_tasks
+  end
+
+  # The started event ids of the run's last 100 failed and timed out workflow tasks in history,
+# in event order. The cap keeps each start small. A transient attempt has no such event.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def failed_tasks=(value)
+  end
+
+  # The started event ids of the run's last 100 failed and timed out workflow tasks in history,
+# in event order. The cap keeps each start small. A transient attempt has no such event.
+  sig { void }
+  def clear_failed_tasks
+  end
+
+  # The attempt and the started time of the task at previous_started_event_id, from its
+# WorkflowTaskScheduled and WorkflowTaskStarted events. Unset when no task has completed.
+  sig { returns(Integer) }
+  def previous_attempt
+  end
+
+  # The attempt and the started time of the task at previous_started_event_id, from its
+# WorkflowTaskScheduled and WorkflowTaskStarted events. Unset when no task has completed.
+  sig { params(value: Integer).void }
+  def previous_attempt=(value)
+  end
+
+  # The attempt and the started time of the task at previous_started_event_id, from its
+# WorkflowTaskScheduled and WorkflowTaskStarted events. Unset when no task has completed.
+  sig { void }
+  def clear_previous_attempt
+  end
+
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def previous_started_time
+  end
+
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def previous_started_time=(value)
+  end
+
+  sig { void }
+  def clear_previous_started_time
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::WorkflowTaskAttempt, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
 # Attempt to cancel a running activity
 class Temporalio::Internal::Bridge::Api::ActivityTask::Cancel
   include ::Google::Protobuf::MessageExts

data/rbi/temporalio/internal/bridge/api/workflow_activation/workflow_activation.rbi

@@ -705,7 +705,8 @@ class Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow
       start_time: T.nilable(Google::Protobuf::Timestamp),
       root_workflow: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution),
       priority: T.nilable(Temporalio::Api::Common::V1::Priority),
-      original_execution_run_id: T.nilable(String)
+      original_execution_run_id: T.nilable(String),
+      propagated_nexus_serialization_context: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)
     ).void
   end
   def initialize(
@@ -734,7 +735,8 @@ class Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow
     start_time: nil,
     root_workflow: nil,
     priority: nil,
-    original_execution_run_id: ""
+    original_execution_run_id: "",
+    propagated_nexus_serialization_context: nil
   )
   end
 
@@ -1173,6 +1175,27 @@ class Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow
   def clear_original_execution_run_id
   end
 
+  # Serialization context of the Nexus operation handler that started this workflow, if any.
+# Lang should use it to serialize the workflow's result and failure, which are returned to the
+# Nexus caller.
+  sig { returns(T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)) }
+  def propagated_nexus_serialization_context
+  end
+
+  # Serialization context of the Nexus operation handler that started this workflow, if any.
+# Lang should use it to serialize the workflow's result and failure, which are returned to the
+# Nexus caller.
+  sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)).void }
+  def propagated_nexus_serialization_context=(value)
+  end
+
+  # Serialization context of the Nexus operation handler that started this workflow, if any.
+# Lang should use it to serialize the workflow's result and failure, which are returned to the
+# Nexus caller.
+  sig { void }
+  def clear_propagated_nexus_serialization_context
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -2413,7 +2436,8 @@ class Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate
       input: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]),
       headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]),
       meta: T.nilable(Temporalio::Api::Update::V1::Meta),
-      run_validator: T.nilable(T::Boolean)
+      run_validator: T.nilable(T::Boolean),
+      propagated_nexus_serialization_context: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)
     ).void
   end
   def initialize(
@@ -2423,7 +2447,8 @@ class Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate
     input: [],
     headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload),
     meta: nil,
-    run_validator: false
+    run_validator: false,
+    propagated_nexus_serialization_context: nil
   )
   end
 
@@ -2541,6 +2566,27 @@ class Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate
   def clear_run_validator
   end
 
+  # Serialization context of the Nexus operation handler that sent this update, if any. Lang
+# should use it to serialize the update's result and failure, which are returned to the Nexus
+# caller.
+  sig { returns(T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)) }
+  def propagated_nexus_serialization_context
+  end
+
+  # Serialization context of the Nexus operation handler that sent this update, if any. Lang
+# should use it to serialize the update's result and failure, which are returned to the Nexus
+# caller.
+  sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext)).void }
+  def propagated_nexus_serialization_context=(value)
+  end
+
+  # Serialization context of the Nexus operation handler that sent this update, if any. Lang
+# should use it to serialize the update's result and failure, which are returned to the Nexus
+# caller.
+  sig { void }
+  def clear_propagated_nexus_serialization_context
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end

data/rbi/temporalio/internal/bridge/testing.rbi

@@ -68,7 +68,8 @@ class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOpti
       log_format: String,
       log_level: String,
       extra_args: T::Array[String],
-      download_ttl: T.nilable(T.any(Integer, Float))
+      download_ttl: T.nilable(T.any(Integer, Float)),
+      startup_timeout: T.nilable(T.any(Integer, Float))
     ).void
   end
   def initialize(
@@ -86,7 +87,8 @@ class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOpti
     log_format,
     log_level,
     extra_args,
-    download_ttl
+    download_ttl,
+    startup_timeout
   ); end
 end
 
@@ -102,8 +104,19 @@ class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOpt
       download_dest_dir: T.nilable(String),
       port: T.nilable(Integer),
       extra_args: T::Array[String],
-      download_ttl: T.nilable(T.any(Integer, Float))
+      download_ttl: T.nilable(T.any(Integer, Float)),
+      startup_timeout: T.nilable(T.any(Integer, Float))
     ).void
   end
-  def initialize(existing_path, sdk_name, sdk_version, download_version, download_dest_dir, port, extra_args, download_ttl); end
+  def initialize(
+    existing_path,
+    sdk_name,
+    sdk_version,
+    download_version,
+    download_dest_dir,
+    port,
+    extra_args,
+    download_ttl,
+    startup_timeout
+  ); end
 end

data/rbi/temporalio/internal/bridge/worker.rbi

@@ -58,15 +58,15 @@ class Temporalio::Internal::Bridge::Worker::Options < ::Struct
       tuner: Temporalio::Internal::Bridge::Worker::TunerOptions,
       identity_override: T.nilable(String),
       max_cached_workflows: Integer,
-      workflow_task_poller_behavior: T.any(
+      workflow_task_poller_behavior: T.nilable(T.any(
         Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum,
         Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling
-      ),
+      )),
       nonsticky_to_sticky_poll_ratio: T.any(Integer, Float),
-      activity_task_poller_behavior: T.any(
+      activity_task_poller_behavior: T.nilable(T.any(
         Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum,
         Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling
-      ),
+      )),
       enable_workflows: T::Boolean,
       enable_local_activities: T::Boolean,
       enable_remote_activities: T::Boolean,

data/rbi/temporalio/internal/worker/workflow_instance/context.rbi

@@ -42,8 +42,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
   sig { returns(T.nilable(Temporalio::Workflow::UpdateInfo)) }
   def current_update_info; end
 
-  sig { params(patch_id: T.any(Symbol, String)).void }
-  def deprecate_patch(patch_id); end
+  sig { params(patch_id: T.any(Symbol, String), event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).void }
+  def deprecate_patch(patch_id, event_groups:); end
 
   sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
   def durable_scheduler_disabled(&block); end
@@ -65,7 +65,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
       disable_eager_execution: T::Boolean,
       priority: Temporalio::Priority,
       arg_hints: T.nilable(T::Array[Object]),
-      result_hint: T.nilable(Object)
+      result_hint: T.nilable(Object),
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).returns(T.nilable(Object))
   end
   def execute_activity(
@@ -84,7 +85,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
     disable_eager_execution:,
     priority:,
     arg_hints:,
-    result_hint:
+    result_hint:,
+    event_groups:
   ); end
 
   sig do
@@ -101,7 +103,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
       cancellation_type: Integer,
       activity_id: T.nilable(String),
       arg_hints: T.nilable(T::Array[Object]),
-      result_hint: T.nilable(Object)
+      result_hint: T.nilable(Object),
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).returns(T.nilable(Object))
   end
   def execute_local_activity(
@@ -117,7 +120,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
     cancellation_type:,
     activity_id:,
     arg_hints:,
-    result_hint:
+    result_hint:,
+    event_groups:
   ); end
 
   sig do
@@ -153,8 +157,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
   sig { returns(Time) }
   def now; end
 
-  sig { params(patch_id: T.any(Symbol, String)).returns(T::Boolean) }
-  def patched(patch_id); end
+  sig { params(patch_id: T.any(Symbol, String), event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).returns(T::Boolean) }
+  def patched(patch_id, event_groups:); end
 
   sig { returns(Temporalio::Converters::PayloadConverter) }
   def payload_converter; end
@@ -177,8 +181,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
   sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) }
   def signal_handlers; end
 
-  sig { params(duration: T.nilable(T.any(Integer, Float)), summary: T.nilable(String), cancellation: Temporalio::Cancellation).void }
-  def sleep(duration, summary:, cancellation:); end
+  sig { params(duration: T.nilable(T.any(Integer, Float)), summary: T.nilable(String), cancellation: Temporalio::Cancellation, event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).void }
+  def sleep(duration, summary:, cancellation:, event_groups:); end
 
   sig do
     params(
@@ -202,7 +206,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
       priority: Temporalio::Priority,
       versioning_override: T.nilable(Temporalio::VersioningOverride),
       arg_hints: T.nilable(T::Array[Object]),
-      result_hint: T.nilable(Object)
+      result_hint: T.nilable(Object),
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).returns(Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle)
   end
   def start_child_workflow(
@@ -226,7 +231,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
     priority:,
     versioning_override:,
     arg_hints:,
-    result_hint:
+    result_hint:,
+    event_groups:
   ); end
 
   sig { returns(T::Hash[Object, Object]) }
@@ -236,23 +242,24 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
     type_parameters(:T)
       .params(
         duration: T.nilable(T.any(Integer, Float)),
-        exception_class: T.class_of(Exception),
+        exception_class: T.any(T.class_of(Exception), Exception),
         exception_args: T.nilable(Object),
         summary: T.nilable(String),
+        event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup]),
         block: T.proc.returns(T.type_parameter(:T))
       )
       .returns(T.type_parameter(:T))
   end
-  def timeout(duration, exception_class, *exception_args, summary:, &block); end
+  def timeout(duration, exception_class, *exception_args, summary:, event_groups:, &block); end
 
   sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) }
   def update_handlers; end
 
-  sig { params(hash: T::Hash[T.any(Symbol, String), T.nilable(Object)]).void }
-  def upsert_memo(hash); end
+  sig { params(hash: T::Hash[T.any(Symbol, String), T.nilable(Object)], event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).void }
+  def upsert_memo(hash, event_groups:); end
 
-  sig { params(updates: Temporalio::SearchAttributes::Update).void }
-  def upsert_search_attributes(*updates); end
+  sig { params(updates: Temporalio::SearchAttributes::Update, event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).void }
+  def upsert_search_attributes(*updates, event_groups:); end
 
   sig do
     type_parameters(:T)
@@ -261,8 +268,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
   end
   def wait_condition(cancellation:, &block); end
 
-  sig { params(id: String, run_id: T.nilable(String)).void }
-  def _cancel_external_workflow(id:, run_id:); end
+  sig { params(id: String, run_id: T.nilable(String), event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).void }
+  def _cancel_external_workflow(id:, run_id:, event_groups:); end
 
   sig { params(outbound: Temporalio::Worker::Interceptor::Workflow::Outbound).void }
   def _outbound=(outbound); end
@@ -273,10 +280,11 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
       signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
       args: T::Array[T.nilable(Object)],
       cancellation: Temporalio::Cancellation,
-      arg_hints: T.nilable(T::Array[Object])
+      arg_hints: T.nilable(T::Array[Object]),
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).void
   end
-  def _signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:); end
+  def _signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:, event_groups:); end
 
   sig do
     params(
@@ -285,8 +293,9 @@ class Temporalio::Internal::Worker::WorkflowInstance::Context
       signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
       args: T::Array[T.nilable(Object)],
       cancellation: Temporalio::Cancellation,
-      arg_hints: T.nilable(T::Array[Object])
+      arg_hints: T.nilable(T::Array[Object]),
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).void
   end
-  def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:, arg_hints:); end
+  def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:, arg_hints:, event_groups:); end
 end

data/rbi/temporalio/internal/worker/workflow_instance/nexus_client.rbi

@@ -29,7 +29,8 @@ class Temporalio::Internal::Worker::WorkflowInstance::NexusClient < Temporalio::
       summary: T.nilable(String),
       cancellation: Temporalio::Cancellation,
       arg_hint: T.nilable(Object),
-      result_hint: T.nilable(Object)
+      result_hint: T.nilable(Object),
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).returns(Temporalio::Workflow::NexusOperationHandle)
   end
   def start_operation(
@@ -42,6 +43,7 @@ class Temporalio::Internal::Worker::WorkflowInstance::NexusClient < Temporalio::
     summary: T.unsafe(nil),
     cancellation: T.unsafe(nil),
     arg_hint: T.unsafe(nil),
-    result_hint: T.unsafe(nil)
+    result_hint: T.unsafe(nil),
+    event_groups: T.unsafe(nil)
   ); end
 end

data/rbi/temporalio/internal/worker/workflow_instance/outbound_implementation.rbi

@@ -11,10 +11,14 @@ class Temporalio::Internal::Worker::WorkflowInstance::OutboundImplementation < T
       local: T::Boolean,
       cancellation: Temporalio::Cancellation,
       result_hint: T.nilable(Object),
-      block: T.proc.params(arg0: T.nilable(Object)).returns(Integer)
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup]),
+      block: T.proc.params(
+        arg0: T.nilable(Object),
+        arg1: T::Array[Temporalio::Api::Sdk::V1::EventGroupMarker]
+      ).returns(Integer)
     ).returns(T.nilable(Object))
   end
-  def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &block); end
+  def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, event_groups:, &block); end
 
   sig do
     params(
@@ -22,10 +26,15 @@ class Temporalio::Internal::Worker::WorkflowInstance::OutboundImplementation < T
       cancellation: Temporalio::Cancellation,
       last_local_backoff: T.nilable(Object),
       result_hint: T.nilable(Object),
-      block: T.proc.params(arg0: T.nilable(Object)).returns(Integer)
+      event_group_markers: T::Array[Temporalio::Api::Sdk::V1::EventGroupMarker],
+      block: T.proc.params(
+        arg0: T.nilable(Object),
+        arg1: T::Array[Temporalio::Api::Sdk::V1::EventGroupMarker]
+      ).returns(Integer)
     ).returns(T.nilable(Object))
   end
-  def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block); end
+  def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, event_group_markers:,
+                            &block); end
 
   sig do
     params(
@@ -36,8 +45,10 @@ class Temporalio::Internal::Worker::WorkflowInstance::OutboundImplementation < T
       args: T::Array[T.nilable(Object)],
       cancellation: Temporalio::Cancellation,
       arg_hints: T.nilable(T::Array[Object]),
-      headers: T::Hash[String, T.nilable(Object)]
+      headers: T::Hash[String, T.nilable(Object)],
+      event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])
     ).void
   end
-  def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, arg_hints:, headers:); end
+  def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, arg_hints:, headers:,
+                                event_groups:); end
 end

data/rbi/temporalio/internal/worker/workflow_instance/scheduler.rbi

@@ -26,7 +26,7 @@ class Temporalio::Internal::Worker::WorkflowInstance::Scheduler
     type_parameters(:T)
       .params(
         duration: T.nilable(T.any(Integer, Float)),
-        exception_class: T.class_of(Exception),
+        exception_class: T.any(T.class_of(Exception), Exception),
         exception_arguments: T.nilable(Object),
         block: T.proc.returns(T.type_parameter(:T))
       )

data/rbi/temporalio/internal/worker/workflow_instance.rbi

@@ -112,6 +112,9 @@ class Temporalio::Internal::Worker::WorkflowInstance
   sig { returns(T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean))) }
   attr_reader :patch_activation_callback
 
+  sig { returns(T::Boolean) }
+  attr_reader :check_conditions
+
   sig { returns(T::Boolean) }
   attr_accessor :io_enabled
 
@@ -142,8 +145,8 @@ class Temporalio::Internal::Worker::WorkflowInstance
   sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
   def illegal_call_tracing_disabled(&block); end
 
-  sig { params(patch_id: T.any(Symbol, String), deprecated: T::Boolean).returns(T::Boolean) }
-  def patch(patch_id:, deprecated:); end
+  sig { params(patch_id: T.any(Symbol, String), deprecated: T::Boolean, event_groups: T.nilable(T::Array[Temporalio::Workflow::EventGroup])).returns(T::Boolean) }
+  def patch(patch_id:, deprecated:, event_groups: T.unsafe(nil)); end
 
   sig { params(patch_id: String).returns(T::Boolean) }
   def patch_activated?(patch_id); end