rcs 2.0.18 → 2.0.20.pre.rc.1

data/lib/pinnacle/types/zod_error.rb

@@ -4,6 +4,7 @@ module Pinnacle
   module Types
     class ZodError < Internal::Types::Model
       field :description, -> { String }, optional: false, nullable: false
+
       field :errors, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
     end
   end

data/lib/pinnacle/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pinnacle
-  VERSION = "2.0.18"
+  VERSION = "2.0.20.pre.rc.1"
 end

data/lib/pinnacle/webhooks/types/attach_webhook_params.rb

@@ -5,10 +5,15 @@ module Pinnacle
     module Types
       class AttachWebhookParams < Internal::Types::Model
         field :senders, -> { Internal::Types::Array[String] }, optional: false, nullable: false
+
         field :webhook_id, -> { String }, optional: true, nullable: false, api_name: "webhookId"
+
         field :name, -> { String }, optional: true, nullable: false
+
         field :url, -> { String }, optional: true, nullable: false
+
         field :event, -> { Pinnacle::Types::WebhookEventEnum }, optional: true, nullable: false
+
         field :headers, -> { Internal::Types::Hash[String, String] }, optional: true, nullable: false
       end
     end

data/lib/pinnacle/webhooks/types/detach_webhook_params.rb

@@ -5,6 +5,7 @@ module Pinnacle
     module Types
       class DetachWebhookParams < Internal::Types::Model
         field :webhook_id, -> { String }, optional: false, nullable: false, api_name: "webhookId"
+
         field :senders, -> { Internal::Types::Array[String] }, optional: false, nullable: false
       end
     end

data/lib/pinnacle/webhooks/types/list_webhooks_params.rb

@@ -5,8 +5,11 @@ module Pinnacle
     module Types
       class ListWebhooksParams < Internal::Types::Model
         field :page_index, -> { Integer }, optional: true, nullable: false, api_name: "pageIndex"
+
         field :page_size, -> { Integer }, optional: true, nullable: false, api_name: "pageSize"
+
         field :status, -> { Pinnacle::Webhooks::Types::ListWebhooksRequestStatus }, optional: true, nullable: false
+
         field :endpoint, -> { String }, optional: true, nullable: false
       end
     end

data/lib/pinnacle/wrapper/messages/client.rb

@@ -5,6 +5,7 @@ require_relative "../../types/message_event"
 require_relative "../../types/user_event"
 require_relative "../../types/form_submission_event"
 require_relative "../../types/campaign_status_event"
+require_relative "../../types/call_status_event"
 
 module Pinnacle
   module Wrapper
@@ -23,7 +24,7 @@ module Pinnacle
         # @param request [Hash] Request with :headers and :body keys
         # @param secret [String, nil] Webhook secret (falls back to PINNACLE_SIGNING_SECRET env var)
         #
-        # @return [Pinnacle::Types::MessageEvent, Pinnacle::Types::UserEvent, Pinnacle::Types::FormSubmissionEvent, Pinnacle::Types::CampaignStatusEvent]
+        # @return [Pinnacle::Types::MessageEvent, Pinnacle::Types::UserEvent, Pinnacle::Types::FormSubmissionEvent, Pinnacle::Types::CampaignStatusEvent, Pinnacle::Types::CallStatusEvent]
         # @raise [Pinnacle::Errors::UnauthorizedError] If webhook signature is invalid or missing
         # @raise [Pinnacle::Errors::ClientError] If request body cannot be parsed
         def process(request, secret: nil)
@@ -66,6 +67,8 @@ module Pinnacle
             Pinnacle::Types::FormSubmissionEvent.coerce(parsed)
           when "CAMPAIGN.STATUS"
             Pinnacle::Types::CampaignStatusEvent.coerce(parsed)
+          when "CALL.STATUS"
+            Pinnacle::Types::CallStatusEvent.coerce(parsed)
           else
             Pinnacle::Types::MessageEvent.coerce(parsed)
           end

data/lib/pinnacle/wrapper/voice/client.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../../calls/client"
+require_relative "voice_socket"
+
+module Pinnacle
+  module Wrapper
+    module Voice
+      class Client
+        DEFAULT_RECONNECT = { enabled: true }.freeze
+
+        class DefaultSocket
+          attr_reader :ready_state
+
+          def initialize(url, protocols = nil)
+            @ready_state = 0
+            @listeners = Hash.new { |hash, key| hash[key] = [] }
+            headers = if protocols.nil?
+                        {}
+                      else
+                        { "Sec-WebSocket-Protocol" => Array(protocols).join(", ") }
+                      end
+            @socket = WebSocket::Client::Simple.connect(url, headers: headers)
+            @socket.on(:open) do |event|
+              @ready_state = 1
+              emit("open", event)
+            end
+            @socket.on(:message) { |message| emit("message", { data: message.data }) }
+            @socket.on(:error) { |error| emit("error", error) }
+            @socket.on(:close) do |event|
+              @ready_state = 3
+              emit("close", event)
+            end
+          end
+
+          def add_event_listener(event, &listener)
+            @listeners[event.to_s] << listener
+          end
+
+          def send(data)
+            @socket.send(data)
+          end
+
+          def close(*)
+            @socket.close
+          end
+
+          private
+
+          def emit(event, payload)
+            @listeners[event].each { |listener| listener.call(payload) }
+          end
+        end
+
+        def initialize(client:)
+          @calls = Pinnacle::Calls::Client.new(client: client)
+        end
+
+        def create_and_connect(
+          to:,
+          from:,
+          record: nil,
+          metadata: nil,
+          token: nil,
+          protocols: nil,
+          reconnect: nil,
+          socket: nil,
+          request_options: {}
+        )
+          call_params = { to: to, from: from }
+          call_params[:record] = record unless record.nil?
+          call_params[:metadata] = metadata unless metadata.nil?
+          call = @calls.create(**call_params, request_options: request_options)
+          connection = connect(
+            call_id: call.id,
+            token: token,
+            protocols: protocols,
+            reconnect: DEFAULT_RECONNECT.merge(reconnect || {}),
+            socket: socket
+          )
+          connection.call = call
+          connection.call_id = call.id
+          connection
+        end
+
+        def connect(call_id:, token: nil, protocols: nil, reconnect: nil, socket: nil)
+          socket_class = socket || default_socket
+          token_params = token || {}
+          stream_token = @calls.create_stream_token(**token_params, id: call_id)
+          create_socket = -> do
+            next_token = @calls.create_stream_token(**token_params, id: call_id)
+            new_socket(socket_class, next_token.stream_url, protocols)
+          end
+
+          VoiceSocket.new(
+            new_socket(socket_class, stream_token.stream_url, protocols),
+            create_socket: create_socket,
+            reconnect: DEFAULT_RECONNECT.merge(reconnect || {})
+          )
+        end
+
+        def connect_stream(stream_url, protocols: nil, reconnect: nil, socket: nil)
+          socket_class = socket || default_socket
+          create_socket = -> { new_socket(socket_class, stream_url, protocols) }
+          VoiceSocket.new(create_socket.call, create_socket: create_socket, reconnect: reconnect)
+        end
+
+        private
+
+        def default_socket
+          require "websocket-client-simple" unless defined?(::WebSocket::Client::Simple)
+          DefaultSocket
+        rescue LoadError => e
+          raise e, "The rcs gem could not load its websocket-client-simple dependency. Reinstall rcs or pass socket: to client.voice.connect."
+        end
+
+        def new_socket(socket_class, stream_url, protocols)
+          return socket_class.new(stream_url) if protocols.nil?
+
+          socket_class.new(stream_url, protocols)
+        end
+      end
+    end
+  end
+end

data/lib/pinnacle/wrapper/voice/types.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Wrapper
+    module Voice
+      module Types
+        VOICE_COMMAND_ACTIONS = [
+          CALL_ANSWER = "call.answer",
+          CALL_END = "call.end",
+          CALL_TRANSFER = "call.transfer",
+          RECORDING_START = "recording.start",
+          RECORDING_STOP = "recording.stop",
+          AUDIO_PLAY = "audio.play",
+          AUDIO_STOP = "audio.stop",
+          AUDIO_REDUCE_NOISE = "audio.reduce_noise",
+          INPUT_GET = "input.get",
+          INPUT_CANCEL = "input.cancel",
+          DTMF_SEND = "dtmf.send",
+          CALL_UPDATE_STATE = "call.update_state"
+        ].freeze
+
+        USER_BUSY = "user_busy"
+        CALL_REJECTED = "call_rejected"
+
+        NOISE_DEFAULT = "default"
+        NOISE_KRISP = "krisp"
+        NOISE_AICOUSTICS = "aicoustics"
+
+        DIRECTION_INBOUND = "inbound"
+        DIRECTION_OUTBOUND = "outbound"
+        DIRECTION_BOTH = "both"
+
+        TRACK_INBOUND = "inbound"
+        TRACK_OUTBOUND = "outbound"
+      end
+    end
+  end
+end

data/lib/pinnacle/wrapper/voice/voice_socket.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "timeout"
+
+require_relative "types"
+
+module Pinnacle
+  module Wrapper
+    module Voice
+      class VoiceSocket
+        attr_accessor :call, :call_id
+        attr_reader :socket
+
+        def initialize(socket, create_socket: nil, reconnect: nil)
+          @socket = socket
+          @create_socket = create_socket
+          @reconnect = normalize_reconnect_options(reconnect || {})
+          @listeners = Hash.new { |hash, key| hash[key] = [] }
+          @pending_acks = {}
+          @closed_by_user = false
+          @reconnect_attempts = 0
+          @reconnect_thread = nil
+          bind_socket
+        end
+
+        def ready_state
+          if @socket.respond_to?(:ready_state)
+            @socket.ready_state
+          elsif @socket.respond_to?(:readyState)
+            @socket.readyState
+          else
+            0
+          end
+        end
+
+        def open?
+          ready_state == 1
+        end
+
+        def wait_until_open(timeout_ms: 10_000)
+          return if open?
+
+          mutex = Mutex.new
+          condition = ConditionVariable.new
+          error = nil
+          done = false
+          unsubscribers = []
+
+          cleanup = -> do
+            unsubscribers.each(&:call)
+          end
+          finish = ->(next_error) do
+            mutex.synchronize do
+              error = next_error
+              done = true
+              condition.signal
+            end
+          end
+
+          unsubscribers << on("open") do
+            cleanup.call
+            finish.call(nil)
+          end
+          unsubscribers << on("close") do
+            cleanup.call
+            finish.call(RuntimeError.new("Voice socket closed before opening."))
+          end
+          unsubscribers << on("error") do |event|
+            cleanup.call
+            finish.call(to_error(event))
+          end
+
+          mutex.synchronize do
+            condition.wait(mutex, timeout_ms / 1000.0) unless done
+          end
+          cleanup.call unless done
+          raise Timeout::Error, "Timed out waiting for voice socket to open." unless done
+          raise error unless error.nil?
+        end
+
+        def connect
+          wait_until_open
+        end
+
+        def on(event, &listener)
+          @listeners[event] << listener
+          -> { @listeners[event].delete(listener) }
+        end
+
+        def send(frame)
+          @socket.send(JSON.generate(frame))
+        end
+
+        def command(frame)
+          send(frame)
+          frame.fetch(:command_id)
+        end
+
+        def command_and_wait(frame, timeout_ms: 10_000)
+          waiter = wait_for_ack(frame.fetch(:command_id), timeout_ms: timeout_ms)
+          command(frame)
+          waiter.call
+        end
+
+        def answer(params = nil, command_id: create_voice_command_id)
+          command(with_optional_params(command_frame(command_id, Types::CALL_ANSWER), params))
+        end
+
+        def end_call(params = nil, command_id: create_voice_command_id)
+          command(with_optional_params(command_frame(command_id, Types::CALL_END), params))
+        end
+
+        def transfer(params, command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::CALL_TRANSFER, params))
+        end
+
+        def start_recording(command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::RECORDING_START))
+        end
+
+        def stop_recording(command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::RECORDING_STOP))
+        end
+
+        def play_audio(params, command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::AUDIO_PLAY, params))
+        end
+
+        def stop_audio(command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::AUDIO_STOP))
+        end
+
+        def reduce_noise(params, command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::AUDIO_REDUCE_NOISE, params))
+        end
+
+        def get_input(params = nil, command_id: create_voice_command_id)
+          command(with_optional_params(command_frame(command_id, Types::INPUT_GET), params))
+        end
+
+        def cancel_input(command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::INPUT_CANCEL))
+        end
+
+        def send_dtmf(params, command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::DTMF_SEND, params))
+        end
+
+        def update_state(params, command_id: create_voice_command_id)
+          command(command_frame(command_id, Types::CALL_UPDATE_STATE, params))
+        end
+
+        def send_media(media)
+          send({ event: "media", media: media })
+        end
+
+        def wait_for_ack(command_id, timeout_ms: 10_000)
+          raise "Already waiting for ack #{command_id}." if @pending_acks.key?(command_id)
+
+          mutex = Mutex.new
+          condition = ConditionVariable.new
+          result = nil
+          error = nil
+          done = false
+          @pending_acks[command_id] = ->(ack, next_error) do
+            mutex.synchronize do
+              result = ack
+              error = next_error
+              done = true
+              condition.signal
+            end
+          end
+
+          -> do
+            mutex.synchronize do
+              condition.wait(mutex, timeout_ms / 1000.0) unless done
+            end
+            @pending_acks.delete(command_id)
+            raise Timeout::Error, "Timed out waiting for ack #{command_id}." unless done
+            raise error unless error.nil?
+
+            result
+          end
+        end
+
+        def close(code = nil, reason = nil)
+          @closed_by_user = true
+          @reconnect_thread&.kill
+          close_socket(@socket, code, reason)
+        end
+
+        def reconnect_now
+          raise "Voice socket was not configured with a reconnect factory." if @create_socket.nil?
+
+          @closed_by_user = false
+          @socket = @create_socket.call
+          bind_socket
+          @reconnect_attempts = 0
+          emit("reconnected", @socket)
+          self
+        end
+
+        def handle_message(data)
+          frame = parse_voice_frame(data)
+          emit("frame", frame)
+          case frame["event"]
+          when "ack"
+            resolve_pending_ack(frame)
+            emit("ack", frame)
+          when "event"
+            emit("event", frame)
+          when "media"
+            emit("media", frame)
+          when "connected"
+            nil
+          else
+            raise "Voice socket received an unknown frame event."
+          end
+        rescue StandardError => e
+          emit("error", e)
+        end
+
+        private
+
+        def bind_socket
+          bind_socket_event(@socket, "open") { |event| emit("open", event) }
+          bind_socket_event(@socket, "close") { |event| handle_close(event) }
+          bind_socket_event(@socket, "error") { |event| emit("error", event) }
+          bind_socket_event(@socket, "message") { |event| handle_message(message_data(event)) }
+        end
+
+        def handle_close(event)
+          reject_pending_acks(RuntimeError.new("Voice socket closed before an ack was received."))
+          emit("close", event)
+          schedule_reconnect
+        end
+
+        def resolve_pending_ack(ack)
+          resolver = @pending_acks.delete(ack["command_id"])
+          resolver&.call(ack, nil)
+        end
+
+        def reject_pending_acks(error)
+          @pending_acks.each_value { |resolver| resolver.call(nil, error) }
+          @pending_acks.clear
+        end
+
+        def emit(event, payload)
+          @listeners[event].each { |listener| listener.call(payload) }
+        end
+
+        def schedule_reconnect
+          return if @closed_by_user || !@reconnect[:enabled] || @create_socket.nil? || @reconnect_thread&.alive?
+
+          if @reconnect_attempts >= @reconnect[:max_attempts]
+            emit("error", RuntimeError.new("Voice socket reconnect attempts exhausted."))
+            return
+          end
+
+          @reconnect_attempts += 1
+          delay_ms = reconnect_delay(@reconnect, @reconnect_attempts)
+          emit("reconnecting", { attempt: @reconnect_attempts, delay_ms: delay_ms })
+          @reconnect_thread = Thread.new do
+            sleep(delay_ms / 1000.0)
+            reconnect_now
+          rescue StandardError => e
+            emit("error", e)
+            schedule_reconnect
+          end
+        end
+
+        def command_frame(command_id, action, params = nil)
+          frame = { event: "command", command_id: command_id, action: action }
+          frame[:params] = params unless params.nil?
+          frame
+        end
+
+        def with_optional_params(frame, params)
+          frame[:params] = params unless params.nil?
+          frame
+        end
+
+        def parse_voice_frame(data)
+          raise "Voice socket received a non-string frame." unless data.is_a?(String)
+
+          JSON.parse(data)
+        end
+
+        def bind_socket_event(socket, event, &listener)
+          if socket.respond_to?(:add_event_listener)
+            socket.add_event_listener(event, &listener)
+          elsif socket.respond_to?(:addEventListener)
+            socket.addEventListener(event, listener)
+          elsif socket.respond_to?(:on)
+            socket.on(event, &listener)
+          else
+            socket.public_send(:"on#{event}=", listener)
+          end
+        end
+
+        def message_data(event)
+          event.is_a?(Hash) ? event[:data] || event["data"] : event.data
+        end
+
+        def close_socket(socket, code, reason)
+          if code.nil? && reason.nil?
+            socket.close
+          elsif reason.nil?
+            socket.close(code)
+          else
+            socket.close(code, reason)
+          end
+        end
+
+        def normalize_reconnect_options(options)
+          {
+            enabled: options.fetch(:enabled, options.fetch("enabled", false)),
+            max_attempts: options.fetch(:max_attempts, options.fetch(:maxAttempts, options.fetch("maxAttempts", 5))),
+            initial_delay_ms: options.fetch(
+              :initial_delay_ms,
+              options.fetch(:initialDelayMs, options.fetch("initialDelayMs", 250))
+            ),
+            max_delay_ms: options.fetch(:max_delay_ms, options.fetch(:maxDelayMs, options.fetch("maxDelayMs", 5_000))),
+            backoff_multiplier: options.fetch(
+              :backoff_multiplier,
+              options.fetch(:backoffMultiplier, options.fetch("backoffMultiplier", 2))
+            )
+          }
+        end
+
+        def reconnect_delay(options, attempt)
+          delay = options[:initial_delay_ms] * (options[:backoff_multiplier]**[attempt - 1, 0].max)
+          [delay, options[:max_delay_ms]].min
+        end
+
+        def create_voice_command_id
+          self.class.create_voice_command_id
+        end
+
+        def to_error(error)
+          error.is_a?(Exception) ? error : RuntimeError.new("Voice socket error.")
+        end
+
+        class << self
+          def create_voice_command_id
+            "cmd_#{SecureRandom.uuid}"
+          end
+        end
+      end
+    end
+  end
+end