llm.rb 0.2.1 → 0.3.1

data/lib/llm/providers/ollama.rb

@@ -2,8 +2,22 @@
 
 module LLM
   ##
-  # The Ollama class implements a provider for
-  # [Ollama](https://ollama.ai/)
+  # The Ollama class implements a provider for [Ollama](https://ollama.ai/).
+  #
+  # This provider supports a wide range of models, it is relatively
+  # straight forward to run on your own hardware, and includes multi-modal
+  # models that can process images and text. See the example for a demonstration
+  # of a multi-modal model by the name `llava`
+  #
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.ollama(nil)
+  #   bot = LLM::Chat.new(llm, model: "llava").lazy
+  #   bot.chat LLM::File("/images/capybara.png")
+  #   bot.chat "Describe the image"
+  #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Ollama < Provider
     require_relative "ollama/error_handler"
     require_relative "ollama/response_parser"
@@ -19,10 +33,14 @@ module LLM
     end
 
     ##
+    # Provides an embedding
     # @param input (see LLM::Provider#embed)
+    # @param model (see LLM::Provider#embed)
+    # @param params (see LLM::Provider#embed)
+    # @raise (see LLM::Provider#request)
     # @return (see LLM::Provider#embed)
-    def embed(input, **params)
-      params   = {model: "llama3.2"}.merge!(params)
+    def embed(input, model: "llama3.2", **params)
+      params   = {model:}.merge!(params)
       req      = Net::HTTP::Post.new("/v1/embeddings", headers)
       req.body = JSON.dump({input:}.merge!(params))
       res      = request(@http, req)
@@ -30,15 +48,20 @@ module LLM
     end
 
     ##
+    # Provides an interface to the chat completions API
     # @see https://github.com/ollama/ollama/blob/main/docs/api.md#generate-a-chat-completion Ollama docs
     # @param prompt (see LLM::Provider#complete)
     # @param role (see LLM::Provider#complete)
+    # @param model (see LLM::Provider#complete)
+    # @param params (see LLM::Provider#complete)
+    # @example (see LLM::Provider#complete)
+    # @raise (see LLM::Provider#request)
     # @return (see LLM::Provider#complete)
-    def complete(prompt, role = :user, **params)
-      params   = {model: "llama3.2", stream: false}.merge!(params)
+    def complete(prompt, role = :user, model: "llama3.2", **params)
+      params   = {model:, stream: false}.merge!(params)
       req      = Net::HTTP::Post.new("/api/chat", headers)
       messages = [*(params.delete(:messages) || []), LLM::Message.new(role, prompt)]
-      req.body = JSON.dump({messages: messages.map(&:to_h)}.merge!(params))
+      req.body = JSON.dump({messages: format(messages)}.merge!(params))
       res      = request(@http, req)
       Response::Completion.new(res).extend(response_parser)
     end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class LLM::OpenAI
+  ##
+  # The {LLM::OpenAI::Audio LLM::OpenAI::Audio} class provides an audio
+  # object for interacting with [OpenAI's audio API](https://platform.openai.com/docs/api-reference/audio/createSpeech).
+  # @example
+  #   llm = LLM.openai(ENV["KEY"])
+  #   res = llm.audio.create_speech(input: "A dog on a rocket to the moon")
+  #   File.binwrite("rocket.mp3", res.audio.string)
+  class Audio
+    require "stringio"
+
+    ##
+    # Returns a new Audio object
+    # @param provider [LLM::Provider]
+    # @return [LLM::OpenAI::Responses]
+    def initialize(provider)
+      @provider = provider
+    end
+
+    ##
+    # Create an audio track
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.images.create_speech(input: "A dog on a rocket to the moon")
+    #   File.binwrite("rocket.mp3", res.audio.string)
+    # @see https://platform.openai.com/docs/api-reference/audio/createSpeech OpenAI docs
+    # @param [String] input The text input
+    # @param [String] voice The voice to use
+    # @param [String] model The model to use
+    # @param [String] response_format The response format
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::Audio]
+    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))
+      io = StringIO.new("".b)
+      res = request(http, req) { _1.read_body { |chunk| io << chunk } }
+      LLM::Response::Audio.new(res).tap { _1.audio = io }
+    end
+
+    ##
+    # Create an audio transcription
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.audio.create_transcription(file: LLM::File("/rocket.mp3"))
+    #   res.text # => "A dog on a rocket to the moon"
+    # @see https://platform.openai.com/docs/api-reference/audio/createTranscription OpenAI docs
+    # @param [LLM::File] file The input audio
+    # @param [String] model The model to use
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::AudioTranscription]
+    def create_transcription(file:, model: "whisper-1", **params)
+      multi = LLM::Multipart.new(params.merge!(file:, model:))
+      req = Net::HTTP::Post.new("/v1/audio/transcriptions", headers)
+      req["content-type"] = multi.content_type
+      req.body_stream = multi.body
+      res = request(http, req)
+      LLM::Response::AudioTranscription.new(res).tap { _1.text = _1.body["text"] }
+    end
+
+    ##
+    # Create an audio translation (in English)
+    # @example
+    #   # Arabic => English
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.audio.create_translation(file: LLM::File("/bismillah.mp3"))
+    #   res.text # => "In the name of Allah, the Beneficent, the Merciful."
+    # @see https://platform.openai.com/docs/api-reference/audio/createTranslation OpenAI docs
+    # @param [LLM::File] file The input audio
+    # @param [String] model The model to use
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::AudioTranslation]
+    def create_translation(file:, model: "whisper-1", **params)
+      multi = LLM::Multipart.new(params.merge!(file:, model:))
+      req = Net::HTTP::Post.new("/v1/audio/translations", headers)
+      req["content-type"] = multi.content_type
+      req.body_stream = multi.body
+      res = request(http, req)
+      LLM::Response::AudioTranslation.new(res).tap { _1.text = _1.body["text"] }
+    end
+
+    private
+
+    def http
+      @provider.instance_variable_get(:@http)
+    end
+
+    [:headers, :request].each do |m|
+      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class LLM::OpenAI
+  ##
+  # @private
   class ErrorHandler
     ##
     # @return [Net::HTTPResponse]
@@ -25,7 +27,7 @@ class LLM::OpenAI
       when Net::HTTPTooManyRequests
         raise LLM::Error::RateLimit.new { _1.response = res }, "Too many requests"
       else
-        raise LLM::Error::BadResponse.new { _1.response = res }, "Unexpected response"
+        raise LLM::Error::ResponseError.new { _1.response = res }, "Unexpected response"
       end
     end
   end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+class LLM::OpenAI
+  ##
+  # The {LLM::OpenAI::Files LLM::OpenAI::Files} class provides a files
+  # object for interacting with [OpenAI's Files API](https://platform.openai.com/docs/api-reference/files/create).
+  # The files API allows a client to upload files for use with OpenAI's models
+  # and API endpoints. OpenAI supports multiple file formats, including text
+  # files, CSV files, JSON files, and more.
+  #
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.openai(ENV["KEY"])
+  #   bot = LLM::Chat.new(llm).lazy
+  #   file = llm.files.create file: LLM::File("/documents/freebsd.pdf")
+  #   bot.chat(file)
+  #   bot.chat("Describe the document")
+  #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.openai(ENV["KEY"])
+  #   bot = LLM::Chat.new(llm).lazy
+  #   file = llm.files.create file: LLM::File("/documents/openbsd.pdf")
+  #   bot.chat(["Describe the document I sent to you", file])
+  #   bot.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
+  class Files
+    ##
+    # Returns a new Files object
+    # @param provider [LLM::Provider]
+    # @return [LLM::OpenAI::Files]
+    def initialize(provider)
+      @provider = provider
+    end
+
+    ##
+    # List all files
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.files.all
+    #   res.each do |file|
+    #     print "id: ", file.id, "\n"
+    #   end
+    # @see https://platform.openai.com/docs/api-reference/files/list OpenAI docs
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::FileList]
+    def all(**params)
+      query = URI.encode_www_form(params)
+      req = Net::HTTP::Get.new("/v1/files?#{query}", headers)
+      res = request(http, req)
+      LLM::Response::FileList.new(res).tap { |filelist|
+        files = filelist.body["data"].map { OpenStruct.from_hash(_1) }
+        filelist.files = files
+      }
+    end
+
+    ##
+    # Create a file
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.files.create file: LLM::File("/documents/haiku.txt"),
+    # @see https://platform.openai.com/docs/api-reference/files/create OpenAI docs
+    # @param [File] file The file
+    # @param [String] purpose The purpose of the file (see OpenAI docs)
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::File]
+    def create(file:, purpose: "assistants", **params)
+      multi = LLM::Multipart.new(params.merge!(file:, purpose:))
+      req = Net::HTTP::Post.new("/v1/files", headers)
+      req["content-type"] = multi.content_type
+      req.body_stream = multi.body
+      res = request(http, req)
+      LLM::Response::File.new(res)
+    end
+
+    ##
+    # Get a file
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.files.get(file: "file-1234567890")
+    #   print "id: ", res.id, "\n"
+    # @see https://platform.openai.com/docs/api-reference/files/get OpenAI docs
+    # @param [#id, #to_s] file The file ID
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::File]
+    def get(file:, **params)
+      file_id = file.respond_to?(:id) ? file.id : file
+      query = URI.encode_www_form(params)
+      req = Net::HTTP::Get.new("/v1/files/#{file_id}?#{query}", headers)
+      res = request(http, req)
+      LLM::Response::File.new(res)
+    end
+
+    ##
+    # Download the content of a file
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.files.download(file: "file-1234567890")
+    #   File.binwrite "haiku1.txt", res.file.read
+    #   print res.file.read, "\n"
+    # @see https://platform.openai.com/docs/api-reference/files/content OpenAI docs
+    # @param [#id, #to_s] file The file ID
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::DownloadFile]
+    def download(file:, **params)
+      query = URI.encode_www_form(params)
+      file_id = file.respond_to?(:id) ? file.id : file
+      req = Net::HTTP::Get.new("/v1/files/#{file_id}/content?#{query}", headers)
+      io = StringIO.new("".b)
+      res = request(http, req) { |res| res.read_body { |chunk| io << chunk } }
+      LLM::Response::DownloadFile.new(res).tap { _1.file = io }
+    end
+
+    ##
+    # Delete a file
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.files.delete(file: "file-1234567890")
+    #   print res.deleted, "\n"
+    # @see https://platform.openai.com/docs/api-reference/files/delete OpenAI docs
+    # @param [#id, #to_s] file The file ID
+    # @raise (see LLM::Provider#request)
+    # @return [OpenStruct] Response body
+    def delete(file:)
+      file_id = file.respond_to?(:id) ? file.id : file
+      req = Net::HTTP::Delete.new("/v1/files/#{file_id}", headers)
+      res = request(http, req)
+      OpenStruct.from_hash JSON.parse(res.body)
+    end
+
+    private
+
+    def http
+      @provider.instance_variable_get(:@http)
+    end
+
+    [:headers, :request].each do |m|
+      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    end
+  end
+end

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

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
 class LLM::OpenAI
+  ##
+  # @private
   module Format
     ##
     # @param [Array<LLM::Message>] messages
     #  The messages to format
+    # @param [Symbol] mode
+    #  The mode to format the messages for
     # @return [Array<Hash>]
-    def format(messages)
+    def format(messages, mode)
       messages.map do
         if Hash === _1
-          {role: _1[:role], content: format_content(_1[:content])}
+          {role: _1[:role], content: format_content(_1[:content], mode)}
         else
-          {role: _1.role, content: format_content(_1.content)}
+          {role: _1.role, content: format_content(_1.content, mode)}
         end
       end
     end
@@ -23,11 +27,21 @@ class LLM::OpenAI
     #  The content to format
     # @return [String, Hash]
     #  The formatted content
-    def format_content(content)
-      if URI === content
-        [{type: :image_url, image_url: {url: content.to_s}}]
-      else
-        content
+    def format_content(content, mode)
+      if mode == :complete
+        case content
+        when Array then content.flat_map { format_content(_1, mode) }
+        when URI then [{type: :image_url, image_url: {url: content.to_s}}]
+        when LLM::Response::File then [{type: :file, file: {file_id: content.id}}]
+        else [{type: :text, text: content.to_s}]
+        end
+      elsif mode == :response
+        case content
+        when Array then content.flat_map { format_content(_1, mode) }
+        when URI then [{type: :image_url, image_url: {url: content.to_s}}]
+        when LLM::Response::File then [{type: :input_file, file_id: content.id}]
+        else [{type: :input_text, text: content.to_s}]
+        end
       end
     end
   end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class LLM::OpenAI
+  ##
+  # The {LLM::OpenAI::Images LLM::OpenAI::Images} class provides an images
+  # object for interacting with [OpenAI's images API](https://platform.openai.com/docs/api-reference/images).
+  # OpenAI supports multiple response formats: temporary URLs, or binary strings
+  # encoded in base64. The default is to return temporary URLs.
+  #
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #   require "open-uri"
+  #   require "fileutils"
+  #
+  #   llm = LLM.openai(ENV["KEY"])
+  #   res = llm.images.create prompt: "A dog on a rocket to the moon"
+  #   FileUtils.mv OpenURI.open_uri(res.urls[0]).path,
+  #                "rocket.png"
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.openai(ENV["KEY"])
+  #   res = llm.images.create prompt: "A dog on a rocket to the moon",
+  #                           response_format: "b64_json"
+  #   File.binwrite("rocket.png", res.images[0].binary)
+  class Images
+    ##
+    # Returns a new Images object
+    # @param provider [LLM::Provider]
+    # @return [LLM::OpenAI::Responses]
+    def initialize(provider)
+      @provider = provider
+    end
+
+    ##
+    # Create an image
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.images.create prompt: "A dog on a rocket to the moon"
+    #   p res.urls
+    # @see https://platform.openai.com/docs/api-reference/images/create OpenAI docs
+    # @param [String] prompt The prompt
+    # @param [String] model The model to use
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::Image]
+    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))
+      res = request(http, req)
+      LLM::Response::Image.new(res).extend(response_parser)
+    end
+
+    ##
+    # Create image variations
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.images.create_variation(image: LLM::File("/images/hat.png"), n: 5)
+    #   p res.urls
+    # @see https://platform.openai.com/docs/api-reference/images/createVariation OpenAI docs
+    # @param [File] image The image to create variations from
+    # @param [String] model The model to use
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::Image]
+    def create_variation(image:, model: "dall-e-2", **params)
+      multi = LLM::Multipart.new(params.merge!(image:, model:))
+      req = Net::HTTP::Post.new("/v1/images/variations", headers)
+      req["content-type"] = multi.content_type
+      req.body_stream = multi.body
+      res = request(http, req)
+      LLM::Response::Image.new(res).extend(response_parser)
+    end
+
+    ##
+    # Edit an image
+    # @example
+    #   llm = LLM.openai(ENV["KEY"])
+    #   res = llm.images.edit(image: LLM::File("/images/hat.png"), prompt: "A cat wearing this hat")
+    #   p res.urls
+    # @see https://platform.openai.com/docs/api-reference/images/createEdit OpenAI docs
+    # @param [File] image The image to edit
+    # @param [String] prompt The prompt
+    # @param [String] model The model to use
+    # @param [Hash] params Other parameters (see OpenAI docs)
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::Image]
+    def edit(image:, prompt:, model: "dall-e-2", **params)
+      multi = LLM::Multipart.new(params.merge!(image:, prompt:, model:))
+      req = Net::HTTP::Post.new("/v1/images/edits", headers)
+      req["content-type"] = multi.content_type
+      req.body_stream = multi.body
+      res = request(http, req)
+      LLM::Response::Image.new(res).extend(response_parser)
+    end
+
+    private
+
+    def http
+      @provider.instance_variable_get(:@http)
+    end
+
+    [:response_parser, :headers, :request].each do |m|
+      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class LLM::OpenAI
+  ##
+  # @private
   module ResponseParser
     ##
     # @param [Hash] body
@@ -22,16 +24,67 @@ class LLM::OpenAI
     def parse_completion(body)
       {
         model: body["model"],
-        choices: body["choices"].map do
-          mesg = _1["message"]
-          logprobs = _1["logprobs"]
-          role, content = mesg.values_at("role", "content")
-          LLM::Message.new(role, content, {completion: self, logprobs:})
+        choices: body["choices"].map.with_index do
+          extra = {
+            index: _2, response: self,
+            logprobs: _1["logprobs"]
+          }
+          LLM::Message.new(*_1["message"].values_at("role", "content"),  extra)
         end,
         prompt_tokens: body.dig("usage", "prompt_tokens"),
         completion_tokens: body.dig("usage", "completion_tokens"),
         total_tokens: body.dig("usage", "total_tokens")
       }
     end
+
+    ##
+    # @param [Hash] body
+    #  The response body from the LLM provider
+    # @return [Hash]
+    def parse_output_response(body)
+      {
+        id: body["id"],
+        model: body["model"],
+        input_tokens: body.dig("usage", "input_tokens"),
+        output_tokens: body.dig("usage", "output_tokens"),
+        total_tokens: body.dig("usage", "total_tokens"),
+        outputs: body["output"].filter_map.with_index do |output, index|
+          next unless output["content"]
+          extra = {
+            index:, response: self,
+            contents: output["content"],
+            annotations: output["annotations"]
+          }
+          LLM::Message.new(output["role"], text(output), extra)
+        end
+      }
+    end
+
+    ##
+    # @param [Hash] body
+    #  The response body from the LLM provider
+    # @return [Hash]
+    def parse_image(body)
+      {
+        urls: body["data"].filter_map { _1["url"] },
+        images: body["data"].filter_map do
+          next unless _1["b64_json"]
+          OpenStruct.from_hash(
+            mime_type: nil,
+            encoded: _1["b64_json"],
+            binary: _1["b64_json"].unpack1("m0")
+          )
+        end
+      }
+    end
+
+    private
+
+    def text(output)
+      output["content"]
+        .select { _1["type"] == "output_text" }
+        .map { _1["text"] }
+        .join("\n")
+    end
   end
 end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class LLM::OpenAI
+  ##
+  # The {LLM::OpenAI::Responses LLM::OpenAI::Responses} class provides a responses
+  # object for interacting with [OpenAI's response API](https://platform.openai.com/docs/guides/conversation-state?api-mode=responses).
+  # The responses API is similar to the chat completions API but it can maintain
+  # conversation state across multiple requests. This is useful when you want to
+  # save bandwidth and/or not maintain the message thread by yourself.
+  #
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.openai(ENV["KEY"])
+  #   res1 = llm.responses.create "Your task is to help me with math", :developer
+  #   res2 = llm.responses.create "5 + 5  = ?", :user, previous_response_id: res1.id
+  #   [res1,res2].each { llm.responses.delete(_1) }
+  class Responses
+    include Format
+
+    ##
+    # Returns a new Responses object
+    # @param provider [LLM::Provider]
+    # @return [LLM::OpenAI::Responses]
+    def initialize(provider)
+      @provider = provider
+    end
+
+    ##
+    # Create a response
+    # @see https://platform.openai.com/docs/api-reference/responses/create OpenAI docs
+    # @param prompt (see LLM::Provider#complete)
+    # @param role (see LLM::Provider#complete)
+    # @param model (see LLM::Provider#complete)
+    # @param [Hash] params Response params
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::Output]
+    def create(prompt, role = :user, model: "gpt-4o-mini", **params)
+      params   = {model:}.merge!(params)
+      req      = Net::HTTP::Post.new("/v1/responses", headers)
+      messages = [*(params.delete(:input) || []), LLM::Message.new(role, prompt)]
+      req.body = JSON.dump({input: format(messages, :response)}.merge!(params))
+      res      = request(http, req)
+      LLM::Response::Output.new(res).extend(response_parser)
+    end
+
+    ##
+    # Get a response
+    # @see https://platform.openai.com/docs/api-reference/responses/get OpenAI docs
+    # @param [#id, #to_s] response Response ID
+    # @raise (see LLM::Provider#request)
+    # @return [LLM::Response::Output]
+    def get(response, **params)
+      response_id = response.respond_to?(:id) ? response.id : response
+      query = URI.encode_www_form(params)
+      req = Net::HTTP::Get.new("/v1/responses/#{response_id}?#{query}", headers)
+      res = request(http, req)
+      LLM::Response::Output.new(res).extend(response_parser)
+    end
+
+    ##
+    # Deletes a response
+    # @see https://platform.openai.com/docs/api-reference/responses/delete OpenAI docs
+    # @param [#id, #to_s] response Response ID
+    # @raise (see LLM::Provider#request)
+    # @return [OpenStruct] Response body
+    def delete(response)
+      response_id = response.respond_to?(:id) ? response.id : response
+      req = Net::HTTP::Delete.new("/v1/responses/#{response_id}", headers)
+      res = request(http, req)
+      OpenStruct.from_hash JSON.parse(res.body)
+    end
+
+    private
+
+    def http
+      @provider.instance_variable_get(:@http)
+    end
+
+    [:response_parser, :headers, :request].each do |m|
+      define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
+    end
+  end
+end