temporalio 1.4.1 → 1.6.0

data/lib/temporalio/client/activity_handle.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+require 'temporalio/client/activity_execution'
+require 'temporalio/client/interceptor'
+require 'temporalio/error'
+
+module Temporalio
+  class Client
+    # Handle for interacting with a standalone activity. Usually created via {Client.activity_handle}
+    # or {Client#start_activity}.
+    #
+    # WARNING: Standalone Activities are experimental.
+    class ActivityHandle
+      # @return [String] ID for the activity.
+      attr_reader :id
+
+      # @return [String, nil] Run ID for this activity execution. When nil, this handle targets the latest run.
+      attr_reader :run_id
+
+      # @return [Object, nil] Result hint used when deserializing the activity's result. May be overridden per
+      #   {#result} call.
+      attr_reader :result_hint
+
+      # @!visibility private
+      def initialize(client:, id:, run_id:, result_hint:)
+        @client = client
+        @id = id
+        @run_id = run_id
+        @result_hint = result_hint
+      end
+
+      # Wait for the activity's outcome (result or failure). Internally long-polls
+      # PollActivityExecution and reissues until the activity reaches a terminal state, so this can
+      # block indefinitely for long-running activities.
+      #
+      # @param result_hint [Object, nil] Override the result hint. If nil, uses {#result_hint}.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @return [Object, nil] Deserialized activity result.
+      #
+      # @raise [Error::ActivityFailedError] With `cause` populated from the activity failure.
+      # @raise [Error::RPCError] RPC error from call.
+      def result(result_hint: nil, rpc_options: nil)
+        hint = result_hint || @result_hint
+        outcome = @client._impl.fetch_activity_outcome(
+          Interceptor::FetchActivityOutcomeInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            rpc_options:
+          )
+        )
+        _process_outcome(outcome, hint)
+      end
+
+      # Describe the activity.
+      #
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      #
+      # @return [ActivityExecution::Description] Activity description.
+      # @raise [Error::RPCError] RPC error from call.
+      def describe(rpc_options: nil)
+        @client._impl.describe_activity(
+          Interceptor::DescribeActivityInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            rpc_options:
+          )
+        )
+      end
+
+      # Request cancellation of the activity.
+      #
+      # @param reason [String, nil] Optional cancellation reason recorded on the server.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      # @raise [Error::RPCError] RPC error from call.
+      def cancel(reason = nil, rpc_options: nil)
+        @client._impl.cancel_activity(
+          Interceptor::CancelActivityInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            reason:,
+            rpc_options:
+          )
+        )
+        nil
+      end
+
+      # Terminate the activity (force-close).
+      #
+      # @param reason [String, nil] Optional termination reason recorded on the activity's failure outcome.
+      # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+      # @raise [Error::RPCError] RPC error from call.
+      def terminate(reason = nil, rpc_options: nil)
+        @client._impl.terminate_activity(
+          Interceptor::TerminateActivityInput.new(
+            activity_id: id,
+            activity_run_id: run_id,
+            reason:,
+            rpc_options:
+          )
+        )
+        nil
+      end
+
+      private
+
+      def _process_outcome(outcome, hint)
+        raise Error, 'Activity completed but outcome is missing from server response' if outcome.nil?
+
+        case outcome.value
+        when :failure
+          cause = @client.data_converter.from_failure(outcome.failure)
+          raise Error::ActivityFailedError.new, cause: cause
+        when :result
+          @client.data_converter.from_payloads(outcome.result, hints: Array(hint)).first
+        else
+          raise Error, "Unknown activity outcome: #{outcome.value.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/client/activity_id_reference.rb

@@ -6,26 +6,61 @@ require 'temporalio/error'
 
 module Temporalio
   class Client
-    # Reference to an existing activity by its workflow ID, run ID, and activity ID.
+    # Reference to an activity for use with {Client#async_activity_handle}. There are two shapes,
+    # depending on whether the activity is run in a workflow, or as a standalone activity.
+    #
+    # 1. Activity run in a workflow -- use {ActivityIDReference#initialize}:
+    #    `ActivityIDReference.new(workflow_id:, run_id:, activity_id:)`.
+    #
+    # 2. Standalone Activity (started  via {Client#start_activity}): use the class factory
+    #    {ActivityIDReference.for_standalone}: `ActivityIDReference.for_standalone(activity_id:, activity_run_id:)`.
     class ActivityIDReference
-      # @return [String] ID for the workflow.
+      # @return [String] ID for the activity.
+      attr_reader :activity_id
+
+      # @return [String, nil] Activity run ID. Set only for standalone activity references.
+      attr_reader :activity_run_id
+
+      # @return [String, nil] ID for the workflow. Set only for workflow-run activity references.
       attr_reader :workflow_id
 
-      # @return [String, nil] Run ID for the workflow.
+      # @return [String, nil] Run ID for the workflow. Set only for workflow-run activity references.
       attr_reader :run_id
 
-      # @return [String] ID for the activity.
-      attr_reader :activity_id
+      # Construct a standalone activity reference.
+      #
+      # WARNING: Standalone Activities are experimental.
+      #
+      # @param activity_id [String] ID for the activity.
+      # @param activity_run_id [String, nil] Run ID for the activity execution. nil targets the latest run.
+      # @return [ActivityIDReference] A reference suitable for {Client#async_activity_handle}.
+      def self.for_standalone(activity_id:, activity_run_id: nil)
+        allocate.tap do |ref|
+          ref.instance_variable_set(:@activity_id, activity_id)
+          ref.instance_variable_set(:@activity_run_id, activity_run_id)
+          ref.instance_variable_set(:@workflow_id, nil)
+          ref.instance_variable_set(:@run_id, nil)
+        end
+      end
 
-      # Create an activity ID reference.
+      # Construct a workflow-run activity reference.
       #
       # @param workflow_id [String] ID for the workflow.
       # @param run_id [String, nil] Run ID for the workflow.
-      # @param activity_id [String] ID for the workflow.
+      # @param activity_id [String] ID for the activity.
+      # @return [ActivityIDReference] A reference suitable for {Client#async_activity_handle}.
       def initialize(workflow_id:, run_id:, activity_id:)
         @workflow_id = workflow_id
         @run_id = run_id
         @activity_id = activity_id
+        @activity_run_id = nil
+      end
+
+      # @return [Boolean] True if this reference is the standalone-form (activity_run_id without workflow_id).
+      #
+      # WARNING: Standalone Activities are experimental.
+      def standalone?
+        @workflow_id.nil?
       end
     end
   end

data/lib/temporalio/client/connection/cloud_service.rb

@@ -1035,6 +1035,126 @@ module Temporalio
             rpc_options:
           )
         end
+
+        # Calls CloudService.GetCustomRoles API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::GetCustomRolesRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::GetCustomRolesResponse] API response.
+        def get_custom_roles(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'get_custom_roles',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::GetCustomRolesRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::GetCustomRolesResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.GetCustomRole API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::GetCustomRoleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::GetCustomRoleResponse] API response.
+        def get_custom_role(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'get_custom_role',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::GetCustomRoleRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::GetCustomRoleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.CreateCustomRole API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::CreateCustomRoleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::CreateCustomRoleResponse] API response.
+        def create_custom_role(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'create_custom_role',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::CreateCustomRoleRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::CreateCustomRoleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.UpdateCustomRole API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::UpdateCustomRoleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::UpdateCustomRoleResponse] API response.
+        def update_custom_role(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'update_custom_role',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::UpdateCustomRoleRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::UpdateCustomRoleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.DeleteCustomRole API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::DeleteCustomRoleRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::DeleteCustomRoleResponse] API response.
+        def delete_custom_role(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'delete_custom_role',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::DeleteCustomRoleRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::DeleteCustomRoleResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.GetUserNamespaceAssignments API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::GetUserNamespaceAssignmentsRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::GetUserNamespaceAssignmentsResponse] API response.
+        def get_user_namespace_assignments(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'get_user_namespace_assignments',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::GetUserNamespaceAssignmentsRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::GetUserNamespaceAssignmentsResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.GetServiceAccountNamespaceAssignments API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountNamespaceAssignmentsRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountNamespaceAssignmentsResponse] API response.
+        def get_service_account_namespace_assignments(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'get_service_account_namespace_assignments',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountNamespaceAssignmentsRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountNamespaceAssignmentsResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls CloudService.GetUserGroupNamespaceAssignments API call.
+        #
+        # @param request [Temporalio::Api::Cloud::CloudService::V1::GetUserGroupNamespaceAssignmentsRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::Cloud::CloudService::V1::GetUserGroupNamespaceAssignmentsResponse] API response.
+        def get_user_group_namespace_assignments(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'get_user_group_namespace_assignments',
+            request_class: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupNamespaceAssignmentsRequest,
+            response_class: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupNamespaceAssignmentsResponse,
+            request:,
+            rpc_options:
+          )
+        end
       end
     end
   end

data/lib/temporalio/client/connection/workflow_service.rb

@@ -1441,6 +1441,21 @@ module Temporalio
           )
         end
 
+        # Calls WorkflowService.CountWorkers API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::CountWorkersRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::CountWorkersResponse] API response.
+        def count_workers(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'count_workers',
+            request_class: Temporalio::Api::WorkflowService::V1::CountWorkersRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::CountWorkersResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
         # Calls WorkflowService.UpdateTaskQueueConfig API call.
         #
         # @param request [Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest] API request.
@@ -1741,6 +1756,66 @@ module Temporalio
           )
         end
 
+        # Calls WorkflowService.PauseActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::PauseActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::PauseActivityExecutionResponse] API response.
+        def pause_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'pause_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::PauseActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::PauseActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.ResetActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::ResetActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::ResetActivityExecutionResponse] API response.
+        def reset_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'reset_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::ResetActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::ResetActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.UnpauseActivityExecution API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::UnpauseActivityExecutionRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::UnpauseActivityExecutionResponse] API response.
+        def unpause_activity_execution(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'unpause_activity_execution',
+            request_class: Temporalio::Api::WorkflowService::V1::UnpauseActivityExecutionRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::UnpauseActivityExecutionResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
+        # Calls WorkflowService.UpdateActivityExecutionOptions API call.
+        #
+        # @param request [Temporalio::Api::WorkflowService::V1::UpdateActivityExecutionOptionsRequest] API request.
+        # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+        # @return [Temporalio::Api::WorkflowService::V1::UpdateActivityExecutionOptionsResponse] API response.
+        def update_activity_execution_options(request, rpc_options: nil)
+          invoke_rpc(
+            rpc: 'update_activity_execution_options',
+            request_class: Temporalio::Api::WorkflowService::V1::UpdateActivityExecutionOptionsRequest,
+            response_class: Temporalio::Api::WorkflowService::V1::UpdateActivityExecutionOptionsResponse,
+            request:,
+            rpc_options:
+          )
+        end
+
         # Calls WorkflowService.TerminateNexusOperationExecution API call.
         #
         # @param request [Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionRequest] API request.

data/lib/temporalio/client/connection.rb

@@ -25,7 +25,8 @@ module Temporalio
         :http_connect_proxy,
         :runtime,
         :lazy_connect,
-        :dns_load_balancing
+        :dns_load_balancing,
+        :grpc_compression
       )
 
       # Options as returned from {options} for +**to_h+ splat use in {initialize}. See {initialize} for details.
@@ -149,6 +150,25 @@ module Temporalio
         end
       end
 
+      # Transport-level gRPC compression options for client connections.
+      module GrpcCompressionOptions
+        # Use gzip for transport-level gRPC compression.
+        class Gzip
+          # @return [Symbol] Compression codec name.
+          def codec
+            :gzip
+          end
+        end
+
+        # Disable transport-level gRPC compression.
+        class None
+          # @return [Symbol] Compression codec name.
+          def codec
+            :none
+          end
+        end
+      end
+
       # @return [Options] Frozen options for this client which has the same attributes as {initialize}. Note that if
       #   {api_key=} or {rpc_metadata=} are updated, the options object is replaced with those changes (it is not
       #   mutated in place).
@@ -188,6 +208,8 @@ module Temporalio
       #   connection.
       # @param dns_load_balancing [DnsLoadBalancingOptions, nil] DNS load balancing options for this connection. Default
       #   is +nil+ (disabled). Silently disabled when +http_connect_proxy+ is set, since the two are mutually exclusive.
+      # @param grpc_compression [GrpcCompressionOptions::Gzip, GrpcCompressionOptions::None] Transport-level gRPC
+      #   compression. Defaults to gzip. Set to {GrpcCompressionOptions::None} to opt out.
       # @param around_connect [Proc, nil] If present, this proc accepts two values: options and a block. The block must
       #   be yielded to only once with the options. The block does not return a meaningful value, nor should
       #   around_connect.
@@ -205,6 +227,7 @@ module Temporalio
         runtime: Runtime.default,
         lazy_connect: false,
         dns_load_balancing: nil,
+        grpc_compression: GrpcCompressionOptions::Gzip.new,
         around_connect: nil
       )
         @options = Options.new(
@@ -218,7 +241,8 @@ module Temporalio
           http_connect_proxy:,
           runtime:,
           lazy_connect:,
-          dns_load_balancing:
+          dns_load_balancing:,
+          grpc_compression:
         ).freeze
         @core_client_mutex = Mutex.new
         # Create core client now if not lazy, applying around_connect if present
@@ -304,6 +328,7 @@ module Temporalio
 
       def new_core_client
         Internal::Bridge.assert_fiber_compatibility!
+        Internal::Bridge.assert_fips_compatibility!
 
         options = Internal::Bridge::Client::Options.new(
           target_host: @options.target_host,
@@ -321,6 +346,16 @@ module Temporalio
           ),
           identity: @options.identity || "#{Process.pid}@#{Socket.gethostname}"
         )
+        grpc_compression_codec = case @options.grpc_compression
+                                 when GrpcCompressionOptions::Gzip
+                                   'gzip'
+                                 when GrpcCompressionOptions::None
+                                   'none'
+                                 else
+                                   raise ArgumentError,
+                                         "Invalid gRPC compression options: #{@options.grpc_compression.inspect}"
+                                 end
+        options.grpc_compression = Internal::Bridge::Client::GrpcCompressionOptions.new(codec: grpc_compression_codec)
         # Auto-enable TLS when API key is provided and tls not explicitly set
         tls = @options.tls
         tls = true if tls.nil? && @options.api_key

data/lib/temporalio/client/interceptor.rb

@@ -259,6 +259,87 @@ module Temporalio
         :rpc_options
       )
 
+      # Input for {Outbound.start_activity}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      StartActivityInput = Data.define(
+        :activity,
+        :args,
+        :activity_id,
+        :task_queue,
+        :schedule_to_close_timeout,
+        :schedule_to_start_timeout,
+        :start_to_close_timeout,
+        :heartbeat_timeout,
+        :id_reuse_policy,
+        :id_conflict_policy,
+        :retry_policy,
+        :search_attributes,
+        :static_summary,
+        :static_details,
+        :headers,
+        :priority,
+        :start_delay,
+        :arg_hints,
+        :result_hint,
+        :rpc_options
+      )
+
+      # Input for {Outbound.describe_activity}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      DescribeActivityInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :rpc_options
+      )
+
+      # Input for {Outbound.cancel_activity}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      CancelActivityInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :reason,
+        :rpc_options
+      )
+
+      # Input for {Outbound.terminate_activity}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      TerminateActivityInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :reason,
+        :rpc_options
+      )
+
+      # Input for {Outbound.list_activities}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      ListActivitiesInput = Data.define(
+        :query,
+        :rpc_options
+      )
+
+      # Input for {Outbound.count_activities}.
+      #
+      # WARNING: Standalone Activities are experimental.
+      CountActivitiesInput = Data.define(
+        :query,
+        :rpc_options
+      )
+
+      # Input for {Outbound.fetch_activity_outcome}. Used by `ActivityHandle#result` for long-polling
+      # the activity outcome via `PollActivityExecution`.
+      #
+      # WARNING: Standalone Activities are experimental.
+      FetchActivityOutcomeInput = Data.define(
+        :activity_id,
+        :activity_run_id,
+        :rpc_options
+      )
+
       # Outbound interceptor for intercepting client calls. This should be extended by users needing to intercept client
       # actions.
       class Outbound
@@ -467,6 +548,74 @@ module Temporalio
         def report_cancellation_async_activity(input)
           next_interceptor.report_cancellation_async_activity(input)
         end
+
+        # Called for every {Client.start_activity} and {Client.execute_activity} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [StartActivityInput] Input.
+        # @return [ActivityHandle] Activity handle.
+        def start_activity(input)
+          next_interceptor.start_activity(input)
+        end
+
+        # Called for every {ActivityHandle.describe} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [DescribeActivityInput] Input.
+        # @return [ActivityExecution::Description] Activity description.
+        def describe_activity(input)
+          next_interceptor.describe_activity(input)
+        end
+
+        # Called for every {ActivityHandle.cancel} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [CancelActivityInput] Input.
+        def cancel_activity(input)
+          next_interceptor.cancel_activity(input)
+        end
+
+        # Called for every {ActivityHandle.terminate} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [TerminateActivityInput] Input.
+        def terminate_activity(input)
+          next_interceptor.terminate_activity(input)
+        end
+
+        # Called for every {Client.list_activities} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [ListActivitiesInput] Input.
+        # @return [Enumerator<ActivityExecution>] Activity executions.
+        def list_activities(input)
+          next_interceptor.list_activities(input)
+        end
+
+        # Called for every {Client.count_activities} call.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [CountActivitiesInput] Input.
+        # @return [ActivityExecutionCount] Activity count.
+        def count_activities(input)
+          next_interceptor.count_activities(input)
+        end
+
+        # Called by {ActivityHandle.result} to long-poll the activity outcome.
+        #
+        # WARNING: Standalone Activities are experimental.
+        #
+        # @param input [FetchActivityOutcomeInput] Input.
+        # @return [Api::Activity::V1::ActivityExecutionOutcome] Activity outcome.
+        def fetch_activity_outcome(input)
+          next_interceptor.fetch_activity_outcome(input)
+        end
       end
     end
   end

data/lib/temporalio/client/pending_activity_state.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+
+module Temporalio
+  class Client
+    # More detailed breakdown of a running activity's state.
+    #
+    # WARNING: Standalone Activities are experimental.
+    module PendingActivityState
+      SCHEDULED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_SCHEDULED
+      STARTED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_STARTED
+      CANCEL_REQUESTED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_CANCEL_REQUESTED
+      PAUSED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_PAUSED
+      PAUSE_REQUESTED = Api::Enums::V1::PendingActivityState::PENDING_ACTIVITY_STATE_PAUSE_REQUESTED
+    end
+  end
+end