intelligence 0.6.0 → 0.8.0

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

@@ -1,46 +1,48 @@
-require_relative 'chat_methods'
+require_relative 'chat_request_methods'
+require_relative 'chat_response_methods'
 
 module Intelligence
   module Anthropic
     class Adapter < Adapter::Base
 
-      configuration do 
+      schema do 
 
         # normalized properties for all endpoints
-        parameter :key 
+        key 
 
         # anthropic specific properties for all endpoints
-        parameter :version, String, default: '2023-06-01'
+        version           String, default: '2023-06-01'
  
-        group :chat_options do 
+        chat_options do 
   
           # normalized properties for anthropic generative text endpoint
-          parameter :model, String
-          parameter :max_tokens, Integer
-          parameter :temperature, Float
-          parameter :top_k, Integer
-          parameter :top_p, Float
-          parameter :stop, String, array: true, as: :stop_sequences
-          parameter :stream, [ TrueClass, FalseClass ]
+          model           String
+          max_tokens      Integer
+          temperature     Float
+          top_k           Integer
+          top_p           Float
+          stop            String, array: true, as: :stop_sequences
+          stream          [ TrueClass, FalseClass ]
 
           # anthropic variant of normalized properties for anthropic generative text endpoints
-          parameter :stop_sequences, String, array: true
+          stop_sequences  String, array: true
 
           # anthropic specific properties for anthropic generative text endpoints
-          parameter :tool_choice do 
-            parameter :type, String  
+          tool_choice     do 
+            type          String  
             # the name parameter should only be set if type = 'tool'
-            parameter :name, String
+            name          String
           end
-          group :metadata do
-            parameter :user_id, String
+          metadata do
+            user_id       String
           end 
           
         end
         
       end
 
-      include ChatMethods
+      include ChatRequestMethods
+      include ChatResponseMethods
 
     end 
   end

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

@@ -0,0 +1,189 @@
+module Intelligence
+  module Anthropic
+    module ChatRequestMethods
+
+      CHAT_REQUEST_URI = "https://api.anthropic.com/v1/messages"
+
+      def chat_request_uri( options )
+        CHAT_REQUEST_URI
+      end
+
+      def chat_request_headers( options = nil )
+        options = @options.merge( build_options( options ) )
+        result = {}
+
+        key = options[ :key ] 
+        version = options[ :version ] || "2023-06-01" 
+
+        raise ArgumentError.new( 
+          "An Anthropic key is required to build an Anthropic chat request." 
+        ) if key.nil?
+
+        result[ 'content-type' ] = 'application/json'
+        result[ 'x-api-key' ] = "#{key}"
+        result[ 'anthropic-version' ] = version unless version.nil?
+
+        result 
+      end
+
+      def chat_request_body( conversation, options = nil )
+        options = @options.merge( build_options( options ) )
+        result = options[ :chat_options ]&.compact || {}
+
+        system_message = to_anthropic_system_message( conversation[ :system_message ] )
+        result[ :system ] = system_message unless system_message.nil?
+        result[ :messages ] = []
+
+        messages = conversation[ :messages ] 
+        length = messages&.length || 0
+        index = 0; while index < length 
+          
+          message = messages[ index ]
+          unless message.nil?
+
+            # The Anthropic API will not accept a sequence of messages where the role of two 
+            # sequentian messages is the same.
+            #
+            # The purpose of this code is to identify such occurences and coalece them such 
+            # that the first message in the sequence aggregates the contents of all subsequent
+            # messages with the same role.
+            look_ahead_index = index + 1; while look_ahead_index < length
+              ahead_message = messages[ look_ahead_index ]
+              unless ahead_message.nil?
+                if ahead_message[ :role ] == message[ :role ]
+                  message[ :contents ] = 
+                    ( message[ :contents ] || [] ) + 
+                    ( ahead_message[ :contents ] || [] )
+                  messages[ look_ahead_index ] = nil 
+                  look_ahead_index += 1
+                else 
+                  break
+                end
+              end
+            end
+
+            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',
+                      source: {
+                        type: 'base64',
+                        media_type: content_type,
+                        data: Base64.strict_encode64( bytes )
+                      }
+                    }
+                  else
+                    raise UnsupportedContentError.new( 
+                      :anthropic, 
+                      'only support content of type image/*' 
+                    ) 
+                  end
+                else 
+                  raise UnsupportedContentError.new(
+                    :anthropic, 
+                    'requires file content to include content type and (packed) bytes'  
+                  )
+                end
+              when :tool_call 
+                result_message_content << {
+                  type: 'tool_use',
+                  id: content[ :tool_call_id ],
+                  name: content[ :tool_name ],
+                  input: content[ :tool_parameters ] || {}
+                }
+              when :tool_result 
+                result_message_content << {
+                  type: 'tool_result',
+                  tool_use_id: content[ :tool_call_id ],
+                  content: content[ :tool_result ]
+                }
+              else
+                raise InvalidContentError.new( :anthropic ) 
+              end
+            end
+            
+            result_message[ :content ] = result_message_content
+            result[ :messages ] << result_message
+          
+          end
+        
+          index += 1 
+
+        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 |
+          tool_attributes = { 
+            name: tool[ :name ],
+            description: tool[ :description ],
+            input_schema: { type: 'object' }
+          }
+      
+          if tool[ :properties ]&.any? 
+            properties_object, properties_required = 
+              properties_array_to_object.call( tool[ :properties ] ) 
+            input_schema = {
+              type: 'object',
+              properties: properties_object 
+            }
+            input_schema[ :required ] = properties_required if properties_required.any?
+            tool_attributes[ :input_schema ] = input_schema
+          end
+          tool_attributes 
+        end
+      end
+
+    private 
+
+      def to_anthropic_system_message( system_message )
+        return nil if system_message.nil?
+        
+        # note: the current version of the anthropic api simply takes a string as the 
+        #       system message but the beta version requires an array of objects akin
+        #       to message contents.
+        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/anthropic/{chat_methods.rb → chat_response_methods.rb}

@@ -1,113 +1,6 @@
 module Intelligence
   module Anthropic
-    module ChatMethods
-
-      CHAT_REQUEST_URI = "https://api.anthropic.com/v1/messages"
-
-      def chat_request_uri( options )
-        CHAT_REQUEST_URI
-      end
-
-      def chat_request_headers( options = nil )
-        options = options ? self.class.configure( options ) : {}
-        options = @options.merge( options )
-        result = {}
-
-        key = options[ :key ] 
-        version = options[ :version ] || "2023-06-01" 
-
-        raise ArgumentError.new( 
-          "An Anthropic key is required to build an Anthropic chat request." 
-        ) if key.nil?
-
-        result[ 'content-type' ] = 'application/json'
-        result[ 'x-api-key' ] = "#{key}"
-        result[ 'anthropic-version' ] = version unless version.nil?
-
-        result 
-      end
-
-      def chat_request_body( conversation, options = nil )
-        options = options ? self.class.configure( options ) : {}
-        options = @options.merge( options )
-        result = options[ :chat_options ]&.compact || {}
-
-        system_message = translate_system_message( conversation[ :system_message ] )
-        result[ :system ] = system_message unless system_message.nil?
-        result[ :messages ] = []
-
-        messages = conversation[ :messages ] 
-        length = messages&.length || 0
-        index = 0; while index < length 
-          
-          message = messages[ index ]
-          unless message.nil?
-
-            # The Anthropic API will not accept a sequence of messages where the role of two 
-            # sequentian messages is the same.
-            #
-            # The purpose of this code is to identify such occurences and coalece them such 
-            # that the first message in the sequence aggregates the contents of all subsequent
-            # messages with the same role.
-            look_ahead_index = index + 1; while look_ahead_index < length
-              ahead_message = messages[ look_ahead_index ]
-              unless ahead_message.nil?
-                if ahead_message[ :role ] == message[ :role ]
-                  message[ :contents ] = 
-                    ( message[ :contents ] || [] ) + 
-                    ( ahead_message[ :contents ] || [] )
-                  messages[ look_ahead_index ] = nil 
-                  look_ahead_index += 1
-                else 
-                  break
-                end
-              end
-            end
-
-            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',
-                      source: {
-                        type: 'base64',
-                        media_type: content_type,
-                        data: Base64.strict_encode64( bytes )
-                      }
-                    }
-                  else
-                    raise UnsupportedContentError.new( 
-                      :anthropic, 
-                      'only support content of type image/*' 
-                    ) 
-                  end
-                else 
-                  raise InvalidContentError.new( :anthropic ) 
-                end
-              end 
-            end
-            
-            result_message[ :content ] = result_message_content
-            result[ :messages ] << result_message
-          
-          end
-        
-          index += 1
-        
-        end
-
-        JSON.generate( result )
-      end 
+    module ChatResponseMethods
 
       def chat_result_attributes( response )
         return nil unless response.success?
@@ -130,6 +23,13 @@ module Intelligence
           response_json[ :content ].each do | content |
             if content[ :type ] == 'text'
               result_content.push( { type: 'text', text: content[ :text ] } )
+            elsif content[ :type ] == 'tool_use'
+              result_content.push( { 
+                type: :tool_call, 
+                tool_call_id: content[ :id ],
+                tool_name: content[ :name ],
+                tool_parameters: content[ :input ]
+              } )
             end
           end
 
@@ -189,15 +89,8 @@ module Intelligence
           output_tokens:  0
         }
 
-        contents.each do | content |
-          case content[ :type ] 
-            when :text 
-              content[ :text ] = ''
-            when :tool_call 
-              content[ :tool_parameters ] = ''
-            else 
-              content.clear 
-          end
+        contents.map! do | content |
+          { type: content[ :type ] }
         end
 
         buffer += chunk
@@ -216,7 +109,7 @@ module Intelligence
               metrics[ :output_tokens ] += data[ 'message' ]&.[]( 'usage' )&.[]( 'output_tokens' ) || 0
             when 'content_block_start'
               index = data[ 'index' ]
-              contents.fill( {}, contents.size, index + 1 ) if contents.size <= index
+              contents.fill( {}, contents.size..index ) if contents.size <= index
               if content_block = data[ 'content_block' ]
                 if content_block[ 'type' ] == 'text'
                   contents[ index ] = {
@@ -234,7 +127,7 @@ module Intelligence
               end
             when 'content_block_delta'
               index = data[ 'index' ]
-              contents.fill( {}, contents.size, index + 1 ) if contents.size <= index
+              contents.fill( {}, contents.size..index ) if contents.size <= index
               if delta = data[ 'delta' ]
                 if delta[ 'type' ] == 'text_delta'
                   contents[ index ][ :type ] = :text 
@@ -242,7 +135,7 @@ module Intelligence
                 elsif delta[ 'type' ] == 'input_json_delta'
                   contents[ index ][ :type ] = :tool_call 
                   contents[ index ][ :tool_parameters ] = 
-                    ( contents[ index ][ :tool_parameters ] || '' ) + delta[ 'input_json_delta' ]                
+                    ( contents[ index ][ :tool_parameters ] || '' ) + delta[ 'partial_json' ]                
                 end
               end
             when 'message_delta'
@@ -289,23 +182,6 @@ module Intelligence
 
     private 
 
-      def translate_system_message( system_message )
-
-        return nil if system_message.nil?
-
-        # note: the current version of the anthropic api simply takes a string as the 
-        #       system message but the beta version requires an array of objects akin
-        #       to message contents.
-
-        result = ''
-        system_message[ :contents ].each do | content |
-          result += content[ :text ] if content[ :type ] == :text 
-        end
-
-        result.empty? ? nil : result 
-
-      end 
-
       def translate_end_result( end_result )
         case end_result
           when 'end_turn'

data/lib/intelligence/adapters/cerebras.rb

@@ -1,31 +1,31 @@
-require_relative 'legacy/adapter'
+require_relative 'generic/adapter'
 
 module Intelligence
   module Cerebras
 
-    class Adapter < Legacy::Adapter
+    class Adapter < Generic::Adapter
 
       chat_request_uri "https://api.cerebras.ai/v1/chat/completions"
       
-      configuration do 
-        parameter :key 
-        group :chat_options do 
-          parameter :model, String
-          parameter :max_tokens, Integer
-          parameter :response_format do 
-            parameter :type, String, default: 'json_schema'
-            parameter :json_schema
+      schema do 
+        key               String 
+        chat_options do 
+          model           String
+          max_tokens      Integer
+          response_format do 
+            type          String, default: 'json_schema'
+            json_schema
           end
-          parameter :seed, Integer
-          parameter :stop, array: true
-          parameter :stream, [ TrueClass, FalseClass ]
-          parameter :temperature, Float
-          parameter :top_p, Float
-          parameter :tool_choice do 
-            parameter :type, String 
-            parameter :mame, String
+          seed            Integer
+          stop            array: true
+          stream          [ TrueClass, FalseClass ]
+          temperature     Float
+          top_p           Float
+          tool_choice do 
+            type          String 
+            mame          String
           end
-          parameter :user
+          user
         end
       end
 

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

@@ -1,10 +1,12 @@
 require_relative '../../adapter'
-require_relative 'chat_methods'
+require_relative 'chat_request_methods'
+require_relative 'chat_response_methods'
 
 module Intelligence
   module Generic
     class Adapter < Adapter::Base
-      include ChatMethods
+      include ChatRequestMethods
+      include ChatResponseMethods
     end 
   end
 end