omniai 1.5.2 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81c34e7c05b90e85fe99ba87f0b462f4322a0dd14c74afdb5f951faccdc698d6
-  data.tar.gz: 551b238e17c909abbe3b08ecf630a2f6aa0047a17413c7966d23ca9ccbf0d26d
+  metadata.gz: fc0ef904482119dedd44057ac782fdf5c0c43a72f4a212c9a10736ba6389bd9d
+  data.tar.gz: 9d8c20309d3652207719f0d95253df5d4bb422658f42d724aa509bec0595721b
 SHA512:
-  metadata.gz: 0c291e2840cd9782046d7011e7becc77b2d9c64da427d6785ed121ae430a4153f7fb3d6f28f4f4c9cb943f18a0b8d7c20e345fc8c6d0097faa83eb205a302132
-  data.tar.gz: d592b529340cacdcf458295a9914589806f6c568469c0c9548cdbd63fa639d64dcb04982dc2f7f68506e2207809a2b1b689b6267dabe262f3847c298785f5ba7
+  metadata.gz: 00462515ed1392ccc2a94dcdc1bc61e18ce316306dbbaf77523938a47e49e33d7f6e17d37ecc921edc82b04f8f7a8de7a122fdd0eeb787cabf95cf8c42092309
+  data.tar.gz: 894271b6a222be666bad5a2502ab4b040ab4e8c7f31c6c3e3dd3226b296a8198a0f3030e31c75de0fea30db8d0b5e27c0601b13d99127ab0121dbbef5b128943

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,12 +10,12 @@ 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

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,7 +62,7 @@ module OmniAI
           choice.content?
         end
 
-        # @return [Array<OmniAI::Chat::Response:ToolCall>]
+        # @return [Array<ToolCall>]
         def tool_call_list
           choice.tool_call_list
         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,24 @@ 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
+    # @yieldparam prompt [OmniAI::Chat::Prompt]
+    #
+    # @return [OmniAi::Chat]
+    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 +87,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 +114,7 @@ module OmniAI
     end
 
     # @param response [HTTP::Response]
-    # @return [OmniAI::Chat::Completion]
+    # @return [OmniAI::Chat::Response::Completion]
     def parse!(response:)
       if @stream
         stream!(response:)
@@ -104,19 +129,18 @@ module OmniAI
       completion = self.class::Response::Completion.new(data: response.parse)
 
       if @tools && completion.tool_call_list.any?
-        @messages = [
-          *@messages,
+        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 +158,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/client.rb

@@ -131,8 +131,11 @@ module OmniAI
     # @param stream [Proc, nil] optional
     # @param tools [Array<OmniAI::Tool>] optional
     #
+    # @yield [prompt] optional
+    # @yieldparam prompt [OmniAI::Chat::Prompt]
+    #
     # @return [OmniAI::Chat::Completion]
-    def chat(messages, model:, temperature: nil, format: nil, stream: nil, tools: nil)
+    def chat(messages, model:, temperature: nil, format: nil, stream: nil, tools: nil, &)
       raise NotImplementedError, "#{self.class.name}#chat undefined"
     end
 

data/lib/omniai/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omniai
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.1
 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