intelligence 0.7.1 → 1.0.0.beta01

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/google/adapter.rb

@@ -35,6 +35,19 @@ module Intelligence
           response_mime_type String,  as: :responseMimeType
           response_schema             as: :responseSchema
 
+          # google tools setup 
+          tools                       do 
+            google_search             as: :google_search_retrieval do 
+              dynamic_retrieval       as: :dynamic_retrieval_config, default: {} do 
+                mode                  String, default: 'MODE_DYNAMIC'
+                threshold             Float, as: :dynamic_threshold, in: 0..1, default: 0.3
+              end
+            end
+            
+            code_execution            do 
+            end
+          end 
+
           # google specific tool configuration
           tool_configuration          as: :tool_config do
             function_calling          as: :function_calling_config do 

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

@@ -61,16 +61,33 @@ module Intelligence
         # discard properties not part of the google generationConfig schema
         gc.delete( :model )
         gc.delete( :stream )
-        
+
+        # googlify tools 
+        tools = gc.delete( :tools )
+        if tools&.any?
+          tools = tools.then do | tools_object |
+            tools_array ||= []
+            tools_object.each { | key, value | tools_array << { key => value } } 
+            tools_array
+          end 
+        end 
+        tool_functions = to_google_tools( conversation[ :tools ] )
+        if tool_functions&.any?
+          tools ||= {}
+          tools[ :function_declarations ] ||= []
+          tools[ :function_declarations ].concat( tool_functions )
+        end 
+
         # googlify tool configuration 
         if tool_config = gc.delete( :tool_config )
           mode = tool_config[ :function_calling_config ]&.[]( :mode )
           tool_config[ :function_calling_config ][ :mode ] = mode.to_s.upcase if mode 
         end 
-      
+
         result = {}
         result[ :generationConfig ] = gc
-        result[ :tool_config ] = tool_config if tool_config
+        result[ :tools ] = tools if tools 
+        result[ :tool_config ] = tool_config if tools && tool_config
 
         # construct the system prompt in the form of the google schema
         system_instructions = to_google_system_message( conversation[ :system_message ] )
@@ -163,9 +180,6 @@ module Intelligence
 
         end 
 
-        tools_attributes = to_google_tools( conversation[ :tools ] )
-        result[ :tools ] = tools_attributes if tools_attributes && tools_attributes.length > 0
-  
         JSON.generate( result )
       end 
 
@@ -208,7 +222,7 @@ module Intelligence
           [ object, required.compact  ]
         end
 
-        return [ { function_declarations: tools&.map { | tool |
+        return tools&.map { | tool |
           function = { 
             name: tool[ :name ],
             description: tool[ :description ],
@@ -223,7 +237,7 @@ module Intelligence
             function[ :parameters ][ :required ] = properties_required if properties_required.any?
           end
           function 
-        } } ]
+        } 
       end
 
     end

data/lib/intelligence/adapters/groq.rb

@@ -1,9 +1,9 @@
-require_relative 'legacy/adapter'
+require_relative 'generic/adapter'
 
 module Intelligence
   module Groq
 
-    class Adapter < Legacy::Adapter
+    class Adapter < Generic::Adapter
       
       chat_request_uri 'https://api.groq.com/openai/v1/chat/completions'
 
@@ -44,25 +44,6 @@ module Intelligence
         end
       end
 
-      alias chat_request_generic_message_attributes chat_request_message_attributes 
-      
-      # groq models only support the legacy Open AI message schema for the assistant 
-      # messages while supporting the modern message schema for user messages 
-      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

data/lib/intelligence/adapters/hyperbolic.rb

@@ -23,32 +23,6 @@ module Intelligence
         end
       end
 
-      def chat_result_error_attributes( response )
-
-        error_type, error_description = translate_error_response_status( response.status )
-        result = {
-          error_type: error_type.to_s,
-          error_description: error_description
-        }
-        parsed_body = JSON.parse( response.body, symbolize_names: true ) rescue nil 
-        if parsed_body && parsed_body.respond_to?( :include? )
-          if parsed_body.include?( :error )
-            result = {
-              error_type: error_type.to_s,
-              error: parsed_body[ :error ][ :code ] || error_type.to_s,
-              error_description: parsed_body[ :error ][ :message ] || error_description
-            }
-          elsif parsed_body.include?( :detail )
-            result[ :error_description ] = parsed_body[ :detail ]
-          elsif parsed_body[ :object ] == 'error'
-            result[ :error_description ] = parsed_body[ :message ]
-          end
-        end
-
-        result
-
-      end
-
     end
 
   end

data/lib/intelligence/adapters/mistral.rb

@@ -1,9 +1,8 @@
-require_relative 'legacy/adapter'
+require_relative 'generic/adapter'
 
 module Intelligence
   module Mistral
-
-    class Adapter < Legacy::Adapter
+    class Adapter < Generic::Adapter
 
       chat_request_uri "https://api.mistral.ai/v1/chat/completions"
       
@@ -31,27 +30,7 @@ module Intelligence
           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

@@ -18,43 +18,67 @@ module Intelligence
         chat_options do 
         
           # normalized properties for openai generative text endpoint
-          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 ]
+          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 ]
 
-          frequency_penalty Float
-          presence_penalty Float
+          frequency_penalty         Float
+          presence_penalty          Float
 
           # openai variant of normalized properties for openai generative text endpoints
-          max_completion_tokens Integer
+          max_completion_tokens     Integer
 
           # openai properties for openai generative text endpoint
           audio do 
-            voice         String 
-            format        String 
+            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 ]
+          logprobs                  [ TrueClass, FalseClass ]
+          top_logprobs              Integer
+          modalities                String, array: true 
           response_format do 
             # 'text' and 'json_schema' are the only supported types
-            type          Symbol, in: [ :text, :json_schema ]
+            type                    Symbol, in: [ :text, :json_schema ]
             json_schema
           end
-          service_tier    String
+          service_tier              String
           stream_options do
-            include_usage [ TrueClass, FalseClass ]
+            include_usage           [ TrueClass, FalseClass ]
           end
-          tool_choice
-          top_logprobs    Integer
-          user
+          user 
+          
+          # open ai tool configuration; this allows you to enable build in tools ( currently 
+          # that's just 'code_interpreter' )
+          # 
+          # tool :code_interpreter 
+          # 
+          #tool                      array: true, as: :tools, arguments: :type 
+          #  type                    Symbol 
+          #end 
+
+          # open ai tool choice configuration 
+          #
+          # `tool_choice :none` 
+          # or 
+          # ```
+          # tool_choice :function do 
+          #   function :my_function 
+          # end  
+          # ```
+          tool_choice               arguments: :type do 
+            type                    Symbol, in: [ :none, :auto, :required ]
+            function                arguments: :name do 
+              name                  Symbol 
+            end 
+          end 
+          # the parallel_tool_calls parameter is only allowed when 'tools' are specified
+          parallel_tool_calls       [ TrueClass, FalseClass ]
 
         end
 

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

@@ -122,7 +122,7 @@ module Intelligence
  
         tools_attributes = chat_request_tools_attributes( conversation[ :tools ] )
         result[ :tools ] = tools_attributes if tools_attributes && tools_attributes.length > 0
-        
+       
         JSON.generate( result )
       end 
 

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

@@ -85,31 +85,21 @@ module Intelligence
 
         choices.each do | choice |
           choice[ :message ][ :contents ] = choice[ :message ][ :contents ]&.map do | content |
-            case content[ :type ] 
-              when :text 
-                content[ :text ] = ''
-              when :tool_call 
-                content[ :tool_parameters ] = ''
-              else 
-                content.clear 
-            end
-            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 )
+          data = JSON.parse( line ) rescue nil
 
           if data.is_a?( Hash )
-            
             data[ 'choices' ]&.each do | data_choice |
 
               data_choice_index = data_choice[ 'index' ]
@@ -119,39 +109,45 @@ module Intelligence
               choices.fill( { message: {} }, choices.size, data_choice_index + 1 ) \
                 if choices.size <= data_choice_index 
               contents = choices[ data_choice_index ][ :message ][ :contents ] || []
-              last_content = contents&.last 
-              
-              if data_choice_delta.include?( 'content' ) 
-                data_choice_content = data_choice_delta[ 'content' ] || ''
-                if last_content.nil? || last_content[ :type ] == :tool_call
-                  contents.push( { type: :text, text: data_choice_content } )
-                elsif last_content[ :type ].nil?
-                  last_content[ :type ] = :text 
-                  last_content[ :text ] = data_choice_content
-                elsif last_content[ :type ] == :text 
-                  last_content[ :text ] = ( last_content[ :text ] || '' ) + data_choice_content
-                end
-              elsif data_choice_delta.include?( 'function_call' )
-                data_choice_tool_call = data_choice_delta[ 'function_call' ] 
-                data_choice_tool_name = data_choice_tool_call[ 'name' ]
-                data_choice_tool_parameters = data_choice_tool_call[ 'arguments' ]
-                if last_content.nil? || last_content[ :type ] == :text
-                  contents.push( { 
-                    type: :tool_call, 
-                    tool_name: data_choice_tool_name,
-                    tool_parameters: data_choice_tool_parameters
-                  } )
-                elsif last_content[ :type ].nil?
-                  last_content[ :type ] = :tool_call 
-                  last_content[ :tool_name ] = data_choice_tool_name if data_choice_tool_name.present?
-                  last_content[ :tool_parameters ] = tool_parameters
-                elsif last_content[ :type ] == :tool_call 
-                  last_content[ :tool_parameters ] = 
-                    ( last_content[ :tool_parameters ] || '' ) + data_choice_tool_parameters
+
+              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 do | data_choice_tool_call |
+                  if data_choice_tool_call_function = data_choice_tool_call[ 'function' ]
+                    data_choice_tool_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 ] = 
+              choices[ data_choice_index ][ :end_reason ] ||= 
                 translate_end_result( data_choice_finish_reason )
             end
   

data/lib/intelligence/adapters/samba_nova.rb

@@ -1,9 +1,9 @@
-require_relative 'legacy/adapter'
+require_relative 'generic/adapter'
 
 module Intelligence
   module SambaNova
 
-    class Adapter < Legacy::Adapter
+    class Adapter < Generic::Adapter
 
       chat_request_uri "https://api.sambanova.ai/v1/chat/completions"
       
@@ -35,8 +35,7 @@ module Intelligence
       end
 
       def chat_result_error_attributes( response )
-
-        error_type, error_description = translate_error_response_status( response.status )
+        error_type, error_description = to_error_response( response.status )
         result = {
           error_type: error_type.to_s,
           error_description: error_description
@@ -55,7 +54,6 @@ module Intelligence
         end
 
         result
-
       end
 
     end