intelligence 1.0.0.beta06 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2882de87c5b4c5e0ce5c59b91ca981788b1435b4e8b68e82c592d67b5b33512e
-  data.tar.gz: 92072e12828beec46b8d988c0b4e6ddaa9aac1d9d4cee7fbdf1d2c02cb8ccc83
+  metadata.gz: 4831cc2ed908d140d2986d50a48db3b71f9436d8ce3c55353fc0a704ca798d07
+  data.tar.gz: 66e71bfca8287772c267daa06ead05b177edd64648dc52d818b8dc47ed4eaef6
 SHA512:
-  metadata.gz: 0a80eedb98958100ca842a66352bb43f68123285a3abc503b1a563e9161e237f7bf095541e22272ae4e73c7d738c9ad7aa23ee06d6ee76d4f7059d2c72b98041
-  data.tar.gz: b0d7a59ade65eb893e976875d42075aacf8edfe32eada98af10de1ab39a8145913f37cb830a09498345d01cd59e1fc6e8eb511efe72e3e9976fc48c0dd2bec41
+  metadata.gz: 12c05f2f7115c61e94b1fd3b0b4acba5f1508abc63748032b8d003ba7d957884d0ca8bd7e4e92adbd2656cf43f0a93f8179852c86c20e26800ccfed70f1b1472
+  data.tar.gz: 1abef016e197f81078e32bdb18825683ff2b609d13eb407b6de20d82cc28a1750e9134c72d75c577ffebf8b2efeda8fc7ef5206eaa5cef6210784aad1dd8df2b

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

@@ -4,6 +4,8 @@ module Intelligence
 
       CHAT_REQUEST_URI = "https://api.anthropic.com/v1/messages"
 
+      SUPPORTED_CONTENT_TYPES = %w[ image/jpeg image/png image/gif image/webp application/pdf ]
+
       def chat_request_uri( options )
         CHAT_REQUEST_URI
       end
@@ -75,10 +77,9 @@ module Intelligence
                 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'
+                  if SUPPORTED_CONTENT_TYPES.include?( content_type )
                     result_message_content << {
-                      type: 'image',
+                      type: content_type == 'application/pdf' ? 'document' : 'image',
                       source: {
                         type: 'base64',
                         media_type: content_type,
@@ -97,6 +98,30 @@ module Intelligence
                     'requires file 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: content_type == 'application/pdf' ? 'document' : 'image',
+                      source: {
+                        type: 'url',
+                        url: uri 
+                      }
+                    }
+                  else 
+                    raise UnsupportedContentError.new( 
+                      :anthropic, 
+                      "only supports content of type #{SUPPORTED_CONTENT_TYPES.join( ', ' )}" 
+                    ) 
+                  end 
+                else 
+                  raise UnsupportedContentError.new(
+                    :anthropic, 
+                    'requires file content to include content type and uri'  
+                  )
+                end 
               when :tool_call 
                 result_message_content << {
                   type: 'tool_use',
@@ -111,7 +136,7 @@ module Intelligence
                   content: content[ :tool_result ]
                 }
               else
-                raise InvalidContentError.new( :anthropic ) 
+                raise UnsupportedContentError.new( :anthropic ) 
               end
             end
             

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

@@ -9,8 +9,8 @@ module Intelligence
 
         result = {}
         result[ :choices ] = []
-
         ( response_json[ :choices ] || [] ).each do | json_choice |
+          end_reason = to_end_reason( json_choice[ :finish_reason ] )
           if ( json_message = json_choice[ :message ] )
             result_message = { role: json_message[ :role ] }
             if json_message[ :content ] 
@@ -18,6 +18,7 @@ module Intelligence
             end
             if json_message[ :tool_calls ] && !json_message[ :tool_calls ].empty?
               result_message[ :contents ] ||= []
+              end_reason = :tool_called if end_reason == :ended
               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 ) \
@@ -31,10 +32,7 @@ module Intelligence
               end 
             end
           end
-          result[ :choices ].push( { 
-            end_reason: to_end_reason( json_choice[ :finish_reason ] ), 
-            message: result_message 
-          } )
+          result[ :choices ].push( { end_reason: end_reason, message: result_message } )
         end
 
         metrics_json = response_json[ :usage ]

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

@@ -35,6 +35,11 @@ module Intelligence
           response_mime_type String,  as: :responseMimeType
           response_schema             as: :responseSchema
 
+          # google specific thinking properies
+          thinking                    as: :thinkingConfig, default: {} do 
+            budget                    as: :thinkingBudget, default: 0
+          end
+
           # google specific tool configuration
           tool                        array: true, as: :tools, &Tool.schema 
           tool_configuration          as: :tool_config do
@@ -44,8 +49,8 @@ module Intelligence
             end
           end 
 
-          # build-in tools are called 'abilities' in Intelligence so as not to conflic with the
-          # caller defined tools  
+          # build-in tools are called 'abilities' in Intelligence so as not to conflic 
+          # with the caller defined tools  
           abilities do 
             # this appears to be a ( now ) legacy argument and is no longer supported
             # with the 2.0 models

data/lib/intelligence/adapters/mistral.rb

@@ -4,30 +4,31 @@ module Intelligence
   module Mistral
     class Adapter < Generic::Adapter
 
-      chat_request_uri "https://api.mistral.ai/v1/chat/completions"
+      DEFAULT_BASE_URI              = "https://api.mistral.ai/v1"
       
       schema do 
-        key                   String 
+        base_uri                    String, default: DEFAULT_BASE_URI
+        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 ]
+          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
+          random_seed               Integer
           response_format do 
-            type              String 
+            type                    String 
           end
 
-          tool                array: true, as: :tools, &Tool.schema 
+          tool                      array: true, as: :tools, &Tool.schema 
           tool_choice do 
-            type              String 
+            type                    String 
             function do 
-              name            String 
+              name                  String 
             end
           end
         end

data/lib/intelligence/adapters/x_ai.rb

@@ -38,55 +38,6 @@ module Intelligence
         end
       end
 
-      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 |
-          end_reason = to_end_reason( json_choice[ :finish_reason ] )
-          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 ] ||= []
-              end_reason = :tool_called if end_reason == :ended
-              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: end_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 

data/lib/intelligence/version.rb

@@ -1,3 +1,3 @@
 module Intelligence
-  VERSION = "1.0.0.beta06"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: intelligence
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta06
+  version: 1.0.0
 platform: ruby
 authors:
 - Kristoph Cichocki-Romanov
 bindir: bin
 cert_chain: []
-date: 2025-06-08 00:00:00.000000000 Z
+date: 2025-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -134,10 +134,6 @@ files:
 - lib/intelligence/adapters/anthropic/chat_request_methods.rb
 - lib/intelligence/adapters/anthropic/chat_response_methods.rb
 - lib/intelligence/adapters/cerebras.rb
-- lib/intelligence/adapters/deepseek.rb
-- lib/intelligence/adapters/deepseek/adapter.rb
-- lib/intelligence/adapters/deepseek/chat_request_methods.rb
-- lib/intelligence/adapters/deepseek/chat_response_methods.rb
 - lib/intelligence/adapters/generic.rb
 - lib/intelligence/adapters/generic/adapter.rb
 - lib/intelligence/adapters/generic/chat_request_methods.rb
@@ -173,7 +169,6 @@ files:
 - lib/intelligence/message_content/binary.rb
 - lib/intelligence/message_content/file.rb
 - lib/intelligence/message_content/text.rb
-- lib/intelligence/message_content/thought.rb
 - lib/intelligence/message_content/tool_call.rb
 - lib/intelligence/message_content/tool_result.rb
 - lib/intelligence/tool.rb

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

@@ -1,47 +0,0 @@
-require_relative '../../adapter'
-require_relative 'chat_request_methods'
-require_relative 'chat_response_methods'
-
-module Intelligence
-  module Deepseek
-    class Adapter < Adapter::Base
-      include ChatRequestMethods
-      include ChatResponseMethods
-
-      chat_request_uri 'https://api.deepseek.com/v1/chat/completions'
-
-      schema do 
-        key                   String
-        chat_options do 
-          frequency_penalty   Float 
-          logprobs            [ TrueClass, FalseClass ]
-          max_tokens          Integer
-          model               String
-          presence_penalty    Float, in: [ -2..2 ]
-          response_format do 
-            # 'text' and 'json_object' are the only supported types; you must also instruct 
-            # the model to output json
-            type              Symbol, in: [ :text, :json_object ]
-          end
-          stop                String, array: true
-          stream              [ TrueClass, FalseClass ]
-          stream_options do
-            include_usage     [ TrueClass, FalseClass ]
-          end
-          temperature         Float, in: [ 0..2 ]
-          tool                array: true, as: :tools, &Tool.schema 
-          tool_choice do 
-            # one of 'auto', 'none' or 'function'
-            type              Symbol, in: [ :auto, :none, :required ]
-            # the function parameters is required if you specify a type of 'function' 
-            function do 
-              name            String 
-            end
-          end
-          top_logprobs        Integer
-          top_p               Float
-        end
-      end
-    end 
-  end
-end

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

@@ -1,233 +0,0 @@
-module Intelligence
-  module Deepseek
-    module ChatRequestMethods
-
-      module ClassMethods
-        def chat_request_uri( uri = nil )
-          if uri
-            @chat_request_uri = uri
-          else
-            @chat_request_uri
-          end
-        end
-      end
-
-      CHAT_COMPLETIONS_PATH = 'chat/completions'
-
-      def self.included( base )
-        base.extend( ClassMethods )
-      end
-
-      def chat_request_uri( options = nil )
-        options = merge_options( @options, build_options( options ) )
-        self.class.chat_request_uri || begin 
-          base_uri = options[ :base_uri ]
-          if base_uri
-            # because URI join is dumb
-            base_uri += '/' unless base_uri.end_with?( '/' )
-            URI.join( base_uri, CHAT_COMPLETIONS_PATH )
-          else
-            nil 
-          end
-        end
-      end
-
-      def chat_request_headers( options = nil )
-        options = merge_options( @options, build_options( options ) )
-        result = { 'Content-Type': 'application/json' }
-
-        key = options[ :key ]
-        result[ 'Authorization' ] = "Bearer #{key}" if key
-
-        result 
-      end
-
-      def chat_request_body( conversation, options = nil )
-        tools = options.delete( :tools ) || []
-
-        options = merge_options( @options, 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( 
-          ( result[ :tools ] || [] ).concat( 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: {
-              type: 'object',
-              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/deepseek/chat_response_methods.rb

@@ -1,248 +0,0 @@
-module Intelligence
-  module Deepseek
-    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 ] || []
-
-              # this deepseek response doesn't place reasoning in a separate index ( presumably 
-              # because they are  simply detecting the thought tag in the first text )
-
-              if data_choice_content = data_choice_delta[ 'reasoning_content' ]
-                thought_content = contents.find { | content | content[ :type ] == :thought }
-                if thought_content.nil?  
-                  thought_content = { type: :thought, text: data_choice_content }
-                  contents << thought_content
-                else
-                  thought_content[ :text ] = ( thought_content[ :text ] || '' ) + data_choice_content
-                end
-              end 
-
-              if data_choice_content = data_choice_delta[ 'content' ]
-                text_content = contents.find { | content | content[ :type ] == :text }
-                if text_content.nil?  
-                  text_content = { type: :text, text: data_choice_content }
-                  contents << text_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' ]
-                    
-                    if data_choice_tool_id
-                      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_content_index = contents.rindex do | content | 
-                        content[ :type ] == :tool_call 
-                      end     
-                      tool_call = contents[ tool_call_content_index ]
-                      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/deepseek.rb

@@ -1 +0,0 @@
-require_relative 'deepseek/adapter'

data/lib/intelligence/message_content/thought.rb

@@ -1,30 +0,0 @@
-module Intelligence   
-  module MessageContent 
-
-    class Thought < Base
-        
-      schema do 
-        text            String, required: true
-      end
-
-      attr_reader :text 
-      
-      def valid?
-        true 
-      end
-
-      def merge( other )
-        other_text = other.text
-        text = @text 
-        text = ( @text || '' ) + other_text if other_text
-
-        self.class.new( text: text )
-      end
-
-      def to_h
-        { type: :text, text: text }
-      end
-    end 
-
-  end
-end