restate-sdk 0.4.3

data/lib/restate/context.rb

@@ -0,0 +1,336 @@
+# typed: true
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength,Metrics/ParameterLists,Style/EmptyMethod
+module Restate
+  # Signals when the current invocation attempt has finished — either the handler
+  # completed, the connection was lost, or a transient error occurred.
+  #
+  # Use this to clean up attempt-scoped resources (open connections, temp files,
+  # etc.) that should not outlive the current attempt.
+  #
+  # Available via +ctx.request.attempt_finished_event+.
+  #
+  # @example Cancel a long-running HTTP call when the attempt finishes
+  #   event = ctx.request.attempt_finished_event
+  #   ctx.run('call-api') do
+  #     # poll event.set? periodically, or pass it to your HTTP client
+  #   end
+  class AttemptFinishedEvent
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @mutex = T.let(Mutex.new, Mutex)
+      @set = T.let(false, T::Boolean)
+      @waiters = T.let([], T::Array[Thread::Queue])
+    end
+
+    # Returns true if the attempt has finished.
+    sig { returns(T::Boolean) }
+    def set?
+      @set
+    end
+
+    # Blocks the current fiber/thread until the attempt finishes.
+    sig { void }
+    def wait
+      return if @set
+
+      waiter = T.let(nil, T.nilable(Thread::Queue))
+      @mutex.synchronize do
+        unless @set
+          waiter = Thread::Queue.new
+          @waiters << waiter
+        end
+      end
+      waiter&.pop
+    end
+
+    # Marks the event as set and wakes all waiters.
+    # Called internally by the SDK when the attempt ends.
+    sig { void }
+    def set!
+      @mutex.synchronize do
+        @set = true
+        @waiters.each { |w| w.push(true) }
+        @waiters.clear
+      end
+    end
+  end
+
+  # Request metadata available to handlers via +ctx.request+.
+  #
+  # @!attribute [r] id
+  #   @return [String] the invocation ID
+  # @!attribute [r] headers
+  #   @return [Hash{String => String}] request headers
+  # @!attribute [r] body
+  #   @return [String] raw input bytes
+  # @!attribute [r] attempt_finished_event
+  #   @return [AttemptFinishedEvent] signaled when this attempt ends
+  Request = Struct.new(:id, :headers, :body, :attempt_finished_event, keyword_init: true)
+
+  # Base context interface for all Restate handlers.
+  #
+  # Provides durable execution (+run+, +run_sync+), timers (+sleep+),
+  # service-to-service calls, awakeables, and request metadata.
+  #
+  # @see ObjectContext for VirtualObject handlers (adds state operations)
+  # @see WorkflowContext for Workflow handlers (adds promise operations)
+  module Context
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    # Execute a durable side effect. The block runs at most once; the result
+    # is journaled and replayed on retries.
+    #
+    # Pass +background: true+ to offload the block to a real OS Thread,
+    # keeping the fiber event loop responsive for CPU-intensive work.
+    sig do
+      abstract.params(
+        name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
+        background: T::Boolean, action: T.proc.returns(T.untyped)
+      ).returns(DurableFuture)
+    end
+    def run(name, serde: JsonSerde, retry_policy: nil, background: false, &action); end
+
+    # Convenience shortcut for +run(...).await+. Returns the result directly.
+    # Accepts all the same options as +run+, including +background: true+.
+    sig do
+      abstract.params(
+        name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
+        background: T::Boolean, action: T.proc.returns(T.untyped)
+      ).returns(T.untyped)
+    end
+    def run_sync(name, serde: JsonSerde, retry_policy: nil, background: false, &action); end
+
+    # Durable timer that survives handler restarts.
+    sig { params(seconds: Numeric).returns(DurableFuture) }
+    def sleep(seconds) # rubocop:disable Lint/UnusedMethodArgument
+      Kernel.raise NotImplementedError
+    end
+
+    # Durably call a handler on a Restate service.
+    sig do
+      abstract.params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        arg: T.untyped, key: T.nilable(String), idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def service_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil,
+                     input_serde: NOT_SET, output_serde: NOT_SET)
+    end
+    # Fire-and-forget send to a Restate service handler.
+    sig do
+      abstract.params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        arg: T.untyped, key: T.nilable(String), delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def service_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil,
+                     headers: nil, input_serde: NOT_SET)
+    end
+    # Durably call a handler on a Restate virtual object.
+    sig do
+      abstract.params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def object_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
+                    input_serde: NOT_SET, output_serde: NOT_SET)
+    end
+    # Fire-and-forget send to a Restate virtual object handler.
+    sig do
+      abstract.params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def object_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
+                    headers: nil, input_serde: NOT_SET)
+    end
+    # Durably call a handler on a Restate workflow.
+    sig do
+      abstract.params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def workflow_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
+                      input_serde: NOT_SET, output_serde: NOT_SET)
+    end
+    # Fire-and-forget send to a Restate workflow handler.
+    sig do
+      abstract.params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def workflow_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
+                      headers: nil, input_serde: NOT_SET)
+    end
+    # Durably call a handler using raw bytes (no serialization).
+    sig do
+      abstract.params(
+        service: String, handler: String, arg: String,
+        key: T.nilable(String), idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String])
+      ).returns(DurableCallFuture)
+    end
+    def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil); end
+
+    # Fire-and-forget send using raw bytes (no serialization).
+    sig do
+      abstract.params(
+        service: String, handler: String, arg: String,
+        key: T.nilable(String), delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String])
+      ).returns(SendHandle)
+    end
+    def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil); end
+
+    # Create an awakeable for external callbacks.
+    # Returns [awakeable_id, DurableFuture].
+    sig { abstract.params(serde: T.untyped).returns([String, DurableFuture]) }
+    def awakeable(serde: JsonSerde); end
+
+    # Resolve an awakeable with a success value.
+    sig { abstract.params(awakeable_id: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_awakeable(awakeable_id, payload, serde: JsonSerde); end
+
+    # Reject an awakeable with a terminal failure.
+    sig { abstract.params(awakeable_id: String, message: String, code: Integer).void }
+    def reject_awakeable(awakeable_id, message, code: 500); end
+
+    # Request cancellation of another invocation.
+    sig { abstract.params(invocation_id: String).void }
+    def cancel_invocation(invocation_id); end
+
+    # Wait until any of the given futures completes.
+    # Returns [completed, remaining].
+    sig { abstract.params(futures: DurableFuture).returns([T::Array[DurableFuture], T::Array[DurableFuture]]) }
+    def wait_any(*futures); end
+
+    # Returns metadata about the current invocation.
+    sig { abstract.returns(Request) }
+    def request; end
+
+    # Returns the key for this virtual object or workflow invocation.
+    sig { abstract.returns(String) }
+    def key; end
+  end
+
+  # Context interface for VirtualObject shared handlers (read-only state).
+  # Extends {Context} with +get+, +state_keys+, and +key+ — but no mutations.
+  module ObjectSharedContext
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+    include Context
+
+    # Durably retrieve a state entry. Returns nil if unset.
+    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
+    def get(name, serde: JsonSerde); end
+
+    # Durably retrieve a state entry, returning a DurableFuture instead of blocking.
+    sig { abstract.params(name: String, serde: T.untyped).returns(DurableFuture) }
+    def get_async(name, serde: JsonSerde); end
+
+    # List all state entry names.
+    sig { abstract.returns(T.untyped) }
+    def state_keys; end
+
+    # List all state entry names, returning a DurableFuture instead of blocking.
+    sig { abstract.returns(DurableFuture) }
+    def state_keys_async; end
+  end
+
+  # Context interface for VirtualObject exclusive handlers (full state access).
+  # Extends {ObjectSharedContext} with mutating state operations.
+  module ObjectContext
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+    include ObjectSharedContext
+
+    # Durably set a state entry.
+    sig { abstract.params(name: String, value: T.untyped, serde: T.untyped).void }
+    def set(name, value, serde: JsonSerde); end
+
+    # Durably remove a single state entry.
+    sig { abstract.params(name: String).void }
+    def clear(name); end
+
+    # Durably remove all state entries.
+    sig { abstract.void }
+    def clear_all; end
+  end
+
+  # Context interface for Workflow shared handlers (read-only state + promises).
+  # Extends {ObjectSharedContext} with durable promise operations.
+  module WorkflowSharedContext
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+    include ObjectSharedContext
+
+    # Get a durable promise value, blocking until resolved.
+    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
+    def promise(name, serde: JsonSerde); end
+
+    # Peek at a durable promise without blocking. Returns nil if not yet resolved.
+    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
+    def peek_promise(name, serde: JsonSerde); end
+
+    # Resolve a durable promise with a value.
+    sig { abstract.params(name: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_promise(name, payload, serde: JsonSerde); end
+
+    # Reject a durable promise with a terminal failure.
+    sig { abstract.params(name: String, message: String, code: Integer).void }
+    def reject_promise(name, message, code: 500); end
+  end
+
+  # Context interface for Workflow main handler (full state + promises).
+  # Extends {ObjectContext} with durable promise operations.
+  module WorkflowContext
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+    include ObjectContext
+
+    # Get a durable promise value, blocking until resolved.
+    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
+    def promise(name, serde: JsonSerde); end
+
+    # Peek at a durable promise without blocking. Returns nil if not yet resolved.
+    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
+    def peek_promise(name, serde: JsonSerde); end
+
+    # Resolve a durable promise with a value.
+    sig { abstract.params(name: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_promise(name, payload, serde: JsonSerde); end
+
+    # Reject a durable promise with a terminal failure.
+    sig { abstract.params(name: String, message: String, code: Integer).void }
+    def reject_promise(name, message, code: 500); end
+  end
+end
+# rubocop:enable Metrics/ModuleLength,Metrics/ParameterLists,Style/EmptyMethod

data/lib/restate/discovery.rb

@@ -0,0 +1,150 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'json'
+
+module Restate
+  module Discovery # rubocop:disable Metrics/ModuleLength
+    extend T::Sig
+
+    PROTOCOL_MODES = T.let({
+      'bidi' => 'BIDI_STREAM',
+      'request_response' => 'REQUEST_RESPONSE'
+    }.freeze, T::Hash[String, String])
+
+    SERVICE_TYPES = T.let({
+      'service' => 'SERVICE',
+      'object' => 'VIRTUAL_OBJECT',
+      'workflow' => 'WORKFLOW'
+    }.freeze, T::Hash[String, String])
+
+    HANDLER_TYPES = T.let({
+      'exclusive' => 'EXCLUSIVE',
+      'shared' => 'SHARED',
+      'workflow' => 'WORKFLOW'
+    }.freeze, T::Hash[String, String])
+
+    module_function
+
+    # Generate the discovery JSON for the given endpoint.
+    sig { params(endpoint: Endpoint, _version: Integer, discovered_as: String).returns(String) }
+    def compute_discovery_json(endpoint, _version, discovered_as)
+      ep = compute_discovery(endpoint, discovered_as)
+      JSON.generate(ep, allow_nan: false)
+    end
+
+    # Build the discovery hash for the endpoint.
+    sig { params(endpoint: Endpoint, discovered_as: String).returns(T::Hash[Symbol, T.untyped]) }
+    def compute_discovery(endpoint, discovered_as)
+      services = endpoint.services.values.map do |service|
+        build_service(service)
+      end
+
+      protocol_mode = PROTOCOL_MODES.fetch(endpoint.protocol || discovered_as)
+
+      compact(
+        protocolMode: protocol_mode,
+        minProtocolVersion: 5,
+        maxProtocolVersion: 5,
+        services: services
+      )
+    end
+
+    sig { params(service: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+    def build_service(service) # rubocop:disable Metrics/AbcSize
+      service_type = SERVICE_TYPES.fetch(service.service_tag.kind)
+
+      handlers = service.handlers.values.map do |handler|
+        build_handler(handler)
+      end
+
+      svc_name = service.service_name
+
+      result = compact(
+        name: svc_name,
+        ty: service_type,
+        handlers: handlers,
+        documentation: service.service_tag.description,
+        metadata: service.service_tag.metadata,
+        enableLazyState: service.lazy_state?,
+        inactivityTimeout: seconds_to_ms(service.svc_inactivity_timeout),
+        abortTimeout: seconds_to_ms(service.svc_abort_timeout),
+        journalRetention: seconds_to_ms(service.svc_journal_retention),
+        idempotencyRetention: seconds_to_ms(service.svc_idempotency_retention),
+        ingressPrivate: service.svc_ingress_private
+      )
+
+      policy = service.svc_invocation_retry_policy
+      merge_retry_policy!(result, policy) if policy
+
+      result
+    end
+
+    sig { params(handler: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+    def build_handler(handler) # rubocop:disable Metrics/AbcSize
+      ty = handler.kind ? HANDLER_TYPES.fetch(handler.kind) : nil
+
+      input_payload = {
+        required: false,
+        contentType: handler.handler_io.accept,
+        jsonSchema: handler.handler_io.input_serde.json_schema
+      }
+
+      output_payload = {
+        setContentTypeIfEmpty: false,
+        contentType: handler.handler_io.content_type,
+        jsonSchema: handler.handler_io.output_serde.json_schema
+      }
+
+      result = compact(
+        name: handler.name,
+        ty: ty,
+        input: compact(**input_payload),
+        output: compact(**output_payload),
+        enableLazyState: handler.enable_lazy_state,
+        documentation: handler.description,
+        metadata: handler.metadata,
+        inactivityTimeout: seconds_to_ms(handler.inactivity_timeout),
+        abortTimeout: seconds_to_ms(handler.abort_timeout),
+        journalRetention: seconds_to_ms(handler.journal_retention),
+        idempotencyRetention: seconds_to_ms(handler.idempotency_retention),
+        workflowCompletionRetention: seconds_to_ms(handler.workflow_completion_retention),
+        ingressPrivate: handler.ingress_private
+      )
+
+      merge_retry_policy!(result, handler.invocation_retry_policy) if handler.invocation_retry_policy
+
+      result
+    end
+
+    # Convert seconds to milliseconds (integer). Returns nil if input is nil.
+    sig { params(seconds: T.nilable(Numeric)).returns(T.nilable(Integer)) }
+    def seconds_to_ms(seconds)
+      return nil if seconds.nil?
+
+      (seconds * 1000).to_i
+    end
+
+    # Merge retry policy fields (flattened) into the target hash.
+    sig { params(target: T::Hash[Symbol, T.untyped], policy: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    def merge_retry_policy!(target, policy) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+      return if policy.nil? || policy.empty?
+
+      target[:retryPolicyInitialInterval] = seconds_to_ms(policy[:initial_interval]) if policy[:initial_interval]
+      target[:retryPolicyMaxInterval] = seconds_to_ms(policy[:max_interval]) if policy[:max_interval]
+      target[:retryPolicyMaxAttempts] = policy[:max_attempts] if policy[:max_attempts]
+      target[:retryPolicyExponentiationFactor] = policy[:exponentiation_factor] if policy[:exponentiation_factor]
+      target[:retryPolicyOnMaxAttempts] = policy[:on_max_attempts].to_s.upcase if policy[:on_max_attempts]
+    end
+
+    # Remove nil values from a hash (non-recursive for top level, recursive for nested).
+    sig { params(kwargs: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+    def compact(**kwargs)
+      kwargs.each_with_object({}) do |(k, v), result|
+        next if v.nil?
+
+        result[k] = v.is_a?(Hash) ? compact(**v) : v
+      end
+    end
+  end
+end

data/lib/restate/durable_future.rb

@@ -0,0 +1,131 @@
+# typed: true
+# frozen_string_literal: true
+
+module Restate
+  # A durable future wrapping a VM handle. Lazily resolves on first +await+ and caches the result.
+  # Returned by +ctx.run+ and +ctx.sleep+.
+  class DurableFuture
+    extend T::Sig
+
+    sig { returns(Integer) }
+    attr_reader :handle
+
+    sig { params(ctx: ServerContext, handle: Integer, serde: T.untyped).void }
+    def initialize(ctx, handle, serde: nil)
+      @ctx = T.let(ctx, ServerContext)
+      @handle = T.let(handle, Integer)
+      @serde = T.let(serde, T.untyped)
+      @resolved = T.let(false, T::Boolean)
+      @value = T.let(nil, T.untyped)
+    end
+
+    # Block until the result is available and return it. Caches across calls.
+    #
+    # @return [Object] the deserialized result
+    sig { returns(T.untyped) }
+    def await
+      unless @resolved
+        raw = @ctx.resolve_handle(@handle)
+        @value = @serde ? @serde.deserialize(raw) : raw
+        @resolved = true
+      end
+      @value
+    end
+
+    # Check whether the future has completed (non-blocking).
+    #
+    # @return [Boolean]
+    sig { returns(T::Boolean) }
+    def completed?
+      @resolved || @ctx.completed?(@handle)
+    end
+  end
+
+  # A durable future for service/object/workflow calls.
+  # Adds +invocation_id+ and +cancel+ on top of DurableFuture.
+  # Returned by +ctx.service_call+, +ctx.object_call+, +ctx.workflow_call+.
+  class DurableCallFuture < DurableFuture
+    extend T::Sig
+
+    sig do
+      params(
+        ctx: ServerContext,
+        result_handle: Integer,
+        invocation_id_handle: Integer,
+        output_serde: T.untyped
+      ).void
+    end
+    def initialize(ctx, result_handle, invocation_id_handle, output_serde:)
+      super(ctx, result_handle)
+      @invocation_id_handle = T.let(invocation_id_handle, Integer)
+      @output_serde = T.let(output_serde, T.untyped)
+      @invocation_id_resolved = T.let(false, T::Boolean)
+      @invocation_id_value = T.let(nil, T.untyped)
+    end
+
+    # Block until the result is available and return it. Deserializes via +output_serde+.
+    sig { returns(T.untyped) }
+    def await
+      unless @resolved
+        raw = @ctx.resolve_handle(@handle)
+        @value = if raw.nil? || @output_serde.nil?
+                   raw
+                 else
+                   @output_serde.deserialize(raw)
+                 end
+        @resolved = true
+      end
+      @value
+    end
+
+    # Returns the invocation ID of the remote call. Lazily resolved.
+    #
+    # @return [String] the invocation ID
+    sig { returns(String) }
+    def invocation_id
+      unless @invocation_id_resolved
+        @invocation_id_value = @ctx.resolve_handle(@invocation_id_handle)
+        @invocation_id_resolved = true
+      end
+      T.must(@invocation_id_value)
+    end
+
+    # Cancel the remote invocation.
+    sig { void }
+    def cancel
+      @ctx.cancel_invocation(invocation_id)
+    end
+  end
+
+  # A handle for fire-and-forget send operations.
+  # Returned by +ctx.service_send+, +ctx.object_send+, +ctx.workflow_send+.
+  class SendHandle
+    extend T::Sig
+
+    sig { params(ctx: ServerContext, invocation_id_handle: Integer).void }
+    def initialize(ctx, invocation_id_handle)
+      @ctx = T.let(ctx, ServerContext)
+      @invocation_id_handle = T.let(invocation_id_handle, Integer)
+      @invocation_id_resolved = T.let(false, T::Boolean)
+      @invocation_id_value = T.let(nil, T.untyped)
+    end
+
+    # Returns the invocation ID of the sent call. Lazily resolved.
+    #
+    # @return [String] the invocation ID
+    sig { returns(String) }
+    def invocation_id
+      unless @invocation_id_resolved
+        @invocation_id_value = @ctx.resolve_handle(@invocation_id_handle)
+        @invocation_id_resolved = true
+      end
+      T.must(@invocation_id_value)
+    end
+
+    # Cancel the remote invocation.
+    sig { void }
+    def cancel
+      @ctx.cancel_invocation(invocation_id)
+    end
+  end
+end

data/lib/restate/endpoint.rb

@@ -0,0 +1,69 @@
+# typed: true
+# frozen_string_literal: true
+
+module Restate
+  # Container for registered services. Bind services here, then create the Rack app.
+  class Endpoint
+    extend T::Sig
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    attr_reader :services
+
+    sig { returns(T::Array[String]) }
+    attr_reader :identity_keys
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :protocol
+
+    sig { void }
+    def initialize
+      @services = T.let({}, T::Hash[String, T.untyped])
+      @protocol = T.let(nil, T.nilable(String))
+      @identity_keys = T.let([], T::Array[String])
+    end
+
+    # Bind one or more services to this endpoint.
+    #
+    # @param svcs [Array<Class<Service>, Class<VirtualObject>, Class<Workflow>>] services to bind
+    # @return [self]
+    # @raise [ArgumentError] if a service with the same name is already bound
+    sig { params(svcs: T.untyped).returns(T.self_type) }
+    def bind(*svcs)
+      svcs.each do |svc|
+        svc_name = svc.service_name
+        raise ArgumentError, "Service #{svc_name} already exists" if @services.key?(svc_name)
+
+        @services[svc_name] = svc
+      end
+      self
+    end
+
+    # Force bidirectional streaming protocol.
+    sig { returns(T.self_type) }
+    def streaming_protocol
+      @protocol = 'bidi'
+      self
+    end
+
+    # Force request/response protocol.
+    sig { returns(T.self_type) }
+    def request_response_protocol
+      @protocol = 'request_response'
+      self
+    end
+
+    # Add an identity key for request verification.
+    sig { params(key: String).returns(T.self_type) }
+    def identity_key(key)
+      @identity_keys << key
+      self
+    end
+
+    # Build and return the Rack-compatible application.
+    sig { returns(T.untyped) }
+    def app
+      require_relative 'server'
+      Server.new(self)
+    end
+  end
+end