llm.rb 2.1.0 → 3.0.0

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Format
+module LLM::OpenAI::RequestAdapter
   ##
   # @private
-  class CompletionFormat
+  class Completion
     ##
     # @param [LLM::Message, Hash] message
     #  The message to format
@@ -12,72 +12,72 @@ module LLM::OpenAI::Format
     end
 
     ##
-    # Formats the message for the OpenAI chat completions API
+    # Adapts the message for the OpenAI 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])}
         elsif message.tool_call?
           {role: message.role, content: nil, tool_calls: message.extra[:original_tool_calls]}
         else
-          format_message
+          adapt_message
         end
       end
     end
 
     private
 
-    def format_message
+    def adapt_message
       case content
       when Array
-        format_array
+        adapt_array
       else
-        {role: message.role, content: format_content(content)}
+        {role: message.role, content: 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
-        {role: message.role, content: content.flat_map { format_content(_1) }}
+        {role: message.role, content: content.flat_map { adapt_content(_1) }}
       end
     end
 
-    def format_content(content)
+    def adapt_content(content)
       case content
       when LLM::Object
-        format_object(content)
+        adapt_object(content)
       when String
         [{type: :text, text: content.to_s}]
       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
-        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)})
       else
         prompt_error!(content)
       end
     end
 
-    def format_object(object)
+    def adapt_object(object)
       case object.kind
       when :image_url
         [{type: :image_url, image_url: {url: object.value}}]
       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!(object)
       end
     end
 
-    def format_local_file(file)
+    def adapt_local_file(file)
       if file.image?
         [{type: :image_url, image_url: {url: file.to_data_uri}}]
       else
@@ -85,7 +85,7 @@ module LLM::OpenAI::Format
       end
     end
 
-    def format_remote_file(file)
+    def adapt_remote_file(file)
       if file.file?
         [{type: :file, file: {file_id: file.id}}]
       else

data/lib/llm/providers/openai/{format/moderation_format.rb → request_adapter/moderation.rb}

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Format
+module LLM::OpenAI::RequestAdapter
   ##
   # @private
-  class ModerationFormat
+  class Moderation
     ##
     # @param [String, URI, Array<String, URI>] inputs
     #  The inputs to format
-    # @return [LLM::OpenAI::Format::ModerationFormat]
+    # @return [LLM::OpenAI::RequestAdapter::Moderation]
     def initialize(inputs)
       @inputs = inputs
     end
 
     ##
-    # Formats the inputs for the OpenAI moderations API
+    # Adapts the inputs for the OpenAI moderations API
     # @return [Array<Hash>]
-    def format
+    def adapt
       [*inputs].flat_map do |input|
         if String === input
           {type: :text, text: input}

data/lib/llm/providers/openai/{format/respond_format.rb → request_adapter/respond.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Format
+module LLM::OpenAI::RequestAdapter
   ##
   # @private
-  class RespondFormat
+  class Respond
     ##
     # @param [LLM::Message] message
     #  The message to format
@@ -11,28 +11,28 @@ module LLM::OpenAI::Format
       @message = message
     end
 
-    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_content(content)
+    def adapt_content(content)
       case content
       when String
         [{type: :input_text, text: content.to_s}]
-      when LLM::Response then format_remote_file(content)
-      when LLM::Message then format_content(content.content)
+      when LLM::Response then adapt_remote_file(content)
+      when LLM::Message then adapt_content(content.content)
       when LLM::Object
         case content.kind
         when :image_url then [{type: :image_url, image_url: {url: content.value.to_s}}]
-        when :remote_file then format_remote_file(content.value)
+        when :remote_file then adapt_remote_file(content.value)
         when :local_file then prompt_error!(content)
         else prompt_error!(content)
         end
@@ -41,26 +41,26 @@ module LLM::OpenAI::Format
       end
     end
 
-    def format_message
+    def adapt_message
       case content
       when Array
-        format_array
+        adapt_array
       else
-        {role: message.role, content: format_content(content)}
+        {role: message.role, content: adapt_content(content)}
       end
     end
 
-    def format_array
+    def adapt_array
       if content.empty?
         nil
       elsif returns.any?
-        returns.map { {type: "function_call_output", call_id: _1.id, output: JSON.dump(_1.value)} }
+        returns.map { {type: "function_call_output", call_id: _1.id, output: LLM.json.dump(_1.value)} }
       else
-        {role: message.role, content: content.flat_map { format_content(_1) }}
+        {role: message.role, content: content.flat_map { adapt_content(_1) }}
       end
     end
 
-    def format_remote_file(content)
+    def adapt_remote_file(content)
       prompt_error!(content) unless content.file?
       file = LLM::File(content.filename)
       if file.image?

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

@@ -3,23 +3,23 @@
 class LLM::OpenAI
   ##
   # @private
-  module Format
-    require_relative "format/completion_format"
-    require_relative "format/respond_format"
-    require_relative "format/moderation_format"
+  module RequestAdapter
+    require_relative "request_adapter/completion"
+    require_relative "request_adapter/respond"
+    require_relative "request_adapter/moderation"
 
     ##
     # @param [Array<LLM::Message>] messages
-    #  The messages to format
+    #  The messages to adapt
     # @param [Symbol] mode
-    #  The mode to format the messages for
+    #  The mode to adapt the messages for
     # @return [Array<Hash>]
-    def format(messages, mode)
+    def adapt(messages, mode: :complete)
       messages.filter_map do |message|
         if mode == :complete
-          CompletionFormat.new(message).format
+          Completion.new(message).adapt
         else
-          RespondFormat.new(message).format
+          Respond.new(message).adapt
         end
       end
     end
@@ -29,7 +29,7 @@ class LLM::OpenAI
     ##
     # @param [Hash] params
     # @return [Hash]
-    def format_schema(params)
+    def adapt_schema(params)
       return {} unless params and params[:schema]
       schema = params.delete(:schema)
       schema = schema.respond_to?(:object) ? schema.object : schema
@@ -44,11 +44,11 @@ class LLM::OpenAI
     ##
     # @param [Hash] params
     # @return [Hash]
-    def format_tools(tools)
+    def adapt_tools(tools)
       if tools.nil? || tools.empty?
         {}
       else
-        {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/openai/{response → response_adapter}/audio.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Response
+module LLM::OpenAI::ResponseAdapter
   module Audio
     def audio = body.audio
   end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module LLM::OpenAI::ResponseAdapter
+  module Completion
+    ##
+    # (see LLM::Contract::Completion#messages)
+    def messages
+      body.choices.map.with_index do |choice, index|
+        message = choice.message
+        extra = {
+          index:, response: self,
+          logprobs: choice.logprobs,
+          tool_calls: adapt_tool_calls(message.tool_calls),
+          original_tool_calls: message.tool_calls
+        }
+        LLM::Message.new(message.role, message.content, extra)
+      end
+    end
+    alias_method :choices, :messages
+
+    ##
+    # (see LLM::Contract::Completion#input_tokens)
+    def input_tokens
+      body.usage["prompt_tokens"] || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#output_tokens)
+    def output_tokens
+      body.usage["completion_tokens"] || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#total_tokens)
+    def total_tokens
+      body.usage["total_tokens"] || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#usage)
+    def usage
+      super
+    end
+
+    ##
+    # (see LLM::Contract::Completion#model)
+    def model
+      body.model
+    end
+
+    private
+
+    def adapt_tool_calls(tools)
+      (tools || []).filter_map do |tool|
+        next unless tool.function
+        {id: tool.id, name: tool.function.name, arguments: LLM.json.load(tool.function.arguments)}
+      end
+    end
+
+    include LLM::Contract::Completion
+  end
+end

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

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

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

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

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Response
+module LLM::OpenAI::ResponseAdapter
   module File
     def file? = true
   end

data/lib/llm/providers/openai/{response → response_adapter}/image.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Response
+module LLM::OpenAI::ResponseAdapter
   module Image
     def urls
       data.filter_map { _1["url"] }

data/lib/llm/providers/openai/{response → response_adapter}/moderations.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Response
+module LLM::OpenAI::ResponseAdapter
   module Moderations
     ##
     # @return [Array<LLM::Response]

data/lib/llm/providers/openai/{response → response_adapter}/responds.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Response
+module LLM::OpenAI::ResponseAdapter
   module Responds
     def model = body.model
     def response_id = respond_to?(:response) ? response["id"] : id
-    def choices = [format_message]
+    def choices = [adapt_message]
     def annotations = choices[0].annotations
 
     def prompt_tokens = body.usage&.input_tokens
@@ -20,11 +20,11 @@ module LLM::OpenAI::Response
 
     private
 
-    def format_message
+    def adapt_message
       message = LLM::Message.new("assistant", +"", {response: self, tool_calls: []})
       output.each.with_index do |choice, index|
         if choice.type == "function_call"
-          message.extra[:tool_calls] << format_tool(choice)
+          message.extra[:tool_calls] << adapt_tool(choice)
         elsif choice.content
           choice.content.each do |c|
             next unless c["type"] == "output_text"
@@ -37,12 +37,8 @@ module LLM::OpenAI::Response
       message
     end
 
-    def format_tool(tool)
-      LLM::Object.new(
-        id: tool.call_id,
-        name: tool.name,
-        arguments: JSON.parse(tool.arguments)
-      )
+    def adapt_tool(tool)
+      {id: tool.call_id, name: tool.name, arguments: LLM.json.load(tool.arguments)}
     end
   end
 end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module LLM::OpenAI::Response
+module LLM::OpenAI::ResponseAdapter
   ##
-  # The {LLM::OpenAI::Response::WebSearch LLM::OpenAI::Response::WebSearch}
+  # The {LLM::OpenAI::ResponseAdapter::WebSearch LLM::OpenAI::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::OpenAI::Response
     # Returns one or more search results
     # @return [Array<LLM::Object>]
     def search_results
-      LLM::Object.from_hash(
+      LLM::Object.from(
         choices[0]
           .annotations
           .map { _1.slice(:title, :url) }

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class LLM::OpenAI
+  ##
+  # @private
+  module ResponseAdapter
+    require_relative "response_adapter/audio"
+    require_relative "response_adapter/completion"
+    require_relative "response_adapter/embedding"
+    require_relative "response_adapter/enumerable"
+    require_relative "response_adapter/file"
+    require_relative "response_adapter/image"
+    require_relative "response_adapter/moderations"
+    require_relative "response_adapter/responds"
+    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)
+      adapter = select(type)
+      response.extend(adapter)
+    end
+
+    ##
+    # @api private
+    def select(type)
+      case type
+      when :audio then LLM::OpenAI::ResponseAdapter::Audio
+      when :completion then LLM::OpenAI::ResponseAdapter::Completion
+      when :embedding then LLM::OpenAI::ResponseAdapter::Embedding
+      when :enumerable then LLM::OpenAI::ResponseAdapter::Enumerable
+      when :file then LLM::OpenAI::ResponseAdapter::File
+      when :image then LLM::OpenAI::ResponseAdapter::Image
+      when :moderations then LLM::OpenAI::ResponseAdapter::Moderations
+      when :responds then LLM::OpenAI::ResponseAdapter::Responds
+      when :web_search then LLM::OpenAI::ResponseAdapter::WebSearch
+      else
+        raise ArgumentError, "Unknown response adapter type: #{type.inspect}"
+      end
+    end
+  end
+end

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

@@ -6,14 +6,14 @@ class LLM::OpenAI
   class Responses::StreamParser
     ##
     # Returns the fully constructed response body
-    # @return [LLM::Object]
+    # @return [Hash]
     attr_reader :body
 
     ##
     # @param [#<<] io An IO-like object
     # @return [LLM::OpenAI::Responses::StreamParser]
     def initialize(io)
-      @body = LLM::Object.new(output: []) # Initialize with an empty output array
+      @body = {"output" => []}
       @io = io
     end
 
@@ -33,43 +33,43 @@ class LLM::OpenAI
           next if k == "type"
           @body[k] = v
         end
-        @body.output ||= []
+        @body["output"] ||= []
       when "response.output_item.added"
         output_index = chunk["output_index"]
-        item = LLM::Object.from_hash(chunk["item"])
-        @body.output[output_index] = item
-        @body.output[output_index].content ||= []
+        item = chunk["item"]
+        @body["output"][output_index] = item
+        @body["output"][output_index]["content"] ||= []
       when "response.content_part.added"
         output_index = chunk["output_index"]
         content_index = chunk["content_index"]
-        part = LLM::Object.from_hash(chunk["part"])
-        @body.output[output_index] ||= LLM::Object.new(content: [])
-        @body.output[output_index].content ||= []
-        @body.output[output_index].content[content_index] = part
+        part = chunk["part"]
+        @body["output"][output_index] ||= {"content" => []}
+        @body["output"][output_index]["content"] ||= []
+        @body["output"][output_index]["content"][content_index] = part
       when "response.output_text.delta"
         output_index = chunk["output_index"]
         content_index = chunk["content_index"]
         delta_text = chunk["delta"]
-        output_item = @body.output[output_index]
-        if output_item&.content
-          content_part = output_item.content[content_index]
-          if content_part && content_part.type == "output_text"
-            content_part.text ||= ""
-            content_part.text << delta_text
+        output_item = @body["output"][output_index]
+        if output_item && output_item["content"]
+          content_part = output_item["content"][content_index]
+          if content_part && content_part["type"] == "output_text"
+            content_part["text"] ||= ""
+            content_part["text"] << delta_text
             @io << delta_text if @io.respond_to?(:<<)
           end
         end
       when "response.output_item.done"
         output_index = chunk["output_index"]
-        item = LLM::Object.from_hash(chunk["item"])
-        @body.output[output_index] = item
+        item = chunk["item"]
+        @body["output"][output_index] = item
       when "response.content_part.done"
         output_index = chunk["output_index"]
         content_index = chunk["content_index"]
-        part = LLM::Object.from_hash(chunk["part"])
-        @body.output[output_index] ||= LLM::Object.new(content: [])
-        @body.output[output_index].content ||= []
-        @body.output[output_index].content[content_index] = part
+        part = chunk["part"]
+        @body["output"][output_index] ||= {"content" => []}
+        @body["output"][output_index]["content"] ||= []
+        @body["output"][output_index]["content"][content_index] = part
       end
     end
   end

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

@@ -14,9 +14,8 @@ class LLM::OpenAI
   #   res2 = llm.responses.create "5 + 5 = X ?", role: :user, previous_response_id: res1.id
   #   [res1, res2].each { llm.responses.delete(_1) }
   class Responses
-    require_relative "response/responds"
     require_relative "responses/stream_parser"
-    include Format
+    include RequestAdapter
 
     ##
     # Returns a new Responses object
@@ -38,16 +37,15 @@ class LLM::OpenAI
     def create(prompt, params = {})
       params = {role: :user, model: @provider.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, stream = params.delete(:role), params.delete(:stream)
       params[:stream] = true if stream.respond_to?(:<<) || stream == true
       req = Net::HTTP::Post.new("/v1/responses", headers)
       messages = [*(params.delete(:input) || []), LLM::Message.new(role, prompt)]
-      body = JSON.dump({input: [format(messages, :response)].flatten}.merge!(params))
+      body = LLM.json.dump({input: [adapt(messages, mode: :response)].flatten}.merge!(params))
       set_body_stream(req, StringIO.new(body))
       res = execute(request: req, stream:, stream_parser:)
-      LLM::Response.new(res)
-        .extend(LLM::OpenAI::Response::Responds)
+      ResponseAdapter.adapt(res, type: :responds)
         .extend(Module.new { define_method(:__tools__) { tools } })
     end
 
@@ -62,7 +60,7 @@ class LLM::OpenAI
       query = URI.encode_www_form(params)
       req = Net::HTTP::Get.new("/v1/responses/#{response_id}?#{query}", headers)
       res = execute(request: req)
-      LLM::Response.new(res).extend(LLM::OpenAI::Response::Responds)
+      ResponseAdapter.adapt(res, type: :responds)
     end
 
     ##
@@ -84,7 +82,7 @@ class LLM::OpenAI
       define_method(m) { |*args, **kwargs, &b| @provider.send(m, *args, **kwargs, &b) }
     end
 
-    def format_schema(params)
+    def adapt_schema(params)
       return {} unless params && params[:schema]
       schema = params.delete(:schema)
       schema = schema.to_h.merge(additionalProperties: false)

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

@@ -6,13 +6,13 @@ class LLM::OpenAI
   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
 
@@ -38,8 +38,9 @@ class LLM::OpenAI
 
     def merge_choices!(choices)
       choices.each do |choice|
-        if @body.choices[choice["index"]]
-          target_message = @body["choices"][choice["index"]]["message"]
+        index = choice["index"]
+        if @body["choices"][index]
+          target_message = @body["choices"][index]["message"]
           delta = choice["delta"]
           delta.each do |key, value|
             if key == "content"
@@ -54,7 +55,7 @@ class LLM::OpenAI
           end
         else
           message_hash = {"role" => "assistant"}
-          @body["choices"][choice["index"]] = {"message" => message_hash}
+          @body["choices"][index] = {"message" => message_hash}
           choice["delta"].each do |key, value|
             if key == "content"
               @io << value if @io.respond_to?(:<<)