ruby_llm 0.1.0.pre2 → 0.1.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 210659964d16b741d71f9abf6eed197ed2caea0a76a036542cdac736ea1c433b
-  data.tar.gz: 7836e9182e7a978492e8060222d490e7a7be2cbf2a266668fd69c6068e4d103e
+  metadata.gz: 33195e0b579713ebc168acdf2d1b6e67e1ee4a0d5db68cacaf1648cd4d1e744e
+  data.tar.gz: ee20d7adaa4f8ef22853894885dc6dfab2e19aab1526fd5022cd7413653e4736
 SHA512:
-  metadata.gz: 901b4c602deff87cfaa3a1fe2b03b01e00165c68e7b15a5ebe942855f7d8c136f4a6e1e27c78d7584a07fd036c0c014f8f9a28c3555a516de68c565f405448c5
-  data.tar.gz: 534807760c3dfdadc18df7c4cfc435831352961550782b897aa99c63b911f5e2eef50b5bd1ecf32e591fbc77eb1c5fe2d7d6820b9250b58f5ccff93b84e16070
+  metadata.gz: bef854e5f925aa246b40ef1f12e4a9cde1c085c97a996ecd4c266810b97f9ac324f6cd19dede1526215e92249cbb9aee7017a512fd309baf834aee06570be6c0
+  data.tar.gz: 3dc20b4b9093cca54bb1d5e033e2270a8e33146c3b3c8dcc85997ca6b01eb9e2b07e95d833938df5ceca561d4a2da75a45473dbc878ce744c93d7816fde82009

data/lib/ruby_llm/client.rb

@@ -14,7 +14,7 @@ module RubyLLM
       end
 
       provider = provider_for(model)
-      provider.chat(
+      response_messages = provider.chat(
         formatted_messages,
         model: model,
         temperature: temperature,
@@ -22,6 +22,9 @@ module RubyLLM
         tools: tools,
         &block
       )
+
+      # Always return an array of messages, even for single responses
+      response_messages.is_a?(Array) ? response_messages : [response_messages]
     end
 
     def list_models(provider = nil)

data/lib/ruby_llm/message.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  # Represents a message in an LLM conversation
   class Message
     VALID_ROLES = %i[system user assistant tool].freeze
 
-    attr_reader :role, :content, :tool_calls, :tool_results
+    attr_reader :role, :content, :tool_calls, :tool_results, :token_usage, :model_id
 
-    def initialize(role:, content: nil, tool_calls: nil, tool_results: nil)
+    def initialize(role:, content: nil, tool_calls: nil, tool_results: nil, token_usage: nil, model_id: nil)
       @role = role.to_sym
       @content = content
       @tool_calls = tool_calls
       @tool_results = tool_results
+      @token_usage = token_usage
+      @model_id = model_id
       validate!
     end
 
@@ -20,7 +21,9 @@ module RubyLLM
         role: role,
         content: content,
         tool_calls: tool_calls,
-        tool_results: tool_results
+        tool_results: tool_results,
+        token_usage: token_usage,
+        model_id: model_id
       }.compact
     end
 
@@ -29,7 +32,8 @@ module RubyLLM
     def validate!
       return if VALID_ROLES.include?(role)
 
-      raise ArgumentError, "Invalid role: #{role}. Must be one of: #{VALID_ROLES.join(', ')}"
+      raise ArgumentError,
+            "Invalid role: #{role}. Must be one of: #{VALID_ROLES.join(', ')}"
     end
   end
 end

data/lib/ruby_llm/model_capabilities/openai.rb

@@ -102,7 +102,7 @@ module RubyLLM
         name = model_id.tr('-', ' ')
 
         # Capitalize each word
-        name = name.split(' ').map { |word| word.capitalize }.join(' ')
+        name = name.split(' ').map(&:capitalize).join(' ')
 
         # Apply specific formatting rules
         name.gsub(/(\d{4}) (\d{2}) (\d{2})/, '\1\2\3') # Convert dates to YYYYMMDD

data/lib/ruby_llm/providers/anthropic.rb

@@ -62,13 +62,24 @@ module RubyLLM
       private
 
       def tool_to_anthropic(tool)
+        # Get required fields and clean properties
+        required_fields = []
+        cleaned_properties = {}
+
+        tool.parameters.each do |name, props|
+          required_fields << name.to_s if props[:required]
+          cleaned_props = props.dup
+          cleaned_props.delete(:required)
+          cleaned_properties[name] = cleaned_props
+        end
+
         {
           name: tool.name,
           description: tool.description,
           input_schema: {
             type: 'object',
-            properties: tool.parameters,
-            required: tool.parameters.select { |_, v| v[:required] }.keys
+            properties: cleaned_properties,
+            required: required_fields
           }
         }
       end
@@ -94,7 +105,7 @@ module RubyLLM
         end
       end
 
-      def create_chat_completion(payload, tools = nil)
+      def create_chat_completion(payload, tools = nil, &block)
         response = @connection.post('/v1/messages') do |req|
           req.headers['x-api-key'] = RubyLLM.configuration.anthropic_api_key
           req.headers['anthropic-version'] = '2023-06-01'
@@ -105,7 +116,10 @@ module RubyLLM
         puts 'Response from Anthropic:' if ENV['RUBY_LLM_DEBUG']
         puts JSON.pretty_generate(response.body) if ENV['RUBY_LLM_DEBUG']
 
-        handle_response(response, tools, payload)
+        # Check for API errors first
+        check_for_api_error(response)
+
+        handle_response(response, tools, payload, &block)
       rescue Faraday::Error => e
         handle_error(e)
       end
@@ -117,6 +131,7 @@ module RubyLLM
           req.body = payload
         end
 
+        messages = []
         response.body.each_line do |line|
           next if line.strip.empty?
           next if line == 'data: [DONE]'
@@ -124,32 +139,48 @@ module RubyLLM
           begin
             data = JSON.parse(line.sub(/^data: /, ''))
 
-            if data['type'] == 'content_block_delta'
-              content = data['delta']['text']
-              yield Message.new(role: :assistant, content: content) if content
-            elsif data['type'] == 'tool_call'
-              handle_tool_calls(data['tool_calls'], tools) do |result|
-                yield Message.new(role: :assistant, content: result)
-              end
+            message = case data['type']
+                      when 'content_block_delta'
+                        Message.new(role: :assistant, content: data['delta']['text']) if data['delta']['text']
+                      when 'tool_call'
+                        handle_tool_calls(data['tool_calls'], tools) do |result|
+                          Message.new(role: :assistant, content: result)
+                        end
+                      end
+
+            if message
+              messages << message
+              yield message if block_given?
             end
           rescue JSON::ParserError
             next
           end
         end
+
+        messages
       rescue Faraday::Error => e
         handle_error(e)
       end
 
-      def handle_response(response, tools, payload)
+      def handle_response(response, tools, payload, &block)
         data = response.body
-        return Message.new(role: :assistant, content: '') if data['type'] == 'error'
 
-        # Extract text content and tool use from response
         content_parts = data['content'] || []
         text_content = content_parts.find { |c| c['type'] == 'text' }&.fetch('text', '')
         tool_use = content_parts.find { |c| c['type'] == 'tool_use' }
 
         if tool_use && tools
+          # Tool call handling code...
+          tool_message = Message.new(
+            role: :assistant,
+            content: text_content,
+            tool_calls: [{
+              name: tool_use['name'],
+              arguments: JSON.generate(tool_use['input'] || {})
+            }]
+          )
+          yield tool_message if block_given?
+
           tool = tools.find { |t| t.name == tool_use['name'] }
           result = if tool
                      begin
@@ -167,7 +198,13 @@ module RubyLLM
                      end
                    end
 
-          # Create a new message with the tool result
+          result_message = Message.new(
+            role: :tool,
+            content: result[:content],
+            tool_results: result
+          )
+          yield result_message if block_given?
+
           new_messages = payload[:messages] + [
             { role: 'assistant', content: data['content'] },
             {
@@ -183,13 +220,29 @@ module RubyLLM
             }
           ]
 
-          return create_chat_completion(payload.merge(messages: new_messages), tools)
-        end
+          final_response = create_chat_completion(
+            payload.merge(messages: new_messages),
+            tools,
+            &block
+          )
+
+          [tool_message, result_message] + final_response
+        else
+          token_usage = if data['usage']
+                          {
+                            input_tokens: data['usage']['input_tokens'],
+                            output_tokens: data['usage']['output_tokens'],
+                            total_tokens: data['usage']['input_tokens'] + data['usage']['output_tokens']
+                          }
+                        end
 
-        Message.new(
-          role: :assistant,
-          content: text_content
-        )
+          [Message.new(
+            role: :assistant,
+            content: text_content,
+            token_usage: token_usage,
+            model_id: data['model']
+          )]
+        end
       end
 
       def handle_tool_calls(tool_calls, tools)
@@ -218,6 +271,36 @@ module RubyLLM
         end.compact
       end
 
+      def handle_api_error(error)
+        response_body = error.response[:body]
+        if response_body.is_a?(String)
+          begin
+            error_data = JSON.parse(response_body)
+            message = error_data.dig('error', 'message')
+            raise RubyLLM::Error, "API error: #{message}" if message
+          rescue JSON::ParserError
+            raise RubyLLM::Error, "API error: #{error.response[:status]}"
+          end
+        elsif response_body['error']
+          raise RubyLLM::Error, "API error: #{response_body['error']['message']}"
+        else
+          raise RubyLLM::Error, "API error: #{error.response[:status]}"
+        end
+      end
+
+      def handle_error(error)
+        case error
+        when Faraday::TimeoutError
+          raise RubyLLM::Error, 'Request timed out'
+        when Faraday::ConnectionFailed
+          raise RubyLLM::Error, 'Connection failed'
+        when Faraday::ClientError
+          handle_api_error(error)
+        else
+          raise error
+        end
+      end
+
       def api_base
         'https://api.anthropic.com'
       end

data/lib/ruby_llm/providers/base.rb

@@ -16,6 +16,13 @@ module RubyLLM
 
       protected
 
+      def check_for_api_error(response)
+        return unless response.body.is_a?(Hash) && response.body['type'] == 'error'
+
+        error_msg = response.body.dig('error', 'message') || 'Unknown API error'
+        raise RubyLLM::Error, "API error: #{error_msg}"
+      end
+
       def build_connection
         Faraday.new(url: api_base) do |f|
           f.options.timeout = RubyLLM.configuration.request_timeout

data/lib/ruby_llm/providers/openai.rb

@@ -22,7 +22,7 @@ module RubyLLM
         if stream && block_given?
           stream_chat_completion(payload, tools, &block)
         else
-          create_chat_completion(payload, tools)
+          create_chat_completion(payload, tools, &block)
         end
       rescue Faraday::TimeoutError
         raise RubyLLM::Error, 'Request timed out'
@@ -80,7 +80,7 @@ module RubyLLM
         }
       end
 
-      def create_chat_completion(payload, tools = nil)
+      def create_chat_completion(payload, tools = nil, &block)
         response = connection.post('/v1/chat/completions') do |req|
           req.headers['Authorization'] = "Bearer #{RubyLLM.configuration.openai_api_key}"
           req.headers['Content-Type'] = 'application/json'
@@ -90,36 +90,74 @@ module RubyLLM
         puts 'Response from OpenAI:' if ENV['RUBY_LLM_DEBUG']
         puts JSON.pretty_generate(response.body) if ENV['RUBY_LLM_DEBUG']
 
+        # Check for API errors
+        check_for_api_error(response)
+
+        # Check for HTTP errors
         if response.status >= 400
           error_msg = response.body['error']&.fetch('message', nil) || "HTTP #{response.status}"
           raise RubyLLM::Error, "API error: #{error_msg}"
         end
 
-        handle_response(response, tools, payload)
+        handle_response(response, tools, payload, &block)
       end
 
-      def handle_response(response, tools, payload)
+      def handle_response(response, tools, payload, &block)
         data = response.body
         message_data = data.dig('choices', 0, 'message')
-        return Message.new(role: :assistant, content: '') unless message_data
+        return [] unless message_data
 
         if message_data['function_call'] && tools
+          # Create function call message
+          function_message = Message.new(
+            role: :assistant,
+            content: message_data['content'],
+            tool_calls: [message_data['function_call']]
+          )
+          yield function_message if block_given?
+
+          # Execute function and create result message
           result = handle_function_call(message_data['function_call'], tools)
-          puts "Function result: #{result}" if ENV['RUBY_LLM_DEBUG']
+          result_message = Message.new(
+            role: :tool,
+            content: result,
+            tool_results: {
+              name: message_data['function_call']['name'],
+              content: result
+            }
+          )
+          yield result_message if block_given?
 
-          # Create a new chat completion with the function results
+          # Get final response with function results
           new_messages = payload[:messages] + [
             { role: 'assistant', content: message_data['content'], function_call: message_data['function_call'] },
             { role: 'function', name: message_data['function_call']['name'], content: result }
           ]
 
-          return create_chat_completion(payload.merge(messages: new_messages), tools)
-        end
+          final_response = create_chat_completion(
+            payload.merge(messages: new_messages),
+            tools,
+            &block
+          )
 
-        Message.new(
-          role: :assistant,
-          content: message_data['content']
-        )
+          # Return all messages in sequence
+          [function_message, result_message] + final_response
+        else
+          token_usage = if data['usage']
+                          {
+                            input_tokens: data['usage']['prompt_tokens'],
+                            output_tokens: data['usage']['completion_tokens'],
+                            total_tokens: data['usage']['total_tokens']
+                          }
+                        end
+
+          [Message.new(
+            role: :assistant,
+            content: message_data['content'],
+            token_usage: token_usage,
+            model_id: data['model']
+          )]
+        end
       end
 
       def handle_function_call(function_call, tools)
@@ -153,6 +191,23 @@ module RubyLLM
         end
       end
 
+      def handle_api_error(error)
+        response_body = error.response[:body]
+        if response_body.is_a?(String)
+          begin
+            error_data = JSON.parse(response_body)
+            message = error_data.dig('error', 'message')
+            raise RubyLLM::Error, "API error: #{message}" if message
+          rescue JSON::ParserError
+            raise RubyLLM::Error, "API error: #{error.response[:status]}"
+          end
+        elsif response_body['error']
+          raise RubyLLM::Error, "API error: #{response_body['error']['message']}"
+        else
+          raise RubyLLM::Error, "API error: #{error.response[:status]}"
+        end
+      end
+
       def api_base
         'https://api.openai.com'
       end

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '0.1.0.pre2'
+  VERSION = '0.1.0.pre4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre2
+  version: 0.1.0.pre4
 platform: ruby
 authors:
 - Carmine Paolino