omniai 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a989cab03afca85385b23f4684d377b8d1a09533a73899fa79eebcce4f4a3260
-  data.tar.gz: bb39575e251b0dd6cf6e0e3b24ba86765fd550feeb3a222ce5f785ca654e8741
+  metadata.gz: b44fd75b138e1f46f517e7077367e02bdbcf1f798ee000087c5ba4c97bb7494b
+  data.tar.gz: 88002c5d7018fc5a940b30bfa644a93e93e9b93d0cbdd993306bf15943ea790d
 SHA512:
-  metadata.gz: e20f0ee5ab32ceb95e33e38888c81e28f936294cfcd9a3dad80a8d89a9fd3241477455e706d70fb949502b01cdf968547104e55931138512b4e617dd9688fe02
-  data.tar.gz: 58aa9a8a43b2e8a7580beac909b7ddd34fcaaa3d9c60c9105d3dba0cd18923f7361473fdb863890fbfa17013a1339b71008381e105bd961de44dec67db8eac8b
+  metadata.gz: f3bc56ecbeaaf50d776c87eb07ba571b85f2ab001b8181cff66875a9a282289fdec9bfa2c2a716637758f61a76d0c3ddf8b794abee6e3adba6117ad4b4fc4ccd
+  data.tar.gz: 233f99eb1daf1a75173559ad2649461aa1b1e1bc1f53eba65c5113690f38017258db79f4ba8d83e525c363adcd76caae9997fda49cf32c01198917c030b2b8f7

data/README.md

@@ -122,25 +122,30 @@ client = OmniAI::OpenAI::Client.new(timeout: {
 
 Clients that support chat (e.g. Anthropic w/ "Claude", Google w/ "Gemini", Mistral w/ "LeChat", OpenAI w/ "ChatGPT", etc) generate completions using the following calls:
 
-#### Completions using Single Message
+#### Completions using a Simple Prompt
+
+Generating a completion is as simple as sending in the text:
 
 ```ruby
 completion = client.chat('Tell me a joke.')
-completion.choice.message.content # '...'
+completion.choice.message.content # 'Why don't scientists trust atoms? They make up everything!'
 ```
 
-#### Completions using Multiple Messages
+#### Completions using a Complex Prompt
+
+More complex completions are generated using a block w/ various system / user messages:
 
 ```ruby
-messages = [
-  {
-    role: OmniAI::Chat::Role::SYSTEM,
-    content: 'You are a helpful assistant with an expertise in geography.',
-  },
-  'What is the capital of Canada?'
-]
-completion = client.chat(messages, model: '...', temperature: 0.7, format: :json)
-completion.choice.message.content  # '...'
+completion = client.chat do |prompt|
+  prompt.system 'You are a helpful assistant with an expertise in animals.'
+  prompt.user do |message|
+    message.text 'What animals are in the attached photos?'
+    message.url('https://.../cat.jpeg', "image/jpeg")
+    message.url('https://.../dog.jpeg', "image/jpeg")
+    message.file('./hamster.jpeg', "image/jpeg")
+  end
+end
+completion.choice.message.content  # 'They are photos of a cat, a cat, and a hamster.'
 ```
 
 #### Completions using Streaming via Proc
@@ -167,20 +172,19 @@ client.chat('Tell me a story', stream: $stdout)
 A chat can also be initialized with tools:
 
 ```ruby
-client.chat('What is the weather in "London, England" and "Madrid, Spain"?', tools: [
-  OmniAI::Tool.new(
-    proc { |location:, unit: 'celsius'| "It is #{rand(20..50)}° #{unit} in #{location}" },
-    name: 'Weather',
-    description: 'Lookup the weather in a location',
-    parameters: OmniAI::Tool::Parameters.new(
-      properties: {
-        location: OmniAI::Tool::Property.string(description: 'The city and country (e.g. Toronto, Canada).'),
-        unit: OmniAI::Tool::Property.string(enum: %w[celcius farenheit]),
-      },
-      required: %i[location]
-    )
+tool = OmniAI::Tool.new(
+  proc { |location:, unit: 'celsius'| "#{rand(20..50)}° #{unit} in #{location}" },
+  name: 'Weather',
+  description: 'Lookup the weather in a location',
+  parameters: OmniAI::Tool::Parameters.new(
+    properties: {
+      location: OmniAI::Tool::Property.string(description: 'e.g. Toronto'),
+      unit: OmniAI::Tool::Property.string(enum: %w[celcius farenheit]),
+    },
+    required: %i[location]
   )
-])
+)
+client.chat('What is the weather in "London" and "Madrid"?', tools: [tool])
 ```
 
 ### Transcribe

data/lib/omniai/chat/content.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # A placeholder for parts of a message. Any subclass must implement the serializable interface.
+    class Content
+      # @param context [Context] optional
+      #
+      # @return [String]
+      def serialize(context: nil)
+        raise NotImplementedError, ' # {self.class}#serialize undefined'
+      end
+
+      # @param data [hash]
+      # @param context [Context] optional
+      #
+      # @return [Content]
+      def self.deserialize(data, context: nil)
+        raise ArgumentError, "untyped data=#{data.inspect}" unless data.key?('type')
+
+        case data['type']
+        when 'text' then Text.deserialize(data, context:)
+        when /(.*)_url/ then URL.deserialize(data, context:)
+        else raise ArgumentError, "unknown type=#{data['type'].inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/omniai/chat/context.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # Used to handle the setup of serializer / deserializer methods for each type.
+    #
+    # Usage:
+    #
+    #   OmniAI::Chat::Context.build do |context|
+    #     context.serializers[:prompt] = (prompt, context:) -> { ... }
+    #     context.serializers[:message] = (prompt, context:) -> { ... }
+    #     context.serializers[:file] = (prompt, context:) -> { ... }
+    #     context.serializers[:text] = (prompt, context:) -> { ... }
+    #     context.serializers[:url] = (prompt, context:) -> { ... }
+    #     context.deserializers[:prompt] = (data, context:) -> { Prompt.new(...) }
+    #     context.deserializers[:message] = (data, context:) -> { Message.new(...) }
+    #     context.deserializers[:file] = (data, context:) -> { File.new(...) }
+    #     context.deserializers[:text] = (data, context:) -> { Text.new(...) }
+    #     context.deserializers[:url] = (data, context:) -> { URL.new(...) }
+    #   end
+    class Context
+      # @return [Hash]
+      attr_accessor :serializers
+
+      # @return [Hash]
+      attr_reader :deserializers
+
+      # @return [Context]
+      def self.build(&block)
+        new.tap do |context|
+          block&.call(context)
+        end
+      end
+
+      # @return [Context]
+      def initialize
+        @serializers = {}
+        @deserializers = {}
+      end
+    end
+  end
+end

data/lib/omniai/chat/file.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # A file is media that can be sent to many LLMs.
+    class File < Media
+      attr_accessor :io
+
+      # @param io [IO, Pathname, String]
+      # @param type [Symbol, String] :image, :video, :audio, "audio/flac", "image/jpeg", "video/mpeg", etc.
+      def initialize(io, type)
+        super(type)
+        @io = io
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class} io=#{@io.inspect}>"
+      end
+
+      # @return [String]
+      def fetch!
+        case @io
+        when IO then @io.read
+        else ::File.binread(@io)
+        end
+      end
+
+      # @param context [Context]
+      # @return [Hash]
+      def serialize(context: nil)
+        serializer = context&.serializers&.[](:file)
+        return serializer.call(self, context:) if serializer
+
+        { type: "#{kind}_url", "#{kind}_url": { url: data_uri } }
+      end
+    end
+  end
+end

data/lib/omniai/chat/media.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # An abstract class that represents audio / image / video and is used for both files and urls.
+    class Media < Content
+      class TypeError < Error; end
+
+      # @return [Symbol, String]
+      attr_accessor :type
+
+      # @param type [String] "audio/flac", "image/jpeg", "video/mpeg", etc.
+      def initialize(type)
+        super()
+        @type = type
+      end
+
+      # @return [Boolean]
+      def text?
+        @type.match?(%r{^text/})
+      end
+
+      # @return [Boolean]
+      def audio?
+        @type.match?(%r{^audio/})
+      end
+
+      # @return [Boolean]
+      def image?
+        @type.match?(%r{^image/})
+      end
+
+      # @return [Boolean]
+      def video?
+        @type.match?(%r{^video/})
+      end
+
+      # @return [:video, :audio, :image, :text]
+      def kind
+        if text? then :text
+        elsif audio? then :audio
+        elsif image? then :image
+        elsif video? then :video
+        else
+          raise(TypeError, "unsupported type=#{@type}")
+        end
+      end
+
+      # e.g. "Hello" -> "SGVsbG8h"
+      #
+      # @return [String]
+      def data
+        Base64.strict_encode64(fetch!)
+      end
+
+      # e.g. "data:text/html;base64,..."
+      #
+      # @return [String]
+      def data_uri
+        "data:#{@type};base64,#{data}"
+      end
+
+      # @return [String]
+      def fetch!
+        raise NotImplementedError, "#{self.class}#fetch! undefined"
+      end
+    end
+  end
+end

data/lib/omniai/chat/message.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # Used to standardize the process of building message within a prompt:
+    #
+    #   completion = client.chat do |prompt|
+    #     prompt.user do |message|
+    #       message.text 'What are these photos of?'
+    #       message.url 'https://example.com/cat.jpg', type: "image/jpeg"
+    #       message.url 'https://example.com/dog.jpg', type: "image/jpeg"
+    #       message.file File.open('hamster.jpg'), type: "image/jpeg"
+    #     end
+    #   end
+    class Message
+      # @return [Array<Content>, String]
+      attr_accessor :content
+
+      # @return [String]
+      attr_accessor :role
+
+      # @param content [String, nil]
+      # @param role [String]
+      def initialize(content: nil, role: Role::USER)
+        @content = content || []
+        @role = role
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class} role=#{@role.inspect} content=#{@content.inspect}>"
+      end
+
+      # Usage:
+      #
+      #   Message.deserialize({ role: :user, content: 'Hello!' }) # => #<Message ...>
+      #
+      # @param data [Hash]
+      # @param context [Context] optional
+      #
+      # @return [Message]
+      def self.deserialize(data, context: nil)
+        deserialize = context&.deserializers&.[](:message)
+        return deserialize.call(data, context:) if deserialize
+
+        new(
+          content: data['content'].map { |content| Content.deserialize(content, context:) },
+          role: data['role']
+        )
+      end
+
+      # Usage:
+      #
+      #   message.serialize # => { role: :user, content: 'Hello!' }
+      #   message.serialize # => { role: :user, content: [{ type: 'text', text: 'Hello!' }] }
+      #
+      # @param context [Context] optional
+      #
+      # @return [Hash]
+      def serialize(context: nil)
+        serializer = context&.serializers&.[](:message)
+        return serializer.call(self, context:) if serializer
+
+        content = @content.is_a?(String) ? @content : @content.map { |content| content.serialize(context:) }
+
+        { role: @role, content: }
+      end
+
+      # @return [Boolean]
+      def role?(role)
+        String(@role).eql?(String(role))
+      end
+
+      # @return [Boolean]
+      def system?
+        role?(Role::SYSTEM)
+      end
+
+      # @return [Boolean]
+      def user?
+        role?(Role::USER)
+      end
+
+      # Usage:
+      #
+      #   message.text('What are these photos of?')
+      #
+      # @param value [String]
+      #
+      # @return [Text]
+      def text(value)
+        Text.new(value).tap do |text|
+          @content << text
+        end
+      end
+
+      # Usage:
+      #
+      #   message.url('https://example.com/hamster.jpg', type: "image/jpeg")
+      #
+      # @param uri [String]
+      # @param type [String]
+      #
+      # @return [URL]
+      def url(uri, type)
+        URL.new(uri, type).tap do |url|
+          @content << url
+        end
+      end
+
+      # Usage:
+      #
+      #   message.file(File.open('hamster.jpg'), type: "image/jpeg")
+      #
+      # @param io [IO]
+      # @param type [String]
+      #
+      # @return [File]
+      def file(io, type)
+        File.new(io, type).tap do |file|
+          @content << file
+        end
+      end
+    end
+  end
+end

data/lib/omniai/chat/prompt.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # Used to standardizes the process of building complex prompts.
+    #
+    # Usage:
+    #
+    #   completion = OmniAI::Chat::Prompt.build do |prompt|
+    #     prompt.system('You are a helpful assistant.')
+    #     prompt.user do |message|
+    #       message.text 'What are these photos of?'
+    #       message.url 'https://example.com/cat.jpg', type: "image/jpeg"
+    #       message.url 'https://example.com/dog.jpg', type: "image/jpeg"
+    #       message.file File.open('hamster.jpg'), type: "image/jpeg"
+    #     end
+    #   end
+    class Prompt
+      class MessageError < Error; end
+
+      # @return [Array<Message>]
+      attr_accessor :messages
+
+      # Usage:
+      #
+      #   OmniAI::Chat::Prompt.build do |prompt|
+      #     prompt.system('You are an expert in geography.')
+      #     prompt.user('What is the capital of Canada?')
+      #   end
+      #
+      # @return [Prompt]
+      # @yield [Prompt]
+      def self.build(&block)
+        new.tap do |prompt|
+          block&.call(prompt)
+        end
+      end
+
+      # Usage:
+      #
+      #   OmniAI::Chat::Prompt.parse('What is the capital of Canada?')
+      #
+      # @param prompt [nil, String]
+      #
+      # @return [Prompt]
+      def self.parse(prompt)
+        new if prompt.nil?
+        return prompt if prompt.is_a?(self)
+
+        new.tap do |instance|
+          instance.user(prompt)
+        end
+      end
+
+      # @param messages [Array<Message>] optional
+      def initialize(messages: [])
+        @messages = messages
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class.name} messages=#{@messages.inspect}>"
+      end
+
+      # Usage:
+      #
+      #   prompt.serialize # => [{ content: "What is the capital of Canada?", role: :user }]
+      #
+      # @param context [Context] optional
+      #
+      # @return [Array<Hash>]
+      def serialize(context: nil)
+        serializer = context&.serializers&.[](:prompt)
+        return serializer.call(self, context:) if serializer
+
+        @messages.map { |message| message.serialize(context:) }
+      end
+
+      # Usage:
+      #
+      #   prompt.message('What is the capital of Canada?')
+      #
+      # @param content [String, nil]
+      # @param role [Symbol]
+      #
+      # @yield [Message]
+      # @return [Message]
+      def message(content = nil, role: :user, &block)
+        raise ArgumentError, 'content or block is required' if content.nil? && block.nil?
+
+        Message.new(content:, role:).tap do |message|
+          block&.call(message)
+          @messages << message
+        end
+      end
+
+      # Usage:
+      #
+      #   prompt.system('You are a helpful assistant.')
+      #
+      #   prompt.system do |message|
+      #     message.text 'You are a helpful assistant.'
+      #   end
+      #
+      # @param content [String, nil]
+      #
+      # @yield [Message]
+      # @return [Message]
+      def system(content = nil, &)
+        message(content, role: Role::SYSTEM, &)
+      end
+
+      # Usage:
+      #
+      #   prompt.user('What is the capital of Canada?')
+      #
+      #   prompt.user do |message|
+      #     message.text 'What is the capital of Canada?'
+      #   end
+      #
+      # @param content [String, nil]
+      #
+      # @yield [Message]
+      # @return [Message]
+      def user(content = nil, &)
+        message(content, role: Role::USER, &)
+      end
+    end
+  end
+end

data/lib/omniai/chat/response/choice.rb

@@ -10,21 +10,16 @@ module OmniAI
           @data['index']
         end
 
-        # @return [OmniAI::Chat::Response::Part]
+        # @return [Part]
         def part
           raise NotImplementedError, "#{self.class.name}#part undefined"
         end
 
-        # @return [OmniAI::Chat::Response::ToolCallList]
+        # @return [ToolCallList]
         def tool_call_list
           part.tool_call_list
         end
 
-        # @return [Boolean]
-        def tool_call_list?
-          tool_call_list.any?
-        end
-
         # @return [String, nil]
         def content
           part.content

data/lib/omniai/chat/response/chunk.rb

@@ -5,7 +5,7 @@ module OmniAI
     module Response
       # A chunk returned by the API.
       class Chunk < Payload
-        # @return [Array<OmniAI::Chat::Response::DeltaChoice>]
+        # @return [Array<DeltaChoice>]
         def choices
           @choices ||= @data['choices'].map { |data| DeltaChoice.new(data:) }
         end

data/lib/omniai/chat/response/completion.rb

@@ -5,7 +5,7 @@ module OmniAI
     module Response
       # A completion returned by the API.
       class Completion < Payload
-        # @return [Array<OmniAI::Chat:Response:::MessageChoice>]
+        # @return [Array<MessageChoice>]
         def choices
           @choices ||= @data['choices'].map { |data| MessageChoice.new(data:) }
         end

data/lib/omniai/chat/response/delta_choice.rb

@@ -10,12 +10,12 @@ module OmniAI
           "#<#{self.class.name} index=#{index} delta=#{delta.inspect}>"
         end
 
-        # @return [OmniAI::Chat::Response::Delta]
+        # @return [Delta]
         def delta
           @delta ||= Delta.new(data: @data['delta'])
         end
 
-        # @return [OmniAI::Chat::Response::Delta]
+        # @return [Delta]
         def part
           delta
         end

data/lib/omniai/chat/response/message_choice.rb

@@ -10,12 +10,12 @@ module OmniAI
           "#<#{self.class.name} index=#{index} message=#{message.inspect}>"
         end
 
-        # @return [OmniAI::Chat::Response::Message]
+        # @return [Message]
         def message
           @message ||= Message.new(data: @data['message'])
         end
 
-        # @return [OmniAI::Chat::Response::Message]
+        # @return [Message]
         def part
           message
         end

data/lib/omniai/chat/response/part.rb

@@ -20,7 +20,7 @@ module OmniAI
           @data['content']
         end
 
-        # @return [Array<OmniAI::Chat::Response::ToolCall>]
+        # @return [Array<ToolCall>]
         def tool_call_list
           return [] unless @data['tool_calls']
 
@@ -28,7 +28,7 @@ module OmniAI
         end
 
         # @param index [Integer]
-        # @return [OmniAI::Chat::Response::ToolCall, nil]
+        # @return [ToolCall, nil]
         def tool_call(index: 0)
           tool_call_list[index]
         end

data/lib/omniai/chat/response/payload.rb

@@ -30,24 +30,24 @@ module OmniAI
           @data['model']
         end
 
-        # @return [Array<OmniAI::Chat::Response::Choice>]
+        # @return [Array<Choice>]
         def choices
           raise NotImplementedError, "#{self.class.name}#choices undefined"
         end
 
         # @param index [Integer]
-        # @return [OmniAI::Chat::Response::DeltaChoice]
+        # @return [DeltaChoice]
         def choice(index: 0)
           choices[index]
         end
 
         # @param index [Integer]
-        # @return [OmniAI::Chat::Response::Part]
+        # @return [Part]
         def part(index: 0)
           choice(index:).part
         end
 
-        # @return [OmniAI::Chat::Response::Usage]
+        # @return [Usage]
         def usage
           @usage ||= Usage.new(data: @data['usage']) if @data['usage']
         end
@@ -62,15 +62,10 @@ module OmniAI
           choice.content?
         end
 
-        # @return [Array<OmniAI::Chat::Response:ToolCall>]
+        # @return [Array<ToolCall>]
         def tool_call_list
           choice.tool_call_list
         end
-
-        # @return [Boolean]
-        def tool_call_list?
-          choice.tool_call_list?
-        end
       end
     end
   end

data/lib/omniai/chat/response/tool_call.rb

@@ -20,7 +20,7 @@ module OmniAI
           @data['type']
         end
 
-        # @return [OmniAI::Chat::Response::Function]
+        # @return [Function]
         def function
           @function ||= Function.new(data: @data['function']) if @data['function']
         end

data/lib/omniai/chat/text.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # Just some text.
+    class Text < Content
+      # @return [String]
+      attr_accessor :text
+
+      # @param text [text]
+      def initialize(text = nil)
+        super()
+        @text = text
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class} text=#{@text.inspect}>"
+      end
+
+      # @param data [Hash]
+      def self.deserialize(data, context: nil)
+        deserialize = context&.deserializers&.[](:text)
+        return deserialize.call(data, context:) if deserialize
+
+        new(data['text'])
+      end
+
+      # @param context [Context] optional
+      #
+      # @return [Hash]
+      def serialize(context: nil)
+        serializer = context&.serializers&.[](:text)
+        return serializer.call(self, context:) if serializer
+
+        { type: 'text', text: @text }
+      end
+    end
+  end
+end

data/lib/omniai/chat/url.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module OmniAI
+  class Chat
+    # A URL that is media that can be sent to many LLMs.
+    class URL < Media
+      # @return [URI, String]
+      attr_accessor :uri
+
+      class FetchError < HTTPError; end
+
+      # @param uri [URI, String] "https://example.com/cat.jpg"
+      # @param type [Symbol, String] "audio/flac", "image/jpeg", "video/mpeg", :audi, :image, :video, etc.
+      def initialize(uri, type = nil)
+        super(type)
+        @uri = uri
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class} uri=#{@uri.inspect}>"
+      end
+
+      # @param data [Hash]
+      def self.deserialize(data, context: nil)
+        deserialize = context&.deserializers&.[](:url)
+        return deserialize.call(data, context:) if deserialize
+
+        type = /(?<type>\w+)_url/.match(data['type'])[:type]
+        uri = data["#{type}_url"]['url']
+
+        new(uri, type)
+      end
+
+      # @param context [Context] optional
+      #
+      # @return [Hash]
+      def serialize(context: nil)
+        serializer = context&.serializers&.[](:url)
+        return serializer.call(self, context:) if serializer
+
+        {
+          type: "#{kind}_url",
+          "#{kind}_url": { url: @uri },
+        }
+      end
+
+      # @raise [FetchError]
+      #
+      # @return [String]
+      def fetch!
+        response = request!
+        String(response.body)
+      end
+
+      protected
+
+      # @raise [FetchError]
+      #
+      # @return [HTTP::Response]
+      def request!
+        response = HTTP.get(@uri)
+        raise FetchError, response.flush unless response.status.success?
+
+        response
+      end
+    end
+  end
+end

data/lib/omniai/chat.rb

@@ -50,15 +50,20 @@ module OmniAI
       new(...).process!
     end
 
-    # @param messages [String] required
+    # @param prompt [OmniAI::Chat::Prompt, String, nil] optional
     # @param client [OmniAI::Client] the client
     # @param model [String] required
     # @param temperature [Float, nil] optional
     # @param stream [Proc, IO, nil] optional
     # @param tools [Array<OmniAI::Tool>] optional
     # @param format [Symbol, nil] optional - :json
-    def initialize(messages, client:, model:, temperature: nil, stream: nil, tools: nil, format: nil)
-      @messages = arrayify(messages)
+    # @yield [prompt] optional
+    def initialize(prompt = nil, client:, model:, temperature: nil, stream: nil, tools: nil, format: nil, &block)
+      raise ArgumentError, 'prompt or block is required' if !prompt && !block
+
+      @prompt = prompt ? Prompt.parse(prompt) : Prompt.new
+      block&.call(@prompt)
+
       @client = client
       @model = model
       @temperature = temperature
@@ -78,6 +83,22 @@ module OmniAI
 
     protected
 
+    # Used to spawn another chat with the same configuration using different messages.
+    #
+    # @param prompt [OmniAI::Chat::Prompt]
+    # @return [OmniAI::Chat::Prompt]
+    def spawn!(prompt)
+      self.class.new(
+        prompt,
+        client: @client,
+        model: @model,
+        temperature: @temperature,
+        stream: @stream,
+        tools: @tools,
+        format: @format
+      ).process!
+    end
+
     # @return [Hash]
     def payload
       raise NotImplementedError, "#{self.class.name}#payload undefined"
@@ -89,7 +110,7 @@ module OmniAI
     end
 
     # @param response [HTTP::Response]
-    # @return [OmniAI::Chat::Completion]
+    # @return [OmniAI::Chat::Response::Completion]
     def parse!(response:)
       if @stream
         stream!(response:)
@@ -103,20 +124,19 @@ module OmniAI
     def complete!(response:)
       completion = self.class::Response::Completion.new(data: response.parse)
 
-      if @tools && completion.tool_call_required?
-        @messages = [
-          *@messages,
+      if @tools && completion.tool_call_list.any?
+        spawn!([
+          *@prompt.serialize,
           *completion.choices.map(&:message).map(&:data),
           *(completion.tool_call_list.map { |tool_call| execute_tool_call(tool_call) }),
-        ]
-        process!
+        ])
       else
         completion
       end
     end
 
     # @param response [HTTP::Response]
-    # @return [OmniAI::Chat::Stream]
+    # @return [OmniAI::Chat::Response::Stream]
     def stream!(response:)
       raise Error, "#{self.class.name}#stream! unstreamable" unless @stream
 
@@ -134,23 +154,6 @@ module OmniAI
       @stream.puts if @stream.is_a?(IO) || @stream.is_a?(StringIO)
     end
 
-    # @return [Array<Hash>]
-    def messages
-      @messages.map do |content|
-        case content
-        when String then { role: Role::USER, content: }
-        when Hash then content
-        else raise Error, "Unsupported content=#{content.inspect}"
-        end
-      end
-    end
-
-    # @param value [Object, Array<Object>]
-    # @return [Array<Object>]
-    def arrayify(value)
-      value.is_a?(Array) ? value : [value]
-    end
-
     # @return [HTTP::Response]
     def request!
       @client

data/lib/omniai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OmniAI
-  VERSION = '1.5.1'
+  VERSION = '1.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omniai
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-12 00:00:00.000000000 Z
+date: 2024-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -68,10 +68,12 @@ files:
 - exe/omniai
 - lib/omniai.rb
 - lib/omniai/chat.rb
-- lib/omniai/chat/content/file.rb
-- lib/omniai/chat/content/media.rb
-- lib/omniai/chat/content/text.rb
-- lib/omniai/chat/content/url.rb
+- lib/omniai/chat/content.rb
+- lib/omniai/chat/context.rb
+- lib/omniai/chat/file.rb
+- lib/omniai/chat/media.rb
+- lib/omniai/chat/message.rb
+- lib/omniai/chat/prompt.rb
 - lib/omniai/chat/response/choice.rb
 - lib/omniai/chat/response/chunk.rb
 - lib/omniai/chat/response/completion.rb
@@ -86,6 +88,8 @@ files:
 - lib/omniai/chat/response/stream.rb
 - lib/omniai/chat/response/tool_call.rb
 - lib/omniai/chat/response/usage.rb
+- lib/omniai/chat/text.rb
+- lib/omniai/chat/url.rb
 - lib/omniai/cli.rb
 - lib/omniai/cli/base_handler.rb
 - lib/omniai/cli/chat_handler.rb

data/lib/omniai/chat/content/file.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  class Chat
-    module Content
-      # A file that is either audio / image / video.
-      class File < Media
-        attr_accessor :io
-
-        # @param io [IO, Pathname, String]
-        # @param type [Symbol, String] :image, :video, :audio, "audio/flac", "image/jpeg", "video/mpeg", etc.
-        def initialize(io, type)
-          super(type)
-          @io = io
-        end
-
-        # @return [String]
-        def fetch!
-          case @io
-          when IO then @io.read
-          else ::File.binread(@io)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/omniai/chat/content/media.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  class Chat
-    module Content
-      # An abstract class that represents audio / image / video and is used for both files and urls.
-      class Media
-        attr_accessor :type
-
-        # @param type [String] "audio/flac", "image/jpeg", "video/mpeg", etc.
-        def initialize(type)
-          @type = type
-        end
-
-        # @return [Boolean]
-        def text?
-          @type.match?(%r{^text/})
-        end
-
-        # @return [Boolean]
-        def audio?
-          @type.match?(%r{^audio/})
-        end
-
-        # @return [Boolean]
-        def image?
-          @type.match?(%r{^image/})
-        end
-
-        # @return [Boolean]
-        def video?
-          @type.match?(%r{^video/})
-        end
-
-        # @yield [io]
-        def fetch!(&)
-          raise NotImplementedError, "#{self.class}#fetch! undefined"
-        end
-
-        # e.g. "Hello" -> "SGVsbG8h"
-        #
-        # @return [String]
-        def data
-          Base64.strict_encode64(fetch!)
-        end
-
-        # e.g. "data:text/html;base64,..."
-        #
-        # @return [String]
-        def data_uri
-          "data:#{@type};base64,#{data}"
-        end
-      end
-    end
-  end
-end

data/lib/omniai/chat/content/text.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  class Chat
-    module Content
-      # Just some text.
-      class Text
-        attr_accessor :text
-
-        # @param text [text]
-        def initialize(text)
-          @text = text
-        end
-      end
-    end
-  end
-end

data/lib/omniai/chat/content/url.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module OmniAI
-  class Chat
-    module Content
-      # A url that is either audio / image / video.
-      class URL < Media
-        attr_accessor :url, :type
-
-        class HTTPError < OmniAI::HTTPError; end
-
-        # @param url [URI, String]
-        # @param type [Symbol, String] "audio/flac", "image/jpeg", "video/mpeg", etc.
-        def initialize(url, type)
-          super(type)
-          @url = url
-        end
-
-        # @raise [HTTPError]
-        #
-        # @return [String]
-        def fetch!
-          response = request!
-          String(response.body)
-        end
-
-        private
-
-        # @raise [HTTPError]
-        #
-        # @return [HTTP::Response]
-        def request!
-          response = HTTP.get(@url)
-          raise HTTPError, response.flush unless response.status.success?
-
-          response
-        end
-      end
-    end
-  end
-end