volcano-sdk 0.34.0 → 0.35.0

data/lib/volcano/generated_transport_durable_messages.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Durable message operations for the internal generated transport. A target
+  # with a project id takes the owner's project route; one without takes the
+  # application route, with the execution's client token when there is one.
+  class GeneratedTransport
+    def send_durable_message(authorization:, target:, name:, data:, idempotency_key:)
+      invoke do
+        durable = @api_factory.call(authorization).durable
+        body = Generated::SendDurableMessageRequest.new(name: name, data: data)
+        payload, status, headers = send_on_route(durable, target, body, idempotency_key)
+        response(payload, status, headers)
+      end
+    end
+
+    def list_durable_messages(authorization:, target:, query:)
+      invoke do
+        data, status, headers = list_on_route(@api_factory.call(authorization).durable, target, query)
+        response(data, status, headers)
+      end
+    end
+
+    private
+
+    def send_on_route(durable, target, body, idempotency_key)
+      if target.project_id
+        durable.send_durable_message_with_http_info(
+          target.project_id, target.function_id, target.execution_id, body,
+          durable_message_options(idempotency_key: idempotency_key)
+        )
+      else
+        durable.send_durable_message_from_application_with_http_info(
+          target.function_id, target.execution_id, body,
+          durable_message_options(idempotency_key: idempotency_key, x_volcano_client_token: target.client_token)
+        )
+      end
+    end
+
+    def list_on_route(durable, target, query)
+      if target.project_id
+        durable.list_durable_messages_with_http_info(
+          target.project_id, target.function_id, target.execution_id, durable_message_options(**query)
+        )
+      else
+        durable.list_durable_messages_from_application_with_http_info(
+          target.function_id, target.execution_id,
+          durable_message_options(**query, x_volcano_client_token: target.client_token)
+        )
+      end
+    end
+
+    def durable_message_options(**options)
+      options.compact.merge(debug_return_type: 'Object')
+    end
+  end
+end

data/lib/volcano/realtime/channel_callbacks.rb

@@ -61,14 +61,18 @@ module Volcano
         end
       end
 
+      # A durable message has no event field; everything the server publishes
+      # on its channel is one.
       def deliver_publication(event, data)
         if postgres?
           dispatch_postgres_change(data)
-        elsif event == 'message'
+        elsif event == 'message' || durable?
           emit('message', data)
         end
       end
 
+      def durable? = @type == :durable
+
       def emit(event, data, before_delivery: nil)
         callbacks = @callbacks[event].dup
         return if callbacks.empty?

data/lib/volcano/realtime/channel_lifecycle.rb

@@ -10,6 +10,7 @@ module Volcano
       def mark_closed
         @closed = true
         @subscription_desired = @subscribed = false
+        @follower&.close
         end_postgres_delivery
         reset_presence
       end
@@ -81,7 +82,9 @@ module Volcano
         detach_publication_handler(protocol)
       end
 
-      def subscription_options(binding) = { recovery: binding&.last, recoverable: presence?, join_leave: presence? }
+      def subscription_options(binding)
+        { recovery: binding&.last, recoverable: presence?, join_leave: presence?, data: @subscribe_data }
+      end
 
       def recovery_binding
         return unless broadcast?

data/lib/volcano/realtime/durable_channel.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Volcano
+  class Realtime
+    # Follows a durable execution's messages on a channel.
+    module DurableChannel
+      # @dynamic durable?
+
+      private
+
+      # +data+ goes with every subscribe, including the ones a reconnect
+      # restores. +follower+ is asked before each of those restores, hears each
+      # one and each publication the connection dropped, and is closed with the
+      # channel.
+      def follow_durable(data, follower)
+        @subscribe_data = data
+        @follower = follower
+      end
+
+      # A durable channel's follower reads back what the connection dropped.
+      def publication_rejection(protocol, generation)
+        follower = @follower
+        follower ? ->(_publication) { follower.dropped } : super
+      end
+
+      # The server refuses a durable subscribe for good once the execution is
+      # gone or hidden from the session, so the follower ends the subscription
+      # instead of the reconnect retrying it, and the refusal says so.
+      def restore_refused(error)
+        follower = @follower
+        return error unless follower
+        return error if error.temporary?
+
+        follower.refused
+        ServerError.new("#{error.message}; the durable message subscription has ended", code: error.code)
+      end
+
+      # The server authorizes a durable subscribe by the socket's session, so
+      # the socket must belong to the client's current one.
+      def prepare_protocol_subscription(protocol, epoch)
+        @realtime.__send__(:capture_protocol_session) if durable?
+        super
+      end
+    end
+    private_constant :DurableChannel
+  end
+end

data/lib/volcano/realtime/lifecycle.rb

@@ -4,7 +4,7 @@ module Volcano
   class Realtime
     # Channel collection and connection-state lifecycle operations.
     module Lifecycle
-      # @dynamic channel_lock, normalize_channel_type
+      # @dynamic channel_lock, normalize_channel_type, report_channel_error, protocol
       def connected? = !@closed && (@protocol&.connected? || false)
 
       def remove_channel(name, type: :broadcast)
@@ -34,6 +34,42 @@ module Volcano
         @channels.delete(name)
       end
 
+      # Leaves a durable channel unless a later subscription replaced it. Once
+      # the connection is closed there is nothing left to leave.
+      def remove_durable_channel(channel)
+        channel_lock.acquire do
+          leave_durable_channel(channel) if forget_durable_channel(channel) && !@closed
+        end
+        nil
+      rescue Async::Cancel
+        # Stopped waiting for the lock, so the channel is still subscribed.
+        abandon_durable_leave(channel) { protocol.drop } if forget_durable_channel(channel)
+        raise
+      end
+
+      def forget_durable_channel(channel)
+        @channels.delete(channel.name) if @channels[channel.name].equal?(channel)
+      end
+
+      # A leave the server did not confirm may have left the subscription in
+      # place, so the connection is dropped, which ends it. The reconnect
+      # restores only the channels still in use.
+      def leave_durable_channel(channel)
+        channel.__send__(:remove)
+      rescue StandardError => e
+        abandon_durable_leave(channel) { protocol.close }
+        report_channel_error(e)
+      rescue Async::Cancel
+        # Closing here would start the reconnect in the task being stopped.
+        abandon_durable_leave(channel) { protocol.drop }
+        raise
+      end
+
+      def abandon_durable_leave(channel)
+        channel.mark_closed
+        yield if connected?
+      end
+
       def remove_channel_entry(name, channel)
         channel.__send__(:remove)
         @channels.delete(name)

data/lib/volcano/realtime/protocol.rb

@@ -16,10 +16,14 @@ module Volcano
 
       # @dynamic code
 
-      def initialize(message, code: nil)
+      def initialize(message, code: nil, temporary: false)
         super(message)
         @code = code.is_a?(String) ? code.dup.freeze : code
+        @temporary = temporary == true
       end
+
+      # Whether the server expects the same command to succeed later.
+      def temporary? = @temporary
     end
 
     class ClosedError < StandardError; end
@@ -93,12 +97,12 @@ module Volcano
         result.tap { @connected = true }
       end
 
-      def subscribe(channel:, recoverable: false, join_leave: false, recovery: nil)
+      def subscribe(channel:, recoverable: false, join_leave: false, recovery: nil, data: nil)
         @subscription_lock.acquire do
           ensure_open!
           raise DuplicateSubscriptionError, "already subscribed to #{channel}" if @subscriptions.include?(channel)
 
-          result = subscribe_request(channel:, recoverable:, join_leave:, recovery:)
+          result = subscribe_request(channel:, recoverable:, join_leave:, recovery:, data:)
           ensure_open!
           @subscriptions.add(channel)
           result

data/lib/volcano/realtime/protocol_dispatch.rb

@@ -59,7 +59,7 @@ module Volcano
         raise TypeError, 'realtime error must be an object' unless error.is_a?(Hash)
 
         message = error['message'] || 'realtime command failed'
-        Protocol::Failure.new(error: ServerError.new(message, code: error['code']))
+        Protocol::Failure.new(error: ServerError.new(message, code: error['code'], temporary: error['temporary']))
       end
 
       def successful_reply(frame, reply_key)

data/lib/volcano/realtime/protocol_io.rb

@@ -10,11 +10,13 @@ module Volcano
 
         private
 
-        def request(reply_key, on_reply: nil)
+        # on_write runs once the frame holds the write lock, when the server may
+        # start to receive it.
+        def request(reply_key, on_reply: nil, on_write: nil)
           # @type var registered_id: Integer?
           ensure_open!
           registered_id, reply_queue = register_request(reply_key, on_reply)
-          write_frame(yield(registered_id || raise(TypeError, 'invalid realtime request id')))
+          write_frame(yield(registered_id || raise(TypeError, 'invalid realtime request id')), on_write)
           reply = await_reply(reply_queue)
           raise reply.error if reply.is_a?(Failure)
 
@@ -36,10 +38,11 @@ module Volcano
           [@next_id, queue]
         end
 
-        def write_frame(frame) = write_serialized_frame("#{JSON.generate(frame)}\n")
+        def write_frame(frame, on_write = nil) = write_serialized_frame("#{JSON.generate(frame)}\n", on_write)
 
-        def write_serialized_frame(frame)
+        def write_serialized_frame(frame, on_write = nil)
           @write_lock.acquire do
+            on_write&.call
             @socket.write(frame)
             @socket.flush
           end

data/lib/volcano/realtime/protocol_lifecycle.rb

@@ -9,6 +9,13 @@ module Volcano
         # @dynamic dispatch_publication_batches, read_loop
         def connected? = @connected && !@closed
 
+        # Ends the connection from the reader, as a loss would, so the reconnect
+        # runs in the protocol's tasks rather than the caller's.
+        def drop
+          close_socket
+          nil
+        end
+
         def on_publication(channel, on_rejection: nil, &handler)
           ensure_open!
           @publication_handlers[channel] << ProtocolPublicationDispatch::Registration.new(

data/lib/volcano/realtime/protocol_recovery.rb

@@ -6,27 +6,38 @@ module Volcano
     module ProtocolRecovery
       # @dynamic class, request, dispatch_recovered_publications, recovery_position
       # @dynamic delete_recovery_state, set_recovery_position, mark_unknown_gap
-      # @dynamic mark_publication_gap, same_epoch?
+      # @dynamic mark_publication_gap, same_epoch?, close_socket
 
       private
 
-      def subscribe_request(channel:, recoverable:, join_leave:, recovery:)
-        on_reply = nil
-        if recovery
-          on_reply = lambda do |reply|
-            publications = parse_recovery_result(channel: channel, recovery: recovery, result: reply)
-            dispatch_recovered_publications(channel, publications)
-          end
-        end
-
-        request('subscribe', on_reply:) do |id|
-          self.class.subscribe(
+      def subscribe_request(channel:, recoverable:, join_leave:, recovery:, data:)
+        writing = false
+        request('subscribe', on_reply: recovery_reply(channel, recovery), on_write: -> { writing = true }) do |id|
+          command = self.class.subscribe(
             id: id,
             channel: channel,
             recoverable: recoverable,
             join_leave: join_leave,
             recovery: recovery
           )
+          command['subscribe']['data'] = data if data
+          command
+        end
+      rescue Async::Cancel
+        # Once the frame is being written the server may subscribe, and nothing
+        # would leave the channel. Closing the socket has the reader end the
+        # connection, as on a loss, so the reconnect is not cancelled along with
+        # this task. Stopped before that, there is nothing to leave.
+        close_socket if writing
+        raise
+      end
+
+      def recovery_reply(channel, recovery)
+        return unless recovery
+
+        lambda do |reply|
+          publications = parse_recovery_result(channel: channel, recovery: recovery, result: reply)
+          dispatch_recovered_publications(channel, publications)
         end
       end
 

data/lib/volcano/realtime.rb

@@ -16,6 +16,7 @@ require_relative 'realtime/postgres_batch'
 require_relative 'realtime/postgres_delivery'
 require_relative 'realtime/broadcast_delivery'
 require_relative 'realtime/channel_callbacks'
+require_relative 'realtime/durable_channel'
 
 module Volcano
   # Manages a project's realtime connection and broadcast channels.
@@ -68,6 +69,9 @@ module Volcano
     end
 
     CHANNEL_TYPES = %i[broadcast presence postgres].freeze
+    # A channel that fetches no rows still takes a batch configuration.
+    UNBATCHED = PostgresBatchConfig.new(auto_fetch: false, batch_window_ms: 1, max_batch_size: 1)
+    private_constant :UNBATCHED
 
     # Owns the public realtime facade and its channel collection.
     module Core
@@ -152,6 +156,8 @@ module Volcano
 
       def report_channel_error(error) = protocol_error(public_error(error))
 
+      def blocking(&) = BlockingCall.call(&)
+
       def cached_channel(channel, batch_config)
         channel.__send__(:ensure_fetch_config!, batch_config)
         channel
@@ -161,6 +167,20 @@ module Volcano
         Channel.new(self, -> { protocol }, name, type, batch_config:)
       end
 
+      # Opens the channel an execution publishes its messages on, or answers
+      # nil when this client already follows the execution.
+      def durable_channel(execution_id, client_token, follower)
+        channel_lock.acquire do
+          ensure_open!
+          name = "durable:#{execution_id}"
+          next if @channels.key?(name)
+
+          channel = build_channel(name, :durable, UNBATCHED)
+          channel.__send__(:follow_durable, client_token && { 'client_token' => client_token }, follower)
+          @channels[name] = channel
+        end
+      end
+
       def protocol_lock
         require 'async/semaphore'
         @protocol_lock ||= Async::Semaphore.new(1)
@@ -186,6 +206,7 @@ module Volcano
       include PostgresDelivery
       include BroadcastDelivery
       include ChannelCallbacks
+      include DurableChannel
 
       attr_reader :name
 
@@ -194,7 +215,7 @@ module Volcano
         @protocol_provider = protocol_provider
         @name = name.freeze
         @handler_registered = @subscribed = @subscription_desired = @closed = false
-        @lifecycle_lock = nil
+        @lifecycle_lock = @subscribe_data = @follower = nil
         initialize_recovery_state
         initialize_callback_dispatch
         initialize_presence(type)
@@ -230,13 +251,13 @@ module Volcano
       def restoration_needed? = subscription_desired? && !@subscribed
 
       def restore_subscription(protocol)
-        state = with_lifecycle_lock do
-          restoration_needed? ? subscribe_protocol(protocol) : nil
-        end
-        if state
-          subscribed_protocol, epoch = state
-          sync_presence(subscribed_protocol, epoch)
-        end
+        ask_follower_to_restore
+        state = resubscribe(protocol)
+        return unless state
+
+        subscribed_protocol, epoch = state
+        sync_presence(subscribed_protocol, epoch)
+        @follower&.resubscribed
         nil
       end
 
@@ -247,6 +268,7 @@ module Volcano
           clear_broadcast_recovery_state
           clear_channel_recovery_state
           mark_removed
+          @follower&.close
         end
         nil
       end
@@ -273,6 +295,18 @@ module Volcano
         raise
       end
 
+      # Outside the lifecycle lock: a follower that refuses may leave the channel.
+      def ask_follower_to_restore
+        @follower&.restoring if restoration_needed?
+      end
+
+      # The refusal is handled outside the lifecycle lock too, for the same reason.
+      def resubscribe(protocol)
+        with_lifecycle_lock { restoration_needed? ? subscribe_protocol(protocol) : nil }
+      rescue ServerError => e
+        raise restore_refused(e)
+      end
+
       def with_lifecycle_lock(&)
         require 'async/semaphore'
         lock = @lifecycle_lock ||= Async::Semaphore.new(1)

data/lib/volcano/redaction.rb

@@ -25,7 +25,7 @@ module Volcano
         return copy_volcano_error(error, redacted_message)
       end
       if defined?(Realtime::ServerError) && error.is_a?(Realtime::ServerError)
-        return error.class.new(redacted_message, code: error.code)
+        return error.class.new(redacted_message, code: error.code, temporary: error.temporary?)
       end
 
       error.exception(redacted_message)

data/lib/volcano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Volcano
-  VERSION = '0.34.0'
+  VERSION = '0.35.0'
 end

data/lib/volcano.rb

@@ -9,6 +9,7 @@ require_relative 'volcano/session_credentials'
 require_relative 'volcano/function_response'
 require_relative 'volcano/durable_models'
 require_relative 'volcano/durable_approval_models'
+require_relative 'volcano/durable_message_models'
 require_relative 'volcano/log_responses'
 require_relative 'volcano/storage_models'
 require_relative 'volcano/storage_upload_models'
@@ -48,6 +49,13 @@ require_relative 'volcano/functions'
 require_relative 'volcano/durable_arguments'
 require_relative 'volcano/durable_approval_responses'
 require_relative 'volcano/durable_approvals'
+require_relative 'volcano/durable_message_arguments'
+require_relative 'volcano/durable_message_responses'
+require_relative 'volcano/durable_message_catch_ups'
+require_relative 'volcano/durable_message_backlog'
+require_relative 'volcano/durable_message_stream'
+require_relative 'volcano/durable_message_session'
+require_relative 'volcano/durable_messages'
 require_relative 'volcano/durable'
 require_relative 'volcano/logs'
 require_relative 'volcano/storage_session_adapter'

data/sig/core_facades.rbs

@@ -1,6 +1,7 @@
 module Volcano
   type sdk_json = nil | bool | Integer | Float | String | Time | Array[sdk_json] | Hash[String | Symbol, sdk_json]
   type sdk_payload = Hash[String | Symbol, sdk_json]
+  type durable_message_filters = { ?direction: (String | Symbol)?, ?name: String?, ?after: Integer?, ?limit: Integer?, ?client_token: String?, ?project_id: String? }
   type durable_approval_filters = { ?status: String?, ?function: String?, ?execution_id: String?, ?from: (Time | String)?, ?to: (Time | String)?, ?page: Integer?, ?limit: Integer? }
   type database_rows = Array[Hash[String, json_value]]
 
@@ -79,8 +80,22 @@ module Volcano
     def deny: (String project_id, String approval_id, ?comment: String?) -> DurableApproval
   end
 
+  class DurableMessageSubscription
+    def unsubscribe: () -> nil
+    def inspect: () -> String
+    def to_s: () -> String
+    def pretty_print: (DurableExecution::_PrettyPrinter printer) -> void
+  end
+
+  class DurableMessages
+    def send_message: (String function_name, String execution_id, String name, ?sdk_json data, **String? options) -> DurableMessage
+    def list: (String function_name, String execution_id, ?durable_message_filters filters) -> DurableMessagePage
+    def subscribe: (String function_name, String execution_id, ?client_token: String?, ?project_id: String?) { (DurableMessage) -> void } -> DurableMessageSubscription
+  end
+
   class Durable
     attr_reader approvals: DurableApprovals
+    attr_reader messages: DurableMessages
 
     def start: (String function_name, ?sdk_payload payload, ?execution_name: String?) -> DurableExecution
     def get: (String project_id, String function_name, String execution_id) -> DurableExecution

data/sig/durable_message_records.rbs

@@ -0,0 +1,68 @@
+module Volcano
+  class DurableMessageSender < Data
+    attr_reader type: String
+    attr_reader user_id: String?
+
+    def self.new: (String type, ?String? user_id) -> DurableMessageSender
+                | (type: String, ?user_id: String?) -> DurableMessageSender
+    def self.[]: (String type, ?String? user_id) -> DurableMessageSender
+               | (type: String, ?user_id: String?) -> DurableMessageSender
+    def self.members: () -> [:type, :user_id]
+
+    def initialize: (type: String, ?user_id: String?) -> void
+    def members: () -> [:type, :user_id]
+    def with: (?type: String, ?user_id: String?) -> DurableMessageSender
+    def to_h: () -> { type: String, user_id: String? }
+            | [K, V] () { (Symbol, String?) -> [K, V] } -> Hash[K, V]
+    def deconstruct: () -> [String, String?]
+    def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, String?]
+  end
+
+  class DurableMessage < Data
+    type field = String | Integer | json_value | DurableMessageSender | Time | nil
+
+    attr_reader id: String
+    attr_reader execution_id: String
+    attr_reader direction: String
+    attr_reader seq: Integer
+    attr_reader name: String
+    attr_reader data: json_value
+    attr_reader sender: DurableMessageSender
+    attr_reader status: String
+    attr_reader sent_at: Time
+    attr_reader delivered_at: Time?
+
+    def self.new: (String id, String execution_id, String direction, Integer seq, String name, json_value data, DurableMessageSender sender, String status, Time sent_at, ?Time? delivered_at) -> DurableMessage
+                | (id: String, execution_id: String, direction: String, seq: Integer, name: String, ?data: json_value, sender: DurableMessageSender, status: String, sent_at: Time, ?delivered_at: Time?) -> DurableMessage
+    def self.[]: (String id, String execution_id, String direction, Integer seq, String name, json_value data, DurableMessageSender sender, String status, Time sent_at, ?Time? delivered_at) -> DurableMessage
+               | (id: String, execution_id: String, direction: String, seq: Integer, name: String, ?data: json_value, sender: DurableMessageSender, status: String, sent_at: Time, ?delivered_at: Time?) -> DurableMessage
+    def self.members: () -> [:id, :execution_id, :direction, :seq, :name, :data, :sender, :status, :sent_at, :delivered_at]
+
+    private def initialize: (**field attributes) -> void
+    def members: () -> [:id, :execution_id, :direction, :seq, :name, :data, :sender, :status, :sent_at, :delivered_at]
+    def with: (?id: String, ?execution_id: String, ?direction: String, ?seq: Integer, ?name: String, ?data: json_value, ?sender: DurableMessageSender, ?status: String, ?sent_at: Time, ?delivered_at: Time?) -> DurableMessage
+    def to_h: () -> { id: String, execution_id: String, direction: String, seq: Integer, name: String, data: json_value, sender: DurableMessageSender, status: String, sent_at: Time, delivered_at: Time? }
+            | [K, V] () { (Symbol, field) -> [K, V] } -> Hash[K, V]
+    def deconstruct: () -> [String, String, String, Integer, String, json_value, DurableMessageSender, String, Time, Time?]
+    def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, field]
+  end
+
+  class DurableMessagePage < Data
+    attr_reader messages: Array[DurableMessage]
+    attr_reader has_more: bool
+
+    def self.new: (Enumerable[DurableMessage] messages, bool has_more) -> DurableMessagePage
+                | (messages: Enumerable[DurableMessage], has_more: bool) -> DurableMessagePage
+    def self.[]: (Enumerable[DurableMessage] messages, bool has_more) -> DurableMessagePage
+               | (messages: Enumerable[DurableMessage], has_more: bool) -> DurableMessagePage
+    def self.members: () -> [:messages, :has_more]
+
+    def initialize: (messages: Enumerable[DurableMessage], has_more: bool) -> void
+    def members: () -> [:messages, :has_more]
+    def with: (?messages: Enumerable[DurableMessage], ?has_more: bool) -> DurableMessagePage
+    def to_h: () -> { messages: Array[DurableMessage], has_more: bool }
+            | [K, V] () { (Symbol, Array[DurableMessage] | bool) -> [K, V] } -> Hash[K, V]
+    def deconstruct: () -> [Array[DurableMessage], bool]
+    def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, Array[DurableMessage] | bool]
+  end
+end

data/sig/durable_records.rbs

@@ -29,21 +29,29 @@ module Volcano
     attr_reader result_expired: bool?
     attr_reader error: DurableExecutionError?
     attr_reader completed_at: Time?
+    attr_reader client_token: String?
 
-    def self.new: (String id, String function_id, String name, String status, String region, Time created_at, ?json_value result, ?bool? result_expired, ?DurableExecutionError? error, ?Time? completed_at) -> DurableExecution
-                | (id: String, function_id: String, name: String, status: String, region: String, created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?) -> DurableExecution
-    def self.[]: (String id, String function_id, String name, String status, String region, Time created_at, ?json_value result, ?bool? result_expired, ?DurableExecutionError? error, ?Time? completed_at) -> DurableExecution
-               | (id: String, function_id: String, name: String, status: String, region: String, created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?) -> DurableExecution
-    def self.members: () -> [:id, :function_id, :name, :status, :region, :created_at, :result, :result_expired, :error, :completed_at]
+    def self.new: (String id, String function_id, String name, String status, String region, Time created_at, ?json_value result, ?bool? result_expired, ?DurableExecutionError? error, ?Time? completed_at, ?String? client_token) -> DurableExecution
+                | (id: String, function_id: String, name: String, status: String, region: String, created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?, ?client_token: String?) -> DurableExecution
+    def self.[]: (String id, String function_id, String name, String status, String region, Time created_at, ?json_value result, ?bool? result_expired, ?DurableExecutionError? error, ?Time? completed_at, ?String? client_token) -> DurableExecution
+               | (id: String, function_id: String, name: String, status: String, region: String, created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?, ?client_token: String?) -> DurableExecution
+    def self.members: () -> [:id, :function_id, :name, :status, :region, :created_at, :result, :result_expired, :error, :completed_at, :client_token]
 
     private def initialize: (**(json_value | Time | DurableExecutionError) attributes) -> void
-    def members: () -> [:id, :function_id, :name, :status, :region, :created_at, :result, :result_expired, :error, :completed_at]
-    def with: (?id: String, ?function_id: String, ?name: String, ?status: String, ?region: String, ?created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?) -> DurableExecution
-    def to_h: () -> { id: String, function_id: String, name: String, status: String, region: String, created_at: Time, result: json_value, result_expired: bool?, error: DurableExecutionError?, completed_at: Time? }
+    def members: () -> [:id, :function_id, :name, :status, :region, :created_at, :result, :result_expired, :error, :completed_at, :client_token]
+    def with: (?id: String, ?function_id: String, ?name: String, ?status: String, ?region: String, ?created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?, ?client_token: String?) -> DurableExecution
+    def to_h: () -> { id: String, function_id: String, name: String, status: String, region: String, created_at: Time, result: json_value, result_expired: bool?, error: DurableExecutionError?, completed_at: Time?, client_token: String? }
             | [K, V] () { (Symbol, String | Time | json_value | bool | DurableExecutionError | nil) -> [K, V] } -> Hash[K, V]
-    def deconstruct: () -> [String, String, String, String, String, Time, json_value, bool?, DurableExecutionError?, Time?]
+    def deconstruct: () -> [String, String, String, String, String, Time, json_value, bool?, DurableExecutionError?, Time?, String?]
     def deconstruct_keys: (Array[Symbol]?) -> Hash[Symbol, String | Time | json_value | bool | DurableExecutionError | nil]
     def terminal?: () -> bool
+    def inspect: () -> String
+    def to_s: () -> String
+    def pretty_print: (_PrettyPrinter printer) -> void
+
+    interface _PrettyPrinter
+      def text: (String text) -> void
+    end
   end
 
   class DurableExecutionPage < Data