temporalio 0.6.0-aarch64-linux → 1.0.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6392e502beb6d8efe8c82a61b8fe04019cf07ab3fb14c607c954a7c4f377016
-  data.tar.gz: c74820f6c105324cea2695cf188f43ef52c2010423d922055027fa2eb32f8edf
+  metadata.gz: ebd63f43e6352b2e6c90908129e7e6563c4de136dccd88992f5335ea74bc2147
+  data.tar.gz: b2fec7313d7b5d706a688cca09bc44e7bc0cf8b59f675c22881e342b7b1e4931
 SHA512:
-  metadata.gz: f4dc6046ad00fb550609b469856a37ba99e292248ff13968f5f4949618bb3b84932c948a7b367241a701a71751677a4f1c6bcfcff88e59fa11d14eeca25224af
-  data.tar.gz: 5aa5bada79633821057032e478267f4bc63dad37f6e753cfcd78eda9a922736f407d861be1e6c71cd04e4dc75276644dab6c6c6364db2a643615fc1f9602dc51
+  metadata.gz: 3ceb2889cf8e0331789f7ad30594ff57de0076529086242a817b42378f721f2b481a6fa1abe977cec65244737d6a0f5228905f88e8341bf18f38c508b3e5fb19
+  data.tar.gz: b494b8806e05d9c2af4327f16d20a336e1c9f39ac2abc6c1670391fa11535d18cb262b1cde7ab825637208b8949fb247b61dd884a53afee361e8ee957e4baf6f

data/lib/temporalio/activity/info.rb

@@ -13,6 +13,7 @@ module Temporalio
       :heartbeat_timeout,
       :local?,
       :priority,
+      :retry_policy,
       :raw_heartbeat_details,
       :schedule_to_close_timeout,
       :scheduled_time,
@@ -42,6 +43,10 @@ module Temporalio
     #   @return [Boolean] Whether the activity is a local activity or not.
     # @!attribute priority
     #   @return [Priority] The priority of this activity.
+    # @!attribute retry_policy
+    #   @return [RetryPolicy, nil] Retry policy for the activity. Note that the server may have set a different policy
+    #     than the one provided when scheduling the activity. If the value is None, it means the server didn't send
+    #     information about retry policy (e.g. due to old server version), but it may still be defined server-side.
     # @!attribute raw_heartbeat_details
     #   @return [Array<Converter::RawValue>] Raw details from the last heartbeat of the last attempt. Can use
     #     {heartbeat_details} to get lazily-converted values.

data/lib/temporalio/cancellation.rb

@@ -167,8 +167,8 @@ module Temporalio
       to_return.values
     end
 
-    def canceled_mutex_synchronize(&)
-      Workflow::Unsafe.illegal_call_tracing_disabled { @canceled_mutex.synchronize(&) }
+    def canceled_mutex_synchronize(&block)
+      Workflow::Unsafe.illegal_call_tracing_disabled { @canceled_mutex.synchronize(&block) }
     end
   end
 end

data/lib/temporalio/client/async_activity_handle.rb

@@ -29,6 +29,7 @@ module Temporalio
       # @param details [Array<Object>] Details of the heartbeat.
       # @param detail_hints [Array<Object>, nil] Converter hints for the details.
       # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      # @raise [Error::AsyncActivityCanceledError] If the activity was canceled, paused, and/or reset.
       def heartbeat(*details, detail_hints: nil, rpc_options: nil)
         @client._impl.heartbeat_async_activity(Interceptor::HeartbeatAsyncActivityInput.new(
                                                  task_token_or_id_reference:,

data/lib/temporalio/env_config.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'temporalio/internal/bridge'
+
+module Temporalio
+  # Environment and file-based configuration for Temporal clients
+  #
+  # WARNING: Experimental API.
+  module EnvConfig
+    # This module provides utilities to load Temporal client configuration from TOML files
+    # and environment variables.
+
+    # TLS configuration as specified as part of client configuration
+    #
+    # @!attribute [r] disabled
+    #   @return [Boolean, nil] If true, TLS is explicitly disabled; if nil, not specified
+    # @!attribute [r] server_name
+    #   @return [String, nil] SNI override
+    # @!attribute [r] server_root_ca_cert
+    #   @return [Pathname, String, nil] Server CA certificate source
+    # @!attribute [r] client_cert
+    #   @return [Pathname, String, nil] Client certificate source
+    # @!attribute [r] client_private_key
+    #   @return [Pathname, String, nil] Client key source
+    ClientConfigTLS = Data.define(:disabled, :server_name, :server_root_ca_cert, :client_cert, :client_private_key)
+
+    # TLS configuration for Temporal client connections.
+    #
+    # This class provides methods for creating, serializing, and converting
+    # TLS configuration objects used by Temporal clients.
+    class ClientConfigTLS
+      # Create a ClientConfigTLS from a hash
+      # @param hash [Hash, nil] Hash representation
+      # @return [ClientConfigTLS, nil] The TLS configuration or nil if hash is nil/empty
+      def self.from_h(hash)
+        return nil if hash.nil? || hash.empty?
+
+        new(
+          disabled: hash[:disabled],
+          server_name: hash[:server_name],
+          server_root_ca_cert: hash_to_source(hash[:server_ca_cert]),
+          client_cert: hash_to_source(hash[:client_cert]),
+          client_private_key: hash_to_source(hash[:client_key])
+        )
+      end
+
+      # Set default values
+      def initialize(disabled: nil, server_name: nil, server_root_ca_cert: nil, client_cert: nil,
+                     client_private_key: nil)
+        super
+      end
+
+      # Convert to a hash that can be used for TOML serialization
+      # @return [Hash] Dictionary representation
+      def to_h
+        {
+          disabled:,
+          server_name:,
+          server_ca_cert: server_root_ca_cert ? source_to_hash(server_root_ca_cert) : nil,
+          client_cert: client_cert ? source_to_hash(client_cert) : nil,
+          client_key: client_private_key ? source_to_hash(client_private_key) : nil
+        }.compact
+      end
+
+      # Create a TLS configuration for use with connections
+      # @return [Connection::TLSOptions, false] TLS options or false if disabled
+      def to_client_tls_options
+        return false if disabled
+
+        Client::Connection::TLSOptions.new(
+          domain: server_name,
+          server_root_ca_cert: read_source(server_root_ca_cert),
+          client_cert: read_source(client_cert),
+          client_private_key: read_source(client_private_key)
+        )
+      end
+
+      private
+
+      class << self
+        private
+
+        # Convert hash to source object (Pathname or String)
+        def hash_to_source(hash)
+          return nil if hash.nil?
+
+          # Always expect a hash with path or data
+          if hash[:path]
+            Pathname.new(hash[:path])
+          elsif hash[:data]
+            hash[:data]
+          end
+        end
+      end
+
+      def source_to_hash(source)
+        case source
+        when Pathname
+          { path: source.to_s }
+        when String
+          # String is always treated as data content
+          { data: source }
+        when nil
+          nil
+        else
+          raise TypeError, "Source must be Pathname, String, or nil, got #{source.class}"
+        end
+      end
+
+      def read_source(source)
+        case source
+        when Pathname
+          File.read(source.to_s)
+        when String
+          # String is always treated as raw data content
+          source
+        when nil
+          nil
+        else
+          raise TypeError, "Source must be Pathname, String, or nil, got #{source.class}"
+        end
+      end
+    end
+
+    # Represents a client configuration profile.
+    #
+    # This class holds the configuration as loaded from a file or environment.
+    # See #to_client_connect_options to transform the profile to a connect config hash.
+    #
+    # @!attribute [r] address
+    #   @return [String, nil] Client address
+    # @!attribute [r] namespace
+    #   @return [String, nil] Client namespace
+    # @!attribute [r] api_key
+    #   @return [String, nil] Client API key
+    # @!attribute [r] tls
+    #   @return [Boolean, ClientConfigTLS, nil] TLS configuration
+    # @!attribute [r] grpc_meta
+    #   @return [Hash] gRPC metadata
+    ClientConfigProfile = Data.define(:address, :namespace, :api_key, :tls, :grpc_meta)
+
+    # A client configuration profile loaded from environment and files.
+    #
+    # This class represents a complete client configuration profile that can be
+    # loaded from TOML files and environment variables, and converted to client
+    # connection options.
+    class ClientConfigProfile
+      # Create a ClientConfigProfile from a hash
+      # @param hash [Hash] Hash representation
+      # @return [ClientConfigProfile] The client profile
+      def self.from_h(hash)
+        new(
+          address: hash[:address],
+          namespace: hash[:namespace],
+          api_key: hash[:api_key],
+          tls: ClientConfigTLS.from_h(hash[:tls]),
+          grpc_meta: hash[:grpc_meta] || {}
+        )
+      end
+
+      # Load a single client profile from given sources, applying env overrides.
+      #
+      # @param profile [String, nil] Profile to load from the config
+      # @param config_source [Pathname, String, nil] Configuration source -
+      #   Pathname for file path, String for TOML content
+      # @param disable_file [Boolean] If true, file loading is disabled
+      # @param disable_env [Boolean] If true, environment variable loading and overriding is disabled
+      # @param config_file_strict [Boolean] If true, will error on unrecognized keys
+      # @param override_env_vars [Hash, nil] Environment variables to use for loading and overrides
+      # @return [ClientConfigProfile] The client configuration profile
+      def self.load(
+        profile: nil,
+        config_source: nil,
+        disable_file: false,
+        disable_env: false,
+        config_file_strict: false,
+        override_env_vars: nil
+      )
+        path, data = EnvConfig._source_to_path_and_data(config_source)
+
+        raw_profile = Internal::Bridge::EnvConfig.load_client_connect_config(
+          profile,
+          path,
+          data,
+          disable_file,
+          disable_env,
+          config_file_strict,
+          override_env_vars || {}
+        )
+
+        from_h(raw_profile)
+      end
+
+      # Create a ClientConfigProfile instance with defaults
+      def initialize(address: nil, namespace: nil, api_key: nil, tls: nil, grpc_meta: {})
+        super
+      end
+
+      # Convert to a hash that can be used for TOML serialization
+      # @return [Hash] Dictionary representation
+      def to_h
+        {
+          address: address,
+          namespace: namespace,
+          api_key: api_key,
+          tls: tls&.to_h&.then { |tls_hash| tls_hash.empty? ? nil : tls_hash }, # steep:ignore
+          grpc_meta: grpc_meta && grpc_meta.empty? ? nil : grpc_meta
+        }.compact
+      end
+
+      # Create a client connect config from this profile
+      # @return [Array] Tuple of [positional_args, keyword_args] that can be splatted to Client.connect
+      def to_client_connect_options
+        positional_args = [address, namespace].compact
+        tls_value = false
+        if tls
+          tls_value = tls.to_client_tls_options
+        elsif api_key
+          tls_value = true
+        end
+
+        keyword_args = {
+          api_key: api_key,
+          rpc_metadata: (grpc_meta if grpc_meta && !grpc_meta.empty?),
+          tls: tls_value
+        }.compact
+
+        [positional_args, keyword_args]
+      end
+    end
+
+    # Client configuration loaded from TOML and environment variables.
+    #
+    # This contains a mapping of profile names to client profiles.
+    #
+    # @!attribute [r] profiles
+    #   @return [Hash<String, ClientConfigProfile>] Map of profile name to its corresponding ClientConfigProfile
+    ClientConfig = Data.define(:profiles)
+
+    # Container for multiple client configuration profiles.
+    #
+    # This class holds a collection of named client profiles loaded from
+    # configuration sources and provides methods for profile management
+    # and client connection configuration.
+    class ClientConfig
+      # Create a ClientConfig from a hash
+      # @param hash [Hash] Hash representation
+      # @return [ClientConfig] The client configuration
+      def self.from_h(hash)
+        profiles = hash.transform_values do |profile_hash|
+          ClientConfigProfile.from_h(profile_hash)
+        end
+        new(profiles: profiles)
+      end
+
+      # Load all client profiles from given sources.
+      #
+      # This does not apply environment variable overrides to the profiles, it
+      # only uses an environment variable to find the default config file path
+      # (TEMPORAL_CONFIG_FILE).
+      #
+      # @param config_source [Pathname, String, nil] Configuration source
+      # @param config_file_strict [Boolean] If true, will error on unrecognized keys
+      # @param override_env_vars [Hash, nil] Environment variables to use
+      # @return [ClientConfig] The client configuration
+      def self.load(
+        config_source: nil,
+        config_file_strict: false,
+        override_env_vars: nil
+      )
+        path, data = EnvConfig._source_to_path_and_data(config_source)
+
+        loaded_profiles = Internal::Bridge::EnvConfig.load_client_config(
+          path,
+          data,
+          config_file_strict,
+          override_env_vars || {}
+        )
+
+        from_h(loaded_profiles)
+      end
+
+      # Load a single client profile and convert to connect config
+      #
+      # This is a convenience function that combines loading a profile and
+      # converting it to a connect config hash.
+      #
+      # @param profile [String, nil] The profile to load from the config
+      # @param config_source [Pathname, String, nil] Configuration source
+      # @param disable_file [Boolean] If true, file loading is disabled
+      # @param disable_env [Boolean] If true, environment variable loading and overriding is disabled
+      # @param config_file_strict [Boolean] If true, will error on unrecognized keys
+      # @param override_env_vars [Hash, nil] Environment variables to use for loading and overrides
+      # @return [Array] Tuple of [positional_args, keyword_args] that can be splatted to Client.connect
+      def self.load_client_connect_options(
+        profile: nil,
+        config_source: nil,
+        disable_file: false,
+        disable_env: false,
+        config_file_strict: false,
+        override_env_vars: nil
+      )
+        prof = ClientConfigProfile.load(
+          profile: profile,
+          config_source: config_source,
+          disable_file: disable_file,
+          disable_env: disable_env,
+          config_file_strict: config_file_strict,
+          override_env_vars: override_env_vars
+        )
+        prof.to_client_connect_options
+      end
+
+      # Create a ClientConfig instance with defaults
+      def initialize(profiles: {})
+        super
+      end
+
+      # Convert to a hash that can be used for TOML serialization
+      # @return [Hash] Dictionary representation
+      def to_h
+        profiles.transform_values(&:to_h)
+      end
+    end
+
+    # @param source [Pathname, String, nil] Configuration source
+    # @return [Array<String?, String?>] Tuple of [path, data]
+    # @!visibility private
+    def self._source_to_path_and_data(source)
+      case source
+      when Pathname
+        [source.to_s, nil]
+      when String
+        [nil, source]
+      when nil
+        [nil, nil]
+      else
+        raise TypeError, "Must be Pathname, String, or nil, got #{source.class}"
+      end
+    end
+  end
+end

data/lib/temporalio/error.rb

@@ -97,9 +97,13 @@ module Temporalio
 
     # Error that occurs when an async activity handle tries to heartbeat and the activity is marked as canceled.
     class AsyncActivityCanceledError < Error
+      # @return [Activity::CancellationDetails]
+      attr_reader :details
+
       # @!visibility private
-      def initialize
+      def initialize(details)
         super('Activity canceled')
+        @details = details
       end
     end
 

data/lib/temporalio/internal/bridge/worker.rb

@@ -40,6 +40,7 @@ module Temporalio
         TunerSlotSupplierOptions = Struct.new(
           :fixed_size,
           :resource_based,
+          :custom,
           keyword_init: true
         )
 
@@ -103,6 +104,55 @@ module Temporalio
           # TODO(cretz): Log error on this somehow?
           async_complete_activity_task(proto.to_proto, queue)
         end
+
+        class CustomSlotSupplier
+          def initialize(slot_supplier:, thread_pool:)
+            @slot_supplier = slot_supplier
+            @thread_pool = thread_pool
+          end
+
+          def reserve_slot(context, cancellation, &block)
+            run_user_code do
+              @slot_supplier.reserve_slot(context, cancellation) { |v| block.call(v) }
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          def try_reserve_slot(context, &block)
+            run_user_code do
+              block.call(@slot_supplier.try_reserve_slot(context))
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          def mark_slot_used(context, &block)
+            run_user_code do
+              block.call(@slot_supplier.mark_slot_used(context))
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          def release_slot(context, &block)
+            run_user_code do
+              block.call(@slot_supplier.release_slot(context))
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          private
+
+          def run_user_code(&)
+            if @thread_pool
+              @thread_pool.execute(&)
+            else
+              yield
+            end
+          end
+        end
       end
     end
   end

data/lib/temporalio/internal/client/implementation.rb

@@ -2,6 +2,7 @@
 
 require 'google/protobuf/well_known_types'
 require 'securerandom'
+require 'temporalio/activity'
 require 'temporalio/api'
 require 'temporalio/client/activity_id_reference'
 require 'temporalio/client/async_activity_handle'
@@ -829,9 +830,13 @@ module Temporalio
                      rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
                    )
                  end
-          raise Error::AsyncActivityCanceledError if resp.cancel_requested
+          return unless resp.cancel_requested || resp.activity_paused || resp.activity_reset
 
-          nil
+          raise Error::AsyncActivityCanceledError, Activity::CancellationDetails.new(
+            cancel_requested: resp.cancel_requested,
+            paused: resp.activity_paused,
+            reset: resp.activity_reset
+          )
         end
 
         def complete_async_activity(input)

data/lib/temporalio/internal/worker/activity_worker.rb

@@ -185,6 +185,7 @@ module Temporalio
               payloads = codec.decode(payloads) if codec
               payloads.map { |p| Temporalio::Converters::RawValue.new(p) }
             end,
+            retry_policy: (RetryPolicy._from_proto(start.retry_policy) if start.retry_policy),
             schedule_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(start.schedule_to_close_timeout),
             scheduled_time: Internal::ProtoUtils.timestamp_to_time(start.scheduled_time) || raise, # Never nil
             start_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(start.start_to_close_timeout),

data/lib/temporalio/internal/worker/workflow_instance/context.rb

@@ -130,6 +130,7 @@ module Temporalio
           def execute_local_activity(
             activity,
             *args,
+            summary:,
             schedule_to_close_timeout:,
             schedule_to_start_timeout:,
             start_to_close_timeout:,
@@ -157,6 +158,7 @@ module Temporalio
               Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput.new(
                 activity:,
                 args:,
+                summary:,
                 schedule_to_close_timeout:,
                 schedule_to_start_timeout:,
                 start_to_close_timeout:,

data/lib/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rb

@@ -84,7 +84,7 @@ module Temporalio
                 when :all
                   ''
                 when Temporalio::Worker::IllegalWorkflowCallValidator
-                  disable do
+                  disable_temporarily do
                     vals.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
                                       class_name:, method_name: tp.callee_id, trace_point: tp
                                     ))
@@ -98,7 +98,7 @@ module Temporalio
                   when true
                     ''
                   when Temporalio::Worker::IllegalWorkflowCallValidator
-                    disable do
+                    disable_temporarily do
                       per_method.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
                                               class_name:, method_name: tp.callee_id, trace_point: tp
                                             ))
@@ -118,8 +118,11 @@ module Temporalio
           end
 
           def enable(&block)
-            # We've seen leaking issues in Ruby 3.2 where the TracePoint inadvertently remains enabled even for threads
-            # that it was not started on. So we will check the thread ourselves.
+            # This is not reentrant and not expected to be called as such. We've seen leaking issues in Ruby 3.2 where
+            # the TracePoint inadvertently remains enabled even for threads that it was not started on. So we will check
+            # the thread ourselves. We also use the "enabled thread" concept for disabling checks too, see
+            # disable_temporarily for more details.
+
             @enabled_thread = Thread.current
             @tracepoint.enable do
               block.call
@@ -128,13 +131,17 @@ module Temporalio
             end
           end
 
-          def disable(&block)
+          def disable_temporarily(&)
+            # An earlier version of this used @tracepoint.disable, but in some versions of Ruby, the observed behavior
+            # is confusingly not reentrant or at least not predictable. Therefore, instead of calling
+            # @tracepoint.disable, we are just unsetting the enabled thread. This means the tracer is still running, but
+            # no checks are performed. This is effectively a no-op if tracing was never enabled.
+
             previous_thread = @enabled_thread
-            @tracepoint.disable do
-              block.call
-            ensure
-              @enabled_thread = previous_thread
-            end
+            @enabled_thread = nil
+            yield
+          ensure
+            @enabled_thread = previous_thread
           end
         end
       end

data/lib/temporalio/internal/worker/workflow_instance/outbound_implementation.rb

@@ -114,14 +114,15 @@ module Temporalio
                     local_retry_threshold: ProtoUtils.seconds_to_duration(input.local_retry_threshold),
                     attempt: do_backoff&.attempt || 0,
                     original_schedule_time: do_backoff&.original_schedule_time
-                  )
+                  ),
+                  user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
                 )
               )
               seq
             end
           end
 
-          def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &)
+          def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &block)
             # We do not even want to schedule if the cancellation is already cancelled. We choose to use canceled
             # failure instead of wrapping in activity failure which is similar to what other SDKs do, with the accepted
             # tradeoff that it makes rescue more difficult (hence the presence of Error.canceled? helper).
@@ -130,7 +131,7 @@ module Temporalio
             # This has to be done in a loop for local activity backoff
             last_local_backoff = nil
             loop do
-              result = execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
+              result = execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block)
               return result unless result.is_a?(Bridge::Api::ActivityResult::DoBackoff)
 
               # @type var result: untyped
@@ -142,9 +143,9 @@ module Temporalio
           end
 
           # If this doesn't raise, it returns success | DoBackoff
-          def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
+          def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block)
             # Add to pending activities (removed by the resolver)
-            seq = yield last_local_backoff
+            seq = block.call(last_local_backoff)
             @instance.pending_activities[seq] = Fiber.current
 
             # Add cancellation hook

data/lib/temporalio/internal/worker/workflow_instance.rb

@@ -125,6 +125,7 @@ module Temporalio
               continued_run_id: ProtoUtils.string_or(@init_job.continued_from_execution_run_id),
               cron_schedule: ProtoUtils.string_or(@init_job.cron_schedule),
               execution_timeout: ProtoUtils.duration_to_seconds(@init_job.workflow_execution_timeout),
+              first_execution_run_id: @init_job.first_execution_run_id,
               headers: ProtoUtils.headers_from_proto_map(@init_job.headers, @payload_converter) || {},
               last_failure: if @init_job.continued_failure
                               @failure_converter.from_failure(@init_job.continued_failure, @payload_converter)
@@ -162,86 +163,9 @@ module Temporalio
         end
 
         def activate(activation)
-          # Run inside of scheduler
-          run_in_scheduler { activate_internal(activation) }
-        end
-
-        def add_command(command)
-          raise Workflow::InvalidWorkflowStateError, 'Cannot add commands in this context' if @context_frozen
-
-          @commands << command
-        end
-
-        def instance
-          @instance or raise 'Instance accessed before created'
-        end
-
-        def search_attributes
-          # Lazy on first access
-          @search_attributes ||= SearchAttributes._from_proto(
-            @init_job.search_attributes, disable_mutations: true, never_nil: true
-          ) || raise
-        end
-
-        def memo
-          # Lazy on first access
-          @memo ||= ExternallyImmutableHash.new(ProtoUtils.memo_from_proto(@init_job.memo, payload_converter) || {})
-        end
-
-        def now
-          # Create each time
-          ProtoUtils.timestamp_to_time(@now_timestamp) or raise 'Time unexpectedly not present'
-        end
-
-        def illegal_call_tracing_disabled(&)
-          @tracer.disable(&)
-        end
-
-        def patch(patch_id:, deprecated:)
-          # Use memoized result if present. If this is being deprecated, we can still use memoized result and skip the
-          # command.
-          patch_id = patch_id.to_s
-          @patches_memoized ||= {}
-          @patches_memoized.fetch(patch_id) do
-            patched = !replaying || @patches_notified.include?(patch_id)
-            @patches_memoized[patch_id] = patched
-            if patched
-              add_command(
-                Bridge::Api::WorkflowCommands::WorkflowCommand.new(
-                  set_patch_marker: Bridge::Api::WorkflowCommands::SetPatchMarker.new(patch_id:, deprecated:)
-                )
-              )
-            end
-            patched
-          end
-        end
-
-        def metric_meter
-          @metric_meter ||= ReplaySafeMetric::Meter.new(
-            @runtime_metric_meter.with_additional_attributes(
-              {
-                namespace: info.namespace,
-                task_queue: info.task_queue,
-                workflow_type: info.workflow_type
-              }
-            )
-          )
-        end
-
-        private
-
-        def run_in_scheduler(&)
+          # Run inside of scheduler (removed on ensure)
           Fiber.set_scheduler(@scheduler)
-          if @tracer
-            @tracer.enable(&)
-          else
-            yield
-          end
-        ensure
-          Fiber.set_scheduler(nil)
-        end
 
-        def activate_internal(activation)
           # Reset some activation state
           @commands = []
           @current_activation_error = nil
@@ -266,8 +190,12 @@ module Temporalio
             # the first activation)
             @primary_fiber ||= schedule(top_level: true) { run_workflow }
 
-            # Run the event loop
-            @scheduler.run_until_all_yielded
+            # Run the event loop in the tracer if it exists
+            if @tracer
+              @tracer.enable { @scheduler.run_until_all_yielded }
+            else
+              @scheduler.run_until_all_yielded
+            end
           rescue Exception => e # rubocop:disable Lint/RescueException
             on_top_level_exception(e)
           end
@@ -306,8 +234,77 @@ module Temporalio
         ensure
           @commands = nil
           @current_activation_error = nil
+          Fiber.set_scheduler(nil)
+        end
+
+        def add_command(command)
+          raise Workflow::InvalidWorkflowStateError, 'Cannot add commands in this context' if @context_frozen
+
+          @commands << command
+        end
+
+        def instance
+          @instance or raise 'Instance accessed before created'
+        end
+
+        def search_attributes
+          # Lazy on first access
+          @search_attributes ||= SearchAttributes._from_proto(
+            @init_job.search_attributes, disable_mutations: true, never_nil: true
+          ) || raise
+        end
+
+        def memo
+          # Lazy on first access
+          @memo ||= ExternallyImmutableHash.new(ProtoUtils.memo_from_proto(@init_job.memo, payload_converter) || {})
+        end
+
+        def now
+          # Create each time
+          ProtoUtils.timestamp_to_time(@now_timestamp) or raise 'Time unexpectedly not present'
         end
 
+        def illegal_call_tracing_disabled(&)
+          if @tracer
+            @tracer.disable_temporarily(&)
+          else
+            yield
+          end
+        end
+
+        def patch(patch_id:, deprecated:)
+          # Use memoized result if present. If this is being deprecated, we can still use memoized result and skip the
+          # command.
+          patch_id = patch_id.to_s
+          @patches_memoized ||= {}
+          @patches_memoized.fetch(patch_id) do
+            patched = !replaying || @patches_notified.include?(patch_id)
+            @patches_memoized[patch_id] = patched
+            if patched
+              add_command(
+                Bridge::Api::WorkflowCommands::WorkflowCommand.new(
+                  set_patch_marker: Bridge::Api::WorkflowCommands::SetPatchMarker.new(patch_id:, deprecated:)
+                )
+              )
+            end
+            patched
+          end
+        end
+
+        def metric_meter
+          @metric_meter ||= ReplaySafeMetric::Meter.new(
+            @runtime_metric_meter.with_additional_attributes(
+              {
+                namespace: info.namespace,
+                task_queue: info.task_queue,
+                workflow_type: info.workflow_type
+              }
+            )
+          )
+        end
+
+        private
+
         def create_instance
           # Convert workflow arguments
           @workflow_arguments = convert_args(payload_array: @init_job.arguments,

data/lib/temporalio/testing/activity_environment.rb

@@ -25,6 +25,7 @@ module Temporalio
           local?: false,
           priority: Temporalio::Priority.default,
           raw_heartbeat_details: [],
+          retry_policy: RetryPolicy.new,
           schedule_to_close_timeout: 1.0,
           scheduled_time: Time.at(0),
           start_to_close_timeout: 1.0,

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '0.6.0'
+  VERSION = '1.0.0'
 end

data/lib/temporalio/worker/interceptor.rb

@@ -228,6 +228,7 @@ module Temporalio
         ExecuteLocalActivityInput = Data.define(
           :activity,
           :args,
+          :summary,
           :schedule_to_close_timeout,
           :schedule_to_start_timeout,
           :start_to_close_timeout,

data/lib/temporalio/worker/tuner.rb

@@ -22,10 +22,11 @@ module Temporalio
           end
 
           # @!visibility private
-          def _to_bridge_options
+          def _to_bridge_options(_tuner)
             Internal::Bridge::Worker::TunerSlotSupplierOptions.new(
               fixed_size: slots,
-              resource_based: nil
+              resource_based: nil,
+              custom: nil
             )
           end
         end
@@ -36,7 +37,7 @@ module Temporalio
         class ResourceBased < SlotSupplier
           attr_reader :tuner_options, :slot_options
 
-          # Create a reosurce-based slot supplier.
+          # Create a resource-based slot supplier.
           #
           # @param tuner_options [ResourceBasedTunerOptions] General tuner options.
           # @param slot_options [ResourceBasedSlotOptions] Slot-supplier-specific tuner options.
@@ -46,7 +47,7 @@ module Temporalio
           end
 
           # @!visibility private
-          def _to_bridge_options
+          def _to_bridge_options(_tuner)
             Internal::Bridge::Worker::TunerSlotSupplierOptions.new(
               fixed_size: nil,
               resource_based: Internal::Bridge::Worker::TunerResourceBasedSlotSupplierOptions.new(
@@ -55,14 +56,175 @@ module Temporalio
                 min_slots: slot_options.min_slots,
                 max_slots: slot_options.max_slots,
                 ramp_throttle: slot_options.ramp_throttle
+              ),
+              custom: nil
+            )
+          end
+        end
+
+        # A slot supplier that has callbacks invoked to handle slot supplying.
+        #
+        # Users should be cautious when implementing this and make sure it is heavily tested and the documentation for
+        # every method is well understood.
+        #
+        # @note WARNING: This API is experimental.
+        class Custom < SlotSupplier
+          # Context provided for slot reservation on custom slot supplier.
+          #
+          # @!attribute slot_type
+          #   @return [:workflow, :activity, :local_activity, :nexus] Slot type.
+          # @!attribute task_queue
+          #   @return [String] Task queue.
+          # @!attribute worker_identity
+          #   @return [String] Worker identity.
+          # @!attribute worker_deployment_name
+          #   @return [String] Worker deployment name or empty string if not applicable.
+          # @!attribute worker_build_id
+          #   @return [String] Worker build ID or empty string if not applicable.
+          # @!attribute sticky?
+          #   @return [Boolean] True if this reservation is for a sticky workflow task.
+          ReserveContext = Data.define(
+            :slot_type,
+            :task_queue,
+            :worker_identity,
+            :worker_deployment_name,
+            :worker_build_id,
+            :sticky?
+          )
+
+          # Context provided for marking a slot used.
+          #
+          # @!attribute slot_info
+          #   @return [SlotInfo::Workflow, SlotInfo::Activity, SlotInfo::LocalActivity, SlotInfo::Nexus] Information
+          #     about the slot. This is never nil.
+          # @!attribute permit
+          #   @return [Object] Object that was provided as the permit on reserve.
+          MarkUsedContext = Data.define(
+            :slot_info,
+            :permit
+          )
+
+          # Context provided for releasing a slot.
+          #
+          # @!attribute slot_info
+          #   @return [SlotInfo::Workflow, SlotInfo::Activity, SlotInfo::LocalActivity, SlotInfo::Nexus, nil]
+          #     Information about the slot. This may be nil if the slot was never used.
+          # @!attribute permit
+          #   @return [Object] Object that was provided as the permit on reserve.
+          ReleaseContext = Data.define(
+            :slot_info,
+            :permit
+          )
+
+          # Reserve a slot.
+          #
+          # This can/should block and must provide the permit to the (code) block. The permit is any object (including
+          # nil) that will be given on the context for mark_slot_used and release_slot.
+          #
+          # Just returning from this call is not enough to reserve the slot, a permit must be provided to the block
+          # (e.g. via yield or block.call). If the call completes, the system will still wait on the block (so this can
+          # be backgrounded by passing the block to something else). Reservations may be canceled via the given
+          # cancellation. Users can do things like add_cancel_callback, but it is very important that the code in the
+          # callback is fast as it is run on the same reactor thread as many other Temporal Ruby worker calls.
+          #
+          # @note WARNING: This call should never raise an exception. Any exception raised is ignored and this is called
+          #   again after 1 second.
+          #
+          # @param context [ReserveContext] Contextual information about this reserve call.
+          # @param cancellation [Cancellation] Cancellation that is canceled when the reservation is no longer being
+          #   asked for.
+          # @yield [Object] Confirm reservation and provide a permit.
+          def reserve_slot(context, cancellation, &)
+            raise NotImplementedError
+          end
+
+          # Try to reserve a slot.
+          #
+          # @note WARNING: This should never block, this should return immediately with a permit, or nil if the
+          #   reservation could not occur.
+          #
+          # @note WARNING: This call should never raise an exception. Any exception raised is ignored and the slot
+          #   reservation attempt fails (i.e. same as if this method returned nil).
+          #
+          # @param context [ReserveContext] Contextual information about this reserve call.
+          # @return [Object, nil] A non-nil object to perform the reservation successfully, a nil to fail the
+          #   reservation.
+          def try_reserve_slot(context)
+            raise NotImplementedError
+          end
+
+          # Mark a slot as used.
+          #
+          # Due to the nature of Temporal polling, slots are reserved before they are used and may never get used. This
+          # call is made as just a notification when a slot is actually used.
+          #
+          # @note WARNING: This should never block, this should return immediately.
+          #
+          # @note WARNING: This call should never raise an exception. Any exception raised is ignored.
+          #
+          # @param context [MarkUsedContext] Contextual information about this reserve call.
+          def mark_slot_used(context)
+            raise NotImplementedError
+          end
+
+          # Release a previously reserved slot.
+          #
+          # @note WARNING: This should never block, this should return immediately.
+          #
+          # @note WARNING: This call should never raise an exception. Any exception raised is ignored.
+          #
+          # @param context [ReleaseContext] Contextual information about this reserve call.
+          def release_slot(context)
+            raise NotImplementedError
+          end
+
+          # @!visibility private
+          def _to_bridge_options(tuner)
+            Internal::Bridge::Worker::TunerSlotSupplierOptions.new(
+              fixed_size: nil,
+              resource_based: nil,
+              custom: Internal::Bridge::Worker::CustomSlotSupplier.new(
+                slot_supplier: self,
+                thread_pool: tuner.custom_slot_supplier_thread_pool
               )
             )
           end
+
+          # Slot information.
+          module SlotInfo
+            # Information about a workflow slot.
+            #
+            # @!attribute workflow_type
+            #   @return [String] Workflow type.
+            # @!attribute sticky?
+            #   @return [Boolean] Whether the slot was for a sticky task.
+            Workflow = Data.define(:workflow_type, :sticky?)
+
+            # Information about an activity slot.
+            #
+            # @!attribute activity_type
+            #   @return [String] Activity type.
+            Activity = Data.define(:activity_type)
+
+            # Information about a local activity slot.
+            #
+            # @!attribute activity_type
+            #   @return [String] Activity type.
+            LocalActivity = Data.define(:activity_type)
+
+            # Information about a Nexus slot.
+            #
+            # @!attribute service
+            #   @return [String] Nexus service.
+            # @!attribute operation
+            #   @return [String] Nexus operation.
+            Nexus = Data.define(:service, :operation)
+          end
         end
 
         # @!visibility private
-        def _to_bridge_options
-          raise ArgumentError, 'Tuner slot suppliers must be instances of Fixed or ResourceBased'
+        def _to_bridge_options(_tuner)
+          raise ArgumentError, 'Tuner slot suppliers must be instances of Fixed, ResourceBased, or Custom'
         end
       end
 
@@ -75,10 +237,9 @@ module Temporalio
       # @!attribute target_cpu_usage
       #   @return [Float] A value between 0 and 1 that represents the target (system) CPU usage. This can be set to 1.0
       #     if desired, but it's recommended to leave some headroom for other processes.
-      ResourceBasedTunerOptions = Struct.new(
+      ResourceBasedTunerOptions = Data.define(
         :target_memory_usage,
-        :target_cpu_usage,
-        keyword_init: true
+        :target_cpu_usage
       )
 
       # Options for a specific slot type being used with {SlotSupplier::ResourceBased}.
@@ -94,11 +255,10 @@ module Temporalio
       #
       #     This value matters because how many resources a task will use cannot be determined ahead of time, and thus
       #     the system should wait to see how much resources are used before issuing more slots.
-      ResourceBasedSlotOptions = Struct.new(
+      ResourceBasedSlotOptions = Data.define(
         :min_slots,
         :max_slots,
-        :ramp_throttle,
-        keyword_init: true
+        :ramp_throttle
       )
 
       # Create a fixed-size tuner with the provided number of slots.
@@ -161,27 +321,36 @@ module Temporalio
       # @return [SlotSupplier] Slot supplier for local activities.
       attr_reader :local_activity_slot_supplier
 
+      # @return [ThreadPool, nil] Thread pool for custom slot suppliers.
+      attr_reader :custom_slot_supplier_thread_pool
+
       # Create a tuner from 3 slot suppliers.
       #
       # @param workflow_slot_supplier [SlotSupplier] Slot supplier for workflows.
       # @param activity_slot_supplier [SlotSupplier] Slot supplier for activities.
       # @param local_activity_slot_supplier [SlotSupplier] Slot supplier for local activities.
+      # @param custom_slot_supplier_thread_pool [ThreadPool, nil] Thread pool to make all custom slot supplier calls on.
+      #   If there are no custom slot suppliers, this parameter is ignored. Technically users may set this to nil which
+      #   will not use a thread pool to make slot supplier calls, but that is dangerous and not advised because even the
+      #   slightest blocking call can slow down the system.
       def initialize(
         workflow_slot_supplier:,
         activity_slot_supplier:,
-        local_activity_slot_supplier:
+        local_activity_slot_supplier:,
+        custom_slot_supplier_thread_pool: ThreadPool.default
       )
         @workflow_slot_supplier = workflow_slot_supplier
         @activity_slot_supplier = activity_slot_supplier
         @local_activity_slot_supplier = local_activity_slot_supplier
+        @custom_slot_supplier_thread_pool = custom_slot_supplier_thread_pool
       end
 
       # @!visibility private
       def _to_bridge_options
         Internal::Bridge::Worker::TunerOptions.new(
-          workflow_slot_supplier: workflow_slot_supplier._to_bridge_options,
-          activity_slot_supplier: activity_slot_supplier._to_bridge_options,
-          local_activity_slot_supplier: local_activity_slot_supplier._to_bridge_options
+          workflow_slot_supplier: workflow_slot_supplier._to_bridge_options(self),
+          activity_slot_supplier: activity_slot_supplier._to_bridge_options(self),
+          local_activity_slot_supplier: local_activity_slot_supplier._to_bridge_options(self)
         )
       end
     end

data/lib/temporalio/workflow/info.rb

@@ -7,6 +7,7 @@ module Temporalio
       :continued_run_id,
       :cron_schedule,
       :execution_timeout,
+      :first_execution_run_id,
       :headers,
       :last_failure,
       :last_result,
@@ -35,6 +36,8 @@ module Temporalio
     #   @return [String, nil] Cron schedule if applicable.
     # @!attribute execution_timeout
     #   @return [Float, nil] Execution timeout for the workflow.
+    # @!attribute first_execution_run_id
+    #   @return [String] The very first run ID the workflow ever had, following continuation chains.
     # @!attribute headers
     #   @return [Hash<String, Api::Common::V1::Payload>] Headers.
     # @!attribute last_failure

data/lib/temporalio/workflow.rb

@@ -208,14 +208,16 @@ module Temporalio
     #
     # @param activity [Class<Activity::Definition>, Symbol, String] Activity definition class or name.
     # @param args [Array<Object>] Arguments to the activity.
+    # @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
     #   being scheduled.
     # @param start_to_close_timeout [Float, nil] Max amount of time a single activity run can take from when it starts
     #   to when it completes. This is per retry.
-    # @param retry_policy [RetryPolicy] How an activity is retried on failure. If unset, a server-defined default is
-    #   used. Set maximum attempts to 1 to disable retries.
+    # @param retry_policy [RetryPolicy, nil] How an activity is retried on failure. If unset, a default policy is used.
+    #   Set maximum attempts to 1 to disable retries.
     # @param local_retry_threshold [Float, nil] If the activity is retrying and backoff would exceed this value, a timer
     #   is scheduled and the activity is retried after. Otherwise, backoff will happen internally within the task.
     #   Defaults to 1 minute.
@@ -238,6 +240,7 @@ module Temporalio
     def self.execute_local_activity(
       activity,
       *args,
+      summary: nil,
       schedule_to_close_timeout: nil,
       schedule_to_start_timeout: nil,
       start_to_close_timeout: nil,
@@ -251,7 +254,7 @@ module Temporalio
     )
       _current.execute_local_activity(
         activity, *args,
-        schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
+        summary:, schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
         retry_policy:, local_retry_threshold:, cancellation:, cancellation_type:,
         activity_id:, arg_hints:, result_hint:
       )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: temporalio
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: aarch64-linux
 authors:
 - Temporal Technologies Inc
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-08-25 00:00:00.000000000 Z
+date: 2025-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -156,6 +156,7 @@ files:
 - lib/temporalio/converters/payload_converter/json_plain.rb
 - lib/temporalio/converters/payload_converter/json_protobuf.rb
 - lib/temporalio/converters/raw_value.rb
+- lib/temporalio/env_config.rb
 - lib/temporalio/error.rb
 - lib/temporalio/error/failure.rb
 - lib/temporalio/internal.rb