ruby_llm 0.1.0.pre3 → 0.1.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1e5d243e58cd5fc884ef6a8ed5078df18e7659523296f175c55dff24c116079
-  data.tar.gz: 9a0cebfd7392a92e05b4f98974735ffab608e96a9af2caa2c5886af92584e0e7
+  metadata.gz: 33195e0b579713ebc168acdf2d1b6e67e1ee4a0d5db68cacaf1648cd4d1e744e
+  data.tar.gz: ee20d7adaa4f8ef22853894885dc6dfab2e19aab1526fd5022cd7413653e4736
 SHA512:
-  metadata.gz: 3df37307db5c36064502f476c714c893717a38fb73136e57c9e395386e8354cce62b47ad12da7cd6fe1c666a8c6e55faf333cd2808cfc280ae775bb96c181d23
-  data.tar.gz: df0f1a5cff449264a3868ac463ada43a94eddc712ed1b3de23802b5188ae217e86b8b48314cb99b24468bbdf2cb9970886908156e3a72642d7967b9a4088db40
+  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

@@ -30,12 +30,10 @@ module RubyLLM
     private
 
     def validate!
-      unless VALID_ROLES.include?(role)
-        raise ArgumentError,
-              "Invalid role: #{role}. Must be one of: #{VALID_ROLES.join(', ')}"
-      end
-      raise ArgumentError, 'Content cannot be nil' if content.nil?
-      raise ArgumentError, 'Content cannot be empty' if content.empty?
+      return if VALID_ROLES.include?(role)
+
+      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,24 +220,29 @@ module RubyLLM
             }
           ]
 
-          return create_chat_completion(payload.merge(messages: new_messages), tools)
-        end
-
-        # Extract token usage from response
-        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
+          final_response = create_chat_completion(
+            payload.merge(messages: new_messages),
+            tools,
+            &block
+          )
 
-        Message.new(
-          role: :assistant,
-          content: text_content,
-          token_usage: token_usage,
-          model_id: data['model']
-        )
+          [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,
+            token_usage: token_usage,
+            model_id: data['model']
+          )]
+        end
       end
 
       def handle_tool_calls(tool_calls, tools)
@@ -239,13 +281,26 @@ module RubyLLM
           rescue JSON::ParserError
             raise RubyLLM::Error, "API error: #{error.response[:status]}"
           end
-        elsif response_body.dig('error', 'type') == 'invalid_request_error'
+        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,47 +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
+          )
 
-        # Extract token usage from response
-        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']
-        )
+          # 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)

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '0.1.0.pre3'
+  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.pre3
+  version: 0.1.0.pre4
 platform: ruby
 authors:
 - Carmine Paolino