intelligence 0.5.0 → 0.7.1

data/lib/intelligence/adapters/hyperbolic.rb

@@ -7,19 +7,19 @@ module Intelligence
 
       chat_request_uri "https://api.hyperbolic.xyz/v1/chat/completions"
       
-      configuration do 
-        parameter :key, String, required: true 
-        group :chat_options do 
-          parameter :model, String
-          parameter :temperature, Float
-          parameter :top_p, Float
-          parameter :n, Integer
-          parameter :max_tokens, Integer
-          parameter :stop, String, array: true
-          parameter :stream, [ TrueClass, FalseClass ]
-          parameter :frequency_penalty, Float
-          parameter :presence_penalty, Float
-          parameter :user, String
+      schema do 
+        key                 String 
+        chat_options do 
+          model             String
+          temperature       Float
+          top_p             Float
+          n                 Integer
+          max_tokens        Integer
+          stop              String, array: true
+          stream            [ TrueClass, FalseClass ]
+          frequency_penalty Float
+          presence_penalty  Float
+          user              String
         end
       end
 

data/lib/intelligence/adapters/legacy/adapter.rb

@@ -3,11 +3,9 @@ require_relative 'chat_methods'
 
 module Intelligence
   module Legacy 
-
     class Adapter < Generic::Adapter
       include ChatMethods
     end
-
   end
 end
 

data/lib/intelligence/adapters/legacy/chat_methods.rb

@@ -3,20 +3,36 @@ module Intelligence
     module ChatMethods
 
       def chat_request_body( conversation, options = {} )
-        result = self.chat_options.merge( options ).compact
+        options = @options.merge( to_options( options ) )
+
+        result = options[ :chat_options ]&.compact || {}
         result[ :messages ] = []
 
         system_message = system_message_to_s( conversation[ :system_message ] )
         result[ :messages ] << { role: 'system', content: system_message } if system_message
-
-        conversation[ :messages ]&.each do | message |
-          result[ :messages ] << chat_request_message_attributes( message )
+        
+        # detect if the conversation has any non-text content; this handles the sittuation 
+        # where non-vision models only support the legacy message schema while the vision 
+        # models only support the modern message schema 
+        has_non_text_content = conversation[ :messages ]&.find do | message |
+          message[ :contents ]&.find do | content |
+            content[ :type ] != nil && content[ :type ] != :text 
+          end
+        end
+        
+        if has_non_text_content
+          conversation[ :messages ]&.each do | message |
+            result[ :messages ] << chat_request_message_attributes( message )
+          end
+        else 
+          conversation[ :messages ]&.each do | message |
+            result[ :messages ] << chat_request_legacy_message_attributes( message )
+          end
         end
-
         JSON.generate( result )
       end 
 
-      def chat_request_message_attributes( message )
+      def chat_request_legacy_message_attributes( message )
         result_message = { role: message[ :role ] }
         result_message_content = ""
         

data/lib/intelligence/adapters/mistral.rb

@@ -0,0 +1,57 @@
+require_relative 'legacy/adapter'
+
+module Intelligence
+  module Mistral
+
+    class Adapter < Legacy::Adapter
+
+      chat_request_uri "https://api.mistral.ai/v1/chat/completions"
+      
+      schema do 
+        key                   String 
+        chat_options do 
+          model               String
+          temperature         Float
+          top_p               Float
+          max_tokens          Integer
+          min_tokens          Integer
+          seed                Integer, as: :random_seed 
+          stop                String, array: true
+          stream              [ TrueClass, FalseClass ]
+
+          random_seed         Integer
+          response_format do 
+            type              String 
+          end
+          tool_choice do 
+            type              String 
+            function do 
+              name            String 
+            end
+          end
+        end
+      end
+
+      alias chat_request_generic_message_attributes chat_request_message_attributes 
+      
+      # mistral vision models only support the legacy Open AI message schema for the assistant 
+      # messages while supporting the modern message schema for user messages :facepalm:
+      def chat_request_message_attributes( message )
+        role = message[ :role ]&.to_sym 
+        case role 
+        when :user 
+          chat_request_generic_message_attributes( message )
+        when :assistant 
+          chat_request_legacy_message_attributes( message )
+        else 
+          raise UnsupportedContentError.new(
+            :mistral, 
+            'only supports user and assistant message roles'  
+          )
+        end
+      end
+
+    end
+
+  end
+end

data/lib/intelligence/adapters/open_ai/adapter.rb

@@ -1,74 +1,67 @@
-require_relative 'chat_methods'
+require_relative 'chat_request_methods'
+require_relative 'chat_response_methods'
 
 module Intelligence
   module OpenAi
     class Adapter < Adapter::Base
 
-      configuration do 
+      schema do 
 
         # normalized properties for all endpoints
-        parameter :key, String, required: true
+        key               String
         
         # openai properties for all endpoints
-        parameter :organization
-        parameter :project
+        organization      String 
+        project           String 
         
         # properties for generative text endpoints
-        group :chat_options do 
+        chat_options do 
         
           # normalized properties for openai generative text endpoint
-          parameter :model, String, required: true
-          parameter :n, Integer
-          parameter :max_tokens, Integer, as: :max_completion_tokens
-          parameter :temperature, Float
-          parameter :top_p, Float
-          parameter :seed, Integer
-          parameter :stop, String, array: true
-          parameter :stream, [ TrueClass, FalseClass ]
+          model           String, requried: true 
+          n               Integer
+          max_tokens      Integer, as: :max_completion_tokens
+          temperature     Float
+          top_p           Float
+          seed            Integer
+          stop            String, array: true
+          stream          [ TrueClass, FalseClass ]
 
-          parameter :frequency_penalty, Float
-          parameter :presence_penalty, Float
+          frequency_penalty Float
+          presence_penalty Float
 
           # openai variant of normalized properties for openai generative text endpoints
-          parameter :max_completion_tokens, Integer
+          max_completion_tokens Integer
 
           # openai properties for openai generative text endpoint
-          parameter :logit_bias
-          parameter :logprobs, [ TrueClass, FalseClass ]
-          parameter :parallel_tool_calls, [ TrueClass, FalseClass ]
-          group :response_format do 
+          audio do 
+            voice         String 
+            format        String 
+          end
+          logit_bias
+          logprobs        [ TrueClass, FalseClass ]
+          modalities      String, array: true 
+          # the parallel_tool_calls parameter is only allowed when 'tools' are specified
+          parallel_tool_calls [ TrueClass, FalseClass ]
+          response_format do 
             # 'text' and 'json_schema' are the only supported types
-            parameter :type, String
-            parameter :json_schema
+            type          Symbol, in: [ :text, :json_schema ]
+            json_schema
           end
-          parameter :service_tier, String
-          group :stream_options do
-            parameter :include_usage, [ TrueClass, FalseClass ]
+          service_tier    String
+          stream_options do
+            include_usage [ TrueClass, FalseClass ]
           end
-          parameter :tool_choice
-          # the parallel_tool_calls parameter is only allowed when 'tools' are specified
-          parameter :top_logprobs, Integer
-          parameter :user
+          tool_choice
+          top_logprobs    Integer
+          user
 
         end
 
       end
 
-      attr_reader :key
-      attr_reader :organization
-      attr_reader :project
-      attr_reader :chat_options
-
-
-      def initialize( attributes = nil, &block )
-        configuration = self.class.configure( attributes, &block ) 
-        @key = configuration[ :key ]
-        @organization = configuration[ :organization ]
-        @project = configuration[ :project ]
-        @chat_options = configuration[ :chat_options ] || {}
-      end
-
-      include ChatMethods
+      include ChatRequestMethods 
+      include ChatResponseMethods
 
     end 
   end

data/lib/intelligence/adapters/open_ai/chat_request_methods.rb

@@ -0,0 +1,186 @@
+module Intelligence
+  module OpenAi
+    module ChatRequestMethods
+
+      CHAT_REQUEST_URI = "https://api.openai.com/v1/chat/completions"
+
+      SUPPORTED_CONTENT_TYPES = [ 'image/jpeg', 'image/png' ]
+
+      def chat_request_uri( options )
+        CHAT_REQUEST_URI
+      end
+
+      def chat_request_headers( options = {} )
+        options = @options.merge( build_options( options )  )
+        result = {}
+
+        key = options[ :key ] 
+        organization = options[ :organization ] 
+        project = options[ :project ]  
+
+        raise ArgumentError.new( "An OpenAI key is required to build an OpenAI chat request." ) \
+          if key.nil?
+
+        result[ 'Content-Type' ] = 'application/json'
+        result[ 'Authorization' ] = "Bearer #{key}"
+        result[ 'OpenAI-Organization' ] = organization unless organization.nil?
+        result[ 'OpenAI-Project' ] = project unless project.nil?
+
+        result 
+      end
+
+      def chat_request_body( conversation, options = {} )
+        options = @options.merge( build_options( options )  )
+        result = options[ :chat_options ]&.compact || {}
+        result[ :messages ] = []
+
+        system_message = to_open_ai_system_message( conversation[ :system_message ] )
+        result[ :messages ] << { role: 'system', content: system_message } if system_message
+
+        conversation[ :messages ]&.each do | message |
+         
+          result_message = { role: message[ :role ] }
+          result_message_content = []
+          
+          message[ :contents ]&.each do | content |
+            case content[ :type ]
+            when :text
+              result_message_content << { type: 'text', text: content[ :text ] }
+            when :binary
+              content_type = content[ :content_type ]
+              bytes = content[ :bytes ]
+              if content_type && bytes
+                if SUPPORTED_CONTENT_TYPES.include?( content_type )
+                  result_message_content << {
+                    type: 'image_url',
+                    image_url: {
+                      url: "data:#{content_type};base64,#{Base64.strict_encode64( bytes )}".freeze
+                    }
+                  }
+                else
+                  raise UnsupportedContentError.new( 
+                    :open_ai, 
+                    "only supports content of type #{SUPPORTED_CONTENT_TYPES.join( ', ' )}"
+                  ) 
+                end
+              else 
+                raise UnsupportedContentError.new(
+                  :open_ai, 
+                  'requires binary content to include content type and ( packed ) bytes'  
+                )
+              end
+            when :file 
+              content_type = content[ :content_type ]
+              uri = content[ :uri ]
+              if content_type && uri  
+                if SUPPORTED_CONTENT_TYPES.include?( content_type )
+                  result_message_content << {
+                    type: 'image_url',
+                    image_url: {
+                      url: uri 
+                    }
+                  }
+                else 
+                  raise UnsupportedContentError.new( 
+                    :open_ai, 
+                    "only supports content of type #{SUPPORTED_CONTENT_TYPES.join( ', ' )}" 
+                  ) 
+                end 
+              else 
+                raise UnsupportedContentError.new(
+                  :open_ai, 
+                  'requires file content to include content type and uri'  
+                )
+              end 
+            when :tool_call 
+              tool_calls = result_message[ :tool_calls ] || [] 
+              function = {
+                name: content[ :tool_name ]
+              }
+              function[ :arguments ] = JSON.generate( content[ :tool_parameters ] || {} )
+              tool_calls << { id: content[ :tool_call_id ], type: 'function', function: function }
+              result_message[ :tool_calls ] = tool_calls
+            when :tool_result 
+              # open-ai returns tool results as a message with a role of 'tool'
+              result[ :messages ] << {
+                role: :tool, 
+                tool_call_id: content[ :tool_call_id ],
+                content: content[ :tool_result ]
+              }
+            else 
+              raise InvalidContentError.new( :open_ai ) 
+            end
+
+          end
+
+          result_message[ :content ] = result_message_content
+          result[ :messages ] << result_message \
+            if result_message[ :content ]&.any? || result_message[ :tool_calls ]&.any? 
+          result
+
+        end
+ 
+        tools_attributes = chat_request_tools_attributes( conversation[ :tools ] )
+        result[ :tools ] = tools_attributes if tools_attributes && tools_attributes.length > 0
+        
+        JSON.generate( result )
+      end 
+
+      def chat_request_tools_attributes( tools ) 
+        properties_array_to_object = lambda do | properties |
+          return nil unless properties&.any?  
+          object = {}
+          required = []
+          properties.each do | property | 
+            name = property.delete( :name ) 
+            required << name if property.delete( :required )
+            if property[ :properties ]&.any?  
+              property_properties, property_required = 
+                properties_array_to_object.call( property[ :properties ] ) 
+              property[ :properties ] = property_properties 
+              property[ :required ] = property_required if property_required.any?
+            end 
+            object[ name ] = property 
+          end 
+          [ object, required.compact  ]
+        end
+
+        tools&.map do | tool |
+          function = { 
+            type: 'function',
+            function: {
+              name: tool[ :name ],
+              description: tool[ :description ],
+            }
+          }
+      
+          if tool[ :properties ]&.any? 
+            properties_object, properties_required = 
+              properties_array_to_object.call( tool[ :properties ] ) 
+            function[ :function ][ :parameters ] = {
+              type: 'object',
+              properties: properties_object 
+            }
+            function[ :function ][ :parameters ][ :required ] = properties_required \
+              if properties_required.any?
+          end
+          function 
+        end
+      end
+
+    private 
+
+      def to_open_ai_system_message( system_message )
+        return nil if system_message.nil?
+
+        result = ''
+        system_message[ :contents ].each do | content |
+          result += content[ :text ] if content[ :type ] == :text 
+        end
+
+        result.empty? ? nil : result 
+      end 
+
+    end
+  end
+end

data/lib/intelligence/adapters/open_ai/{chat_methods.rb → chat_response_methods.rb}

@@ -1,85 +1,9 @@
 module Intelligence
   module OpenAi
-    module ChatMethods
-
-      CHAT_REQUEST_URI = "https://api.openai.com/v1/chat/completions"
-
-      def chat_request_uri( options )
-        CHAT_REQUEST_URI
-      end
-
-      def chat_request_headers( options = {} )
-        result = {}
-
-        key = options[ :key ] || self.key
-        organization = options[ :organization ] || self.organization 
-        project = options[ :project ] || self.project 
-
-        raise ArgumentError.new( "An OpenAI key is required to build an OpenAI chat request." ) \
-          if key.nil?
-
-        result[ 'Content-Type' ] = 'application/json'
-        result[ 'Authorization' ] = "Bearer #{key}"
-        result[ 'OpenAI-Organization' ] = organization unless organization.nil?
-        result[ 'OpenAI-Project' ] = project unless project.nil?
-
-        result 
-      end
-
-      def chat_request_body( conversation, options = {} )
-        result = self.chat_options.merge( options ).compact
-        result[ :messages ] = []
-
-        system_message = translate_system_message( conversation[ :system_message ] )
-        result[ :messages ] << { role: 'system', content: system_message } if system_message
-
-        conversation[ :messages ]&.each do | message |
-
-          result_message = { role: message[ :role ] }
-          result_message_content = []
-          
-          message[ :contents ]&.each do | content |
-            case content[ :type ]
-            when :text
-              result_message_content << { type: 'text', text: content[ :text ] }
-            when :binary
-              content_type = content[ :content_type ]
-              bytes = content[ :bytes ]
-              if content_type && bytes
-                mime_type = MIME::Types[ content_type ].first
-                if mime_type&.media_type == 'image'
-                  result_message_content << {
-                    type: 'image_url',
-                    image_url: {
-                      url: "data:#{content_type};base64,#{Base64.strict_encode64( bytes )}".freeze
-                    }
-                  }
-                else
-                  raise UnsupportedContentError.new( 
-                    :open_ai, 
-                    'only supports content of type image/*' 
-                  ) 
-                end
-              else 
-                raise UnsupportedContentError.new(
-                  :open_ai, 
-                  'requires binary content to include content type and ( packed ) bytes'  
-                )
-              end
-            end 
-          end
-
-          result_message[ :content ] = result_message_content
-          result[ :messages ] << result_message
-
-        end
-
-        JSON.generate( result )
-      end 
+    module ChatResponseMethods
 
       def chat_result_attributes( response )
         return nil unless response.success?
-        
         response_json = JSON.parse( response.body, symbolize_names: true ) rescue nil
         return nil \
           if response_json.nil? || response_json[ :choices ].nil?
@@ -89,15 +13,31 @@ module Intelligence
 
         ( response_json[ :choices ] || [] ).each do | json_choice |
           json_message = json_choice[ :message ]
-          result[ :choices ].push(
-            { 
-              end_reason: translate_end_result( json_choice[ :finish_reason ] ), 
-              message: { 
-                role: json_message[ :role ],
-                contents: [ { type: 'text', text: json_message[ :content ] } ]
-              } 
-            }
-          )
+          result_message = nil
+          if ( json_message )
+            result_message = { role: json_message[ :role ] }
+            if json_message[ :content ] 
+              result_message[ :contents ] = [ { type: :text, text: json_message[ :content ] } ]
+            end
+            if json_message[ :tool_calls ] && !json_message[ :tool_calls ].empty?
+              result_message[ :contents ] ||= []
+              json_message[ :tool_calls ].each do | json_message_tool_call |
+                result_message_tool_call_parameters = 
+                  JSON.parse( json_message_tool_call[ :function ][ :arguments ], symbolize_names: true ) \
+                    rescue json_message_tool_call[ :function ][ :arguments ]
+                result_message[ :contents ] << {
+                  type: :tool_call, 
+                  tool_call_id: json_message_tool_call[ :id ],
+                  tool_name: json_message_tool_call[ :function ][ :name ],
+                  tool_parameters: result_message_tool_call_parameters
+                }
+              end 
+            end
+          end 
+          result[ :choices ].push( { 
+            end_reason: translate_end_result( json_choice[ :finish_reason ] ), 
+            message: result_message 
+          } )
         end
 
         metrics_json = response_json[ :usage ]
@@ -244,26 +184,15 @@ module Intelligence
 
       alias_method :stream_result_error_attributes, :chat_result_error_attributes
 
-      private; def translate_system_message( system_message )
+    private 
 
-        return nil if system_message.nil?
-
-        result = ''
-        system_message[ :contents ].each do | content |
-          result += content[ :text ] if content[ :type ] == :text 
-        end
-
-        result.empty? ? nil : result 
-
-      end 
-
-      private; def translate_end_result( end_result )
+      def translate_end_result( end_result )
         case end_result
           when 'stop'
             :ended
           when 'length'
             :token_limit_exceeded
-          when 'function_call'
+          when 'tool_calls'
             :tool_called
           when 'content_filter'
             :filtered
@@ -274,37 +203,37 @@ module Intelligence
 
       def translate_error_response_status( status )
         case status
-          when 400
-            [ :invalid_request_error, 
-              "There was an issue with the format or content of your request." ]
-          when 401
-            [ :authentication_error, 
-              "There's an issue with your API key." ]
-          when 403
-            [ :permission_error, 
-              "Your API key does not have permission to use the specified resource." ]
-          when 404
-            [ :not_found_error, 
-              "The requested resource was not found." ]
-          when 413
-            [ :request_too_large, 
-              "Request exceeds the maximum allowed number of bytes." ]
-          when 422
-            [ :invalid_request_error, 
-              "There was an issue with the format or content of your request." ]
-          when 429
-            [ :rate_limit_error, 
-              "Your account has hit a rate limit." ]
-          when 500, 502, 503
-            [ :api_error, 
-              "An unexpected error has occurred internal to the providers systems." ]
-          when 529
-            [ :overloaded_error, 
-              "The providers server is temporarily overloaded." ]
-          else
-            [ :unknown_error, "
-              An unknown error occurred." ]
-          end
+        when 400
+          [ :invalid_request_error, 
+            "There was an issue with the format or content of your request." ]
+        when 401
+          [ :authentication_error, 
+            "There's an issue with your API key." ]
+        when 403
+          [ :permission_error, 
+            "Your API key does not have permission to use the specified resource." ]
+        when 404
+          [ :not_found_error, 
+            "The requested resource was not found." ]
+        when 413
+          [ :request_too_large, 
+            "Request exceeds the maximum allowed number of bytes." ]
+        when 422
+          [ :invalid_request_error, 
+            "There was an issue with the format or content of your request." ]
+        when 429
+          [ :rate_limit_error, 
+            "Your account has hit a rate limit." ]
+        when 500, 502, 503
+          [ :api_error, 
+            "An unexpected error has occurred internal to the providers systems." ]
+        when 529
+          [ :overloaded_error, 
+            "The providers server is temporarily overloaded." ]
+        else
+          [ :unknown_error, "
+            An unknown error occurred." ]
+        end
       end
     
     end

data/lib/intelligence/adapters/open_ai.rb

@@ -1,2 +1,2 @@
 require_relative '../adapter'
-require_relative 'open_ai/adapter'
+require_relative 'open_ai/adapter'