intelligence 0.6.0 → 0.8.0

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

@@ -0,0 +1,221 @@
+module Intelligence
+  module Generic
+    module ChatRequestMethods
+
+      module ClassMethods
+        def chat_request_uri( uri = nil )
+          if uri
+            @chat_request_uri = uri
+          else
+            @chat_request_uri
+          end
+        end
+      end
+
+      def self.included( base )
+        base.extend( ClassMethods )
+      end
+
+      def chat_request_uri( options )
+        self.class.chat_request_uri
+      end
+
+      def chat_request_headers( options = nil )
+        options = @options.merge( build_options( options ) )
+        result = {}
+
+        key = options[ :key ]
+
+        raise ArgumentError.new( "An API key is required to build a chat request." ) \
+          if key.nil?
+
+        result[ 'Content-Type' ] = 'application/json'
+        result[ 'Authorization' ] = "Bearer #{key}"
+
+        result 
+      end
+
+      def chat_request_body( conversation, options = nil )
+        options = @options.merge( build_options( options ) )
+        
+        result = options[ :chat_options ]
+        result[ :messages ] = []
+
+        system_message = chat_request_system_message_attributes( conversation[ :system_message ] )
+        result[ :messages ] << system_message if system_message
+
+        conversation[ :messages ]&.each do | message |
+          return nil unless message[ :contents ]&.any?
+
+          result_message = { role: message[ :role ] }
+          result_message_content = []
+
+          message_contents = message[ :contents ]
+
+          # tool calls in the open ai api are not content
+          tool_calls, message_contents = message_contents.partition do | content | 
+            content[ :type ] == :tool_call 
+          end 
+
+          # tool results in the open ai api are not content
+          tool_results, message_contents = message_contents.partition do | content |
+            content[ :type ] == :tool_result 
+          end 
+
+          # many vendor api's, especially when hosting text only models, will only accept a single 
+          # text content item; if the content is only text this will coalece multiple text content 
+          # items into a single content item
+          unless message_contents.any? { | c | c[ :type ] != :text }
+            result_message_content = message_contents.map { | c | c[ :text ] || '' }.join( "\n" )
+          else  
+            message_contents&.each do | content |
+              result_message_content << chat_request_message_content_attributes( content )
+            end
+          end
+
+          if tool_calls.any?
+            result_message[ :tool_calls ] = tool_calls.map { | tool_call |
+              {
+                id: tool_call[ :tool_call_id ],
+                type: 'function',
+                function: {
+                  name: tool_call[ :tool_name ],
+                  arguments: JSON.generate( tool_call[ :tool_parameters ] || {} )
+                }
+              }
+            }
+          end 
+
+          result_message[ :content ] = result_message_content 
+          unless result_message_content.empty? && tool_calls.empty? 
+           result[ :messages ] << result_message 
+          end 
+
+          if tool_results.any? 
+            result[ :messages ].concat( tool_results.map { | tool_result |
+              {
+                role: :tool, 
+                tool_call_id: tool_result[ :tool_call_id ],
+                content: tool_result[ :tool_result ]
+              }
+            } )
+          end 
+        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_message_content_attributes( content )
+        case content[ :type ]
+        when :text
+          { 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'
+              {
+                type: 'image_url',
+                image_url: {
+                  url: "data:#{content_type};base64,#{Base64.strict_encode64( bytes )}".freeze
+                }
+              }
+            else
+              raise UnsupportedContentError.new( 
+                :generic, 
+                'only support content of type image/*' 
+              ) 
+            end
+          else 
+            raise UnsupportedContentError.new(
+              :generic, 
+              '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
+            mime_type = MIME::Types[ content_type ].first
+            if mime_type&.media_type == 'image'
+              {
+                type: 'image_url',
+                image_url: { url: uri }
+              }
+            else
+              raise UnsupportedContentError.new( 
+                :generic, 
+                'only support content of type image/*' 
+              ) 
+            end
+          else 
+            raise UnsupportedContentError.new(
+              :generic, 
+              'requires binary content to include content type and ( packed ) bytes'  
+            )
+          end
+        end
+      end
+
+      def chat_request_system_message_attributes( 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 : { role: 'system', content: result } if system_message  
+      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?
+          else
+            function[ :function ][ :parameters ] = {}
+          end
+          function 
+        end
+      end
+    
+    end
+  end
+end

data/lib/intelligence/adapters/generic/chat_response_methods.rb

@@ -0,0 +1,234 @@
+module Intelligence
+  module Generic
+    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?
+
+        result = {}
+        result[ :choices ] = []
+
+        ( response_json[ :choices ] || [] ).each do | json_choice |
+          if ( json_message = json_choice[ :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: to_end_reason( json_choice[ :finish_reason ] ), 
+            message: result_message 
+          } )
+        end
+
+        metrics_json = response_json[ :usage ]
+        unless metrics_json.nil?
+
+          metrics = {}
+          metrics[ :input_tokens ] = metrics_json[ :prompt_tokens ] 
+          metrics[ :output_tokens ] = metrics_json[ :completion_tokens ]
+          metrics = metrics.compact
+
+          result[ :metrics ] = metrics unless metrics.empty?
+
+        end
+
+        result
+      end
+
+      def chat_result_error_attributes( response )
+        error_type, error_description = to_error_response( response.status )
+        error = error_type 
+
+        parsed_body = JSON.parse( response.body, symbolize_names: true ) rescue nil 
+        if parsed_body && parsed_body.respond_to?( :[] )
+          if parsed_body[ :error ].respond_to?( :[] )
+            error = parsed_body[ :error ][ :code ] || error_type
+            error_description = parsed_body[ :error ][ :message ] || error_description
+          elsif parsed_body[ :object ] == 'error'
+            error = parsed_body[ :type ] || error_type 
+            error_description = parsed_body[ :detail ] || parsed_body[ :message ]
+          end 
+        end 
+
+        { error_type: error_type.to_s, error: error.to_s, error_description: error_description }
+      end
+
+      def stream_result_chunk_attributes( context, chunk )
+        context ||= {}
+        buffer = context[ :buffer ] || ''
+        metrics = context[ :metrics ] || {
+          input_tokens: 0,
+          output_tokens:  0
+        }
+        choices = context[ :choices ] || Array.new( 1 , { message: {} } )
+
+        choices.each do | choice |
+          choice[ :message ][ :contents ] = choice[ :message ][ :contents ]&.map do | content |
+            { type: content[ :type ] }
+          end
+        end
+
+        buffer += chunk
+        while ( eol_index = buffer.index( "\n" ) )
+          line = buffer.slice!( 0..eol_index )        
+          line = line.strip 
+          next if line.empty? || !line.start_with?( 'data:' )
+          line = line[ 6..-1 ]
+          next if line.end_with?( '[DONE]' )
+
+          data = JSON.parse( line ) rescue nil
+          if data.is_a?( Hash )
+            data[ 'choices' ]&.each do | data_choice |
+
+              data_choice_index = data_choice[ 'index' ]
+              data_choice_delta = data_choice[ 'delta' ]
+              data_choice_finish_reason = data_choice[ 'finish_reason' ]
+              
+              choices.fill( { message: {} }, choices.size, data_choice_index + 1 ) \
+                if choices.size <= data_choice_index 
+              contents = choices[ data_choice_index ][ :message ][ :contents ] || []
+
+              text_content = contents.first&.[]( :type ) == :text ? contents.first : nil 
+              if data_choice_content = data_choice_delta[ 'content' ]
+                if text_content.nil?  
+                  contents.unshift( text_content = { type: :text, text: data_choice_content } )
+                else
+                  text_content[ :text ] = ( text_content[ :text ] || '' ) + data_choice_content
+                end
+              end 
+              if data_choice_tool_calls = data_choice_delta[ 'tool_calls' ]
+                data_choice_tool_calls.each_with_index do | data_choice_tool_call, data_choice_tool_call_index |
+                  if data_choice_tool_call_function = data_choice_tool_call[ 'function' ]
+                    data_choice_tool_index = data_choice_tool_call[ 'index' ] || data_choice_tool_call_index
+                    data_choice_tool_id = data_choice_tool_call[ 'id' ]
+                    data_choice_tool_name = data_choice_tool_call_function[ 'name' ]
+                    data_choice_tool_parameters = data_choice_tool_call_function[ 'arguments' ]
+                    
+                    tool_call_content_index = ( text_content.nil? ? 0 : 1 ) + data_choice_tool_index 
+                    if tool_call_content_index >= contents.length 
+                      contents.push( { 
+                        type: :tool_call, 
+                        tool_call_id: data_choice_tool_id,
+                        tool_name: data_choice_tool_name,
+                        tool_parameters: data_choice_tool_parameters
+                      } )
+                    else 
+                      tool_call = contents[ tool_call_content_index ]
+                      tool_call[ :tool_call_id ] = ( tool_call[ :tool_call_id ] || '' ) + data_choice_tool_id \
+                        if data_choice_tool_id 
+                      tool_call[ :tool_name ] = ( tool_call[ :tool_name ] || '' ) + data_choice_tool_name \
+                        if data_choice_tool_name 
+                      tool_call[ :tool_parameters ] = ( tool_call[ :tool_parameters ] || '' ) + data_choice_tool_parameters \
+                        if data_choice_tool_parameters
+                    end 
+                  end 
+                end 
+              end
+              choices[ data_choice_index ][ :message ][ :contents ] = contents
+              choices[ data_choice_index ][ :end_reason ] ||= 
+                to_end_reason( data_choice_finish_reason )
+            end
+  
+            if usage = data[ 'usage' ]
+              # note: A number of providers will resend the input tokens as part of their usage 
+              #       payload.
+              metrics[ :input_tokens ] = usage[ 'prompt_tokens' ] \
+                if usage.include?( 'prompt_tokens' )
+              metrics[ :output_tokens ] += usage[ 'completion_tokens' ] \
+                if usage.include?( 'completion_tokens' )
+            end 
+
+          end
+
+        end
+
+        context[ :buffer ] = buffer 
+        context[ :metrics ] = metrics
+        context[ :choices ] = choices
+
+        [ context, choices.empty? ? nil : { choices: choices.dup } ]
+      end
+
+      def stream_result_attributes( context )
+        choices = context[ :choices ]
+        metrics = context[ :metrics ]
+
+        choices = choices.map do | choice |
+          { end_reason: choice[ :end_reason ] }
+        end
+
+        { choices: choices, metrics: context[ :metrics ] }
+      end
+
+      alias_method :stream_result_error_attributes, :chat_result_error_attributes
+
+      def to_end_reason( finish_reason )
+        case finish_reason
+          when 'stop'
+            :ended
+          when 'length'
+            :token_limit_exceeded
+          when 'tool_calls'
+            :tool_called
+          when 'content_filter'
+            :filtered
+          else
+            nil
+        end
+      end
+
+      def to_error_response( 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
+      end
+    
+    end
+  end
+end

data/lib/intelligence/adapters/generic.rb

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

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

@@ -1,44 +1,55 @@
-require_relative 'chat_methods'
+require_relative 'chat_request_methods'
+require_relative 'chat_response_methods'
 
 module Intelligence
   module Google
     class Adapter < Adapter::Base
 
-      configuration do 
+      schema do 
 
         # normalized properties for all endpoints
-        parameter :key, String  
+        key               String  
 
-        group :chat_options, as: :generationConfig do
+        chat_options      as: :generationConfig do
 
           # normalized properties for google generative text endpoint
-          parameter :model, String
-          parameter :max_tokens, Integer, as: :maxOutputTokens
-          parameter :n, Integer, as: :candidateCount
-          parameter :temperature, Float
-          parameter :top_k, Integer, as: :topK
-          parameter :top_p, Float, as: :topP
-          parameter :seed, Integer
-          parameter :stop, String, array: true, as: :stopSequences
-          parameter :stream, [ TrueClass, FalseClass ]
-
-          parameter :frequency_penalty, Float, as: :frequencyPenalty
-          parameter :presence_penalty, Float, as: :presencePenalty
+          model           String
+          max_tokens      Integer,    as: :maxOutputTokens
+          n               Integer,    as: :candidateCount
+          temperature     Float
+          top_k           Integer,    as: :topK
+          top_p           Float,      as: :topP
+          seed            Integer
+          stop            String,     array: true, as: :stopSequences
+          stream          [ TrueClass, FalseClass ]
+
+          frequency_penalty Float,    as: :frequencyPenalty
+          presence_penalty Float,     as: :presencePenalty
 
           # google variant of normalized properties for google generative text endpoints
-          parameter :candidate_count, Integer, as: :candidateCount
-          parameter :max_output_tokens, Integer, as: :maxOutputTokens
-          parameter :stop_sequences, String, array: true, as: :stopSequences
+          candidate_count Integer,    as: :candidateCount
+          max_output_tokens Integer,  as: :maxOutputTokens
+          stop_sequences String,      array: true, as: :stopSequences
 
           # google specific properties for google generative text endpoints
-          parameter :response_mime_type, String, as: :responseMimeType
-          parameter :response_schema, as: :responseSchema
+          response_mime_type String,  as: :responseMimeType
+          response_schema             as: :responseSchema
+
+          # google specific tool configuration
+          tool_configuration          as: :tool_config do
+            function_calling          as: :function_calling_config do 
+              mode                    Symbol, in: [ :auto, :any, :none ]
+              allowed_function_names  String, array: true 
+            end
+          end 
+
 
         end
 
       end
 
-      include ChatMethods
+      include ChatRequestMethods 
+      include ChatResponseMethods
 
     end