llm.rb 2.1.0 → 3.0.0

data/lib/llm/multipart.rb

@@ -5,6 +5,8 @@
 # @private
 class LLM::Multipart
   require "securerandom"
+  require_relative "multipart/enumerator_io"
+  CHUNK_SIZE = 16 * 1024
 
   ##
   # @return [String]
@@ -27,69 +29,36 @@ class LLM::Multipart
   end
 
   ##
-  # Returns the multipart request body
-  # @return [String]
+  # Returns the multipart request body as a stream
+  # @return [LLM::Multipart::EnumeratorIO]
   def body
-    io = StringIO.new("".b)
-    [*parts, StringIO.new("--#{@boundary}--\r\n".b)].each { IO.copy_stream(_1.tap(&:rewind), io) }
-    io.tap(&:rewind)
+    LLM::Multipart::EnumeratorIO.new(enum_for(:each_part))
   end
 
   private
 
   attr_reader :params
 
-  def file(locals, file)
-    locals = locals.merge(attributes(file))
-    build_file(locals) do |body|
-      IO.copy_stream(file.path, body)
-      body << "\r\n"
-    end
-  end
-
-  def form(locals, value)
-    locals = locals.merge(value:)
-    build_form(locals) do |body|
-      body << value.to_s
-      body << "\r\n"
-    end
-  end
-
-  def build_file(locals)
-    StringIO.new("".b).tap do |io|
-      io << "--#{locals[:boundary]}" \
-             "\r\n" \
-             "Content-Disposition: form-data; name=\"#{locals[:key]}\";" \
-             "filename=\"#{locals[:filename]}\"" \
-             "\r\n" \
-             "Content-Type: #{locals[:content_type]}" \
-             "\r\n\r\n"
-      yield(io)
-    end
-  end
-
-  def build_form(locals)
-    StringIO.new("".b).tap do |io|
-      io << "--#{locals[:boundary]}" \
-             "\r\n" \
-             "Content-Disposition: form-data; name=\"#{locals[:key]}\"" \
-             "\r\n\r\n"
-      yield(io)
-    end
-  end
-
-  ##
-  # Returns the multipart request body parts
-  # @return [Array<String>]
-  def parts
-    params.map do |key, value|
+  def each_part
+    params.each do |key, value|
       locals = {key: key.to_s.b, boundary: boundary.to_s.b}
       if value.respond_to?(:path)
-        file(locals, value)
+        locals = locals.merge(attributes(value))
+        yield file_header(locals)
+        File.open(value.path, "rb") do |io|
+          while (chunk = io.read(CHUNK_SIZE))
+            yield chunk
+          end
+        end
+        yield "\r\n".b
       else
-        form(locals, value)
+        locals = locals.merge(value:)
+        yield form_header(locals)
+        yield value.to_s.b
+        yield "\r\n".b
       end
     end
+    yield "--#{@boundary}--\r\n".b
   end
 
   def attributes(file)
@@ -98,4 +67,16 @@ class LLM::Multipart
       content_type: LLM::Mime[file].b
     }
   end
+
+  def file_header(locals)
+    "--#{locals[:boundary]}\r\n" \
+      "Content-Disposition: form-data; name=\"#{locals[:key]}\";" \
+      "filename=\"#{locals[:filename]}\"\r\n" \
+      "Content-Type: #{locals[:content_type]}\r\n\r\n"
+  end
+
+  def form_header(locals)
+    "--#{locals[:boundary]}\r\n" \
+      "Content-Disposition: form-data; name=\"#{locals[:key]}\"\r\n\r\n"
+  end
 end

data/lib/llm/object/builder.rb

@@ -6,17 +6,17 @@ class LLM::Object
   module Builder
     ##
     # @example
-    #   obj = LLM::Object.from_hash(person: {name: 'John'})
+    #   obj = LLM::Object.from(person: {name: 'John'})
     #   obj.person.name  # => 'John'
     #   obj.person.class # => LLM::Object
     # @param [Hash, LLM::Object, Array] obj
     #   A Hash object
     # @return [LLM::Object]
     #   An LLM::Object object initialized by visiting `obj` with recursion
-    def from_hash(obj)
+    def from(obj)
       case obj
-      when self then from_hash(obj.to_h)
-      when Array then obj.map { |v| from_hash(v) }
+      when self then from(obj.to_h)
+      when Array then obj.map { |v| from(v) }
       else
         visited = {}
         obj.each { visited[_1] = visit(_2) }
@@ -28,8 +28,8 @@ class LLM::Object
 
     def visit(value)
       case value
-      when self then from_hash(value.to_h)
-      when Hash then from_hash(value)
+      when self then from(value.to_h)
+      when Hash then from(value)
       when Array then value.map { |v| visit(v) }
       else value
       end

data/lib/llm/object/kernel.rb

@@ -26,11 +26,11 @@ class LLM::Object
     alias_method :is_a?, :kind_of?
 
     def respond_to?(m, include_private = false)
-      @h.key?(m.to_sym) || self.class.instance_methods.include?(m) || super
+      !!key(m) || self.class.method_defined?(m) || super
     end
 
     def respond_to_missing?(m, include_private = false)
-      @h.key?(m.to_sym) || super
+      !!key(m) || super
     end
 
     def object_id

data/lib/llm/object.rb

@@ -17,7 +17,7 @@ class LLM::Object < BasicObject
   # @param [Hash] h
   # @return [LLM::Object]
   def initialize(h = {})
-    @h = h.transform_keys(&:to_sym) || h
+    @h = h || {}
   end
 
   ##
@@ -33,7 +33,7 @@ class LLM::Object < BasicObject
   # @param [Symbol, #to_sym] k
   # @return [Object]
   def [](k)
-    @h[k.to_sym]
+    @h[key(k)]
   end
 
   ##
@@ -41,7 +41,7 @@ class LLM::Object < BasicObject
   # @param [Object] v
   # @return [void]
   def []=(k, v)
-    @h[k.to_sym] = v
+    @h[k.to_s] = v
   end
 
   ##
@@ -59,9 +59,14 @@ class LLM::Object < BasicObject
   ##
   # @return [Hash]
   def to_h
-    @h
+    @h.dup
+  end
+
+  ##
+  # @return [Hash]
+  def to_hash
+    @h.transform_keys(&:to_sym)
   end
-  alias_method :to_hash, :to_h
 
   ##
   # @return [Object, nil]
@@ -79,9 +84,19 @@ class LLM::Object < BasicObject
 
   def method_missing(m, *args, &b)
     if m.to_s.end_with?("=")
-      @h[m[0..-2].to_sym] = args.first
-    elsif @h.key?(m)
-      @h[m]
+      self[m[0..-2]] = args.first
+    elsif k = key(m)
+      @h[k]
+    else
+      nil
+    end
+  end
+
+  def key(k)
+    if @h.key?(k.to_s)
+      k.to_s
+    elsif @h.key?(k.to_sym)
+      k.to_sym
     else
       nil
     end

data/lib/llm/provider.rb

@@ -280,7 +280,7 @@ class LLM::Provider
   #  When authentication fails
   # @raise [LLM::Error::RateLimit]
   #  When the rate limit is exceeded
-  # @raise [LLM::Error::ResponseError]
+  # @raise [LLM::Error]
   #  When any other unsuccessful status code is returned
   # @raise [SystemCallError]
   #  When there is a network error at the operating system level
@@ -297,7 +297,7 @@ class LLM::Provider
         # response was most likely not streamed or
         # parsing has failed. In that case, we fallback
         # on the original response body.
-        res.body = handler.body.empty? ? parser.body.dup : handler.body
+        res.body = LLM::Object.from(handler.body.empty? ? parser.body : handler.body)
       ensure
         parser&.free
       end
@@ -315,9 +315,17 @@ class LLM::Provider
   # @return [Net::HTTPResponse]
   def handle_response(res)
     case res
-    when Net::HTTPOK then res
+    when Net::HTTPOK then res.body = parse_response(res)
     else error_handler.new(res).raise_error!
     end
+    res
+  end
+
+  def parse_response(res)
+    case res["content-type"]
+    when %r|\Aapplication/json\s*| then LLM::Object.from(LLM.json.load(res.body))
+    else res.body
+    end
   end
 
   ##

data/lib/llm/providers/anthropic/error_handler.rb

@@ -29,7 +29,7 @@ class LLM::Anthropic
       when Net::HTTPTooManyRequests
         raise LLM::RateLimitError.new { _1.response = res }, "Too many requests"
       else
-        raise LLM::ResponseError.new { _1.response = res }, "Unexpected response"
+        raise LLM::Error.new { _1.response = res }, "Unexpected response"
       end
     end
   end

data/lib/llm/providers/anthropic/files.rb

@@ -15,7 +15,6 @@ class LLM::Anthropic
   #   bot.chat ["Tell me about this PDF", file]
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Files
-    require_relative "response/file"
     ##
     # Returns a new Files object
     # @param provider [LLM::Provider]
@@ -40,7 +39,7 @@ class LLM::Anthropic
       query = URI.encode_www_form(params)
       req = Net::HTTP::Get.new("/v1/files?#{query}", headers)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Anthropic::Response::Enumerable)
+      ResponseAdapter.adapt(res, type: :enumerable)
     end
 
     ##
@@ -59,7 +58,7 @@ class LLM::Anthropic
       req["content-type"] = multi.content_type
       set_body_stream(req, multi.body)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Anthropic::Response::File)
+      ResponseAdapter.adapt(res, type: :file)
     end
 
     ##
@@ -78,7 +77,7 @@ class LLM::Anthropic
       query = URI.encode_www_form(params)
       req = Net::HTTP::Get.new("/v1/files/#{file_id}?#{query}", headers)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Anthropic::Response::File)
+      ResponseAdapter.adapt(res, type: :file)
     end
 
     ##
@@ -97,7 +96,7 @@ class LLM::Anthropic
       file_id = file.respond_to?(:id) ? file.id : file
       req = Net::HTTP::Get.new("/v1/files/#{file_id}?#{query}", headers)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Anthropic::Response::File)
+      ResponseAdapter.adapt(res, type: :file)
     end
     alias_method :retrieve_metadata, :get_metadata
 

data/lib/llm/providers/anthropic/models.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 class LLM::Anthropic
-  require_relative "response/enumerable"
   ##
   # The {LLM::Anthropic::Models LLM::Anthropic::Models} class provides a model
   # object for interacting with [Anthropic's models API](https://platform.anthropic.com/docs/api-reference/models/list).
@@ -42,7 +41,7 @@ class LLM::Anthropic
       query = URI.encode_www_form(params)
       req = Net::HTTP::Get.new("/v1/models?#{query}", headers)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Anthropic::Response::Enumerable)
+      ResponseAdapter.adapt(res, type: :enumerable)
     end
 
     private

data/lib/llm/providers/anthropic/{format/completion_format.rb → request_adapter/completion.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module LLM::Anthropic::Format
+module LLM::Anthropic::RequestAdapter
   ##
   # @private
-  class CompletionFormat
+  class Completion
     ##
     # @param [LLM::Message, Hash] message
     #  The message to format
@@ -12,25 +12,25 @@ module LLM::Anthropic::Format
     end
 
     ##
-    # Formats the message for the Anthropic chat completions API
+    # Adapts the message for the Anthropic chat completions API
     # @return [Hash]
-    def format
+    def adapt
       catch(:abort) do
         if Hash === message
-          {role: message[:role], content: format_content(message[:content])}
+          {role: message[:role], content: adapt_content(message[:content])}
         else
-          format_message
+          adapt_message
         end
       end
     end
 
     private
 
-    def format_message
+    def adapt_message
       if message.tool_call?
         {role: message.role, content: message.extra[:original_tool_calls]}
       else
-        {role: message.role, content: format_content(content)}
+        {role: message.role, content: adapt_content(content)}
       end
     end
 
@@ -39,41 +39,41 @@ module LLM::Anthropic::Format
     #  The content to format
     # @return [String, Hash]
     #  The formatted content
-    def format_content(content)
+    def adapt_content(content)
       case content
       when Hash
         content.empty? ? throw(:abort, nil) : [content]
       when Array
-        content.empty? ? throw(:abort, nil) : content.flat_map { format_content(_1) }
+        content.empty? ? throw(:abort, nil) : content.flat_map { adapt_content(_1) }
       when LLM::Object
-        format_object(content)
+        adapt_object(content)
       when String
         [{type: :text, text: content}]
       when LLM::Response
-        format_remote_file(content)
+        adapt_remote_file(content)
       when LLM::Message
-        format_content(content.content)
+        adapt_content(content.content)
       when LLM::Function::Return
-        [{type: "tool_result", tool_use_id: content.id, content: [{type: :text, text: JSON.dump(content.value)}]}]
+        [{type: "tool_result", tool_use_id: content.id, content: [{type: :text, text: LLM.json.dump(content.value)}]}]
       else
         prompt_error!(content)
       end
     end
 
-    def format_object(object)
+    def adapt_object(object)
       case object.kind
       when :image_url
         [{type: :image, source: {type: "url", url: object.value.to_s}}]
       when :local_file
-        format_local_file(object.value)
+        adapt_local_file(object.value)
       when :remote_file
-        format_remote_file(object.value)
+        adapt_remote_file(object.value)
       else
         prompt_error!(content)
       end
     end
 
-    def format_local_file(file)
+    def adapt_local_file(file)
       if file.image?
         [{type: :image, source: {type: "base64", media_type: file.mime_type, data: file.to_b64}}]
       elsif file.pdf?
@@ -85,7 +85,7 @@ module LLM::Anthropic::Format
       end
     end
 
-    def format_remote_file(file)
+    def adapt_remote_file(file)
       prompt_error!(file) unless file.file?
       [{type: file.file_type, source: {type: :file, file_id: file.id}}]
     end

data/lib/llm/providers/anthropic/{format.rb → request_adapter.rb}

@@ -3,16 +3,16 @@
 class LLM::Anthropic
   ##
   # @private
-  module Format
-    require_relative "format/completion_format"
+  module RequestAdapter
+    require_relative "request_adapter/completion"
 
     ##
     # @param [Array<LLM::Message>] messages
-    #  The messages to format
+    #  The messages to adapt
     # @return [Array<Hash>]
-    def format(messages)
+    def adapt(messages, mode: nil)
       messages.filter_map do
-        CompletionFormat.new(_1).format
+        Completion.new(_1).adapt
       end
     end
 
@@ -21,9 +21,9 @@ class LLM::Anthropic
     ##
     # @param [Hash] params
     # @return [Hash]
-    def format_tools(tools)
+    def adapt_tools(tools)
       return {} unless tools&.any?
-      {tools: tools.map { _1.respond_to?(:format) ? _1.format(self) : _1 }}
+      {tools: tools.map { _1.respond_to?(:adapt) ? _1.adapt(self) : _1 }}
     end
   end
 end

data/lib/llm/providers/anthropic/response_adapter/completion.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module LLM::Anthropic::ResponseAdapter
+  module Completion
+    ##
+    # (see LLM::Contract::Completion#messages)
+    def messages
+      adapt_choices
+    end
+    alias_method :choices, :messages
+
+    ##
+    # (see LLM::Contract::Completion#input_tokens)
+    def input_tokens
+      body.usage["input_tokens"] || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#output_tokens)
+    def output_tokens
+      body.usage["output_tokens"] || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#total_tokens)
+    def total_tokens
+      input_tokens + output_tokens
+    end
+
+    ##
+    # (see LLM::Contract::Completion#usage)
+    def usage
+      super
+    end
+
+    ##
+    # (see LLM::Contract::Completion#model)
+    def model
+      body.model
+    end
+
+    private
+
+    def adapt_choices
+      texts.map.with_index do |choice, index|
+        extra = {
+          index:, response: self,
+          tool_calls: adapt_tool_calls(tools), original_tool_calls: tools
+        }
+        LLM::Message.new(role, choice["text"], extra)
+      end
+    end
+
+    def adapt_tool_calls(tools)
+      (tools || []).filter_map do |tool|
+        {id: tool.id, name: tool.name, arguments: tool.input}
+      end
+    end
+
+    def parts = body.content
+    def texts = @texts ||= parts.select { _1["type"] == "text" }
+    def tools = @tools ||= parts.select { _1["type"] == "tool_use" }
+
+    include LLM::Contract::Completion
+  end
+end

data/lib/llm/providers/anthropic/{response → response_adapter}/enumerable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::Anthropic::Response
+module LLM::Anthropic::ResponseAdapter
   module Enumerable
     include ::Enumerable
 

data/lib/llm/providers/anthropic/{response → response_adapter}/file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::Anthropic::Response
+module LLM::Anthropic::ResponseAdapter
   module File
     ##
     # Always return true

data/lib/llm/providers/anthropic/{response → response_adapter}/web_search.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module LLM::Anthropic::Response
+module LLM::Anthropic::ResponseAdapter
   ##
-  # The {LLM::Anthropic::Response::WebSearch LLM::Anthropic::Response::WebSearch}
+  # The {LLM::Anthropic::ResponseAdapter::WebSearch LLM::Anthropic::ResponseAdapter::WebSearch}
   # module provides methods for accessing web search results from a web search
   # tool call made via the {LLM::Provider#web_search LLM::Provider#web_search}
   # method.
@@ -11,7 +11,7 @@ module LLM::Anthropic::Response
     # Returns one or more search results
     # @return [Array<LLM::Object>]
     def search_results
-      LLM::Object.from_hash(
+      LLM::Object.from(
         content
           .select { _1["type"] == "web_search_tool_result" }
           .flat_map { |n| n.content.map { _1.slice(:title, :url) } }

data/lib/llm/providers/anthropic/response_adapter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class LLM::Anthropic
+  ##
+  # @private
+  module ResponseAdapter
+    require_relative "response_adapter/completion"
+    require_relative "response_adapter/enumerable"
+    require_relative "response_adapter/file"
+    require_relative "response_adapter/web_search"
+
+    module_function
+
+    ##
+    # @param [LLM::Response, Net::HTTPResponse] res
+    # @param [Symbol] type
+    # @return [LLM::Response]
+    def adapt(res, type:)
+      response = (LLM::Response === res) ? res : LLM::Response.new(res)
+      response.extend(select(type))
+    end
+
+    ##
+    # @api private
+    def select(type)
+      case type
+      when :completion then LLM::Anthropic::ResponseAdapter::Completion
+      when :enumerable then LLM::Anthropic::ResponseAdapter::Enumerable
+      when :file then LLM::Anthropic::ResponseAdapter::File
+      when :web_search then LLM::Anthropic::ResponseAdapter::WebSearch
+      else
+        raise ArgumentError, "Unknown response adapter type: #{type.inspect}"
+      end
+    end
+  end
+end

data/lib/llm/providers/anthropic/stream_parser.rb

@@ -6,14 +6,14 @@ class LLM::Anthropic
   class StreamParser
     ##
     # Returns the fully constructed response body
-    # @return [LLM::Object]
+    # @return [Hash]
     attr_reader :body
 
     ##
     # @param [#<<] io An IO-like object
     # @return [LLM::Anthropic::StreamParser]
     def initialize(io)
-      @body = LLM::Object.new(role: "assistant", content: [])
+      @body = {"role" => "assistant", "content" => []}
       @io = io
     end
 
@@ -33,10 +33,10 @@ class LLM::Anthropic
         @body["content"][chunk["index"]] = chunk["content_block"]
       elsif chunk["type"] == "content_block_delta"
         if chunk["delta"]["type"] == "text_delta"
-          @body.content[chunk["index"]]["text"] << chunk["delta"]["text"]
+          @body["content"][chunk["index"]]["text"] << chunk["delta"]["text"]
           @io << chunk["delta"]["text"] if @io.respond_to?(:<<)
         elsif chunk["delta"]["type"] == "input_json_delta"
-          content = @body.content[chunk["index"]]
+          content = @body["content"][chunk["index"]]
           if Hash === content["input"]
             content["input"] = chunk["delta"]["partial_json"]
           else
@@ -46,9 +46,9 @@ class LLM::Anthropic
       elsif chunk["type"] == "message_delta"
         merge_message!(chunk["delta"])
       elsif chunk["type"] == "content_block_stop"
-        content = @body.content[chunk["index"]]
+        content = @body["content"][chunk["index"]]
         if content["input"]
-          content["input"] = JSON.parse(content["input"])
+          content["input"] = LLM.json.load(content["input"])
         end
       end
     end