intelligence 0.5.0 → 0.7.1

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

@@ -1,57 +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, required: true 
+        key 
 
         # anthropic specific properties for all endpoints
-        parameter :version, String, required: true, 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, required: true
-          parameter :max_tokens, Integer, required: true
-          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
 
-      attr_reader :key
-      attr_reader :version
-      attr_reader :chat_options
-
-      def initialize( attributes = nil, &block )
-        configuration = self.class.configure( attributes, &block ) 
-        @key = configuration[ :key ]
-        @version = configuration[ :version ]
-        @chat_options = configuration[ :chat_options ] || {}
-      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,112 +1,6 @@
-require 'base64'
-
 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 = {} )
-        result = {}
-
-        key = options[ :key ] || self.key
-        version = options[ :version ] || self.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 = {} )
-        options = self.class.configure( options ) unless options.empty?
-        result = self.chat_options.merge( 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?
@@ -129,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
 
@@ -288,23 +189,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

@@ -7,25 +7,25 @@ module Intelligence
 
       chat_request_uri "https://api.cerebras.ai/v1/chat/completions"
       
-      configuration do 
-        parameter :key, required: true 
-        group :chat_options do 
-          parameter :model, String, required: true
-          parameter :max_tokens, Integer, required: true
-          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

@@ -4,18 +4,7 @@ require_relative 'chat_methods'
 module Intelligence
   module Generic
     class Adapter < Adapter::Base
-
-      attr_reader :key
-      attr_reader :chat_options
-
-      def initialize( attributes = nil, &block )
-        configuration = self.class.configure( attributes, &block ) 
-        @key = configuration[ :key ]
-        @chat_options = configuration[ :chat_options ] || {}
-      end
-
       include ChatMethods
-    
     end 
   end
-end
+end

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

@@ -20,10 +20,11 @@ module Intelligence
         self.class.chat_request_uri
       end
 
-      def chat_request_headers( options = {} )
+      def chat_request_headers( options = nil )
+        options = @options.merge( build_options( options ) )
         result = {}
 
-        key = options[ :key ] || self.key
+        key = options[ :key ]
 
         raise ArgumentError.new( "An API key is required to build a chat request." ) \
           if key.nil?
@@ -34,8 +35,10 @@ module Intelligence
         result 
       end
 
-      def chat_request_body( conversation, options = {} )
-        result = self.chat_options.merge( options ).compact
+      def chat_request_body( conversation, options = nil )
+        options = @options.merge( build_options( options ) )
+        
+        result = options[ :chat_options ]
         result[ :messages ] = []
 
         system_message = system_message_to_s( conversation[ :system_message ] )
@@ -79,6 +82,28 @@ module Intelligence
                 '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'
+                result_message_content << {
+                  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
         result_message[ :content ] = result_message_content
@@ -124,7 +149,7 @@ module Intelligence
       end
 
       def chat_result_error_attributes( response )
-
+        
         error_type, error_description = translate_error_response_status( response.status )
         result = {
           error_type: error_type.to_s,
@@ -178,7 +203,6 @@ module Intelligence
 
           next if line.end_with?( '[DONE]' )
           data = JSON.parse( line )
-
           if data.is_a?( Hash )
             
             data[ 'choices' ]&.each do | data_choice |
@@ -196,10 +220,8 @@ module Intelligence
                 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?
+                elsif last_content[ :type ] == :text || 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' )
@@ -223,7 +245,7 @@ module Intelligence
                 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
   
@@ -313,7 +335,16 @@ module Intelligence
           end
       end
 
-      private; def system_message_to_s( system_message )
+    private
+
+      def to_options( options, &block )
+        return {} unless options&.any?
+        @options_builder ||= DynamicSchema::Builder.new.define( &self.class.schema )
+        @options_builder.build( options, &block )
+      end
+
+
+      def system_message_to_s( system_message )
 
         return nil if system_message.nil?
 

data/lib/intelligence/adapters/generic.rb

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