llm.rb 2.1.0 → 3.0.0

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

@@ -6,14 +6,14 @@ class LLM::Gemini
   class StreamParser
     ##
     # Returns the fully constructed response body
-    # @return [LLM::Object]
+    # @return [Hash]
     attr_reader :body
 
     ##
     # @param [#<<] io An IO-like object
     # @return [LLM::Gemini::StreamParser]
     def initialize(io)
-      @body = LLM::Object.from_hash({candidates: []})
+      @body = {"candidates" => []}
       @io = io
     end
 
@@ -21,35 +21,37 @@ class LLM::Gemini
     # @param [Hash] chunk
     # @return [LLM::Gemini::StreamParser]
     def parse!(chunk)
-      tap { merge_chunk!(LLM::Object.from_hash(chunk)) }
+      tap { merge_chunk!(chunk) }
     end
 
     private
 
     def merge_chunk!(chunk)
       chunk.each do |key, value|
-        if key.to_s == "candidates"
+        k = key.to_s
+        if k == "candidates"
           merge_candidates!(value)
-        elsif key.to_s == "usageMetadata" &&
-            @body.usageMetadata.is_a?(LLM::Object) &&
-            value.is_a?(LLM::Object)
-          @body.usageMetadata = LLM::Object.from_hash(@body.usageMetadata.to_h.merge(value.to_h))
+        elsif k == "usageMetadata" &&
+            @body["usageMetadata"].is_a?(Hash) &&
+            value.is_a?(Hash)
+          @body["usageMetadata"] = @body["usageMetadata"].merge(value)
         else
-          @body[key] = value
+          @body[k] = value
         end
       end
     end
 
     def merge_candidates!(deltas)
       deltas.each do |delta|
-        index = delta.index
-        @body.candidates[index] ||= LLM::Object.from_hash({content: {parts: []}})
-        candidate = @body.candidates[index]
+        index = delta["index"]
+        @body["candidates"][index] ||= {"content" => {"parts" => []}}
+        candidate = @body["candidates"][index]
         delta.each do |key, value|
-          if key.to_s == "content"
-            merge_candidate_content!(candidate.content, value) if value
+          k = key.to_s
+          if k == "content"
+            merge_candidate_content!(candidate["content"], value) if value
           else
-            candidate[key] = value # Overwrite other fields
+            candidate[k] = value # Overwrite other fields
           end
         end
       end
@@ -57,26 +59,27 @@ class LLM::Gemini
 
     def merge_candidate_content!(content, delta)
       delta.each do |key, value|
-        if key.to_s == "parts"
-          content.parts ||= []
-          merge_content_parts!(content.parts, value) if value
+        k = key.to_s
+        if k == "parts"
+          content["parts"] ||= []
+          merge_content_parts!(content["parts"], value) if value
         else
-          content[key] = value
+          content[k] = value
         end
       end
     end
 
     def merge_content_parts!(parts, deltas)
       deltas.each do |delta|
-        if delta.text
+        if delta["text"]
           merge_text!(parts, delta)
-        elsif delta.functionCall
+        elsif delta["functionCall"]
           merge_function_call!(parts, delta)
-        elsif delta.inlineData
+        elsif delta["inlineData"]
           parts << delta
-        elsif delta.functionResponse
+        elsif delta["functionResponse"]
           parts << delta
-        elsif delta.fileData
+        elsif delta["fileData"]
           parts << delta
         end
       end
@@ -84,21 +87,23 @@ class LLM::Gemini
 
     def merge_text!(parts, delta)
       last_existing_part = parts.last
-      if last_existing_part&.text
-        last_existing_part.text << delta.text
-        @io << delta.text if @io.respond_to?(:<<)
+      text = delta["text"]
+      if last_existing_part.is_a?(Hash) && last_existing_part["text"]
+        last_existing_part["text"] ||= +""
+        last_existing_part["text"] << text
+        @io << text if @io.respond_to?(:<<)
       else
         parts << delta
-        @io << delta.text if @io.respond_to?(:<<)
+        @io << text if @io.respond_to?(:<<)
       end
     end
 
     def merge_function_call!(parts, delta)
       last_existing_part = parts.last
-      if last_existing_part&.functionCall
-        last_existing_part.functionCall = LLM::Object.from_hash(
-          last_existing_part.functionCall.to_h.merge(delta.functionCall.to_h)
-        )
+      last_call = last_existing_part.is_a?(Hash) ? last_existing_part["functionCall"] : nil
+      delta_call = delta["functionCall"]
+      if last_call.is_a?(Hash) && delta_call.is_a?(Hash)
+        last_existing_part["functionCall"] = last_call.merge(delta_call)
       else
         parts << delta
       end

data/lib/llm/providers/gemini.rb

@@ -18,18 +18,16 @@ module LLM
   #   bot.chat ["Tell me about this photo", File.open("/images/horse.jpg", "rb")]
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Gemini < Provider
-    require_relative "gemini/response/embedding"
-    require_relative "gemini/response/completion"
-    require_relative "gemini/response/web_search"
     require_relative "gemini/error_handler"
-    require_relative "gemini/format"
+    require_relative "gemini/request_adapter"
+    require_relative "gemini/response_adapter"
     require_relative "gemini/stream_parser"
     require_relative "gemini/models"
     require_relative "gemini/images"
-    require_relative "gemini/files"
     require_relative "gemini/audio"
+    require_relative "gemini/files"
 
-    include Format
+    include RequestAdapter
 
     HOST = "generativelanguage.googleapis.com"
 
@@ -50,9 +48,9 @@ module LLM
       model = model.respond_to?(:id) ? model.id : model
       path = ["/v1beta/models/#{model}", "embedContent?key=#{@key}"].join(":")
       req = Net::HTTP::Post.new(path, headers)
-      req.body = JSON.dump({content: {parts: [{text: input}]}})
+      req.body = LLM.json.dump({content: {parts: [{text: input}]}})
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Gemini::Response::Embedding)
+      ResponseAdapter.adapt(res, type: :embedding)
     end
 
     ##
@@ -68,18 +66,17 @@ module LLM
     def complete(prompt, params = {})
       params = {role: :user, model: default_model}.merge!(params)
       tools  = resolve_tools(params.delete(:tools))
-      params = [params, format_schema(params), format_tools(tools)].inject({}, &:merge!).compact
+      params = [params, adapt_schema(params), adapt_tools(tools)].inject({}, &:merge!).compact
       role, model, stream = [:role, :model, :stream].map { params.delete(_1) }
       action = stream ? "streamGenerateContent?key=#{@key}&alt=sse" : "generateContent?key=#{@key}"
       model.respond_to?(:id) ? model.id : model
       path = ["/v1beta/models/#{model}", action].join(":")
       req  = Net::HTTP::Post.new(path, headers)
       messages = [*(params.delete(:messages) || []), LLM::Message.new(role, prompt)]
-      body = JSON.dump({contents: format(messages)}.merge!(params))
+      body = LLM.json.dump({contents: adapt(messages)}.merge!(params))
       set_body_stream(req, StringIO.new(body))
       res = execute(request: req, stream:)
-      LLM::Response.new(res)
-        .extend(LLM::Gemini::Response::Completion)
+      ResponseAdapter.adapt(res, type: :completion)
         .extend(Module.new { define_method(:__tools__) { tools } })
     end
 
@@ -150,8 +147,7 @@ module LLM
     # @param query [String] The search query.
     # @return [LLM::Response] The response from the LLM provider.
     def web_search(query:)
-      complete(query, tools: [server_tools[:google_search]])
-        .extend(LLM::Gemini::Response::WebSearch)
+      ResponseAdapter.adapt(complete(query, tools: [server_tools[:google_search]]), type: :web_search)
     end
 
     private

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

@@ -29,7 +29,7 @@ class LLM::Ollama
       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/ollama/{format/completion_format.rb → request_adapter/completion.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module LLM::Ollama::Format
+module LLM::Ollama::RequestAdapter
   ##
   # @private
-  class CompletionFormat
+  class Completion
     ##
     # @param [LLM::Message] message
     #  The message to format
@@ -12,64 +12,64 @@ module LLM::Ollama::Format
     end
 
     ##
-    # Formats the message for the Ollama chat completions API
+    # Adapts the message for the Ollama chat completions API
     # @return [Hash]
-    def format
+    def adapt
       catch(:abort) do
         if Hash === message
-          {role: message[:role]}.merge(format_content(message[:content]))
+          {role: message[:role]}.merge(adapt_content(message[:content]))
         else
-          format_message
+          adapt_message
         end
       end
     end
 
     private
 
-    def format_content(content)
+    def adapt_content(content)
       case content
       when String
         {content:}
       when LLM::Message
-        format_content(content.content)
+        adapt_content(content.content)
       when LLM::Function::Return
-        throw(:abort, {role: "tool", tool_call_id: content.id, content: JSON.dump(content.value)})
+        throw(:abort, {role: "tool", tool_call_id: content.id, content: LLM.json.dump(content.value)})
       when LLM::Object
-        format_object(content)
+        adapt_object(content)
       else
         prompt_error!(content)
       end
     end
 
-    def format_message
+    def adapt_message
       case content
       when Array
-        format_array
+        adapt_array
       else
-        {role: message.role}.merge(format_content(content))
+        {role: message.role}.merge(adapt_content(content))
       end
     end
 
-    def format_array
+    def adapt_array
       if content.empty?
         nil
       elsif returns.any?
-        returns.map { {role: "tool", tool_call_id: _1.id, content: JSON.dump(_1.value)} }
+        returns.map { {role: "tool", tool_call_id: _1.id, content: LLM.json.dump(_1.value)} }
       else
-        content.flat_map { {role: message.role}.merge(format_content(_1)) }
+        content.flat_map { {role: message.role}.merge(adapt_content(_1)) }
       end
     end
 
-    def format_object(object)
+    def adapt_object(object)
       case object.kind
-      when :local_file then format_local_file(object.value)
+      when :local_file then adapt_local_file(object.value)
       when :remote_file then prompt_error!(object)
       when :image_url then prompt_error!(object)
       else prompt_error!(object)
       end
     end
 
-    def format_local_file(file)
+    def adapt_local_file(file)
       if file.image?
         {content: "This message has an image associated with it", images: [file.to_b64]}
       else

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

@@ -3,16 +3,16 @@
 class LLM::Ollama
   ##
   # @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 |message|
-        CompletionFormat.new(message).format
+        Completion.new(message).adapt
       end
     end
 
@@ -21,9 +21,9 @@ class LLM::Ollama
     ##
     # @param [Hash] params
     # @return [Hash]
-    def format_tools(tools)
+    def adapt_tools(tools)
       return {} unless tools&.any?
-      {tools: tools.map { _1.format(self) }}
+      {tools: tools.map { _1.adapt(self) }}
     end
   end
 end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LLM::Ollama::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.prompt_eval_count || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#output_tokens)
+    def output_tokens
+      body.eval_count || 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
+      message = body.message
+      role, content, calls = message.role, message.content, message.tool_calls
+      extra = {response: self, tool_calls: adapt_tool_calls(calls)}
+      [LLM::Message.new(role, content, extra)]
+    end
+
+    def adapt_tool_calls(tools)
+      return [] unless tools
+      tools.filter_map do |tool|
+        next unless tool["function"]
+        tool["function"]
+      end
+    end
+
+    include LLM::Contract::Completion
+  end
+end

data/lib/llm/providers/ollama/{response → response_adapter}/embedding.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::Ollama::Response
+module LLM::Ollama::ResponseAdapter
   module Embedding
     def embeddings = data.map { _1["embedding"] }
     def prompt_tokens = body.dig("usage", "prompt_tokens") || 0

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class LLM::Ollama
+  ##
+  # @private
+  module ResponseAdapter
+    require_relative "response_adapter/completion"
+    require_relative "response_adapter/embedding"
+
+    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::Ollama::ResponseAdapter::Completion
+      when :embedding then LLM::Ollama::ResponseAdapter::Embedding
+      else
+        raise ArgumentError, "Unknown response adapter type: #{type.inspect}"
+      end
+    end
+  end
+end

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

@@ -6,13 +6,13 @@ class LLM::Ollama
   class StreamParser
     ##
     # Returns the fully constructed response body
-    # @return [LLM::Object]
+    # @return [Hash]
     attr_reader :body
 
     ##
     # @return [LLM::OpenAI::Chunk]
     def initialize(io)
-      @body = LLM::Object.new
+      @body = {}
       @io = io
     end
 

data/lib/llm/providers/ollama.rb

@@ -16,14 +16,13 @@ module LLM
   #   bot.chat ["Tell me about this image", File.open("/images/parrot.png", "rb")]
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Ollama < Provider
-    require_relative "ollama/response/embedding"
-    require_relative "ollama/response/completion"
     require_relative "ollama/error_handler"
-    require_relative "ollama/format"
+    require_relative "ollama/request_adapter"
+    require_relative "ollama/response_adapter"
     require_relative "ollama/stream_parser"
     require_relative "ollama/models"
 
-    include Format
+    include RequestAdapter
 
     HOST = "localhost"
 
@@ -43,9 +42,9 @@ module LLM
     def embed(input, model: default_model, **params)
       params   = {model:}.merge!(params)
       req      = Net::HTTP::Post.new("/v1/embeddings", headers)
-      req.body = JSON.dump({input:}.merge!(params))
+      req.body = LLM.json.dump({input:}.merge!(params))
       res      = execute(request: req)
-      LLM::Response.new(res).extend(LLM::Ollama::Response::Embedding)
+      ResponseAdapter.adapt(res, type: :embedding)
     end
 
     ##
@@ -61,16 +60,15 @@ module LLM
     def complete(prompt, params = {})
       params = {role: :user, model: default_model, stream: true}.merge!(params)
       tools  = resolve_tools(params.delete(:tools))
-      params = [params, {format: params[:schema]}, format_tools(tools)].inject({}, &:merge!).compact
+      params = [params, {format: params[:schema]}, adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), params.delete(:stream)
       params[:stream] = true if stream.respond_to?(:<<) || stream == true
       req = Net::HTTP::Post.new("/api/chat", headers)
       messages = [*(params.delete(:messages) || []), LLM::Message.new(role, prompt)]
-      body = JSON.dump({messages: [format(messages)].flatten}.merge!(params))
+      body = LLM.json.dump({messages: [adapt(messages)].flatten}.merge!(params))
       set_body_stream(req, StringIO.new(body))
       res = execute(request: req, stream:)
-      LLM::Response.new(res)
-        .extend(LLM::Ollama::Response::Completion)
+      ResponseAdapter.adapt(res, type: :completion)
         .extend(Module.new { define_method(:__tools__) { tools } })
     end
 

data/lib/llm/providers/openai/audio.rb

@@ -33,7 +33,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def create_speech(input:, voice: "alloy", model: "gpt-4o-mini-tts", response_format: "mp3", **params)
       req = Net::HTTP::Post.new("/v1/audio/speech", headers)
-      req.body = JSON.dump({input:, voice:, model:, response_format:}.merge!(params))
+      req.body = LLM.json.dump({input:, voice:, model:, response_format:}.merge!(params))
       io = StringIO.new("".b)
       res = execute(request: req) { _1.read_body { |chunk| io << chunk } }
       LLM::Response.new(res).tap { _1.define_singleton_method(:audio) { io } }

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

@@ -31,16 +31,26 @@ class LLM::OpenAI
       else
         error = body["error"] || {}
         case error["type"]
+        when "invalid_request_error" then handle_invalid_request(error)
         when "server_error" then raise LLM::ServerError.new { _1.response = res }, error["message"]
-        else raise LLM::ResponseError.new { _1.response = res }, error["message"] || "Unexpected response"
+        else raise LLM::Error.new { _1.response = res }, error["message"] || "Unexpected response"
         end
       end
     end
 
     private
 
+    def handle_invalid_request(error)
+      case error["code"]
+      when "context_length_exceeded"
+        raise LLM::ContextWindowError.new { _1.response = res }, error["message"]
+      else
+        raise LLM::InvalidRequestError.new { _1.response = res }, error["message"]
+      end
+    end
+
     def body
-      @body ||= JSON.parse(res.body)
+      @body ||= LLM.json.load(res.body)
     end
   end
 end

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

@@ -18,9 +18,6 @@ class LLM::OpenAI
   #   bot.chat ["Tell me about this PDF", file]
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Files
-    require_relative "response/enumerable"
-    require_relative "response/file"
-
     ##
     # Returns a new Files object
     # @param provider [LLM::Provider]
@@ -45,7 +42,7 @@ class LLM::OpenAI
       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::OpenAI::Response::Enumerable)
+      ResponseAdapter.adapt(res, type: :enumerable)
     end
 
     ##
@@ -65,7 +62,7 @@ class LLM::OpenAI
       req["content-type"] = multi.content_type
       set_body_stream(req, multi.body)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::OpenAI::Response::File)
+      ResponseAdapter.adapt(res, type: :file)
     end
 
     ##
@@ -84,7 +81,7 @@ class LLM::OpenAI
       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::OpenAI::Response::File)
+      ResponseAdapter.adapt(res, type: :file)
     end
 
     ##

data/lib/llm/providers/openai/images.rb

@@ -27,7 +27,6 @@ class LLM::OpenAI
   #                           response_format: "b64_json"
   #   IO.copy_stream res.images[0], "rocket.png"
   class Images
-    require_relative "response/image"
     ##
     # Returns a new Images object
     # @param provider [LLM::Provider]
@@ -50,9 +49,9 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def create(prompt:, model: "dall-e-3", **params)
       req = Net::HTTP::Post.new("/v1/images/generations", headers)
-      req.body = JSON.dump({prompt:, n: 1, model:}.merge!(params))
+      req.body = LLM.json.dump({prompt:, n: 1, model:}.merge!(params))
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::OpenAI::Response::Image)
+      ResponseAdapter.adapt(res, type: :image)
     end
 
     ##
@@ -74,7 +73,7 @@ class LLM::OpenAI
       req["content-type"] = multi.content_type
       set_body_stream(req, multi.body)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::OpenAI::Response::Image)
+      ResponseAdapter.adapt(res, type: :image)
     end
 
     ##
@@ -97,7 +96,7 @@ class LLM::OpenAI
       req["content-type"] = multi.content_type
       set_body_stream(req, multi.body)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::OpenAI::Response::Image)
+      ResponseAdapter.adapt(res, type: :image)
     end
 
     private

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

@@ -17,8 +17,6 @@ class LLM::OpenAI
   #     print "id: ", model.id, "\n"
   #   end
   class Models
-    require_relative "response/enumerable"
-
     ##
     # Returns a new Models object
     # @param provider [LLM::Provider]
@@ -43,7 +41,7 @@ class LLM::OpenAI
       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::OpenAI::Response::Enumerable)
+      ResponseAdapter.adapt(res, type: :enumerable)
     end
 
     private

data/lib/llm/providers/openai/moderations.rb

@@ -31,8 +31,6 @@ class LLM::OpenAI
   # @see https://platform.openai.com/docs/api-reference/moderations/create OpenAI docs
   # @see https://platform.openai.com/docs/models#moderation OpenAI moderation models
   class Moderations
-    require_relative "response/moderations"
-
     ##
     # Returns a new Moderations object
     # @param [LLM::Provider] provider
@@ -50,10 +48,10 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def create(input:, model: "omni-moderation-latest", **params)
       req = Net::HTTP::Post.new("/v1/moderations", headers)
-      input = Format::ModerationFormat.new(input).format
-      req.body = JSON.dump({input:, model:}.merge!(params))
+      input = RequestAdapter::Moderation.new(input).adapt
+      req.body = LLM.json.dump({input:, model:}.merge!(params))
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::OpenAI::Response::Moderations)
+      ResponseAdapter.adapt(res, type: :moderations)
     end
 
     private