llm.rb 0.7.2 → 0.9.0

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

@@ -40,7 +40,7 @@ class LLM::Anthropic
     def all(**params)
       query = URI.encode_www_form(params)
       req = Net::HTTP::Get.new("/v1/models?#{query}", headers)
-      res = request(http, req)
+      res = execute(request: req)
       LLM::Response::ModelList.new(res).tap { |modellist|
         models = modellist.body["data"].map do |model|
           LLM::Model.from_hash(model).tap { _1.provider = @provider }
@@ -51,12 +51,8 @@ class LLM::Anthropic
 
     private
 
-    def http
-      @provider.instance_variable_get(:@http)
-    end
-
-    [:headers, :request].each do |m|
-      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    [:headers, :execute].each do |m|
+      define_method(m) { |*args, **kwargs, &b| @provider.send(m, *args, **kwargs, &b) }
     end
   end
 end

data/lib/llm/providers/anthropic/response_parser/completion_parser.rb

@@ -5,7 +5,7 @@ module LLM::Anthropic::ResponseParser
   # @private
   class CompletionParser
     def initialize(body)
-      @body = OpenStruct.from_hash(body)
+      @body = LLM::Object.from_hash(body)
     end
 
     def format(response)
@@ -34,16 +34,16 @@ module LLM::Anthropic::ResponseParser
           name: tool.name,
           arguments: tool.input
         }
-        OpenStruct.new(tool)
+        LLM::Object.new(tool)
       end
     end
 
     def body = @body
     def role = body.role
     def model = body.model
-    def prompt_tokens = body.usage.input_tokens
-    def completion_tokens = body.usage.output_tokens
-    def total_tokens = body.usage.total_tokens
+    def prompt_tokens = body.usage&.input_tokens
+    def completion_tokens = body.usage&.output_tokens
+    def total_tokens = body.usage&.total_tokens
     def parts = body.content
     def texts = parts.select { _1["type"] == "text" }
     def tools = parts.select { _1["type"] == "tool_use" }

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

@@ -4,6 +4,7 @@ class LLM::Anthropic
   ##
   # @private
   module ResponseParser
+    require_relative "response_parser/completion_parser"
     def parse_embedding(body)
       {
         model: body["model"],

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class LLM::Anthropic
+  ##
+  # @private
+  class StreamParser
+    ##
+    # Returns the fully constructed response body
+    # @return [LLM::Object]
+    attr_reader :body
+
+    ##
+    # @param [#<<] io An IO-like object
+    # @return [LLM::Anthropic::StreamParser]
+    def initialize(io)
+      @body = LLM::Object.new(role: "assistant", content: [])
+      @io = io
+    end
+
+    ##
+    # @param [Hash] chunk
+    # @return [LLM::Anthropic::StreamParser]
+    def parse!(chunk)
+      tap { merge!(chunk) }
+    end
+
+    private
+
+    def merge!(chunk)
+      if chunk["type"] == "message_start"
+        merge_message!(chunk["message"])
+      elsif chunk["type"] == "content_block_start"
+        @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"]
+          @io << chunk["delta"]["text"] if @io.respond_to?(:<<)
+        elsif chunk["delta"]["type"] == "input_json_delta"
+          content = @body.content[chunk["index"]]
+          if Hash === content["input"]
+            content["input"] = chunk["delta"]["partial_json"]
+          else
+            content["input"] << chunk["delta"]["partial_json"]
+          end
+        end
+      elsif chunk["type"] == "message_delta"
+        merge_message!(chunk["delta"])
+      elsif chunk["type"] == "content_block_stop"
+        content = @body.content[chunk["index"]]
+        if content["input"]
+          content["input"] = JSON.parse(content["input"])
+        end
+      end
+    end
+
+    def merge_message!(message)
+      message.each do |key, value|
+        @body[key] = if value.respond_to?(:each_pair)
+          merge_message!(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/llm/providers/anthropic.rb

@@ -5,10 +5,10 @@ module LLM
   # The Anthropic class implements a provider for
   # [Anthropic](https://www.anthropic.com)
   class Anthropic < Provider
+    require_relative "anthropic/format"
     require_relative "anthropic/error_handler"
+    require_relative "anthropic/stream_parser"
     require_relative "anthropic/response_parser"
-    require_relative "anthropic/response_parser/completion_parser"
-    require_relative "anthropic/format"
     require_relative "anthropic/models"
     include Format
 
@@ -50,12 +50,13 @@ module LLM
     def complete(prompt, params = {})
       params = {role: :user, model: default_model, max_tokens: 1024}.merge!(params)
       params = [params, format_tools(params)].inject({}, &:merge!).compact
-      role = params.delete(:role)
+      role, stream = params.delete(:role), params.delete(:stream)
+      params[:stream] = true if stream.respond_to?(:<<) || stream == true
       req = Net::HTTP::Post.new("/v1/messages", headers)
       messages = [*(params.delete(:messages) || []), Message.new(role, prompt)]
       body = JSON.dump({messages: [format(messages)].flatten}.merge!(params))
       set_body_stream(req, StringIO.new(body))
-      res = request(@http, req)
+      res = execute(request: req, stream:)
       Response::Completion.new(res).extend(response_parser)
     end
 
@@ -95,6 +96,10 @@ module LLM
       LLM::Anthropic::ResponseParser
     end
 
+    def stream_parser
+      LLM::Anthropic::StreamParser
+    end
+
     def error_handler
       LLM::Anthropic::ErrorHandler
     end

data/lib/llm/providers/deepseek/format/completion_format.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module LLM::DeepSeek::Format
+  ##
+  # @private
+  class CompletionFormat
+    ##
+    # @param [LLM::Message, Hash] message
+    #  The message to format
+    def initialize(message)
+      @message = message
+    end
+
+    ##
+    # Formats the message for the OpenAI chat completions API
+    # @return [Hash]
+    def format
+      catch(:abort) do
+        if Hash === message
+          {role: message[:role], content: format_content(message[:content])}
+        elsif message.tool_call?
+          {role: message.role, content: nil, tool_calls: message.extra[:original_tool_calls]}
+        else
+          format_message
+        end
+      end
+    end
+
+    private
+
+    def format_content(content)
+      case content
+      when String
+        content.to_s
+      when LLM::Message
+        format_content(content.content)
+      when LLM::Function::Return
+        throw(:abort, {role: "tool", tool_call_id: content.id, content: JSON.dump(content.value)})
+      else
+        raise LLM::Error::PromptError, "The given object (an instance of #{content.class}) " \
+                                       "is not supported by the DeepSeek chat completions API"
+      end
+    end
+
+    def format_message
+      case content
+      when Array
+        format_array
+      else
+        {role: message.role, content: format_content(content)}
+      end
+    end
+
+    def format_array
+      if content.empty?
+        nil
+      elsif returns.any?
+        returns.map { {role: "tool", tool_call_id: _1.id, content: JSON.dump(_1.value)} }
+      else
+        {role: message.role, content: content.flat_map { format_content(_1) }}
+      end
+    end
+
+    def message = @message
+    def content = message.content
+    def returns = content.grep(LLM::Function::Return)
+  end
+end

data/lib/llm/providers/deepseek/format.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class LLM::DeepSeek
+  ##
+  # @private
+  module Format
+    require_relative "format/completion_format"
+    ##
+    # @param [Array<LLM::Message>] messages
+    #  The messages to format
+    # @return [Array<Hash>]
+    def format(messages, ...)
+      messages.filter_map do |message|
+        CompletionFormat.new(message).format
+      end
+    end
+
+    private
+
+    ##
+    # @param [Hash] params
+    # @return [Hash]
+    def format_tools(params)
+      tools = params.delete(:tools)
+      (tools.nil? || tools.empty?) ? {} : {tools: tools.map { _1.format(self) }}
+    end
+  end
+end

data/lib/llm/providers/deepseek.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "openai" unless defined?(LLM::OpenAI)
+
+module LLM
+  ##
+  # The DeepSeek class implements a provider for
+  # [DeepSeek](https://deepseek.com)
+  # through its OpenAI-compatible API provided via
+  # their [web platform](https://platform.deepseek.com).
+  class DeepSeek < OpenAI
+    require_relative "deepseek/format"
+    include DeepSeek::Format
+
+    ##
+    # @param (see LLM::Provider#initialize)
+    # @return [LLM::DeepSeek]
+    def initialize(host: "api.deepseek.com", port: 443, ssl: true, **)
+      super
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def files
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def images
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def audio
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def moderations
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def responses
+      raise NotImplementedError
+    end
+
+    ##
+    # Returns the default model for chat completions
+    # @see https://api-docs.deepseek.com/quick_start/pricing deepseek-chat
+    # @return [String]
+    def default_model
+      "deepseek-chat"
+    end
+  end
+end

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

@@ -25,14 +25,14 @@ class LLM::Gemini
       when Net::HTTPBadRequest
         reason = body.dig("error", "details", 0, "reason")
         if reason == "API_KEY_INVALID"
-          raise LLM::Error::Unauthorized.new { _1.response = res }, "Authentication error"
+          raise LLM::UnauthorizedError.new { _1.response = res }, "Authentication error"
         else
-          raise LLM::Error::ResponseError.new { _1.response = res }, "Unexpected response"
+          raise LLM::ResponseError.new { _1.response = res }, "Unexpected response"
         end
       when Net::HTTPTooManyRequests
-        raise LLM::Error::RateLimit.new { _1.response = res }, "Too many requests"
+        raise LLM::RateLimitError.new { _1.response = res }, "Too many requests"
       else
-        raise LLM::Error::ResponseError.new { _1.response = res }, "Unexpected response"
+        raise LLM::ResponseError.new { _1.response = res }, "Unexpected response"
       end
     end
 

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

@@ -13,23 +13,24 @@ class LLM::Gemini
   # in the prompt over and over again (which could be the case in a
   # multi-turn conversation).
   #
-  # @example
+  # @example example #1
   #   #!/usr/bin/env ruby
   #   require "llm"
   #
   #   llm = LLM.gemini(ENV["KEY"])
-  #   bot = LLM::Chat.new(llm).lazy
+  #   bot = LLM::Bot.new(llm)
   #   file = llm.files.create file: "/audio/haiku.mp3"
   #   bot.chat(file)
   #   bot.chat("Describe the audio file I sent to you")
   #   bot.chat("The audio file is the first message I sent to you.")
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
-  # @example
+  #
+  # @example example #2
   #   #!/usr/bin/env ruby
   #   require "llm"
   #
   #   llm = LLM.gemini(ENV["KEY"])
-  #   bot = LLM::Chat.new(llm).lazy
+  #   bot = LLM::Bot.new(llm)
   #   file = llm.files.create file: "/audio/haiku.mp3"
   #   bot.chat(["Describe the audio file I sent to you", file])
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
@@ -57,11 +58,11 @@ class LLM::Gemini
     def all(**params)
       query = URI.encode_www_form(params.merge!(key: key))
       req = Net::HTTP::Get.new("/v1beta/files?#{query}", headers)
-      res = request(http, req)
+      res = execute(request: req)
       LLM::Response::FileList.new(res).tap { |filelist|
         files = filelist.body["files"]&.map do |file|
           file = file.transform_keys { snakecase(_1) }
-          OpenStruct.from_hash(file)
+          LLM::Object.from_hash(file)
         end || []
         filelist.files = files
       }
@@ -85,7 +86,7 @@ class LLM::Gemini
       req["X-Goog-Upload-Command"] = "upload, finalize"
       file.with_io do |io|
         set_body_stream(req, io)
-        res = request(http, req)
+        res = execute(request: req)
         LLM::Response::File.new(res)
       end
     end
@@ -105,7 +106,7 @@ class LLM::Gemini
       file_id = file.respond_to?(:name) ? file.name : file.to_s
       query = URI.encode_www_form(params.merge!(key: key))
       req = Net::HTTP::Get.new("/v1beta/#{file_id}?#{query}", headers)
-      res = request(http, req)
+      res = execute(request: req)
       LLM::Response::File.new(res)
     end
 
@@ -123,7 +124,7 @@ class LLM::Gemini
       file_id = file.respond_to?(:name) ? file.name : file.to_s
       query = URI.encode_www_form(params.merge!(key: key))
       req = Net::HTTP::Delete.new("/v1beta/#{file_id}?#{query}", headers)
-      request(http, req)
+      execute(request: req)
     end
 
     ##
@@ -144,20 +145,16 @@ class LLM::Gemini
       req["X-Goog-Upload-Header-Content-Length"] = file.bytesize
       req["X-Goog-Upload-Header-Content-Type"] = file.mime_type
       req.body = JSON.dump(file: {display_name: File.basename(file.path)})
-      res = request(http, req)
+      res = execute(request: req)
       res["x-goog-upload-url"]
     end
 
-    def http
-      @provider.instance_variable_get(:@http)
-    end
-
     def key
       @provider.instance_variable_get(:@key)
     end
 
-    [:headers, :request, :set_body_stream].each do |m|
-      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    [:headers, :execute, :set_body_stream].each do |m|
+      define_method(m) { |*args, **kwargs, &b| @provider.send(m, *args, **kwargs, &b) }
     end
   end
 end

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

@@ -47,7 +47,7 @@ class LLM::Gemini
         generationConfig: {responseModalities: ["TEXT", "IMAGE"]}
       }.merge!(params))
       req.body = body
-      res = request(http, req)
+      res = execute(request: req)
       LLM::Response::Image.new(res).extend(response_parser)
     end
 
@@ -72,7 +72,7 @@ class LLM::Gemini
         generationConfig: {responseModalities: ["TEXT", "IMAGE"]}
       }.merge!(params)).b
       set_body_stream(req, StringIO.new(body))
-      res = request(http, req)
+      res = execute(request: req)
       LLM::Response::Image.new(res).extend(response_parser)
     end
 
@@ -93,12 +93,8 @@ class LLM::Gemini
       @provider.instance_variable_get(:@key)
     end
 
-    def http
-      @provider.instance_variable_get(:@http)
-    end
-
-    [:response_parser, :headers, :request, :set_body_stream].each do |m|
-      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    [:response_parser, :headers, :execute, :set_body_stream].each do |m|
+      define_method(m) { |*args, **kwargs, &b| @provider.send(m, *args, **kwargs, &b) }
     end
   end
 end

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

@@ -42,7 +42,7 @@ class LLM::Gemini
     def all(**params)
       query = URI.encode_www_form(params.merge!(key: key))
       req = Net::HTTP::Get.new("/v1beta/models?#{query}", headers)
-      res = request(http, req)
+      res = execute(request: req)
       LLM::Response::ModelList.new(res).tap { |modellist|
         models = modellist.body["models"].map do |model|
           model = model.transform_keys { snakecase(_1) }
@@ -54,16 +54,12 @@ class LLM::Gemini
 
     private
 
-    def http
-      @provider.instance_variable_get(:@http)
-    end
-
     def key
       @provider.instance_variable_get(:@key)
     end
 
-    [:headers, :request].each do |m|
-      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    [:headers, :execute].each do |m|
+      define_method(m) { |*args, **kwargs, &b| @provider.send(m, *args, **kwargs, &b) }
     end
   end
 end

data/lib/llm/providers/gemini/response_parser/completion_parser.rb

@@ -3,7 +3,7 @@
 module LLM::Gemini::ResponseParser
   class CompletionParser
     def initialize(body)
-      @body = OpenStruct.from_hash(body)
+      @body = LLM::Object.from_hash(body)
     end
 
     def format(response)
@@ -32,7 +32,7 @@ module LLM::Gemini::ResponseParser
     def format_tool_calls(tools)
       (tools || []).map do |tool|
         function = {name: tool.name, arguments: tool.args}
-        OpenStruct.new(function)
+        LLM::Object.new(function)
       end
     end
 

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class LLM::Gemini
+  ##
+  # @private
+  class StreamParser
+    ##
+    # Returns the fully constructed response body
+    # @return [LLM::Object]
+    attr_reader :body
+
+    ##
+    # @param [#<<] io An IO-like object
+    # @return [LLM::Gemini::StreamParser]
+    def initialize(io)
+      @body = LLM::Object.new
+      @io = io
+    end
+
+    ##
+    # @param [Hash] chunk
+    # @return [LLM::Gemini::StreamParser]
+    def parse!(chunk)
+      tap { merge!(chunk) }
+    end
+
+    private
+
+    def merge!(chunk)
+      chunk.each do |key, value|
+        if key == "candidates"
+          @body.candidates ||= []
+          merge_candidates!(value)
+        else
+          @body[key] = value
+        end
+      end
+    end
+
+    def merge_candidates!(candidates)
+      candidates.each.with_index do |candidate, i|
+        if @body.candidates[i].nil?
+          merge_one(@body.candidates, candidate, i)
+        else
+          merge_two(@body.candidates, candidate, i)
+        end
+      end
+    end
+
+    def merge_one(candidates, candidate, i)
+      candidate
+        .dig("content", "parts")
+        &.filter_map { _1["text"] }
+        &.each { @io << _1 if @io.respond_to?(:<<) }
+      candidates[i] = candidate
+    end
+
+    def merge_two(candidates, candidate, i)
+      parts = candidates[i].dig("content", "parts")
+      parts&.each&.with_index do |part, j|
+        if part["text"]
+          target = candidate["content"]["parts"][j]
+          part["text"] << target["text"]
+          @io << target["text"] if @io.respond_to?(:<<)
+        end
+      end
+    end
+  end
+end

data/lib/llm/providers/gemini.rb

@@ -10,31 +10,34 @@ module LLM
   # prompt for files under 20MB or via the Gemini Files API for
   # files that are over 20MB
   #
-  # @example
+  # @example example #1
   #   #!/usr/bin/env ruby
   #   require "llm"
   #
   #   llm = LLM.gemini(ENV["KEY"])
-  #   bot = LLM::Chat.new(llm).lazy
-  #   bot.chat LLM::File("/images/capybara.png")
+  #   bot = LLM::Bot.new(llm)
+  #   bot.chat LLM.File("/images/capybara.png")
   #   bot.chat "Describe the image"
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
-  # @example
+  #
+  # @example example #2
   #   #!/usr/bin/env ruby
   #   require "llm"
   #
   #   llm = LLM.gemini(ENV["KEY"])
-  #   bot = LLM::Chat.new(llm).lazy
+  #   bot = LLM::Bot.new(llm)
   #   bot.chat ["Describe the image", LLM::File("/images/capybara.png")]
   #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Gemini < Provider
     require_relative "gemini/error_handler"
-    require_relative "gemini/response_parser"
     require_relative "gemini/format"
+    require_relative "gemini/stream_parser"
+    require_relative "gemini/response_parser"
+    require_relative "gemini/models"
     require_relative "gemini/images"
     require_relative "gemini/files"
     require_relative "gemini/audio"
-    require_relative "gemini/models"
+
     include Format
 
     HOST = "generativelanguage.googleapis.com"
@@ -57,7 +60,7 @@ module LLM
       path = ["/v1beta/models/#{model}", "embedContent?key=#{@key}"].join(":")
       req = Net::HTTP::Post.new(path, headers)
       req.body = JSON.dump({content: {parts: [{text: input}]}})
-      res = request(@http, req)
+      res = execute(request: req)
       Response::Embedding.new(res).extend(response_parser)
     end
 
@@ -74,14 +77,15 @@ module LLM
     def complete(prompt, params = {})
       params = {role: :user, model: default_model}.merge!(params)
       params = [params, format_schema(params), format_tools(params)].inject({}, &:merge!).compact
-      role, model = [:role, :model].map { params.delete(_1) }
+      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}", "generateContent?key=#{@key}"].join(":")
+      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))
       set_body_stream(req, StringIO.new(body))
-      res = request(@http, req)
+      res = execute(request: req, stream:)
       Response::Completion.new(res).extend(response_parser)
     end
 
@@ -140,6 +144,10 @@ module LLM
       LLM::Gemini::ResponseParser
     end
 
+    def stream_parser
+      LLM::Gemini::StreamParser
+    end
+
     def error_handler
       LLM::Gemini::ErrorHandler
     end