llm.rb 0.4.2 → 0.5.0

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module LLM::OpenAI::Format
+  ##
+  # @private
+  class RespondFormat
+    def initialize(message)
+      @message = message
+    end
+
+    def format
+      catch(:abort) do
+        if Hash === message
+          {role: message[:role], content: format_content(message[:content])}
+        else
+          format_message
+        end
+      end
+    end
+
+    private
+
+    def format_content(content)
+      case content
+      when LLM::Response::File
+        format_file(content)
+      when String
+        [{type: :input_text, text: content.to_s}]
+      when LLM::Message
+        format_content(content.content)
+      else
+        raise LLM::Error::PromptError, "The given object (an instance of #{content.class}) " \
+                                       "is not supported by the OpenAI responses 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 { {type: "function_call_output", call_id: _1.id, output: JSON.dump(_1.value)} }
+      else
+        {role: message.role, content: content.flat_map { format_content(_1) }}
+      end
+    end
+
+    def format_file(content)
+      file = LLM::File(content.filename)
+      if file.image?
+        [{type: :input_image, file_id: content.id}]
+      else
+        [{type: :input_file, file_id: content.id}]
+      end
+    end
+
+    def message = @message
+    def content = message.content
+    def returns = content.grep(LLM::Function::Return)
+  end
+end

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

@@ -4,6 +4,9 @@ class LLM::OpenAI
   ##
   # @private
   module Format
+    require_relative "format/completion_format"
+    require_relative "format/respond_format"
+
     ##
     # @param [Array<LLM::Message>] messages
     #  The messages to format
@@ -11,11 +14,11 @@ class LLM::OpenAI
     #  The mode to format the messages for
     # @return [Array<Hash>]
     def format(messages, mode)
-      messages.map do
-        if Hash === _1
-          {role: _1[:role], content: format_content(_1[:content], mode)}
+      messages.filter_map do |message|
+        if mode == :complete
+          CompletionFormat.new(message).format
         else
-          {role: _1.role, content: format_content(_1.content, mode)}
+          RespondFormat.new(message).format
         end
       end
     end
@@ -23,62 +26,26 @@ class LLM::OpenAI
     private
 
     ##
-    # @param [String, URI] content
-    #  The content to format
-    # @return [String, Hash]
-    #  The formatted content
-    def format_content(content, mode)
-      if mode == :complete
-        format_complete(content)
-      elsif mode == :response
-        format_response(content)
-      end
+    # @param [JSON::Schema] schema
+    #  The schema to format
+    # @return [Hash]
+    def format_schema(schema)
+      return {} unless schema
+      {
+        response_format: {
+          type: "json_schema",
+          json_schema: {name: "JSONSchema", schema:}
+        }
+      }
     end
 
-    def format_complete(content)
-      case content
-      when Array
-        content.flat_map { format_complete(_1) }
-      when URI
-        [{type: :image_url, image_url: {url: content.to_s}}]
-      when LLM::File
-        file = content
-        if file.image?
-          [{type: :image_url, image_url: {url: file.to_data_uri}}]
-        else
-          [{type: :file, file: {filename: file.basename, file_data: file.to_data_uri}}]
-        end
-      when LLM::Response::File
-        [{type: :file, file: {file_id: content.id}}]
-      when String
-        [{type: :text, text: content.to_s}]
-      when LLM::Message
-        format_complete(content.content)
-      else
-        raise LLM::Error::PromptError, "The given object (an instance of #{content.class}) " \
-                                       "is not supported by the OpenAI chat completions API"
-      end
-    end
-
-    def format_response(content)
-      case content
-      when Array
-        content.flat_map { format_response(_1) }
-      when LLM::Response::File
-        file = LLM::File(content.filename)
-        if file.image?
-          [{type: :input_image, file_id: content.id}]
-        else
-          [{type: :input_file, file_id: content.id}]
-        end
-      when String
-        [{type: :input_text, text: content.to_s}]
-      when LLM::Message
-        format_response(content.content)
-      else
-        raise LLM::Error::PromptError, "The given object (an instance of #{content.class}) " \
-                                       "is not supported by the OpenAI responses API"
-      end
+    ##
+    # @param [Array<LLM::Function>] tools
+    #  The tools to format
+    # @return [Hash]
+    def format_tools(tools)
+      return {} unless tools
+      {tools: tools.map { _1.format(self) }}
     end
   end
 end

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

@@ -57,7 +57,7 @@ class LLM::OpenAI
     # Create image variations
     # @example
     #   llm = LLM.openai(ENV["KEY"])
-    #   res = llm.images.create_variation(image: LLM::File("/images/hat.png"), n: 5)
+    #   res = llm.images.create_variation(image: "/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
@@ -66,6 +66,7 @@ class LLM::OpenAI
     # @raise (see LLM::Provider#request)
     # @return [LLM::Response::Image]
     def create_variation(image:, model: "dall-e-2", **params)
+      image = LLM.File(image)
       multi = LLM::Multipart.new(params.merge!(image:, model:))
       req = Net::HTTP::Post.new("/v1/images/variations", headers)
       req["content-type"] = multi.content_type
@@ -78,7 +79,7 @@ class LLM::OpenAI
     # 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")
+    #   res = llm.images.edit(image: "/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
@@ -88,6 +89,7 @@ class LLM::OpenAI
     # @raise (see LLM::Provider#request)
     # @return [LLM::Response::Image]
     def edit(image:, prompt:, model: "dall-e-2", **params)
+      image = LLM.File(image)
       multi = LLM::Multipart.new(params.merge!(image:, prompt:, model:))
       req = Net::HTTP::Post.new("/v1/images/edits", headers)
       req["content-type"] = multi.content_type

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LLM::OpenAI::ResponseParser
+  ##
+  # @private
+  class CompletionParser
+    def initialize(body)
+      @body = OpenStruct.from_hash(body)
+    end
+
+    def format(response)
+      {
+        model:,
+        prompt_tokens:,
+        completion_tokens:,
+        total_tokens:,
+        choices: format_choices(response)
+      }
+    end
+
+    private
+
+    def format_choices(response)
+      choices.map.with_index do |choice, index|
+        message = choice.message
+        extra = {
+          index:, response:,
+          logprobs: choice.logprobs,
+          tool_calls: format_tool_calls(message.tool_calls),
+          original_tool_calls: message.tool_calls
+        }
+        LLM::Message.new(message.role, message.content, extra)
+      end
+    end
+
+    def format_tool_calls(tools)
+      (tools || []).filter_map do |tool|
+        next unless tool.function
+        tool = {
+          id: tool.id,
+          name: tool.function.name,
+          arguments: JSON.parse(tool.function.arguments)
+        }
+        OpenStruct.new(tool)
+      end
+    end
+
+    def body = @body
+    def model = body.model
+    def prompt_tokens = body.usage.prompt_tokens
+    def completion_tokens = body.usage.completion_tokens
+    def total_tokens = body.usage.total_tokens
+    def choices = body.choices
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module LLM::OpenAI::ResponseParser
+  ##
+  # @private
+  class RespondParser
+    def initialize(body)
+      @body = OpenStruct.from_hash(body)
+    end
+
+    def format(response)
+      {
+        id:,
+        model:,
+        input_tokens:,
+        output_tokens:,
+        total_tokens:,
+        outputs: [format_message(response)]
+      }
+    end
+
+    private
+
+    def format_message(response)
+      message = LLM::Message.new("assistant", +"", {response:, tool_calls: []})
+      choices.each.with_index do |choice, index|
+        if choice.type == "function_call"
+          message.extra[:tool_calls] << format_tool(choice)
+        elsif choice.content
+          choice.content.each do |c|
+            next unless c["type"] == "output_text"
+            message.content << c["text"] << "\n"
+          end
+        end
+      end
+      message
+    end
+
+    def format_tool(tool)
+      OpenStruct.new(
+        id: tool.call_id,
+        name: tool.name,
+        arguments: JSON.parse(tool.arguments)
+      )
+    end
+
+    def body = @body
+    def id = body.id
+    def model = body.model
+    def input_tokens = body.usage.input_tokens
+    def output_tokens = body.usage.output_tokens
+    def total_tokens = body.usage.total_tokens
+    def choices = body.output
+    def tools = output.select { _1.type == "function_call" }
+  end
+end

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

@@ -8,55 +8,28 @@ class LLM::OpenAI
     # @param [Hash] body
     #  The response body from the LLM provider
     # @return [Hash]
-    def parse_embedding(body)
-      {
-        model: body["model"],
-        embeddings: body["data"].map { _1["embedding"] },
-        prompt_tokens: body.dig("usage", "prompt_tokens"),
-        total_tokens: body.dig("usage", "total_tokens")
-      }
+    def parse_completion(body)
+      CompletionParser.new(body).format(self)
     end
 
     ##
     # @param [Hash] body
     #  The response body from the LLM provider
     # @return [Hash]
-    def parse_completion(body)
-      {
-        model: body["model"],
-        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")
-      }
+    def parse_respond_response(body)
+      RespondParser.new(body).format(self)
     end
 
     ##
     # @param [Hash] body
     #  The response body from the LLM provider
     # @return [Hash]
-    def parse_output_response(body)
+    def parse_embedding(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
+        embeddings: body["data"].map { _1["embedding"] },
+        prompt_tokens: body.dig("usage", "prompt_tokens"),
+        total_tokens: body.dig("usage", "total_tokens")
       }
     end
 
@@ -73,14 +46,5 @@ class LLM::OpenAI
         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

@@ -21,14 +21,14 @@ class LLM::OpenAI
   #   require "llm"
   #
   #   llm  = LLM.openai(ENV["KEY"])
-  #   file = llm.files.create file: LLM::File("/images/hat.png")
+  #   file = llm.files.create file: "/images/hat.png"
   #   res  = llm.responses.create ["Describe the image", file]
   # @example
   #   #!/usr/bin/env ruby
   #   require "llm"
   #
   #   llm  = LLM.openai(ENV["KEY"])
-  #   file = llm.files.create file: LLM::File("/documents/freebsd.pdf")
+  #   file = llm.files.create file: "/documents/freebsd.pdf"
   #   res  = llm.responses.create ["Describe the document, file]
   class Responses
     include Format
@@ -52,17 +52,14 @@ class LLM::OpenAI
     # @raise [LLM::Error::PromptError]
     #  When given an object a provider does not understand
     # @return [LLM::Response::Output]
-    def create(prompt, role = :user, model: @provider.default_model, schema: nil, **params)
-      params = {model:}
-                 .merge!(expand_schema(schema))
-                 .merge!(params)
-                 .compact
+    def create(prompt, role = :user, model: @provider.default_model, schema: nil, tools: nil, **params)
+      params = [{model:}, format_schema(schema), format_tools(tools), params].inject({}, &:merge!).compact
       req = Net::HTTP::Post.new("/v1/responses", headers)
       messages = [*(params.delete(:input) || []), LLM::Message.new(role, prompt)]
-      body = JSON.dump({input: format(messages, :response)}.merge!(params))
+      body = JSON.dump({input: [format(messages, :response)].flatten}.merge!(params))
       set_body_stream(req, StringIO.new(body))
       res = request(http, req)
-      LLM::Response::Output.new(res).extend(response_parser)
+      LLM::Response::Respond.new(res).extend(response_parser)
     end
 
     ##
@@ -76,7 +73,7 @@ class LLM::OpenAI
       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)
+      LLM::Response::Respond.new(res).extend(response_parser)
     end
 
     ##
@@ -98,7 +95,9 @@ class LLM::OpenAI
       @provider.instance_variable_get(:@http)
     end
 
-    [:response_parser, :headers, :request, :set_body_stream, :expand_schema].each do |m|
+    [:response_parser, :headers,
+     :request, :set_body_stream,
+     :format_schema, :format_tools].each do |m|
       define_method(m) { |*args, &b| @provider.send(m, *args, &b) }
     end
   end

data/lib/llm/providers/openai.rb

@@ -8,6 +8,8 @@ module LLM
     require_relative "openai/format"
     require_relative "openai/error_handler"
     require_relative "openai/response_parser"
+    require_relative "openai/response_parser/completion_parser"
+    require_relative "openai/response_parser/respond_parser"
     require_relative "openai/responses"
     require_relative "openai/images"
     require_relative "openai/audio"
@@ -51,14 +53,11 @@ module LLM
     # @raise [LLM::Error::PromptError]
     #  When given an object a provider does not understand
     # @return (see LLM::Provider#complete)
-    def complete(prompt, role = :user, model: default_model, schema: nil, **params)
-      params = {model:}
-                 .merge!(expand_schema(schema))
-                 .merge!(params)
-                 .compact
+    def complete(prompt, role = :user, model: default_model, schema: nil, tools: nil, **params)
+      params = [{model:}, format_schema(schema), format_tools(tools), params].inject({}, &:merge!).compact
       req = Net::HTTP::Post.new("/v1/chat/completions", headers)
       messages = [*(params.delete(:messages) || []), Message.new(role, prompt)]
-      body = JSON.dump({messages: format(messages, :complete)}.merge!(params))
+      body = JSON.dump({messages: format(messages, :complete).flatten}.merge!(params))
       set_body_stream(req, StringIO.new(body))
       res = request(@http, req)
       Response::Completion.new(res).extend(response_parser)
@@ -134,15 +133,5 @@ module LLM
     def error_handler
       LLM::OpenAI::ErrorHandler
     end
-
-    def expand_schema(schema)
-      return {} unless schema
-      {
-        response_format: {
-          type: "json_schema",
-          json_schema: {name: "JSONSchema", schema:}
-        }
-      }
-    end
   end
 end

data/lib/llm/response/{output.rb → respond.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LLM
-  class Response::Output < Response
+  class Response::Respond < Response
     ##
     # @return [String]
     #  Returns the id of the response
@@ -50,7 +50,7 @@ module LLM
     # @return [Hash]
     #  Returns the parsed response from the provider
     def parsed
-      @parsed ||= parse_output_response(body)
+      @parsed ||= parse_respond_response(body)
     end
   end
 end

data/lib/llm/response.rb

@@ -5,7 +5,7 @@ module LLM
     require "json"
     require_relative "response/completion"
     require_relative "response/embedding"
-    require_relative "response/output"
+    require_relative "response/respond"
     require_relative "response/image"
     require_relative "response/audio"
     require_relative "response/audio_transcription"

data/lib/llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LLM
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/lib/llm.rb

@@ -2,6 +2,7 @@
 
 module LLM
   require "stringio"
+  require_relative "json/schema"
   require_relative "llm/core_ext/ostruct"
   require_relative "llm/version"
   require_relative "llm/utils"
@@ -15,6 +16,7 @@ module LLM
   require_relative "llm/provider"
   require_relative "llm/chat"
   require_relative "llm/buffer"
+  require_relative "llm/function"
 
   module_function
 
@@ -58,4 +60,30 @@ module LLM
     require_relative "llm/providers/openai" unless defined?(LLM::OpenAI)
     LLM::OpenAI.new(secret, **options)
   end
+
+  ##
+  # Define a function
+  # @example
+  # LLM.function(:system) do |fn|
+  #   fn.description "Run system command"
+  #   fn.params do |schema|
+  #     schema.object(command: schema.string.required)
+  #   end
+  #   fn.define do |params|
+  #     system(params.command)
+  #   end
+  # end
+  # @param [Symbol] name The name of the function
+  # @param [Proc] b The block to define the function
+  # @return [LLM::Function] The function object
+  def function(name, &b)
+    functions[name.to_s] = LLM::Function.new(name, &b)
+  end
+
+  ##
+  # Returns all known functions
+  # @return [Hash<String,LLM::Function>]
+  def functions
+    @functions ||= {}
+  end
 end

data/llm.gemspec

@@ -36,4 +36,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "standard", "~> 1.40"
   spec.add_development_dependency "vcr", "~> 6.0"
+  spec.add_development_dependency "dotenv", "~> 2.8"
 end