temporalio 1.6.0 → 1.8.0

data/rbi/temporalio/api/workflowservice/v1/service_services.rbi

@@ -1567,5 +1567,13 @@ module Temporalio::Api::WorkflowService::V1::WorkflowService
     end
     def delete_nexus_operation_execution(request)
     end
+
+    sig do
+      params(
+        request: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionTimeSkippingRequest
+      ).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionTimeSkippingResponse)
+    end
+    def poll_workflow_execution_time_skipping(request)
+    end
   end
 end

data/rbi/temporalio/client/activity_execution.rbi

@@ -33,6 +33,9 @@ class Temporalio::Client::ActivityExecution
   sig { returns(T.nilable(Time)) }
   def schedule_time; end
 
+  sig { returns(T.nilable(Time)) }
+  def execution_time; end
+
   sig { returns(T.nilable(Time)) }
   def close_time; end
 
@@ -76,9 +79,30 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   sig { returns(T.nilable(Float)) }
   def heartbeat_timeout; end
 
+  sig { returns(T.nilable(Float)) }
+  def start_delay; end
+
   sig { returns(T::Boolean) }
   def has_heartbeat_details?; end
 
+  sig { returns(T::Boolean) }
+  def has_last_failure?; end
+
+  sig { returns(T::Boolean) }
+  def has_input?; end
+
+  sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
+  def input(hints: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def has_result?; end
+
+  sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def result(result_hint: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(Temporalio::Error::Failure)) }
+  def failure; end
+
   sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
   def heartbeat_details(hints: T.unsafe(nil)); end
 
@@ -94,6 +118,9 @@ class Temporalio::Client::ActivityExecution::Description < ::Temporalio::Client:
   sig { returns(Integer) }
   def attempt; end
 
+  sig { returns(Integer) }
+  def total_heartbeat_count; end
+
   sig { returns(T.nilable(Temporalio::Error::Failure)) }
   def last_failure; end
 

data/rbi/temporalio/client/activity_execution_options.rbi

@@ -0,0 +1,58 @@
+# typed: true
+
+class Temporalio::Client::ActivityExecutionOptions
+  class << self
+    sig do
+      params(options: Temporalio::Api::Activity::V1::ActivityOptions)
+        .returns(Temporalio::Client::ActivityExecutionOptions)
+    end
+    def _from_proto(options); end
+  end
+
+  sig do
+    params(
+      task_queue: T.nilable(String),
+      schedule_to_close_timeout: T.nilable(Float),
+      schedule_to_start_timeout: T.nilable(Float),
+      start_to_close_timeout: T.nilable(Float),
+      heartbeat_timeout: T.nilable(Float),
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      priority: Temporalio::Priority,
+      start_delay: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    task_queue:,
+    schedule_to_close_timeout:,
+    schedule_to_start_timeout:,
+    start_to_close_timeout:,
+    heartbeat_timeout:,
+    retry_policy:,
+    priority:,
+    start_delay:
+  ); end
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :task_queue
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :schedule_to_close_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :schedule_to_start_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :start_to_close_timeout
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :heartbeat_timeout
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  attr_reader :retry_policy
+
+  sig { returns(Temporalio::Priority) }
+  attr_reader :priority
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :start_delay
+end

data/rbi/temporalio/client/activity_execution_status.rbi

@@ -8,4 +8,5 @@ module Temporalio::Client::ActivityExecutionStatus
   CANCELED = T.let(T.unsafe(nil), Integer)
   TERMINATED = T.let(T.unsafe(nil), Integer)
   TIMED_OUT = T.let(T.unsafe(nil), Integer)
+  PAUSED = T.let(T.unsafe(nil), Integer)
 end

data/rbi/temporalio/client/activity_handle.rbi

@@ -1,6 +1,8 @@
 # typed: true
 
 class Temporalio::Client::ActivityHandle
+  UPDATABLE_OPTION_PATHS = T.let(T.unsafe(nil), T::Hash[Symbol, String])
+
   sig do
     params(
       client: Temporalio::Client,
@@ -28,8 +30,22 @@ class Temporalio::Client::ActivityHandle
   end
   def result(result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
 
-  sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Client::ActivityExecution::Description) }
-  def describe(rpc_options: T.unsafe(nil)); end
+  sig do
+    params(
+      include_input: T::Boolean,
+      include_outcome: T::Boolean,
+      include_heartbeat_details: T::Boolean,
+      include_last_failure: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::ActivityExecution::Description)
+  end
+  def describe(
+    include_input: T.unsafe(nil),
+    include_outcome: T.unsafe(nil),
+    include_heartbeat_details: T.unsafe(nil),
+    include_last_failure: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
 
   sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
   def cancel(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
@@ -37,6 +53,31 @@ class Temporalio::Client::ActivityHandle
   sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
   def terminate(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
 
+  sig { params(reason: T.nilable(String), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def pause(reason = T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      reason: T.nilable(String),
+      jitter: T.nilable(Float),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).void
+  end
+  def unpause(reason: T.unsafe(nil), jitter: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      updates: Temporalio::Client::ActivityOptions::Update,
+      restore_original: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::ActivityExecutionOptions)
+  end
+  def update_options(
+    *updates,
+    restore_original: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
+
   private
 
   sig do

data/rbi/temporalio/client/activity_options.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Temporalio
+  class Client
+    module ActivityOptions
+      class Key
+        sig { returns(String) }
+        def name; end
+
+        sig do
+          params(
+            name: String,
+            to_proto: T.proc.params(proto: Temporalio::Api::Activity::V1::ActivityOptions, value: Object).void
+          ).void
+        end
+        def initialize(name, &to_proto); end
+
+        sig { params(value: Object).returns(Temporalio::Client::ActivityOptions::Update) }
+        def value_set(value); end
+
+        sig { returns(Temporalio::Client::ActivityOptions::Update) }
+        def value_unset; end
+
+        sig { params(proto: Temporalio::Api::Activity::V1::ActivityOptions, value: Object).void }
+        def _apply(proto, value); end
+      end
+
+      class Update
+        sig { returns(Temporalio::Client::ActivityOptions::Key) }
+        def key; end
+
+        sig { returns(T.nilable(Object)) }
+        def value; end
+
+        sig { params(key: Temporalio::Client::ActivityOptions::Key, value: T.nilable(Object)).void }
+        def initialize(key, value); end
+      end
+
+      TASK_QUEUE = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      SCHEDULE_TO_CLOSE_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      SCHEDULE_TO_START_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      START_TO_CLOSE_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      HEARTBEAT_TIMEOUT = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      START_DELAY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      RETRY_POLICY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+      PRIORITY = T.let(T.unsafe(nil), Temporalio::Client::ActivityOptions::Key)
+    end
+  end
+end

data/rbi/temporalio/client/connection/workflow_service.rbi

@@ -374,4 +374,7 @@ class Temporalio::Client::Connection::WorkflowService < ::Temporalio::Client::Co
 
   sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionResponse) }
   def delete_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end
+
+  sig { params(request: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionTimeSkippingRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionTimeSkippingResponse) }
+  def poll_workflow_execution_time_skipping(request, rpc_options: T.unsafe(nil)); end
 end

data/rbi/temporalio/client/connection.rbi

@@ -15,6 +15,7 @@ class Temporalio::Client::Connection
       lazy_connect: T::Boolean,
       dns_load_balancing: T.nilable(Temporalio::Client::Connection::DnsLoadBalancingOptions),
       grpc_compression: T.any(Temporalio::Client::Connection::GrpcCompressionOptions::Gzip, Temporalio::Client::Connection::GrpcCompressionOptions::None),
+      payload_limits: Temporalio::Client::Connection::PayloadLimitsOptions,
       around_connect: T.nilable(T.proc.params(arg0: Temporalio::Client::Connection::Options, arg1: T.proc.params(arg0: Temporalio::Client::Connection::Options).void).void)
     ).void
   end
@@ -31,6 +32,7 @@ class Temporalio::Client::Connection
     lazy_connect: T.unsafe(nil),
     dns_load_balancing: T.unsafe(nil),
     grpc_compression: T.unsafe(nil),
+    payload_limits: T.unsafe(nil),
     around_connect: T.unsafe(nil)
   ); end
 

data/rbi/temporalio/client/interceptor.rbi

@@ -834,6 +834,18 @@ class Temporalio::Client::Interceptor::DescribeActivityInput < ::Data
   sig { returns(T.nilable(String)) }
   def activity_run_id; end
 
+  sig { returns(T::Boolean) }
+  def include_input; end
+
+  sig { returns(T::Boolean) }
+  def include_outcome; end
+
+  sig { returns(T::Boolean) }
+  def include_heartbeat_details; end
+
+  sig { returns(T::Boolean) }
+  def include_last_failure; end
+
   sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
   def rpc_options; end
 
@@ -849,6 +861,88 @@ class Temporalio::Client::Interceptor::DescribeActivityInput < ::Data
   end
 end
 
+class Temporalio::Client::Interceptor::PauseActivityInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def reason; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseActivityInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseActivityInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+class Temporalio::Client::Interceptor::UnpauseActivityInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def reason; end
+
+  sig { returns(T.nilable(Float)) }
+  def jitter; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseActivityInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseActivityInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+class Temporalio::Client::Interceptor::UpdateActivityOptionsInput < ::Data
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(Temporalio::Api::Activity::V1::ActivityOptions) }
+  def activity_options; end
+
+  sig { returns(Google::Protobuf::FieldMask) }
+  def update_mask; end
+
+  sig { returns(T::Boolean) }
+  def restore_original; end
+
+  sig { returns(T.nilable(Temporalio::Client::RPCOptions)) }
+  def rpc_options; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateActivityOptionsInput) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateActivityOptionsInput) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end
+
 class Temporalio::Client::Interceptor::CancelActivityInput < ::Data
   sig { returns(String) }
   def activity_id; end
@@ -1056,6 +1150,19 @@ class Temporalio::Client::Interceptor::Outbound
   sig { params(input: Temporalio::Client::Interceptor::TerminateActivityInput).void }
   def terminate_activity(input); end
 
+  sig { params(input: Temporalio::Client::Interceptor::PauseActivityInput).void }
+  def pause_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::UnpauseActivityInput).void }
+  def unpause_activity(input); end
+
+
+  sig do
+    params(input: Temporalio::Client::Interceptor::UpdateActivityOptionsInput)
+      .returns(Temporalio::Client::ActivityExecutionOptions)
+  end
+  def update_activity_options(input); end
+
   sig { params(input: Temporalio::Client::Interceptor::ListActivitiesInput).returns(T::Enumerator[Temporalio::Client::ActivityExecution]) }
   def list_activities(input); end
 

data/rbi/temporalio/converters/failure_converter.rbi

@@ -6,8 +6,13 @@ class Temporalio::Converters::FailureConverter
   sig { returns(Temporalio::Converters::FailureConverter) }
   def self.default; end
 
-  sig { params(encode_common_attributes: T::Boolean).void }
-  def initialize(encode_common_attributes: T.unsafe(nil)); end
+  sig do
+    params(
+      encode_common_attributes: T::Boolean,
+      process_common_attributes: T.nilable(T.proc.params(arg0: T::Hash[Symbol, T.nilable(String)]).returns(Object))
+    ).void
+  end
+  def initialize(encode_common_attributes: T.unsafe(nil), process_common_attributes: T.unsafe(nil)); end
 
   sig { returns(T::Boolean) }
   attr_reader :encode_common_attributes

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

@@ -172,6 +172,121 @@ class Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion
   end
 end
 
+# Metrics for a set of external payload storage operations (all uploads and downloads)
+# performed while processing a task, so core can emit unified logging and metrics.
+class Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      payload_count: T.nilable(Integer),
+      total_size_bytes: T.nilable(Integer),
+      total_duration: T.nilable(Google::Protobuf::Duration),
+      driver_names: T.nilable(T::Array[String])
+    ).void
+  end
+  def initialize(
+    payload_count: 0,
+    total_size_bytes: 0,
+    total_duration: nil,
+    driver_names: []
+  )
+  end
+
+  # Number of payloads stored or retrieved externally.
+  sig { returns(Integer) }
+  def payload_count
+  end
+
+  # Number of payloads stored or retrieved externally.
+  sig { params(value: Integer).void }
+  def payload_count=(value)
+  end
+
+  # Number of payloads stored or retrieved externally.
+  sig { void }
+  def clear_payload_count
+  end
+
+  # Total size in bytes of the externally stored or retrieved payloads.
+  sig { returns(Integer) }
+  def total_size_bytes
+  end
+
+  # Total size in bytes of the externally stored or retrieved payloads.
+  sig { params(value: Integer).void }
+  def total_size_bytes=(value)
+  end
+
+  # Total size in bytes of the externally stored or retrieved payloads.
+  sig { void }
+  def clear_total_size_bytes
+  end
+
+  # Wall-clock time spent on the external storage operations.
+  sig { returns(T.nilable(Google::Protobuf::Duration)) }
+  def total_duration
+  end
+
+  # Wall-clock time spent on the external storage operations.
+  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
+  def total_duration=(value)
+  end
+
+  # Wall-clock time spent on the external storage operations.
+  sig { void }
+  def clear_total_duration
+  end
+
+  # Names of the drivers that participated in the operations.
+  sig { returns(T::Array[String]) }
+  def driver_names
+  end
+
+  # Names of the drivers that participated in the operations.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def driver_names=(value)
+  end
+
+  # Names of the drivers that participated in the operations.
+  sig { void }
+  def clear_driver_names
+  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::Common::ExternalStorageMetrics) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
 module Temporalio::Internal::Bridge::Api::Common::VersioningIntent
   self::UNSPECIFIED = T.let(0, Integer)
   self::COMPATIBLE = T.let(1, Integer)

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

@@ -11,13 +11,17 @@ class Temporalio::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationC
     params(
       run_id: T.nilable(String),
       successful: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success),
-      failed: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure)
+      failed: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure),
+      payload_download_metrics: T.nilable(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics),
+      payload_upload_metrics: T.nilable(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics)
     ).void
   end
   def initialize(
     run_id: "",
     successful: nil,
-    failed: nil
+    failed: nil,
+    payload_download_metrics: nil,
+    payload_upload_metrics: nil
   )
   end
 
@@ -60,6 +64,42 @@ class Temporalio::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationC
   def clear_failed
   end
 
+  # Metrics for external payload storage downloads (retrievals) performed while processing
+# this activation. Only set when external storage retrieved payloads.
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics)) }
+  def payload_download_metrics
+  end
+
+  # Metrics for external payload storage downloads (retrievals) performed while processing
+# this activation. Only set when external storage retrieved payloads.
+  sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics)).void }
+  def payload_download_metrics=(value)
+  end
+
+  # Metrics for external payload storage downloads (retrievals) performed while processing
+# this activation. Only set when external storage retrieved payloads.
+  sig { void }
+  def clear_payload_download_metrics
+  end
+
+  # Metrics for external payload storage uploads (stores) performed while processing this
+# activation. Only set when external storage stored payloads.
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics)) }
+  def payload_upload_metrics
+  end
+
+  # Metrics for external payload storage uploads (stores) performed while processing this
+# activation. Only set when external storage stored payloads.
+  sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Common::ExternalStorageMetrics)).void }
+  def payload_upload_metrics=(value)
+  end
+
+  # Metrics for external payload storage uploads (stores) performed while processing this
+# activation. Only set when external storage stored payloads.
+  sig { void }
+  def clear_payload_upload_metrics
+  end
+
   sig { returns(T.nilable(Symbol)) }
   def status
   end

data/rbi/temporalio/internal/bridge/runtime.rbi

@@ -19,10 +19,12 @@ class Temporalio::Internal::Bridge::Runtime::Options < ::Struct
   sig do
     params(
       telemetry: Temporalio::Internal::Bridge::Runtime::TelemetryOptions,
-      worker_heartbeat_interval: T.nilable(T.any(Integer, Float))
+      worker_heartbeat_interval: T.nilable(T.any(Integer, Float)),
+      disable_environment_info: T::Boolean,
+      runtime_version: T.nilable(String)
     ).void
   end
-  def initialize(telemetry, worker_heartbeat_interval); end
+  def initialize(telemetry, worker_heartbeat_interval, disable_environment_info, runtime_version); end
 
   sig { returns(Temporalio::Internal::Bridge::Runtime::TelemetryOptions) }
   def telemetry; end
@@ -35,6 +37,18 @@ class Temporalio::Internal::Bridge::Runtime::Options < ::Struct
 
   sig { params(_: T.nilable(T.any(Integer, Float))).void }
   def worker_heartbeat_interval=(_); end
+
+  sig { returns(T::Boolean) }
+  def disable_environment_info; end
+
+  sig { params(_: T::Boolean).void }
+  def disable_environment_info=(_); end
+
+  sig { returns(T.nilable(String)) }
+  def runtime_version; end
+
+  sig { params(_: T.nilable(String)).void }
+  def runtime_version=(_); end
 end
 
 class Temporalio::Internal::Bridge::Runtime::TelemetryOptions < ::Struct
@@ -64,14 +78,20 @@ end
 class Temporalio::Internal::Bridge::Runtime::LoggingOptions < ::Struct
   extend T::Sig
 
-  sig { params(log_filter: T.nilable(String)).void }
-  def initialize(log_filter); end
+  sig { params(log_filter: T.nilable(String), log_format: T.nilable(String)).void }
+  def initialize(log_filter, log_format); end
 
   sig { returns(T.nilable(String)) }
   def log_filter; end
 
   sig { params(_: T.nilable(String)).void }
   def log_filter=(_); end
+
+  sig { returns(T.nilable(String)) }
+  def log_format; end
+
+  sig { params(_: T.nilable(String)).void }
+  def log_format=(_); end
 end
 
 class Temporalio::Internal::Bridge::Runtime::MetricsOptions < ::Struct

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

@@ -76,6 +76,7 @@ class Temporalio::Internal::Bridge::Worker::Options < ::Struct
       default_heartbeat_throttle_interval: T.any(Integer, Float),
       max_worker_activities_per_second: T.nilable(T.any(Integer, Float)),
       max_task_queue_activities_per_second: T.nilable(T.any(Integer, Float)),
+      max_eager_activity_reservations_per_workflow_task: Integer,
       graceful_shutdown_period: T.any(Integer, Float),
       nondeterminism_as_workflow_fail: T::Boolean,
       nondeterminism_as_workflow_fail_for_types: T::Array[String],
@@ -101,6 +102,7 @@ class Temporalio::Internal::Bridge::Worker::Options < ::Struct
     default_heartbeat_throttle_interval,
     max_worker_activities_per_second,
     max_task_queue_activities_per_second,
+    max_eager_activity_reservations_per_workflow_task,
     graceful_shutdown_period,
     nondeterminism_as_workflow_fail,
     nondeterminism_as_workflow_fail_for_types,