retell-sdk-unofficial 0.1.0

data/lib/retell/sdk/unofficial/client.rb

@@ -0,0 +1,285 @@
+require 'httparty'
+require 'json'
+
+require_relative 'api/agent'
+require_relative 'api/call'
+require_relative 'api/retell_llm'
+require_relative 'api/phone_number'
+require_relative 'api/voice'
+require_relative 'api/concurrency'
+
+module Retell
+  module SDK
+    module Unofficial
+      class Client
+        DEFAULT_BASE_URL = 'https://api.retellai.com'.freeze
+        DEFAULT_TIMEOUT = 60
+
+        def initialize(api_key:, base_url: nil, timeout: DEFAULT_TIMEOUT)
+          @api_key = api_key
+          @base_url = base_url || DEFAULT_BASE_URL
+          @timeout = timeout
+        end
+
+        def agent
+          @agent ||= Retell::SDK::Unofficial::API::Agent.new(self)
+        end
+
+        def call
+          @call ||= Retell::SDK::Unofficial::API::Call.new(self)
+        end
+
+        def retell_llm
+          @retell_llm ||= Retell::SDK::Unofficial::API::RetellLLM.new(self)
+        end
+
+        def phone_number
+          @phone_number ||= Retell::SDK::Unofficial::API::PhoneNumber.new(self)
+        end
+
+        def voice
+          @voice ||= Retell::SDK::Unofficial::API::Voice.new(self)
+        end
+
+        def concurrency
+          @concurrency ||= Retell::SDK::Unofficial::API::Concurrency.new(self)
+        end
+
+        def agents
+          agent.list
+        end
+
+        def calls(**params)
+          call.list(**params)
+        end
+
+        def retell_llms
+          retell_llm.list
+        end
+
+        def phone_numbers
+          phone_number.list
+        end
+
+        def voices
+          voice.list
+        end
+
+        def request(method, path, params = {}, **options)
+          url = "#{@base_url}#{path}"
+
+          http_options = {
+            headers: headers.merge(options[:headers] || {}),
+            format: :json,
+            timeout: options[:timeout] || @timeout
+          }
+
+          body_params = options[:body] || {}
+
+          if [:get, :delete].include?(method)
+            options[:query] = options[:query].merge(params)
+          else
+            options[:body] = options[:body].merge(params)
+          end
+
+          http_options[:query] = options[:query] unless options[:query].empty?
+
+          if [:post, :patch].include?(method)
+            http_options[:body] = options[:body].to_json
+          elsif !body_params.empty?
+            http_options[:body] = body_params.to_json
+          end
+
+          begin
+            response = HTTParty.send(
+              method,
+              url,
+              http_options
+            )
+          rescue Net::OpenTimeout, Net::ReadTimeout, Timeout::Error, Errno::ETIMEDOUT => e
+            raise APITimeoutError.new(http_options)
+          end
+
+          handle_response(response)
+        end
+
+        def get(path, params = {}, **options)
+          request(:get, path, params, **options)
+        end
+
+        def post(path, params = {}, **options)
+          request(:post, path, params, **options)
+        end
+
+        def patch(path, params = {}, **options)
+          request(:patch, path, params, **options)
+        end
+
+        def delete(path, params = {}, **options)
+          request(:delete, path, params, **options)
+          nil
+        end
+
+        def make_request_options(extra_headers: nil, extra_query: nil, extra_body: nil, timeout: nil)
+          options = {}
+          options[:headers] = extra_headers || {}
+          options[:query] = extra_query || {}
+          options[:body] = extra_body || {}
+          options[:timeout] = timeout if timeout
+          options
+        end
+
+        private
+
+        def headers
+          {
+            'Authorization' => "Bearer #{@api_key}",
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json'
+          }
+        end
+
+        def handle_response(response)
+          case response.code
+          when 204
+            return nil
+          when 200..299
+            parse_response(response)
+          when 400..499
+            raise Retell::SDK::Unofficial::Error.new(response.code, "Client error: #{response.body}")
+          when 500..599
+            raise Retell::SDK::Unofficial::Error.new(response.code, "Server error: #{response.body}")
+          else
+            raise Retell::SDK::Unofficial::Error.new(response.code, "Unknown error: #{response.body}")
+          end
+        end
+
+        def parse_response(response)
+          data = response.parsed_response
+          if data.is_a?(Array)
+            parse_array_response(data)
+          elsif data.is_a?(Hash)
+            parse_single_response(data)
+          else
+            raise Retell::SDK::Unofficial::Error, "Unexpected data format: #{data.class}"
+          end
+        end
+
+        def parse_array_response(data)
+          type_key = data.first&.keys&.find { |key|
+            key.end_with?('_id') || key == 'phone_number'
+          }&.gsub('_id', '')
+
+          return unknown_response_error('array') unless type_key
+
+          list_class = "Retell::SDK::Unofficial::#{process_type_key(type_key)}List"
+          item_class = "Retell::SDK::Unofficial::#{process_type_key(type_key)}"
+
+          items = data.map { |item_data| constantize_item_class(item_class).new(
+            self,
+            **process_data(item_data, type_key)
+          )}
+          raw_response = { "#{type_key}s".to_sym => items }
+
+          constantize_list_class(list_class).new(**raw_response)
+        end
+
+        def parse_single_response(data)
+          type_key = data.keys.find { |key|
+            key.end_with?('_id') || key == 'phone_number' || key == 'concurrency_limit'
+          }&.gsub('_id', '')
+
+          return unknown_response_error('single object') unless type_key
+
+          response_class = "Retell::SDK::Unofficial::#{process_type_key(type_key)}"
+          processed_data = process_data(data, type_key)
+
+          constantize_item_class(response_class).new(self, **processed_data)
+        end
+
+        # yes, same as constantize_list_class - to circumvent type checking issues
+        def constantize_item_class(class_name)
+          class_name.split('::').inject(Object) { |mod, class_name| mod.const_get(class_name) }
+        end
+
+        # yes, same as constantize_item_class - Ruby type checking isn't where it should be
+        def constantize_list_class(class_name)
+          class_name.split('::').inject(Object) { |mod, class_name| mod.const_get(class_name) }
+        end
+
+        def process_type_key(type_key)
+          case type_key
+          when 'llm'
+            'RetellLLM'
+          when 'concurrency_limit'
+            'Concurrency'
+          when 'phone_number'
+            'PhoneNumber'
+          else
+            type_key.capitalize
+          end
+        end
+
+        def process_data(data, type_key)
+          case data
+          when Hash
+            data.map do |key, value|
+              processed_value = process_data(value, type_key)
+              [
+                key.to_sym,
+                convert_to_float(processed_value, type_key, key.to_sym)
+              ]
+            end.to_h
+          when Array
+            data.map { |item| process_data(item, type_key) }
+          else
+            data
+          end
+        end
+
+        def convert_to_float(value, type_key, field_name)
+          if value.is_a?(Integer) && float_fields(type_key).include?(field_name)
+            value.to_f
+          else
+            value
+          end
+        end
+
+        def float_fields(type_key)
+          case type_key
+          when 'agent'
+            [:ambient_sound_volume, :backchannel_frequency, :interruption_sensitivity, :responsiveness, :voice_speed, :voice_temperature, :volume]
+          when 'llm'
+            [:model_temperature]
+          else
+            []
+          end
+        end
+
+        def unknown_response_error(type)
+          raise Retell::SDK::Unofficial::Error, "Unknown response type for #{type} data"
+        end
+      end
+
+      class Error < StandardError
+        attr_reader :code, :message
+
+        def initialize(code, message)
+          @code = code
+          @message = message
+          super("#{code}: #{message}")
+        end
+      end
+
+
+      class APITimeoutError < Error
+        attr_reader :request
+
+        def initialize(request)
+          @request = request
+          super(500, "API request timed out")
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/concurrency.rb

@@ -0,0 +1,17 @@
+module Retell
+  module SDK
+    module Unofficial
+      class Concurrency < Base
+        @attributes = [
+          :current_concurrency, :concurrency_limit
+        ]
+
+        attr_reader *@attributes
+
+        def retrieve
+          @client.concurrency.retrieve()
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/phone_call.rb

@@ -0,0 +1,22 @@
+module Retell
+  module SDK
+    module Unofficial
+      class PhoneCall < BaseCall
+        @attributes = [:from_number, :to_number, :direction] + BaseCall.attributes
+
+        attr_reader *@attributes
+
+        def initialize(client, raw_response)
+          super(client, raw_response)
+          @from_number = raw_response[:from_number]
+          @to_number = raw_response[:to_number]
+          @direction = raw_response[:direction]
+        end
+
+        def retrieve
+          @client.call.retrieve(self)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/phone_number.rb

@@ -0,0 +1,62 @@
+module Retell
+  module SDK
+    module Unofficial
+      class PhoneNumber < Base
+        @attributes = [
+          :phone_number, :phone_number_pretty, :inbound_agent_id, :outbound_agent_id,
+          :area_code, :nickname, :last_modification_timestamp
+        ]
+
+        @writeable_attributes = [
+          :inbound_agent_id, :outbound_agent_id, :nickname
+        ]
+
+        attr_reader *@attributes
+
+        @writeable_attributes.each do |attr|
+          define_method("#{attr}=") do |value|
+            self[attr] = value
+          end
+        end
+
+        def inbound_agent
+          inbound_agent_id
+        end
+
+        def inbound_agent=(value)
+          self[:inbound_agent_id] = value
+        end
+
+        def outbound_agent
+          outbound_agent_id
+        end
+
+        def outbound_agent=(value)
+          self[:outbound_agent_id] = value
+        end
+
+        def retrieve
+          @client.phone_number.retrieve(self)
+        end
+
+        def update(**params)
+          update_params = @changed_attributes.merge(params)
+
+          if update_params.any?
+            updated_phone_number = @client.phone_number.update(self, **update_params)
+            self.class.attributes.each do |attr|
+              instance_variable_set("@#{attr}", updated_phone_number.send(attr))
+            end
+            @changed_attributes.clear
+          end
+
+          self
+        end
+
+        def delete
+          @client.phone_number.delete(self)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/phone_number_list.rb

@@ -0,0 +1,11 @@
+module Retell
+  module SDK
+    module Unofficial
+      class PhoneNumberList < BaseList
+        def initialize(raw_response)
+          super(:phone_numbers, raw_response)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/retell_llm.rb

@@ -0,0 +1,59 @@
+module Retell
+  module SDK
+    module Unofficial
+      class RetellLLM < Base
+        @attributes = [
+          :last_modification_timestamp, :llm_id, :llm_websocket_url, :begin_message,
+          :general_prompt, :general_tools, :inbound_dynamic_variables_webhook_url,
+          :model, :model_temperature, :starting_state, :states
+        ]
+
+        @writeable_attributes = [
+          :begin_message,:general_prompt, :general_tools, :inbound_dynamic_variables_webhook_url, :model, :model_temperature, :states, :starting_state
+        ]
+
+        attr_reader *@attributes
+
+        def id
+          llm_id
+        end
+
+        def websocket_url
+          llm_websocket_url
+        end
+
+        def url
+          llm_websocket_url
+        end
+
+        @writeable_attributes.each do |attr|
+          define_method("#{attr}=") do |value|
+            self[attr] = value
+          end
+        end
+
+        def retrieve
+          @client.retell_llm.retrieve(self)
+        end
+
+        def update(**params)
+          update_params = @changed_attributes.merge(params)
+
+          if update_params.any?
+            updated_retell_llm = @client.retell_llm.update(self, **update_params)
+            self.class.attributes.each do |attr|
+              instance_variable_set("@#{attr}", updated_retell_llm.send(attr))
+            end
+            @changed_attributes.clear
+          end
+
+          self
+        end
+
+        def delete
+          @client.retell_llm.delete(self)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/retell_llm_list.rb

@@ -0,0 +1,11 @@
+module Retell
+  module SDK
+    module Unofficial
+      class RetellLLMList < BaseList
+        def initialize(raw_response)
+          super(:llms, raw_response)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/version.rb

@@ -0,0 +1,7 @@
+module Retell
+  module SDK
+    module Unofficial
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/retell/sdk/unofficial/voice.rb

@@ -0,0 +1,25 @@
+module Retell
+  module SDK
+    module Unofficial
+      class Voice < Base
+        @attributes = [
+          :voice_id, :voice_name, :provider, :accent, :gender, :age, :preview_audio_url
+        ]
+
+        attr_reader *@attributes
+
+        def retrieve
+          @client.voice.retrieve(self)
+        end
+
+        def id
+          voice_id
+        end
+
+        def name
+          voice_name
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/voice_list.rb

@@ -0,0 +1,11 @@
+module Retell
+  module SDK
+    module Unofficial
+      class VoiceList < BaseList
+        def initialize(raw_response)
+          super(:voices, raw_response)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial/web_call.rb

@@ -0,0 +1,20 @@
+module Retell
+  module SDK
+    module Unofficial
+      class WebCall < BaseCall
+        @attributes = [:access_token] + BaseCall.attributes
+
+        attr_reader *@attributes
+
+        def initialize(client, raw_response)
+          super(client, raw_response)
+          @access_token = raw_response[:access_token]
+        end
+
+        def retrieve
+          @client.call.retrieve(self)
+        end
+      end
+    end
+  end
+end

data/lib/retell/sdk/unofficial.rb

@@ -0,0 +1,33 @@
+require_relative 'unofficial/client'
+require_relative 'unofficial/api/agent'
+require_relative 'unofficial/api/call'
+require_relative 'unofficial/api/retell_llm'
+require_relative 'unofficial/api/phone_number'
+require_relative 'unofficial/api/voice'
+require_relative 'unofficial/api/concurrency'
+require_relative 'unofficial/base'
+require_relative 'unofficial/base_list'
+require_relative 'unofficial/agent'
+require_relative 'unofficial/agent_list'
+require_relative 'unofficial/call'
+require_relative 'unofficial/base_call'
+require_relative 'unofficial/web_call'
+require_relative 'unofficial/phone_call'
+require_relative 'unofficial/call_list'
+require_relative 'unofficial/retell_llm'
+require_relative 'unofficial/retell_llm_list'
+require_relative 'unofficial/phone_number'
+require_relative 'unofficial/phone_number_list'
+require_relative 'unofficial/voice'
+require_relative 'unofficial/voice_list'
+require_relative 'unofficial/concurrency'
+
+module Retell
+  module SDK
+    module Unofficial
+      def self.new(api_key:, base_url: nil)
+        Client.new(base_url: base_url, api_key: api_key)
+      end
+    end
+  end
+end